diff options
Diffstat (limited to 'arch')
63 files changed, 971 insertions, 362 deletions
diff --git a/arch/alpha/include/asm/sysinfo.h b/arch/alpha/include/asm/sysinfo.h index 086aba284df2..e77d77cd07b8 100644 --- a/arch/alpha/include/asm/sysinfo.h +++ b/arch/alpha/include/asm/sysinfo.h | |||
| @@ -27,13 +27,4 @@ | |||
| 27 | #define UAC_NOFIX 2 | 27 | #define UAC_NOFIX 2 |
| 28 | #define UAC_SIGBUS 4 | 28 | #define UAC_SIGBUS 4 |
| 29 | 29 | ||
| 30 | |||
| 31 | #ifdef __KERNEL__ | ||
| 32 | |||
| 33 | /* This is the shift that is applied to the UAC bits as stored in the | ||
| 34 | per-thread flags. See thread_info.h. */ | ||
| 35 | #define UAC_SHIFT 6 | ||
| 36 | |||
| 37 | #endif | ||
| 38 | |||
| 39 | #endif /* __ASM_ALPHA_SYSINFO_H */ | 30 | #endif /* __ASM_ALPHA_SYSINFO_H */ |
diff --git a/arch/alpha/include/asm/thread_info.h b/arch/alpha/include/asm/thread_info.h index 6f32f9c84a2d..ff73db022342 100644 --- a/arch/alpha/include/asm/thread_info.h +++ b/arch/alpha/include/asm/thread_info.h | |||
| @@ -74,9 +74,9 @@ register struct thread_info *__current_thread_info __asm__("$8"); | |||
| 74 | #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ | 74 | #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ |
| 75 | #define TIF_POLLING_NRFLAG 8 /* poll_idle is polling NEED_RESCHED */ | 75 | #define TIF_POLLING_NRFLAG 8 /* poll_idle is polling NEED_RESCHED */ |
| 76 | #define TIF_DIE_IF_KERNEL 9 /* dik recursion lock */ | 76 | #define TIF_DIE_IF_KERNEL 9 /* dik recursion lock */ |
| 77 | #define TIF_UAC_NOPRINT 10 /* see sysinfo.h */ | 77 | #define TIF_UAC_NOPRINT 10 /* ! Preserve sequence of following */ |
| 78 | #define TIF_UAC_NOFIX 11 | 78 | #define TIF_UAC_NOFIX 11 /* ! flags as they match */ |
| 79 | #define TIF_UAC_SIGBUS 12 | 79 | #define TIF_UAC_SIGBUS 12 /* ! userspace part of 'osf_sysinfo' */ |
| 80 | #define TIF_MEMDIE 13 /* is terminating due to OOM killer */ | 80 | #define TIF_MEMDIE 13 /* is terminating due to OOM killer */ |
| 81 | #define TIF_RESTORE_SIGMASK 14 /* restore signal mask in do_signal */ | 81 | #define TIF_RESTORE_SIGMASK 14 /* restore signal mask in do_signal */ |
| 82 | #define TIF_FREEZE 16 /* is freezing for suspend */ | 82 | #define TIF_FREEZE 16 /* is freezing for suspend */ |
| @@ -97,7 +97,7 @@ register struct thread_info *__current_thread_info __asm__("$8"); | |||
| 97 | #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK \ | 97 | #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK \ |
| 98 | | _TIF_SYSCALL_TRACE) | 98 | | _TIF_SYSCALL_TRACE) |
| 99 | 99 | ||
| 100 | #define ALPHA_UAC_SHIFT 10 | 100 | #define ALPHA_UAC_SHIFT TIF_UAC_NOPRINT |
| 101 | #define ALPHA_UAC_MASK (1 << TIF_UAC_NOPRINT | 1 << TIF_UAC_NOFIX | \ | 101 | #define ALPHA_UAC_MASK (1 << TIF_UAC_NOPRINT | 1 << TIF_UAC_NOFIX | \ |
| 102 | 1 << TIF_UAC_SIGBUS) | 102 | 1 << TIF_UAC_SIGBUS) |
| 103 | 103 | ||
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c index 326f0a2d56e5..01e8715e26d9 100644 --- a/arch/alpha/kernel/osf_sys.c +++ b/arch/alpha/kernel/osf_sys.c | |||
| @@ -42,6 +42,7 @@ | |||
| 42 | #include <asm/uaccess.h> | 42 | #include <asm/uaccess.h> |
| 43 | #include <asm/system.h> | 43 | #include <asm/system.h> |
| 44 | #include <asm/sysinfo.h> | 44 | #include <asm/sysinfo.h> |
| 45 | #include <asm/thread_info.h> | ||
| 45 | #include <asm/hwrpb.h> | 46 | #include <asm/hwrpb.h> |
| 46 | #include <asm/processor.h> | 47 | #include <asm/processor.h> |
| 47 | 48 | ||
| @@ -633,9 +634,10 @@ SYSCALL_DEFINE5(osf_getsysinfo, unsigned long, op, void __user *, buffer, | |||
| 633 | case GSI_UACPROC: | 634 | case GSI_UACPROC: |
| 634 | if (nbytes < sizeof(unsigned int)) | 635 | if (nbytes < sizeof(unsigned int)) |
| 635 | return -EINVAL; | 636 | return -EINVAL; |
| 636 | w = (current_thread_info()->flags >> UAC_SHIFT) & UAC_BITMASK; | 637 | w = (current_thread_info()->flags >> ALPHA_UAC_SHIFT) & |
| 637 | if (put_user(w, (unsigned int __user *)buffer)) | 638 | UAC_BITMASK; |
| 638 | return -EFAULT; | 639 | if (put_user(w, (unsigned int __user *)buffer)) |
| 640 | return -EFAULT; | ||
| 639 | return 1; | 641 | return 1; |
| 640 | 642 | ||
| 641 | case GSI_PROC_TYPE: | 643 | case GSI_PROC_TYPE: |
| @@ -756,8 +758,8 @@ SYSCALL_DEFINE5(osf_setsysinfo, unsigned long, op, void __user *, buffer, | |||
| 756 | case SSIN_UACPROC: | 758 | case SSIN_UACPROC: |
| 757 | again: | 759 | again: |
| 758 | old = current_thread_info()->flags; | 760 | old = current_thread_info()->flags; |
| 759 | new = old & ~(UAC_BITMASK << UAC_SHIFT); | 761 | new = old & ~(UAC_BITMASK << ALPHA_UAC_SHIFT); |
| 760 | new = new | (w & UAC_BITMASK) << UAC_SHIFT; | 762 | new = new | (w & UAC_BITMASK) << ALPHA_UAC_SHIFT; |
| 761 | if (cmpxchg(¤t_thread_info()->flags, | 763 | if (cmpxchg(¤t_thread_info()->flags, |
| 762 | old, new) != old) | 764 | old, new) != old) |
| 763 | goto again; | 765 | goto again; |
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S index b9c28f3f1956..6acea1f96de3 100644 --- a/arch/alpha/kernel/systbls.S +++ b/arch/alpha/kernel/systbls.S | |||
| @@ -360,7 +360,7 @@ sys_call_table: | |||
| 360 | .quad sys_newuname | 360 | .quad sys_newuname |
| 361 | .quad sys_nanosleep /* 340 */ | 361 | .quad sys_nanosleep /* 340 */ |
| 362 | .quad sys_mremap | 362 | .quad sys_mremap |
| 363 | .quad sys_nfsservctl | 363 | .quad sys_ni_syscall /* old nfsservctl */ |
| 364 | .quad sys_setresuid | 364 | .quad sys_setresuid |
| 365 | .quad sys_getresuid | 365 | .quad sys_getresuid |
| 366 | .quad sys_pciconfig_read /* 345 */ | 366 | .quad sys_pciconfig_read /* 345 */ |
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 5ebc5d922ea1..73c320ea172c 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig | |||
| @@ -1781,6 +1781,38 @@ config ZBOOT_ROM_SH_MOBILE_SDHI | |||
| 1781 | 1781 | ||
| 1782 | endchoice | 1782 | endchoice |
| 1783 | 1783 | ||
| 1784 | config ARM_APPENDED_DTB | ||
| 1785 | bool "Use appended device tree blob to zImage (EXPERIMENTAL)" | ||
| 1786 | depends on OF && !ZBOOT_ROM && EXPERIMENTAL | ||
| 1787 | help | ||
| 1788 | With this option, the boot code will look for a device tree binary | ||
| 1789 | (DTB) appended to zImage | ||
| 1790 | (e.g. cat zImage <filename>.dtb > zImage_w_dtb). | ||
| 1791 | |||
| 1792 | This is meant as a backward compatibility convenience for those | ||
| 1793 | systems with a bootloader that can't be upgraded to accommodate | ||
| 1794 | the documented boot protocol using a device tree. | ||
| 1795 | |||
| 1796 | Beware that there is very little in terms of protection against | ||
| 1797 | this option being confused by leftover garbage in memory that might | ||
| 1798 | look like a DTB header after a reboot if no actual DTB is appended | ||
| 1799 | to zImage. Do not leave this option active in a production kernel | ||
| 1800 | if you don't intend to always append a DTB. Proper passing of the | ||
| 1801 | location into r2 of a bootloader provided DTB is always preferable | ||
| 1802 | to this option. | ||
| 1803 | |||
| 1804 | config ARM_ATAG_DTB_COMPAT | ||
| 1805 | bool "Supplement the appended DTB with traditional ATAG information" | ||
| 1806 | depends on ARM_APPENDED_DTB | ||
| 1807 | help | ||
| 1808 | Some old bootloaders can't be updated to a DTB capable one, yet | ||
| 1809 | they provide ATAGs with memory configuration, the ramdisk address, | ||
| 1810 | the kernel cmdline string, etc. Such information is dynamically | ||
| 1811 | provided by the bootloader and can't always be stored in a static | ||
| 1812 | DTB. To allow a device tree enabled kernel to be used with such | ||
| 1813 | bootloaders, this option allows zImage to extract the information | ||
| 1814 | from the ATAG list and store it at run time into the appended DTB. | ||
| 1815 | |||
| 1784 | config CMDLINE | 1816 | config CMDLINE |
| 1785 | string "Default kernel command string" | 1817 | string "Default kernel command string" |
| 1786 | default "" | 1818 | default "" |
diff --git a/arch/arm/boot/compressed/.gitignore b/arch/arm/boot/compressed/.gitignore index c6028967d336..e0936a148516 100644 --- a/arch/arm/boot/compressed/.gitignore +++ b/arch/arm/boot/compressed/.gitignore | |||
| @@ -5,3 +5,12 @@ piggy.lzo | |||
| 5 | piggy.lzma | 5 | piggy.lzma |
| 6 | vmlinux | 6 | vmlinux |
| 7 | vmlinux.lds | 7 | vmlinux.lds |
| 8 | |||
| 9 | # borrowed libfdt files | ||
| 10 | fdt.c | ||
| 11 | fdt.h | ||
| 12 | fdt_ro.c | ||
| 13 | fdt_rw.c | ||
| 14 | fdt_wip.c | ||
| 15 | libfdt.h | ||
| 16 | libfdt_internal.h | ||
diff --git a/arch/arm/boot/compressed/Makefile b/arch/arm/boot/compressed/Makefile index 0c74a6fab952..e4f32a8e002a 100644 --- a/arch/arm/boot/compressed/Makefile +++ b/arch/arm/boot/compressed/Makefile | |||
| @@ -26,6 +26,10 @@ HEAD = head.o | |||
| 26 | OBJS += misc.o decompress.o | 26 | OBJS += misc.o decompress.o |
| 27 | FONTC = $(srctree)/drivers/video/console/font_acorn_8x8.c | 27 | FONTC = $(srctree)/drivers/video/console/font_acorn_8x8.c |
| 28 | 28 | ||
| 29 | # string library code (-Os is enforced to keep it much smaller) | ||
| 30 | OBJS += string.o | ||
| 31 | CFLAGS_string.o := -Os | ||
| 32 | |||
| 29 | # | 33 | # |
| 30 | # Architecture dependencies | 34 | # Architecture dependencies |
| 31 | # | 35 | # |
| @@ -89,21 +93,41 @@ suffix_$(CONFIG_KERNEL_GZIP) = gzip | |||
| 89 | suffix_$(CONFIG_KERNEL_LZO) = lzo | 93 | suffix_$(CONFIG_KERNEL_LZO) = lzo |
| 90 | suffix_$(CONFIG_KERNEL_LZMA) = lzma | 94 | suffix_$(CONFIG_KERNEL_LZMA) = lzma |
| 91 | 95 | ||
| 96 | # Borrowed libfdt files for the ATAG compatibility mode | ||
| 97 | |||
| 98 | libfdt := fdt_rw.c fdt_ro.c fdt_wip.c fdt.c | ||
| 99 | libfdt_hdrs := fdt.h libfdt.h libfdt_internal.h | ||
| 100 | |||
| 101 | libfdt_objs := $(addsuffix .o, $(basename $(libfdt))) | ||
| 102 | |||
| 103 | $(addprefix $(obj)/,$(libfdt) $(libfdt_hdrs)): $(obj)/%: $(srctree)/scripts/dtc/libfdt/% | ||
| 104 | $(call cmd,shipped) | ||
| 105 | |||
| 106 | $(addprefix $(obj)/,$(libfdt_objs) atags_to_fdt.o): \ | ||
| 107 | $(addprefix $(obj)/,$(libfdt_hdrs)) | ||
| 108 | |||
| 109 | ifeq ($(CONFIG_ARM_ATAG_DTB_COMPAT),y) | ||
| 110 | OBJS += $(libfdt_objs) atags_to_fdt.o | ||
| 111 | endif | ||
| 112 | |||
| 92 | targets := vmlinux vmlinux.lds \ | 113 | targets := vmlinux vmlinux.lds \ |
| 93 | piggy.$(suffix_y) piggy.$(suffix_y).o \ | 114 | piggy.$(suffix_y) piggy.$(suffix_y).o \ |
| 94 | font.o font.c head.o misc.o $(OBJS) | 115 | lib1funcs.o lib1funcs.S font.o font.c head.o misc.o $(OBJS) |
| 95 | 116 | ||
| 96 | # Make sure files are removed during clean | 117 | # Make sure files are removed during clean |
| 97 | extra-y += piggy.gzip piggy.lzo piggy.lzma lib1funcs.S | 118 | extra-y += piggy.gzip piggy.lzo piggy.lzma lib1funcs.S $(libfdt) $(libfdt_hdrs) |
| 98 | 119 | ||
| 99 | ifeq ($(CONFIG_FUNCTION_TRACER),y) | 120 | ifeq ($(CONFIG_FUNCTION_TRACER),y) |
| 100 | ORIG_CFLAGS := $(KBUILD_CFLAGS) | 121 | ORIG_CFLAGS := $(KBUILD_CFLAGS) |
| 101 | KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS)) | 122 | KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS)) |
| 102 | endif | 123 | endif |
| 103 | 124 | ||
| 104 | ccflags-y := -fpic -fno-builtin | 125 | ccflags-y := -fpic -fno-builtin -I$(obj) |
| 105 | asflags-y := -Wa,-march=all | 126 | asflags-y := -Wa,-march=all |
| 106 | 127 | ||
| 128 | # Supply kernel BSS size to the decompressor via a linker symbol. | ||
| 129 | KBSS_SZ = $(shell size $(obj)/../../../../vmlinux | awk 'END{print $$3}') | ||
| 130 | LDFLAGS_vmlinux = --defsym _kernel_bss_size=$(KBSS_SZ) | ||
| 107 | # Supply ZRELADDR to the decompressor via a linker symbol. | 131 | # Supply ZRELADDR to the decompressor via a linker symbol. |
| 108 | ifneq ($(CONFIG_AUTO_ZRELADDR),y) | 132 | ifneq ($(CONFIG_AUTO_ZRELADDR),y) |
| 109 | LDFLAGS_vmlinux += --defsym zreladdr=$(ZRELADDR) | 133 | LDFLAGS_vmlinux += --defsym zreladdr=$(ZRELADDR) |
| @@ -123,7 +147,7 @@ LDFLAGS_vmlinux += -T | |||
| 123 | # For __aeabi_uidivmod | 147 | # For __aeabi_uidivmod |
| 124 | lib1funcs = $(obj)/lib1funcs.o | 148 | lib1funcs = $(obj)/lib1funcs.o |
| 125 | 149 | ||
| 126 | $(obj)/lib1funcs.S: $(srctree)/arch/$(SRCARCH)/lib/lib1funcs.S FORCE | 150 | $(obj)/lib1funcs.S: $(srctree)/arch/$(SRCARCH)/lib/lib1funcs.S |
| 127 | $(call cmd,shipped) | 151 | $(call cmd,shipped) |
| 128 | 152 | ||
| 129 | # We need to prevent any GOTOFF relocs being used with references | 153 | # We need to prevent any GOTOFF relocs being used with references |
diff --git a/arch/arm/boot/compressed/atags_to_fdt.c b/arch/arm/boot/compressed/atags_to_fdt.c new file mode 100644 index 000000000000..6ce11c481178 --- /dev/null +++ b/arch/arm/boot/compressed/atags_to_fdt.c | |||
| @@ -0,0 +1,97 @@ | |||
| 1 | #include <asm/setup.h> | ||
| 2 | #include <libfdt.h> | ||
| 3 | |||
| 4 | static int node_offset(void *fdt, const char *node_path) | ||
| 5 | { | ||
| 6 | int offset = fdt_path_offset(fdt, node_path); | ||
| 7 | if (offset == -FDT_ERR_NOTFOUND) | ||
| 8 | offset = fdt_add_subnode(fdt, 0, node_path); | ||
| 9 | return offset; | ||
| 10 | } | ||
| 11 | |||
| 12 | static int setprop(void *fdt, const char *node_path, const char *property, | ||
| 13 | uint32_t *val_array, int size) | ||
| 14 | { | ||
| 15 | int offset = node_offset(fdt, node_path); | ||
| 16 | if (offset < 0) | ||
| 17 | return offset; | ||
| 18 | return fdt_setprop(fdt, offset, property, val_array, size); | ||
| 19 | } | ||
| 20 | |||
| 21 | static int setprop_string(void *fdt, const char *node_path, | ||
| 22 | const char *property, const char *string) | ||
| 23 | { | ||
| 24 | int offset = node_offset(fdt, node_path); | ||
| 25 | if (offset < 0) | ||
| 26 | return offset; | ||
| 27 | return fdt_setprop_string(fdt, offset, property, string); | ||
| 28 | } | ||
| 29 | |||
| 30 | static int setprop_cell(void *fdt, const char *node_path, | ||
| 31 | const char *property, uint32_t val) | ||
| 32 | { | ||
| 33 | int offset = node_offset(fdt, node_path); | ||
| 34 | if (offset < 0) | ||
| 35 | return offset; | ||
| 36 | return fdt_setprop_cell(fdt, offset, property, val); | ||
| 37 | } | ||
| 38 | |||
| 39 | /* | ||
| 40 | * Convert and fold provided ATAGs into the provided FDT. | ||
| 41 | * | ||
| 42 | * REturn values: | ||
| 43 | * = 0 -> pretend success | ||
| 44 | * = 1 -> bad ATAG (may retry with another possible ATAG pointer) | ||
| 45 | * < 0 -> error from libfdt | ||
| 46 | */ | ||
| 47 | int atags_to_fdt(void *atag_list, void *fdt, int total_space) | ||
| 48 | { | ||
| 49 | struct tag *atag = atag_list; | ||
| 50 | uint32_t mem_reg_property[2 * NR_BANKS]; | ||
| 51 | int memcount = 0; | ||
| 52 | int ret; | ||
| 53 | |||
| 54 | /* make sure we've got an aligned pointer */ | ||
| 55 | if ((u32)atag_list & 0x3) | ||
| 56 | return 1; | ||
| 57 | |||
| 58 | /* if we get a DTB here we're done already */ | ||
| 59 | if (*(u32 *)atag_list == fdt32_to_cpu(FDT_MAGIC)) | ||
| 60 | return 0; | ||
| 61 | |||
| 62 | /* validate the ATAG */ | ||
| 63 | if (atag->hdr.tag != ATAG_CORE || | ||
| 64 | (atag->hdr.size != tag_size(tag_core) && | ||
| 65 | atag->hdr.size != 2)) | ||
| 66 | return 1; | ||
| 67 | |||
| 68 | /* let's give it all the room it could need */ | ||
| 69 | ret = fdt_open_into(fdt, fdt, total_space); | ||
| 70 | if (ret < 0) | ||
| 71 | return ret; | ||
| 72 | |||
| 73 | for_each_tag(atag, atag_list) { | ||
| 74 | if (atag->hdr.tag == ATAG_CMDLINE) { | ||
| 75 | setprop_string(fdt, "/chosen", "bootargs", | ||
| 76 | atag->u.cmdline.cmdline); | ||
| 77 | } else if (atag->hdr.tag == ATAG_MEM) { | ||
| 78 | if (memcount >= sizeof(mem_reg_property)/4) | ||
| 79 | continue; | ||
| 80 | mem_reg_property[memcount++] = cpu_to_fdt32(atag->u.mem.start); | ||
| 81 | mem_reg_property[memcount++] = cpu_to_fdt32(atag->u.mem.size); | ||
| 82 | } else if (atag->hdr.tag == ATAG_INITRD2) { | ||
| 83 | uint32_t initrd_start, initrd_size; | ||
| 84 | initrd_start = atag->u.initrd.start; | ||
| 85 | initrd_size = atag->u.initrd.size; | ||
| 86 | setprop_cell(fdt, "/chosen", "linux,initrd-start", | ||
| 87 | initrd_start); | ||
| 88 | setprop_cell(fdt, "/chosen", "linux,initrd-end", | ||
| 89 | initrd_start + initrd_size); | ||
| 90 | } | ||
| 91 | } | ||
| 92 | |||
| 93 | if (memcount) | ||
| 94 | setprop(fdt, "/memory", "reg", mem_reg_property, 4*memcount); | ||
| 95 | |||
| 96 | return fdt_pack(fdt); | ||
| 97 | } | ||
diff --git a/arch/arm/boot/compressed/head.S b/arch/arm/boot/compressed/head.S index e95a5989602a..9f5ac11ccd8e 100644 --- a/arch/arm/boot/compressed/head.S +++ b/arch/arm/boot/compressed/head.S | |||
| @@ -216,6 +216,103 @@ restart: adr r0, LC0 | |||
| 216 | mov r10, r6 | 216 | mov r10, r6 |
| 217 | #endif | 217 | #endif |
| 218 | 218 | ||
| 219 | mov r5, #0 @ init dtb size to 0 | ||
| 220 | #ifdef CONFIG_ARM_APPENDED_DTB | ||
| 221 | /* | ||
| 222 | * r0 = delta | ||
| 223 | * r2 = BSS start | ||
| 224 | * r3 = BSS end | ||
| 225 | * r4 = final kernel address | ||
| 226 | * r5 = appended dtb size (still unknown) | ||
| 227 | * r6 = _edata | ||
| 228 | * r7 = architecture ID | ||
| 229 | * r8 = atags/device tree pointer | ||
| 230 | * r9 = size of decompressed image | ||
| 231 | * r10 = end of this image, including bss/stack/malloc space if non XIP | ||
| 232 | * r11 = GOT start | ||
| 233 | * r12 = GOT end | ||
| 234 | * sp = stack pointer | ||
| 235 | * | ||
| 236 | * if there are device trees (dtb) appended to zImage, advance r10 so that the | ||
| 237 | * dtb data will get relocated along with the kernel if necessary. | ||
| 238 | */ | ||
| 239 | |||
| 240 | ldr lr, [r6, #0] | ||
| 241 | #ifndef __ARMEB__ | ||
| 242 | ldr r1, =0xedfe0dd0 @ sig is 0xd00dfeed big endian | ||
| 243 | #else | ||
| 244 | ldr r1, =0xd00dfeed | ||
| 245 | #endif | ||
| 246 | cmp lr, r1 | ||
| 247 | bne dtb_check_done @ not found | ||
| 248 | |||
| 249 | #ifdef CONFIG_ARM_ATAG_DTB_COMPAT | ||
| 250 | /* | ||
| 251 | * OK... Let's do some funky business here. | ||
| 252 | * If we do have a DTB appended to zImage, and we do have | ||
| 253 | * an ATAG list around, we want the later to be translated | ||
| 254 | * and folded into the former here. To be on the safe side, | ||
| 255 | * let's temporarily move the stack away into the malloc | ||
| 256 | * area. No GOT fixup has occurred yet, but none of the | ||
| 257 | * code we're about to call uses any global variable. | ||
| 258 | */ | ||
| 259 | add sp, sp, #0x10000 | ||
| 260 | stmfd sp!, {r0-r3, ip, lr} | ||
| 261 | mov r0, r8 | ||
| 262 | mov r1, r6 | ||
| 263 | sub r2, sp, r6 | ||
| 264 | bl atags_to_fdt | ||
| 265 | |||
| 266 | /* | ||
| 267 | * If returned value is 1, there is no ATAG at the location | ||
| 268 | * pointed by r8. Try the typical 0x100 offset from start | ||
| 269 | * of RAM and hope for the best. | ||
| 270 | */ | ||
| 271 | cmp r0, #1 | ||
| 272 | sub r0, r4, #(TEXT_OFFSET - 0x100) | ||
| 273 | mov r1, r6 | ||
| 274 | sub r2, sp, r6 | ||
| 275 | blne atags_to_fdt | ||
| 276 | |||
| 277 | ldmfd sp!, {r0-r3, ip, lr} | ||
| 278 | sub sp, sp, #0x10000 | ||
| 279 | #endif | ||
| 280 | |||
| 281 | mov r8, r6 @ use the appended device tree | ||
| 282 | |||
| 283 | /* | ||
| 284 | * Make sure that the DTB doesn't end up in the final | ||
| 285 | * kernel's .bss area. To do so, we adjust the decompressed | ||
| 286 | * kernel size to compensate if that .bss size is larger | ||
| 287 | * than the relocated code. | ||
| 288 | */ | ||
| 289 | ldr r5, =_kernel_bss_size | ||
| 290 | adr r1, wont_overwrite | ||
| 291 | sub r1, r6, r1 | ||
| 292 | subs r1, r5, r1 | ||
| 293 | addhi r9, r9, r1 | ||
| 294 | |||
| 295 | /* Get the dtb's size */ | ||
| 296 | ldr r5, [r6, #4] | ||
| 297 | #ifndef __ARMEB__ | ||
| 298 | /* convert r5 (dtb size) to little endian */ | ||
| 299 | eor r1, r5, r5, ror #16 | ||
| 300 | bic r1, r1, #0x00ff0000 | ||
| 301 | mov r5, r5, ror #8 | ||
| 302 | eor r5, r5, r1, lsr #8 | ||
| 303 | #endif | ||
| 304 | |||
| 305 | /* preserve 64-bit alignment */ | ||
| 306 | add r5, r5, #7 | ||
| 307 | bic r5, r5, #7 | ||
| 308 | |||
| 309 | /* relocate some pointers past the appended dtb */ | ||
| 310 | add r6, r6, r5 | ||
| 311 | add r10, r10, r5 | ||
| 312 | add sp, sp, r5 | ||
| 313 | dtb_check_done: | ||
| 314 | #endif | ||
| 315 | |||
| 219 | /* | 316 | /* |
| 220 | * Check to see if we will overwrite ourselves. | 317 | * Check to see if we will overwrite ourselves. |
| 221 | * r4 = final kernel address | 318 | * r4 = final kernel address |
| @@ -223,15 +320,14 @@ restart: adr r0, LC0 | |||
| 223 | * r10 = end of this image, including bss/stack/malloc space if non XIP | 320 | * r10 = end of this image, including bss/stack/malloc space if non XIP |
| 224 | * We basically want: | 321 | * We basically want: |
| 225 | * r4 - 16k page directory >= r10 -> OK | 322 | * r4 - 16k page directory >= r10 -> OK |
| 226 | * r4 + image length <= current position (pc) -> OK | 323 | * r4 + image length <= address of wont_overwrite -> OK |
| 227 | */ | 324 | */ |
| 228 | add r10, r10, #16384 | 325 | add r10, r10, #16384 |
| 229 | cmp r4, r10 | 326 | cmp r4, r10 |
| 230 | bhs wont_overwrite | 327 | bhs wont_overwrite |
| 231 | add r10, r4, r9 | 328 | add r10, r4, r9 |
| 232 | ARM( cmp r10, pc ) | 329 | adr r9, wont_overwrite |
| 233 | THUMB( mov lr, pc ) | 330 | cmp r10, r9 |
| 234 | THUMB( cmp r10, lr ) | ||
| 235 | bls wont_overwrite | 331 | bls wont_overwrite |
| 236 | 332 | ||
| 237 | /* | 333 | /* |
| @@ -285,14 +381,16 @@ wont_overwrite: | |||
| 285 | * r2 = BSS start | 381 | * r2 = BSS start |
| 286 | * r3 = BSS end | 382 | * r3 = BSS end |
| 287 | * r4 = kernel execution address | 383 | * r4 = kernel execution address |
| 384 | * r5 = appended dtb size (0 if not present) | ||
| 288 | * r7 = architecture ID | 385 | * r7 = architecture ID |
| 289 | * r8 = atags pointer | 386 | * r8 = atags pointer |
| 290 | * r11 = GOT start | 387 | * r11 = GOT start |
| 291 | * r12 = GOT end | 388 | * r12 = GOT end |
| 292 | * sp = stack pointer | 389 | * sp = stack pointer |
| 293 | */ | 390 | */ |
| 294 | teq r0, #0 | 391 | orrs r1, r0, r5 |
| 295 | beq not_relocated | 392 | beq not_relocated |
| 393 | |||
| 296 | add r11, r11, r0 | 394 | add r11, r11, r0 |
| 297 | add r12, r12, r0 | 395 | add r12, r12, r0 |
| 298 | 396 | ||
| @@ -307,12 +405,21 @@ wont_overwrite: | |||
| 307 | 405 | ||
| 308 | /* | 406 | /* |
| 309 | * Relocate all entries in the GOT table. | 407 | * Relocate all entries in the GOT table. |
| 408 | * Bump bss entries to _edata + dtb size | ||
| 310 | */ | 409 | */ |
| 311 | 1: ldr r1, [r11, #0] @ relocate entries in the GOT | 410 | 1: ldr r1, [r11, #0] @ relocate entries in the GOT |
| 312 | add r1, r1, r0 @ table. This fixes up the | 411 | add r1, r1, r0 @ This fixes up C references |
| 313 | str r1, [r11], #4 @ C references. | 412 | cmp r1, r2 @ if entry >= bss_start && |
| 413 | cmphs r3, r1 @ bss_end > entry | ||
| 414 | addhi r1, r1, r5 @ entry += dtb size | ||
| 415 | str r1, [r11], #4 @ next entry | ||
| 314 | cmp r11, r12 | 416 | cmp r11, r12 |
| 315 | blo 1b | 417 | blo 1b |
| 418 | |||
| 419 | /* bump our bss pointers too */ | ||
| 420 | add r2, r2, r5 | ||
| 421 | add r3, r3, r5 | ||
| 422 | |||
| 316 | #else | 423 | #else |
| 317 | 424 | ||
| 318 | /* | 425 | /* |
diff --git a/arch/arm/boot/compressed/libfdt_env.h b/arch/arm/boot/compressed/libfdt_env.h new file mode 100644 index 000000000000..1f4e71876b00 --- /dev/null +++ b/arch/arm/boot/compressed/libfdt_env.h | |||
| @@ -0,0 +1,15 @@ | |||
| 1 | #ifndef _ARM_LIBFDT_ENV_H | ||
| 2 | #define _ARM_LIBFDT_ENV_H | ||
| 3 | |||
| 4 | #include <linux/types.h> | ||
| 5 | #include <linux/string.h> | ||
| 6 | #include <asm/byteorder.h> | ||
| 7 | |||
| 8 | #define fdt16_to_cpu(x) be16_to_cpu(x) | ||
| 9 | #define cpu_to_fdt16(x) cpu_to_be16(x) | ||
| 10 | #define fdt32_to_cpu(x) be32_to_cpu(x) | ||
| 11 | #define cpu_to_fdt32(x) cpu_to_be32(x) | ||
| 12 | #define fdt64_to_cpu(x) be64_to_cpu(x) | ||
| 13 | #define cpu_to_fdt64(x) cpu_to_be64(x) | ||
| 14 | |||
| 15 | #endif | ||
diff --git a/arch/arm/boot/compressed/misc.c b/arch/arm/boot/compressed/misc.c index 832d37236c59..8e2a8fca5ed2 100644 --- a/arch/arm/boot/compressed/misc.c +++ b/arch/arm/boot/compressed/misc.c | |||
| @@ -18,14 +18,9 @@ | |||
| 18 | 18 | ||
| 19 | unsigned int __machine_arch_type; | 19 | unsigned int __machine_arch_type; |
| 20 | 20 | ||
| 21 | #define _LINUX_STRING_H_ | ||
| 22 | |||
| 23 | #include <linux/compiler.h> /* for inline */ | 21 | #include <linux/compiler.h> /* for inline */ |
| 24 | #include <linux/types.h> /* for size_t */ | 22 | #include <linux/types.h> |
| 25 | #include <linux/stddef.h> /* for NULL */ | ||
| 26 | #include <linux/linkage.h> | 23 | #include <linux/linkage.h> |
| 27 | #include <asm/string.h> | ||
| 28 | |||
| 29 | 24 | ||
| 30 | static void putstr(const char *ptr); | 25 | static void putstr(const char *ptr); |
| 31 | extern void error(char *x); | 26 | extern void error(char *x); |
| @@ -101,41 +96,6 @@ static void putstr(const char *ptr) | |||
| 101 | flush(); | 96 | flush(); |
| 102 | } | 97 | } |
| 103 | 98 | ||
| 104 | |||
| 105 | void *memcpy(void *__dest, __const void *__src, size_t __n) | ||
| 106 | { | ||
| 107 | int i = 0; | ||
| 108 | unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src; | ||
| 109 | |||
| 110 | for (i = __n >> 3; i > 0; i--) { | ||
| 111 | *d++ = *s++; | ||
| 112 | *d++ = *s++; | ||
| 113 | *d++ = *s++; | ||
| 114 | *d++ = *s++; | ||
| 115 | *d++ = *s++; | ||
| 116 | *d++ = *s++; | ||
| 117 | *d++ = *s++; | ||
| 118 | *d++ = *s++; | ||
| 119 | } | ||
| 120 | |||
| 121 | if (__n & 1 << 2) { | ||
| 122 | *d++ = *s++; | ||
| 123 | *d++ = *s++; | ||
| 124 | *d++ = *s++; | ||
| 125 | *d++ = *s++; | ||
| 126 | } | ||
| 127 | |||
| 128 | if (__n & 1 << 1) { | ||
| 129 | *d++ = *s++; | ||
| 130 | *d++ = *s++; | ||
| 131 | } | ||
| 132 | |||
| 133 | if (__n & 1) | ||
| 134 | *d++ = *s++; | ||
| 135 | |||
| 136 | return __dest; | ||
| 137 | } | ||
| 138 | |||
| 139 | /* | 99 | /* |
| 140 | * gzip declarations | 100 | * gzip declarations |
| 141 | */ | 101 | */ |
diff --git a/arch/arm/boot/compressed/string.c b/arch/arm/boot/compressed/string.c new file mode 100644 index 000000000000..36e53ef9200f --- /dev/null +++ b/arch/arm/boot/compressed/string.c | |||
| @@ -0,0 +1,127 @@ | |||
| 1 | /* | ||
| 2 | * arch/arm/boot/compressed/string.c | ||
| 3 | * | ||
| 4 | * Small subset of simple string routines | ||
| 5 | */ | ||
| 6 | |||
| 7 | #include <linux/string.h> | ||
| 8 | |||
| 9 | void *memcpy(void *__dest, __const void *__src, size_t __n) | ||
| 10 | { | ||
| 11 | int i = 0; | ||
| 12 | unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src; | ||
| 13 | |||
| 14 | for (i = __n >> 3; i > 0; i--) { | ||
| 15 | *d++ = *s++; | ||
| 16 | *d++ = *s++; | ||
| 17 | *d++ = *s++; | ||
| 18 | *d++ = *s++; | ||
| 19 | *d++ = *s++; | ||
| 20 | *d++ = *s++; | ||
| 21 | *d++ = *s++; | ||
| 22 | *d++ = *s++; | ||
| 23 | } | ||
| 24 | |||
| 25 | if (__n & 1 << 2) { | ||
| 26 | *d++ = *s++; | ||
| 27 | *d++ = *s++; | ||
| 28 | *d++ = *s++; | ||
| 29 | *d++ = *s++; | ||
| 30 | } | ||
| 31 | |||
| 32 | if (__n & 1 << 1) { | ||
| 33 | *d++ = *s++; | ||
| 34 | *d++ = *s++; | ||
| 35 | } | ||
| 36 | |||
| 37 | if (__n & 1) | ||
| 38 | *d++ = *s++; | ||
| 39 | |||
| 40 | return __dest; | ||
| 41 | } | ||
| 42 | |||
| 43 | void *memmove(void *__dest, __const void *__src, size_t count) | ||
| 44 | { | ||
| 45 | unsigned char *d = __dest; | ||
| 46 | const unsigned char *s = __src; | ||
| 47 | |||
| 48 | if (__dest == __src) | ||
| 49 | return __dest; | ||
| 50 | |||
| 51 | if (__dest < __src) | ||
| 52 | return memcpy(__dest, __src, count); | ||
| 53 | |||
| 54 | while (count--) | ||
| 55 | d[count] = s[count]; | ||
| 56 | return __dest; | ||
| 57 | } | ||
| 58 | |||
| 59 | size_t strlen(const char *s) | ||
| 60 | { | ||
| 61 | const char *sc = s; | ||
| 62 | |||
| 63 | while (*sc != '\0') | ||
| 64 | sc++; | ||
| 65 | return sc - s; | ||
| 66 | } | ||
| 67 | |||
| 68 | int memcmp(const void *cs, const void *ct, size_t count) | ||
| 69 | { | ||
| 70 | const unsigned char *su1 = cs, *su2 = ct, *end = su1 + count; | ||
| 71 | int res = 0; | ||
| 72 | |||
| 73 | while (su1 < end) { | ||
| 74 | res = *su1++ - *su2++; | ||
| 75 | if (res) | ||
| 76 | break; | ||
| 77 | } | ||
| 78 | return res; | ||
| 79 | } | ||
| 80 | |||
| 81 | int strcmp(const char *cs, const char *ct) | ||
| 82 | { | ||
| 83 | unsigned char c1, c2; | ||
| 84 | int res = 0; | ||
| 85 | |||
| 86 | do { | ||
| 87 | c1 = *cs++; | ||
| 88 | c2 = *ct++; | ||
| 89 | res = c1 - c2; | ||
| 90 | if (res) | ||
| 91 | break; | ||
| 92 | } while (c1); | ||
| 93 | return res; | ||
| 94 | } | ||
| 95 | |||
| 96 | void *memchr(const void *s, int c, size_t count) | ||
| 97 | { | ||
| 98 | const unsigned char *p = s; | ||
| 99 | |||
| 100 | while (count--) | ||
| 101 | if ((unsigned char)c == *p++) | ||
| 102 | return (void *)(p - 1); | ||
| 103 | return NULL; | ||
| 104 | } | ||
| 105 | |||
| 106 | char *strchr(const char *s, int c) | ||
| 107 | { | ||
| 108 | while (*s != (char)c) | ||
| 109 | if (*s++ == '\0') | ||
| 110 | return NULL; | ||
| 111 | return (char *)s; | ||
| 112 | } | ||
| 113 | |||
| 114 | #undef memset | ||
| 115 | |||
| 116 | void *memset(void *s, int c, size_t count) | ||
| 117 | { | ||
| 118 | char *xs = s; | ||
| 119 | while (count--) | ||
| 120 | *xs++ = c; | ||
| 121 | return s; | ||
| 122 | } | ||
| 123 | |||
| 124 | void __memzero(void *s, size_t count) | ||
| 125 | { | ||
| 126 | memset(s, 0, count); | ||
| 127 | } | ||
diff --git a/arch/arm/boot/compressed/vmlinux.lds.in b/arch/arm/boot/compressed/vmlinux.lds.in index 4e728834a1b9..4919f2ac8b89 100644 --- a/arch/arm/boot/compressed/vmlinux.lds.in +++ b/arch/arm/boot/compressed/vmlinux.lds.in | |||
| @@ -51,6 +51,10 @@ SECTIONS | |||
| 51 | _got_start = .; | 51 | _got_start = .; |
| 52 | .got : { *(.got) } | 52 | .got : { *(.got) } |
| 53 | _got_end = .; | 53 | _got_end = .; |
| 54 | |||
| 55 | /* ensure the zImage file size is always a multiple of 64 bits */ | ||
| 56 | /* (without a dummy byte, ld just ignores the empty section) */ | ||
| 57 | .pad : { BYTE(0); . = ALIGN(8); } | ||
| 54 | _edata = .; | 58 | _edata = .; |
| 55 | 59 | ||
| 56 | . = BSS_START; | 60 | . = BSS_START; |
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S index 80f7896cc016..9943e9e74a1b 100644 --- a/arch/arm/kernel/calls.S +++ b/arch/arm/kernel/calls.S | |||
| @@ -178,7 +178,7 @@ | |||
| 178 | CALL(sys_ni_syscall) /* vm86 */ | 178 | CALL(sys_ni_syscall) /* vm86 */ |
| 179 | CALL(sys_ni_syscall) /* was sys_query_module */ | 179 | CALL(sys_ni_syscall) /* was sys_query_module */ |
| 180 | CALL(sys_poll) | 180 | CALL(sys_poll) |
| 181 | CALL(sys_nfsservctl) | 181 | CALL(sys_ni_syscall) /* was nfsservctl */ |
| 182 | /* 170 */ CALL(sys_setresgid16) | 182 | /* 170 */ CALL(sys_setresgid16) |
| 183 | CALL(sys_getresgid16) | 183 | CALL(sys_getresgid16) |
| 184 | CALL(sys_prctl) | 184 | CALL(sys_prctl) |
diff --git a/arch/arm/mach-shmobile/board-ap4evb.c b/arch/arm/mach-shmobile/board-ap4evb.c index ec8f9d960e27..b622d8d3ab72 100644 --- a/arch/arm/mach-shmobile/board-ap4evb.c +++ b/arch/arm/mach-shmobile/board-ap4evb.c | |||
| @@ -1415,6 +1415,7 @@ static void __init ap4evb_init(void) | |||
| 1415 | fsi_init_pm_clock(); | 1415 | fsi_init_pm_clock(); |
| 1416 | sh7372_pm_init(); | 1416 | sh7372_pm_init(); |
| 1417 | pm_clk_add(&fsi_device.dev, "spu2"); | 1417 | pm_clk_add(&fsi_device.dev, "spu2"); |
| 1418 | pm_clk_add(&lcdc1_device.dev, "hdmi"); | ||
| 1418 | } | 1419 | } |
| 1419 | 1420 | ||
| 1420 | static void __init ap4evb_timer_init(void) | 1421 | static void __init ap4evb_timer_init(void) |
diff --git a/arch/arm/mach-shmobile/board-mackerel.c b/arch/arm/mach-shmobile/board-mackerel.c index 671925dcf5f9..e7c5379069ef 100644 --- a/arch/arm/mach-shmobile/board-mackerel.c +++ b/arch/arm/mach-shmobile/board-mackerel.c | |||
| @@ -1591,6 +1591,7 @@ static void __init mackerel_init(void) | |||
| 1591 | hdmi_init_pm_clock(); | 1591 | hdmi_init_pm_clock(); |
| 1592 | sh7372_pm_init(); | 1592 | sh7372_pm_init(); |
| 1593 | pm_clk_add(&fsi_device.dev, "spu2"); | 1593 | pm_clk_add(&fsi_device.dev, "spu2"); |
| 1594 | pm_clk_add(&hdmi_lcdc_device.dev, "hdmi"); | ||
| 1594 | } | 1595 | } |
| 1595 | 1596 | ||
| 1596 | static void __init mackerel_timer_init(void) | 1597 | static void __init mackerel_timer_init(void) |
diff --git a/arch/arm/mach-shmobile/clock-sh7372.c b/arch/arm/mach-shmobile/clock-sh7372.c index 6b1619a65dba..e6e11e4e2d43 100644 --- a/arch/arm/mach-shmobile/clock-sh7372.c +++ b/arch/arm/mach-shmobile/clock-sh7372.c | |||
| @@ -655,6 +655,8 @@ static struct clk_lookup lookups[] = { | |||
| 655 | CLKDEV_DEV_ID("renesas_usbhs.1", &mstp_clks[MSTP406]), /* USB1 */ | 655 | CLKDEV_DEV_ID("renesas_usbhs.1", &mstp_clks[MSTP406]), /* USB1 */ |
| 656 | CLKDEV_DEV_ID("sh_keysc.0", &mstp_clks[MSTP403]), /* KEYSC */ | 656 | CLKDEV_DEV_ID("sh_keysc.0", &mstp_clks[MSTP403]), /* KEYSC */ |
| 657 | 657 | ||
| 658 | CLKDEV_ICK_ID("hdmi", "sh_mobile_lcdc_fb.1", | ||
| 659 | &div6_reparent_clks[DIV6_HDMI]), | ||
| 658 | CLKDEV_ICK_ID("ick", "sh-mobile-hdmi", &div6_reparent_clks[DIV6_HDMI]), | 660 | CLKDEV_ICK_ID("ick", "sh-mobile-hdmi", &div6_reparent_clks[DIV6_HDMI]), |
| 659 | CLKDEV_ICK_ID("icka", "sh_fsi2", &div6_reparent_clks[DIV6_FSIA]), | 661 | CLKDEV_ICK_ID("icka", "sh_fsi2", &div6_reparent_clks[DIV6_FSIA]), |
| 660 | CLKDEV_ICK_ID("ickb", "sh_fsi2", &div6_reparent_clks[DIV6_FSIB]), | 662 | CLKDEV_ICK_ID("ickb", "sh_fsi2", &div6_reparent_clks[DIV6_FSIB]), |
diff --git a/arch/arm/plat-omap/omap_device.c b/arch/arm/plat-omap/omap_device.c index b6b409744954..9a6a53854911 100644 --- a/arch/arm/plat-omap/omap_device.c +++ b/arch/arm/plat-omap/omap_device.c | |||
| @@ -622,7 +622,8 @@ static struct dev_pm_domain omap_device_pm_domain = { | |||
| 622 | SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, | 622 | SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, |
| 623 | _od_runtime_idle) | 623 | _od_runtime_idle) |
| 624 | USE_PLATFORM_PM_SLEEP_OPS | 624 | USE_PLATFORM_PM_SLEEP_OPS |
| 625 | SET_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, _od_resume_noirq) | 625 | .suspend_noirq = _od_suspend_noirq, |
| 626 | .resume_noirq = _od_resume_noirq, | ||
| 626 | } | 627 | } |
| 627 | }; | 628 | }; |
| 628 | 629 | ||
diff --git a/arch/avr32/kernel/syscall_table.S b/arch/avr32/kernel/syscall_table.S index c7fd394d28a4..6eba53530d1c 100644 --- a/arch/avr32/kernel/syscall_table.S +++ b/arch/avr32/kernel/syscall_table.S | |||
| @@ -158,7 +158,7 @@ sys_call_table: | |||
| 158 | .long sys_sched_rr_get_interval | 158 | .long sys_sched_rr_get_interval |
| 159 | .long sys_nanosleep | 159 | .long sys_nanosleep |
| 160 | .long sys_poll | 160 | .long sys_poll |
| 161 | .long sys_nfsservctl /* 145 */ | 161 | .long sys_ni_syscall /* 145 was nfsservctl */ |
| 162 | .long sys_setresgid | 162 | .long sys_setresgid |
| 163 | .long sys_getresgid | 163 | .long sys_getresgid |
| 164 | .long sys_prctl | 164 | .long sys_prctl |
diff --git a/arch/blackfin/mach-common/entry.S b/arch/blackfin/mach-common/entry.S index 225d311c9701..e4137297b790 100644 --- a/arch/blackfin/mach-common/entry.S +++ b/arch/blackfin/mach-common/entry.S | |||
| @@ -1543,7 +1543,7 @@ ENTRY(_sys_call_table) | |||
| 1543 | .long _sys_ni_syscall /* for vm86 */ | 1543 | .long _sys_ni_syscall /* for vm86 */ |
| 1544 | .long _sys_ni_syscall /* old "query_module" */ | 1544 | .long _sys_ni_syscall /* old "query_module" */ |
| 1545 | .long _sys_ni_syscall /* sys_poll */ | 1545 | .long _sys_ni_syscall /* sys_poll */ |
| 1546 | .long _sys_nfsservctl | 1546 | .long _sys_ni_syscall /* old nfsservctl */ |
| 1547 | .long _sys_setresgid /* setresgid16 */ /* 170 */ | 1547 | .long _sys_setresgid /* setresgid16 */ /* 170 */ |
| 1548 | .long _sys_getresgid /* getresgid16 */ | 1548 | .long _sys_getresgid /* getresgid16 */ |
| 1549 | .long _sys_prctl | 1549 | .long _sys_prctl |
diff --git a/arch/cris/arch-v10/kernel/entry.S b/arch/cris/arch-v10/kernel/entry.S index 1161883eb582..592fbe9dfb62 100644 --- a/arch/cris/arch-v10/kernel/entry.S +++ b/arch/cris/arch-v10/kernel/entry.S | |||
| @@ -771,7 +771,7 @@ sys_call_table: | |||
| 771 | .long sys_ni_syscall /* sys_vm86 */ | 771 | .long sys_ni_syscall /* sys_vm86 */ |
| 772 | .long sys_ni_syscall /* Old sys_query_module */ | 772 | .long sys_ni_syscall /* Old sys_query_module */ |
| 773 | .long sys_poll | 773 | .long sys_poll |
| 774 | .long sys_nfsservctl | 774 | .long sys_ni_syscall /* old nfsservctl */ |
| 775 | .long sys_setresgid16 /* 170 */ | 775 | .long sys_setresgid16 /* 170 */ |
| 776 | .long sys_getresgid16 | 776 | .long sys_getresgid16 |
| 777 | .long sys_prctl | 777 | .long sys_prctl |
diff --git a/arch/cris/arch-v32/kernel/entry.S b/arch/cris/arch-v32/kernel/entry.S index 84fed7e91ada..c3ea4694fbaf 100644 --- a/arch/cris/arch-v32/kernel/entry.S +++ b/arch/cris/arch-v32/kernel/entry.S | |||
| @@ -714,7 +714,7 @@ sys_call_table: | |||
| 714 | .long sys_ni_syscall /* sys_vm86 */ | 714 | .long sys_ni_syscall /* sys_vm86 */ |
| 715 | .long sys_ni_syscall /* Old sys_query_module */ | 715 | .long sys_ni_syscall /* Old sys_query_module */ |
| 716 | .long sys_poll | 716 | .long sys_poll |
| 717 | .long sys_nfsservctl | 717 | .long sys_ni_syscall /* Old nfsservctl */ |
| 718 | .long sys_setresgid16 /* 170 */ | 718 | .long sys_setresgid16 /* 170 */ |
| 719 | .long sys_getresgid16 | 719 | .long sys_getresgid16 |
| 720 | .long sys_prctl | 720 | .long sys_prctl |
diff --git a/arch/cris/include/asm/serial.h b/arch/cris/include/asm/serial.h new file mode 100644 index 000000000000..af7535a955fb --- /dev/null +++ b/arch/cris/include/asm/serial.h | |||
| @@ -0,0 +1,9 @@ | |||
| 1 | #ifndef _ASM_SERIAL_H | ||
| 2 | #define _ASM_SERIAL_H | ||
| 3 | |||
| 4 | /* | ||
| 5 | * This assumes you have a 1.8432 MHz clock for your UART. | ||
| 6 | */ | ||
| 7 | #define BASE_BAUD (1843200 / 16) | ||
| 8 | |||
| 9 | #endif /* _ASM_SERIAL_H */ | ||
diff --git a/arch/frv/kernel/entry.S b/arch/frv/kernel/entry.S index 017d6d7b784f..5ba23f715ea5 100644 --- a/arch/frv/kernel/entry.S +++ b/arch/frv/kernel/entry.S | |||
| @@ -1358,7 +1358,7 @@ sys_call_table: | |||
| 1358 | .long sys_ni_syscall /* for vm86 */ | 1358 | .long sys_ni_syscall /* for vm86 */ |
| 1359 | .long sys_ni_syscall /* Old sys_query_module */ | 1359 | .long sys_ni_syscall /* Old sys_query_module */ |
| 1360 | .long sys_poll | 1360 | .long sys_poll |
| 1361 | .long sys_nfsservctl | 1361 | .long sys_ni_syscall /* Old nfsservctl */ |
| 1362 | .long sys_setresgid16 /* 170 */ | 1362 | .long sys_setresgid16 /* 170 */ |
| 1363 | .long sys_getresgid16 | 1363 | .long sys_getresgid16 |
| 1364 | .long sys_prctl | 1364 | .long sys_prctl |
diff --git a/arch/h8300/kernel/syscalls.S b/arch/h8300/kernel/syscalls.S index f4b2e67bcc34..4be2ea2fbe26 100644 --- a/arch/h8300/kernel/syscalls.S +++ b/arch/h8300/kernel/syscalls.S | |||
| @@ -183,7 +183,7 @@ SYMBOL_NAME_LABEL(sys_call_table) | |||
| 183 | .long SYMBOL_NAME(sys_ni_syscall) /* for vm86 */ | 183 | .long SYMBOL_NAME(sys_ni_syscall) /* for vm86 */ |
| 184 | .long SYMBOL_NAME(sys_ni_syscall) /* sys_query_module */ | 184 | .long SYMBOL_NAME(sys_ni_syscall) /* sys_query_module */ |
| 185 | .long SYMBOL_NAME(sys_poll) | 185 | .long SYMBOL_NAME(sys_poll) |
| 186 | .long SYMBOL_NAME(sys_nfsservctl) | 186 | .long SYMBOL_NAME(sys_ni_syscall) /* old nfsservctl */ |
| 187 | .long SYMBOL_NAME(sys_setresgid16) /* 170 */ | 187 | .long SYMBOL_NAME(sys_setresgid16) /* 170 */ |
| 188 | .long SYMBOL_NAME(sys_getresgid16) | 188 | .long SYMBOL_NAME(sys_getresgid16) |
| 189 | .long SYMBOL_NAME(sys_prctl) | 189 | .long SYMBOL_NAME(sys_prctl) |
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S index 97dd2abdeb1a..198c753d1006 100644 --- a/arch/ia64/kernel/entry.S +++ b/arch/ia64/kernel/entry.S | |||
| @@ -1614,7 +1614,7 @@ sys_call_table: | |||
| 1614 | data8 sys_sched_get_priority_min | 1614 | data8 sys_sched_get_priority_min |
| 1615 | data8 sys_sched_rr_get_interval | 1615 | data8 sys_sched_rr_get_interval |
| 1616 | data8 sys_nanosleep | 1616 | data8 sys_nanosleep |
| 1617 | data8 sys_nfsservctl | 1617 | data8 sys_ni_syscall // old nfsservctl |
| 1618 | data8 sys_prctl // 1170 | 1618 | data8 sys_prctl // 1170 |
| 1619 | data8 sys_getpagesize | 1619 | data8 sys_getpagesize |
| 1620 | data8 sys_mmap2 | 1620 | data8 sys_mmap2 |
diff --git a/arch/m32r/kernel/syscall_table.S b/arch/m32r/kernel/syscall_table.S index 528f2e6ad064..f365c19795ef 100644 --- a/arch/m32r/kernel/syscall_table.S +++ b/arch/m32r/kernel/syscall_table.S | |||
| @@ -168,7 +168,7 @@ ENTRY(sys_call_table) | |||
| 168 | .long sys_tas /* vm86 syscall holder */ | 168 | .long sys_tas /* vm86 syscall holder */ |
| 169 | .long sys_ni_syscall /* query_module syscall holder */ | 169 | .long sys_ni_syscall /* query_module syscall holder */ |
| 170 | .long sys_poll | 170 | .long sys_poll |
| 171 | .long sys_nfsservctl | 171 | .long sys_ni_syscall /* was nfsservctl */ |
| 172 | .long sys_setresgid /* 170 */ | 172 | .long sys_setresgid /* 170 */ |
| 173 | .long sys_getresgid | 173 | .long sys_getresgid |
| 174 | .long sys_prctl | 174 | .long sys_prctl |
diff --git a/arch/m68k/include/asm/page_mm.h b/arch/m68k/include/asm/page_mm.h index 31d5570d6567..89f201434b5a 100644 --- a/arch/m68k/include/asm/page_mm.h +++ b/arch/m68k/include/asm/page_mm.h | |||
| @@ -162,7 +162,7 @@ static inline __attribute_const__ int __virt_to_node_shift(void) | |||
| 162 | pgdat->node_mem_map + (__pfn - pgdat->node_start_pfn); \ | 162 | pgdat->node_mem_map + (__pfn - pgdat->node_start_pfn); \ |
| 163 | }) | 163 | }) |
| 164 | #define page_to_pfn(_page) ({ \ | 164 | #define page_to_pfn(_page) ({ \ |
| 165 | struct page *__p = (_page); \ | 165 | const struct page *__p = (_page); \ |
| 166 | struct pglist_data *pgdat; \ | 166 | struct pglist_data *pgdat; \ |
| 167 | pgdat = &pg_data_map[page_to_nid(__p)]; \ | 167 | pgdat = &pg_data_map[page_to_nid(__p)]; \ |
| 168 | ((__p) - pgdat->node_mem_map) + pgdat->node_start_pfn; \ | 168 | ((__p) - pgdat->node_mem_map) + pgdat->node_start_pfn; \ |
diff --git a/arch/m68k/kernel/syscalltable.S b/arch/m68k/kernel/syscalltable.S index 00d1452f9571..c468f2edaa85 100644 --- a/arch/m68k/kernel/syscalltable.S +++ b/arch/m68k/kernel/syscalltable.S | |||
| @@ -189,7 +189,7 @@ ENTRY(sys_call_table) | |||
| 189 | .long sys_getpagesize | 189 | .long sys_getpagesize |
| 190 | .long sys_ni_syscall /* old "query_module" */ | 190 | .long sys_ni_syscall /* old "query_module" */ |
| 191 | .long sys_poll | 191 | .long sys_poll |
| 192 | .long sys_nfsservctl | 192 | .long sys_ni_syscall /* old nfsservctl */ |
| 193 | .long sys_setresgid16 /* 170 */ | 193 | .long sys_setresgid16 /* 170 */ |
| 194 | .long sys_getresgid16 | 194 | .long sys_getresgid16 |
| 195 | .long sys_prctl | 195 | .long sys_prctl |
diff --git a/arch/microblaze/kernel/syscall_table.S b/arch/microblaze/kernel/syscall_table.S index d915a122c865..8789daa2a346 100644 --- a/arch/microblaze/kernel/syscall_table.S +++ b/arch/microblaze/kernel/syscall_table.S | |||
| @@ -173,7 +173,7 @@ ENTRY(sys_call_table) | |||
| 173 | .long sys_ni_syscall /* sys_vm86 */ | 173 | .long sys_ni_syscall /* sys_vm86 */ |
| 174 | .long sys_ni_syscall /* Old sys_query_module */ | 174 | .long sys_ni_syscall /* Old sys_query_module */ |
| 175 | .long sys_poll | 175 | .long sys_poll |
| 176 | .long sys_nfsservctl | 176 | .long sys_ni_syscall /* old nfsservctl */ |
| 177 | .long sys_setresgid /* 170 */ | 177 | .long sys_setresgid /* 170 */ |
| 178 | .long sys_getresgid | 178 | .long sys_getresgid |
| 179 | .long sys_prctl | 179 | .long sys_prctl |
diff --git a/arch/mips/kernel/scall32-o32.S b/arch/mips/kernel/scall32-o32.S index e521420a45a5..865bc7a6f5a1 100644 --- a/arch/mips/kernel/scall32-o32.S +++ b/arch/mips/kernel/scall32-o32.S | |||
| @@ -424,7 +424,7 @@ einval: li v0, -ENOSYS | |||
| 424 | sys sys_getresuid 3 | 424 | sys sys_getresuid 3 |
| 425 | sys sys_ni_syscall 0 /* was sys_query_module */ | 425 | sys sys_ni_syscall 0 /* was sys_query_module */ |
| 426 | sys sys_poll 3 | 426 | sys sys_poll 3 |
| 427 | sys sys_nfsservctl 3 | 427 | sys sys_ni_syscall 0 /* was nfsservctl */ |
| 428 | sys sys_setresgid 3 /* 4190 */ | 428 | sys sys_setresgid 3 /* 4190 */ |
| 429 | sys sys_getresgid 3 | 429 | sys sys_getresgid 3 |
| 430 | sys sys_prctl 5 | 430 | sys sys_prctl 5 |
diff --git a/arch/mips/kernel/scall64-64.S b/arch/mips/kernel/scall64-64.S index 85874d6a8a70..fb7334bea731 100644 --- a/arch/mips/kernel/scall64-64.S +++ b/arch/mips/kernel/scall64-64.S | |||
| @@ -299,7 +299,7 @@ sys_call_table: | |||
| 299 | PTR sys_ni_syscall /* 5170, was get_kernel_syms */ | 299 | PTR sys_ni_syscall /* 5170, was get_kernel_syms */ |
| 300 | PTR sys_ni_syscall /* was query_module */ | 300 | PTR sys_ni_syscall /* was query_module */ |
| 301 | PTR sys_quotactl | 301 | PTR sys_quotactl |
| 302 | PTR sys_nfsservctl | 302 | PTR sys_ni_syscall /* was nfsservctl */ |
| 303 | PTR sys_ni_syscall /* res. for getpmsg */ | 303 | PTR sys_ni_syscall /* res. for getpmsg */ |
| 304 | PTR sys_ni_syscall /* 5175 for putpmsg */ | 304 | PTR sys_ni_syscall /* 5175 for putpmsg */ |
| 305 | PTR sys_ni_syscall /* res. for afs_syscall */ | 305 | PTR sys_ni_syscall /* res. for afs_syscall */ |
diff --git a/arch/mips/kernel/scall64-n32.S b/arch/mips/kernel/scall64-n32.S index b85842fc87ae..f9296e894e46 100644 --- a/arch/mips/kernel/scall64-n32.S +++ b/arch/mips/kernel/scall64-n32.S | |||
| @@ -294,7 +294,7 @@ EXPORT(sysn32_call_table) | |||
| 294 | PTR sys_ni_syscall /* 6170, was get_kernel_syms */ | 294 | PTR sys_ni_syscall /* 6170, was get_kernel_syms */ |
| 295 | PTR sys_ni_syscall /* was query_module */ | 295 | PTR sys_ni_syscall /* was query_module */ |
| 296 | PTR sys_quotactl | 296 | PTR sys_quotactl |
| 297 | PTR compat_sys_nfsservctl | 297 | PTR sys_ni_syscall /* was nfsservctl */ |
| 298 | PTR sys_ni_syscall /* res. for getpmsg */ | 298 | PTR sys_ni_syscall /* res. for getpmsg */ |
| 299 | PTR sys_ni_syscall /* 6175 for putpmsg */ | 299 | PTR sys_ni_syscall /* 6175 for putpmsg */ |
| 300 | PTR sys_ni_syscall /* res. for afs_syscall */ | 300 | PTR sys_ni_syscall /* res. for afs_syscall */ |
diff --git a/arch/mips/kernel/scall64-o32.S b/arch/mips/kernel/scall64-o32.S index 46c4763edf21..4d7c9827706f 100644 --- a/arch/mips/kernel/scall64-o32.S +++ b/arch/mips/kernel/scall64-o32.S | |||
| @@ -392,7 +392,7 @@ sys_call_table: | |||
| 392 | PTR sys_getresuid | 392 | PTR sys_getresuid |
| 393 | PTR sys_ni_syscall /* was query_module */ | 393 | PTR sys_ni_syscall /* was query_module */ |
| 394 | PTR sys_poll | 394 | PTR sys_poll |
| 395 | PTR compat_sys_nfsservctl | 395 | PTR sys_ni_syscall /* was nfsservctl */ |
| 396 | PTR sys_setresgid /* 4190 */ | 396 | PTR sys_setresgid /* 4190 */ |
| 397 | PTR sys_getresgid | 397 | PTR sys_getresgid |
| 398 | PTR sys_prctl | 398 | PTR sys_prctl |
diff --git a/arch/mn10300/kernel/entry.S b/arch/mn10300/kernel/entry.S index ae435e1d5669..3e3620d9fc45 100644 --- a/arch/mn10300/kernel/entry.S +++ b/arch/mn10300/kernel/entry.S | |||
| @@ -589,7 +589,7 @@ ENTRY(sys_call_table) | |||
| 589 | .long sys_ni_syscall /* vm86 */ | 589 | .long sys_ni_syscall /* vm86 */ |
| 590 | .long sys_ni_syscall /* Old sys_query_module */ | 590 | .long sys_ni_syscall /* Old sys_query_module */ |
| 591 | .long sys_poll | 591 | .long sys_poll |
| 592 | .long sys_nfsservctl | 592 | .long sys_ni_syscall /* was nfsservctl */ |
| 593 | .long sys_setresgid16 /* 170 */ | 593 | .long sys_setresgid16 /* 170 */ |
| 594 | .long sys_getresgid16 | 594 | .long sys_getresgid16 |
| 595 | .long sys_prctl | 595 | .long sys_prctl |
diff --git a/arch/powerpc/sysdev/fsl_rio.c b/arch/powerpc/sysdev/fsl_rio.c index 2de8551df40f..c65f75aa7ff7 100644 --- a/arch/powerpc/sysdev/fsl_rio.c +++ b/arch/powerpc/sysdev/fsl_rio.c | |||
| @@ -54,6 +54,7 @@ | |||
| 54 | #define ODSR_CLEAR 0x1c00 | 54 | #define ODSR_CLEAR 0x1c00 |
| 55 | #define LTLEECSR_ENABLE_ALL 0xFFC000FC | 55 | #define LTLEECSR_ENABLE_ALL 0xFFC000FC |
| 56 | #define ESCSR_CLEAR 0x07120204 | 56 | #define ESCSR_CLEAR 0x07120204 |
| 57 | #define IECSR_CLEAR 0x80000000 | ||
| 57 | 58 | ||
| 58 | #define RIO_PORT1_EDCSR 0x0640 | 59 | #define RIO_PORT1_EDCSR 0x0640 |
| 59 | #define RIO_PORT2_EDCSR 0x0680 | 60 | #define RIO_PORT2_EDCSR 0x0680 |
| @@ -1089,11 +1090,11 @@ static void port_error_handler(struct rio_mport *port, int offset) | |||
| 1089 | 1090 | ||
| 1090 | if (offset == 0) { | 1091 | if (offset == 0) { |
| 1091 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_EDCSR), 0); | 1092 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_EDCSR), 0); |
| 1092 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_IECSR), 0); | 1093 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_IECSR), IECSR_CLEAR); |
| 1093 | out_be32((u32 *)(rio_regs_win + RIO_ESCSR), ESCSR_CLEAR); | 1094 | out_be32((u32 *)(rio_regs_win + RIO_ESCSR), ESCSR_CLEAR); |
| 1094 | } else { | 1095 | } else { |
| 1095 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_EDCSR), 0); | 1096 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_EDCSR), 0); |
| 1096 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_IECSR), 0); | 1097 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_IECSR), IECSR_CLEAR); |
| 1097 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_ESCSR), ESCSR_CLEAR); | 1098 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_ESCSR), ESCSR_CLEAR); |
| 1098 | } | 1099 | } |
| 1099 | } | 1100 | } |
diff --git a/arch/s390/kernel/compat_wrapper.S b/arch/s390/kernel/compat_wrapper.S index 08ab9aa6a0d5..7526db6bf501 100644 --- a/arch/s390/kernel/compat_wrapper.S +++ b/arch/s390/kernel/compat_wrapper.S | |||
| @@ -665,12 +665,6 @@ ENTRY(sys32_poll_wrapper) | |||
| 665 | lgfr %r4,%r4 # long | 665 | lgfr %r4,%r4 # long |
| 666 | jg sys_poll # branch to system call | 666 | jg sys_poll # branch to system call |
| 667 | 667 | ||
| 668 | ENTRY(compat_sys_nfsservctl_wrapper) | ||
| 669 | lgfr %r2,%r2 # int | ||
| 670 | llgtr %r3,%r3 # struct compat_nfsctl_arg* | ||
| 671 | llgtr %r4,%r4 # union compat_nfsctl_res* | ||
| 672 | jg compat_sys_nfsservctl # branch to system call | ||
| 673 | |||
| 674 | ENTRY(sys32_setresgid16_wrapper) | 668 | ENTRY(sys32_setresgid16_wrapper) |
| 675 | llgfr %r2,%r2 # __kernel_old_gid_emu31_t | 669 | llgfr %r2,%r2 # __kernel_old_gid_emu31_t |
| 676 | llgfr %r3,%r3 # __kernel_old_gid_emu31_t | 670 | llgfr %r3,%r3 # __kernel_old_gid_emu31_t |
diff --git a/arch/s390/kernel/early.c b/arch/s390/kernel/early.c index 068f8465c4ee..f297456dba7a 100644 --- a/arch/s390/kernel/early.c +++ b/arch/s390/kernel/early.c | |||
| @@ -396,17 +396,19 @@ static __init void detect_machine_facilities(void) | |||
| 396 | static __init void rescue_initrd(void) | 396 | static __init void rescue_initrd(void) |
| 397 | { | 397 | { |
| 398 | #ifdef CONFIG_BLK_DEV_INITRD | 398 | #ifdef CONFIG_BLK_DEV_INITRD |
| 399 | unsigned long min_initrd_addr = (unsigned long) _end + (4UL << 20); | ||
| 399 | /* | 400 | /* |
| 400 | * Move the initrd right behind the bss section in case it starts | 401 | * Just like in case of IPL from VM reader we make sure there is a |
| 401 | * within the bss section. So we don't overwrite it when the bss | 402 | * gap of 4MB between end of kernel and start of initrd. |
| 402 | * section gets cleared. | 403 | * That way we can also be sure that saving an NSS will succeed, |
| 404 | * which however only requires different segments. | ||
| 403 | */ | 405 | */ |
| 404 | if (!INITRD_START || !INITRD_SIZE) | 406 | if (!INITRD_START || !INITRD_SIZE) |
| 405 | return; | 407 | return; |
| 406 | if (INITRD_START >= (unsigned long) __bss_stop) | 408 | if (INITRD_START >= min_initrd_addr) |
| 407 | return; | 409 | return; |
| 408 | memmove(__bss_stop, (void *) INITRD_START, INITRD_SIZE); | 410 | memmove((void *) min_initrd_addr, (void *) INITRD_START, INITRD_SIZE); |
| 409 | INITRD_START = (unsigned long) __bss_stop; | 411 | INITRD_START = min_initrd_addr; |
| 410 | #endif | 412 | #endif |
| 411 | } | 413 | } |
| 412 | 414 | ||
diff --git a/arch/s390/kernel/ipl.c b/arch/s390/kernel/ipl.c index 04361d5a4279..48c710206366 100644 --- a/arch/s390/kernel/ipl.c +++ b/arch/s390/kernel/ipl.c | |||
| @@ -1220,7 +1220,7 @@ static int __init reipl_fcp_init(void) | |||
| 1220 | /* sysfs: create fcp kset for mixing attr group and bin attrs */ | 1220 | /* sysfs: create fcp kset for mixing attr group and bin attrs */ |
| 1221 | reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL, | 1221 | reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL, |
| 1222 | &reipl_kset->kobj); | 1222 | &reipl_kset->kobj); |
| 1223 | if (!reipl_kset) { | 1223 | if (!reipl_fcp_kset) { |
| 1224 | free_page((unsigned long) reipl_block_fcp); | 1224 | free_page((unsigned long) reipl_block_fcp); |
| 1225 | return -ENOMEM; | 1225 | return -ENOMEM; |
| 1226 | } | 1226 | } |
| @@ -1618,7 +1618,8 @@ static struct shutdown_action vmcmd_action = {SHUTDOWN_ACTION_VMCMD_STR, | |||
| 1618 | 1618 | ||
| 1619 | static void stop_run(struct shutdown_trigger *trigger) | 1619 | static void stop_run(struct shutdown_trigger *trigger) |
| 1620 | { | 1620 | { |
| 1621 | if (strcmp(trigger->name, ON_PANIC_STR) == 0) | 1621 | if (strcmp(trigger->name, ON_PANIC_STR) == 0 || |
| 1622 | strcmp(trigger->name, ON_RESTART_STR) == 0) | ||
| 1622 | disabled_wait((unsigned long) __builtin_return_address(0)); | 1623 | disabled_wait((unsigned long) __builtin_return_address(0)); |
| 1623 | while (sigp(smp_processor_id(), sigp_stop) == sigp_busy) | 1624 | while (sigp(smp_processor_id(), sigp_stop) == sigp_busy) |
| 1624 | cpu_relax(); | 1625 | cpu_relax(); |
| @@ -1717,7 +1718,7 @@ static void do_panic(void) | |||
| 1717 | /* on restart */ | 1718 | /* on restart */ |
| 1718 | 1719 | ||
| 1719 | static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR, | 1720 | static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR, |
| 1720 | &reipl_action}; | 1721 | &stop_action}; |
| 1721 | 1722 | ||
| 1722 | static ssize_t on_restart_show(struct kobject *kobj, | 1723 | static ssize_t on_restart_show(struct kobject *kobj, |
| 1723 | struct kobj_attribute *attr, char *page) | 1724 | struct kobj_attribute *attr, char *page) |
diff --git a/arch/s390/kernel/syscalls.S b/arch/s390/kernel/syscalls.S index 6ee39ef8fe4a..73eb08c874fb 100644 --- a/arch/s390/kernel/syscalls.S +++ b/arch/s390/kernel/syscalls.S | |||
| @@ -177,7 +177,7 @@ SYSCALL(sys_getresuid16,sys_ni_syscall,sys32_getresuid16_wrapper) /* 165 old get | |||
| 177 | NI_SYSCALL /* for vm86 */ | 177 | NI_SYSCALL /* for vm86 */ |
| 178 | NI_SYSCALL /* old sys_query_module */ | 178 | NI_SYSCALL /* old sys_query_module */ |
| 179 | SYSCALL(sys_poll,sys_poll,sys32_poll_wrapper) | 179 | SYSCALL(sys_poll,sys_poll,sys32_poll_wrapper) |
| 180 | SYSCALL(sys_nfsservctl,sys_nfsservctl,compat_sys_nfsservctl_wrapper) | 180 | NI_SYSCALL /* old nfsservctl */ |
| 181 | SYSCALL(sys_setresgid16,sys_ni_syscall,sys32_setresgid16_wrapper) /* 170 old setresgid16 syscall */ | 181 | SYSCALL(sys_setresgid16,sys_ni_syscall,sys32_setresgid16_wrapper) /* 170 old setresgid16 syscall */ |
| 182 | SYSCALL(sys_getresgid16,sys_ni_syscall,sys32_getresgid16_wrapper) /* old getresgid16 syscall */ | 182 | SYSCALL(sys_getresgid16,sys_ni_syscall,sys32_getresgid16_wrapper) /* old getresgid16 syscall */ |
| 183 | SYSCALL(sys_prctl,sys_prctl,sys32_prctl_wrapper) | 183 | SYSCALL(sys_prctl,sys_prctl,sys32_prctl_wrapper) |
diff --git a/arch/sh/kernel/syscalls_32.S b/arch/sh/kernel/syscalls_32.S index 39b051de4c7c..293e39c59c00 100644 --- a/arch/sh/kernel/syscalls_32.S +++ b/arch/sh/kernel/syscalls_32.S | |||
| @@ -185,7 +185,7 @@ ENTRY(sys_call_table) | |||
| 185 | .long sys_ni_syscall /* vm86 */ | 185 | .long sys_ni_syscall /* vm86 */ |
| 186 | .long sys_ni_syscall /* old "query_module" */ | 186 | .long sys_ni_syscall /* old "query_module" */ |
| 187 | .long sys_poll | 187 | .long sys_poll |
| 188 | .long sys_nfsservctl | 188 | .long sys_ni_syscall /* was nfsservctl */ |
| 189 | .long sys_setresgid16 /* 170 */ | 189 | .long sys_setresgid16 /* 170 */ |
| 190 | .long sys_getresgid16 | 190 | .long sys_getresgid16 |
| 191 | .long sys_prctl | 191 | .long sys_prctl |
diff --git a/arch/sh/kernel/syscalls_64.S b/arch/sh/kernel/syscalls_64.S index 089c4d825d08..ceb34b94afa9 100644 --- a/arch/sh/kernel/syscalls_64.S +++ b/arch/sh/kernel/syscalls_64.S | |||
| @@ -189,7 +189,7 @@ sys_call_table: | |||
| 189 | .long sys_ni_syscall /* vm86 */ | 189 | .long sys_ni_syscall /* vm86 */ |
| 190 | .long sys_ni_syscall /* old "query_module" */ | 190 | .long sys_ni_syscall /* old "query_module" */ |
| 191 | .long sys_poll | 191 | .long sys_poll |
| 192 | .long sys_nfsservctl | 192 | .long sys_ni_syscall /* was nfsservctl */ |
| 193 | .long sys_setresgid16 /* 170 */ | 193 | .long sys_setresgid16 /* 170 */ |
| 194 | .long sys_getresgid16 | 194 | .long sys_getresgid16 |
| 195 | .long sys_prctl | 195 | .long sys_prctl |
diff --git a/arch/sparc/include/asm/sigcontext.h b/arch/sparc/include/asm/sigcontext.h index a1607d180354..69914d748130 100644 --- a/arch/sparc/include/asm/sigcontext.h +++ b/arch/sparc/include/asm/sigcontext.h | |||
| @@ -45,6 +45,19 @@ typedef struct { | |||
| 45 | int si_mask; | 45 | int si_mask; |
| 46 | } __siginfo32_t; | 46 | } __siginfo32_t; |
| 47 | 47 | ||
| 48 | #define __SIGC_MAXWIN 7 | ||
| 49 | |||
| 50 | typedef struct { | ||
| 51 | unsigned long locals[8]; | ||
| 52 | unsigned long ins[8]; | ||
| 53 | } __siginfo_reg_window; | ||
| 54 | |||
| 55 | typedef struct { | ||
| 56 | int wsaved; | ||
| 57 | __siginfo_reg_window reg_window[__SIGC_MAXWIN]; | ||
| 58 | unsigned long rwbuf_stkptrs[__SIGC_MAXWIN]; | ||
| 59 | } __siginfo_rwin_t; | ||
| 60 | |||
| 48 | #ifdef CONFIG_SPARC64 | 61 | #ifdef CONFIG_SPARC64 |
| 49 | typedef struct { | 62 | typedef struct { |
| 50 | unsigned int si_float_regs [64]; | 63 | unsigned int si_float_regs [64]; |
| @@ -73,6 +86,7 @@ struct sigcontext { | |||
| 73 | unsigned long ss_size; | 86 | unsigned long ss_size; |
| 74 | } sigc_stack; | 87 | } sigc_stack; |
| 75 | unsigned long sigc_mask; | 88 | unsigned long sigc_mask; |
| 89 | __siginfo_rwin_t * sigc_rwin_save; | ||
| 76 | }; | 90 | }; |
| 77 | 91 | ||
| 78 | #else | 92 | #else |
diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile index b90b4a1d070a..cb85458f89d2 100644 --- a/arch/sparc/kernel/Makefile +++ b/arch/sparc/kernel/Makefile | |||
| @@ -32,6 +32,7 @@ obj-$(CONFIG_SPARC32) += sun4m_irq.o sun4c_irq.o sun4d_irq.o | |||
| 32 | 32 | ||
| 33 | obj-y += process_$(BITS).o | 33 | obj-y += process_$(BITS).o |
| 34 | obj-y += signal_$(BITS).o | 34 | obj-y += signal_$(BITS).o |
| 35 | obj-y += sigutil_$(BITS).o | ||
| 35 | obj-$(CONFIG_SPARC32) += ioport.o | 36 | obj-$(CONFIG_SPARC32) += ioport.o |
| 36 | obj-y += setup_$(BITS).o | 37 | obj-y += setup_$(BITS).o |
| 37 | obj-y += idprom.o | 38 | obj-y += idprom.o |
diff --git a/arch/sparc/kernel/signal32.c b/arch/sparc/kernel/signal32.c index 75fad425e249..1ba95aff5d59 100644 --- a/arch/sparc/kernel/signal32.c +++ b/arch/sparc/kernel/signal32.c | |||
| @@ -29,6 +29,8 @@ | |||
| 29 | #include <asm/visasm.h> | 29 | #include <asm/visasm.h> |
| 30 | #include <asm/compat_signal.h> | 30 | #include <asm/compat_signal.h> |
| 31 | 31 | ||
| 32 | #include "sigutil.h" | ||
| 33 | |||
| 32 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | 34 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) |
| 33 | 35 | ||
| 34 | /* This magic should be in g_upper[0] for all upper parts | 36 | /* This magic should be in g_upper[0] for all upper parts |
| @@ -44,14 +46,14 @@ typedef struct { | |||
| 44 | struct signal_frame32 { | 46 | struct signal_frame32 { |
| 45 | struct sparc_stackf32 ss; | 47 | struct sparc_stackf32 ss; |
| 46 | __siginfo32_t info; | 48 | __siginfo32_t info; |
| 47 | /* __siginfo_fpu32_t * */ u32 fpu_save; | 49 | /* __siginfo_fpu_t * */ u32 fpu_save; |
| 48 | unsigned int insns[2]; | 50 | unsigned int insns[2]; |
| 49 | unsigned int extramask[_COMPAT_NSIG_WORDS - 1]; | 51 | unsigned int extramask[_COMPAT_NSIG_WORDS - 1]; |
| 50 | unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ | 52 | unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ |
| 51 | /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ | 53 | /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ |
| 52 | siginfo_extra_v8plus_t v8plus; | 54 | siginfo_extra_v8plus_t v8plus; |
| 53 | __siginfo_fpu_t fpu_state; | 55 | /* __siginfo_rwin_t * */u32 rwin_save; |
| 54 | }; | 56 | } __attribute__((aligned(8))); |
| 55 | 57 | ||
| 56 | typedef struct compat_siginfo{ | 58 | typedef struct compat_siginfo{ |
| 57 | int si_signo; | 59 | int si_signo; |
| @@ -110,18 +112,14 @@ struct rt_signal_frame32 { | |||
| 110 | compat_siginfo_t info; | 112 | compat_siginfo_t info; |
| 111 | struct pt_regs32 regs; | 113 | struct pt_regs32 regs; |
| 112 | compat_sigset_t mask; | 114 | compat_sigset_t mask; |
| 113 | /* __siginfo_fpu32_t * */ u32 fpu_save; | 115 | /* __siginfo_fpu_t * */ u32 fpu_save; |
| 114 | unsigned int insns[2]; | 116 | unsigned int insns[2]; |
| 115 | stack_t32 stack; | 117 | stack_t32 stack; |
| 116 | unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ | 118 | unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ |
| 117 | /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ | 119 | /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ |
| 118 | siginfo_extra_v8plus_t v8plus; | 120 | siginfo_extra_v8plus_t v8plus; |
| 119 | __siginfo_fpu_t fpu_state; | 121 | /* __siginfo_rwin_t * */u32 rwin_save; |
| 120 | }; | 122 | } __attribute__((aligned(8))); |
| 121 | |||
| 122 | /* Align macros */ | ||
| 123 | #define SF_ALIGNEDSZ (((sizeof(struct signal_frame32) + 15) & (~15))) | ||
| 124 | #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 15) & (~15))) | ||
| 125 | 123 | ||
| 126 | int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) | 124 | int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) |
| 127 | { | 125 | { |
| @@ -192,30 +190,13 @@ int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) | |||
| 192 | return 0; | 190 | return 0; |
| 193 | } | 191 | } |
| 194 | 192 | ||
| 195 | static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 196 | { | ||
| 197 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 198 | unsigned long fprs; | ||
| 199 | int err; | ||
| 200 | |||
| 201 | err = __get_user(fprs, &fpu->si_fprs); | ||
| 202 | fprs_write(0); | ||
| 203 | regs->tstate &= ~TSTATE_PEF; | ||
| 204 | if (fprs & FPRS_DL) | ||
| 205 | err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32)); | ||
| 206 | if (fprs & FPRS_DU) | ||
| 207 | err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32)); | ||
| 208 | err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 209 | err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 210 | current_thread_info()->fpsaved[0] |= fprs; | ||
| 211 | return err; | ||
| 212 | } | ||
| 213 | |||
| 214 | void do_sigreturn32(struct pt_regs *regs) | 193 | void do_sigreturn32(struct pt_regs *regs) |
| 215 | { | 194 | { |
| 216 | struct signal_frame32 __user *sf; | 195 | struct signal_frame32 __user *sf; |
| 196 | compat_uptr_t fpu_save; | ||
| 197 | compat_uptr_t rwin_save; | ||
| 217 | unsigned int psr; | 198 | unsigned int psr; |
| 218 | unsigned pc, npc, fpu_save; | 199 | unsigned pc, npc; |
| 219 | sigset_t set; | 200 | sigset_t set; |
| 220 | unsigned seta[_COMPAT_NSIG_WORDS]; | 201 | unsigned seta[_COMPAT_NSIG_WORDS]; |
| 221 | int err, i; | 202 | int err, i; |
| @@ -273,8 +254,13 @@ void do_sigreturn32(struct pt_regs *regs) | |||
| 273 | pt_regs_clear_syscall(regs); | 254 | pt_regs_clear_syscall(regs); |
| 274 | 255 | ||
| 275 | err |= __get_user(fpu_save, &sf->fpu_save); | 256 | err |= __get_user(fpu_save, &sf->fpu_save); |
| 276 | if (fpu_save) | 257 | if (!err && fpu_save) |
| 277 | err |= restore_fpu_state32(regs, &sf->fpu_state); | 258 | err |= restore_fpu_state(regs, compat_ptr(fpu_save)); |
| 259 | err |= __get_user(rwin_save, &sf->rwin_save); | ||
| 260 | if (!err && rwin_save) { | ||
| 261 | if (restore_rwin_state(compat_ptr(rwin_save))) | ||
| 262 | goto segv; | ||
| 263 | } | ||
| 278 | err |= __get_user(seta[0], &sf->info.si_mask); | 264 | err |= __get_user(seta[0], &sf->info.si_mask); |
| 279 | err |= copy_from_user(seta+1, &sf->extramask, | 265 | err |= copy_from_user(seta+1, &sf->extramask, |
| 280 | (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); | 266 | (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); |
| @@ -300,7 +286,9 @@ segv: | |||
| 300 | asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) | 286 | asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) |
| 301 | { | 287 | { |
| 302 | struct rt_signal_frame32 __user *sf; | 288 | struct rt_signal_frame32 __user *sf; |
| 303 | unsigned int psr, pc, npc, fpu_save, u_ss_sp; | 289 | unsigned int psr, pc, npc, u_ss_sp; |
| 290 | compat_uptr_t fpu_save; | ||
| 291 | compat_uptr_t rwin_save; | ||
| 304 | mm_segment_t old_fs; | 292 | mm_segment_t old_fs; |
| 305 | sigset_t set; | 293 | sigset_t set; |
| 306 | compat_sigset_t seta; | 294 | compat_sigset_t seta; |
| @@ -359,8 +347,8 @@ asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) | |||
| 359 | pt_regs_clear_syscall(regs); | 347 | pt_regs_clear_syscall(regs); |
| 360 | 348 | ||
| 361 | err |= __get_user(fpu_save, &sf->fpu_save); | 349 | err |= __get_user(fpu_save, &sf->fpu_save); |
| 362 | if (fpu_save) | 350 | if (!err && fpu_save) |
| 363 | err |= restore_fpu_state32(regs, &sf->fpu_state); | 351 | err |= restore_fpu_state(regs, compat_ptr(fpu_save)); |
| 364 | err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t)); | 352 | err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t)); |
| 365 | err |= __get_user(u_ss_sp, &sf->stack.ss_sp); | 353 | err |= __get_user(u_ss_sp, &sf->stack.ss_sp); |
| 366 | st.ss_sp = compat_ptr(u_ss_sp); | 354 | st.ss_sp = compat_ptr(u_ss_sp); |
| @@ -376,6 +364,12 @@ asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) | |||
| 376 | do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf); | 364 | do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf); |
| 377 | set_fs(old_fs); | 365 | set_fs(old_fs); |
| 378 | 366 | ||
| 367 | err |= __get_user(rwin_save, &sf->rwin_save); | ||
| 368 | if (!err && rwin_save) { | ||
| 369 | if (restore_rwin_state(compat_ptr(rwin_save))) | ||
| 370 | goto segv; | ||
| 371 | } | ||
| 372 | |||
| 379 | switch (_NSIG_WORDS) { | 373 | switch (_NSIG_WORDS) { |
| 380 | case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32); | 374 | case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32); |
| 381 | case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32); | 375 | case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32); |
| @@ -433,26 +427,6 @@ static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, uns | |||
| 433 | return (void __user *) sp; | 427 | return (void __user *) sp; |
| 434 | } | 428 | } |
| 435 | 429 | ||
| 436 | static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 437 | { | ||
| 438 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 439 | unsigned long fprs; | ||
| 440 | int err = 0; | ||
| 441 | |||
| 442 | fprs = current_thread_info()->fpsaved[0]; | ||
| 443 | if (fprs & FPRS_DL) | ||
| 444 | err |= copy_to_user(&fpu->si_float_regs[0], fpregs, | ||
| 445 | (sizeof(unsigned int) * 32)); | ||
| 446 | if (fprs & FPRS_DU) | ||
| 447 | err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16, | ||
| 448 | (sizeof(unsigned int) * 32)); | ||
| 449 | err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 450 | err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 451 | err |= __put_user(fprs, &fpu->si_fprs); | ||
| 452 | |||
| 453 | return err; | ||
| 454 | } | ||
| 455 | |||
| 456 | /* The I-cache flush instruction only works in the primary ASI, which | 430 | /* The I-cache flush instruction only works in the primary ASI, which |
| 457 | * right now is the nucleus, aka. kernel space. | 431 | * right now is the nucleus, aka. kernel space. |
| 458 | * | 432 | * |
| @@ -515,18 +489,23 @@ static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 515 | int signo, sigset_t *oldset) | 489 | int signo, sigset_t *oldset) |
| 516 | { | 490 | { |
| 517 | struct signal_frame32 __user *sf; | 491 | struct signal_frame32 __user *sf; |
| 492 | int i, err, wsaved; | ||
| 493 | void __user *tail; | ||
| 518 | int sigframe_size; | 494 | int sigframe_size; |
| 519 | u32 psr; | 495 | u32 psr; |
| 520 | int i, err; | ||
| 521 | unsigned int seta[_COMPAT_NSIG_WORDS]; | 496 | unsigned int seta[_COMPAT_NSIG_WORDS]; |
| 522 | 497 | ||
| 523 | /* 1. Make sure everything is clean */ | 498 | /* 1. Make sure everything is clean */ |
| 524 | synchronize_user_stack(); | 499 | synchronize_user_stack(); |
| 525 | save_and_clear_fpu(); | 500 | save_and_clear_fpu(); |
| 526 | 501 | ||
| 527 | sigframe_size = SF_ALIGNEDSZ; | 502 | wsaved = get_thread_wsaved(); |
| 528 | if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) | 503 | |
| 529 | sigframe_size -= sizeof(__siginfo_fpu_t); | 504 | sigframe_size = sizeof(*sf); |
| 505 | if (current_thread_info()->fpsaved[0] & FPRS_FEF) | ||
| 506 | sigframe_size += sizeof(__siginfo_fpu_t); | ||
| 507 | if (wsaved) | ||
| 508 | sigframe_size += sizeof(__siginfo_rwin_t); | ||
| 530 | 509 | ||
| 531 | sf = (struct signal_frame32 __user *) | 510 | sf = (struct signal_frame32 __user *) |
| 532 | get_sigframe(&ka->sa, regs, sigframe_size); | 511 | get_sigframe(&ka->sa, regs, sigframe_size); |
| @@ -534,8 +513,7 @@ static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 534 | if (invalid_frame_pointer(sf, sigframe_size)) | 513 | if (invalid_frame_pointer(sf, sigframe_size)) |
| 535 | goto sigill; | 514 | goto sigill; |
| 536 | 515 | ||
| 537 | if (get_thread_wsaved() != 0) | 516 | tail = (sf + 1); |
| 538 | goto sigill; | ||
| 539 | 517 | ||
| 540 | /* 2. Save the current process state */ | 518 | /* 2. Save the current process state */ |
| 541 | if (test_thread_flag(TIF_32BIT)) { | 519 | if (test_thread_flag(TIF_32BIT)) { |
| @@ -560,11 +538,22 @@ static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 560 | &sf->v8plus.asi); | 538 | &sf->v8plus.asi); |
| 561 | 539 | ||
| 562 | if (psr & PSR_EF) { | 540 | if (psr & PSR_EF) { |
| 563 | err |= save_fpu_state32(regs, &sf->fpu_state); | 541 | __siginfo_fpu_t __user *fp = tail; |
| 564 | err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); | 542 | tail += sizeof(*fp); |
| 543 | err |= save_fpu_state(regs, fp); | ||
| 544 | err |= __put_user((u64)fp, &sf->fpu_save); | ||
| 565 | } else { | 545 | } else { |
| 566 | err |= __put_user(0, &sf->fpu_save); | 546 | err |= __put_user(0, &sf->fpu_save); |
| 567 | } | 547 | } |
| 548 | if (wsaved) { | ||
| 549 | __siginfo_rwin_t __user *rwp = tail; | ||
| 550 | tail += sizeof(*rwp); | ||
| 551 | err |= save_rwin_state(wsaved, rwp); | ||
| 552 | err |= __put_user((u64)rwp, &sf->rwin_save); | ||
| 553 | set_thread_wsaved(0); | ||
| 554 | } else { | ||
| 555 | err |= __put_user(0, &sf->rwin_save); | ||
| 556 | } | ||
| 568 | 557 | ||
| 569 | switch (_NSIG_WORDS) { | 558 | switch (_NSIG_WORDS) { |
| 570 | case 4: seta[7] = (oldset->sig[3] >> 32); | 559 | case 4: seta[7] = (oldset->sig[3] >> 32); |
| @@ -580,10 +569,21 @@ static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 580 | err |= __copy_to_user(sf->extramask, seta + 1, | 569 | err |= __copy_to_user(sf->extramask, seta + 1, |
| 581 | (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); | 570 | (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); |
| 582 | 571 | ||
| 583 | err |= copy_in_user((u32 __user *)sf, | 572 | if (!wsaved) { |
| 584 | (u32 __user *)(regs->u_regs[UREG_FP]), | 573 | err |= copy_in_user((u32 __user *)sf, |
| 585 | sizeof(struct reg_window32)); | 574 | (u32 __user *)(regs->u_regs[UREG_FP]), |
| 586 | 575 | sizeof(struct reg_window32)); | |
| 576 | } else { | ||
| 577 | struct reg_window *rp; | ||
| 578 | |||
| 579 | rp = ¤t_thread_info()->reg_window[wsaved - 1]; | ||
| 580 | for (i = 0; i < 8; i++) | ||
| 581 | err |= __put_user(rp->locals[i], &sf->ss.locals[i]); | ||
| 582 | for (i = 0; i < 6; i++) | ||
| 583 | err |= __put_user(rp->ins[i], &sf->ss.ins[i]); | ||
| 584 | err |= __put_user(rp->ins[6], &sf->ss.fp); | ||
| 585 | err |= __put_user(rp->ins[7], &sf->ss.callers_pc); | ||
| 586 | } | ||
| 587 | if (err) | 587 | if (err) |
| 588 | goto sigsegv; | 588 | goto sigsegv; |
| 589 | 589 | ||
| @@ -613,7 +613,6 @@ static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 613 | err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/ | 613 | err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/ |
| 614 | if (err) | 614 | if (err) |
| 615 | goto sigsegv; | 615 | goto sigsegv; |
| 616 | |||
| 617 | flush_signal_insns(address); | 616 | flush_signal_insns(address); |
| 618 | } | 617 | } |
| 619 | return 0; | 618 | return 0; |
| @@ -632,18 +631,23 @@ static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 632 | siginfo_t *info) | 631 | siginfo_t *info) |
| 633 | { | 632 | { |
| 634 | struct rt_signal_frame32 __user *sf; | 633 | struct rt_signal_frame32 __user *sf; |
| 634 | int i, err, wsaved; | ||
| 635 | void __user *tail; | ||
| 635 | int sigframe_size; | 636 | int sigframe_size; |
| 636 | u32 psr; | 637 | u32 psr; |
| 637 | int i, err; | ||
| 638 | compat_sigset_t seta; | 638 | compat_sigset_t seta; |
| 639 | 639 | ||
| 640 | /* 1. Make sure everything is clean */ | 640 | /* 1. Make sure everything is clean */ |
| 641 | synchronize_user_stack(); | 641 | synchronize_user_stack(); |
| 642 | save_and_clear_fpu(); | 642 | save_and_clear_fpu(); |
| 643 | 643 | ||
| 644 | sigframe_size = RT_ALIGNEDSZ; | 644 | wsaved = get_thread_wsaved(); |
| 645 | if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) | 645 | |
| 646 | sigframe_size -= sizeof(__siginfo_fpu_t); | 646 | sigframe_size = sizeof(*sf); |
| 647 | if (current_thread_info()->fpsaved[0] & FPRS_FEF) | ||
| 648 | sigframe_size += sizeof(__siginfo_fpu_t); | ||
| 649 | if (wsaved) | ||
| 650 | sigframe_size += sizeof(__siginfo_rwin_t); | ||
| 647 | 651 | ||
| 648 | sf = (struct rt_signal_frame32 __user *) | 652 | sf = (struct rt_signal_frame32 __user *) |
| 649 | get_sigframe(&ka->sa, regs, sigframe_size); | 653 | get_sigframe(&ka->sa, regs, sigframe_size); |
| @@ -651,8 +655,7 @@ static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 651 | if (invalid_frame_pointer(sf, sigframe_size)) | 655 | if (invalid_frame_pointer(sf, sigframe_size)) |
| 652 | goto sigill; | 656 | goto sigill; |
| 653 | 657 | ||
| 654 | if (get_thread_wsaved() != 0) | 658 | tail = (sf + 1); |
| 655 | goto sigill; | ||
| 656 | 659 | ||
| 657 | /* 2. Save the current process state */ | 660 | /* 2. Save the current process state */ |
| 658 | if (test_thread_flag(TIF_32BIT)) { | 661 | if (test_thread_flag(TIF_32BIT)) { |
| @@ -677,11 +680,22 @@ static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 677 | &sf->v8plus.asi); | 680 | &sf->v8plus.asi); |
| 678 | 681 | ||
| 679 | if (psr & PSR_EF) { | 682 | if (psr & PSR_EF) { |
| 680 | err |= save_fpu_state32(regs, &sf->fpu_state); | 683 | __siginfo_fpu_t __user *fp = tail; |
| 681 | err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); | 684 | tail += sizeof(*fp); |
| 685 | err |= save_fpu_state(regs, fp); | ||
| 686 | err |= __put_user((u64)fp, &sf->fpu_save); | ||
| 682 | } else { | 687 | } else { |
| 683 | err |= __put_user(0, &sf->fpu_save); | 688 | err |= __put_user(0, &sf->fpu_save); |
| 684 | } | 689 | } |
| 690 | if (wsaved) { | ||
| 691 | __siginfo_rwin_t __user *rwp = tail; | ||
| 692 | tail += sizeof(*rwp); | ||
| 693 | err |= save_rwin_state(wsaved, rwp); | ||
| 694 | err |= __put_user((u64)rwp, &sf->rwin_save); | ||
| 695 | set_thread_wsaved(0); | ||
| 696 | } else { | ||
| 697 | err |= __put_user(0, &sf->rwin_save); | ||
| 698 | } | ||
| 685 | 699 | ||
| 686 | /* Update the siginfo structure. */ | 700 | /* Update the siginfo structure. */ |
| 687 | err |= copy_siginfo_to_user32(&sf->info, info); | 701 | err |= copy_siginfo_to_user32(&sf->info, info); |
| @@ -703,9 +717,21 @@ static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 703 | } | 717 | } |
| 704 | err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t)); | 718 | err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t)); |
| 705 | 719 | ||
| 706 | err |= copy_in_user((u32 __user *)sf, | 720 | if (!wsaved) { |
| 707 | (u32 __user *)(regs->u_regs[UREG_FP]), | 721 | err |= copy_in_user((u32 __user *)sf, |
| 708 | sizeof(struct reg_window32)); | 722 | (u32 __user *)(regs->u_regs[UREG_FP]), |
| 723 | sizeof(struct reg_window32)); | ||
| 724 | } else { | ||
| 725 | struct reg_window *rp; | ||
| 726 | |||
| 727 | rp = ¤t_thread_info()->reg_window[wsaved - 1]; | ||
| 728 | for (i = 0; i < 8; i++) | ||
| 729 | err |= __put_user(rp->locals[i], &sf->ss.locals[i]); | ||
| 730 | for (i = 0; i < 6; i++) | ||
| 731 | err |= __put_user(rp->ins[i], &sf->ss.ins[i]); | ||
| 732 | err |= __put_user(rp->ins[6], &sf->ss.fp); | ||
| 733 | err |= __put_user(rp->ins[7], &sf->ss.callers_pc); | ||
| 734 | } | ||
| 709 | if (err) | 735 | if (err) |
| 710 | goto sigsegv; | 736 | goto sigsegv; |
| 711 | 737 | ||
diff --git a/arch/sparc/kernel/signal_32.c b/arch/sparc/kernel/signal_32.c index 5e5c5fd03783..04ede8f04add 100644 --- a/arch/sparc/kernel/signal_32.c +++ b/arch/sparc/kernel/signal_32.c | |||
| @@ -26,6 +26,8 @@ | |||
| 26 | #include <asm/pgtable.h> | 26 | #include <asm/pgtable.h> |
| 27 | #include <asm/cacheflush.h> /* flush_sig_insns */ | 27 | #include <asm/cacheflush.h> /* flush_sig_insns */ |
| 28 | 28 | ||
| 29 | #include "sigutil.h" | ||
| 30 | |||
| 29 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | 31 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) |
| 30 | 32 | ||
| 31 | extern void fpsave(unsigned long *fpregs, unsigned long *fsr, | 33 | extern void fpsave(unsigned long *fpregs, unsigned long *fsr, |
| @@ -39,8 +41,8 @@ struct signal_frame { | |||
| 39 | unsigned long insns[2] __attribute__ ((aligned (8))); | 41 | unsigned long insns[2] __attribute__ ((aligned (8))); |
| 40 | unsigned int extramask[_NSIG_WORDS - 1]; | 42 | unsigned int extramask[_NSIG_WORDS - 1]; |
| 41 | unsigned int extra_size; /* Should be 0 */ | 43 | unsigned int extra_size; /* Should be 0 */ |
| 42 | __siginfo_fpu_t fpu_state; | 44 | __siginfo_rwin_t __user *rwin_save; |
| 43 | }; | 45 | } __attribute__((aligned(8))); |
| 44 | 46 | ||
| 45 | struct rt_signal_frame { | 47 | struct rt_signal_frame { |
| 46 | struct sparc_stackf ss; | 48 | struct sparc_stackf ss; |
| @@ -51,8 +53,8 @@ struct rt_signal_frame { | |||
| 51 | unsigned int insns[2]; | 53 | unsigned int insns[2]; |
| 52 | stack_t stack; | 54 | stack_t stack; |
| 53 | unsigned int extra_size; /* Should be 0 */ | 55 | unsigned int extra_size; /* Should be 0 */ |
| 54 | __siginfo_fpu_t fpu_state; | 56 | __siginfo_rwin_t __user *rwin_save; |
| 55 | }; | 57 | } __attribute__((aligned(8))); |
| 56 | 58 | ||
| 57 | /* Align macros */ | 59 | /* Align macros */ |
| 58 | #define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7))) | 60 | #define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7))) |
| @@ -79,43 +81,13 @@ asmlinkage int sys_sigsuspend(old_sigset_t set) | |||
| 79 | return _sigpause_common(set); | 81 | return _sigpause_common(set); |
| 80 | } | 82 | } |
| 81 | 83 | ||
| 82 | static inline int | ||
| 83 | restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 84 | { | ||
| 85 | int err; | ||
| 86 | #ifdef CONFIG_SMP | ||
| 87 | if (test_tsk_thread_flag(current, TIF_USEDFPU)) | ||
| 88 | regs->psr &= ~PSR_EF; | ||
| 89 | #else | ||
| 90 | if (current == last_task_used_math) { | ||
| 91 | last_task_used_math = NULL; | ||
| 92 | regs->psr &= ~PSR_EF; | ||
| 93 | } | ||
| 94 | #endif | ||
| 95 | set_used_math(); | ||
| 96 | clear_tsk_thread_flag(current, TIF_USEDFPU); | ||
| 97 | |||
| 98 | if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu))) | ||
| 99 | return -EFAULT; | ||
| 100 | |||
| 101 | err = __copy_from_user(¤t->thread.float_regs[0], &fpu->si_float_regs[0], | ||
| 102 | (sizeof(unsigned long) * 32)); | ||
| 103 | err |= __get_user(current->thread.fsr, &fpu->si_fsr); | ||
| 104 | err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth); | ||
| 105 | if (current->thread.fpqdepth != 0) | ||
| 106 | err |= __copy_from_user(¤t->thread.fpqueue[0], | ||
| 107 | &fpu->si_fpqueue[0], | ||
| 108 | ((sizeof(unsigned long) + | ||
| 109 | (sizeof(unsigned long *)))*16)); | ||
| 110 | return err; | ||
| 111 | } | ||
| 112 | |||
| 113 | asmlinkage void do_sigreturn(struct pt_regs *regs) | 84 | asmlinkage void do_sigreturn(struct pt_regs *regs) |
| 114 | { | 85 | { |
| 115 | struct signal_frame __user *sf; | 86 | struct signal_frame __user *sf; |
| 116 | unsigned long up_psr, pc, npc; | 87 | unsigned long up_psr, pc, npc; |
| 117 | sigset_t set; | 88 | sigset_t set; |
| 118 | __siginfo_fpu_t __user *fpu_save; | 89 | __siginfo_fpu_t __user *fpu_save; |
| 90 | __siginfo_rwin_t __user *rwin_save; | ||
| 119 | int err; | 91 | int err; |
| 120 | 92 | ||
| 121 | /* Always make any pending restarted system calls return -EINTR */ | 93 | /* Always make any pending restarted system calls return -EINTR */ |
| @@ -150,9 +122,11 @@ asmlinkage void do_sigreturn(struct pt_regs *regs) | |||
| 150 | pt_regs_clear_syscall(regs); | 122 | pt_regs_clear_syscall(regs); |
| 151 | 123 | ||
| 152 | err |= __get_user(fpu_save, &sf->fpu_save); | 124 | err |= __get_user(fpu_save, &sf->fpu_save); |
| 153 | |||
| 154 | if (fpu_save) | 125 | if (fpu_save) |
| 155 | err |= restore_fpu_state(regs, fpu_save); | 126 | err |= restore_fpu_state(regs, fpu_save); |
| 127 | err |= __get_user(rwin_save, &sf->rwin_save); | ||
| 128 | if (rwin_save) | ||
| 129 | err |= restore_rwin_state(rwin_save); | ||
| 156 | 130 | ||
| 157 | /* This is pretty much atomic, no amount locking would prevent | 131 | /* This is pretty much atomic, no amount locking would prevent |
| 158 | * the races which exist anyways. | 132 | * the races which exist anyways. |
| @@ -180,6 +154,7 @@ asmlinkage void do_rt_sigreturn(struct pt_regs *regs) | |||
| 180 | struct rt_signal_frame __user *sf; | 154 | struct rt_signal_frame __user *sf; |
| 181 | unsigned int psr, pc, npc; | 155 | unsigned int psr, pc, npc; |
| 182 | __siginfo_fpu_t __user *fpu_save; | 156 | __siginfo_fpu_t __user *fpu_save; |
| 157 | __siginfo_rwin_t __user *rwin_save; | ||
| 183 | mm_segment_t old_fs; | 158 | mm_segment_t old_fs; |
| 184 | sigset_t set; | 159 | sigset_t set; |
| 185 | stack_t st; | 160 | stack_t st; |
| @@ -207,8 +182,7 @@ asmlinkage void do_rt_sigreturn(struct pt_regs *regs) | |||
| 207 | pt_regs_clear_syscall(regs); | 182 | pt_regs_clear_syscall(regs); |
| 208 | 183 | ||
| 209 | err |= __get_user(fpu_save, &sf->fpu_save); | 184 | err |= __get_user(fpu_save, &sf->fpu_save); |
| 210 | 185 | if (!err && fpu_save) | |
| 211 | if (fpu_save) | ||
| 212 | err |= restore_fpu_state(regs, fpu_save); | 186 | err |= restore_fpu_state(regs, fpu_save); |
| 213 | err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); | 187 | err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); |
| 214 | 188 | ||
| @@ -228,6 +202,12 @@ asmlinkage void do_rt_sigreturn(struct pt_regs *regs) | |||
| 228 | do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf); | 202 | do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf); |
| 229 | set_fs(old_fs); | 203 | set_fs(old_fs); |
| 230 | 204 | ||
| 205 | err |= __get_user(rwin_save, &sf->rwin_save); | ||
| 206 | if (!err && rwin_save) { | ||
| 207 | if (restore_rwin_state(rwin_save)) | ||
| 208 | goto segv; | ||
| 209 | } | ||
| 210 | |||
| 231 | sigdelsetmask(&set, ~_BLOCKABLE); | 211 | sigdelsetmask(&set, ~_BLOCKABLE); |
| 232 | spin_lock_irq(¤t->sighand->siglock); | 212 | spin_lock_irq(¤t->sighand->siglock); |
| 233 | current->blocked = set; | 213 | current->blocked = set; |
| @@ -280,53 +260,23 @@ static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *re | |||
| 280 | return (void __user *) sp; | 260 | return (void __user *) sp; |
| 281 | } | 261 | } |
| 282 | 262 | ||
| 283 | static inline int | ||
| 284 | save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 285 | { | ||
| 286 | int err = 0; | ||
| 287 | #ifdef CONFIG_SMP | ||
| 288 | if (test_tsk_thread_flag(current, TIF_USEDFPU)) { | ||
| 289 | put_psr(get_psr() | PSR_EF); | ||
| 290 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, | ||
| 291 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); | ||
| 292 | regs->psr &= ~(PSR_EF); | ||
| 293 | clear_tsk_thread_flag(current, TIF_USEDFPU); | ||
| 294 | } | ||
| 295 | #else | ||
| 296 | if (current == last_task_used_math) { | ||
| 297 | put_psr(get_psr() | PSR_EF); | ||
| 298 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, | ||
| 299 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); | ||
| 300 | last_task_used_math = NULL; | ||
| 301 | regs->psr &= ~(PSR_EF); | ||
| 302 | } | ||
| 303 | #endif | ||
| 304 | err |= __copy_to_user(&fpu->si_float_regs[0], | ||
| 305 | ¤t->thread.float_regs[0], | ||
| 306 | (sizeof(unsigned long) * 32)); | ||
| 307 | err |= __put_user(current->thread.fsr, &fpu->si_fsr); | ||
| 308 | err |= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth); | ||
| 309 | if (current->thread.fpqdepth != 0) | ||
| 310 | err |= __copy_to_user(&fpu->si_fpqueue[0], | ||
| 311 | ¤t->thread.fpqueue[0], | ||
| 312 | ((sizeof(unsigned long) + | ||
| 313 | (sizeof(unsigned long *)))*16)); | ||
| 314 | clear_used_math(); | ||
| 315 | return err; | ||
| 316 | } | ||
| 317 | |||
| 318 | static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs, | 263 | static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs, |
| 319 | int signo, sigset_t *oldset) | 264 | int signo, sigset_t *oldset) |
| 320 | { | 265 | { |
| 321 | struct signal_frame __user *sf; | 266 | struct signal_frame __user *sf; |
| 322 | int sigframe_size, err; | 267 | int sigframe_size, err, wsaved; |
| 268 | void __user *tail; | ||
| 323 | 269 | ||
| 324 | /* 1. Make sure everything is clean */ | 270 | /* 1. Make sure everything is clean */ |
| 325 | synchronize_user_stack(); | 271 | synchronize_user_stack(); |
| 326 | 272 | ||
| 327 | sigframe_size = SF_ALIGNEDSZ; | 273 | wsaved = current_thread_info()->w_saved; |
| 328 | if (!used_math()) | 274 | |
| 329 | sigframe_size -= sizeof(__siginfo_fpu_t); | 275 | sigframe_size = sizeof(*sf); |
| 276 | if (used_math()) | ||
| 277 | sigframe_size += sizeof(__siginfo_fpu_t); | ||
| 278 | if (wsaved) | ||
| 279 | sigframe_size += sizeof(__siginfo_rwin_t); | ||
| 330 | 280 | ||
| 331 | sf = (struct signal_frame __user *) | 281 | sf = (struct signal_frame __user *) |
| 332 | get_sigframe(&ka->sa, regs, sigframe_size); | 282 | get_sigframe(&ka->sa, regs, sigframe_size); |
| @@ -334,8 +284,7 @@ static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 334 | if (invalid_frame_pointer(sf, sigframe_size)) | 284 | if (invalid_frame_pointer(sf, sigframe_size)) |
| 335 | goto sigill_and_return; | 285 | goto sigill_and_return; |
| 336 | 286 | ||
| 337 | if (current_thread_info()->w_saved != 0) | 287 | tail = sf + 1; |
| 338 | goto sigill_and_return; | ||
| 339 | 288 | ||
| 340 | /* 2. Save the current process state */ | 289 | /* 2. Save the current process state */ |
| 341 | err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs)); | 290 | err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs)); |
| @@ -343,17 +292,34 @@ static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 343 | err |= __put_user(0, &sf->extra_size); | 292 | err |= __put_user(0, &sf->extra_size); |
| 344 | 293 | ||
| 345 | if (used_math()) { | 294 | if (used_math()) { |
| 346 | err |= save_fpu_state(regs, &sf->fpu_state); | 295 | __siginfo_fpu_t __user *fp = tail; |
| 347 | err |= __put_user(&sf->fpu_state, &sf->fpu_save); | 296 | tail += sizeof(*fp); |
| 297 | err |= save_fpu_state(regs, fp); | ||
| 298 | err |= __put_user(fp, &sf->fpu_save); | ||
| 348 | } else { | 299 | } else { |
| 349 | err |= __put_user(0, &sf->fpu_save); | 300 | err |= __put_user(0, &sf->fpu_save); |
| 350 | } | 301 | } |
| 302 | if (wsaved) { | ||
| 303 | __siginfo_rwin_t __user *rwp = tail; | ||
| 304 | tail += sizeof(*rwp); | ||
| 305 | err |= save_rwin_state(wsaved, rwp); | ||
| 306 | err |= __put_user(rwp, &sf->rwin_save); | ||
| 307 | } else { | ||
| 308 | err |= __put_user(0, &sf->rwin_save); | ||
| 309 | } | ||
| 351 | 310 | ||
| 352 | err |= __put_user(oldset->sig[0], &sf->info.si_mask); | 311 | err |= __put_user(oldset->sig[0], &sf->info.si_mask); |
| 353 | err |= __copy_to_user(sf->extramask, &oldset->sig[1], | 312 | err |= __copy_to_user(sf->extramask, &oldset->sig[1], |
| 354 | (_NSIG_WORDS - 1) * sizeof(unsigned int)); | 313 | (_NSIG_WORDS - 1) * sizeof(unsigned int)); |
| 355 | err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], | 314 | if (!wsaved) { |
| 356 | sizeof(struct reg_window32)); | 315 | err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], |
| 316 | sizeof(struct reg_window32)); | ||
| 317 | } else { | ||
| 318 | struct reg_window32 *rp; | ||
| 319 | |||
| 320 | rp = ¤t_thread_info()->reg_window[wsaved - 1]; | ||
| 321 | err |= __copy_to_user(sf, rp, sizeof(struct reg_window32)); | ||
| 322 | } | ||
| 357 | if (err) | 323 | if (err) |
| 358 | goto sigsegv; | 324 | goto sigsegv; |
| 359 | 325 | ||
| @@ -399,21 +365,24 @@ static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 399 | int signo, sigset_t *oldset, siginfo_t *info) | 365 | int signo, sigset_t *oldset, siginfo_t *info) |
| 400 | { | 366 | { |
| 401 | struct rt_signal_frame __user *sf; | 367 | struct rt_signal_frame __user *sf; |
| 402 | int sigframe_size; | 368 | int sigframe_size, wsaved; |
| 369 | void __user *tail; | ||
| 403 | unsigned int psr; | 370 | unsigned int psr; |
| 404 | int err; | 371 | int err; |
| 405 | 372 | ||
| 406 | synchronize_user_stack(); | 373 | synchronize_user_stack(); |
| 407 | sigframe_size = RT_ALIGNEDSZ; | 374 | wsaved = current_thread_info()->w_saved; |
| 408 | if (!used_math()) | 375 | sigframe_size = sizeof(*sf); |
| 409 | sigframe_size -= sizeof(__siginfo_fpu_t); | 376 | if (used_math()) |
| 377 | sigframe_size += sizeof(__siginfo_fpu_t); | ||
| 378 | if (wsaved) | ||
| 379 | sigframe_size += sizeof(__siginfo_rwin_t); | ||
| 410 | sf = (struct rt_signal_frame __user *) | 380 | sf = (struct rt_signal_frame __user *) |
| 411 | get_sigframe(&ka->sa, regs, sigframe_size); | 381 | get_sigframe(&ka->sa, regs, sigframe_size); |
| 412 | if (invalid_frame_pointer(sf, sigframe_size)) | 382 | if (invalid_frame_pointer(sf, sigframe_size)) |
| 413 | goto sigill; | 383 | goto sigill; |
| 414 | if (current_thread_info()->w_saved != 0) | ||
| 415 | goto sigill; | ||
| 416 | 384 | ||
| 385 | tail = sf + 1; | ||
| 417 | err = __put_user(regs->pc, &sf->regs.pc); | 386 | err = __put_user(regs->pc, &sf->regs.pc); |
| 418 | err |= __put_user(regs->npc, &sf->regs.npc); | 387 | err |= __put_user(regs->npc, &sf->regs.npc); |
| 419 | err |= __put_user(regs->y, &sf->regs.y); | 388 | err |= __put_user(regs->y, &sf->regs.y); |
| @@ -425,11 +394,21 @@ static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 425 | err |= __put_user(0, &sf->extra_size); | 394 | err |= __put_user(0, &sf->extra_size); |
| 426 | 395 | ||
| 427 | if (psr & PSR_EF) { | 396 | if (psr & PSR_EF) { |
| 428 | err |= save_fpu_state(regs, &sf->fpu_state); | 397 | __siginfo_fpu_t *fp = tail; |
| 429 | err |= __put_user(&sf->fpu_state, &sf->fpu_save); | 398 | tail += sizeof(*fp); |
| 399 | err |= save_fpu_state(regs, fp); | ||
| 400 | err |= __put_user(fp, &sf->fpu_save); | ||
| 430 | } else { | 401 | } else { |
| 431 | err |= __put_user(0, &sf->fpu_save); | 402 | err |= __put_user(0, &sf->fpu_save); |
| 432 | } | 403 | } |
| 404 | if (wsaved) { | ||
| 405 | __siginfo_rwin_t *rwp = tail; | ||
| 406 | tail += sizeof(*rwp); | ||
| 407 | err |= save_rwin_state(wsaved, rwp); | ||
| 408 | err |= __put_user(rwp, &sf->rwin_save); | ||
| 409 | } else { | ||
| 410 | err |= __put_user(0, &sf->rwin_save); | ||
| 411 | } | ||
| 433 | err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t)); | 412 | err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t)); |
| 434 | 413 | ||
| 435 | /* Setup sigaltstack */ | 414 | /* Setup sigaltstack */ |
| @@ -437,8 +416,15 @@ static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 437 | err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags); | 416 | err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags); |
| 438 | err |= __put_user(current->sas_ss_size, &sf->stack.ss_size); | 417 | err |= __put_user(current->sas_ss_size, &sf->stack.ss_size); |
| 439 | 418 | ||
| 440 | err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], | 419 | if (!wsaved) { |
| 441 | sizeof(struct reg_window32)); | 420 | err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], |
| 421 | sizeof(struct reg_window32)); | ||
| 422 | } else { | ||
| 423 | struct reg_window32 *rp; | ||
| 424 | |||
| 425 | rp = ¤t_thread_info()->reg_window[wsaved - 1]; | ||
| 426 | err |= __copy_to_user(sf, rp, sizeof(struct reg_window32)); | ||
| 427 | } | ||
| 442 | 428 | ||
| 443 | err |= copy_siginfo_to_user(&sf->info, info); | 429 | err |= copy_siginfo_to_user(&sf->info, info); |
| 444 | 430 | ||
diff --git a/arch/sparc/kernel/signal_64.c b/arch/sparc/kernel/signal_64.c index 006fe4515886..47509df3b893 100644 --- a/arch/sparc/kernel/signal_64.c +++ b/arch/sparc/kernel/signal_64.c | |||
| @@ -34,6 +34,7 @@ | |||
| 34 | 34 | ||
| 35 | #include "entry.h" | 35 | #include "entry.h" |
| 36 | #include "systbls.h" | 36 | #include "systbls.h" |
| 37 | #include "sigutil.h" | ||
| 37 | 38 | ||
| 38 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | 39 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) |
| 39 | 40 | ||
| @@ -236,7 +237,7 @@ struct rt_signal_frame { | |||
| 236 | __siginfo_fpu_t __user *fpu_save; | 237 | __siginfo_fpu_t __user *fpu_save; |
| 237 | stack_t stack; | 238 | stack_t stack; |
| 238 | sigset_t mask; | 239 | sigset_t mask; |
| 239 | __siginfo_fpu_t fpu_state; | 240 | __siginfo_rwin_t *rwin_save; |
| 240 | }; | 241 | }; |
| 241 | 242 | ||
| 242 | static long _sigpause_common(old_sigset_t set) | 243 | static long _sigpause_common(old_sigset_t set) |
| @@ -266,33 +267,12 @@ asmlinkage long sys_sigsuspend(old_sigset_t set) | |||
| 266 | return _sigpause_common(set); | 267 | return _sigpause_common(set); |
| 267 | } | 268 | } |
| 268 | 269 | ||
| 269 | static inline int | ||
| 270 | restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 271 | { | ||
| 272 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 273 | unsigned long fprs; | ||
| 274 | int err; | ||
| 275 | |||
| 276 | err = __get_user(fprs, &fpu->si_fprs); | ||
| 277 | fprs_write(0); | ||
| 278 | regs->tstate &= ~TSTATE_PEF; | ||
| 279 | if (fprs & FPRS_DL) | ||
| 280 | err |= copy_from_user(fpregs, &fpu->si_float_regs[0], | ||
| 281 | (sizeof(unsigned int) * 32)); | ||
| 282 | if (fprs & FPRS_DU) | ||
| 283 | err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], | ||
| 284 | (sizeof(unsigned int) * 32)); | ||
| 285 | err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 286 | err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 287 | current_thread_info()->fpsaved[0] |= fprs; | ||
| 288 | return err; | ||
| 289 | } | ||
| 290 | |||
| 291 | void do_rt_sigreturn(struct pt_regs *regs) | 270 | void do_rt_sigreturn(struct pt_regs *regs) |
| 292 | { | 271 | { |
| 293 | struct rt_signal_frame __user *sf; | 272 | struct rt_signal_frame __user *sf; |
| 294 | unsigned long tpc, tnpc, tstate; | 273 | unsigned long tpc, tnpc, tstate; |
| 295 | __siginfo_fpu_t __user *fpu_save; | 274 | __siginfo_fpu_t __user *fpu_save; |
| 275 | __siginfo_rwin_t __user *rwin_save; | ||
| 296 | sigset_t set; | 276 | sigset_t set; |
| 297 | int err; | 277 | int err; |
| 298 | 278 | ||
| @@ -325,8 +305,8 @@ void do_rt_sigreturn(struct pt_regs *regs) | |||
| 325 | regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); | 305 | regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); |
| 326 | 306 | ||
| 327 | err |= __get_user(fpu_save, &sf->fpu_save); | 307 | err |= __get_user(fpu_save, &sf->fpu_save); |
| 328 | if (fpu_save) | 308 | if (!err && fpu_save) |
| 329 | err |= restore_fpu_state(regs, &sf->fpu_state); | 309 | err |= restore_fpu_state(regs, fpu_save); |
| 330 | 310 | ||
| 331 | err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); | 311 | err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); |
| 332 | err |= do_sigaltstack(&sf->stack, NULL, (unsigned long)sf); | 312 | err |= do_sigaltstack(&sf->stack, NULL, (unsigned long)sf); |
| @@ -334,6 +314,12 @@ void do_rt_sigreturn(struct pt_regs *regs) | |||
| 334 | if (err) | 314 | if (err) |
| 335 | goto segv; | 315 | goto segv; |
| 336 | 316 | ||
| 317 | err |= __get_user(rwin_save, &sf->rwin_save); | ||
| 318 | if (!err && rwin_save) { | ||
| 319 | if (restore_rwin_state(rwin_save)) | ||
| 320 | goto segv; | ||
| 321 | } | ||
| 322 | |||
| 337 | regs->tpc = tpc; | 323 | regs->tpc = tpc; |
| 338 | regs->tnpc = tnpc; | 324 | regs->tnpc = tnpc; |
| 339 | 325 | ||
| @@ -351,34 +337,13 @@ segv: | |||
| 351 | } | 337 | } |
| 352 | 338 | ||
| 353 | /* Checks if the fp is valid */ | 339 | /* Checks if the fp is valid */ |
| 354 | static int invalid_frame_pointer(void __user *fp, int fplen) | 340 | static int invalid_frame_pointer(void __user *fp) |
| 355 | { | 341 | { |
| 356 | if (((unsigned long) fp) & 15) | 342 | if (((unsigned long) fp) & 15) |
| 357 | return 1; | 343 | return 1; |
| 358 | return 0; | 344 | return 0; |
| 359 | } | 345 | } |
| 360 | 346 | ||
| 361 | static inline int | ||
| 362 | save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 363 | { | ||
| 364 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 365 | unsigned long fprs; | ||
| 366 | int err = 0; | ||
| 367 | |||
| 368 | fprs = current_thread_info()->fpsaved[0]; | ||
| 369 | if (fprs & FPRS_DL) | ||
| 370 | err |= copy_to_user(&fpu->si_float_regs[0], fpregs, | ||
| 371 | (sizeof(unsigned int) * 32)); | ||
| 372 | if (fprs & FPRS_DU) | ||
| 373 | err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16, | ||
| 374 | (sizeof(unsigned int) * 32)); | ||
| 375 | err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 376 | err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 377 | err |= __put_user(fprs, &fpu->si_fprs); | ||
| 378 | |||
| 379 | return err; | ||
| 380 | } | ||
| 381 | |||
| 382 | static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize) | 347 | static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize) |
| 383 | { | 348 | { |
| 384 | unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS; | 349 | unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS; |
| @@ -414,34 +379,48 @@ setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 414 | int signo, sigset_t *oldset, siginfo_t *info) | 379 | int signo, sigset_t *oldset, siginfo_t *info) |
| 415 | { | 380 | { |
| 416 | struct rt_signal_frame __user *sf; | 381 | struct rt_signal_frame __user *sf; |
| 417 | int sigframe_size, err; | 382 | int wsaved, err, sf_size; |
| 383 | void __user *tail; | ||
| 418 | 384 | ||
| 419 | /* 1. Make sure everything is clean */ | 385 | /* 1. Make sure everything is clean */ |
| 420 | synchronize_user_stack(); | 386 | synchronize_user_stack(); |
| 421 | save_and_clear_fpu(); | 387 | save_and_clear_fpu(); |
| 422 | 388 | ||
| 423 | sigframe_size = sizeof(struct rt_signal_frame); | 389 | wsaved = get_thread_wsaved(); |
| 424 | if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) | ||
| 425 | sigframe_size -= sizeof(__siginfo_fpu_t); | ||
| 426 | 390 | ||
| 391 | sf_size = sizeof(struct rt_signal_frame); | ||
| 392 | if (current_thread_info()->fpsaved[0] & FPRS_FEF) | ||
| 393 | sf_size += sizeof(__siginfo_fpu_t); | ||
| 394 | if (wsaved) | ||
| 395 | sf_size += sizeof(__siginfo_rwin_t); | ||
| 427 | sf = (struct rt_signal_frame __user *) | 396 | sf = (struct rt_signal_frame __user *) |
| 428 | get_sigframe(ka, regs, sigframe_size); | 397 | get_sigframe(ka, regs, sf_size); |
| 429 | |||
| 430 | if (invalid_frame_pointer (sf, sigframe_size)) | ||
| 431 | goto sigill; | ||
| 432 | 398 | ||
| 433 | if (get_thread_wsaved() != 0) | 399 | if (invalid_frame_pointer (sf)) |
| 434 | goto sigill; | 400 | goto sigill; |
| 435 | 401 | ||
| 402 | tail = (sf + 1); | ||
| 403 | |||
| 436 | /* 2. Save the current process state */ | 404 | /* 2. Save the current process state */ |
| 437 | err = copy_to_user(&sf->regs, regs, sizeof (*regs)); | 405 | err = copy_to_user(&sf->regs, regs, sizeof (*regs)); |
| 438 | 406 | ||
| 439 | if (current_thread_info()->fpsaved[0] & FPRS_FEF) { | 407 | if (current_thread_info()->fpsaved[0] & FPRS_FEF) { |
| 440 | err |= save_fpu_state(regs, &sf->fpu_state); | 408 | __siginfo_fpu_t __user *fpu_save = tail; |
| 441 | err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); | 409 | tail += sizeof(__siginfo_fpu_t); |
| 410 | err |= save_fpu_state(regs, fpu_save); | ||
| 411 | err |= __put_user((u64)fpu_save, &sf->fpu_save); | ||
| 442 | } else { | 412 | } else { |
| 443 | err |= __put_user(0, &sf->fpu_save); | 413 | err |= __put_user(0, &sf->fpu_save); |
| 444 | } | 414 | } |
| 415 | if (wsaved) { | ||
| 416 | __siginfo_rwin_t __user *rwin_save = tail; | ||
| 417 | tail += sizeof(__siginfo_rwin_t); | ||
| 418 | err |= save_rwin_state(wsaved, rwin_save); | ||
| 419 | err |= __put_user((u64)rwin_save, &sf->rwin_save); | ||
| 420 | set_thread_wsaved(0); | ||
| 421 | } else { | ||
| 422 | err |= __put_user(0, &sf->rwin_save); | ||
| 423 | } | ||
| 445 | 424 | ||
| 446 | /* Setup sigaltstack */ | 425 | /* Setup sigaltstack */ |
| 447 | err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp); | 426 | err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp); |
| @@ -450,10 +429,17 @@ setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, | |||
| 450 | 429 | ||
| 451 | err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t)); | 430 | err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t)); |
| 452 | 431 | ||
| 453 | err |= copy_in_user((u64 __user *)sf, | 432 | if (!wsaved) { |
| 454 | (u64 __user *)(regs->u_regs[UREG_FP]+STACK_BIAS), | 433 | err |= copy_in_user((u64 __user *)sf, |
| 455 | sizeof(struct reg_window)); | 434 | (u64 __user *)(regs->u_regs[UREG_FP] + |
| 435 | STACK_BIAS), | ||
| 436 | sizeof(struct reg_window)); | ||
| 437 | } else { | ||
| 438 | struct reg_window *rp; | ||
| 456 | 439 | ||
| 440 | rp = ¤t_thread_info()->reg_window[wsaved - 1]; | ||
| 441 | err |= copy_to_user(sf, rp, sizeof(struct reg_window)); | ||
| 442 | } | ||
| 457 | if (info) | 443 | if (info) |
| 458 | err |= copy_siginfo_to_user(&sf->info, info); | 444 | err |= copy_siginfo_to_user(&sf->info, info); |
| 459 | else { | 445 | else { |
diff --git a/arch/sparc/kernel/sigutil.h b/arch/sparc/kernel/sigutil.h new file mode 100644 index 000000000000..d223aa432bb6 --- /dev/null +++ b/arch/sparc/kernel/sigutil.h | |||
| @@ -0,0 +1,9 @@ | |||
| 1 | #ifndef _SIGUTIL_H | ||
| 2 | #define _SIGUTIL_H | ||
| 3 | |||
| 4 | int save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu); | ||
| 5 | int restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu); | ||
| 6 | int save_rwin_state(int wsaved, __siginfo_rwin_t __user *rwin); | ||
| 7 | int restore_rwin_state(__siginfo_rwin_t __user *rp); | ||
| 8 | |||
| 9 | #endif /* _SIGUTIL_H */ | ||
diff --git a/arch/sparc/kernel/sigutil_32.c b/arch/sparc/kernel/sigutil_32.c new file mode 100644 index 000000000000..35c7897b009a --- /dev/null +++ b/arch/sparc/kernel/sigutil_32.c | |||
| @@ -0,0 +1,120 @@ | |||
| 1 | #include <linux/kernel.h> | ||
| 2 | #include <linux/types.h> | ||
| 3 | #include <linux/thread_info.h> | ||
| 4 | #include <linux/uaccess.h> | ||
| 5 | #include <linux/sched.h> | ||
| 6 | |||
| 7 | #include <asm/sigcontext.h> | ||
| 8 | #include <asm/fpumacro.h> | ||
| 9 | #include <asm/ptrace.h> | ||
| 10 | |||
| 11 | #include "sigutil.h" | ||
| 12 | |||
| 13 | int save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 14 | { | ||
| 15 | int err = 0; | ||
| 16 | #ifdef CONFIG_SMP | ||
| 17 | if (test_tsk_thread_flag(current, TIF_USEDFPU)) { | ||
| 18 | put_psr(get_psr() | PSR_EF); | ||
| 19 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, | ||
| 20 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); | ||
| 21 | regs->psr &= ~(PSR_EF); | ||
| 22 | clear_tsk_thread_flag(current, TIF_USEDFPU); | ||
| 23 | } | ||
| 24 | #else | ||
| 25 | if (current == last_task_used_math) { | ||
| 26 | put_psr(get_psr() | PSR_EF); | ||
| 27 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, | ||
| 28 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); | ||
| 29 | last_task_used_math = NULL; | ||
| 30 | regs->psr &= ~(PSR_EF); | ||
| 31 | } | ||
| 32 | #endif | ||
| 33 | err |= __copy_to_user(&fpu->si_float_regs[0], | ||
| 34 | ¤t->thread.float_regs[0], | ||
| 35 | (sizeof(unsigned long) * 32)); | ||
| 36 | err |= __put_user(current->thread.fsr, &fpu->si_fsr); | ||
| 37 | err |= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth); | ||
| 38 | if (current->thread.fpqdepth != 0) | ||
| 39 | err |= __copy_to_user(&fpu->si_fpqueue[0], | ||
| 40 | ¤t->thread.fpqueue[0], | ||
| 41 | ((sizeof(unsigned long) + | ||
| 42 | (sizeof(unsigned long *)))*16)); | ||
| 43 | clear_used_math(); | ||
| 44 | return err; | ||
| 45 | } | ||
| 46 | |||
| 47 | int restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 48 | { | ||
| 49 | int err; | ||
| 50 | #ifdef CONFIG_SMP | ||
| 51 | if (test_tsk_thread_flag(current, TIF_USEDFPU)) | ||
| 52 | regs->psr &= ~PSR_EF; | ||
| 53 | #else | ||
| 54 | if (current == last_task_used_math) { | ||
| 55 | last_task_used_math = NULL; | ||
| 56 | regs->psr &= ~PSR_EF; | ||
| 57 | } | ||
| 58 | #endif | ||
| 59 | set_used_math(); | ||
| 60 | clear_tsk_thread_flag(current, TIF_USEDFPU); | ||
| 61 | |||
| 62 | if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu))) | ||
| 63 | return -EFAULT; | ||
| 64 | |||
| 65 | err = __copy_from_user(¤t->thread.float_regs[0], &fpu->si_float_regs[0], | ||
| 66 | (sizeof(unsigned long) * 32)); | ||
| 67 | err |= __get_user(current->thread.fsr, &fpu->si_fsr); | ||
| 68 | err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth); | ||
| 69 | if (current->thread.fpqdepth != 0) | ||
| 70 | err |= __copy_from_user(¤t->thread.fpqueue[0], | ||
| 71 | &fpu->si_fpqueue[0], | ||
| 72 | ((sizeof(unsigned long) + | ||
| 73 | (sizeof(unsigned long *)))*16)); | ||
| 74 | return err; | ||
| 75 | } | ||
| 76 | |||
| 77 | int save_rwin_state(int wsaved, __siginfo_rwin_t __user *rwin) | ||
| 78 | { | ||
| 79 | int i, err = __put_user(wsaved, &rwin->wsaved); | ||
| 80 | |||
| 81 | for (i = 0; i < wsaved; i++) { | ||
| 82 | struct reg_window32 *rp; | ||
| 83 | unsigned long fp; | ||
| 84 | |||
| 85 | rp = ¤t_thread_info()->reg_window[i]; | ||
| 86 | fp = current_thread_info()->rwbuf_stkptrs[i]; | ||
| 87 | err |= copy_to_user(&rwin->reg_window[i], rp, | ||
| 88 | sizeof(struct reg_window32)); | ||
| 89 | err |= __put_user(fp, &rwin->rwbuf_stkptrs[i]); | ||
| 90 | } | ||
| 91 | return err; | ||
| 92 | } | ||
| 93 | |||
| 94 | int restore_rwin_state(__siginfo_rwin_t __user *rp) | ||
| 95 | { | ||
| 96 | struct thread_info *t = current_thread_info(); | ||
| 97 | int i, wsaved, err; | ||
| 98 | |||
| 99 | __get_user(wsaved, &rp->wsaved); | ||
| 100 | if (wsaved > NSWINS) | ||
| 101 | return -EFAULT; | ||
| 102 | |||
| 103 | err = 0; | ||
| 104 | for (i = 0; i < wsaved; i++) { | ||
| 105 | err |= copy_from_user(&t->reg_window[i], | ||
| 106 | &rp->reg_window[i], | ||
| 107 | sizeof(struct reg_window32)); | ||
| 108 | err |= __get_user(t->rwbuf_stkptrs[i], | ||
| 109 | &rp->rwbuf_stkptrs[i]); | ||
| 110 | } | ||
| 111 | if (err) | ||
| 112 | return err; | ||
| 113 | |||
| 114 | t->w_saved = wsaved; | ||
| 115 | synchronize_user_stack(); | ||
| 116 | if (t->w_saved) | ||
| 117 | return -EFAULT; | ||
| 118 | return 0; | ||
| 119 | |||
| 120 | } | ||
diff --git a/arch/sparc/kernel/sigutil_64.c b/arch/sparc/kernel/sigutil_64.c new file mode 100644 index 000000000000..e7dc508c38eb --- /dev/null +++ b/arch/sparc/kernel/sigutil_64.c | |||
| @@ -0,0 +1,93 @@ | |||
| 1 | #include <linux/kernel.h> | ||
| 2 | #include <linux/types.h> | ||
| 3 | #include <linux/thread_info.h> | ||
| 4 | #include <linux/uaccess.h> | ||
| 5 | |||
| 6 | #include <asm/sigcontext.h> | ||
| 7 | #include <asm/fpumacro.h> | ||
| 8 | #include <asm/ptrace.h> | ||
| 9 | |||
| 10 | #include "sigutil.h" | ||
| 11 | |||
| 12 | int save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 13 | { | ||
| 14 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 15 | unsigned long fprs; | ||
| 16 | int err = 0; | ||
| 17 | |||
| 18 | fprs = current_thread_info()->fpsaved[0]; | ||
| 19 | if (fprs & FPRS_DL) | ||
| 20 | err |= copy_to_user(&fpu->si_float_regs[0], fpregs, | ||
| 21 | (sizeof(unsigned int) * 32)); | ||
| 22 | if (fprs & FPRS_DU) | ||
| 23 | err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16, | ||
| 24 | (sizeof(unsigned int) * 32)); | ||
| 25 | err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 26 | err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 27 | err |= __put_user(fprs, &fpu->si_fprs); | ||
| 28 | |||
| 29 | return err; | ||
| 30 | } | ||
| 31 | |||
| 32 | int restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) | ||
| 33 | { | ||
| 34 | unsigned long *fpregs = current_thread_info()->fpregs; | ||
| 35 | unsigned long fprs; | ||
| 36 | int err; | ||
| 37 | |||
| 38 | err = __get_user(fprs, &fpu->si_fprs); | ||
| 39 | fprs_write(0); | ||
| 40 | regs->tstate &= ~TSTATE_PEF; | ||
| 41 | if (fprs & FPRS_DL) | ||
| 42 | err |= copy_from_user(fpregs, &fpu->si_float_regs[0], | ||
| 43 | (sizeof(unsigned int) * 32)); | ||
| 44 | if (fprs & FPRS_DU) | ||
| 45 | err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], | ||
| 46 | (sizeof(unsigned int) * 32)); | ||
| 47 | err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr); | ||
| 48 | err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr); | ||
| 49 | current_thread_info()->fpsaved[0] |= fprs; | ||
| 50 | return err; | ||
| 51 | } | ||
| 52 | |||
| 53 | int save_rwin_state(int wsaved, __siginfo_rwin_t __user *rwin) | ||
| 54 | { | ||
| 55 | int i, err = __put_user(wsaved, &rwin->wsaved); | ||
| 56 | |||
| 57 | for (i = 0; i < wsaved; i++) { | ||
| 58 | struct reg_window *rp = ¤t_thread_info()->reg_window[i]; | ||
| 59 | unsigned long fp = current_thread_info()->rwbuf_stkptrs[i]; | ||
| 60 | |||
| 61 | err |= copy_to_user(&rwin->reg_window[i], rp, | ||
| 62 | sizeof(struct reg_window)); | ||
| 63 | err |= __put_user(fp, &rwin->rwbuf_stkptrs[i]); | ||
| 64 | } | ||
| 65 | return err; | ||
| 66 | } | ||
| 67 | |||
| 68 | int restore_rwin_state(__siginfo_rwin_t __user *rp) | ||
| 69 | { | ||
| 70 | struct thread_info *t = current_thread_info(); | ||
| 71 | int i, wsaved, err; | ||
| 72 | |||
| 73 | __get_user(wsaved, &rp->wsaved); | ||
| 74 | if (wsaved > NSWINS) | ||
| 75 | return -EFAULT; | ||
| 76 | |||
| 77 | err = 0; | ||
| 78 | for (i = 0; i < wsaved; i++) { | ||
| 79 | err |= copy_from_user(&t->reg_window[i], | ||
| 80 | &rp->reg_window[i], | ||
| 81 | sizeof(struct reg_window)); | ||
| 82 | err |= __get_user(t->rwbuf_stkptrs[i], | ||
| 83 | &rp->rwbuf_stkptrs[i]); | ||
| 84 | } | ||
| 85 | if (err) | ||
| 86 | return err; | ||
| 87 | |||
| 88 | set_thread_wsaved(wsaved); | ||
| 89 | synchronize_user_stack(); | ||
| 90 | if (get_thread_wsaved()) | ||
| 91 | return -EFAULT; | ||
| 92 | return 0; | ||
| 93 | } | ||
diff --git a/arch/sparc/kernel/sys32.S b/arch/sparc/kernel/sys32.S index 44e5faf1ad5f..d97f3eb72e06 100644 --- a/arch/sparc/kernel/sys32.S +++ b/arch/sparc/kernel/sys32.S | |||
| @@ -81,7 +81,6 @@ SIGN2(sys32_fadvise64, compat_sys_fadvise64, %o0, %o4) | |||
| 81 | SIGN2(sys32_fadvise64_64, compat_sys_fadvise64_64, %o0, %o5) | 81 | SIGN2(sys32_fadvise64_64, compat_sys_fadvise64_64, %o0, %o5) |
| 82 | SIGN2(sys32_bdflush, sys_bdflush, %o0, %o1) | 82 | SIGN2(sys32_bdflush, sys_bdflush, %o0, %o1) |
| 83 | SIGN1(sys32_mlockall, sys_mlockall, %o0) | 83 | SIGN1(sys32_mlockall, sys_mlockall, %o0) |
| 84 | SIGN1(sys32_nfsservctl, compat_sys_nfsservctl, %o0) | ||
| 85 | SIGN1(sys32_clock_nanosleep, compat_sys_clock_nanosleep, %o1) | 84 | SIGN1(sys32_clock_nanosleep, compat_sys_clock_nanosleep, %o1) |
| 86 | SIGN1(sys32_timer_settime, compat_sys_timer_settime, %o1) | 85 | SIGN1(sys32_timer_settime, compat_sys_timer_settime, %o1) |
| 87 | SIGN1(sys32_io_submit, compat_sys_io_submit, %o1) | 86 | SIGN1(sys32_io_submit, compat_sys_io_submit, %o1) |
diff --git a/arch/sparc/kernel/systbls_32.S b/arch/sparc/kernel/systbls_32.S index 6e492d59f6b1..09d8ec454450 100644 --- a/arch/sparc/kernel/systbls_32.S +++ b/arch/sparc/kernel/systbls_32.S | |||
| @@ -67,7 +67,7 @@ sys_call_table: | |||
| 67 | /*235*/ .long sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall | 67 | /*235*/ .long sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall |
| 68 | /*240*/ .long sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler | 68 | /*240*/ .long sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler |
| 69 | /*245*/ .long sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep | 69 | /*245*/ .long sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep |
| 70 | /*250*/ .long sys_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl | 70 | /*250*/ .long sys_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_ni_syscall |
| 71 | /*255*/ .long sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep | 71 | /*255*/ .long sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep |
| 72 | /*260*/ .long sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun | 72 | /*260*/ .long sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun |
| 73 | /*265*/ .long sys_timer_delete, sys_timer_create, sys_nis_syscall, sys_io_setup, sys_io_destroy | 73 | /*265*/ .long sys_timer_delete, sys_timer_create, sys_nis_syscall, sys_io_setup, sys_io_destroy |
diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S index f566518483b5..c9296ab0b1f4 100644 --- a/arch/sparc/kernel/systbls_64.S +++ b/arch/sparc/kernel/systbls_64.S | |||
| @@ -145,7 +145,7 @@ sys_call_table: | |||
| 145 | .word sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall | 145 | .word sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall |
| 146 | /*240*/ .word sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler | 146 | /*240*/ .word sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler |
| 147 | .word sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep | 147 | .word sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep |
| 148 | /*250*/ .word sys_64_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl | 148 | /*250*/ .word sys_64_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nis_syscall |
| 149 | .word sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep | 149 | .word sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep |
| 150 | /*260*/ .word sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun | 150 | /*260*/ .word sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun |
| 151 | .word sys_timer_delete, sys_timer_create, sys_ni_syscall, sys_io_setup, sys_io_destroy | 151 | .word sys_timer_delete, sys_timer_create, sys_ni_syscall, sys_io_setup, sys_io_destroy |
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S index a0e866d233ee..54edb207ff3a 100644 --- a/arch/x86/ia32/ia32entry.S +++ b/arch/x86/ia32/ia32entry.S | |||
| @@ -672,7 +672,7 @@ ia32_sys_call_table: | |||
| 672 | .quad sys32_vm86_warning /* vm86 */ | 672 | .quad sys32_vm86_warning /* vm86 */ |
| 673 | .quad quiet_ni_syscall /* query_module */ | 673 | .quad quiet_ni_syscall /* query_module */ |
| 674 | .quad sys_poll | 674 | .quad sys_poll |
| 675 | .quad compat_sys_nfsservctl | 675 | .quad quiet_ni_syscall /* old nfsservctl */ |
| 676 | .quad sys_setresgid16 /* 170 */ | 676 | .quad sys_setresgid16 /* 170 */ |
| 677 | .quad sys_getresgid16 | 677 | .quad sys_getresgid16 |
| 678 | .quad sys_prctl | 678 | .quad sys_prctl |
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h index d92641cc7acc..201040573444 100644 --- a/arch/x86/include/asm/unistd_64.h +++ b/arch/x86/include/asm/unistd_64.h | |||
| @@ -414,7 +414,7 @@ __SYSCALL(__NR_query_module, sys_ni_syscall) | |||
| 414 | __SYSCALL(__NR_quotactl, sys_quotactl) | 414 | __SYSCALL(__NR_quotactl, sys_quotactl) |
| 415 | 415 | ||
| 416 | #define __NR_nfsservctl 180 | 416 | #define __NR_nfsservctl 180 |
| 417 | __SYSCALL(__NR_nfsservctl, sys_nfsservctl) | 417 | __SYSCALL(__NR_nfsservctl, sys_ni_syscall) |
| 418 | 418 | ||
| 419 | /* reserved for LiS/STREAMS */ | 419 | /* reserved for LiS/STREAMS */ |
| 420 | #define __NR_getpmsg 181 | 420 | #define __NR_getpmsg 181 |
diff --git a/arch/x86/kernel/apic/x2apic_uv_x.c b/arch/x86/kernel/apic/x2apic_uv_x.c index adc66c3a1fef..34b18594e724 100644 --- a/arch/x86/kernel/apic/x2apic_uv_x.c +++ b/arch/x86/kernel/apic/x2apic_uv_x.c | |||
| @@ -207,7 +207,6 @@ static int __cpuinit uv_wakeup_secondary(int phys_apicid, unsigned long start_ri | |||
| 207 | ((start_rip << UVH_IPI_INT_VECTOR_SHFT) >> 12) | | 207 | ((start_rip << UVH_IPI_INT_VECTOR_SHFT) >> 12) | |
| 208 | APIC_DM_INIT; | 208 | APIC_DM_INIT; |
| 209 | uv_write_global_mmr64(pnode, UVH_IPI_INT, val); | 209 | uv_write_global_mmr64(pnode, UVH_IPI_INT, val); |
| 210 | mdelay(10); | ||
| 211 | 210 | ||
| 212 | val = (1UL << UVH_IPI_INT_SEND_SHFT) | | 211 | val = (1UL << UVH_IPI_INT_SEND_SHFT) | |
| 213 | (phys_apicid << UVH_IPI_INT_APIC_ID_SHFT) | | 212 | (phys_apicid << UVH_IPI_INT_APIC_ID_SHFT) | |
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c index 08119a37e53c..6b96110bb0c3 100644 --- a/arch/x86/kernel/cpu/mtrr/main.c +++ b/arch/x86/kernel/cpu/mtrr/main.c | |||
| @@ -149,7 +149,6 @@ struct set_mtrr_data { | |||
| 149 | */ | 149 | */ |
| 150 | static int mtrr_rendezvous_handler(void *info) | 150 | static int mtrr_rendezvous_handler(void *info) |
| 151 | { | 151 | { |
| 152 | #ifdef CONFIG_SMP | ||
| 153 | struct set_mtrr_data *data = info; | 152 | struct set_mtrr_data *data = info; |
| 154 | 153 | ||
| 155 | /* | 154 | /* |
| @@ -171,7 +170,6 @@ static int mtrr_rendezvous_handler(void *info) | |||
| 171 | } else if (mtrr_aps_delayed_init || !cpu_online(smp_processor_id())) { | 170 | } else if (mtrr_aps_delayed_init || !cpu_online(smp_processor_id())) { |
| 172 | mtrr_if->set_all(); | 171 | mtrr_if->set_all(); |
| 173 | } | 172 | } |
| 174 | #endif | ||
| 175 | return 0; | 173 | return 0; |
| 176 | } | 174 | } |
| 177 | 175 | ||
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S index 5c1a91974918..f3f6f5344001 100644 --- a/arch/x86/kernel/entry_32.S +++ b/arch/x86/kernel/entry_32.S | |||
| @@ -54,6 +54,7 @@ | |||
| 54 | #include <asm/ftrace.h> | 54 | #include <asm/ftrace.h> |
| 55 | #include <asm/irq_vectors.h> | 55 | #include <asm/irq_vectors.h> |
| 56 | #include <asm/cpufeature.h> | 56 | #include <asm/cpufeature.h> |
| 57 | #include <asm/alternative-asm.h> | ||
| 57 | 58 | ||
| 58 | /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this. */ | 59 | /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this. */ |
| 59 | #include <linux/elf-em.h> | 60 | #include <linux/elf-em.h> |
| @@ -873,12 +874,7 @@ ENTRY(simd_coprocessor_error) | |||
| 873 | 661: pushl_cfi $do_general_protection | 874 | 661: pushl_cfi $do_general_protection |
| 874 | 662: | 875 | 662: |
| 875 | .section .altinstructions,"a" | 876 | .section .altinstructions,"a" |
| 876 | .balign 4 | 877 | altinstruction_entry 661b, 663f, X86_FEATURE_XMM, 662b-661b, 664f-663f |
| 877 | .long 661b | ||
| 878 | .long 663f | ||
| 879 | .word X86_FEATURE_XMM | ||
| 880 | .byte 662b-661b | ||
| 881 | .byte 664f-663f | ||
| 882 | .previous | 878 | .previous |
| 883 | .section .altinstr_replacement,"ax" | 879 | .section .altinstr_replacement,"ax" |
| 884 | 663: pushl $do_simd_coprocessor_error | 880 | 663: pushl $do_simd_coprocessor_error |
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S index fbb0a045a1a2..bc19be332bc9 100644 --- a/arch/x86/kernel/syscall_table_32.S +++ b/arch/x86/kernel/syscall_table_32.S | |||
| @@ -168,7 +168,7 @@ ENTRY(sys_call_table) | |||
| 168 | .long ptregs_vm86 | 168 | .long ptregs_vm86 |
| 169 | .long sys_ni_syscall /* Old sys_query_module */ | 169 | .long sys_ni_syscall /* Old sys_query_module */ |
| 170 | .long sys_poll | 170 | .long sys_poll |
| 171 | .long sys_nfsservctl | 171 | .long sys_ni_syscall /* Old nfsservctl */ |
| 172 | .long sys_setresgid16 /* 170 */ | 172 | .long sys_setresgid16 /* 170 */ |
| 173 | .long sys_getresgid16 | 173 | .long sys_getresgid16 |
| 174 | .long sys_prctl | 174 | .long sys_prctl |
diff --git a/arch/x86/platform/mrst/mrst.c b/arch/x86/platform/mrst/mrst.c index 7000e74b3087..58425adc22c6 100644 --- a/arch/x86/platform/mrst/mrst.c +++ b/arch/x86/platform/mrst/mrst.c | |||
| @@ -689,7 +689,9 @@ static int __init sfi_parse_devs(struct sfi_table_header *table) | |||
| 689 | irq_attr.trigger = 1; | 689 | irq_attr.trigger = 1; |
| 690 | irq_attr.polarity = 1; | 690 | irq_attr.polarity = 1; |
| 691 | io_apic_set_pci_routing(NULL, pentry->irq, &irq_attr); | 691 | io_apic_set_pci_routing(NULL, pentry->irq, &irq_attr); |
| 692 | } | 692 | } else |
| 693 | pentry->irq = 0; /* No irq */ | ||
| 694 | |||
| 693 | switch (pentry->type) { | 695 | switch (pentry->type) { |
| 694 | case SFI_DEV_TYPE_IPC: | 696 | case SFI_DEV_TYPE_IPC: |
| 695 | /* ID as IRQ is a hack that will go away */ | 697 | /* ID as IRQ is a hack that will go away */ |
diff --git a/arch/x86/platform/olpc/olpc.c b/arch/x86/platform/olpc/olpc.c index 8b9940e78e2f..7cce722667b8 100644 --- a/arch/x86/platform/olpc/olpc.c +++ b/arch/x86/platform/olpc/olpc.c | |||
| @@ -161,13 +161,13 @@ restart: | |||
| 161 | if (inbuf && inlen) { | 161 | if (inbuf && inlen) { |
| 162 | /* write data to EC */ | 162 | /* write data to EC */ |
| 163 | for (i = 0; i < inlen; i++) { | 163 | for (i = 0; i < inlen; i++) { |
| 164 | pr_devel("olpc-ec: sending cmd arg 0x%x\n", inbuf[i]); | ||
| 165 | outb(inbuf[i], 0x68); | ||
| 164 | if (wait_on_ibf(0x6c, 0)) { | 166 | if (wait_on_ibf(0x6c, 0)) { |
| 165 | printk(KERN_ERR "olpc-ec: timeout waiting for" | 167 | printk(KERN_ERR "olpc-ec: timeout waiting for" |
| 166 | " EC accept data!\n"); | 168 | " EC accept data!\n"); |
| 167 | goto err; | 169 | goto err; |
| 168 | } | 170 | } |
| 169 | pr_devel("olpc-ec: sending cmd arg 0x%x\n", inbuf[i]); | ||
| 170 | outb(inbuf[i], 0x68); | ||
| 171 | } | 171 | } |
| 172 | } | 172 | } |
| 173 | if (outbuf && outlen) { | 173 | if (outbuf && outlen) { |
diff --git a/arch/x86/vdso/vdso32/sysenter.S b/arch/x86/vdso/vdso32/sysenter.S index e2800affa754..e354bceee0e0 100644 --- a/arch/x86/vdso/vdso32/sysenter.S +++ b/arch/x86/vdso/vdso32/sysenter.S | |||
| @@ -43,7 +43,7 @@ __kernel_vsyscall: | |||
| 43 | .space 7,0x90 | 43 | .space 7,0x90 |
| 44 | 44 | ||
| 45 | /* 14: System call restart point is here! (SYSENTER_RETURN-2) */ | 45 | /* 14: System call restart point is here! (SYSENTER_RETURN-2) */ |
| 46 | jmp .Lenter_kernel | 46 | int $0x80 |
| 47 | /* 16: System call normal return point is here! */ | 47 | /* 16: System call normal return point is here! */ |
| 48 | VDSO32_SYSENTER_RETURN: /* Symbol used by sysenter.c via vdso32-syms.h */ | 48 | VDSO32_SYSENTER_RETURN: /* Symbol used by sysenter.c via vdso32-syms.h */ |
| 49 | pop %ebp | 49 | pop %ebp |
diff --git a/arch/xtensa/include/asm/unistd.h b/arch/xtensa/include/asm/unistd.h index a6f934f37f1a..798ee6d285a1 100644 --- a/arch/xtensa/include/asm/unistd.h +++ b/arch/xtensa/include/asm/unistd.h | |||
| @@ -455,7 +455,7 @@ __SYSCALL(203, sys_reboot, 3) | |||
| 455 | #define __NR_quotactl 204 | 455 | #define __NR_quotactl 204 |
| 456 | __SYSCALL(204, sys_quotactl, 4) | 456 | __SYSCALL(204, sys_quotactl, 4) |
| 457 | #define __NR_nfsservctl 205 | 457 | #define __NR_nfsservctl 205 |
| 458 | __SYSCALL(205, sys_nfsservctl, 3) | 458 | __SYSCALL(205, sys_ni_syscall, 0) |
| 459 | #define __NR__sysctl 206 | 459 | #define __NR__sysctl 206 |
| 460 | __SYSCALL(206, sys_sysctl, 1) | 460 | __SYSCALL(206, sys_sysctl, 1) |
| 461 | #define __NR_bdflush 207 | 461 | #define __NR_bdflush 207 |
