Commit 74b6eb6b authored by Ingo Molnar's avatar Ingo Molnar
Browse files

Merge branches 'x86/asm', 'x86/cleanups', 'x86/cpudetect', 'x86/debug',... 

Merge branches 'x86/asm', 'x86/cleanups', 'x86/cpudetect', 'x86/debug', 'x86/doc', 'x86/header-fixes', 'x86/mm', 'x86/paravirt', 'x86/pat', 'x86/setup-v2', 'x86/subarch', 'x86/uaccess' and 'x86/urgent' into x86/core
parents 6a385db5 2d4d57db 8f6d86dc b38b0665 d5e397cb e56d0cfe dbca1df4 fb746d0e 6522869c d639bab8 042cbaf8 5662a2f8 3b4b7570 30a0fb94

Documentation/x86/boot.txt

+7 −6
Original line number Diff line number Diff line
@@ -158,7 +158,7 @@ Offset Proto Name Meaning 
0202/4	2.00+	header		Magic signature "HdrS"

0206/2	2.00+	version		Boot protocol version supported

0208/4	2.00+	realmode_swtch	Boot loader hook (see below)

020C/2	2.00+	start_sys	The load-low segment (0x1000) (obsolete)

020C/2	2.00+	start_sys_seg	The load-low segment (0x1000) (obsolete)

020E/2	2.00+	kernel_version	Pointer to kernel version string

0210/1	2.00+	type_of_loader	Boot loader identifier

0211/1	2.00+	loadflags	Boot protocol option flags
@@ -170,10 +170,11 @@ Offset Proto Name Meaning 
0224/2	2.01+	heap_end_ptr	Free memory after setup end

0226/2	N/A	pad1		Unused

0228/4	2.02+	cmd_line_ptr	32-bit pointer to the kernel command line

022C/4	2.03+	initrd_addr_max	Highest legal initrd address

022C/4	2.03+	ramdisk_max	Highest legal initrd address

0230/4	2.05+	kernel_alignment Physical addr alignment required for kernel

0234/1	2.05+	relocatable_kernel Whether kernel is relocatable or not

0235/3	N/A	pad2		Unused

0235/1	N/A	pad2		Unused

0236/2	N/A	pad3		Unused

0238/4	2.06+	cmdline_size	Maximum size of the kernel command line

023C/4	2.07+	hardware_subarch Hardware subarchitecture

0240/8	2.07+	hardware_subarch_data Subarchitecture-specific data
@@ -299,14 +300,14 @@ Protocol: 2.00+ 
  e.g. 0x0204 for version 2.04, and 0x0a11 for a hypothetical version

  10.17.



Field name:	readmode_swtch

Field name:	realmode_swtch

Type:		modify (optional)

Offset/size:	0x208/4

Protocol:	2.00+



  Boot loader hook (see ADVANCED BOOT LOADER HOOKS below.)



Field name:	start_sys

Field name:	start_sys_seg

Type:		read

Offset/size:	0x20c/2

Protocol:	2.00+
@@ -468,7 +469,7 @@ Protocol: 2.02+ 
  zero, the kernel will assume that your boot loader does not support

  the 2.02+ protocol.



Field name:	initrd_addr_max

Field name:	ramdisk_max

Type:		read

Offset/size:	0x22c/4

Protocol:	2.03+

arch/x86/boot/video-vesa.c

+5 −6
Original line number Diff line number Diff line
@@ -269,9 +269,8 @@ void vesa_store_edid(void) 
	   we genuinely have to assume all registers are destroyed here. */



	asm("pushw %%es; movw %2,%%es; "INT10"; popw %%es"

	    : "+a" (ax), "+b" (bx)

	    :  "c" (cx), "D" (di)

	    : "esi");

	    : "+a" (ax), "+b" (bx), "+c" (cx), "+D" (di)

	    : : "esi", "edx");



	if (ax != 0x004f)

		return;		/* No EDID */
@@ -285,9 +284,9 @@ void vesa_store_edid(void) 
	dx = 0;			/* EDID block number */

	di =(size_t) &boot_params.edid_info; /* (ES:)Pointer to block */

	asm(INT10

	    : "+a" (ax), "+b" (bx), "+d" (dx), "=m" (boot_params.edid_info)

	    : "c" (cx), "D" (di)

	    : "esi");

	    : "+a" (ax), "+b" (bx), "+d" (dx), "=m" (boot_params.edid_info),

	      "+c" (cx), "+D" (di)

	    : : "esi");

#endif /* CONFIG_FIRMWARE_EDID */

}

arch/x86/ia32/ia32_signal.c

+195 −170
Original line number Diff line number Diff line
@@ -46,78 +46,83 @@ void signal_fault(struct pt_regs *regs, void __user *frame, char *where); 


