Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9fb71c2f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull x86 fixes from Thomas Gleixner:
 "A set of fixes and updates for x86:

   - Address a swiotlb regression which was caused by the recent DMA
     rework and made driver fail because dma_direct_supported() returned
     false

   - Fix a signedness bug in the APIC ID validation which caused invalid
     APIC IDs to be detected as valid thereby bloating the CPU possible
     space.

   - Fix inconsisten config dependcy/select magic for the MFD_CS5535
     driver.

   - Fix a corruption of the physical address space bits when encryption
     has reduced the address space and late cpuinfo updates overwrite
     the reduced bit information with the original value.

   - Dominiks syscall rework which consolidates the architecture
     specific syscall functions so all syscalls can be wrapped with the
     same macros. This allows to switch x86/64 to struct pt_regs based
     syscalls. Extend the clearing of user space controlled registers in
     the entry patch to the lower registers"

* 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86/apic: Fix signedness bug in APIC ID validity checks
  x86/cpu: Prevent cpuinfo_x86::x86_phys_bits adjustment corruption
  x86/olpc: Fix inconsistent MFD_CS5535 configuration
  swiotlb: Use dma_direct_supported() for swiotlb_ops
  syscalls/x86: Adapt syscall_wrapper.h to the new syscall stub naming convention
  syscalls/core, syscalls/x86: Rename struct pt_regs-based sys_*() to __x64_sys_*()
  syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
  syscalls/core, syscalls/x86: Clean up syscall stub naming convention
  syscalls/x86: Extend register clearing on syscall entry to lower registers
  syscalls/x86: Unconditionally enable 'struct pt_regs' based syscalls on x86_64
  syscalls/x86: Use 'struct pt_regs' based syscall calling for IA32_EMULATION and x32
  syscalls/core: Prepare CONFIG_ARCH_HAS_SYSCALL_WRAPPER=y for compat syscalls
  syscalls/x86: Use 'struct pt_regs' based syscall calling convention for 64-bit syscalls
  syscalls/core: Introduce CONFIG_ARCH_HAS_SYSCALL_WRAPPER=y
  x86/syscalls: Don't pointlessly reload the system call number
  x86/mm: Fix documentation of module mapping range with 4-level paging
  x86/cpuid: Switch to 'static const' specifier
parents 6b0a02e8 ef389b73

Documentation/process/adding-syscalls.rst

+2 −2
Original line number Diff line number Diff line
@@ -360,7 +360,7 @@ First, the entry in ``arch/x86/entry/syscalls/syscall_32.tbl`` gets an extra 
column to indicate that a 32-bit userspace program running on a 64-bit kernel

should hit the compat entry point::



    380   i386     xyzzy     sys_xyzzy    compat_sys_xyzzy

    380   i386     xyzzy     sys_xyzzy    __ia32_compat_sys_xyzzy



Second, you need to figure out what should happen for the x32 ABI version of

the new system call.  There's a choice here: the layout of the arguments
@@ -373,7 +373,7 @@ the compatibility wrapper:: 


    333   64       xyzzy     sys_xyzzy

    ...

    555   x32      xyzzy     compat_sys_xyzzy

    555   x32      xyzzy     __x32_compat_sys_xyzzy



If no pointers are involved, then it is preferable to re-use the 64-bit system

