From: Greg Kroah-Hartman Date: Thu, 3 May 2012 21:18:19 +0000 (-0700) Subject: 3.3-stable patches X-Git-Tag: v3.3.5~7 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=a94d0c415759904fe2f79db299d50fca9141377d;p=thirdparty%2Fkernel%2Fstable-queue.git 3.3-stable patches added patches: tools-include-add-byteshift-headers-for-endian-access.patch x86-boot-correct-cflags-for-hostprogs.patch x86-boot-restrict-cflags-for-hostprogs.patch x86-efi-add-dedicated-efi-stub-entry-point.patch x86-efi-fix-endian-issues-and-unaligned-accesses.patch x86-efi-fix-pointer-math-issue-in-handle_ramdisks.patch x86-mkpiggy-don-t-open-code-put_unaligned_le32.patch --- diff --git a/queue-3.3/series b/queue-3.3/series index dccdeed36a5..500dc089bbb 100644 --- a/queue-3.3/series +++ b/queue-3.3/series @@ -44,3 +44,10 @@ scsi-libsas-fix-sas_find_bcast_phy-in-the-presence-of-vacant-phys.patch scsi-libsas-fix-false-positive-device-attached-conditions.patch efi-add-new-variable-attributes.patch efi-validate-uefi-boot-variables.patch +x86-efi-fix-pointer-math-issue-in-handle_ramdisks.patch +tools-include-add-byteshift-headers-for-endian-access.patch +x86-mkpiggy-don-t-open-code-put_unaligned_le32.patch +x86-boot-restrict-cflags-for-hostprogs.patch +x86-efi-fix-endian-issues-and-unaligned-accesses.patch +x86-boot-correct-cflags-for-hostprogs.patch +x86-efi-add-dedicated-efi-stub-entry-point.patch diff --git a/queue-3.3/tools-include-add-byteshift-headers-for-endian-access.patch b/queue-3.3/tools-include-add-byteshift-headers-for-endian-access.patch new file mode 100644 index 00000000000..f114936370d --- /dev/null +++ b/queue-3.3/tools-include-add-byteshift-headers-for-endian-access.patch @@ -0,0 +1,173 @@ +From a07f7672d7cf0ff0d6e548a9feb6e0bd016d9c6c Mon Sep 17 00:00:00 2001 +From: Matt Fleming +Date: Tue, 28 Feb 2012 13:37:20 +0000 +Subject: tools/include: Add byteshift headers for endian access + +From: Matt Fleming + +commit a07f7672d7cf0ff0d6e548a9feb6e0bd016d9c6c upstream. + +There are various hostprogs in the kernel that are rolling their own +implementations of {get,put}_unaligned_le*(). Copy the byteshift +headers from include/linux/unaligned so that they can all use a single +implementation. + +This requires changing some of the data types to the userspace +exported ones (u32 -> __u32, etc). + +Signed-off-by: Matt Fleming +Link: http://lkml.kernel.org/r/1330436245-24875-2-git-send-email-matt@console-pimps.org +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + tools/include/tools/be_byteshift.h | 70 +++++++++++++++++++++++++++++++++++++ + tools/include/tools/le_byteshift.h | 70 +++++++++++++++++++++++++++++++++++++ + 2 files changed, 140 insertions(+) + +--- /dev/null ++++ b/tools/include/tools/be_byteshift.h +@@ -0,0 +1,70 @@ ++#ifndef _TOOLS_BE_BYTESHIFT_H ++#define _TOOLS_BE_BYTESHIFT_H ++ ++#include ++ ++static inline __u16 __get_unaligned_be16(const __u8 *p) ++{ ++ return p[0] << 8 | p[1]; ++} ++ ++static inline __u32 __get_unaligned_be32(const __u8 *p) ++{ ++ return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]; ++} ++ ++static inline __u64 __get_unaligned_be64(const __u8 *p) ++{ ++ return (__u64)__get_unaligned_be32(p) << 32 | ++ __get_unaligned_be32(p + 4); ++} ++ ++static inline void __put_unaligned_be16(__u16 val, __u8 *p) ++{ ++ *p++ = val >> 8; ++ *p++ = val; ++} ++ ++static inline void __put_unaligned_be32(__u32 val, __u8 *p) ++{ ++ __put_unaligned_be16(val >> 16, p); ++ __put_unaligned_be16(val, p + 2); ++} ++ ++static inline void __put_unaligned_be64(__u64 val, __u8 *p) ++{ ++ __put_unaligned_be32(val >> 32, p); ++ __put_unaligned_be32(val, p + 4); ++} ++ ++static inline __u16 get_unaligned_be16(const void *p) ++{ ++ return __get_unaligned_be16((const __u8 *)p); ++} ++ ++static inline __u32 get_unaligned_be32(const void *p) ++{ ++ return __get_unaligned_be32((const __u8 *)p); ++} ++ ++static inline __u64 get_unaligned_be64(const void *p) ++{ ++ return __get_unaligned_be64((const __u8 *)p); ++} ++ ++static inline void put_unaligned_be16(__u16 val, void *p) ++{ ++ __put_unaligned_be16(val, p); ++} ++ ++static inline void put_unaligned_be32(__u32 val, void *p) ++{ ++ __put_unaligned_be32(val, p); ++} ++ ++static inline void put_unaligned_be64(__u64 val, void *p) ++{ ++ __put_unaligned_be64(val, p); ++} ++ ++#endif /* _TOOLS_BE_BYTESHIFT_H */ +--- /dev/null ++++ b/tools/include/tools/le_byteshift.h +@@ -0,0 +1,70 @@ ++#ifndef _TOOLS_LE_BYTESHIFT_H ++#define _TOOLS_LE_BYTESHIFT_H ++ ++#include ++ ++static inline __u16 __get_unaligned_le16(const __u8 *p) ++{ ++ return p[0] | p[1] << 8; ++} ++ ++static inline __u32 __get_unaligned_le32(const __u8 *p) ++{ ++ return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24; ++} ++ ++static inline __u64 __get_unaligned_le64(const __u8 *p) ++{ ++ return (__u64)__get_unaligned_le32(p + 4) << 32 | ++ __get_unaligned_le32(p); ++} ++ ++static inline void __put_unaligned_le16(__u16 val, __u8 *p) ++{ ++ *p++ = val; ++ *p++ = val >> 8; ++} ++ ++static inline void __put_unaligned_le32(__u32 val, __u8 *p) ++{ ++ __put_unaligned_le16(val >> 16, p + 2); ++ __put_unaligned_le16(val, p); ++} ++ ++static inline void __put_unaligned_le64(__u64 val, __u8 *p) ++{ ++ __put_unaligned_le32(val >> 32, p + 4); ++ __put_unaligned_le32(val, p); ++} ++ ++static inline __u16 get_unaligned_le16(const void *p) ++{ ++ return __get_unaligned_le16((const __u8 *)p); ++} ++ ++static inline __u32 get_unaligned_le32(const void *p) ++{ ++ return __get_unaligned_le32((const __u8 *)p); ++} ++ ++static inline __u64 get_unaligned_le64(const void *p) ++{ ++ return __get_unaligned_le64((const __u8 *)p); ++} ++ ++static inline void put_unaligned_le16(__u16 val, void *p) ++{ ++ __put_unaligned_le16(val, p); ++} ++ ++static inline void put_unaligned_le32(__u32 val, void *p) ++{ ++ __put_unaligned_le32(val, p); ++} ++ ++static inline void put_unaligned_le64(__u64 val, void *p) ++{ ++ __put_unaligned_le64(val, p); ++} ++ ++#endif /* _TOOLS_LE_BYTESHIFT_H */ diff --git a/queue-3.3/x86-boot-correct-cflags-for-hostprogs.patch b/queue-3.3/x86-boot-correct-cflags-for-hostprogs.patch new file mode 100644 index 00000000000..2d4d8b92fc6 --- /dev/null +++ b/queue-3.3/x86-boot-correct-cflags-for-hostprogs.patch @@ -0,0 +1,50 @@ +From 446e1c86d51d0823e003a43a2b85c430efce2733 Mon Sep 17 00:00:00 2001 +From: "H. Peter Anvin" +Date: Thu, 22 Mar 2012 11:08:18 -0700 +Subject: x86, boot: Correct CFLAGS for hostprogs + +From: "H. Peter Anvin" + +commit 446e1c86d51d0823e003a43a2b85c430efce2733 upstream. + +This is a partial revert of commit: + d40f833 "Restrict CFLAGS for hostprogs" + +The endian-manipulation macros in tools/include need , +but the hostprogs in arch/x86/boot need several headers from the +kernel build tree, which means we have to add the kernel headers to +the include path. This picks up from the kernel tree, +which gives a warning. + +Since this use of is intentional, add +-D__EXPORTED_HEADERS__ to the command line to silence the warning. + +A better way to fix this would be to always install the exported +kernel headers into $(objtree)/usr/include as a standard part of the +kernel build, but that is a lot more involved. + +Reported-by: Linus Torvalds +Acked-by: Matt Fleming +Link: http://lkml.kernel.org/r/1330436245-24875-5-git-send-email-matt@console-pimps.org +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/Makefile | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/arch/x86/boot/Makefile ++++ b/arch/x86/boot/Makefile +@@ -37,9 +37,9 @@ setup-y += video-bios.o + targets += $(setup-y) + hostprogs-y := mkcpustr tools/build + +-HOSTCFLAGS_mkcpustr.o := -I$(srctree)/arch/$(SRCARCH)/include +-HOST_EXTRACFLAGS += -I$(objtree)/include -I$(srctree)/tools/include \ +- -include $(srctree)/include/linux/kconfig.h ++HOST_EXTRACFLAGS += -I$(srctree)/tools/include $(LINUXINCLUDE) \ ++ -D__EXPORTED_HEADERS__ ++ + $(obj)/cpu.o: $(obj)/cpustr.h + + quiet_cmd_cpustr = CPUSTR $@ diff --git a/queue-3.3/x86-boot-restrict-cflags-for-hostprogs.patch b/queue-3.3/x86-boot-restrict-cflags-for-hostprogs.patch new file mode 100644 index 00000000000..ef90a933910 --- /dev/null +++ b/queue-3.3/x86-boot-restrict-cflags-for-hostprogs.patch @@ -0,0 +1,41 @@ +From d40f833630a1299fd377408dc8d8fac370d621b0 Mon Sep 17 00:00:00 2001 +From: Matt Fleming +Date: Tue, 28 Feb 2012 13:37:23 +0000 +Subject: x86, boot: Restrict CFLAGS for hostprogs + +From: Matt Fleming + +commit d40f833630a1299fd377408dc8d8fac370d621b0 upstream. + +Currently tools/build has access to all the kernel headers in +$(srctree). This is unnecessary and could potentially allow +tools/build to erroneously include kernel headers when it should only +be including userspace-exported headers. + +Unfortunately, mkcpustr still needs access to some of the asm kernel +headers, so explicitly special case that hostprog. + +Cc: H. Peter Anvin +Signed-off-by: Matt Fleming +Link: http://lkml.kernel.org/r/1330436245-24875-5-git-send-email-matt@console-pimps.org +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/Makefile | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +--- a/arch/x86/boot/Makefile ++++ b/arch/x86/boot/Makefile +@@ -37,8 +37,9 @@ setup-y += video-bios.o + targets += $(setup-y) + hostprogs-y := mkcpustr tools/build + +-HOST_EXTRACFLAGS += $(LINUXINCLUDE) +- ++HOSTCFLAGS_mkcpustr.o := -I$(srctree)/arch/$(SRCARCH)/include ++HOST_EXTRACFLAGS += -I$(objtree)/include -I$(srctree)/tools/include \ ++ -include $(srctree)/include/linux/kconfig.h + $(obj)/cpu.o: $(obj)/cpustr.h + + quiet_cmd_cpustr = CPUSTR $@ diff --git a/queue-3.3/x86-efi-add-dedicated-efi-stub-entry-point.patch b/queue-3.3/x86-efi-add-dedicated-efi-stub-entry-point.patch new file mode 100644 index 00000000000..244efa3729c --- /dev/null +++ b/queue-3.3/x86-efi-add-dedicated-efi-stub-entry-point.patch @@ -0,0 +1,138 @@ +From b1994304fc399f5d3a5368c81111d713490c4799 Mon Sep 17 00:00:00 2001 +From: Matt Fleming +Date: Sun, 15 Apr 2012 16:06:04 +0100 +Subject: x86, efi: Add dedicated EFI stub entry point + +From: Matt Fleming + +commit b1994304fc399f5d3a5368c81111d713490c4799 upstream. + +The method used to work out whether we were booted by EFI firmware or +via a boot loader is broken. Because efi_main() is always executed +when booting from a boot loader we will dereference invalid pointers +either on the stack (CONFIG_X86_32) or contained in %rdx +(CONFIG_X86_64) when searching for an EFI System Table signature. + +Instead of dereferencing these invalid system table pointers, add a +new entry point that is only used when booting from EFI firmware, when +we know the pointer arguments will be valid. With this change legacy +boot loaders will no longer execute efi_main(), but will instead skip +EFI stub initialisation completely. + +[ hpa: Marking this for urgent/stable since it is a regression when + the option is enabled; without the option the patch has no effect ] + +Signed-off-by: Matt Fleming +Link: http://lkml.kernel.org/r/1334584744.26997.14.camel@mfleming-mobl1.ger.corp.intel.com +Reported-by: Jordan Justen +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/compressed/head_32.S | 14 +++++++++++--- + arch/x86/boot/compressed/head_64.S | 22 ++++++++++++++++------ + arch/x86/boot/tools/build.c | 15 +++++++++++---- + 3 files changed, 38 insertions(+), 13 deletions(-) + +--- a/arch/x86/boot/compressed/head_32.S ++++ b/arch/x86/boot/compressed/head_32.S +@@ -33,6 +33,9 @@ + __HEAD + ENTRY(startup_32) + #ifdef CONFIG_EFI_STUB ++ jmp preferred_addr ++ ++ .balign 0x10 + /* + * We don't need the return address, so set up the stack so + * efi_main() can find its arugments. +@@ -41,12 +44,17 @@ ENTRY(startup_32) + + call efi_main + cmpl $0, %eax +- je preferred_addr + movl %eax, %esi +- call 1f ++ jne 2f + 1: ++ /* EFI init failed, so hang. */ ++ hlt ++ jmp 1b ++2: ++ call 3f ++3: + popl %eax +- subl $1b, %eax ++ subl $3b, %eax + subl BP_pref_address(%esi), %eax + add BP_code32_start(%esi), %eax + leal preferred_addr(%eax), %eax +--- a/arch/x86/boot/compressed/head_64.S ++++ b/arch/x86/boot/compressed/head_64.S +@@ -200,18 +200,28 @@ ENTRY(startup_64) + * entire text+data+bss and hopefully all of memory. + */ + #ifdef CONFIG_EFI_STUB +- pushq %rsi ++ /* ++ * The entry point for the PE/COFF executable is 0x210, so only ++ * legacy boot loaders will execute this jmp. ++ */ ++ jmp preferred_addr ++ ++ .org 0x210 + mov %rcx, %rdi + mov %rdx, %rsi + call efi_main +- popq %rsi +- cmpq $0,%rax +- je preferred_addr + movq %rax,%rsi +- call 1f ++ cmpq $0,%rax ++ jne 2f + 1: ++ /* EFI init failed, so hang. */ ++ hlt ++ jmp 1b ++2: ++ call 3f ++3: + popq %rax +- subq $1b, %rax ++ subq $3b, %rax + subq BP_pref_address(%rsi), %rax + add BP_code32_start(%esi), %eax + leaq preferred_addr(%rax), %rax +--- a/arch/x86/boot/tools/build.c ++++ b/arch/x86/boot/tools/build.c +@@ -207,8 +207,13 @@ int main(int argc, char ** argv) + put_unaligned_le32(file_sz, &buf[pe_header + 0x50]); + + #ifdef CONFIG_X86_32 +- /* Address of entry point */ +- put_unaligned_le32(i, &buf[pe_header + 0x28]); ++ /* ++ * Address of entry point. ++ * ++ * The EFI stub entry point is +16 bytes from the start of ++ * the .text section. ++ */ ++ put_unaligned_le32(i + 16, &buf[pe_header + 0x28]); + + /* .text size */ + put_unaligned_le32(file_sz, &buf[pe_header + 0xb0]); +@@ -219,9 +224,11 @@ int main(int argc, char ** argv) + /* + * Address of entry point. startup_32 is at the beginning and + * the 64-bit entry point (startup_64) is always 512 bytes +- * after. ++ * after. The EFI stub entry point is 16 bytes after that, as ++ * the first instruction allows legacy loaders to jump over ++ * the EFI stub initialisation + */ +- put_unaligned_le32(i + 512, &buf[pe_header + 0x28]); ++ put_unaligned_le32(i + 528, &buf[pe_header + 0x28]); + + /* .text size */ + put_unaligned_le32(file_sz, &buf[pe_header + 0xc0]); diff --git a/queue-3.3/x86-efi-fix-endian-issues-and-unaligned-accesses.patch b/queue-3.3/x86-efi-fix-endian-issues-and-unaligned-accesses.patch new file mode 100644 index 00000000000..dc5c6ae9fc3 --- /dev/null +++ b/queue-3.3/x86-efi-fix-endian-issues-and-unaligned-accesses.patch @@ -0,0 +1,125 @@ +From 92f42c50f227ad228f815a8f4eec872524dae3a5 Mon Sep 17 00:00:00 2001 +From: Matt Fleming +Date: Tue, 28 Feb 2012 13:37:24 +0000 +Subject: x86, efi: Fix endian issues and unaligned accesses + +From: Matt Fleming + +commit 92f42c50f227ad228f815a8f4eec872524dae3a5 upstream. + +We may need to convert the endianness of the data we read from/write +to 'buf', so let's use {get,put}_unaligned_le32() to do that. Failure +to do so can result in accessing invalid memory, leading to a +segfault. Stephen Rothwell noticed this bug while cross-building an +x86_64 allmodconfig kernel on PowerPC. + +We need to read from and write to 'buf' a byte at a time otherwise +it's possible we'll perform an unaligned access, which can lead to bus +errors when cross-building an x86 kernel on risc architectures. + +Cc: H. Peter Anvin +Cc: Nick Bowler +Tested-by: Stephen Rothwell +Reported-by: Stephen Rothwell +Signed-off-by: Matt Fleming +Link: http://lkml.kernel.org/r/1330436245-24875-6-git-send-email-matt@console-pimps.org +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/tools/build.c | 31 +++++++++++++++---------------- + 1 file changed, 15 insertions(+), 16 deletions(-) + +--- a/arch/x86/boot/tools/build.c ++++ b/arch/x86/boot/tools/build.c +@@ -34,6 +34,7 @@ + #include + #include + #include ++#include + + typedef unsigned char u8; + typedef unsigned short u16; +@@ -41,6 +42,7 @@ typedef unsigned long u32; + + #define DEFAULT_MAJOR_ROOT 0 + #define DEFAULT_MINOR_ROOT 0 ++#define DEFAULT_ROOT_DEV (DEFAULT_MAJOR_ROOT << 8 | DEFAULT_MINOR_ROOT) + + /* Minimal number of setup sectors */ + #define SETUP_SECT_MIN 5 +@@ -159,7 +161,7 @@ int main(int argc, char ** argv) + die("read-error on `setup'"); + if (c < 1024) + die("The setup must be at least 1024 bytes"); +- if (buf[510] != 0x55 || buf[511] != 0xaa) ++ if (get_unaligned_le16(&buf[510]) != 0xAA55) + die("Boot block hasn't got boot flag (0xAA55)"); + fclose(file); + +@@ -171,8 +173,7 @@ int main(int argc, char ** argv) + memset(buf+c, 0, i-c); + + /* Set the default root device */ +- buf[508] = DEFAULT_MINOR_ROOT; +- buf[509] = DEFAULT_MAJOR_ROOT; ++ put_unaligned_le16(DEFAULT_ROOT_DEV, &buf[508]); + + fprintf(stderr, "Setup is %d bytes (padded to %d bytes).\n", c, i); + +@@ -192,44 +193,42 @@ int main(int argc, char ** argv) + + /* Patch the setup code with the appropriate size parameters */ + buf[0x1f1] = setup_sectors-1; +- buf[0x1f4] = sys_size; +- buf[0x1f5] = sys_size >> 8; +- buf[0x1f6] = sys_size >> 16; +- buf[0x1f7] = sys_size >> 24; ++ put_unaligned_le32(sys_size, &buf[0x1f4]); + + #ifdef CONFIG_EFI_STUB + file_sz = sz + i + ((sys_size * 16) - sz); + +- pe_header = *(unsigned int *)&buf[0x3c]; ++ pe_header = get_unaligned_le32(&buf[0x3c]); + + /* Size of code */ +- *(unsigned int *)&buf[pe_header + 0x1c] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0x1c]); + + /* Size of image */ +- *(unsigned int *)&buf[pe_header + 0x50] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0x50]); + + #ifdef CONFIG_X86_32 + /* Address of entry point */ +- *(unsigned int *)&buf[pe_header + 0x28] = i; ++ put_unaligned_le32(i, &buf[pe_header + 0x28]); + + /* .text size */ +- *(unsigned int *)&buf[pe_header + 0xb0] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0xb0]); + + /* .text size of initialised data */ +- *(unsigned int *)&buf[pe_header + 0xb8] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0xb8]); + #else + /* + * Address of entry point. startup_32 is at the beginning and + * the 64-bit entry point (startup_64) is always 512 bytes + * after. + */ +- *(unsigned int *)&buf[pe_header + 0x28] = i + 512; ++ put_unaligned_le32(i + 512, &buf[pe_header + 0x28]); + + /* .text size */ +- *(unsigned int *)&buf[pe_header + 0xc0] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0xc0]); + + /* .text size of initialised data */ +- *(unsigned int *)&buf[pe_header + 0xc8] = file_sz; ++ put_unaligned_le32(file_sz, &buf[pe_header + 0xc8]); ++ + #endif /* CONFIG_X86_32 */ + #endif /* CONFIG_EFI_STUB */ + diff --git a/queue-3.3/x86-efi-fix-pointer-math-issue-in-handle_ramdisks.patch b/queue-3.3/x86-efi-fix-pointer-math-issue-in-handle_ramdisks.patch new file mode 100644 index 00000000000..74e42251095 --- /dev/null +++ b/queue-3.3/x86-efi-fix-pointer-math-issue-in-handle_ramdisks.patch @@ -0,0 +1,63 @@ +From c7b738351ba92f48b943ac59aff6b5b0f17f37c9 Mon Sep 17 00:00:00 2001 +From: Dan Carpenter +Date: Mon, 5 Mar 2012 21:06:14 +0300 +Subject: x86, efi: Fix pointer math issue in handle_ramdisks() + +From: Dan Carpenter + +commit c7b738351ba92f48b943ac59aff6b5b0f17f37c9 upstream. + +"filename" is a efi_char16_t string so this check for reaching the end +of the array doesn't work. We need to cast the pointer to (u8 *) before +doing the math. + +This patch changes the "filename" to "filename_16" to avoid confusion in +the future. + +Signed-off-by: Dan Carpenter +Link: http://lkml.kernel.org/r/20120305180614.GA26880@elgon.mountain +Acked-by: Matt Fleming +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/compressed/eboot.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +--- a/arch/x86/boot/compressed/eboot.c ++++ b/arch/x86/boot/compressed/eboot.c +@@ -539,7 +539,7 @@ static efi_status_t handle_ramdisks(efi_ + struct initrd *initrd; + efi_file_handle_t *h; + efi_file_info_t *info; +- efi_char16_t filename[256]; ++ efi_char16_t filename_16[256]; + unsigned long info_sz; + efi_guid_t info_guid = EFI_FILE_INFO_ID; + efi_char16_t *p; +@@ -552,14 +552,14 @@ static efi_status_t handle_ramdisks(efi_ + str += 7; + + initrd = &initrds[i]; +- p = filename; ++ p = filename_16; + + /* Skip any leading slashes */ + while (*str == '/' || *str == '\\') + str++; + + while (*str && *str != ' ' && *str != '\n') { +- if (p >= filename + sizeof(filename)) ++ if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16)) + break; + + *p++ = *str++; +@@ -583,7 +583,7 @@ static efi_status_t handle_ramdisks(efi_ + goto free_initrds; + } + +- status = efi_call_phys5(fh->open, fh, &h, filename, ++ status = efi_call_phys5(fh->open, fh, &h, filename_16, + EFI_FILE_MODE_READ, (u64)0); + if (status != EFI_SUCCESS) + goto close_handles; diff --git a/queue-3.3/x86-mkpiggy-don-t-open-code-put_unaligned_le32.patch b/queue-3.3/x86-mkpiggy-don-t-open-code-put_unaligned_le32.patch new file mode 100644 index 00000000000..066815ffc39 --- /dev/null +++ b/queue-3.3/x86-mkpiggy-don-t-open-code-put_unaligned_le32.patch @@ -0,0 +1,60 @@ +From 12871c568305a0b20f116315479a18cd46882e9b Mon Sep 17 00:00:00 2001 +From: Matt Fleming +Date: Tue, 28 Feb 2012 13:37:22 +0000 +Subject: x86, mkpiggy: Don't open code put_unaligned_le32() + +From: Matt Fleming + +commit 12871c568305a0b20f116315479a18cd46882e9b upstream. + +Use the new headers in tools/include instead of rolling our own +put_unaligned_le32() implementation. + +Cc: H. Peter Anvin +Signed-off-by: Matt Fleming +Link: http://lkml.kernel.org/r/1330436245-24875-4-git-send-email-matt@console-pimps.org +Signed-off-by: H. Peter Anvin +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/boot/compressed/Makefile | 1 + + arch/x86/boot/compressed/mkpiggy.c | 11 ++--------- + 2 files changed, 3 insertions(+), 9 deletions(-) + +--- a/arch/x86/boot/compressed/Makefile ++++ b/arch/x86/boot/compressed/Makefile +@@ -22,6 +22,7 @@ LDFLAGS := -m elf_$(UTS_MACHINE) + LDFLAGS_vmlinux := -T + + hostprogs-y := mkpiggy ++HOST_EXTRACFLAGS += -I$(srctree)/tools/include + + VMLINUX_OBJS = $(obj)/vmlinux.lds $(obj)/head_$(BITS).o $(obj)/misc.o \ + $(obj)/string.o $(obj)/cmdline.o $(obj)/early_serial_console.o \ +--- a/arch/x86/boot/compressed/mkpiggy.c ++++ b/arch/x86/boot/compressed/mkpiggy.c +@@ -29,14 +29,7 @@ + #include + #include + #include +- +-static uint32_t getle32(const void *p) +-{ +- const uint8_t *cp = p; +- +- return (uint32_t)cp[0] + ((uint32_t)cp[1] << 8) + +- ((uint32_t)cp[2] << 16) + ((uint32_t)cp[3] << 24); +-} ++#include + + int main(int argc, char *argv[]) + { +@@ -69,7 +62,7 @@ int main(int argc, char *argv[]) + } + + ilen = ftell(f); +- olen = getle32(&olen); ++ olen = get_unaligned_le32(&olen); + fclose(f); + + /*