int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)

{

	int err;

	int err = 0;



	if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))

		return -EFAULT;



	put_user_try {

		/* If you change siginfo_t structure, please make sure that

		   this code is fixed accordingly.

		   It should never copy any pad contained in the structure

		   to avoid security leaks, but must copy the generic

		   3 ints plus the relevant union member.  */

	err = __put_user(from->si_signo, &to->si_signo);

	err |= __put_user(from->si_errno, &to->si_errno);

	err |= __put_user((short)from->si_code, &to->si_code);

		put_user_ex(from->si_signo, &to->si_signo);

		put_user_ex(from->si_errno, &to->si_errno);

		put_user_ex((short)from->si_code, &to->si_code);



		if (from->si_code < 0) {

		err |= __put_user(from->si_pid, &to->si_pid);

		err |= __put_user(from->si_uid, &to->si_uid);

		err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);

			put_user_ex(from->si_pid, &to->si_pid);

			put_user_ex(from->si_uid, &to->si_uid);

			put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);

		} else {

			/*

			 * First 32bits of unions are always present:

			 * si_pid === si_band === si_tid === si_addr(LS half)

			 */

		err |= __put_user(from->_sifields._pad[0],

			put_user_ex(from->_sifields._pad[0],

					  &to->_sifields._pad[0]);

			switch (from->si_code >> 16) {

			case __SI_FAULT >> 16:

				break;

			case __SI_CHLD >> 16:

			err |= __put_user(from->si_utime, &to->si_utime);

			err |= __put_user(from->si_stime, &to->si_stime);

			err |= __put_user(from->si_status, &to->si_status);

				put_user_ex(from->si_utime, &to->si_utime);

				put_user_ex(from->si_stime, &to->si_stime);

				put_user_ex(from->si_status, &to->si_status);

				/* FALL THROUGH */

			default:

			case __SI_KILL >> 16:

			err |= __put_user(from->si_uid, &to->si_uid);

				put_user_ex(from->si_uid, &to->si_uid);

				break;

			case __SI_POLL >> 16:

			err |= __put_user(from->si_fd, &to->si_fd);

				put_user_ex(from->si_fd, &to->si_fd);

				break;

			case __SI_TIMER >> 16:

			err |= __put_user(from->si_overrun, &to->si_overrun);

			err |= __put_user(ptr_to_compat(from->si_ptr),

				put_user_ex(from->si_overrun, &to->si_overrun);

				put_user_ex(ptr_to_compat(from->si_ptr),

					    &to->si_ptr);

				break;

				 /* This is not generated by the kernel as of now.  */

			case __SI_RT >> 16:

			case __SI_MESGQ >> 16:

			err |= __put_user(from->si_uid, &to->si_uid);

			err |= __put_user(from->si_int, &to->si_int);

				put_user_ex(from->si_uid, &to->si_uid);

				put_user_ex(from->si_int, &to->si_int);

				break;

			}

		}

	} put_user_catch(err);



	return err;

}



int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)

{

	int err;

	int err = 0;

	u32 ptr32;



	if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))

		return -EFAULT;



	err = __get_user(to->si_signo, &from->si_signo);

	err |= __get_user(to->si_errno, &from->si_errno);

	err |= __get_user(to->si_code, &from->si_code);

	get_user_try {

		get_user_ex(to->si_signo, &from->si_signo);

		get_user_ex(to->si_errno, &from->si_errno);

		get_user_ex(to->si_code, &from->si_code);



	err |= __get_user(to->si_pid, &from->si_pid);

	err |= __get_user(to->si_uid, &from->si_uid);

	err |= __get_user(ptr32, &from->si_ptr);

		get_user_ex(to->si_pid, &from->si_pid);

		get_user_ex(to->si_uid, &from->si_uid);

		get_user_ex(ptr32, &from->si_ptr);

		to->si_ptr = compat_ptr(ptr32);

	} get_user_catch(err);



	return err;

}
@@ -142,17 +147,23 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
				  struct pt_regs *regs)

{

	stack_t uss, uoss;

	int ret;

	int ret, err = 0;

	mm_segment_t seg;



	if (uss_ptr) {

		u32 ptr;



		memset(&uss, 0, sizeof(stack_t));

		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||

			    __get_user(ptr, &uss_ptr->ss_sp) ||

			    __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||

			    __get_user(uss.ss_size, &uss_ptr->ss_size))

		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)))

			return -EFAULT;



		get_user_try {

			get_user_ex(ptr, &uss_ptr->ss_sp);

			get_user_ex(uss.ss_flags, &uss_ptr->ss_flags);

			get_user_ex(uss.ss_size, &uss_ptr->ss_size);

		} get_user_catch(err);



		if (err)

			return -EFAULT;

		uss.ss_sp = compat_ptr(ptr);

	}