call for the x32 ABI (and consequently the entry in

Documentation/x86/x86_64/mm.txt

+1 −1
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ ffffff0000000000 - ffffff7fffffffff (=39 bits) %esp fixup stacks 
ffffffef00000000 - fffffffeffffffff (=64 GB) EFI region mapping space

... unused hole ...

ffffffff80000000 - ffffffff9fffffff (=512 MB)  kernel text mapping, from phys 0

ffffffffa0000000 - [fixmap start]   (~1526 MB) module mapping space (variable)

ffffffffa0000000 - fffffffffeffffff (1520 MB) module mapping space

[fixmap start]   - ffffffffff5fffff kernel-internal fixmap range

ffffffffff600000 - ffffffffff600fff (=4 kB) legacy vsyscall ABI

ffffffffffe00000 - ffffffffffffffff (=2 MB) unused hole

arch/x86/Kconfig

+2 −3
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ config X86_64 
	select HAVE_ARCH_SOFT_DIRTY

	select MODULES_USE_ELF_RELA

	select X86_DEV_DMA_OPS

	select ARCH_HAS_SYSCALL_WRAPPER



#

# Arch settings
@@ -2763,11 +2764,9 @@ config OLPC_XO1_RTC 


config OLPC_XO1_SCI

	bool "OLPC XO-1 SCI extras"

	depends on OLPC && OLPC_XO1_PM

	depends on OLPC && OLPC_XO1_PM && GPIO_CS5535=y

	depends on INPUT=y

	select POWER_SUPPLY

	select GPIO_CS5535

	select MFD_CORE

	---help---

	  Add support for SCI-based features of the OLPC XO-1 laptop:

	   - EC-driven system wakeups

arch/x86/entry/calling.h

+2 −0
Original line number Diff line number Diff line
@@ -114,7 +114,9 @@ For 32-bit we have the following conventions - kernel is built with 
	pushq   %rsi		/* pt_regs->si */

	.endif

	pushq	\rdx		/* pt_regs->dx */

	xorl	%edx, %edx	/* nospec   dx */

	pushq   %rcx		/* pt_regs->cx */

	xorl	%ecx, %ecx	/* nospec   cx */

	pushq   \rax		/* pt_regs->ax */

	pushq   %r8		/* pt_regs->r8 */

	xorl	%r8d, %r8d	/* nospec   r8 */

arch/x86/entry/common.c

+11 −9
Original line number Diff line number Diff line
@@ -266,14 +266,13 @@ __visible inline void syscall_return_slowpath(struct pt_regs *regs) 
}



#ifdef CONFIG_X86_64

__visible void do_syscall_64(struct pt_regs *regs)

__visible void do_syscall_64(unsigned long nr, struct pt_regs *regs)

{

	struct thread_info *ti = current_thread_info();

	unsigned long nr = regs->orig_ax;

	struct thread_info *ti;



	enter_from_user_mode();

	local_irq_enable();



	ti = current_thread_info();

	if (READ_ONCE(ti->flags) & _TIF_WORK_SYSCALL_ENTRY)

		nr = syscall_trace_enter(regs);
@@ -282,11 +281,10 @@ __visible void do_syscall_64(struct pt_regs *regs) 
	 * table.  The only functional difference is the x32 bit in

	 * regs->orig_ax, which changes the behavior of some syscalls.

	 */

	if (likely((nr & __SYSCALL_MASK) < NR_syscalls)) {

		nr = array_index_nospec(nr & __SYSCALL_MASK, NR_syscalls);

		regs->ax = sys_call_table[nr](

			regs->di, regs->si, regs->dx,

			regs->r10, regs->r8, regs->r9);

	nr &= __SYSCALL_MASK;

	if (likely(nr < NR_syscalls)) {

		nr = array_index_nospec(nr, NR_syscalls);

		regs->ax = sys_call_table[nr](regs);

	}



	syscall_return_slowpath(regs);
@@ -321,6 +319,9 @@ static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs) 


	if (likely(nr < IA32_NR_syscalls)) {

		nr = array_index_nospec(nr, IA32_NR_syscalls);

#ifdef CONFIG_IA32_EMULATION

		regs->ax = ia32_sys_call_table[nr](regs);

#else

		/*

		 * It's possible that a 32-bit syscall implementation

		 * takes a 64-bit parameter but nonetheless assumes that
@@ -331,6 +332,7 @@ static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs) 
			(unsigned int)regs->bx, (unsigned int)regs->cx,

			(unsigned int)regs->dx, (unsigned int)regs->si,

			(unsigned int)regs->di, (unsigned int)regs->bp);

#endif /* CONFIG_IA32_EMULATION */

	}



	syscall_return_slowpath(regs);