commit: 69a7525da9273507079df4501f998d2a743fb1b2 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Tue Nov 1 03:14:02 2016 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Tue Nov 1 03:14:02 2016 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=69a7525d
Linux patch 4.4.30 0000_README | 4 + 1029_linux-4.4.30.patch | 434 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 438 insertions(+) diff --git a/0000_README b/0000_README index de6d5fd..3d770fc 100644 --- a/0000_README +++ b/0000_README @@ -159,6 +159,10 @@ Patch: 1028_linux-4.4.29.patch From: http://www.kernel.org Desc: Linux 4.4.29 +Patch: 1029_linux-4.4.30.patch +From: http://www.kernel.org +Desc: Linux 4.4.30 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1029_linux-4.4.30.patch b/1029_linux-4.4.30.patch new file mode 100644 index 0000000..e19a680 --- /dev/null +++ b/1029_linux-4.4.30.patch @@ -0,0 +1,434 @@ +diff --git a/Documentation/x86/exception-tables.txt b/Documentation/x86/exception-tables.txt +index e396bcd8d830..32901aa36f0a 100644 +--- a/Documentation/x86/exception-tables.txt ++++ b/Documentation/x86/exception-tables.txt +@@ -290,38 +290,3 @@ Due to the way that the exception table is built and needs to be ordered, + only use exceptions for code in the .text section. Any other section + will cause the exception table to not be sorted correctly, and the + exceptions will fail. +- +-Things changed when 64-bit support was added to x86 Linux. Rather than +-double the size of the exception table by expanding the two entries +-from 32-bits to 64 bits, a clever trick was used to store addresses +-as relative offsets from the table itself. The assembly code changed +-from: +- .long 1b,3b +-to: +- .long (from) - . +- .long (to) - . +- +-and the C-code that uses these values converts back to absolute addresses +-like this: +- +- ex_insn_addr(const struct exception_table_entry *x) +- { +- return (unsigned long)&x->insn + x->insn; +- } +- +-In v4.6 the exception table entry was expanded with a new field "handler". +-This is also 32-bits wide and contains a third relative function +-pointer which points to one of: +- +-1) int ex_handler_default(const struct exception_table_entry *fixup) +- This is legacy case that just jumps to the fixup code +-2) int ex_handler_fault(const struct exception_table_entry *fixup) +- This case provides the fault number of the trap that occurred at +- entry->insn. It is used to distinguish page faults from machine +- check. +-3) int ex_handler_ext(const struct exception_table_entry *fixup) +- This case is used for uaccess_err ... we need to set a flag +- in the task structure. Before the handler functions existed this +- case was handled by adding a large offset to the fixup to tag +- it as special. +-More functions can easily be added. +diff --git a/Makefile b/Makefile +index 19d7d9f68e35..98239d56924c 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 4 +-SUBLEVEL = 29 ++SUBLEVEL = 30 + EXTRAVERSION = + NAME = Blurry Fish Butt + +diff --git a/arch/x86/include/asm/asm.h b/arch/x86/include/asm/asm.h +index f5063b6659eb..189679aba703 100644 +--- a/arch/x86/include/asm/asm.h ++++ b/arch/x86/include/asm/asm.h +@@ -44,22 +44,19 @@ + + /* Exception table entry */ + #ifdef __ASSEMBLY__ +-# define _ASM_EXTABLE_HANDLE(from, to, handler) \ ++# define _ASM_EXTABLE(from,to) \ + .pushsection "__ex_table","a" ; \ +- .balign 4 ; \ ++ .balign 8 ; \ + .long (from) - . ; \ + .long (to) - . ; \ +- .long (handler) - . ; \ + .popsection + +-# define _ASM_EXTABLE(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_default) +- +-# define _ASM_EXTABLE_FAULT(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_fault) +- +-# define _ASM_EXTABLE_EX(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_ext) ++# define _ASM_EXTABLE_EX(from,to) \ ++ .pushsection "__ex_table","a" ; \ ++ .balign 8 ; \ ++ .long (from) - . ; \ ++ .long (to) - . + 0x7ffffff0 ; \ ++ .popsection + + # define _ASM_NOKPROBE(entry) \ + .pushsection "_kprobe_blacklist","aw" ; \ +@@ -92,24 +89,19 @@ + .endm + + #else +-# define _EXPAND_EXTABLE_HANDLE(x) #x +-# define _ASM_EXTABLE_HANDLE(from, to, handler) \ ++# define _ASM_EXTABLE(from,to) \ + " .pushsection \"__ex_table\",\"a\"\n" \ +- " .balign 4\n" \ ++ " .balign 8\n" \ + " .long (" #from ") - .\n" \ + " .long (" #to ") - .\n" \ +- " .long (" _EXPAND_EXTABLE_HANDLE(handler) ") - .\n" \ + " .popsection\n" + +-# define _ASM_EXTABLE(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_default) +- +-# define _ASM_EXTABLE_FAULT(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_fault) +- +-# define _ASM_EXTABLE_EX(from, to) \ +- _ASM_EXTABLE_HANDLE(from, to, ex_handler_ext) +- ++# define _ASM_EXTABLE_EX(from,to) \ ++ " .pushsection \"__ex_table\",\"a\"\n" \ ++ " .balign 8\n" \ ++ " .long (" #from ") - .\n" \ ++ " .long (" #to ") - . + 0x7ffffff0\n" \ ++ " .popsection\n" + /* For C file, we already have NOKPROBE_SYMBOL macro */ + #endif + +diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h +index 3794c7331cfc..09b1b0ab94b7 100644 +--- a/arch/x86/include/asm/uaccess.h ++++ b/arch/x86/include/asm/uaccess.h +@@ -90,11 +90,12 @@ static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, un + likely(!__range_not_ok(addr, size, user_addr_max())) + + /* +- * The exception table consists of triples of addresses relative to the +- * exception table entry itself. The first address is of an instruction +- * that is allowed to fault, the second is the target at which the program +- * should continue. The third is a handler function to deal with the fault +- * caused by the instruction in the first field. ++ * The exception table consists of pairs of addresses relative to the ++ * exception table enty itself: the first is the address of an ++ * instruction that is allowed to fault, and the second is the address ++ * at which the program should continue. No registers are modified, ++ * so it is entirely up to the continuation code to figure out what to ++ * do. + * + * All the routines below use bits of fixup code that are out of line + * with the main instruction path. This means when everything is well, +@@ -103,14 +104,13 @@ static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, un + */ + + struct exception_table_entry { +- int insn, fixup, handler; ++ int insn, fixup; + }; + /* This is not the generic standard exception_table_entry format */ + #define ARCH_HAS_SORT_EXTABLE + #define ARCH_HAS_SEARCH_EXTABLE + +-extern int fixup_exception(struct pt_regs *regs, int trapnr); +-extern bool ex_has_fault_handler(unsigned long ip); ++extern int fixup_exception(struct pt_regs *regs); + extern int early_fixup_exception(unsigned long *ip); + + /* +@@ -394,11 +394,7 @@ do { \ + #define __get_user_asm_ex(x, addr, itype, rtype, ltype) \ + asm volatile("1: mov"itype" %1,%"rtype"0\n" \ + "2:\n" \ +- ".section .fixup,\"ax\"\n" \ +- "3:xor"itype" %"rtype"0,%"rtype"0\n" \ +- " jmp 2b\n" \ +- ".previous\n" \ +- _ASM_EXTABLE_EX(1b, 3b) \ ++ _ASM_EXTABLE_EX(1b, 2b) \ + : ltype(x) : "m" (__m(addr))) + + #define __put_user_nocheck(x, ptr, size) \ +diff --git a/arch/x86/kernel/kprobes/core.c b/arch/x86/kernel/kprobes/core.c +index e1d1f6cbaf11..023c442c33bb 100644 +--- a/arch/x86/kernel/kprobes/core.c ++++ b/arch/x86/kernel/kprobes/core.c +@@ -1000,7 +1000,7 @@ int kprobe_fault_handler(struct pt_regs *regs, int trapnr) + * In case the user-specified fault handler returned + * zero, try to fix up. + */ +- if (fixup_exception(regs, trapnr)) ++ if (fixup_exception(regs)) + return 1; + + /* +diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c +index 5621f882645e..679302c312f8 100644 +--- a/arch/x86/kernel/traps.c ++++ b/arch/x86/kernel/traps.c +@@ -199,7 +199,7 @@ do_trap_no_signal(struct task_struct *tsk, int trapnr, char *str, + } + + if (!user_mode(regs)) { +- if (!fixup_exception(regs, trapnr)) { ++ if (!fixup_exception(regs)) { + tsk->thread.error_code = error_code; + tsk->thread.trap_nr = trapnr; + die(str, regs, error_code); +@@ -453,7 +453,7 @@ do_general_protection(struct pt_regs *regs, long error_code) + + tsk = current; + if (!user_mode(regs)) { +- if (fixup_exception(regs, X86_TRAP_GP)) ++ if (fixup_exception(regs)) + return; + + tsk->thread.error_code = error_code; +@@ -699,7 +699,7 @@ static void math_error(struct pt_regs *regs, int error_code, int trapnr) + conditional_sti(regs); + + if (!user_mode(regs)) { +- if (!fixup_exception(regs, trapnr)) { ++ if (!fixup_exception(regs)) { + task->thread.error_code = error_code; + task->thread.trap_nr = trapnr; + die(str, regs, error_code); +diff --git a/arch/x86/mm/extable.c b/arch/x86/mm/extable.c +index 9dd7e4b7fcde..903ec1e9c326 100644 +--- a/arch/x86/mm/extable.c ++++ b/arch/x86/mm/extable.c +@@ -3,9 +3,6 @@ + #include <linux/sort.h> + #include <asm/uaccess.h> + +-typedef bool (*ex_handler_t)(const struct exception_table_entry *, +- struct pt_regs *, int); +- + static inline unsigned long + ex_insn_addr(const struct exception_table_entry *x) + { +@@ -16,56 +13,11 @@ ex_fixup_addr(const struct exception_table_entry *x) + { + return (unsigned long)&x->fixup + x->fixup; + } +-static inline ex_handler_t +-ex_fixup_handler(const struct exception_table_entry *x) +-{ +- return (ex_handler_t)((unsigned long)&x->handler + x->handler); +-} +- +-bool ex_handler_default(const struct exception_table_entry *fixup, +- struct pt_regs *regs, int trapnr) +-{ +- regs->ip = ex_fixup_addr(fixup); +- return true; +-} +-EXPORT_SYMBOL(ex_handler_default); +- +-bool ex_handler_fault(const struct exception_table_entry *fixup, +- struct pt_regs *regs, int trapnr) +-{ +- regs->ip = ex_fixup_addr(fixup); +- regs->ax = trapnr; +- return true; +-} +-EXPORT_SYMBOL_GPL(ex_handler_fault); +- +-bool ex_handler_ext(const struct exception_table_entry *fixup, +- struct pt_regs *regs, int trapnr) +-{ +- /* Special hack for uaccess_err */ +- current_thread_info()->uaccess_err = 1; +- regs->ip = ex_fixup_addr(fixup); +- return true; +-} +-EXPORT_SYMBOL(ex_handler_ext); +- +-bool ex_has_fault_handler(unsigned long ip) +-{ +- const struct exception_table_entry *e; +- ex_handler_t handler; +- +- e = search_exception_tables(ip); +- if (!e) +- return false; +- handler = ex_fixup_handler(e); +- +- return handler == ex_handler_fault; +-} + +-int fixup_exception(struct pt_regs *regs, int trapnr) ++int fixup_exception(struct pt_regs *regs) + { +- const struct exception_table_entry *e; +- ex_handler_t handler; ++ const struct exception_table_entry *fixup; ++ unsigned long new_ip; + + #ifdef CONFIG_PNPBIOS + if (unlikely(SEGMENT_IS_PNP_CODE(regs->cs))) { +@@ -81,34 +33,42 @@ int fixup_exception(struct pt_regs *regs, int trapnr) + } + #endif + +- e = search_exception_tables(regs->ip); +- if (!e) +- return 0; ++ fixup = search_exception_tables(regs->ip); ++ if (fixup) { ++ new_ip = ex_fixup_addr(fixup); ++ ++ if (fixup->fixup - fixup->insn >= 0x7ffffff0 - 4) { ++ /* Special hack for uaccess_err */ ++ current_thread_info()->uaccess_err = 1; ++ new_ip -= 0x7ffffff0; ++ } ++ regs->ip = new_ip; ++ return 1; ++ } + +- handler = ex_fixup_handler(e); +- return handler(e, regs, trapnr); ++ return 0; + } + + /* Restricted version used during very early boot */ + int __init early_fixup_exception(unsigned long *ip) + { +- const struct exception_table_entry *e; ++ const struct exception_table_entry *fixup; + unsigned long new_ip; +- ex_handler_t handler; + +- e = search_exception_tables(*ip); +- if (!e) +- return 0; ++ fixup = search_exception_tables(*ip); ++ if (fixup) { ++ new_ip = ex_fixup_addr(fixup); + +- new_ip = ex_fixup_addr(e); +- handler = ex_fixup_handler(e); ++ if (fixup->fixup - fixup->insn >= 0x7ffffff0 - 4) { ++ /* uaccess handling not supported during early boot */ ++ return 0; ++ } + +- /* special handling not supported during early boot */ +- if (handler != ex_handler_default) +- return 0; ++ *ip = new_ip; ++ return 1; ++ } + +- *ip = new_ip; +- return 1; ++ return 0; + } + + /* +@@ -173,8 +133,6 @@ void sort_extable(struct exception_table_entry *start, + i += 4; + p->fixup += i; + i += 4; +- p->handler += i; +- i += 4; + } + + sort(start, finish - start, sizeof(struct exception_table_entry), +@@ -187,8 +145,6 @@ void sort_extable(struct exception_table_entry *start, + i += 4; + p->fixup -= i; + i += 4; +- p->handler -= i; +- i += 4; + } + } + +diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c +index 03898aea6e0f..e830c71a1323 100644 +--- a/arch/x86/mm/fault.c ++++ b/arch/x86/mm/fault.c +@@ -663,7 +663,7 @@ no_context(struct pt_regs *regs, unsigned long error_code, + int sig; + + /* Are we prepared to handle this kernel fault? */ +- if (fixup_exception(regs, X86_TRAP_PF)) { ++ if (fixup_exception(regs)) { + /* + * Any interrupt that takes a fault gets the fixup. This makes + * the below recursive fault logic only apply to a faults from +diff --git a/scripts/sortextable.c b/scripts/sortextable.c +index 7b29fb14f870..c2423d913b46 100644 +--- a/scripts/sortextable.c ++++ b/scripts/sortextable.c +@@ -209,35 +209,6 @@ static int compare_relative_table(const void *a, const void *b) + return 0; + } + +-static void x86_sort_relative_table(char *extab_image, int image_size) +-{ +- int i; +- +- i = 0; +- while (i < image_size) { +- uint32_t *loc = (uint32_t *)(extab_image + i); +- +- w(r(loc) + i, loc); +- w(r(loc + 1) + i + 4, loc + 1); +- w(r(loc + 2) + i + 8, loc + 2); +- +- i += sizeof(uint32_t) * 3; +- } +- +- qsort(extab_image, image_size / 12, 12, compare_relative_table); +- +- i = 0; +- while (i < image_size) { +- uint32_t *loc = (uint32_t *)(extab_image + i); +- +- w(r(loc) - i, loc); +- w(r(loc + 1) - (i + 4), loc + 1); +- w(r(loc + 2) - (i + 8), loc + 2); +- +- i += sizeof(uint32_t) * 3; +- } +-} +- + static void sort_relative_table(char *extab_image, int image_size) + { + int i; +@@ -310,9 +281,6 @@ do_file(char const *const fname) + break; + case EM_386: + case EM_X86_64: +- custom_sort = x86_sort_relative_table; +- break; +- + case EM_S390: + custom_sort = sort_relative_table; + break;