@@ -161,10 +172,16 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);

	set_fs(seg);

	if (ret >= 0 && uoss_ptr)  {

		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||

		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||

		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||

		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))

		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)))

			return -EFAULT;



		put_user_try {

			put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);

			put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);

			put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);

		} put_user_catch(err);



		if (err)

			ret = -EFAULT;

	}

	return ret;
@@ -174,18 +191,18 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
 * Do a signal return; undo the signal stack.

 */

#define COPY(x)			{		\

	err |= __get_user(regs->x, &sc->x);	\

	get_user_ex(regs->x, &sc->x);		\

}



#define COPY_SEG_CPL3(seg)	{			\

		unsigned short tmp;			\

		err |= __get_user(tmp, &sc->seg);	\

		get_user_ex(tmp, &sc->seg);		\

		regs->seg = tmp | 3;			\

}



#define RELOAD_SEG(seg)		{		\

	unsigned int cur, pre;			\

	err |= __get_user(pre, &sc->seg);	\

	get_user_ex(pre, &sc->seg);		\

	savesegment(seg, cur);			\

	pre |= 3;				\

	if (pre != cur)				\
@@ -209,13 +226,14 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
	       sc, sc->err, sc->ip, sc->cs, sc->flags);

#endif



	get_user_try {

		/*

		 * Reload fs and gs if they have changed in the signal

		 * handler.  This does not handle long fs/gs base changes in

		 * the handler, but does not clobber them at least in the

		 * normal case.

		 */

	err |= __get_user(gs, &sc->gs);

		get_user_ex(gs, &sc->gs);

		gs |= 3;

		savesegment(gs, oldgs);

		if (gs != oldgs)
@@ -232,16 +250,18 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
		COPY_SEG_CPL3(cs);

		COPY_SEG_CPL3(ss);



	err |= __get_user(tmpflags, &sc->flags);

		get_user_ex(tmpflags, &sc->flags);

		regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);

		/* disable syscall checks */

		regs->orig_ax = -1;



	err |= __get_user(tmp, &sc->fpstate);

		get_user_ex(tmp, &sc->fpstate);

		buf = compat_ptr(tmp);

		err |= restore_i387_xstate_ia32(buf);



	err |= __get_user(*pax, &sc->ax);

		get_user_ex(*pax, &sc->ax);

	} get_user_catch(err);



	return err;

}
@@ -319,36 +339,38 @@ static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, 
{

	int tmp, err = 0;



	put_user_try {

		savesegment(gs, tmp);

	err |= __put_user(tmp, (unsigned int __user *)&sc->gs);

		put_user_ex(tmp, (unsigned int __user *)&sc->gs);

		savesegment(fs, tmp);

	err |= __put_user(tmp, (unsigned int __user *)&sc->fs);

		put_user_ex(tmp, (unsigned int __user *)&sc->fs);

		savesegment(ds, tmp);

	err |= __put_user(tmp, (unsigned int __user *)&sc->ds);

		put_user_ex(tmp, (unsigned int __user *)&sc->ds);

		savesegment(es, tmp);

	err |= __put_user(tmp, (unsigned int __user *)&sc->es);



	err |= __put_user(regs->di, &sc->di);

	err |= __put_user(regs->si, &sc->si);

	err |= __put_user(regs->bp, &sc->bp);

	err |= __put_user(regs->sp, &sc->sp);

	err |= __put_user(regs->bx, &sc->bx);

	err |= __put_user(regs->dx, &sc->dx);

	err |= __put_user(regs->cx, &sc->cx);

	err |= __put_user(regs->ax, &sc->ax);

	err |= __put_user(current->thread.trap_no, &sc->trapno);

	err |= __put_user(current->thread.error_code, &sc->err);

	err |= __put_user(regs->ip, &sc->ip);

	err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs);

	err |= __put_user(regs->flags, &sc->flags);

	err |= __put_user(regs->sp, &sc->sp_at_signal);

	err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss);



	err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);

		put_user_ex(tmp, (unsigned int __user *)&sc->es);



		put_user_ex(regs->di, &sc->di);

		put_user_ex(regs->si, &sc->si);

		put_user_ex(regs->bp, &sc->bp);

		put_user_ex(regs->sp, &sc->sp);

		put_user_ex(regs->bx, &sc->bx);

		put_user_ex(regs->dx, &sc->dx);

		put_user_ex(regs->cx, &sc->cx);

		put_user_ex(regs->ax, &sc->ax);

		put_user_ex(current->thread.trap_no, &sc->trapno);

		put_user_ex(current->thread.error_code, &sc->err);

		put_user_ex(regs->ip, &sc->ip);

		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);

		put_user_ex(regs->flags, &sc->flags);

		put_user_ex(regs->sp, &sc->sp_at_signal);

		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);



		put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);



		/* non-iBCS2 extensions.. */

	err |= __put_user(mask, &sc->oldmask);

	err |= __put_user(current->thread.cr2, &sc->cr2);

		put_user_ex(mask, &sc->oldmask);

		put_user_ex(current->thread.cr2, &sc->cr2);

	} put_user_catch(err);



	return err;

}
@@ -437,13 +459,17 @@ int ia32_setup_frame(int sig, struct k_sigaction *ka, 
		else

			restorer = &frame->retcode;

	}

	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);



	put_user_try {

		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);



		/*

		 * These are actually not used anymore, but left because some

		 * gdb versions depend on them as a marker.

		 */

	err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);

		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);

	} put_user_catch(err);



	if (err)

		return -EFAULT;
@@ -496,41 +522,40 @@ int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 
	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))

		return -EFAULT;



	err |= __put_user(sig, &frame->sig);

	err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);

	err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);

	put_user_try {

		put_user_ex(sig, &frame->sig);

		put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);

		put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);

		err |= copy_siginfo_to_user32(&frame->info, info);

	if (err)

		return -EFAULT;



		/* Create the ucontext.  */

		if (cpu_has_xsave)

		err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);

			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);

		else

		err |= __put_user(0, &frame->uc.uc_flags);

	err |= __put_user(0, &frame->uc.uc_link);

	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);

	err |= __put_user(sas_ss_flags(regs->sp),

			put_user_ex(0, &frame->uc.uc_flags);

		put_user_ex(0, &frame->uc.uc_link);

		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);

		put_user_ex(sas_ss_flags(regs->sp),

			    &frame->uc.uc_stack.ss_flags);

	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);

		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);

		err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,

					     regs, set->sig[0]);

		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	if (err)

		return -EFAULT;



		if (ka->sa.sa_flags & SA_RESTORER)

			restorer = ka->sa.sa_restorer;

		else

			restorer = VDSO32_SYMBOL(current->mm->context.vdso,

						 rt_sigreturn);

	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);

		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);



		/*

		 * Not actually used anymore, but left because some gdb

		 * versions need it.

		 */

	err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);

		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);

	} put_user_catch(err);



	if (err)

		return -EFAULT;

arch/x86/include/asm/io.h

+1 −1
Original line number Diff line number Diff line
@@ -91,7 +91,7 @@ extern void unxlate_dev_mem_ptr(unsigned long phys, void *addr); 


extern int ioremap_change_attr(unsigned long vaddr, unsigned long size,

				unsigned long prot_val);

extern void __iomem *ioremap_wc(unsigned long offset, unsigned long size);

extern void __iomem *ioremap_wc(resource_size_t offset, unsigned long size);



/*

 * early_ioremap() and early_iounmap() are for temporary early boot-time

arch/x86/include/asm/mach-rdc321x/gpio.h

deleted100644 → 0
+0 −60
Original line number Diff line number Diff line 
#ifndef _ASM_X86_MACH_RDC321X_GPIO_H

#define _ASM_X86_MACH_RDC321X_GPIO_H



#include <linux/kernel.h>



extern int rdc_gpio_get_value(unsigned gpio);

extern void rdc_gpio_set_value(unsigned gpio, int value);

extern int rdc_gpio_direction_input(unsigned gpio);

extern int rdc_gpio_direction_output(unsigned gpio, int value);

extern int rdc_gpio_request(unsigned gpio, const char *label);

extern void rdc_gpio_free(unsigned gpio);

extern void __init rdc321x_gpio_setup(void);



/* Wrappers for the arch-neutral GPIO API */



static inline int gpio_request(unsigned gpio, const char *label)

{

	return rdc_gpio_request(gpio, label);

}



static inline void gpio_free(unsigned gpio)

{

	might_sleep();

	rdc_gpio_free(gpio);

}



static inline int gpio_direction_input(unsigned gpio)

{

	return rdc_gpio_direction_input(gpio);

}



static inline int gpio_direction_output(unsigned gpio, int value)

{

	return rdc_gpio_direction_output(gpio, value);

}



static inline int gpio_get_value(unsigned gpio)

{

	return rdc_gpio_get_value(gpio);

}



static inline void gpio_set_value(unsigned gpio, int value)

{

	rdc_gpio_set_value(gpio, value);

}



static inline int gpio_to_irq(unsigned gpio)

{

	return gpio;

}



static inline int irq_to_gpio(unsigned irq)

{

	return irq;

}



/* For cansleep */

#include <asm-generic/gpio.h>



#endif /* _ASM_X86_MACH_RDC321X_GPIO_H */