diff options
145 files changed, 6465 insertions, 3583 deletions
diff --git a/Documentation/x86/earlyprintk.txt b/Documentation/x86/earlyprintk.txt new file mode 100644 index 000000000000..607b1a016064 --- /dev/null +++ b/Documentation/x86/earlyprintk.txt | |||
| @@ -0,0 +1,101 @@ | |||
| 1 | |||
| 2 | Mini-HOWTO for using the earlyprintk=dbgp boot option with a | ||
| 3 | USB2 Debug port key and a debug cable, on x86 systems. | ||
| 4 | |||
| 5 | You need two computers, the 'USB debug key' special gadget and | ||
| 6 | and two USB cables, connected like this: | ||
| 7 | |||
| 8 | [host/target] <-------> [USB debug key] <-------> [client/console] | ||
| 9 | |||
| 10 | 1. There are three specific hardware requirements: | ||
| 11 | |||
| 12 | a.) Host/target system needs to have USB debug port capability. | ||
| 13 | |||
| 14 | You can check this capability by looking at a 'Debug port' bit in | ||
| 15 | the lspci -vvv output: | ||
| 16 | |||
| 17 | # lspci -vvv | ||
| 18 | ... | ||
| 19 | 00:1d.7 USB Controller: Intel Corporation 82801H (ICH8 Family) USB2 EHCI Controller #1 (rev 03) (prog-if 20 [EHCI]) | ||
| 20 | Subsystem: Lenovo ThinkPad T61 | ||
| 21 | Control: I/O- Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR+ FastB2B- DisINTx- | ||
| 22 | Status: Cap+ 66MHz- UDF- FastB2B+ ParErr- DEVSEL=medium >TAbort- <TAbort- <MAbort- >SERR- <PERR- INTx- | ||
| 23 | Latency: 0 | ||
| 24 | Interrupt: pin D routed to IRQ 19 | ||
| 25 | Region 0: Memory at fe227000 (32-bit, non-prefetchable) [size=1K] | ||
| 26 | Capabilities: [50] Power Management version 2 | ||
| 27 | Flags: PMEClk- DSI- D1- D2- AuxCurrent=375mA PME(D0+,D1-,D2-,D3hot+,D3cold+) | ||
| 28 | Status: D0 PME-Enable- DSel=0 DScale=0 PME+ | ||
| 29 | Capabilities: [58] Debug port: BAR=1 offset=00a0 | ||
| 30 | ^^^^^^^^^^^ <==================== [ HERE ] | ||
| 31 | Kernel driver in use: ehci_hcd | ||
| 32 | Kernel modules: ehci-hcd | ||
| 33 | ... | ||
| 34 | |||
| 35 | ( If your system does not list a debug port capability then you probably | ||
| 36 | wont be able to use the USB debug key. ) | ||
| 37 | |||
| 38 | b.) You also need a Netchip USB debug cable/key: | ||
| 39 | |||
| 40 | http://www.plxtech.com/products/NET2000/NET20DC/default.asp | ||
| 41 | |||
| 42 | This is a small blue plastic connector with two USB connections, | ||
| 43 | it draws power from its USB connections. | ||
| 44 | |||
| 45 | c.) Thirdly, you need a second client/console system with a regular USB port. | ||
| 46 | |||
| 47 | 2. Software requirements: | ||
| 48 | |||
| 49 | a.) On the host/target system: | ||
| 50 | |||
| 51 | You need to enable the following kernel config option: | ||
| 52 | |||
| 53 | CONFIG_EARLY_PRINTK_DBGP=y | ||
| 54 | |||
| 55 | And you need to add the boot command line: "earlyprintk=dbgp". | ||
| 56 | (If you are using Grub, append it to the 'kernel' line in | ||
| 57 | /etc/grub.conf) | ||
| 58 | |||
| 59 | NOTE: normally earlyprintk console gets turned off once the | ||
| 60 | regular console is alive - use "earlyprintk=dbgp,keep" to keep | ||
| 61 | this channel open beyond early bootup. This can be useful for | ||
| 62 | debugging crashes under Xorg, etc. | ||
| 63 | |||
| 64 | b.) On the client/console system: | ||
| 65 | |||
| 66 | You should enable the following kernel config option: | ||
| 67 | |||
| 68 | CONFIG_USB_SERIAL_DEBUG=y | ||
| 69 | |||
| 70 | On the next bootup with the modified kernel you should | ||
| 71 | get a /dev/ttyUSBx device(s). | ||
| 72 | |||
| 73 | Now this channel of kernel messages is ready to be used: start | ||
| 74 | your favorite terminal emulator (minicom, etc.) and set | ||
| 75 | it up to use /dev/ttyUSB0 - or use a raw 'cat /dev/ttyUSBx' to | ||
| 76 | see the raw output. | ||
| 77 | |||
| 78 | c.) On Nvidia Southbridge based systems: the kernel will try to probe | ||
| 79 | and find out which port has debug device connected. | ||
| 80 | |||
| 81 | 3. Testing that it works fine: | ||
| 82 | |||
| 83 | You can test the output by using earlyprintk=dbgp,keep and provoking | ||
| 84 | kernel messages on the host/target system. You can provoke a harmless | ||
| 85 | kernel message by for example doing: | ||
| 86 | |||
| 87 | echo h > /proc/sysrq-trigger | ||
| 88 | |||
| 89 | On the host/target system you should see this help line in "dmesg" output: | ||
| 90 | |||
| 91 | SysRq : HELP : loglevel(0-9) reBoot Crashdump terminate-all-tasks(E) memory-full-oom-kill(F) kill-all-tasks(I) saK show-backtrace-all-active-cpus(L) show-memory-usage(M) nice-all-RT-tasks(N) powerOff show-registers(P) show-all-timers(Q) unRaw Sync show-task-states(T) Unmount show-blocked-tasks(W) dump-ftrace-buffer(Z) | ||
| 92 | |||
| 93 | On the client/console system do: | ||
| 94 | |||
| 95 | cat /dev/ttyUSB0 | ||
| 96 | |||
| 97 | And you should see the help line above displayed shortly after you've | ||
| 98 | provoked it on the host system. | ||
| 99 | |||
| 100 | If it does not work then please ask about it on the linux-kernel@vger.kernel.org | ||
| 101 | mailing list or contact the x86 maintainers. | ||
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 06c02c00d7d9..34bc3a89228b 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig | |||
| @@ -786,6 +786,11 @@ config X86_MCE_AMD | |||
| 786 | Additional support for AMD specific MCE features such as | 786 | Additional support for AMD specific MCE features such as |
| 787 | the DRAM Error Threshold. | 787 | the DRAM Error Threshold. |
| 788 | 788 | ||
| 789 | config X86_MCE_THRESHOLD | ||
| 790 | depends on X86_MCE_AMD || X86_MCE_INTEL | ||
| 791 | bool | ||
| 792 | default y | ||
| 793 | |||
| 789 | config X86_MCE_NONFATAL | 794 | config X86_MCE_NONFATAL |
| 790 | tristate "Check for non-fatal errors on AMD Athlon/Duron / Intel Pentium 4" | 795 | tristate "Check for non-fatal errors on AMD Athlon/Duron / Intel Pentium 4" |
| 791 | depends on X86_32 && X86_MCE | 796 | depends on X86_32 && X86_MCE |
| @@ -929,6 +934,12 @@ config X86_CPUID | |||
| 929 | with major 203 and minors 0 to 31 for /dev/cpu/0/cpuid to | 934 | with major 203 and minors 0 to 31 for /dev/cpu/0/cpuid to |
| 930 | /dev/cpu/31/cpuid. | 935 | /dev/cpu/31/cpuid. |
| 931 | 936 | ||
| 937 | config X86_CPU_DEBUG | ||
| 938 | tristate "/sys/kernel/debug/x86/cpu/* - CPU Debug support" | ||
| 939 | ---help--- | ||
| 940 | If you select this option, this will provide various x86 CPUs | ||
| 941 | information through debugfs. | ||
| 942 | |||
| 932 | choice | 943 | choice |
| 933 | prompt "High Memory Support" | 944 | prompt "High Memory Support" |
| 934 | default HIGHMEM4G if !X86_NUMAQ | 945 | default HIGHMEM4G if !X86_NUMAQ |
| @@ -1121,7 +1132,7 @@ config NUMA_EMU | |||
| 1121 | 1132 | ||
| 1122 | config NODES_SHIFT | 1133 | config NODES_SHIFT |
| 1123 | int "Maximum NUMA Nodes (as a power of 2)" if !MAXSMP | 1134 | int "Maximum NUMA Nodes (as a power of 2)" if !MAXSMP |
| 1124 | range 1 9 if X86_64 | 1135 | range 1 9 |
| 1125 | default "9" if MAXSMP | 1136 | default "9" if MAXSMP |
| 1126 | default "6" if X86_64 | 1137 | default "6" if X86_64 |
| 1127 | default "4" if X86_NUMAQ | 1138 | default "4" if X86_NUMAQ |
| @@ -1429,7 +1440,7 @@ config CRASH_DUMP | |||
| 1429 | config KEXEC_JUMP | 1440 | config KEXEC_JUMP |
| 1430 | bool "kexec jump (EXPERIMENTAL)" | 1441 | bool "kexec jump (EXPERIMENTAL)" |
| 1431 | depends on EXPERIMENTAL | 1442 | depends on EXPERIMENTAL |
| 1432 | depends on KEXEC && HIBERNATION && X86_32 | 1443 | depends on KEXEC && HIBERNATION |
| 1433 | ---help--- | 1444 | ---help--- |
| 1434 | Jump between original kernel and kexeced kernel and invoke | 1445 | Jump between original kernel and kexeced kernel and invoke |
| 1435 | code in physical address mode via KEXEC | 1446 | code in physical address mode via KEXEC |
diff --git a/arch/x86/Kconfig.cpu b/arch/x86/Kconfig.cpu index a95eaf0e582a..924e156a85ab 100644 --- a/arch/x86/Kconfig.cpu +++ b/arch/x86/Kconfig.cpu | |||
| @@ -456,24 +456,9 @@ config CPU_SUP_AMD | |||
| 456 | 456 | ||
| 457 | If unsure, say N. | 457 | If unsure, say N. |
| 458 | 458 | ||
| 459 | config CPU_SUP_CENTAUR_32 | 459 | config CPU_SUP_CENTAUR |
| 460 | default y | 460 | default y |
| 461 | bool "Support Centaur processors" if PROCESSOR_SELECT | 461 | bool "Support Centaur processors" if PROCESSOR_SELECT |
| 462 | depends on !64BIT | ||
| 463 | ---help--- | ||
| 464 | This enables detection, tunings and quirks for Centaur processors | ||
| 465 | |||
| 466 | You need this enabled if you want your kernel to run on a | ||
| 467 | Centaur CPU. Disabling this option on other types of CPUs | ||
| 468 | makes the kernel a tiny bit smaller. Disabling it on a Centaur | ||
| 469 | CPU might render the kernel unbootable. | ||
| 470 | |||
| 471 | If unsure, say N. | ||
| 472 | |||
| 473 | config CPU_SUP_CENTAUR_64 | ||
| 474 | default y | ||
| 475 | bool "Support Centaur processors" if PROCESSOR_SELECT | ||
| 476 | depends on 64BIT | ||
| 477 | ---help--- | 462 | ---help--- |
| 478 | This enables detection, tunings and quirks for Centaur processors | 463 | This enables detection, tunings and quirks for Centaur processors |
| 479 | 464 | ||
diff --git a/arch/x86/Makefile b/arch/x86/Makefile index 1836191839ee..f05d8c91d9e5 100644 --- a/arch/x86/Makefile +++ b/arch/x86/Makefile | |||
| @@ -153,34 +153,23 @@ endif | |||
| 153 | 153 | ||
| 154 | boot := arch/x86/boot | 154 | boot := arch/x86/boot |
| 155 | 155 | ||
| 156 | PHONY += zImage bzImage compressed zlilo bzlilo \ | 156 | BOOT_TARGETS = bzlilo bzdisk fdimage fdimage144 fdimage288 isoimage install |
| 157 | zdisk bzdisk fdimage fdimage144 fdimage288 isoimage install | 157 | |
| 158 | PHONY += bzImage $(BOOT_TARGETS) | ||
| 158 | 159 | ||
| 159 | # Default kernel to build | 160 | # Default kernel to build |
| 160 | all: bzImage | 161 | all: bzImage |
| 161 | 162 | ||
| 162 | # KBUILD_IMAGE specify target image being built | 163 | # KBUILD_IMAGE specify target image being built |
| 163 | KBUILD_IMAGE := $(boot)/bzImage | 164 | KBUILD_IMAGE := $(boot)/bzImage |
| 164 | zImage zlilo zdisk: KBUILD_IMAGE := $(boot)/zImage | ||
| 165 | 165 | ||
| 166 | zImage bzImage: vmlinux | 166 | bzImage: vmlinux |
| 167 | $(Q)$(MAKE) $(build)=$(boot) $(KBUILD_IMAGE) | 167 | $(Q)$(MAKE) $(build)=$(boot) $(KBUILD_IMAGE) |
| 168 | $(Q)mkdir -p $(objtree)/arch/$(UTS_MACHINE)/boot | 168 | $(Q)mkdir -p $(objtree)/arch/$(UTS_MACHINE)/boot |
| 169 | $(Q)ln -fsn ../../x86/boot/bzImage $(objtree)/arch/$(UTS_MACHINE)/boot/$@ | 169 | $(Q)ln -fsn ../../x86/boot/bzImage $(objtree)/arch/$(UTS_MACHINE)/boot/$@ |
| 170 | 170 | ||
| 171 | compressed: zImage | 171 | $(BOOT_TARGETS): vmlinux |
| 172 | 172 | $(Q)$(MAKE) $(build)=$(boot) $@ | |
| 173 | zlilo bzlilo: vmlinux | ||
| 174 | $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) zlilo | ||
| 175 | |||
| 176 | zdisk bzdisk: vmlinux | ||
| 177 | $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) zdisk | ||
| 178 | |||
| 179 | fdimage fdimage144 fdimage288 isoimage: vmlinux | ||
| 180 | $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) $@ | ||
| 181 | |||
| 182 | install: | ||
| 183 | $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) install | ||
| 184 | 173 | ||
| 185 | PHONY += vdso_install | 174 | PHONY += vdso_install |
| 186 | vdso_install: | 175 | vdso_install: |
| @@ -205,7 +194,3 @@ define archhelp | |||
| 205 | echo ' FDARGS="..." arguments for the booted kernel' | 194 | echo ' FDARGS="..." arguments for the booted kernel' |
| 206 | echo ' FDINITRD=file initrd for the booted kernel' | 195 | echo ' FDINITRD=file initrd for the booted kernel' |
| 207 | endef | 196 | endef |
| 208 | |||
| 209 | CLEAN_FILES += arch/x86/boot/fdimage \ | ||
| 210 | arch/x86/boot/image.iso \ | ||
| 211 | arch/x86/boot/mtools.conf | ||
diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile index c70eff69a1fb..fb737ce5888d 100644 --- a/arch/x86/boot/Makefile +++ b/arch/x86/boot/Makefile | |||
| @@ -6,26 +6,24 @@ | |||
| 6 | # for more details. | 6 | # for more details. |
| 7 | # | 7 | # |
| 8 | # Copyright (C) 1994 by Linus Torvalds | 8 | # Copyright (C) 1994 by Linus Torvalds |
| 9 | # Changed by many, many contributors over the years. | ||
| 9 | # | 10 | # |
| 10 | 11 | ||
| 11 | # ROOT_DEV specifies the default root-device when making the image. | 12 | # ROOT_DEV specifies the default root-device when making the image. |
| 12 | # This can be either FLOPPY, CURRENT, /dev/xxxx or empty, in which case | 13 | # This can be either FLOPPY, CURRENT, /dev/xxxx or empty, in which case |
| 13 | # the default of FLOPPY is used by 'build'. | 14 | # the default of FLOPPY is used by 'build'. |
| 14 | 15 | ||
| 15 | ROOT_DEV := CURRENT | 16 | ROOT_DEV := CURRENT |
| 16 | 17 | ||
| 17 | # If you want to preset the SVGA mode, uncomment the next line and | 18 | # If you want to preset the SVGA mode, uncomment the next line and |
| 18 | # set SVGA_MODE to whatever number you want. | 19 | # set SVGA_MODE to whatever number you want. |
| 19 | # Set it to -DSVGA_MODE=NORMAL_VGA if you just want the EGA/VGA mode. | 20 | # Set it to -DSVGA_MODE=NORMAL_VGA if you just want the EGA/VGA mode. |
| 20 | # The number is the same as you would ordinarily press at bootup. | 21 | # The number is the same as you would ordinarily press at bootup. |
| 21 | 22 | ||
| 22 | SVGA_MODE := -DSVGA_MODE=NORMAL_VGA | 23 | SVGA_MODE := -DSVGA_MODE=NORMAL_VGA |
| 23 | 24 | ||
| 24 | # If you want the RAM disk device, define this to be the size in blocks. | 25 | targets := vmlinux.bin setup.bin setup.elf bzImage |
| 25 | 26 | targets += fdimage fdimage144 fdimage288 image.iso mtools.conf | |
| 26 | #RAMDISK := -DRAMDISK=512 | ||
| 27 | |||
| 28 | targets := vmlinux.bin setup.bin setup.elf zImage bzImage | ||
| 29 | subdir- := compressed | 27 | subdir- := compressed |
| 30 | 28 | ||
| 31 | setup-y += a20.o cmdline.o copy.o cpu.o cpucheck.o edd.o | 29 | setup-y += a20.o cmdline.o copy.o cpu.o cpucheck.o edd.o |
| @@ -71,17 +69,13 @@ KBUILD_CFLAGS := $(LINUXINCLUDE) -g -Os -D_SETUP -D__KERNEL__ \ | |||
| 71 | KBUILD_CFLAGS += $(call cc-option,-m32) | 69 | KBUILD_CFLAGS += $(call cc-option,-m32) |
| 72 | KBUILD_AFLAGS := $(KBUILD_CFLAGS) -D__ASSEMBLY__ | 70 | KBUILD_AFLAGS := $(KBUILD_CFLAGS) -D__ASSEMBLY__ |
| 73 | 71 | ||
| 74 | $(obj)/zImage: asflags-y := $(SVGA_MODE) $(RAMDISK) | 72 | $(obj)/bzImage: asflags-y := $(SVGA_MODE) |
| 75 | $(obj)/bzImage: ccflags-y := -D__BIG_KERNEL__ | ||
| 76 | $(obj)/bzImage: asflags-y := $(SVGA_MODE) $(RAMDISK) -D__BIG_KERNEL__ | ||
| 77 | $(obj)/bzImage: BUILDFLAGS := -b | ||
| 78 | 73 | ||
| 79 | quiet_cmd_image = BUILD $@ | 74 | quiet_cmd_image = BUILD $@ |
| 80 | cmd_image = $(obj)/tools/build $(BUILDFLAGS) $(obj)/setup.bin \ | 75 | cmd_image = $(obj)/tools/build $(obj)/setup.bin $(obj)/vmlinux.bin \ |
| 81 | $(obj)/vmlinux.bin $(ROOT_DEV) > $@ | 76 | $(ROOT_DEV) > $@ |
| 82 | 77 | ||
| 83 | $(obj)/zImage $(obj)/bzImage: $(obj)/setup.bin \ | 78 | $(obj)/bzImage: $(obj)/setup.bin $(obj)/vmlinux.bin $(obj)/tools/build FORCE |
| 84 | $(obj)/vmlinux.bin $(obj)/tools/build FORCE | ||
| 85 | $(call if_changed,image) | 79 | $(call if_changed,image) |
| 86 | @echo 'Kernel: $@ is ready' ' (#'`cat .version`')' | 80 | @echo 'Kernel: $@ is ready' ' (#'`cat .version`')' |
| 87 | 81 | ||
| @@ -116,9 +110,11 @@ $(obj)/setup.bin: $(obj)/setup.elf FORCE | |||
| 116 | $(obj)/compressed/vmlinux: FORCE | 110 | $(obj)/compressed/vmlinux: FORCE |
| 117 | $(Q)$(MAKE) $(build)=$(obj)/compressed $@ | 111 | $(Q)$(MAKE) $(build)=$(obj)/compressed $@ |
| 118 | 112 | ||
| 119 | # Set this if you want to pass append arguments to the zdisk/fdimage/isoimage kernel | 113 | # Set this if you want to pass append arguments to the |
| 114 | # bzdisk/fdimage/isoimage kernel | ||
| 120 | FDARGS = | 115 | FDARGS = |
| 121 | # Set this if you want an initrd included with the zdisk/fdimage/isoimage kernel | 116 | # Set this if you want an initrd included with the |
| 117 | # bzdisk/fdimage/isoimage kernel | ||
| 122 | FDINITRD = | 118 | FDINITRD = |
| 123 | 119 | ||
| 124 | image_cmdline = default linux $(FDARGS) $(if $(FDINITRD),initrd=initrd.img,) | 120 | image_cmdline = default linux $(FDARGS) $(if $(FDINITRD),initrd=initrd.img,) |
| @@ -127,7 +123,7 @@ $(obj)/mtools.conf: $(src)/mtools.conf.in | |||
| 127 | sed -e 's|@OBJ@|$(obj)|g' < $< > $@ | 123 | sed -e 's|@OBJ@|$(obj)|g' < $< > $@ |
| 128 | 124 | ||
| 129 | # This requires write access to /dev/fd0 | 125 | # This requires write access to /dev/fd0 |
| 130 | zdisk: $(BOOTIMAGE) $(obj)/mtools.conf | 126 | bzdisk: $(obj)/bzImage $(obj)/mtools.conf |
| 131 | MTOOLSRC=$(obj)/mtools.conf mformat a: ; sync | 127 | MTOOLSRC=$(obj)/mtools.conf mformat a: ; sync |
| 132 | syslinux /dev/fd0 ; sync | 128 | syslinux /dev/fd0 ; sync |
| 133 | echo '$(image_cmdline)' | \ | 129 | echo '$(image_cmdline)' | \ |
| @@ -135,10 +131,10 @@ zdisk: $(BOOTIMAGE) $(obj)/mtools.conf | |||
| 135 | if [ -f '$(FDINITRD)' ] ; then \ | 131 | if [ -f '$(FDINITRD)' ] ; then \ |
| 136 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' a:initrd.img ; \ | 132 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' a:initrd.img ; \ |
| 137 | fi | 133 | fi |
| 138 | MTOOLSRC=$(obj)/mtools.conf mcopy $(BOOTIMAGE) a:linux ; sync | 134 | MTOOLSRC=$(obj)/mtools.conf mcopy $(obj)/bzImage a:linux ; sync |
| 139 | 135 | ||
| 140 | # These require being root or having syslinux 2.02 or higher installed | 136 | # These require being root or having syslinux 2.02 or higher installed |
| 141 | fdimage fdimage144: $(BOOTIMAGE) $(obj)/mtools.conf | 137 | fdimage fdimage144: $(obj)/bzImage $(obj)/mtools.conf |
| 142 | dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=1440 | 138 | dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=1440 |
| 143 | MTOOLSRC=$(obj)/mtools.conf mformat v: ; sync | 139 | MTOOLSRC=$(obj)/mtools.conf mformat v: ; sync |
| 144 | syslinux $(obj)/fdimage ; sync | 140 | syslinux $(obj)/fdimage ; sync |
| @@ -147,9 +143,9 @@ fdimage fdimage144: $(BOOTIMAGE) $(obj)/mtools.conf | |||
| 147 | if [ -f '$(FDINITRD)' ] ; then \ | 143 | if [ -f '$(FDINITRD)' ] ; then \ |
| 148 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' v:initrd.img ; \ | 144 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' v:initrd.img ; \ |
| 149 | fi | 145 | fi |
| 150 | MTOOLSRC=$(obj)/mtools.conf mcopy $(BOOTIMAGE) v:linux ; sync | 146 | MTOOLSRC=$(obj)/mtools.conf mcopy $(obj)/bzImage v:linux ; sync |
| 151 | 147 | ||
| 152 | fdimage288: $(BOOTIMAGE) $(obj)/mtools.conf | 148 | fdimage288: $(obj)/bzImage $(obj)/mtools.conf |
| 153 | dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=2880 | 149 | dd if=/dev/zero of=$(obj)/fdimage bs=1024 count=2880 |
| 154 | MTOOLSRC=$(obj)/mtools.conf mformat w: ; sync | 150 | MTOOLSRC=$(obj)/mtools.conf mformat w: ; sync |
| 155 | syslinux $(obj)/fdimage ; sync | 151 | syslinux $(obj)/fdimage ; sync |
| @@ -158,9 +154,9 @@ fdimage288: $(BOOTIMAGE) $(obj)/mtools.conf | |||
| 158 | if [ -f '$(FDINITRD)' ] ; then \ | 154 | if [ -f '$(FDINITRD)' ] ; then \ |
| 159 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' w:initrd.img ; \ | 155 | MTOOLSRC=$(obj)/mtools.conf mcopy '$(FDINITRD)' w:initrd.img ; \ |
| 160 | fi | 156 | fi |
| 161 | MTOOLSRC=$(obj)/mtools.conf mcopy $(BOOTIMAGE) w:linux ; sync | 157 | MTOOLSRC=$(obj)/mtools.conf mcopy $(obj)/bzImage w:linux ; sync |
| 162 | 158 | ||
| 163 | isoimage: $(BOOTIMAGE) | 159 | isoimage: $(obj)/bzImage |
| 164 | -rm -rf $(obj)/isoimage | 160 | -rm -rf $(obj)/isoimage |
| 165 | mkdir $(obj)/isoimage | 161 | mkdir $(obj)/isoimage |
| 166 | for i in lib lib64 share end ; do \ | 162 | for i in lib lib64 share end ; do \ |
| @@ -170,7 +166,7 @@ isoimage: $(BOOTIMAGE) | |||
| 170 | fi ; \ | 166 | fi ; \ |
| 171 | if [ $$i = end ] ; then exit 1 ; fi ; \ | 167 | if [ $$i = end ] ; then exit 1 ; fi ; \ |
| 172 | done | 168 | done |
| 173 | cp $(BOOTIMAGE) $(obj)/isoimage/linux | 169 | cp $(obj)/bzImage $(obj)/isoimage/linux |
| 174 | echo '$(image_cmdline)' > $(obj)/isoimage/isolinux.cfg | 170 | echo '$(image_cmdline)' > $(obj)/isoimage/isolinux.cfg |
| 175 | if [ -f '$(FDINITRD)' ] ; then \ | 171 | if [ -f '$(FDINITRD)' ] ; then \ |
| 176 | cp '$(FDINITRD)' $(obj)/isoimage/initrd.img ; \ | 172 | cp '$(FDINITRD)' $(obj)/isoimage/initrd.img ; \ |
| @@ -181,12 +177,13 @@ isoimage: $(BOOTIMAGE) | |||
| 181 | isohybrid $(obj)/image.iso 2>/dev/null || true | 177 | isohybrid $(obj)/image.iso 2>/dev/null || true |
| 182 | rm -rf $(obj)/isoimage | 178 | rm -rf $(obj)/isoimage |
| 183 | 179 | ||
| 184 | zlilo: $(BOOTIMAGE) | 180 | bzlilo: $(obj)/bzImage |
| 185 | if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi | 181 | if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi |
| 186 | if [ -f $(INSTALL_PATH)/System.map ]; then mv $(INSTALL_PATH)/System.map $(INSTALL_PATH)/System.old; fi | 182 | if [ -f $(INSTALL_PATH)/System.map ]; then mv $(INSTALL_PATH)/System.map $(INSTALL_PATH)/System.old; fi |
| 187 | cat $(BOOTIMAGE) > $(INSTALL_PATH)/vmlinuz | 183 | cat $(obj)/bzImage > $(INSTALL_PATH)/vmlinuz |
| 188 | cp System.map $(INSTALL_PATH)/ | 184 | cp System.map $(INSTALL_PATH)/ |
| 189 | if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi | 185 | if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi |
| 190 | 186 | ||
| 191 | install: | 187 | install: |
| 192 | sh $(srctree)/$(src)/install.sh $(KERNELRELEASE) $(BOOTIMAGE) System.map "$(INSTALL_PATH)" | 188 | sh $(srctree)/$(src)/install.sh $(KERNELRELEASE) $(obj)/bzImage \ |
| 189 | System.map "$(INSTALL_PATH)" | ||
diff --git a/arch/x86/boot/header.S b/arch/x86/boot/header.S index 7ccff4884a23..5d84d1c74e4c 100644 --- a/arch/x86/boot/header.S +++ b/arch/x86/boot/header.S | |||
| @@ -24,12 +24,8 @@ | |||
| 24 | #include "boot.h" | 24 | #include "boot.h" |
| 25 | #include "offsets.h" | 25 | #include "offsets.h" |
| 26 | 26 | ||
| 27 | SETUPSECTS = 4 /* default nr of setup-sectors */ | ||
| 28 | BOOTSEG = 0x07C0 /* original address of boot-sector */ | 27 | BOOTSEG = 0x07C0 /* original address of boot-sector */ |
| 29 | SYSSEG = DEF_SYSSEG /* system loaded at 0x10000 (65536) */ | 28 | SYSSEG = 0x1000 /* historical load address >> 4 */ |
| 30 | SYSSIZE = DEF_SYSSIZE /* system size: # of 16-byte clicks */ | ||
| 31 | /* to be loaded */ | ||
| 32 | ROOT_DEV = 0 /* ROOT_DEV is now written by "build" */ | ||
| 33 | 29 | ||
| 34 | #ifndef SVGA_MODE | 30 | #ifndef SVGA_MODE |
| 35 | #define SVGA_MODE ASK_VGA | 31 | #define SVGA_MODE ASK_VGA |
| @@ -97,12 +93,12 @@ bugger_off_msg: | |||
| 97 | .section ".header", "a" | 93 | .section ".header", "a" |
| 98 | .globl hdr | 94 | .globl hdr |
| 99 | hdr: | 95 | hdr: |
| 100 | setup_sects: .byte SETUPSECTS | 96 | setup_sects: .byte 0 /* Filled in by build.c */ |
| 101 | root_flags: .word ROOT_RDONLY | 97 | root_flags: .word ROOT_RDONLY |
| 102 | syssize: .long SYSSIZE | 98 | syssize: .long 0 /* Filled in by build.c */ |
| 103 | ram_size: .word RAMDISK | 99 | ram_size: .word 0 /* Obsolete */ |
| 104 | vid_mode: .word SVGA_MODE | 100 | vid_mode: .word SVGA_MODE |
| 105 | root_dev: .word ROOT_DEV | 101 | root_dev: .word 0 /* Filled in by build.c */ |
| 106 | boot_flag: .word 0xAA55 | 102 | boot_flag: .word 0xAA55 |
| 107 | 103 | ||
| 108 | # offset 512, entry point | 104 | # offset 512, entry point |
| @@ -123,14 +119,15 @@ _start: | |||
| 123 | # or else old loadlin-1.5 will fail) | 119 | # or else old loadlin-1.5 will fail) |
| 124 | .globl realmode_swtch | 120 | .globl realmode_swtch |
| 125 | realmode_swtch: .word 0, 0 # default_switch, SETUPSEG | 121 | realmode_swtch: .word 0, 0 # default_switch, SETUPSEG |
| 126 | start_sys_seg: .word SYSSEG | 122 | start_sys_seg: .word SYSSEG # obsolete and meaningless, but just |
| 123 | # in case something decided to "use" it | ||
| 127 | .word kernel_version-512 # pointing to kernel version string | 124 | .word kernel_version-512 # pointing to kernel version string |
| 128 | # above section of header is compatible | 125 | # above section of header is compatible |
| 129 | # with loadlin-1.5 (header v1.5). Don't | 126 | # with loadlin-1.5 (header v1.5). Don't |
| 130 | # change it. | 127 | # change it. |
| 131 | 128 | ||
| 132 | type_of_loader: .byte 0 # = 0, old one (LILO, Loadlin, | 129 | type_of_loader: .byte 0 # 0 means ancient bootloader, newer |
| 133 | # Bootlin, SYSLX, bootsect...) | 130 | # bootloaders know to change this. |
| 134 | # See Documentation/i386/boot.txt for | 131 | # See Documentation/i386/boot.txt for |
| 135 | # assigned ids | 132 | # assigned ids |
| 136 | 133 | ||
| @@ -142,11 +139,7 @@ CAN_USE_HEAP = 0x80 # If set, the loader also has set | |||
| 142 | # space behind setup.S can be used for | 139 | # space behind setup.S can be used for |
| 143 | # heap purposes. | 140 | # heap purposes. |
| 144 | # Only the loader knows what is free | 141 | # Only the loader knows what is free |
| 145 | #ifndef __BIG_KERNEL__ | ||
| 146 | .byte 0 | ||
| 147 | #else | ||
| 148 | .byte LOADED_HIGH | 142 | .byte LOADED_HIGH |
| 149 | #endif | ||
| 150 | 143 | ||
| 151 | setup_move_size: .word 0x8000 # size to move, when setup is not | 144 | setup_move_size: .word 0x8000 # size to move, when setup is not |
| 152 | # loaded at 0x90000. We will move setup | 145 | # loaded at 0x90000. We will move setup |
| @@ -157,11 +150,7 @@ setup_move_size: .word 0x8000 # size to move, when setup is not | |||
| 157 | 150 | ||
| 158 | code32_start: # here loaders can put a different | 151 | code32_start: # here loaders can put a different |
| 159 | # start address for 32-bit code. | 152 | # start address for 32-bit code. |
| 160 | #ifndef __BIG_KERNEL__ | ||
| 161 | .long 0x1000 # 0x1000 = default for zImage | ||
| 162 | #else | ||
| 163 | .long 0x100000 # 0x100000 = default for big kernel | 153 | .long 0x100000 # 0x100000 = default for big kernel |
| 164 | #endif | ||
| 165 | 154 | ||
| 166 | ramdisk_image: .long 0 # address of loaded ramdisk image | 155 | ramdisk_image: .long 0 # address of loaded ramdisk image |
| 167 | # Here the loader puts the 32-bit | 156 | # Here the loader puts the 32-bit |
diff --git a/arch/x86/boot/pm.c b/arch/x86/boot/pm.c index 85a1cd8a8ff8..8062f8915250 100644 --- a/arch/x86/boot/pm.c +++ b/arch/x86/boot/pm.c | |||
| @@ -33,47 +33,6 @@ static void realmode_switch_hook(void) | |||
| 33 | } | 33 | } |
| 34 | 34 | ||
| 35 | /* | 35 | /* |
| 36 | * A zImage kernel is loaded at 0x10000 but wants to run at 0x1000. | ||
| 37 | * A bzImage kernel is loaded and runs at 0x100000. | ||
| 38 | */ | ||
| 39 | static void move_kernel_around(void) | ||
| 40 | { | ||
| 41 | /* Note: rely on the compile-time option here rather than | ||
| 42 | the LOADED_HIGH flag. The Qemu kernel loader unconditionally | ||
| 43 | sets the loadflags to zero. */ | ||
| 44 | #ifndef __BIG_KERNEL__ | ||
| 45 | u16 dst_seg, src_seg; | ||
| 46 | u32 syssize; | ||
| 47 | |||
| 48 | dst_seg = 0x1000 >> 4; | ||
| 49 | src_seg = 0x10000 >> 4; | ||
| 50 | syssize = boot_params.hdr.syssize; /* Size in 16-byte paragraphs */ | ||
| 51 | |||
| 52 | while (syssize) { | ||
| 53 | int paras = (syssize >= 0x1000) ? 0x1000 : syssize; | ||
| 54 | int dwords = paras << 2; | ||
| 55 | |||
| 56 | asm volatile("pushw %%es ; " | ||
| 57 | "pushw %%ds ; " | ||
| 58 | "movw %1,%%es ; " | ||
| 59 | "movw %2,%%ds ; " | ||
| 60 | "xorw %%di,%%di ; " | ||
| 61 | "xorw %%si,%%si ; " | ||
| 62 | "rep;movsl ; " | ||
| 63 | "popw %%ds ; " | ||
| 64 | "popw %%es" | ||
| 65 | : "+c" (dwords) | ||
| 66 | : "r" (dst_seg), "r" (src_seg) | ||
| 67 | : "esi", "edi"); | ||
| 68 | |||
| 69 | syssize -= paras; | ||
| 70 | dst_seg += paras; | ||
| 71 | src_seg += paras; | ||
| 72 | } | ||
| 73 | #endif | ||
| 74 | } | ||
| 75 | |||
| 76 | /* | ||
| 77 | * Disable all interrupts at the legacy PIC. | 36 | * Disable all interrupts at the legacy PIC. |
| 78 | */ | 37 | */ |
| 79 | static void mask_all_interrupts(void) | 38 | static void mask_all_interrupts(void) |
| @@ -147,9 +106,6 @@ void go_to_protected_mode(void) | |||
| 147 | /* Hook before leaving real mode, also disables interrupts */ | 106 | /* Hook before leaving real mode, also disables interrupts */ |
| 148 | realmode_switch_hook(); | 107 | realmode_switch_hook(); |
| 149 | 108 | ||
| 150 | /* Move the kernel/setup to their final resting places */ | ||
| 151 | move_kernel_around(); | ||
| 152 | |||
| 153 | /* Enable the A20 gate */ | 109 | /* Enable the A20 gate */ |
| 154 | if (enable_a20()) { | 110 | if (enable_a20()) { |
| 155 | puts("A20 gate not responding, unable to boot...\n"); | 111 | puts("A20 gate not responding, unable to boot...\n"); |
diff --git a/arch/x86/boot/pmjump.S b/arch/x86/boot/pmjump.S index 019c17a75851..3e0edc6d2a20 100644 --- a/arch/x86/boot/pmjump.S +++ b/arch/x86/boot/pmjump.S | |||
| @@ -47,6 +47,7 @@ GLOBAL(protected_mode_jump) | |||
| 47 | ENDPROC(protected_mode_jump) | 47 | ENDPROC(protected_mode_jump) |
| 48 | 48 | ||
| 49 | .code32 | 49 | .code32 |
| 50 | .section ".text32","ax" | ||
| 50 | GLOBAL(in_pm32) | 51 | GLOBAL(in_pm32) |
| 51 | # Set up data segments for flat 32-bit mode | 52 | # Set up data segments for flat 32-bit mode |
| 52 | movl %ecx, %ds | 53 | movl %ecx, %ds |
diff --git a/arch/x86/boot/setup.ld b/arch/x86/boot/setup.ld index df9234b3a5e0..bb8dc2de7969 100644 --- a/arch/x86/boot/setup.ld +++ b/arch/x86/boot/setup.ld | |||
| @@ -17,7 +17,8 @@ SECTIONS | |||
| 17 | .header : { *(.header) } | 17 | .header : { *(.header) } |
| 18 | .inittext : { *(.inittext) } | 18 | .inittext : { *(.inittext) } |
| 19 | .initdata : { *(.initdata) } | 19 | .initdata : { *(.initdata) } |
| 20 | .text : { *(.text*) } | 20 | .text : { *(.text) } |
| 21 | .text32 : { *(.text32) } | ||
| 21 | 22 | ||
| 22 | . = ALIGN(16); | 23 | . = ALIGN(16); |
| 23 | .rodata : { *(.rodata*) } | 24 | .rodata : { *(.rodata*) } |
diff --git a/arch/x86/boot/tools/build.c b/arch/x86/boot/tools/build.c index 44dc1923c0e3..ee3a4ea923ac 100644 --- a/arch/x86/boot/tools/build.c +++ b/arch/x86/boot/tools/build.c | |||
| @@ -130,7 +130,7 @@ static void die(const char * str, ...) | |||
| 130 | 130 | ||
| 131 | static void usage(void) | 131 | static void usage(void) |
| 132 | { | 132 | { |
| 133 | die("Usage: build [-b] setup system [rootdev] [> image]"); | 133 | die("Usage: build setup system [rootdev] [> image]"); |
| 134 | } | 134 | } |
| 135 | 135 | ||
| 136 | int main(int argc, char ** argv) | 136 | int main(int argc, char ** argv) |
| @@ -145,11 +145,6 @@ int main(int argc, char ** argv) | |||
| 145 | void *kernel; | 145 | void *kernel; |
| 146 | u32 crc = 0xffffffffUL; | 146 | u32 crc = 0xffffffffUL; |
| 147 | 147 | ||
| 148 | if (argc > 2 && !strcmp(argv[1], "-b")) | ||
| 149 | { | ||
| 150 | is_big_kernel = 1; | ||
| 151 | argc--, argv++; | ||
| 152 | } | ||
| 153 | if ((argc < 3) || (argc > 4)) | 148 | if ((argc < 3) || (argc > 4)) |
| 154 | usage(); | 149 | usage(); |
| 155 | if (argc > 3) { | 150 | if (argc > 3) { |
| @@ -216,8 +211,6 @@ int main(int argc, char ** argv) | |||
| 216 | die("Unable to mmap '%s': %m", argv[2]); | 211 | die("Unable to mmap '%s': %m", argv[2]); |
| 217 | /* Number of 16-byte paragraphs, including space for a 4-byte CRC */ | 212 | /* Number of 16-byte paragraphs, including space for a 4-byte CRC */ |
| 218 | sys_size = (sz + 15 + 4) / 16; | 213 | sys_size = (sz + 15 + 4) / 16; |
| 219 | if (!is_big_kernel && sys_size > DEF_SYSSIZE) | ||
| 220 | die("System is too big. Try using bzImage or modules."); | ||
| 221 | 214 | ||
| 222 | /* Patch the setup code with the appropriate size parameters */ | 215 | /* Patch the setup code with the appropriate size parameters */ |
| 223 | buf[0x1f1] = setup_sectors-1; | 216 | buf[0x1f1] = setup_sectors-1; |
diff --git a/arch/x86/boot/video-vga.c b/arch/x86/boot/video-vga.c index 5d4742ed4aa2..95d86ce0421c 100644 --- a/arch/x86/boot/video-vga.c +++ b/arch/x86/boot/video-vga.c | |||
| @@ -129,41 +129,45 @@ u16 vga_crtc(void) | |||
| 129 | return (inb(0x3cc) & 1) ? 0x3d4 : 0x3b4; | 129 | return (inb(0x3cc) & 1) ? 0x3d4 : 0x3b4; |
| 130 | } | 130 | } |
| 131 | 131 | ||
| 132 | static void vga_set_480_scanlines(int end) | 132 | static void vga_set_480_scanlines(int lines) |
| 133 | { | 133 | { |
| 134 | u16 crtc; | 134 | u16 crtc; /* CRTC base address */ |
| 135 | u8 csel; | 135 | u8 csel; /* CRTC miscellaneous output register */ |
| 136 | u8 ovfw; /* CRTC overflow register */ | ||
| 137 | int end = lines-1; | ||
| 136 | 138 | ||
| 137 | crtc = vga_crtc(); | 139 | crtc = vga_crtc(); |
| 138 | 140 | ||
| 141 | ovfw = 0x3c | ((end >> (8-1)) & 0x02) | ((end >> (9-6)) & 0x40); | ||
| 142 | |||
| 139 | out_idx(0x0c, crtc, 0x11); /* Vertical sync end, unlock CR0-7 */ | 143 | out_idx(0x0c, crtc, 0x11); /* Vertical sync end, unlock CR0-7 */ |
| 140 | out_idx(0x0b, crtc, 0x06); /* Vertical total */ | 144 | out_idx(0x0b, crtc, 0x06); /* Vertical total */ |
| 141 | out_idx(0x3e, crtc, 0x07); /* Vertical overflow */ | 145 | out_idx(ovfw, crtc, 0x07); /* Vertical overflow */ |
| 142 | out_idx(0xea, crtc, 0x10); /* Vertical sync start */ | 146 | out_idx(0xea, crtc, 0x10); /* Vertical sync start */ |
| 143 | out_idx(end, crtc, 0x12); /* Vertical display end */ | 147 | out_idx(end, crtc, 0x12); /* Vertical display end */ |
| 144 | out_idx(0xe7, crtc, 0x15); /* Vertical blank start */ | 148 | out_idx(0xe7, crtc, 0x15); /* Vertical blank start */ |
| 145 | out_idx(0x04, crtc, 0x16); /* Vertical blank end */ | 149 | out_idx(0x04, crtc, 0x16); /* Vertical blank end */ |
| 146 | csel = inb(0x3cc); | 150 | csel = inb(0x3cc); |
| 147 | csel &= 0x0d; | 151 | csel &= 0x0d; |
| 148 | csel |= 0xe2; | 152 | csel |= 0xe2; |
| 149 | outb(csel, 0x3cc); | 153 | outb(csel, 0x3c2); |
| 150 | } | 154 | } |
| 151 | 155 | ||
| 152 | static void vga_set_80x30(void) | 156 | static void vga_set_80x30(void) |
| 153 | { | 157 | { |
| 154 | vga_set_480_scanlines(0xdf); | 158 | vga_set_480_scanlines(30*16); |
| 155 | } | 159 | } |
| 156 | 160 | ||
| 157 | static void vga_set_80x34(void) | 161 | static void vga_set_80x34(void) |
| 158 | { | 162 | { |
| 159 | vga_set_14font(); | 163 | vga_set_14font(); |
| 160 | vga_set_480_scanlines(0xdb); | 164 | vga_set_480_scanlines(34*14); |
| 161 | } | 165 | } |
| 162 | 166 | ||
| 163 | static void vga_set_80x60(void) | 167 | static void vga_set_80x60(void) |
| 164 | { | 168 | { |
| 165 | vga_set_8font(); | 169 | vga_set_8font(); |
| 166 | vga_set_480_scanlines(0xdf); | 170 | vga_set_480_scanlines(60*8); |
| 167 | } | 171 | } |
| 168 | 172 | ||
| 169 | static int vga_set_mode(struct mode_info *mode) | 173 | static int vga_set_mode(struct mode_info *mode) |
diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h index 4ef949c1972e..df8a300dfe6c 100644 --- a/arch/x86/include/asm/apic.h +++ b/arch/x86/include/asm/apic.h | |||
| @@ -75,7 +75,7 @@ static inline void default_inquire_remote_apic(int apicid) | |||
| 75 | #define setup_secondary_clock setup_secondary_APIC_clock | 75 | #define setup_secondary_clock setup_secondary_APIC_clock |
| 76 | #endif | 76 | #endif |
| 77 | 77 | ||
| 78 | #ifdef CONFIG_X86_VSMP | 78 | #ifdef CONFIG_X86_64 |
| 79 | extern int is_vsmp_box(void); | 79 | extern int is_vsmp_box(void); |
| 80 | #else | 80 | #else |
| 81 | static inline int is_vsmp_box(void) | 81 | static inline int is_vsmp_box(void) |
| @@ -108,6 +108,16 @@ extern void native_apic_icr_write(u32 low, u32 id); | |||
| 108 | extern u64 native_apic_icr_read(void); | 108 | extern u64 native_apic_icr_read(void); |
| 109 | 109 | ||
| 110 | #ifdef CONFIG_X86_X2APIC | 110 | #ifdef CONFIG_X86_X2APIC |
| 111 | /* | ||
| 112 | * Make previous memory operations globally visible before | ||
| 113 | * sending the IPI through x2apic wrmsr. We need a serializing instruction or | ||
| 114 | * mfence for this. | ||
| 115 | */ | ||
| 116 | static inline void x2apic_wrmsr_fence(void) | ||
| 117 | { | ||
| 118 | asm volatile("mfence" : : : "memory"); | ||
| 119 | } | ||
| 120 | |||
| 111 | static inline void native_apic_msr_write(u32 reg, u32 v) | 121 | static inline void native_apic_msr_write(u32 reg, u32 v) |
| 112 | { | 122 | { |
| 113 | if (reg == APIC_DFR || reg == APIC_ID || reg == APIC_LDR || | 123 | if (reg == APIC_DFR || reg == APIC_ID || reg == APIC_LDR || |
| @@ -184,6 +194,9 @@ static inline int x2apic_enabled(void) | |||
| 184 | { | 194 | { |
| 185 | return 0; | 195 | return 0; |
| 186 | } | 196 | } |
| 197 | |||
| 198 | #define x2apic 0 | ||
| 199 | |||
| 187 | #endif | 200 | #endif |
| 188 | 201 | ||
| 189 | extern int get_physical_broadcast(void); | 202 | extern int get_physical_broadcast(void); |
| @@ -379,6 +392,7 @@ static inline u32 safe_apic_wait_icr_idle(void) | |||
| 379 | 392 | ||
| 380 | static inline void ack_APIC_irq(void) | 393 | static inline void ack_APIC_irq(void) |
| 381 | { | 394 | { |
| 395 | #ifdef CONFIG_X86_LOCAL_APIC | ||
| 382 | /* | 396 | /* |
| 383 | * ack_APIC_irq() actually gets compiled as a single instruction | 397 | * ack_APIC_irq() actually gets compiled as a single instruction |
| 384 | * ... yummie. | 398 | * ... yummie. |
| @@ -386,6 +400,7 @@ static inline void ack_APIC_irq(void) | |||
| 386 | 400 | ||
| 387 | /* Docs say use 0 for future compatibility */ | 401 | /* Docs say use 0 for future compatibility */ |
| 388 | apic_write(APIC_EOI, 0); | 402 | apic_write(APIC_EOI, 0); |
| 403 | #endif | ||
| 389 | } | 404 | } |
| 390 | 405 | ||
| 391 | static inline unsigned default_get_apic_id(unsigned long x) | 406 | static inline unsigned default_get_apic_id(unsigned long x) |
| @@ -474,10 +489,19 @@ static inline int default_apic_id_registered(void) | |||
| 474 | return physid_isset(read_apic_id(), phys_cpu_present_map); | 489 | return physid_isset(read_apic_id(), phys_cpu_present_map); |
| 475 | } | 490 | } |
| 476 | 491 | ||
| 492 | static inline int default_phys_pkg_id(int cpuid_apic, int index_msb) | ||
| 493 | { | ||
| 494 | return cpuid_apic >> index_msb; | ||
| 495 | } | ||
| 496 | |||
| 497 | extern int default_apicid_to_node(int logical_apicid); | ||
| 498 | |||
| 499 | #endif | ||
| 500 | |||
| 477 | static inline unsigned int | 501 | static inline unsigned int |
| 478 | default_cpu_mask_to_apicid(const struct cpumask *cpumask) | 502 | default_cpu_mask_to_apicid(const struct cpumask *cpumask) |
| 479 | { | 503 | { |
| 480 | return cpumask_bits(cpumask)[0]; | 504 | return cpumask_bits(cpumask)[0] & APIC_ALL_CPUS; |
| 481 | } | 505 | } |
| 482 | 506 | ||
| 483 | static inline unsigned int | 507 | static inline unsigned int |
| @@ -491,15 +515,6 @@ default_cpu_mask_to_apicid_and(const struct cpumask *cpumask, | |||
| 491 | return (unsigned int)(mask1 & mask2 & mask3); | 515 | return (unsigned int)(mask1 & mask2 & mask3); |
| 492 | } | 516 | } |
| 493 | 517 | ||
| 494 | static inline int default_phys_pkg_id(int cpuid_apic, int index_msb) | ||
| 495 | { | ||
| 496 | return cpuid_apic >> index_msb; | ||
| 497 | } | ||
| 498 | |||
| 499 | extern int default_apicid_to_node(int logical_apicid); | ||
| 500 | |||
| 501 | #endif | ||
| 502 | |||
| 503 | static inline unsigned long default_check_apicid_used(physid_mask_t bitmap, int apicid) | 518 | static inline unsigned long default_check_apicid_used(physid_mask_t bitmap, int apicid) |
| 504 | { | 519 | { |
| 505 | return physid_isset(apicid, bitmap); | 520 | return physid_isset(apicid, bitmap); |
diff --git a/arch/x86/include/asm/apicdef.h b/arch/x86/include/asm/apicdef.h index 63134e31e8b9..bc9514fb3b13 100644 --- a/arch/x86/include/asm/apicdef.h +++ b/arch/x86/include/asm/apicdef.h | |||
| @@ -53,6 +53,7 @@ | |||
| 53 | #define APIC_ESR_SENDILL 0x00020 | 53 | #define APIC_ESR_SENDILL 0x00020 |
| 54 | #define APIC_ESR_RECVILL 0x00040 | 54 | #define APIC_ESR_RECVILL 0x00040 |
| 55 | #define APIC_ESR_ILLREGA 0x00080 | 55 | #define APIC_ESR_ILLREGA 0x00080 |
| 56 | #define APIC_LVTCMCI 0x2f0 | ||
| 56 | #define APIC_ICR 0x300 | 57 | #define APIC_ICR 0x300 |
| 57 | #define APIC_DEST_SELF 0x40000 | 58 | #define APIC_DEST_SELF 0x40000 |
| 58 | #define APIC_DEST_ALLINC 0x80000 | 59 | #define APIC_DEST_ALLINC 0x80000 |
diff --git a/arch/x86/include/asm/boot.h b/arch/x86/include/asm/boot.h index 6526cf08b0e4..6ba23dd9fc92 100644 --- a/arch/x86/include/asm/boot.h +++ b/arch/x86/include/asm/boot.h | |||
| @@ -1,10 +1,6 @@ | |||
| 1 | #ifndef _ASM_X86_BOOT_H | 1 | #ifndef _ASM_X86_BOOT_H |
| 2 | #define _ASM_X86_BOOT_H | 2 | #define _ASM_X86_BOOT_H |
| 3 | 3 | ||
| 4 | /* Don't touch these, unless you really know what you're doing. */ | ||
| 5 | #define DEF_SYSSEG 0x1000 | ||
| 6 | #define DEF_SYSSIZE 0x7F00 | ||
| 7 | |||
| 8 | /* Internal svga startup constants */ | 4 | /* Internal svga startup constants */ |
| 9 | #define NORMAL_VGA 0xffff /* 80x25 mode */ | 5 | #define NORMAL_VGA 0xffff /* 80x25 mode */ |
| 10 | #define EXTENDED_VGA 0xfffe /* 80x50 mode */ | 6 | #define EXTENDED_VGA 0xfffe /* 80x50 mode */ |
diff --git a/arch/x86/include/asm/cacheflush.h b/arch/x86/include/asm/cacheflush.h index 5b301b7ff5f4..b3894bf52fcd 100644 --- a/arch/x86/include/asm/cacheflush.h +++ b/arch/x86/include/asm/cacheflush.h | |||
| @@ -90,6 +90,9 @@ int set_memory_4k(unsigned long addr, int numpages); | |||
| 90 | int set_memory_array_uc(unsigned long *addr, int addrinarray); | 90 | int set_memory_array_uc(unsigned long *addr, int addrinarray); |
| 91 | int set_memory_array_wb(unsigned long *addr, int addrinarray); | 91 | int set_memory_array_wb(unsigned long *addr, int addrinarray); |
| 92 | 92 | ||
| 93 | int set_pages_array_uc(struct page **pages, int addrinarray); | ||
| 94 | int set_pages_array_wb(struct page **pages, int addrinarray); | ||
| 95 | |||
| 93 | /* | 96 | /* |
| 94 | * For legacy compatibility with the old APIs, a few functions | 97 | * For legacy compatibility with the old APIs, a few functions |
| 95 | * are provided that work on a "struct page". | 98 | * are provided that work on a "struct page". |
diff --git a/arch/x86/include/asm/cpu_debug.h b/arch/x86/include/asm/cpu_debug.h new file mode 100755 index 000000000000..222802029fa6 --- /dev/null +++ b/arch/x86/include/asm/cpu_debug.h | |||
| @@ -0,0 +1,226 @@ | |||
| 1 | #ifndef _ASM_X86_CPU_DEBUG_H | ||
| 2 | #define _ASM_X86_CPU_DEBUG_H | ||
| 3 | |||
| 4 | /* | ||
| 5 | * CPU x86 architecture debug | ||
| 6 | * | ||
| 7 | * Copyright(C) 2009 Jaswinder Singh Rajput | ||
| 8 | */ | ||
| 9 | |||
| 10 | /* Register flags */ | ||
| 11 | enum cpu_debug_bit { | ||
| 12 | /* Model Specific Registers (MSRs) */ | ||
| 13 | CPU_MC_BIT, /* Machine Check */ | ||
| 14 | CPU_MONITOR_BIT, /* Monitor */ | ||
| 15 | CPU_TIME_BIT, /* Time */ | ||
| 16 | CPU_PMC_BIT, /* Performance Monitor */ | ||
| 17 | CPU_PLATFORM_BIT, /* Platform */ | ||
| 18 | CPU_APIC_BIT, /* APIC */ | ||
| 19 | CPU_POWERON_BIT, /* Power-on */ | ||
| 20 | CPU_CONTROL_BIT, /* Control */ | ||
| 21 | CPU_FEATURES_BIT, /* Features control */ | ||
| 22 | CPU_LBRANCH_BIT, /* Last Branch */ | ||
| 23 | CPU_BIOS_BIT, /* BIOS */ | ||
| 24 | CPU_FREQ_BIT, /* Frequency */ | ||
| 25 | CPU_MTTR_BIT, /* MTRR */ | ||
| 26 | CPU_PERF_BIT, /* Performance */ | ||
| 27 | CPU_CACHE_BIT, /* Cache */ | ||
| 28 | CPU_SYSENTER_BIT, /* Sysenter */ | ||
| 29 | CPU_THERM_BIT, /* Thermal */ | ||
| 30 | CPU_MISC_BIT, /* Miscellaneous */ | ||
| 31 | CPU_DEBUG_BIT, /* Debug */ | ||
| 32 | CPU_PAT_BIT, /* PAT */ | ||
| 33 | CPU_VMX_BIT, /* VMX */ | ||
| 34 | CPU_CALL_BIT, /* System Call */ | ||
| 35 | CPU_BASE_BIT, /* BASE Address */ | ||
| 36 | CPU_VER_BIT, /* Version ID */ | ||
| 37 | CPU_CONF_BIT, /* Configuration */ | ||
| 38 | CPU_SMM_BIT, /* System mgmt mode */ | ||
| 39 | CPU_SVM_BIT, /*Secure Virtual Machine*/ | ||
| 40 | CPU_OSVM_BIT, /* OS-Visible Workaround*/ | ||
| 41 | /* Standard Registers */ | ||
| 42 | CPU_TSS_BIT, /* Task Stack Segment */ | ||
| 43 | CPU_CR_BIT, /* Control Registers */ | ||
| 44 | CPU_DT_BIT, /* Descriptor Table */ | ||
| 45 | /* End of Registers flags */ | ||
| 46 | CPU_REG_ALL_BIT, /* Select all Registers */ | ||
| 47 | }; | ||
| 48 | |||
| 49 | #define CPU_REG_ALL (~0) /* Select all Registers */ | ||
| 50 | |||
| 51 | #define CPU_MC (1 << CPU_MC_BIT) | ||
| 52 | #define CPU_MONITOR (1 << CPU_MONITOR_BIT) | ||
| 53 | #define CPU_TIME (1 << CPU_TIME_BIT) | ||
| 54 | #define CPU_PMC (1 << CPU_PMC_BIT) | ||
| 55 | #define CPU_PLATFORM (1 << CPU_PLATFORM_BIT) | ||
| 56 | #define CPU_APIC (1 << CPU_APIC_BIT) | ||
| 57 | #define CPU_POWERON (1 << CPU_POWERON_BIT) | ||
| 58 | #define CPU_CONTROL (1 << CPU_CONTROL_BIT) | ||
| 59 | #define CPU_FEATURES (1 << CPU_FEATURES_BIT) | ||
| 60 | #define CPU_LBRANCH (1 << CPU_LBRANCH_BIT) | ||
| 61 | #define CPU_BIOS (1 << CPU_BIOS_BIT) | ||
| 62 | #define CPU_FREQ (1 << CPU_FREQ_BIT) | ||
| 63 | #define CPU_MTRR (1 << CPU_MTTR_BIT) | ||
| 64 | #define CPU_PERF (1 << CPU_PERF_BIT) | ||
| 65 | #define CPU_CACHE (1 << CPU_CACHE_BIT) | ||
| 66 | #define CPU_SYSENTER (1 << CPU_SYSENTER_BIT) | ||
| 67 | #define CPU_THERM (1 << CPU_THERM_BIT) | ||
| 68 | #define CPU_MISC (1 << CPU_MISC_BIT) | ||
| 69 | #define CPU_DEBUG (1 << CPU_DEBUG_BIT) | ||
| 70 | #define CPU_PAT (1 << CPU_PAT_BIT) | ||
| 71 | #define CPU_VMX (1 << CPU_VMX_BIT) | ||
| 72 | #define CPU_CALL (1 << CPU_CALL_BIT) | ||
| 73 | #define CPU_BASE (1 << CPU_BASE_BIT) | ||
| 74 | #define CPU_VER (1 << CPU_VER_BIT) | ||
| 75 | #define CPU_CONF (1 << CPU_CONF_BIT) | ||
| 76 | #define CPU_SMM (1 << CPU_SMM_BIT) | ||
| 77 | #define CPU_SVM (1 << CPU_SVM_BIT) | ||
| 78 | #define CPU_OSVM (1 << CPU_OSVM_BIT) | ||
| 79 | #define CPU_TSS (1 << CPU_TSS_BIT) | ||
| 80 | #define CPU_CR (1 << CPU_CR_BIT) | ||
| 81 | #define CPU_DT (1 << CPU_DT_BIT) | ||
| 82 | |||
| 83 | /* Register file flags */ | ||
| 84 | enum cpu_file_bit { | ||
| 85 | CPU_INDEX_BIT, /* index */ | ||
| 86 | CPU_VALUE_BIT, /* value */ | ||
| 87 | }; | ||
| 88 | |||
| 89 | #define CPU_FILE_VALUE (1 << CPU_VALUE_BIT) | ||
| 90 | |||
| 91 | /* | ||
| 92 | * DisplayFamily_DisplayModel Processor Families/Processor Number Series | ||
| 93 | * -------------------------- ------------------------------------------ | ||
| 94 | * 05_01, 05_02, 05_04 Pentium, Pentium with MMX | ||
| 95 | * | ||
| 96 | * 06_01 Pentium Pro | ||
| 97 | * 06_03, 06_05 Pentium II Xeon, Pentium II | ||
| 98 | * 06_07, 06_08, 06_0A, 06_0B Pentium III Xeon, Pentum III | ||
| 99 | * | ||
| 100 | * 06_09, 060D Pentium M | ||
| 101 | * | ||
| 102 | * 06_0E Core Duo, Core Solo | ||
| 103 | * | ||
| 104 | * 06_0F Xeon 3000, 3200, 5100, 5300, 7300 series, | ||
| 105 | * Core 2 Quad, Core 2 Extreme, Core 2 Duo, | ||
| 106 | * Pentium dual-core | ||
| 107 | * 06_17 Xeon 5200, 5400 series, Core 2 Quad Q9650 | ||
| 108 | * | ||
| 109 | * 06_1C Atom | ||
| 110 | * | ||
| 111 | * 0F_00, 0F_01, 0F_02 Xeon, Xeon MP, Pentium 4 | ||
| 112 | * 0F_03, 0F_04 Xeon, Xeon MP, Pentium 4, Pentium D | ||
| 113 | * | ||
| 114 | * 0F_06 Xeon 7100, 5000 Series, Xeon MP, | ||
| 115 | * Pentium 4, Pentium D | ||
| 116 | */ | ||
| 117 | |||
| 118 | /* Register processors bits */ | ||
| 119 | enum cpu_processor_bit { | ||
| 120 | CPU_NONE, | ||
| 121 | /* Intel */ | ||
| 122 | CPU_INTEL_PENTIUM_BIT, | ||
| 123 | CPU_INTEL_P6_BIT, | ||
| 124 | CPU_INTEL_PENTIUM_M_BIT, | ||
| 125 | CPU_INTEL_CORE_BIT, | ||
| 126 | CPU_INTEL_CORE2_BIT, | ||
| 127 | CPU_INTEL_ATOM_BIT, | ||
| 128 | CPU_INTEL_XEON_P4_BIT, | ||
| 129 | CPU_INTEL_XEON_MP_BIT, | ||
| 130 | /* AMD */ | ||
| 131 | CPU_AMD_K6_BIT, | ||
| 132 | CPU_AMD_K7_BIT, | ||
| 133 | CPU_AMD_K8_BIT, | ||
| 134 | CPU_AMD_0F_BIT, | ||
| 135 | CPU_AMD_10_BIT, | ||
| 136 | CPU_AMD_11_BIT, | ||
| 137 | }; | ||
| 138 | |||
| 139 | #define CPU_INTEL_PENTIUM (1 << CPU_INTEL_PENTIUM_BIT) | ||
| 140 | #define CPU_INTEL_P6 (1 << CPU_INTEL_P6_BIT) | ||
| 141 | #define CPU_INTEL_PENTIUM_M (1 << CPU_INTEL_PENTIUM_M_BIT) | ||
| 142 | #define CPU_INTEL_CORE (1 << CPU_INTEL_CORE_BIT) | ||
| 143 | #define CPU_INTEL_CORE2 (1 << CPU_INTEL_CORE2_BIT) | ||
| 144 | #define CPU_INTEL_ATOM (1 << CPU_INTEL_ATOM_BIT) | ||
| 145 | #define CPU_INTEL_XEON_P4 (1 << CPU_INTEL_XEON_P4_BIT) | ||
| 146 | #define CPU_INTEL_XEON_MP (1 << CPU_INTEL_XEON_MP_BIT) | ||
| 147 | |||
| 148 | #define CPU_INTEL_PX (CPU_INTEL_P6 | CPU_INTEL_PENTIUM_M) | ||
| 149 | #define CPU_INTEL_COREX (CPU_INTEL_CORE | CPU_INTEL_CORE2) | ||
| 150 | #define CPU_INTEL_XEON (CPU_INTEL_XEON_P4 | CPU_INTEL_XEON_MP) | ||
| 151 | #define CPU_CO_AT (CPU_INTEL_CORE | CPU_INTEL_ATOM) | ||
| 152 | #define CPU_C2_AT (CPU_INTEL_CORE2 | CPU_INTEL_ATOM) | ||
| 153 | #define CPU_CX_AT (CPU_INTEL_COREX | CPU_INTEL_ATOM) | ||
| 154 | #define CPU_CX_XE (CPU_INTEL_COREX | CPU_INTEL_XEON) | ||
| 155 | #define CPU_P6_XE (CPU_INTEL_P6 | CPU_INTEL_XEON) | ||
| 156 | #define CPU_PM_CO_AT (CPU_INTEL_PENTIUM_M | CPU_CO_AT) | ||
| 157 | #define CPU_C2_AT_XE (CPU_C2_AT | CPU_INTEL_XEON) | ||
| 158 | #define CPU_CX_AT_XE (CPU_CX_AT | CPU_INTEL_XEON) | ||
| 159 | #define CPU_P6_CX_AT (CPU_INTEL_P6 | CPU_CX_AT) | ||
| 160 | #define CPU_P6_CX_XE (CPU_P6_XE | CPU_INTEL_COREX) | ||
| 161 | #define CPU_P6_CX_AT_XE (CPU_INTEL_P6 | CPU_CX_AT_XE) | ||
| 162 | #define CPU_PM_CX_AT_XE (CPU_INTEL_PENTIUM_M | CPU_CX_AT_XE) | ||
| 163 | #define CPU_PM_CX_AT (CPU_INTEL_PENTIUM_M | CPU_CX_AT) | ||
| 164 | #define CPU_PM_CX_XE (CPU_INTEL_PENTIUM_M | CPU_CX_XE) | ||
| 165 | #define CPU_PX_CX_AT (CPU_INTEL_PX | CPU_CX_AT) | ||
| 166 | #define CPU_PX_CX_AT_XE (CPU_INTEL_PX | CPU_CX_AT_XE) | ||
| 167 | |||
| 168 | /* Select all supported Intel CPUs */ | ||
| 169 | #define CPU_INTEL_ALL (CPU_INTEL_PENTIUM | CPU_PX_CX_AT_XE) | ||
| 170 | |||
| 171 | #define CPU_AMD_K6 (1 << CPU_AMD_K6_BIT) | ||
| 172 | #define CPU_AMD_K7 (1 << CPU_AMD_K7_BIT) | ||
| 173 | #define CPU_AMD_K8 (1 << CPU_AMD_K8_BIT) | ||
| 174 | #define CPU_AMD_0F (1 << CPU_AMD_0F_BIT) | ||
| 175 | #define CPU_AMD_10 (1 << CPU_AMD_10_BIT) | ||
| 176 | #define CPU_AMD_11 (1 << CPU_AMD_11_BIT) | ||
| 177 | |||
| 178 | #define CPU_K10_PLUS (CPU_AMD_10 | CPU_AMD_11) | ||
| 179 | #define CPU_K0F_PLUS (CPU_AMD_0F | CPU_K10_PLUS) | ||
| 180 | #define CPU_K8_PLUS (CPU_AMD_K8 | CPU_K0F_PLUS) | ||
| 181 | #define CPU_K7_PLUS (CPU_AMD_K7 | CPU_K8_PLUS) | ||
| 182 | |||
| 183 | /* Select all supported AMD CPUs */ | ||
| 184 | #define CPU_AMD_ALL (CPU_AMD_K6 | CPU_K7_PLUS) | ||
| 185 | |||
| 186 | /* Select all supported CPUs */ | ||
| 187 | #define CPU_ALL (CPU_INTEL_ALL | CPU_AMD_ALL) | ||
| 188 | |||
| 189 | #define MAX_CPU_FILES 512 | ||
| 190 | |||
| 191 | struct cpu_private { | ||
| 192 | unsigned cpu; | ||
| 193 | unsigned type; | ||
| 194 | unsigned reg; | ||
| 195 | unsigned file; | ||
| 196 | }; | ||
| 197 | |||
| 198 | struct cpu_debug_base { | ||
| 199 | char *name; /* Register name */ | ||
| 200 | unsigned flag; /* Register flag */ | ||
| 201 | unsigned write; /* Register write flag */ | ||
| 202 | }; | ||
| 203 | |||
| 204 | /* | ||
| 205 | * Currently it looks similar to cpu_debug_base but once we add more files | ||
| 206 | * cpu_file_base will go in different direction | ||
| 207 | */ | ||
| 208 | struct cpu_file_base { | ||
| 209 | char *name; /* Register file name */ | ||
| 210 | unsigned flag; /* Register file flag */ | ||
| 211 | unsigned write; /* Register write flag */ | ||
| 212 | }; | ||
| 213 | |||
| 214 | struct cpu_cpuX_base { | ||
| 215 | struct dentry *dentry; /* Register dentry */ | ||
| 216 | int init; /* Register index file */ | ||
| 217 | }; | ||
| 218 | |||
| 219 | struct cpu_debug_range { | ||
| 220 | unsigned min; /* Register range min */ | ||
| 221 | unsigned max; /* Register range max */ | ||
| 222 | unsigned flag; /* Supported flags */ | ||
| 223 | unsigned model; /* Supported models */ | ||
| 224 | }; | ||
| 225 | |||
| 226 | #endif /* _ASM_X86_CPU_DEBUG_H */ | ||
diff --git a/arch/x86/include/asm/desc.h b/arch/x86/include/asm/desc.h index dc27705f5443..5623c50d67b2 100644 --- a/arch/x86/include/asm/desc.h +++ b/arch/x86/include/asm/desc.h | |||
| @@ -91,7 +91,6 @@ static inline int desc_empty(const void *ptr) | |||
| 91 | #define store_gdt(dtr) native_store_gdt(dtr) | 91 | #define store_gdt(dtr) native_store_gdt(dtr) |
| 92 | #define store_idt(dtr) native_store_idt(dtr) | 92 | #define store_idt(dtr) native_store_idt(dtr) |
| 93 | #define store_tr(tr) (tr = native_store_tr()) | 93 | #define store_tr(tr) (tr = native_store_tr()) |
| 94 | #define store_ldt(ldt) asm("sldt %0":"=m" (ldt)) | ||
| 95 | 94 | ||
| 96 | #define load_TLS(t, cpu) native_load_tls(t, cpu) | 95 | #define load_TLS(t, cpu) native_load_tls(t, cpu) |
| 97 | #define set_ldt native_set_ldt | 96 | #define set_ldt native_set_ldt |
| @@ -112,6 +111,8 @@ static inline void paravirt_free_ldt(struct desc_struct *ldt, unsigned entries) | |||
| 112 | } | 111 | } |
| 113 | #endif /* CONFIG_PARAVIRT */ | 112 | #endif /* CONFIG_PARAVIRT */ |
| 114 | 113 | ||
| 114 | #define store_ldt(ldt) asm("sldt %0" : "=m"(ldt)) | ||
| 115 | |||
| 115 | static inline void native_write_idt_entry(gate_desc *idt, int entry, | 116 | static inline void native_write_idt_entry(gate_desc *idt, int entry, |
| 116 | const gate_desc *gate) | 117 | const gate_desc *gate) |
| 117 | { | 118 | { |
diff --git a/arch/x86/include/asm/dmi.h b/arch/x86/include/asm/dmi.h index bc68212c6bc0..fd8f9e2ca35f 100644 --- a/arch/x86/include/asm/dmi.h +++ b/arch/x86/include/asm/dmi.h | |||
| @@ -1,22 +1,15 @@ | |||
| 1 | #ifndef _ASM_X86_DMI_H | 1 | #ifndef _ASM_X86_DMI_H |
| 2 | #define _ASM_X86_DMI_H | 2 | #define _ASM_X86_DMI_H |
| 3 | 3 | ||
| 4 | #include <asm/io.h> | 4 | #include <linux/compiler.h> |
| 5 | 5 | #include <linux/init.h> | |
| 6 | #define DMI_MAX_DATA 2048 | ||
| 7 | 6 | ||
| 8 | extern int dmi_alloc_index; | 7 | #include <asm/io.h> |
| 9 | extern char dmi_alloc_data[DMI_MAX_DATA]; | 8 | #include <asm/setup.h> |
| 10 | 9 | ||
| 11 | /* This is so early that there is no good way to allocate dynamic memory. | 10 | static __always_inline __init void *dmi_alloc(unsigned len) |
| 12 | Allocate data in an BSS array. */ | ||
| 13 | static inline void *dmi_alloc(unsigned len) | ||
| 14 | { | 11 | { |
| 15 | int idx = dmi_alloc_index; | 12 | return extend_brk(len, sizeof(int)); |
| 16 | if ((dmi_alloc_index + len) > DMI_MAX_DATA) | ||
| 17 | return NULL; | ||
| 18 | dmi_alloc_index += len; | ||
| 19 | return dmi_alloc_data + idx; | ||
| 20 | } | 13 | } |
| 21 | 14 | ||
| 22 | /* Use early IO mappings for DMI because it's initialized early */ | 15 | /* Use early IO mappings for DMI because it's initialized early */ |
diff --git a/arch/x86/include/asm/e820.h b/arch/x86/include/asm/e820.h index 00d41ce4c844..7ecba4d85089 100644 --- a/arch/x86/include/asm/e820.h +++ b/arch/x86/include/asm/e820.h | |||
| @@ -72,7 +72,7 @@ extern int e820_all_mapped(u64 start, u64 end, unsigned type); | |||
| 72 | extern void e820_add_region(u64 start, u64 size, int type); | 72 | extern void e820_add_region(u64 start, u64 size, int type); |
| 73 | extern void e820_print_map(char *who); | 73 | extern void e820_print_map(char *who); |
| 74 | extern int | 74 | extern int |
| 75 | sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, int *pnr_map); | 75 | sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, u32 *pnr_map); |
| 76 | extern u64 e820_update_range(u64 start, u64 size, unsigned old_type, | 76 | extern u64 e820_update_range(u64 start, u64 size, unsigned old_type, |
| 77 | unsigned new_type); | 77 | unsigned new_type); |
| 78 | extern u64 e820_remove_range(u64 start, u64 size, unsigned old_type, | 78 | extern u64 e820_remove_range(u64 start, u64 size, unsigned old_type, |
diff --git a/arch/x86/include/asm/entry_arch.h b/arch/x86/include/asm/entry_arch.h index 854d538ae857..c2e6bedaf258 100644 --- a/arch/x86/include/asm/entry_arch.h +++ b/arch/x86/include/asm/entry_arch.h | |||
| @@ -33,6 +33,8 @@ BUILD_INTERRUPT3(invalidate_interrupt7,INVALIDATE_TLB_VECTOR_START+7, | |||
| 33 | smp_invalidate_interrupt) | 33 | smp_invalidate_interrupt) |
| 34 | #endif | 34 | #endif |
| 35 | 35 | ||
| 36 | BUILD_INTERRUPT(generic_interrupt, GENERIC_INTERRUPT_VECTOR) | ||
| 37 | |||
| 36 | /* | 38 | /* |
| 37 | * every pentium local APIC has two 'local interrupts', with a | 39 | * every pentium local APIC has two 'local interrupts', with a |
| 38 | * soft-definable vector attached to both interrupts, one of | 40 | * soft-definable vector attached to both interrupts, one of |
diff --git a/arch/x86/include/asm/hardirq.h b/arch/x86/include/asm/hardirq.h index 176f058e7159..039db6aa8e02 100644 --- a/arch/x86/include/asm/hardirq.h +++ b/arch/x86/include/asm/hardirq.h | |||
| @@ -12,6 +12,7 @@ typedef struct { | |||
| 12 | unsigned int apic_timer_irqs; /* arch dependent */ | 12 | unsigned int apic_timer_irqs; /* arch dependent */ |
| 13 | unsigned int irq_spurious_count; | 13 | unsigned int irq_spurious_count; |
| 14 | #endif | 14 | #endif |
| 15 | unsigned int generic_irqs; /* arch dependent */ | ||
| 15 | #ifdef CONFIG_SMP | 16 | #ifdef CONFIG_SMP |
| 16 | unsigned int irq_resched_count; | 17 | unsigned int irq_resched_count; |
| 17 | unsigned int irq_call_count; | 18 | unsigned int irq_call_count; |
diff --git a/arch/x86/include/asm/highmem.h b/arch/x86/include/asm/highmem.h index bf9276bea660..014c2b85ae45 100644 --- a/arch/x86/include/asm/highmem.h +++ b/arch/x86/include/asm/highmem.h | |||
| @@ -63,6 +63,7 @@ void *kmap_atomic_prot(struct page *page, enum km_type type, pgprot_t prot); | |||
| 63 | void *kmap_atomic(struct page *page, enum km_type type); | 63 | void *kmap_atomic(struct page *page, enum km_type type); |
| 64 | void kunmap_atomic(void *kvaddr, enum km_type type); | 64 | void kunmap_atomic(void *kvaddr, enum km_type type); |
| 65 | void *kmap_atomic_pfn(unsigned long pfn, enum km_type type); | 65 | void *kmap_atomic_pfn(unsigned long pfn, enum km_type type); |
| 66 | void *kmap_atomic_prot_pfn(unsigned long pfn, enum km_type type, pgprot_t prot); | ||
| 66 | struct page *kmap_atomic_to_page(void *ptr); | 67 | struct page *kmap_atomic_to_page(void *ptr); |
| 67 | 68 | ||
| 68 | #ifndef CONFIG_PARAVIRT | 69 | #ifndef CONFIG_PARAVIRT |
diff --git a/arch/x86/include/asm/hw_irq.h b/arch/x86/include/asm/hw_irq.h index 370e1c83bb49..b762ea49bd70 100644 --- a/arch/x86/include/asm/hw_irq.h +++ b/arch/x86/include/asm/hw_irq.h | |||
| @@ -27,6 +27,7 @@ | |||
| 27 | 27 | ||
| 28 | /* Interrupt handlers registered during init_IRQ */ | 28 | /* Interrupt handlers registered during init_IRQ */ |
| 29 | extern void apic_timer_interrupt(void); | 29 | extern void apic_timer_interrupt(void); |
| 30 | extern void generic_interrupt(void); | ||
| 30 | extern void error_interrupt(void); | 31 | extern void error_interrupt(void); |
| 31 | extern void spurious_interrupt(void); | 32 | extern void spurious_interrupt(void); |
| 32 | extern void thermal_interrupt(void); | 33 | extern void thermal_interrupt(void); |
diff --git a/arch/x86/include/asm/init.h b/arch/x86/include/asm/init.h new file mode 100644 index 000000000000..36fb1a6a5109 --- /dev/null +++ b/arch/x86/include/asm/init.h | |||
| @@ -0,0 +1,18 @@ | |||
| 1 | #ifndef _ASM_X86_INIT_32_H | ||
| 2 | #define _ASM_X86_INIT_32_H | ||
| 3 | |||
| 4 | #ifdef CONFIG_X86_32 | ||
| 5 | extern void __init early_ioremap_page_table_range_init(void); | ||
| 6 | #endif | ||
| 7 | |||
| 8 | extern unsigned long __init | ||
| 9 | kernel_physical_mapping_init(unsigned long start, | ||
| 10 | unsigned long end, | ||
| 11 | unsigned long page_size_mask); | ||
| 12 | |||
| 13 | |||
| 14 | extern unsigned long __initdata e820_table_start; | ||
| 15 | extern unsigned long __meminitdata e820_table_end; | ||
| 16 | extern unsigned long __meminitdata e820_table_top; | ||
| 17 | |||
| 18 | #endif /* _ASM_X86_INIT_32_H */ | ||
diff --git a/arch/x86/include/asm/io_apic.h b/arch/x86/include/asm/io_apic.h index 59cb4a1317b7..373cc2bbcad2 100644 --- a/arch/x86/include/asm/io_apic.h +++ b/arch/x86/include/asm/io_apic.h | |||
| @@ -162,7 +162,8 @@ extern int (*ioapic_renumber_irq)(int ioapic, int irq); | |||
| 162 | extern void ioapic_init_mappings(void); | 162 | extern void ioapic_init_mappings(void); |
| 163 | 163 | ||
| 164 | #ifdef CONFIG_X86_64 | 164 | #ifdef CONFIG_X86_64 |
| 165 | extern int save_mask_IO_APIC_setup(void); | 165 | extern int save_IO_APIC_setup(void); |
| 166 | extern void mask_IO_APIC_setup(void); | ||
| 166 | extern void restore_IO_APIC_setup(void); | 167 | extern void restore_IO_APIC_setup(void); |
| 167 | extern void reinit_intr_remapped_IO_APIC(int); | 168 | extern void reinit_intr_remapped_IO_APIC(int); |
| 168 | #endif | 169 | #endif |
| @@ -172,7 +173,7 @@ extern void probe_nr_irqs_gsi(void); | |||
| 172 | extern int setup_ioapic_entry(int apic, int irq, | 173 | extern int setup_ioapic_entry(int apic, int irq, |
| 173 | struct IO_APIC_route_entry *entry, | 174 | struct IO_APIC_route_entry *entry, |
| 174 | unsigned int destination, int trigger, | 175 | unsigned int destination, int trigger, |
| 175 | int polarity, int vector); | 176 | int polarity, int vector, int pin); |
| 176 | extern void ioapic_write_entry(int apic, int pin, | 177 | extern void ioapic_write_entry(int apic, int pin, |
| 177 | struct IO_APIC_route_entry e); | 178 | struct IO_APIC_route_entry e); |
| 178 | #else /* !CONFIG_X86_IO_APIC */ | 179 | #else /* !CONFIG_X86_IO_APIC */ |
diff --git a/arch/x86/include/asm/irq.h b/arch/x86/include/asm/irq.h index 107eb2196691..f38481bcd455 100644 --- a/arch/x86/include/asm/irq.h +++ b/arch/x86/include/asm/irq.h | |||
| @@ -36,6 +36,7 @@ static inline int irq_canonicalize(int irq) | |||
| 36 | extern void fixup_irqs(void); | 36 | extern void fixup_irqs(void); |
| 37 | #endif | 37 | #endif |
| 38 | 38 | ||
| 39 | extern void (*generic_interrupt_extension)(void); | ||
| 39 | extern void init_IRQ(void); | 40 | extern void init_IRQ(void); |
| 40 | extern void native_init_IRQ(void); | 41 | extern void native_init_IRQ(void); |
| 41 | extern bool handle_irq(unsigned irq, struct pt_regs *regs); | 42 | extern bool handle_irq(unsigned irq, struct pt_regs *regs); |
diff --git a/arch/x86/include/asm/irq_remapping.h b/arch/x86/include/asm/irq_remapping.h index 20e1fd588dbf..0396760fccb8 100644 --- a/arch/x86/include/asm/irq_remapping.h +++ b/arch/x86/include/asm/irq_remapping.h | |||
| @@ -1,8 +1,6 @@ | |||
| 1 | #ifndef _ASM_X86_IRQ_REMAPPING_H | 1 | #ifndef _ASM_X86_IRQ_REMAPPING_H |
| 2 | #define _ASM_X86_IRQ_REMAPPING_H | 2 | #define _ASM_X86_IRQ_REMAPPING_H |
| 3 | 3 | ||
| 4 | extern int x2apic; | ||
| 5 | |||
| 6 | #define IRTE_DEST(dest) ((x2apic) ? dest : dest << 8) | 4 | #define IRTE_DEST(dest) ((x2apic) ? dest : dest << 8) |
| 7 | 5 | ||
| 8 | #endif /* _ASM_X86_IRQ_REMAPPING_H */ | 6 | #endif /* _ASM_X86_IRQ_REMAPPING_H */ |
diff --git a/arch/x86/include/asm/irq_vectors.h b/arch/x86/include/asm/irq_vectors.h index 8a285f356f8a..3cbd79bbb47c 100644 --- a/arch/x86/include/asm/irq_vectors.h +++ b/arch/x86/include/asm/irq_vectors.h | |||
| @@ -112,6 +112,11 @@ | |||
| 112 | #define LOCAL_PERF_VECTOR 0xee | 112 | #define LOCAL_PERF_VECTOR 0xee |
| 113 | 113 | ||
| 114 | /* | 114 | /* |
| 115 | * Generic system vector for platform specific use | ||
| 116 | */ | ||
| 117 | #define GENERIC_INTERRUPT_VECTOR 0xed | ||
| 118 | |||
| 119 | /* | ||
| 115 | * First APIC vector available to drivers: (vectors 0x30-0xee) we | 120 | * First APIC vector available to drivers: (vectors 0x30-0xee) we |
| 116 | * start at 0x31(0x41) to spread out vectors evenly between priority | 121 | * start at 0x31(0x41) to spread out vectors evenly between priority |
| 117 | * levels. (0x80 is the syscall vector) | 122 | * levels. (0x80 is the syscall vector) |
diff --git a/arch/x86/include/asm/kexec.h b/arch/x86/include/asm/kexec.h index 0ceb6d19ed30..317ff1703d0b 100644 --- a/arch/x86/include/asm/kexec.h +++ b/arch/x86/include/asm/kexec.h | |||
| @@ -9,13 +9,13 @@ | |||
| 9 | # define PAGES_NR 4 | 9 | # define PAGES_NR 4 |
| 10 | #else | 10 | #else |
| 11 | # define PA_CONTROL_PAGE 0 | 11 | # define PA_CONTROL_PAGE 0 |
| 12 | # define PA_TABLE_PAGE 1 | 12 | # define VA_CONTROL_PAGE 1 |
| 13 | # define PAGES_NR 2 | 13 | # define PA_TABLE_PAGE 2 |
| 14 | # define PA_SWAP_PAGE 3 | ||
| 15 | # define PAGES_NR 4 | ||
| 14 | #endif | 16 | #endif |
| 15 | 17 | ||
| 16 | #ifdef CONFIG_X86_32 | ||
| 17 | # define KEXEC_CONTROL_CODE_MAX_SIZE 2048 | 18 | # define KEXEC_CONTROL_CODE_MAX_SIZE 2048 |
| 18 | #endif | ||
| 19 | 19 | ||
| 20 | #ifndef __ASSEMBLY__ | 20 | #ifndef __ASSEMBLY__ |
| 21 | 21 | ||
| @@ -136,10 +136,11 @@ relocate_kernel(unsigned long indirection_page, | |||
| 136 | unsigned int has_pae, | 136 | unsigned int has_pae, |
| 137 | unsigned int preserve_context); | 137 | unsigned int preserve_context); |
| 138 | #else | 138 | #else |
| 139 | NORET_TYPE void | 139 | unsigned long |
| 140 | relocate_kernel(unsigned long indirection_page, | 140 | relocate_kernel(unsigned long indirection_page, |
| 141 | unsigned long page_list, | 141 | unsigned long page_list, |
| 142 | unsigned long start_address) ATTRIB_NORET; | 142 | unsigned long start_address, |
| 143 | unsigned int preserve_context); | ||
| 143 | #endif | 144 | #endif |
| 144 | 145 | ||
| 145 | #define ARCH_HAS_KIMAGE_ARCH | 146 | #define ARCH_HAS_KIMAGE_ARCH |
diff --git a/arch/x86/include/asm/linkage.h b/arch/x86/include/asm/linkage.h index 9320e2a8a26a..12d55e773eb6 100644 --- a/arch/x86/include/asm/linkage.h +++ b/arch/x86/include/asm/linkage.h | |||
| @@ -1,14 +1,11 @@ | |||
| 1 | #ifndef _ASM_X86_LINKAGE_H | 1 | #ifndef _ASM_X86_LINKAGE_H |
| 2 | #define _ASM_X86_LINKAGE_H | 2 | #define _ASM_X86_LINKAGE_H |
| 3 | 3 | ||
| 4 | #include <linux/stringify.h> | ||
| 5 | |||
| 4 | #undef notrace | 6 | #undef notrace |
| 5 | #define notrace __attribute__((no_instrument_function)) | 7 | #define notrace __attribute__((no_instrument_function)) |
| 6 | 8 | ||
| 7 | #ifdef CONFIG_X86_64 | ||
| 8 | #define __ALIGN .p2align 4,,15 | ||
| 9 | #define __ALIGN_STR ".p2align 4,,15" | ||
| 10 | #endif | ||
| 11 | |||
| 12 | #ifdef CONFIG_X86_32 | 9 | #ifdef CONFIG_X86_32 |
| 13 | #define asmlinkage CPP_ASMLINKAGE __attribute__((regparm(0))) | 10 | #define asmlinkage CPP_ASMLINKAGE __attribute__((regparm(0))) |
| 14 | /* | 11 | /* |
| @@ -50,16 +47,20 @@ | |||
| 50 | __asmlinkage_protect_n(ret, "g" (arg1), "g" (arg2), "g" (arg3), \ | 47 | __asmlinkage_protect_n(ret, "g" (arg1), "g" (arg2), "g" (arg3), \ |
| 51 | "g" (arg4), "g" (arg5), "g" (arg6)) | 48 | "g" (arg4), "g" (arg5), "g" (arg6)) |
| 52 | 49 | ||
| 53 | #endif | 50 | #endif /* CONFIG_X86_32 */ |
| 51 | |||
| 52 | #ifdef __ASSEMBLY__ | ||
| 54 | 53 | ||
| 55 | #define GLOBAL(name) \ | 54 | #define GLOBAL(name) \ |
| 56 | .globl name; \ | 55 | .globl name; \ |
| 57 | name: | 56 | name: |
| 58 | 57 | ||
| 59 | #ifdef CONFIG_X86_ALIGNMENT_16 | 58 | #if defined(CONFIG_X86_64) || defined(CONFIG_X86_ALIGNMENT_16) |
| 60 | #define __ALIGN .align 16,0x90 | 59 | #define __ALIGN .p2align 4, 0x90 |
| 61 | #define __ALIGN_STR ".align 16,0x90" | 60 | #define __ALIGN_STR __stringify(__ALIGN) |
| 62 | #endif | 61 | #endif |
| 63 | 62 | ||
| 63 | #endif /* __ASSEMBLY__ */ | ||
| 64 | |||
| 64 | #endif /* _ASM_X86_LINKAGE_H */ | 65 | #endif /* _ASM_X86_LINKAGE_H */ |
| 65 | 66 | ||
diff --git a/arch/x86/include/asm/mce.h b/arch/x86/include/asm/mce.h index 32c6e17b960b..563933e06a35 100644 --- a/arch/x86/include/asm/mce.h +++ b/arch/x86/include/asm/mce.h | |||
| @@ -11,6 +11,8 @@ | |||
| 11 | */ | 11 | */ |
| 12 | 12 | ||
| 13 | #define MCG_CTL_P (1UL<<8) /* MCG_CAP register available */ | 13 | #define MCG_CTL_P (1UL<<8) /* MCG_CAP register available */ |
| 14 | #define MCG_EXT_P (1ULL<<9) /* Extended registers available */ | ||
| 15 | #define MCG_CMCI_P (1ULL<<10) /* CMCI supported */ | ||
| 14 | 16 | ||
| 15 | #define MCG_STATUS_RIPV (1UL<<0) /* restart ip valid */ | 17 | #define MCG_STATUS_RIPV (1UL<<0) /* restart ip valid */ |
| 16 | #define MCG_STATUS_EIPV (1UL<<1) /* ip points to correct instruction */ | 18 | #define MCG_STATUS_EIPV (1UL<<1) /* ip points to correct instruction */ |
| @@ -90,14 +92,29 @@ extern int mce_disabled; | |||
| 90 | 92 | ||
| 91 | #include <asm/atomic.h> | 93 | #include <asm/atomic.h> |
| 92 | 94 | ||
| 95 | void mce_setup(struct mce *m); | ||
| 93 | void mce_log(struct mce *m); | 96 | void mce_log(struct mce *m); |
| 94 | DECLARE_PER_CPU(struct sys_device, device_mce); | 97 | DECLARE_PER_CPU(struct sys_device, device_mce); |
| 95 | extern void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu); | 98 | extern void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu); |
| 96 | 99 | ||
| 100 | /* | ||
| 101 | * To support more than 128 would need to escape the predefined | ||
| 102 | * Linux defined extended banks first. | ||
| 103 | */ | ||
| 104 | #define MAX_NR_BANKS (MCE_EXTENDED_BANK - 1) | ||
| 105 | |||
| 97 | #ifdef CONFIG_X86_MCE_INTEL | 106 | #ifdef CONFIG_X86_MCE_INTEL |
| 98 | void mce_intel_feature_init(struct cpuinfo_x86 *c); | 107 | void mce_intel_feature_init(struct cpuinfo_x86 *c); |
| 108 | void cmci_clear(void); | ||
| 109 | void cmci_reenable(void); | ||
| 110 | void cmci_rediscover(int dying); | ||
| 111 | void cmci_recheck(void); | ||
| 99 | #else | 112 | #else |
| 100 | static inline void mce_intel_feature_init(struct cpuinfo_x86 *c) { } | 113 | static inline void mce_intel_feature_init(struct cpuinfo_x86 *c) { } |
| 114 | static inline void cmci_clear(void) {} | ||
| 115 | static inline void cmci_reenable(void) {} | ||
| 116 | static inline void cmci_rediscover(int dying) {} | ||
| 117 | static inline void cmci_recheck(void) {} | ||
| 101 | #endif | 118 | #endif |
| 102 | 119 | ||
| 103 | #ifdef CONFIG_X86_MCE_AMD | 120 | #ifdef CONFIG_X86_MCE_AMD |
| @@ -106,11 +123,23 @@ void mce_amd_feature_init(struct cpuinfo_x86 *c); | |||
| 106 | static inline void mce_amd_feature_init(struct cpuinfo_x86 *c) { } | 123 | static inline void mce_amd_feature_init(struct cpuinfo_x86 *c) { } |
| 107 | #endif | 124 | #endif |
| 108 | 125 | ||
| 109 | void mce_log_therm_throt_event(unsigned int cpu, __u64 status); | 126 | extern int mce_available(struct cpuinfo_x86 *c); |
| 127 | |||
| 128 | void mce_log_therm_throt_event(__u64 status); | ||
| 110 | 129 | ||
| 111 | extern atomic_t mce_entry; | 130 | extern atomic_t mce_entry; |
| 112 | 131 | ||
| 113 | extern void do_machine_check(struct pt_regs *, long); | 132 | extern void do_machine_check(struct pt_regs *, long); |
| 133 | |||
| 134 | typedef DECLARE_BITMAP(mce_banks_t, MAX_NR_BANKS); | ||
| 135 | DECLARE_PER_CPU(mce_banks_t, mce_poll_banks); | ||
| 136 | |||
| 137 | enum mcp_flags { | ||
| 138 | MCP_TIMESTAMP = (1 << 0), /* log time stamp */ | ||
| 139 | MCP_UC = (1 << 1), /* log uncorrected errors */ | ||
| 140 | }; | ||
| 141 | extern void machine_check_poll(enum mcp_flags flags, mce_banks_t *b); | ||
| 142 | |||
| 114 | extern int mce_notify_user(void); | 143 | extern int mce_notify_user(void); |
| 115 | 144 | ||
| 116 | #endif /* !CONFIG_X86_32 */ | 145 | #endif /* !CONFIG_X86_32 */ |
| @@ -120,8 +149,8 @@ extern void mcheck_init(struct cpuinfo_x86 *c); | |||
| 120 | #else | 149 | #else |
| 121 | #define mcheck_init(c) do { } while (0) | 150 | #define mcheck_init(c) do { } while (0) |
| 122 | #endif | 151 | #endif |
| 123 | extern void stop_mce(void); | 152 | |
| 124 | extern void restart_mce(void); | 153 | extern void (*mce_threshold_vector)(void); |
| 125 | 154 | ||
| 126 | #endif /* __KERNEL__ */ | 155 | #endif /* __KERNEL__ */ |
| 127 | #endif /* _ASM_X86_MCE_H */ | 156 | #endif /* _ASM_X86_MCE_H */ |
diff --git a/arch/x86/include/asm/msidef.h b/arch/x86/include/asm/msidef.h index 6706b3006f13..4cc48af23fef 100644 --- a/arch/x86/include/asm/msidef.h +++ b/arch/x86/include/asm/msidef.h | |||
| @@ -47,6 +47,7 @@ | |||
| 47 | #define MSI_ADDR_DEST_ID_MASK 0x00ffff0 | 47 | #define MSI_ADDR_DEST_ID_MASK 0x00ffff0 |
| 48 | #define MSI_ADDR_DEST_ID(dest) (((dest) << MSI_ADDR_DEST_ID_SHIFT) & \ | 48 | #define MSI_ADDR_DEST_ID(dest) (((dest) << MSI_ADDR_DEST_ID_SHIFT) & \ |
| 49 | MSI_ADDR_DEST_ID_MASK) | 49 | MSI_ADDR_DEST_ID_MASK) |
| 50 | #define MSI_ADDR_EXT_DEST_ID(dest) ((dest) & 0xffffff00) | ||
| 50 | 51 | ||
| 51 | #define MSI_ADDR_IR_EXT_INT (1 << 4) | 52 | #define MSI_ADDR_IR_EXT_INT (1 << 4) |
| 52 | #define MSI_ADDR_IR_SHV (1 << 3) | 53 | #define MSI_ADDR_IR_SHV (1 << 3) |
diff --git a/arch/x86/include/asm/msr-index.h b/arch/x86/include/asm/msr-index.h index f4e505f286bc..ec41fc16c167 100644 --- a/arch/x86/include/asm/msr-index.h +++ b/arch/x86/include/asm/msr-index.h | |||
| @@ -81,6 +81,11 @@ | |||
| 81 | #define MSR_IA32_MC0_ADDR 0x00000402 | 81 | #define MSR_IA32_MC0_ADDR 0x00000402 |
| 82 | #define MSR_IA32_MC0_MISC 0x00000403 | 82 | #define MSR_IA32_MC0_MISC 0x00000403 |
| 83 | 83 | ||
| 84 | /* These are consecutive and not in the normal 4er MCE bank block */ | ||
| 85 | #define MSR_IA32_MC0_CTL2 0x00000280 | ||
| 86 | #define CMCI_EN (1ULL << 30) | ||
| 87 | #define CMCI_THRESHOLD_MASK 0xffffULL | ||
| 88 | |||
| 84 | #define MSR_P6_PERFCTR0 0x000000c1 | 89 | #define MSR_P6_PERFCTR0 0x000000c1 |
| 85 | #define MSR_P6_PERFCTR1 0x000000c2 | 90 | #define MSR_P6_PERFCTR1 0x000000c2 |
| 86 | #define MSR_P6_EVNTSEL0 0x00000186 | 91 | #define MSR_P6_EVNTSEL0 0x00000186 |
diff --git a/arch/x86/include/asm/page_32_types.h b/arch/x86/include/asm/page_32_types.h index f1e4a79a6e41..0f915ae649a7 100644 --- a/arch/x86/include/asm/page_32_types.h +++ b/arch/x86/include/asm/page_32_types.h | |||
| @@ -39,6 +39,11 @@ | |||
| 39 | #define __VIRTUAL_MASK_SHIFT 32 | 39 | #define __VIRTUAL_MASK_SHIFT 32 |
| 40 | #endif /* CONFIG_X86_PAE */ | 40 | #endif /* CONFIG_X86_PAE */ |
| 41 | 41 | ||
| 42 | /* | ||
| 43 | * Kernel image size is limited to 512 MB (see in arch/x86/kernel/head_32.S) | ||
| 44 | */ | ||
| 45 | #define KERNEL_IMAGE_SIZE (512 * 1024 * 1024) | ||
| 46 | |||
| 42 | #ifndef __ASSEMBLY__ | 47 | #ifndef __ASSEMBLY__ |
| 43 | 48 | ||
| 44 | /* | 49 | /* |
diff --git a/arch/x86/include/asm/page_types.h b/arch/x86/include/asm/page_types.h index 2d625da6603c..826ad37006ab 100644 --- a/arch/x86/include/asm/page_types.h +++ b/arch/x86/include/asm/page_types.h | |||
| @@ -40,14 +40,8 @@ | |||
| 40 | 40 | ||
| 41 | #ifndef __ASSEMBLY__ | 41 | #ifndef __ASSEMBLY__ |
| 42 | 42 | ||
| 43 | struct pgprot; | ||
| 44 | |||
| 45 | extern int page_is_ram(unsigned long pagenr); | 43 | extern int page_is_ram(unsigned long pagenr); |
| 46 | extern int devmem_is_allowed(unsigned long pagenr); | 44 | extern int devmem_is_allowed(unsigned long pagenr); |
| 47 | extern void map_devmem(unsigned long pfn, unsigned long size, | ||
| 48 | struct pgprot vma_prot); | ||
| 49 | extern void unmap_devmem(unsigned long pfn, unsigned long size, | ||
| 50 | struct pgprot vma_prot); | ||
| 51 | 45 | ||
| 52 | extern unsigned long max_low_pfn_mapped; | 46 | extern unsigned long max_low_pfn_mapped; |
| 53 | extern unsigned long max_pfn_mapped; | 47 | extern unsigned long max_pfn_mapped; |
diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h index 0617d5cc9712..7727aa8b7dda 100644 --- a/arch/x86/include/asm/paravirt.h +++ b/arch/x86/include/asm/paravirt.h | |||
| @@ -317,8 +317,6 @@ struct pv_mmu_ops { | |||
| 317 | #if PAGETABLE_LEVELS >= 3 | 317 | #if PAGETABLE_LEVELS >= 3 |
| 318 | #ifdef CONFIG_X86_PAE | 318 | #ifdef CONFIG_X86_PAE |
| 319 | void (*set_pte_atomic)(pte_t *ptep, pte_t pteval); | 319 | void (*set_pte_atomic)(pte_t *ptep, pte_t pteval); |
| 320 | void (*set_pte_present)(struct mm_struct *mm, unsigned long addr, | ||
| 321 | pte_t *ptep, pte_t pte); | ||
| 322 | void (*pte_clear)(struct mm_struct *mm, unsigned long addr, | 320 | void (*pte_clear)(struct mm_struct *mm, unsigned long addr, |
| 323 | pte_t *ptep); | 321 | pte_t *ptep); |
| 324 | void (*pmd_clear)(pmd_t *pmdp); | 322 | void (*pmd_clear)(pmd_t *pmdp); |
| @@ -389,7 +387,7 @@ extern struct pv_lock_ops pv_lock_ops; | |||
| 389 | 387 | ||
| 390 | #define paravirt_type(op) \ | 388 | #define paravirt_type(op) \ |
| 391 | [paravirt_typenum] "i" (PARAVIRT_PATCH(op)), \ | 389 | [paravirt_typenum] "i" (PARAVIRT_PATCH(op)), \ |
| 392 | [paravirt_opptr] "m" (op) | 390 | [paravirt_opptr] "i" (&(op)) |
| 393 | #define paravirt_clobber(clobber) \ | 391 | #define paravirt_clobber(clobber) \ |
| 394 | [paravirt_clobber] "i" (clobber) | 392 | [paravirt_clobber] "i" (clobber) |
| 395 | 393 | ||
| @@ -443,7 +441,7 @@ int paravirt_disable_iospace(void); | |||
| 443 | * offset into the paravirt_patch_template structure, and can therefore be | 441 | * offset into the paravirt_patch_template structure, and can therefore be |
| 444 | * freely converted back into a structure offset. | 442 | * freely converted back into a structure offset. |
| 445 | */ | 443 | */ |
| 446 | #define PARAVIRT_CALL "call *%[paravirt_opptr];" | 444 | #define PARAVIRT_CALL "call *%c[paravirt_opptr];" |
| 447 | 445 | ||
| 448 | /* | 446 | /* |
| 449 | * These macros are intended to wrap calls through one of the paravirt | 447 | * These macros are intended to wrap calls through one of the paravirt |
| @@ -1365,13 +1363,6 @@ static inline void set_pte_atomic(pte_t *ptep, pte_t pte) | |||
| 1365 | pte.pte, pte.pte >> 32); | 1363 | pte.pte, pte.pte >> 32); |
| 1366 | } | 1364 | } |
| 1367 | 1365 | ||
| 1368 | static inline void set_pte_present(struct mm_struct *mm, unsigned long addr, | ||
| 1369 | pte_t *ptep, pte_t pte) | ||
| 1370 | { | ||
| 1371 | /* 5 arg words */ | ||
| 1372 | pv_mmu_ops.set_pte_present(mm, addr, ptep, pte); | ||
| 1373 | } | ||
| 1374 | |||
| 1375 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, | 1366 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, |
| 1376 | pte_t *ptep) | 1367 | pte_t *ptep) |
| 1377 | { | 1368 | { |
| @@ -1388,12 +1379,6 @@ static inline void set_pte_atomic(pte_t *ptep, pte_t pte) | |||
| 1388 | set_pte(ptep, pte); | 1379 | set_pte(ptep, pte); |
| 1389 | } | 1380 | } |
| 1390 | 1381 | ||
| 1391 | static inline void set_pte_present(struct mm_struct *mm, unsigned long addr, | ||
| 1392 | pte_t *ptep, pte_t pte) | ||
| 1393 | { | ||
| 1394 | set_pte(ptep, pte); | ||
| 1395 | } | ||
| 1396 | |||
| 1397 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, | 1382 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, |
| 1398 | pte_t *ptep) | 1383 | pte_t *ptep) |
| 1399 | { | 1384 | { |
diff --git a/arch/x86/include/asm/pat.h b/arch/x86/include/asm/pat.h index b0e70056838e..2cd07b9422f4 100644 --- a/arch/x86/include/asm/pat.h +++ b/arch/x86/include/asm/pat.h | |||
| @@ -2,6 +2,7 @@ | |||
| 2 | #define _ASM_X86_PAT_H | 2 | #define _ASM_X86_PAT_H |
| 3 | 3 | ||
| 4 | #include <linux/types.h> | 4 | #include <linux/types.h> |
| 5 | #include <asm/pgtable_types.h> | ||
| 5 | 6 | ||
| 6 | #ifdef CONFIG_X86_PAT | 7 | #ifdef CONFIG_X86_PAT |
| 7 | extern int pat_enabled; | 8 | extern int pat_enabled; |
| @@ -17,5 +18,9 @@ extern int free_memtype(u64 start, u64 end); | |||
| 17 | 18 | ||
| 18 | extern int kernel_map_sync_memtype(u64 base, unsigned long size, | 19 | extern int kernel_map_sync_memtype(u64 base, unsigned long size, |
| 19 | unsigned long flag); | 20 | unsigned long flag); |
| 21 | extern void map_devmem(unsigned long pfn, unsigned long size, | ||
| 22 | struct pgprot vma_prot); | ||
| 23 | extern void unmap_devmem(unsigned long pfn, unsigned long size, | ||
| 24 | struct pgprot vma_prot); | ||
| 20 | 25 | ||
| 21 | #endif /* _ASM_X86_PAT_H */ | 26 | #endif /* _ASM_X86_PAT_H */ |
diff --git a/arch/x86/include/asm/pgtable-2level.h b/arch/x86/include/asm/pgtable-2level.h index c1774ac9da7a..2334982b339e 100644 --- a/arch/x86/include/asm/pgtable-2level.h +++ b/arch/x86/include/asm/pgtable-2level.h | |||
| @@ -26,13 +26,6 @@ static inline void native_set_pte_atomic(pte_t *ptep, pte_t pte) | |||
| 26 | native_set_pte(ptep, pte); | 26 | native_set_pte(ptep, pte); |
| 27 | } | 27 | } |
| 28 | 28 | ||
| 29 | static inline void native_set_pte_present(struct mm_struct *mm, | ||
| 30 | unsigned long addr, | ||
| 31 | pte_t *ptep, pte_t pte) | ||
| 32 | { | ||
| 33 | native_set_pte(ptep, pte); | ||
| 34 | } | ||
| 35 | |||
| 36 | static inline void native_pmd_clear(pmd_t *pmdp) | 29 | static inline void native_pmd_clear(pmd_t *pmdp) |
| 37 | { | 30 | { |
| 38 | native_set_pmd(pmdp, __pmd(0)); | 31 | native_set_pmd(pmdp, __pmd(0)); |
diff --git a/arch/x86/include/asm/pgtable-3level.h b/arch/x86/include/asm/pgtable-3level.h index 3f13cdf61156..177b0165ea01 100644 --- a/arch/x86/include/asm/pgtable-3level.h +++ b/arch/x86/include/asm/pgtable-3level.h | |||
| @@ -31,23 +31,6 @@ static inline void native_set_pte(pte_t *ptep, pte_t pte) | |||
| 31 | ptep->pte_low = pte.pte_low; | 31 | ptep->pte_low = pte.pte_low; |
| 32 | } | 32 | } |
| 33 | 33 | ||
| 34 | /* | ||
| 35 | * Since this is only called on user PTEs, and the page fault handler | ||
| 36 | * must handle the already racy situation of simultaneous page faults, | ||
| 37 | * we are justified in merely clearing the PTE present bit, followed | ||
| 38 | * by a set. The ordering here is important. | ||
| 39 | */ | ||
| 40 | static inline void native_set_pte_present(struct mm_struct *mm, | ||
| 41 | unsigned long addr, | ||
| 42 | pte_t *ptep, pte_t pte) | ||
| 43 | { | ||
| 44 | ptep->pte_low = 0; | ||
| 45 | smp_wmb(); | ||
| 46 | ptep->pte_high = pte.pte_high; | ||
| 47 | smp_wmb(); | ||
| 48 | ptep->pte_low = pte.pte_low; | ||
| 49 | } | ||
| 50 | |||
| 51 | static inline void native_set_pte_atomic(pte_t *ptep, pte_t pte) | 34 | static inline void native_set_pte_atomic(pte_t *ptep, pte_t pte) |
| 52 | { | 35 | { |
| 53 | set_64bit((unsigned long long *)(ptep), native_pte_val(pte)); | 36 | set_64bit((unsigned long long *)(ptep), native_pte_val(pte)); |
diff --git a/arch/x86/include/asm/pgtable.h b/arch/x86/include/asm/pgtable.h index d0812e155f1d..29d96d168bc0 100644 --- a/arch/x86/include/asm/pgtable.h +++ b/arch/x86/include/asm/pgtable.h | |||
| @@ -31,8 +31,6 @@ extern struct list_head pgd_list; | |||
| 31 | #define set_pte(ptep, pte) native_set_pte(ptep, pte) | 31 | #define set_pte(ptep, pte) native_set_pte(ptep, pte) |
| 32 | #define set_pte_at(mm, addr, ptep, pte) native_set_pte_at(mm, addr, ptep, pte) | 32 | #define set_pte_at(mm, addr, ptep, pte) native_set_pte_at(mm, addr, ptep, pte) |
| 33 | 33 | ||
| 34 | #define set_pte_present(mm, addr, ptep, pte) \ | ||
| 35 | native_set_pte_present(mm, addr, ptep, pte) | ||
| 36 | #define set_pte_atomic(ptep, pte) \ | 34 | #define set_pte_atomic(ptep, pte) \ |
| 37 | native_set_pte_atomic(ptep, pte) | 35 | native_set_pte_atomic(ptep, pte) |
| 38 | 36 | ||
diff --git a/arch/x86/include/asm/pgtable_32.h b/arch/x86/include/asm/pgtable_32.h index 97612fc7632f..31bd120cf2a2 100644 --- a/arch/x86/include/asm/pgtable_32.h +++ b/arch/x86/include/asm/pgtable_32.h | |||
| @@ -42,9 +42,6 @@ extern void set_pmd_pfn(unsigned long, unsigned long, pgprot_t); | |||
| 42 | */ | 42 | */ |
| 43 | #undef TEST_ACCESS_OK | 43 | #undef TEST_ACCESS_OK |
| 44 | 44 | ||
| 45 | /* The boot page tables (all created as a single array) */ | ||
| 46 | extern unsigned long pg0[]; | ||
| 47 | |||
| 48 | #ifdef CONFIG_X86_PAE | 45 | #ifdef CONFIG_X86_PAE |
| 49 | # include <asm/pgtable-3level.h> | 46 | # include <asm/pgtable-3level.h> |
| 50 | #else | 47 | #else |
diff --git a/arch/x86/include/asm/pgtable_32_types.h b/arch/x86/include/asm/pgtable_32_types.h index bd8df3b2fe04..2733fad45f98 100644 --- a/arch/x86/include/asm/pgtable_32_types.h +++ b/arch/x86/include/asm/pgtable_32_types.h | |||
| @@ -25,6 +25,11 @@ | |||
| 25 | * area for the same reason. ;) | 25 | * area for the same reason. ;) |
| 26 | */ | 26 | */ |
| 27 | #define VMALLOC_OFFSET (8 * 1024 * 1024) | 27 | #define VMALLOC_OFFSET (8 * 1024 * 1024) |
| 28 | |||
| 29 | #ifndef __ASSEMBLER__ | ||
| 30 | extern bool __vmalloc_start_set; /* set once high_memory is set */ | ||
| 31 | #endif | ||
| 32 | |||
| 28 | #define VMALLOC_START ((unsigned long)high_memory + VMALLOC_OFFSET) | 33 | #define VMALLOC_START ((unsigned long)high_memory + VMALLOC_OFFSET) |
| 29 | #ifdef CONFIG_X86_PAE | 34 | #ifdef CONFIG_X86_PAE |
| 30 | #define LAST_PKMAP 512 | 35 | #define LAST_PKMAP 512 |
diff --git a/arch/x86/include/asm/pgtable_types.h b/arch/x86/include/asm/pgtable_types.h index 4d258ad76a0f..b8238dc8786d 100644 --- a/arch/x86/include/asm/pgtable_types.h +++ b/arch/x86/include/asm/pgtable_types.h | |||
| @@ -273,6 +273,7 @@ typedef struct page *pgtable_t; | |||
| 273 | 273 | ||
| 274 | extern pteval_t __supported_pte_mask; | 274 | extern pteval_t __supported_pte_mask; |
| 275 | extern int nx_enabled; | 275 | extern int nx_enabled; |
| 276 | extern void set_nx(void); | ||
| 276 | 277 | ||
| 277 | #define pgprot_writecombine pgprot_writecombine | 278 | #define pgprot_writecombine pgprot_writecombine |
| 278 | extern pgprot_t pgprot_writecombine(pgprot_t prot); | 279 | extern pgprot_t pgprot_writecombine(pgprot_t prot); |
diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h index 76139506c3e4..ae85a8d66a30 100644 --- a/arch/x86/include/asm/processor.h +++ b/arch/x86/include/asm/processor.h | |||
| @@ -75,9 +75,9 @@ struct cpuinfo_x86 { | |||
| 75 | #else | 75 | #else |
| 76 | /* Number of 4K pages in DTLB/ITLB combined(in pages): */ | 76 | /* Number of 4K pages in DTLB/ITLB combined(in pages): */ |
| 77 | int x86_tlbsize; | 77 | int x86_tlbsize; |
| 78 | #endif | ||
| 78 | __u8 x86_virt_bits; | 79 | __u8 x86_virt_bits; |
| 79 | __u8 x86_phys_bits; | 80 | __u8 x86_phys_bits; |
| 80 | #endif | ||
| 81 | /* CPUID returned core id bits: */ | 81 | /* CPUID returned core id bits: */ |
| 82 | __u8 x86_coreid_bits; | 82 | __u8 x86_coreid_bits; |
| 83 | /* Max extended CPUID function supported: */ | 83 | /* Max extended CPUID function supported: */ |
| @@ -391,6 +391,9 @@ DECLARE_PER_CPU(union irq_stack_union, irq_stack_union); | |||
| 391 | DECLARE_INIT_PER_CPU(irq_stack_union); | 391 | DECLARE_INIT_PER_CPU(irq_stack_union); |
| 392 | 392 | ||
| 393 | DECLARE_PER_CPU(char *, irq_stack_ptr); | 393 | DECLARE_PER_CPU(char *, irq_stack_ptr); |
| 394 | DECLARE_PER_CPU(unsigned int, irq_count); | ||
| 395 | extern unsigned long kernel_eflags; | ||
| 396 | extern asmlinkage void ignore_sysret(void); | ||
| 394 | #else /* X86_64 */ | 397 | #else /* X86_64 */ |
| 395 | #ifdef CONFIG_CC_STACKPROTECTOR | 398 | #ifdef CONFIG_CC_STACKPROTECTOR |
| 396 | DECLARE_PER_CPU(unsigned long, stack_canary); | 399 | DECLARE_PER_CPU(unsigned long, stack_canary); |
diff --git a/arch/x86/include/asm/sections.h b/arch/x86/include/asm/sections.h index 2b8c5160388f..1b7ee5d673c2 100644 --- a/arch/x86/include/asm/sections.h +++ b/arch/x86/include/asm/sections.h | |||
| @@ -1 +1,8 @@ | |||
| 1 | #ifndef _ASM_X86_SECTIONS_H | ||
| 2 | #define _ASM_X86_SECTIONS_H | ||
| 3 | |||
| 1 | #include <asm-generic/sections.h> | 4 | #include <asm-generic/sections.h> |
| 5 | |||
| 6 | extern char __brk_base[], __brk_limit[]; | ||
| 7 | |||
| 8 | #endif /* _ASM_X86_SECTIONS_H */ | ||
diff --git a/arch/x86/include/asm/setup.h b/arch/x86/include/asm/setup.h index 05c6f6b11fd5..bdc2ada05ae0 100644 --- a/arch/x86/include/asm/setup.h +++ b/arch/x86/include/asm/setup.h | |||
| @@ -64,7 +64,7 @@ extern void x86_quirk_time_init(void); | |||
| 64 | #include <asm/bootparam.h> | 64 | #include <asm/bootparam.h> |
| 65 | 65 | ||
| 66 | /* Interrupt control for vSMPowered x86_64 systems */ | 66 | /* Interrupt control for vSMPowered x86_64 systems */ |
| 67 | #ifdef CONFIG_X86_VSMP | 67 | #ifdef CONFIG_X86_64 |
| 68 | void vsmp_init(void); | 68 | void vsmp_init(void); |
| 69 | #else | 69 | #else |
| 70 | static inline void vsmp_init(void) { } | 70 | static inline void vsmp_init(void) { } |
| @@ -100,20 +100,51 @@ extern struct boot_params boot_params; | |||
| 100 | */ | 100 | */ |
| 101 | #define LOWMEMSIZE() (0x9f000) | 101 | #define LOWMEMSIZE() (0x9f000) |
| 102 | 102 | ||
| 103 | /* exceedingly early brk-like allocator */ | ||
| 104 | extern unsigned long _brk_end; | ||
| 105 | void *extend_brk(size_t size, size_t align); | ||
| 106 | |||
| 107 | /* | ||
| 108 | * Reserve space in the brk section. The name must be unique within | ||
| 109 | * the file, and somewhat descriptive. The size is in bytes. Must be | ||
| 110 | * used at file scope. | ||
| 111 | * | ||
| 112 | * (This uses a temp function to wrap the asm so we can pass it the | ||
| 113 | * size parameter; otherwise we wouldn't be able to. We can't use a | ||
| 114 | * "section" attribute on a normal variable because it always ends up | ||
| 115 | * being @progbits, which ends up allocating space in the vmlinux | ||
| 116 | * executable.) | ||
| 117 | */ | ||
| 118 | #define RESERVE_BRK(name,sz) \ | ||
| 119 | static void __section(.discard) __used \ | ||
| 120 | __brk_reservation_fn_##name##__(void) { \ | ||
| 121 | asm volatile ( \ | ||
| 122 | ".pushsection .brk_reservation,\"aw\",@nobits;" \ | ||
| 123 | ".brk." #name ":" \ | ||
| 124 | " 1:.skip %c0;" \ | ||
| 125 | " .size .brk." #name ", . - 1b;" \ | ||
| 126 | " .popsection" \ | ||
| 127 | : : "i" (sz)); \ | ||
| 128 | } | ||
| 129 | |||
| 103 | #ifdef __i386__ | 130 | #ifdef __i386__ |
| 104 | 131 | ||
| 105 | void __init i386_start_kernel(void); | 132 | void __init i386_start_kernel(void); |
| 106 | extern void probe_roms(void); | 133 | extern void probe_roms(void); |
| 107 | 134 | ||
| 108 | extern unsigned long init_pg_tables_start; | ||
| 109 | extern unsigned long init_pg_tables_end; | ||
| 110 | |||
| 111 | #else | 135 | #else |
| 112 | void __init x86_64_start_kernel(char *real_mode); | 136 | void __init x86_64_start_kernel(char *real_mode); |
| 113 | void __init x86_64_start_reservations(char *real_mode_data); | 137 | void __init x86_64_start_reservations(char *real_mode_data); |
| 114 | 138 | ||
| 115 | #endif /* __i386__ */ | 139 | #endif /* __i386__ */ |
| 116 | #endif /* _SETUP */ | 140 | #endif /* _SETUP */ |
| 141 | #else | ||
| 142 | #define RESERVE_BRK(name,sz) \ | ||
| 143 | .pushsection .brk_reservation,"aw",@nobits; \ | ||
| 144 | .brk.name: \ | ||
| 145 | 1: .skip sz; \ | ||
| 146 | .size .brk.name,.-1b; \ | ||
| 147 | .popsection | ||
| 117 | #endif /* __ASSEMBLY__ */ | 148 | #endif /* __ASSEMBLY__ */ |
| 118 | #endif /* __KERNEL__ */ | 149 | #endif /* __KERNEL__ */ |
| 119 | 150 | ||
diff --git a/arch/x86/include/asm/uv/uv_hub.h b/arch/x86/include/asm/uv/uv_hub.h index 777327ef05c1..9f4dfba33b28 100644 --- a/arch/x86/include/asm/uv/uv_hub.h +++ b/arch/x86/include/asm/uv/uv_hub.h | |||
| @@ -199,6 +199,10 @@ DECLARE_PER_CPU(struct uv_hub_info_s, __uv_hub_info); | |||
| 199 | #define SCIR_CPU_ACTIVITY 0x02 /* not idle */ | 199 | #define SCIR_CPU_ACTIVITY 0x02 /* not idle */ |
| 200 | #define SCIR_CPU_HB_INTERVAL (HZ) /* once per second */ | 200 | #define SCIR_CPU_HB_INTERVAL (HZ) /* once per second */ |
| 201 | 201 | ||
| 202 | /* Loop through all installed blades */ | ||
| 203 | #define for_each_possible_blade(bid) \ | ||
| 204 | for ((bid) = 0; (bid) < uv_num_possible_blades(); (bid)++) | ||
| 205 | |||
| 202 | /* | 206 | /* |
| 203 | * Macros for converting between kernel virtual addresses, socket local physical | 207 | * Macros for converting between kernel virtual addresses, socket local physical |
| 204 | * addresses, and UV global physical addresses. | 208 | * addresses, and UV global physical addresses. |
diff --git a/arch/x86/include/asm/xen/hypercall.h b/arch/x86/include/asm/xen/hypercall.h index 5e79ca694326..9c371e4a9fa6 100644 --- a/arch/x86/include/asm/xen/hypercall.h +++ b/arch/x86/include/asm/xen/hypercall.h | |||
| @@ -296,6 +296,8 @@ HYPERVISOR_get_debugreg(int reg) | |||
| 296 | static inline int | 296 | static inline int |
| 297 | HYPERVISOR_update_descriptor(u64 ma, u64 desc) | 297 | HYPERVISOR_update_descriptor(u64 ma, u64 desc) |
| 298 | { | 298 | { |
| 299 | if (sizeof(u64) == sizeof(long)) | ||
| 300 | return _hypercall2(int, update_descriptor, ma, desc); | ||
| 299 | return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32); | 301 | return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32); |
| 300 | } | 302 | } |
| 301 | 303 | ||
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile index 95f216bbfaf1..6e9c1f320acf 100644 --- a/arch/x86/kernel/Makefile +++ b/arch/x86/kernel/Makefile | |||
| @@ -70,7 +70,6 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o | |||
| 70 | obj-$(CONFIG_KEXEC) += machine_kexec_$(BITS).o | 70 | obj-$(CONFIG_KEXEC) += machine_kexec_$(BITS).o |
| 71 | obj-$(CONFIG_KEXEC) += relocate_kernel_$(BITS).o crash.o | 71 | obj-$(CONFIG_KEXEC) += relocate_kernel_$(BITS).o crash.o |
| 72 | obj-$(CONFIG_CRASH_DUMP) += crash_dump_$(BITS).o | 72 | obj-$(CONFIG_CRASH_DUMP) += crash_dump_$(BITS).o |
| 73 | obj-$(CONFIG_X86_VSMP) += vsmp_64.o | ||
| 74 | obj-$(CONFIG_KPROBES) += kprobes.o | 73 | obj-$(CONFIG_KPROBES) += kprobes.o |
| 75 | obj-$(CONFIG_MODULES) += module_$(BITS).o | 74 | obj-$(CONFIG_MODULES) += module_$(BITS).o |
| 76 | obj-$(CONFIG_EFI) += efi.o efi_$(BITS).o efi_stub_$(BITS).o | 75 | obj-$(CONFIG_EFI) += efi.o efi_$(BITS).o efi_stub_$(BITS).o |
| @@ -111,7 +110,7 @@ obj-$(CONFIG_SWIOTLB) += pci-swiotlb_64.o # NB rename without _64 | |||
| 111 | ### | 110 | ### |
| 112 | # 64 bit specific files | 111 | # 64 bit specific files |
| 113 | ifeq ($(CONFIG_X86_64),y) | 112 | ifeq ($(CONFIG_X86_64),y) |
| 114 | obj-$(CONFIG_X86_UV) += tlb_uv.o bios_uv.o uv_irq.o uv_sysfs.o | 113 | obj-$(CONFIG_X86_UV) += tlb_uv.o bios_uv.o uv_irq.o uv_sysfs.o uv_time.o |
| 115 | obj-$(CONFIG_X86_PM_TIMER) += pmtimer_64.o | 114 | obj-$(CONFIG_X86_PM_TIMER) += pmtimer_64.o |
| 116 | obj-$(CONFIG_AUDIT) += audit_64.o | 115 | obj-$(CONFIG_AUDIT) += audit_64.o |
| 117 | 116 | ||
| @@ -120,4 +119,5 @@ ifeq ($(CONFIG_X86_64),y) | |||
| 120 | obj-$(CONFIG_AMD_IOMMU) += amd_iommu_init.o amd_iommu.o | 119 | obj-$(CONFIG_AMD_IOMMU) += amd_iommu_init.o amd_iommu.o |
| 121 | 120 | ||
| 122 | obj-$(CONFIG_PCI_MMCONFIG) += mmconf-fam10h_64.o | 121 | obj-$(CONFIG_PCI_MMCONFIG) += mmconf-fam10h_64.o |
| 122 | obj-y += vsmp_64.o | ||
| 123 | endif | 123 | endif |
diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c index 6907b8e85d52..4c80f1557433 100644 --- a/arch/x86/kernel/alternative.c +++ b/arch/x86/kernel/alternative.c | |||
| @@ -414,9 +414,17 @@ void __init alternative_instructions(void) | |||
| 414 | that might execute the to be patched code. | 414 | that might execute the to be patched code. |
| 415 | Other CPUs are not running. */ | 415 | Other CPUs are not running. */ |
| 416 | stop_nmi(); | 416 | stop_nmi(); |
| 417 | #ifdef CONFIG_X86_MCE | 417 | |
| 418 | stop_mce(); | 418 | /* |
| 419 | #endif | 419 | * Don't stop machine check exceptions while patching. |
| 420 | * MCEs only happen when something got corrupted and in this | ||
| 421 | * case we must do something about the corruption. | ||
| 422 | * Ignoring it is worse than a unlikely patching race. | ||
| 423 | * Also machine checks tend to be broadcast and if one CPU | ||
| 424 | * goes into machine check the others follow quickly, so we don't | ||
| 425 | * expect a machine check to cause undue problems during to code | ||
| 426 | * patching. | ||
| 427 | */ | ||
| 420 | 428 | ||
| 421 | apply_alternatives(__alt_instructions, __alt_instructions_end); | 429 | apply_alternatives(__alt_instructions, __alt_instructions_end); |
| 422 | 430 | ||
| @@ -456,9 +464,6 @@ void __init alternative_instructions(void) | |||
| 456 | (unsigned long)__smp_locks_end); | 464 | (unsigned long)__smp_locks_end); |
| 457 | 465 | ||
| 458 | restart_nmi(); | 466 | restart_nmi(); |
| 459 | #ifdef CONFIG_X86_MCE | ||
| 460 | restart_mce(); | ||
| 461 | #endif | ||
| 462 | } | 467 | } |
| 463 | 468 | ||
| 464 | /** | 469 | /** |
diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c index f9cecdfd05c5..85eb8e100818 100644 --- a/arch/x86/kernel/apic/apic.c +++ b/arch/x86/kernel/apic/apic.c | |||
| @@ -46,6 +46,7 @@ | |||
| 46 | #include <asm/idle.h> | 46 | #include <asm/idle.h> |
| 47 | #include <asm/mtrr.h> | 47 | #include <asm/mtrr.h> |
| 48 | #include <asm/smp.h> | 48 | #include <asm/smp.h> |
| 49 | #include <asm/mce.h> | ||
| 49 | 50 | ||
| 50 | unsigned int num_processors; | 51 | unsigned int num_processors; |
| 51 | 52 | ||
| @@ -808,7 +809,7 @@ void clear_local_APIC(void) | |||
| 808 | u32 v; | 809 | u32 v; |
| 809 | 810 | ||
| 810 | /* APIC hasn't been mapped yet */ | 811 | /* APIC hasn't been mapped yet */ |
| 811 | if (!apic_phys) | 812 | if (!x2apic && !apic_phys) |
| 812 | return; | 813 | return; |
| 813 | 814 | ||
| 814 | maxlvt = lapic_get_maxlvt(); | 815 | maxlvt = lapic_get_maxlvt(); |
| @@ -842,6 +843,14 @@ void clear_local_APIC(void) | |||
| 842 | apic_write(APIC_LVTTHMR, v | APIC_LVT_MASKED); | 843 | apic_write(APIC_LVTTHMR, v | APIC_LVT_MASKED); |
| 843 | } | 844 | } |
| 844 | #endif | 845 | #endif |
| 846 | #ifdef CONFIG_X86_MCE_INTEL | ||
| 847 | if (maxlvt >= 6) { | ||
| 848 | v = apic_read(APIC_LVTCMCI); | ||
| 849 | if (!(v & APIC_LVT_MASKED)) | ||
| 850 | apic_write(APIC_LVTCMCI, v | APIC_LVT_MASKED); | ||
| 851 | } | ||
| 852 | #endif | ||
| 853 | |||
| 845 | /* | 854 | /* |
| 846 | * Clean APIC state for other OSs: | 855 | * Clean APIC state for other OSs: |
| 847 | */ | 856 | */ |
| @@ -1241,6 +1250,12 @@ void __cpuinit setup_local_APIC(void) | |||
| 1241 | apic_write(APIC_LVT1, value); | 1250 | apic_write(APIC_LVT1, value); |
| 1242 | 1251 | ||
| 1243 | preempt_enable(); | 1252 | preempt_enable(); |
| 1253 | |||
| 1254 | #ifdef CONFIG_X86_MCE_INTEL | ||
| 1255 | /* Recheck CMCI information after local APIC is up on CPU #0 */ | ||
| 1256 | if (smp_processor_id() == 0) | ||
| 1257 | cmci_recheck(); | ||
| 1258 | #endif | ||
| 1244 | } | 1259 | } |
| 1245 | 1260 | ||
| 1246 | void __cpuinit end_local_APIC_setup(void) | 1261 | void __cpuinit end_local_APIC_setup(void) |
| @@ -1319,15 +1334,16 @@ void __init enable_IR_x2apic(void) | |||
| 1319 | return; | 1334 | return; |
| 1320 | } | 1335 | } |
| 1321 | 1336 | ||
| 1322 | local_irq_save(flags); | 1337 | ret = save_IO_APIC_setup(); |
| 1323 | mask_8259A(); | ||
| 1324 | |||
| 1325 | ret = save_mask_IO_APIC_setup(); | ||
| 1326 | if (ret) { | 1338 | if (ret) { |
| 1327 | pr_info("Saving IO-APIC state failed: %d\n", ret); | 1339 | pr_info("Saving IO-APIC state failed: %d\n", ret); |
| 1328 | goto end; | 1340 | goto end; |
| 1329 | } | 1341 | } |
| 1330 | 1342 | ||
| 1343 | local_irq_save(flags); | ||
| 1344 | mask_IO_APIC_setup(); | ||
| 1345 | mask_8259A(); | ||
| 1346 | |||
| 1331 | ret = enable_intr_remapping(1); | 1347 | ret = enable_intr_remapping(1); |
| 1332 | 1348 | ||
| 1333 | if (ret && x2apic_preenabled) { | 1349 | if (ret && x2apic_preenabled) { |
| @@ -1352,10 +1368,10 @@ end_restore: | |||
| 1352 | else | 1368 | else |
| 1353 | reinit_intr_remapped_IO_APIC(x2apic_preenabled); | 1369 | reinit_intr_remapped_IO_APIC(x2apic_preenabled); |
| 1354 | 1370 | ||
| 1355 | end: | ||
| 1356 | unmask_8259A(); | 1371 | unmask_8259A(); |
| 1357 | local_irq_restore(flags); | 1372 | local_irq_restore(flags); |
| 1358 | 1373 | ||
| 1374 | end: | ||
| 1359 | if (!ret) { | 1375 | if (!ret) { |
| 1360 | if (!x2apic_preenabled) | 1376 | if (!x2apic_preenabled) |
| 1361 | pr_info("Enabled x2apic and interrupt-remapping\n"); | 1377 | pr_info("Enabled x2apic and interrupt-remapping\n"); |
| @@ -1508,12 +1524,10 @@ void __init early_init_lapic_mapping(void) | |||
| 1508 | */ | 1524 | */ |
| 1509 | void __init init_apic_mappings(void) | 1525 | void __init init_apic_mappings(void) |
| 1510 | { | 1526 | { |
| 1511 | #ifdef CONFIG_X86_X2APIC | ||
| 1512 | if (x2apic) { | 1527 | if (x2apic) { |
| 1513 | boot_cpu_physical_apicid = read_apic_id(); | 1528 | boot_cpu_physical_apicid = read_apic_id(); |
| 1514 | return; | 1529 | return; |
| 1515 | } | 1530 | } |
| 1516 | #endif | ||
| 1517 | 1531 | ||
| 1518 | /* | 1532 | /* |
| 1519 | * If no local APIC can be found then set up a fake all | 1533 | * If no local APIC can be found then set up a fake all |
| @@ -1957,12 +1971,9 @@ static int lapic_resume(struct sys_device *dev) | |||
| 1957 | 1971 | ||
| 1958 | local_irq_save(flags); | 1972 | local_irq_save(flags); |
| 1959 | 1973 | ||
| 1960 | #ifdef CONFIG_X86_X2APIC | ||
| 1961 | if (x2apic) | 1974 | if (x2apic) |
| 1962 | enable_x2apic(); | 1975 | enable_x2apic(); |
| 1963 | else | 1976 | else { |
| 1964 | #endif | ||
| 1965 | { | ||
| 1966 | /* | 1977 | /* |
| 1967 | * Make sure the APICBASE points to the right address | 1978 | * Make sure the APICBASE points to the right address |
| 1968 | * | 1979 | * |
diff --git a/arch/x86/kernel/apic/apic_flat_64.c b/arch/x86/kernel/apic/apic_flat_64.c index f933822dba18..0014714ea97b 100644 --- a/arch/x86/kernel/apic/apic_flat_64.c +++ b/arch/x86/kernel/apic/apic_flat_64.c | |||
| @@ -159,20 +159,6 @@ static int flat_apic_id_registered(void) | |||
| 159 | return physid_isset(read_xapic_id(), phys_cpu_present_map); | 159 | return physid_isset(read_xapic_id(), phys_cpu_present_map); |
| 160 | } | 160 | } |
| 161 | 161 | ||
| 162 | static unsigned int flat_cpu_mask_to_apicid(const struct cpumask *cpumask) | ||
| 163 | { | ||
| 164 | return cpumask_bits(cpumask)[0] & APIC_ALL_CPUS; | ||
| 165 | } | ||
| 166 | |||
| 167 | static unsigned int flat_cpu_mask_to_apicid_and(const struct cpumask *cpumask, | ||
| 168 | const struct cpumask *andmask) | ||
| 169 | { | ||
| 170 | unsigned long mask1 = cpumask_bits(cpumask)[0] & APIC_ALL_CPUS; | ||
| 171 | unsigned long mask2 = cpumask_bits(andmask)[0] & APIC_ALL_CPUS; | ||
| 172 | |||
| 173 | return mask1 & mask2; | ||
| 174 | } | ||
| 175 | |||
| 176 | static int flat_phys_pkg_id(int initial_apic_id, int index_msb) | 162 | static int flat_phys_pkg_id(int initial_apic_id, int index_msb) |
| 177 | { | 163 | { |
| 178 | return hard_smp_processor_id() >> index_msb; | 164 | return hard_smp_processor_id() >> index_msb; |
| @@ -213,8 +199,8 @@ struct apic apic_flat = { | |||
| 213 | .set_apic_id = set_apic_id, | 199 | .set_apic_id = set_apic_id, |
| 214 | .apic_id_mask = 0xFFu << 24, | 200 | .apic_id_mask = 0xFFu << 24, |
| 215 | 201 | ||
| 216 | .cpu_mask_to_apicid = flat_cpu_mask_to_apicid, | 202 | .cpu_mask_to_apicid = default_cpu_mask_to_apicid, |
| 217 | .cpu_mask_to_apicid_and = flat_cpu_mask_to_apicid_and, | 203 | .cpu_mask_to_apicid_and = default_cpu_mask_to_apicid_and, |
| 218 | 204 | ||
| 219 | .send_IPI_mask = flat_send_IPI_mask, | 205 | .send_IPI_mask = flat_send_IPI_mask, |
| 220 | .send_IPI_mask_allbutself = flat_send_IPI_mask_allbutself, | 206 | .send_IPI_mask_allbutself = flat_send_IPI_mask_allbutself, |
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c index 00e6071cefc4..da99ffcdfde6 100644 --- a/arch/x86/kernel/apic/io_apic.c +++ b/arch/x86/kernel/apic/io_apic.c | |||
| @@ -389,6 +389,8 @@ struct io_apic { | |||
| 389 | unsigned int index; | 389 | unsigned int index; |
| 390 | unsigned int unused[3]; | 390 | unsigned int unused[3]; |
| 391 | unsigned int data; | 391 | unsigned int data; |
| 392 | unsigned int unused2[11]; | ||
| 393 | unsigned int eoi; | ||
| 392 | }; | 394 | }; |
| 393 | 395 | ||
| 394 | static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx) | 396 | static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx) |
| @@ -397,6 +399,12 @@ static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx) | |||
| 397 | + (mp_ioapics[idx].apicaddr & ~PAGE_MASK); | 399 | + (mp_ioapics[idx].apicaddr & ~PAGE_MASK); |
| 398 | } | 400 | } |
| 399 | 401 | ||
| 402 | static inline void io_apic_eoi(unsigned int apic, unsigned int vector) | ||
| 403 | { | ||
| 404 | struct io_apic __iomem *io_apic = io_apic_base(apic); | ||
| 405 | writel(vector, &io_apic->eoi); | ||
| 406 | } | ||
| 407 | |||
| 400 | static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg) | 408 | static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg) |
| 401 | { | 409 | { |
| 402 | struct io_apic __iomem *io_apic = io_apic_base(apic); | 410 | struct io_apic __iomem *io_apic = io_apic_base(apic); |
| @@ -546,16 +554,12 @@ static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq | |||
| 546 | 554 | ||
| 547 | apic = entry->apic; | 555 | apic = entry->apic; |
| 548 | pin = entry->pin; | 556 | pin = entry->pin; |
| 549 | #ifdef CONFIG_INTR_REMAP | ||
| 550 | /* | 557 | /* |
| 551 | * With interrupt-remapping, destination information comes | 558 | * With interrupt-remapping, destination information comes |
| 552 | * from interrupt-remapping table entry. | 559 | * from interrupt-remapping table entry. |
| 553 | */ | 560 | */ |
| 554 | if (!irq_remapped(irq)) | 561 | if (!irq_remapped(irq)) |
| 555 | io_apic_write(apic, 0x11 + pin*2, dest); | 562 | io_apic_write(apic, 0x11 + pin*2, dest); |
| 556 | #else | ||
| 557 | io_apic_write(apic, 0x11 + pin*2, dest); | ||
| 558 | #endif | ||
| 559 | reg = io_apic_read(apic, 0x10 + pin*2); | 563 | reg = io_apic_read(apic, 0x10 + pin*2); |
| 560 | reg &= ~IO_APIC_REDIR_VECTOR_MASK; | 564 | reg &= ~IO_APIC_REDIR_VECTOR_MASK; |
| 561 | reg |= vector; | 565 | reg |= vector; |
| @@ -588,10 +592,12 @@ set_desc_affinity(struct irq_desc *desc, const struct cpumask *mask) | |||
| 588 | if (assign_irq_vector(irq, cfg, mask)) | 592 | if (assign_irq_vector(irq, cfg, mask)) |
| 589 | return BAD_APICID; | 593 | return BAD_APICID; |
| 590 | 594 | ||
| 591 | cpumask_and(desc->affinity, cfg->domain, mask); | 595 | /* check that before desc->addinity get updated */ |
| 592 | set_extra_move_desc(desc, mask); | 596 | set_extra_move_desc(desc, mask); |
| 593 | 597 | ||
| 594 | return apic->cpu_mask_to_apicid_and(desc->affinity, cpu_online_mask); | 598 | cpumask_copy(desc->affinity, mask); |
| 599 | |||
| 600 | return apic->cpu_mask_to_apicid_and(desc->affinity, cfg->domain); | ||
| 595 | } | 601 | } |
| 596 | 602 | ||
| 597 | static void | 603 | static void |
| @@ -849,9 +855,9 @@ __setup("pirq=", ioapic_pirq_setup); | |||
| 849 | static struct IO_APIC_route_entry *early_ioapic_entries[MAX_IO_APICS]; | 855 | static struct IO_APIC_route_entry *early_ioapic_entries[MAX_IO_APICS]; |
| 850 | 856 | ||
| 851 | /* | 857 | /* |
| 852 | * Saves and masks all the unmasked IO-APIC RTE's | 858 | * Saves all the IO-APIC RTE's |
| 853 | */ | 859 | */ |
| 854 | int save_mask_IO_APIC_setup(void) | 860 | int save_IO_APIC_setup(void) |
| 855 | { | 861 | { |
| 856 | union IO_APIC_reg_01 reg_01; | 862 | union IO_APIC_reg_01 reg_01; |
| 857 | unsigned long flags; | 863 | unsigned long flags; |
| @@ -876,16 +882,9 @@ int save_mask_IO_APIC_setup(void) | |||
| 876 | } | 882 | } |
| 877 | 883 | ||
| 878 | for (apic = 0; apic < nr_ioapics; apic++) | 884 | for (apic = 0; apic < nr_ioapics; apic++) |
| 879 | for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) { | 885 | for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) |
| 880 | struct IO_APIC_route_entry entry; | 886 | early_ioapic_entries[apic][pin] = |
| 881 | |||
| 882 | entry = early_ioapic_entries[apic][pin] = | ||
| 883 | ioapic_read_entry(apic, pin); | 887 | ioapic_read_entry(apic, pin); |
| 884 | if (!entry.mask) { | ||
| 885 | entry.mask = 1; | ||
| 886 | ioapic_write_entry(apic, pin, entry); | ||
| 887 | } | ||
| 888 | } | ||
| 889 | 888 | ||
| 890 | return 0; | 889 | return 0; |
| 891 | 890 | ||
| @@ -898,6 +897,25 @@ nomem: | |||
| 898 | return -ENOMEM; | 897 | return -ENOMEM; |
| 899 | } | 898 | } |
| 900 | 899 | ||
| 900 | void mask_IO_APIC_setup(void) | ||
| 901 | { | ||
| 902 | int apic, pin; | ||
| 903 | |||
| 904 | for (apic = 0; apic < nr_ioapics; apic++) { | ||
| 905 | if (!early_ioapic_entries[apic]) | ||
| 906 | break; | ||
| 907 | for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) { | ||
| 908 | struct IO_APIC_route_entry entry; | ||
| 909 | |||
| 910 | entry = early_ioapic_entries[apic][pin]; | ||
| 911 | if (!entry.mask) { | ||
| 912 | entry.mask = 1; | ||
| 913 | ioapic_write_entry(apic, pin, entry); | ||
| 914 | } | ||
| 915 | } | ||
| 916 | } | ||
| 917 | } | ||
| 918 | |||
| 901 | void restore_IO_APIC_setup(void) | 919 | void restore_IO_APIC_setup(void) |
| 902 | { | 920 | { |
| 903 | int apic, pin; | 921 | int apic, pin; |
| @@ -1411,9 +1429,7 @@ void __setup_vector_irq(int cpu) | |||
| 1411 | } | 1429 | } |
| 1412 | 1430 | ||
| 1413 | static struct irq_chip ioapic_chip; | 1431 | static struct irq_chip ioapic_chip; |
| 1414 | #ifdef CONFIG_INTR_REMAP | ||
| 1415 | static struct irq_chip ir_ioapic_chip; | 1432 | static struct irq_chip ir_ioapic_chip; |
| 1416 | #endif | ||
| 1417 | 1433 | ||
| 1418 | #define IOAPIC_AUTO -1 | 1434 | #define IOAPIC_AUTO -1 |
| 1419 | #define IOAPIC_EDGE 0 | 1435 | #define IOAPIC_EDGE 0 |
| @@ -1452,7 +1468,6 @@ static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long t | |||
| 1452 | else | 1468 | else |
| 1453 | desc->status &= ~IRQ_LEVEL; | 1469 | desc->status &= ~IRQ_LEVEL; |
| 1454 | 1470 | ||
| 1455 | #ifdef CONFIG_INTR_REMAP | ||
| 1456 | if (irq_remapped(irq)) { | 1471 | if (irq_remapped(irq)) { |
| 1457 | desc->status |= IRQ_MOVE_PCNTXT; | 1472 | desc->status |= IRQ_MOVE_PCNTXT; |
| 1458 | if (trigger) | 1473 | if (trigger) |
| @@ -1464,7 +1479,7 @@ static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long t | |||
| 1464 | handle_edge_irq, "edge"); | 1479 | handle_edge_irq, "edge"); |
| 1465 | return; | 1480 | return; |
| 1466 | } | 1481 | } |
| 1467 | #endif | 1482 | |
| 1468 | if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) || | 1483 | if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) || |
| 1469 | trigger == IOAPIC_LEVEL) | 1484 | trigger == IOAPIC_LEVEL) |
| 1470 | set_irq_chip_and_handler_name(irq, &ioapic_chip, | 1485 | set_irq_chip_and_handler_name(irq, &ioapic_chip, |
| @@ -1478,14 +1493,13 @@ static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long t | |||
| 1478 | int setup_ioapic_entry(int apic_id, int irq, | 1493 | int setup_ioapic_entry(int apic_id, int irq, |
| 1479 | struct IO_APIC_route_entry *entry, | 1494 | struct IO_APIC_route_entry *entry, |
| 1480 | unsigned int destination, int trigger, | 1495 | unsigned int destination, int trigger, |
| 1481 | int polarity, int vector) | 1496 | int polarity, int vector, int pin) |
| 1482 | { | 1497 | { |
| 1483 | /* | 1498 | /* |
| 1484 | * add it to the IO-APIC irq-routing table: | 1499 | * add it to the IO-APIC irq-routing table: |
| 1485 | */ | 1500 | */ |
| 1486 | memset(entry,0,sizeof(*entry)); | 1501 | memset(entry,0,sizeof(*entry)); |
| 1487 | 1502 | ||
| 1488 | #ifdef CONFIG_INTR_REMAP | ||
| 1489 | if (intr_remapping_enabled) { | 1503 | if (intr_remapping_enabled) { |
| 1490 | struct intel_iommu *iommu = map_ioapic_to_ir(apic_id); | 1504 | struct intel_iommu *iommu = map_ioapic_to_ir(apic_id); |
| 1491 | struct irte irte; | 1505 | struct irte irte; |
| @@ -1504,7 +1518,14 @@ int setup_ioapic_entry(int apic_id, int irq, | |||
| 1504 | 1518 | ||
| 1505 | irte.present = 1; | 1519 | irte.present = 1; |
| 1506 | irte.dst_mode = apic->irq_dest_mode; | 1520 | irte.dst_mode = apic->irq_dest_mode; |
| 1507 | irte.trigger_mode = trigger; | 1521 | /* |
| 1522 | * Trigger mode in the IRTE will always be edge, and the | ||
| 1523 | * actual level or edge trigger will be setup in the IO-APIC | ||
| 1524 | * RTE. This will help simplify level triggered irq migration. | ||
| 1525 | * For more details, see the comments above explainig IO-APIC | ||
| 1526 | * irq migration in the presence of interrupt-remapping. | ||
| 1527 | */ | ||
| 1528 | irte.trigger_mode = 0; | ||
| 1508 | irte.dlvry_mode = apic->irq_delivery_mode; | 1529 | irte.dlvry_mode = apic->irq_delivery_mode; |
| 1509 | irte.vector = vector; | 1530 | irte.vector = vector; |
| 1510 | irte.dest_id = IRTE_DEST(destination); | 1531 | irte.dest_id = IRTE_DEST(destination); |
| @@ -1515,18 +1536,21 @@ int setup_ioapic_entry(int apic_id, int irq, | |||
| 1515 | ir_entry->zero = 0; | 1536 | ir_entry->zero = 0; |
| 1516 | ir_entry->format = 1; | 1537 | ir_entry->format = 1; |
| 1517 | ir_entry->index = (index & 0x7fff); | 1538 | ir_entry->index = (index & 0x7fff); |
| 1518 | } else | 1539 | /* |
| 1519 | #endif | 1540 | * IO-APIC RTE will be configured with virtual vector. |
| 1520 | { | 1541 | * irq handler will do the explicit EOI to the io-apic. |
| 1542 | */ | ||
| 1543 | ir_entry->vector = pin; | ||
| 1544 | } else { | ||
| 1521 | entry->delivery_mode = apic->irq_delivery_mode; | 1545 | entry->delivery_mode = apic->irq_delivery_mode; |
| 1522 | entry->dest_mode = apic->irq_dest_mode; | 1546 | entry->dest_mode = apic->irq_dest_mode; |
| 1523 | entry->dest = destination; | 1547 | entry->dest = destination; |
| 1548 | entry->vector = vector; | ||
| 1524 | } | 1549 | } |
| 1525 | 1550 | ||
| 1526 | entry->mask = 0; /* enable IRQ */ | 1551 | entry->mask = 0; /* enable IRQ */ |
| 1527 | entry->trigger = trigger; | 1552 | entry->trigger = trigger; |
| 1528 | entry->polarity = polarity; | 1553 | entry->polarity = polarity; |
| 1529 | entry->vector = vector; | ||
| 1530 | 1554 | ||
| 1531 | /* Mask level triggered irqs. | 1555 | /* Mask level triggered irqs. |
| 1532 | * Use IRQ_DELAYED_DISABLE for edge triggered irqs. | 1556 | * Use IRQ_DELAYED_DISABLE for edge triggered irqs. |
| @@ -1561,7 +1585,7 @@ static void setup_IO_APIC_irq(int apic_id, int pin, unsigned int irq, struct irq | |||
| 1561 | 1585 | ||
| 1562 | 1586 | ||
| 1563 | if (setup_ioapic_entry(mp_ioapics[apic_id].apicid, irq, &entry, | 1587 | if (setup_ioapic_entry(mp_ioapics[apic_id].apicid, irq, &entry, |
| 1564 | dest, trigger, polarity, cfg->vector)) { | 1588 | dest, trigger, polarity, cfg->vector, pin)) { |
| 1565 | printk("Failed to setup ioapic entry for ioapic %d, pin %d\n", | 1589 | printk("Failed to setup ioapic entry for ioapic %d, pin %d\n", |
| 1566 | mp_ioapics[apic_id].apicid, pin); | 1590 | mp_ioapics[apic_id].apicid, pin); |
| 1567 | __clear_irq_vector(irq, cfg); | 1591 | __clear_irq_vector(irq, cfg); |
| @@ -1642,10 +1666,8 @@ static void __init setup_timer_IRQ0_pin(unsigned int apic_id, unsigned int pin, | |||
| 1642 | { | 1666 | { |
| 1643 | struct IO_APIC_route_entry entry; | 1667 | struct IO_APIC_route_entry entry; |
| 1644 | 1668 | ||
| 1645 | #ifdef CONFIG_INTR_REMAP | ||
| 1646 | if (intr_remapping_enabled) | 1669 | if (intr_remapping_enabled) |
| 1647 | return; | 1670 | return; |
| 1648 | #endif | ||
| 1649 | 1671 | ||
| 1650 | memset(&entry, 0, sizeof(entry)); | 1672 | memset(&entry, 0, sizeof(entry)); |
| 1651 | 1673 | ||
| @@ -2040,8 +2062,13 @@ void disable_IO_APIC(void) | |||
| 2040 | * If the i8259 is routed through an IOAPIC | 2062 | * If the i8259 is routed through an IOAPIC |
| 2041 | * Put that IOAPIC in virtual wire mode | 2063 | * Put that IOAPIC in virtual wire mode |
| 2042 | * so legacy interrupts can be delivered. | 2064 | * so legacy interrupts can be delivered. |
| 2065 | * | ||
| 2066 | * With interrupt-remapping, for now we will use virtual wire A mode, | ||
| 2067 | * as virtual wire B is little complex (need to configure both | ||
| 2068 | * IOAPIC RTE aswell as interrupt-remapping table entry). | ||
| 2069 | * As this gets called during crash dump, keep this simple for now. | ||
| 2043 | */ | 2070 | */ |
| 2044 | if (ioapic_i8259.pin != -1) { | 2071 | if (ioapic_i8259.pin != -1 && !intr_remapping_enabled) { |
| 2045 | struct IO_APIC_route_entry entry; | 2072 | struct IO_APIC_route_entry entry; |
| 2046 | 2073 | ||
| 2047 | memset(&entry, 0, sizeof(entry)); | 2074 | memset(&entry, 0, sizeof(entry)); |
| @@ -2061,7 +2088,10 @@ void disable_IO_APIC(void) | |||
| 2061 | ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry); | 2088 | ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry); |
| 2062 | } | 2089 | } |
| 2063 | 2090 | ||
| 2064 | disconnect_bsp_APIC(ioapic_i8259.pin != -1); | 2091 | /* |
| 2092 | * Use virtual wire A mode when interrupt remapping is enabled. | ||
| 2093 | */ | ||
| 2094 | disconnect_bsp_APIC(!intr_remapping_enabled && ioapic_i8259.pin != -1); | ||
| 2065 | } | 2095 | } |
| 2066 | 2096 | ||
| 2067 | #ifdef CONFIG_X86_32 | 2097 | #ifdef CONFIG_X86_32 |
| @@ -2303,37 +2333,24 @@ static int ioapic_retrigger_irq(unsigned int irq) | |||
| 2303 | #ifdef CONFIG_SMP | 2333 | #ifdef CONFIG_SMP |
| 2304 | 2334 | ||
| 2305 | #ifdef CONFIG_INTR_REMAP | 2335 | #ifdef CONFIG_INTR_REMAP |
| 2306 | static void ir_irq_migration(struct work_struct *work); | ||
| 2307 | |||
| 2308 | static DECLARE_DELAYED_WORK(ir_migration_work, ir_irq_migration); | ||
| 2309 | 2336 | ||
| 2310 | /* | 2337 | /* |
| 2311 | * Migrate the IO-APIC irq in the presence of intr-remapping. | 2338 | * Migrate the IO-APIC irq in the presence of intr-remapping. |
| 2312 | * | 2339 | * |
| 2313 | * For edge triggered, irq migration is a simple atomic update(of vector | 2340 | * For both level and edge triggered, irq migration is a simple atomic |
| 2314 | * and cpu destination) of IRTE and flush the hardware cache. | 2341 | * update(of vector and cpu destination) of IRTE and flush the hardware cache. |
| 2315 | * | ||
| 2316 | * For level triggered, we need to modify the io-apic RTE aswell with the update | ||
| 2317 | * vector information, along with modifying IRTE with vector and destination. | ||
| 2318 | * So irq migration for level triggered is little bit more complex compared to | ||
| 2319 | * edge triggered migration. But the good news is, we use the same algorithm | ||
| 2320 | * for level triggered migration as we have today, only difference being, | ||
| 2321 | * we now initiate the irq migration from process context instead of the | ||
| 2322 | * interrupt context. | ||
| 2323 | * | 2342 | * |
| 2324 | * In future, when we do a directed EOI (combined with cpu EOI broadcast | 2343 | * For level triggered, we eliminate the io-apic RTE modification (with the |
| 2325 | * suppression) to the IO-APIC, level triggered irq migration will also be | 2344 | * updated vector information), by using a virtual vector (io-apic pin number). |
| 2326 | * as simple as edge triggered migration and we can do the irq migration | 2345 | * Real vector that is used for interrupting cpu will be coming from |
| 2327 | * with a simple atomic update to IO-APIC RTE. | 2346 | * the interrupt-remapping table entry. |
| 2328 | */ | 2347 | */ |
| 2329 | static void | 2348 | static void |
| 2330 | migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask) | 2349 | migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask) |
| 2331 | { | 2350 | { |
| 2332 | struct irq_cfg *cfg; | 2351 | struct irq_cfg *cfg; |
| 2333 | struct irte irte; | 2352 | struct irte irte; |
| 2334 | int modify_ioapic_rte; | ||
| 2335 | unsigned int dest; | 2353 | unsigned int dest; |
| 2336 | unsigned long flags; | ||
| 2337 | unsigned int irq; | 2354 | unsigned int irq; |
| 2338 | 2355 | ||
| 2339 | if (!cpumask_intersects(mask, cpu_online_mask)) | 2356 | if (!cpumask_intersects(mask, cpu_online_mask)) |
| @@ -2351,13 +2368,6 @@ migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask) | |||
| 2351 | 2368 | ||
| 2352 | dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask); | 2369 | dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask); |
| 2353 | 2370 | ||
| 2354 | modify_ioapic_rte = desc->status & IRQ_LEVEL; | ||
| 2355 | if (modify_ioapic_rte) { | ||
| 2356 | spin_lock_irqsave(&ioapic_lock, flags); | ||
| 2357 | __target_IO_APIC_irq(irq, dest, cfg); | ||
| 2358 | spin_unlock_irqrestore(&ioapic_lock, flags); | ||
| 2359 | } | ||
| 2360 | |||
| 2361 | irte.vector = cfg->vector; | 2371 | irte.vector = cfg->vector; |
| 2362 | irte.dest_id = IRTE_DEST(dest); | 2372 | irte.dest_id = IRTE_DEST(dest); |
| 2363 | 2373 | ||
| @@ -2372,73 +2382,12 @@ migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask) | |||
| 2372 | cpumask_copy(desc->affinity, mask); | 2382 | cpumask_copy(desc->affinity, mask); |
| 2373 | } | 2383 | } |
| 2374 | 2384 | ||
| 2375 | static int migrate_irq_remapped_level_desc(struct irq_desc *desc) | ||
| 2376 | { | ||
| 2377 | int ret = -1; | ||
| 2378 | struct irq_cfg *cfg = desc->chip_data; | ||
| 2379 | |||
| 2380 | mask_IO_APIC_irq_desc(desc); | ||
| 2381 | |||
| 2382 | if (io_apic_level_ack_pending(cfg)) { | ||
| 2383 | /* | ||
| 2384 | * Interrupt in progress. Migrating irq now will change the | ||
| 2385 | * vector information in the IO-APIC RTE and that will confuse | ||
| 2386 | * the EOI broadcast performed by cpu. | ||
| 2387 | * So, delay the irq migration to the next instance. | ||
| 2388 | */ | ||
| 2389 | schedule_delayed_work(&ir_migration_work, 1); | ||
| 2390 | goto unmask; | ||
| 2391 | } | ||
| 2392 | |||
| 2393 | /* everthing is clear. we have right of way */ | ||
| 2394 | migrate_ioapic_irq_desc(desc, desc->pending_mask); | ||
| 2395 | |||
| 2396 | ret = 0; | ||
| 2397 | desc->status &= ~IRQ_MOVE_PENDING; | ||
| 2398 | cpumask_clear(desc->pending_mask); | ||
| 2399 | |||
| 2400 | unmask: | ||
| 2401 | unmask_IO_APIC_irq_desc(desc); | ||
| 2402 | |||
| 2403 | return ret; | ||
| 2404 | } | ||
| 2405 | |||
| 2406 | static void ir_irq_migration(struct work_struct *work) | ||
| 2407 | { | ||
| 2408 | unsigned int irq; | ||
| 2409 | struct irq_desc *desc; | ||
| 2410 | |||
| 2411 | for_each_irq_desc(irq, desc) { | ||
| 2412 | if (desc->status & IRQ_MOVE_PENDING) { | ||
| 2413 | unsigned long flags; | ||
| 2414 | |||
| 2415 | spin_lock_irqsave(&desc->lock, flags); | ||
| 2416 | if (!desc->chip->set_affinity || | ||
| 2417 | !(desc->status & IRQ_MOVE_PENDING)) { | ||
| 2418 | desc->status &= ~IRQ_MOVE_PENDING; | ||
| 2419 | spin_unlock_irqrestore(&desc->lock, flags); | ||
| 2420 | continue; | ||
| 2421 | } | ||
| 2422 | |||
| 2423 | desc->chip->set_affinity(irq, desc->pending_mask); | ||
| 2424 | spin_unlock_irqrestore(&desc->lock, flags); | ||
| 2425 | } | ||
| 2426 | } | ||
| 2427 | } | ||
| 2428 | |||
| 2429 | /* | 2385 | /* |
| 2430 | * Migrates the IRQ destination in the process context. | 2386 | * Migrates the IRQ destination in the process context. |
| 2431 | */ | 2387 | */ |
| 2432 | static void set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc, | 2388 | static void set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc, |
| 2433 | const struct cpumask *mask) | 2389 | const struct cpumask *mask) |
| 2434 | { | 2390 | { |
| 2435 | if (desc->status & IRQ_LEVEL) { | ||
| 2436 | desc->status |= IRQ_MOVE_PENDING; | ||
| 2437 | cpumask_copy(desc->pending_mask, mask); | ||
| 2438 | migrate_irq_remapped_level_desc(desc); | ||
| 2439 | return; | ||
| 2440 | } | ||
| 2441 | |||
| 2442 | migrate_ioapic_irq_desc(desc, mask); | 2391 | migrate_ioapic_irq_desc(desc, mask); |
| 2443 | } | 2392 | } |
| 2444 | static void set_ir_ioapic_affinity_irq(unsigned int irq, | 2393 | static void set_ir_ioapic_affinity_irq(unsigned int irq, |
| @@ -2448,6 +2397,11 @@ static void set_ir_ioapic_affinity_irq(unsigned int irq, | |||
| 2448 | 2397 | ||
| 2449 | set_ir_ioapic_affinity_irq_desc(desc, mask); | 2398 | set_ir_ioapic_affinity_irq_desc(desc, mask); |
| 2450 | } | 2399 | } |
| 2400 | #else | ||
| 2401 | static inline void set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc, | ||
| 2402 | const struct cpumask *mask) | ||
| 2403 | { | ||
| 2404 | } | ||
| 2451 | #endif | 2405 | #endif |
| 2452 | 2406 | ||
| 2453 | asmlinkage void smp_irq_move_cleanup_interrupt(void) | 2407 | asmlinkage void smp_irq_move_cleanup_interrupt(void) |
| @@ -2461,6 +2415,7 @@ asmlinkage void smp_irq_move_cleanup_interrupt(void) | |||
| 2461 | me = smp_processor_id(); | 2415 | me = smp_processor_id(); |
| 2462 | for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) { | 2416 | for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) { |
| 2463 | unsigned int irq; | 2417 | unsigned int irq; |
| 2418 | unsigned int irr; | ||
| 2464 | struct irq_desc *desc; | 2419 | struct irq_desc *desc; |
| 2465 | struct irq_cfg *cfg; | 2420 | struct irq_cfg *cfg; |
| 2466 | irq = __get_cpu_var(vector_irq)[vector]; | 2421 | irq = __get_cpu_var(vector_irq)[vector]; |
| @@ -2480,6 +2435,18 @@ asmlinkage void smp_irq_move_cleanup_interrupt(void) | |||
| 2480 | if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain)) | 2435 | if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain)) |
| 2481 | goto unlock; | 2436 | goto unlock; |
| 2482 | 2437 | ||
| 2438 | irr = apic_read(APIC_IRR + (vector / 32 * 0x10)); | ||
| 2439 | /* | ||
| 2440 | * Check if the vector that needs to be cleanedup is | ||
| 2441 | * registered at the cpu's IRR. If so, then this is not | ||
| 2442 | * the best time to clean it up. Lets clean it up in the | ||
| 2443 | * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR | ||
| 2444 | * to myself. | ||
| 2445 | */ | ||
| 2446 | if (irr & (1 << (vector % 32))) { | ||
| 2447 | apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR); | ||
| 2448 | goto unlock; | ||
| 2449 | } | ||
| 2483 | __get_cpu_var(vector_irq)[vector] = -1; | 2450 | __get_cpu_var(vector_irq)[vector] = -1; |
| 2484 | cfg->move_cleanup_count--; | 2451 | cfg->move_cleanup_count--; |
| 2485 | unlock: | 2452 | unlock: |
| @@ -2529,9 +2496,44 @@ static inline void irq_complete_move(struct irq_desc **descp) {} | |||
| 2529 | #endif | 2496 | #endif |
| 2530 | 2497 | ||
| 2531 | #ifdef CONFIG_INTR_REMAP | 2498 | #ifdef CONFIG_INTR_REMAP |
| 2499 | static void __eoi_ioapic_irq(unsigned int irq, struct irq_cfg *cfg) | ||
| 2500 | { | ||
| 2501 | int apic, pin; | ||
| 2502 | struct irq_pin_list *entry; | ||
| 2503 | |||
| 2504 | entry = cfg->irq_2_pin; | ||
| 2505 | for (;;) { | ||
| 2506 | |||
| 2507 | if (!entry) | ||
| 2508 | break; | ||
| 2509 | |||
| 2510 | apic = entry->apic; | ||
| 2511 | pin = entry->pin; | ||
| 2512 | io_apic_eoi(apic, pin); | ||
| 2513 | entry = entry->next; | ||
| 2514 | } | ||
| 2515 | } | ||
| 2516 | |||
| 2517 | static void | ||
| 2518 | eoi_ioapic_irq(struct irq_desc *desc) | ||
| 2519 | { | ||
| 2520 | struct irq_cfg *cfg; | ||
| 2521 | unsigned long flags; | ||
| 2522 | unsigned int irq; | ||
| 2523 | |||
| 2524 | irq = desc->irq; | ||
| 2525 | cfg = desc->chip_data; | ||
| 2526 | |||
| 2527 | spin_lock_irqsave(&ioapic_lock, flags); | ||
| 2528 | __eoi_ioapic_irq(irq, cfg); | ||
| 2529 | spin_unlock_irqrestore(&ioapic_lock, flags); | ||
| 2530 | } | ||
| 2531 | |||
| 2532 | static void ack_x2apic_level(unsigned int irq) | 2532 | static void ack_x2apic_level(unsigned int irq) |
| 2533 | { | 2533 | { |
| 2534 | struct irq_desc *desc = irq_to_desc(irq); | ||
| 2534 | ack_x2APIC_irq(); | 2535 | ack_x2APIC_irq(); |
| 2536 | eoi_ioapic_irq(desc); | ||
| 2535 | } | 2537 | } |
| 2536 | 2538 | ||
| 2537 | static void ack_x2apic_edge(unsigned int irq) | 2539 | static void ack_x2apic_edge(unsigned int irq) |
| @@ -2662,20 +2664,20 @@ static struct irq_chip ioapic_chip __read_mostly = { | |||
| 2662 | .retrigger = ioapic_retrigger_irq, | 2664 | .retrigger = ioapic_retrigger_irq, |
| 2663 | }; | 2665 | }; |
| 2664 | 2666 | ||
| 2665 | #ifdef CONFIG_INTR_REMAP | ||
| 2666 | static struct irq_chip ir_ioapic_chip __read_mostly = { | 2667 | static struct irq_chip ir_ioapic_chip __read_mostly = { |
| 2667 | .name = "IR-IO-APIC", | 2668 | .name = "IR-IO-APIC", |
| 2668 | .startup = startup_ioapic_irq, | 2669 | .startup = startup_ioapic_irq, |
| 2669 | .mask = mask_IO_APIC_irq, | 2670 | .mask = mask_IO_APIC_irq, |
| 2670 | .unmask = unmask_IO_APIC_irq, | 2671 | .unmask = unmask_IO_APIC_irq, |
| 2672 | #ifdef CONFIG_INTR_REMAP | ||
| 2671 | .ack = ack_x2apic_edge, | 2673 | .ack = ack_x2apic_edge, |
| 2672 | .eoi = ack_x2apic_level, | 2674 | .eoi = ack_x2apic_level, |
| 2673 | #ifdef CONFIG_SMP | 2675 | #ifdef CONFIG_SMP |
| 2674 | .set_affinity = set_ir_ioapic_affinity_irq, | 2676 | .set_affinity = set_ir_ioapic_affinity_irq, |
| 2675 | #endif | 2677 | #endif |
| 2678 | #endif | ||
| 2676 | .retrigger = ioapic_retrigger_irq, | 2679 | .retrigger = ioapic_retrigger_irq, |
| 2677 | }; | 2680 | }; |
| 2678 | #endif | ||
| 2679 | 2681 | ||
| 2680 | static inline void init_IO_APIC_traps(void) | 2682 | static inline void init_IO_APIC_traps(void) |
| 2681 | { | 2683 | { |
| @@ -2901,10 +2903,8 @@ static inline void __init check_timer(void) | |||
| 2901 | * 8259A. | 2903 | * 8259A. |
| 2902 | */ | 2904 | */ |
| 2903 | if (pin1 == -1) { | 2905 | if (pin1 == -1) { |
| 2904 | #ifdef CONFIG_INTR_REMAP | ||
| 2905 | if (intr_remapping_enabled) | 2906 | if (intr_remapping_enabled) |
| 2906 | panic("BIOS bug: timer not connected to IO-APIC"); | 2907 | panic("BIOS bug: timer not connected to IO-APIC"); |
| 2907 | #endif | ||
| 2908 | pin1 = pin2; | 2908 | pin1 = pin2; |
| 2909 | apic1 = apic2; | 2909 | apic1 = apic2; |
| 2910 | no_pin1 = 1; | 2910 | no_pin1 = 1; |
| @@ -2940,10 +2940,8 @@ static inline void __init check_timer(void) | |||
| 2940 | clear_IO_APIC_pin(0, pin1); | 2940 | clear_IO_APIC_pin(0, pin1); |
| 2941 | goto out; | 2941 | goto out; |
| 2942 | } | 2942 | } |
| 2943 | #ifdef CONFIG_INTR_REMAP | ||
| 2944 | if (intr_remapping_enabled) | 2943 | if (intr_remapping_enabled) |
| 2945 | panic("timer doesn't work through Interrupt-remapped IO-APIC"); | 2944 | panic("timer doesn't work through Interrupt-remapped IO-APIC"); |
| 2946 | #endif | ||
| 2947 | local_irq_disable(); | 2945 | local_irq_disable(); |
| 2948 | clear_IO_APIC_pin(apic1, pin1); | 2946 | clear_IO_APIC_pin(apic1, pin1); |
| 2949 | if (!no_pin1) | 2947 | if (!no_pin1) |
| @@ -3237,9 +3235,7 @@ void destroy_irq(unsigned int irq) | |||
| 3237 | if (desc) | 3235 | if (desc) |
| 3238 | desc->chip_data = cfg; | 3236 | desc->chip_data = cfg; |
| 3239 | 3237 | ||
| 3240 | #ifdef CONFIG_INTR_REMAP | ||
| 3241 | free_irte(irq); | 3238 | free_irte(irq); |
| 3242 | #endif | ||
| 3243 | spin_lock_irqsave(&vector_lock, flags); | 3239 | spin_lock_irqsave(&vector_lock, flags); |
| 3244 | __clear_irq_vector(irq, cfg); | 3240 | __clear_irq_vector(irq, cfg); |
| 3245 | spin_unlock_irqrestore(&vector_lock, flags); | 3241 | spin_unlock_irqrestore(&vector_lock, flags); |
| @@ -3265,7 +3261,6 @@ static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_ms | |||
| 3265 | 3261 | ||
| 3266 | dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus()); | 3262 | dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus()); |
| 3267 | 3263 | ||
| 3268 | #ifdef CONFIG_INTR_REMAP | ||
| 3269 | if (irq_remapped(irq)) { | 3264 | if (irq_remapped(irq)) { |
| 3270 | struct irte irte; | 3265 | struct irte irte; |
| 3271 | int ir_index; | 3266 | int ir_index; |
| @@ -3291,10 +3286,13 @@ static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_ms | |||
| 3291 | MSI_ADDR_IR_SHV | | 3286 | MSI_ADDR_IR_SHV | |
| 3292 | MSI_ADDR_IR_INDEX1(ir_index) | | 3287 | MSI_ADDR_IR_INDEX1(ir_index) | |
| 3293 | MSI_ADDR_IR_INDEX2(ir_index); | 3288 | MSI_ADDR_IR_INDEX2(ir_index); |
| 3294 | } else | 3289 | } else { |
| 3295 | #endif | 3290 | if (x2apic_enabled()) |
| 3296 | { | 3291 | msg->address_hi = MSI_ADDR_BASE_HI | |
| 3297 | msg->address_hi = MSI_ADDR_BASE_HI; | 3292 | MSI_ADDR_EXT_DEST_ID(dest); |
| 3293 | else | ||
| 3294 | msg->address_hi = MSI_ADDR_BASE_HI; | ||
| 3295 | |||
| 3298 | msg->address_lo = | 3296 | msg->address_lo = |
| 3299 | MSI_ADDR_BASE_LO | | 3297 | MSI_ADDR_BASE_LO | |
| 3300 | ((apic->irq_dest_mode == 0) ? | 3298 | ((apic->irq_dest_mode == 0) ? |
| @@ -3394,15 +3392,16 @@ static struct irq_chip msi_chip = { | |||
| 3394 | .retrigger = ioapic_retrigger_irq, | 3392 | .retrigger = ioapic_retrigger_irq, |
| 3395 | }; | 3393 | }; |
| 3396 | 3394 | ||
| 3397 | #ifdef CONFIG_INTR_REMAP | ||
| 3398 | static struct irq_chip msi_ir_chip = { | 3395 | static struct irq_chip msi_ir_chip = { |
| 3399 | .name = "IR-PCI-MSI", | 3396 | .name = "IR-PCI-MSI", |
| 3400 | .unmask = unmask_msi_irq, | 3397 | .unmask = unmask_msi_irq, |
| 3401 | .mask = mask_msi_irq, | 3398 | .mask = mask_msi_irq, |
| 3399 | #ifdef CONFIG_INTR_REMAP | ||
| 3402 | .ack = ack_x2apic_edge, | 3400 | .ack = ack_x2apic_edge, |
| 3403 | #ifdef CONFIG_SMP | 3401 | #ifdef CONFIG_SMP |
| 3404 | .set_affinity = ir_set_msi_irq_affinity, | 3402 | .set_affinity = ir_set_msi_irq_affinity, |
| 3405 | #endif | 3403 | #endif |
| 3404 | #endif | ||
| 3406 | .retrigger = ioapic_retrigger_irq, | 3405 | .retrigger = ioapic_retrigger_irq, |
| 3407 | }; | 3406 | }; |
| 3408 | 3407 | ||
| @@ -3432,7 +3431,6 @@ static int msi_alloc_irte(struct pci_dev *dev, int irq, int nvec) | |||
| 3432 | } | 3431 | } |
| 3433 | return index; | 3432 | return index; |
| 3434 | } | 3433 | } |
| 3435 | #endif | ||
| 3436 | 3434 | ||
| 3437 | static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq) | 3435 | static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq) |
| 3438 | { | 3436 | { |
| @@ -3446,7 +3444,6 @@ static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq) | |||
| 3446 | set_irq_msi(irq, msidesc); | 3444 | set_irq_msi(irq, msidesc); |
| 3447 | write_msi_msg(irq, &msg); | 3445 | write_msi_msg(irq, &msg); |
| 3448 | 3446 | ||
| 3449 | #ifdef CONFIG_INTR_REMAP | ||
| 3450 | if (irq_remapped(irq)) { | 3447 | if (irq_remapped(irq)) { |
| 3451 | struct irq_desc *desc = irq_to_desc(irq); | 3448 | struct irq_desc *desc = irq_to_desc(irq); |
| 3452 | /* | 3449 | /* |
| @@ -3455,7 +3452,6 @@ static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq) | |||
| 3455 | desc->status |= IRQ_MOVE_PCNTXT; | 3452 | desc->status |= IRQ_MOVE_PCNTXT; |
| 3456 | set_irq_chip_and_handler_name(irq, &msi_ir_chip, handle_edge_irq, "edge"); | 3453 | set_irq_chip_and_handler_name(irq, &msi_ir_chip, handle_edge_irq, "edge"); |
| 3457 | } else | 3454 | } else |
| 3458 | #endif | ||
| 3459 | set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge"); | 3455 | set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge"); |
| 3460 | 3456 | ||
| 3461 | dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq); | 3457 | dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq); |
| @@ -3469,11 +3465,8 @@ int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) | |||
| 3469 | int ret, sub_handle; | 3465 | int ret, sub_handle; |
| 3470 | struct msi_desc *msidesc; | 3466 | struct msi_desc *msidesc; |
| 3471 | unsigned int irq_want; | 3467 | unsigned int irq_want; |
| 3472 | 3468 | struct intel_iommu *iommu = NULL; | |
| 3473 | #ifdef CONFIG_INTR_REMAP | ||
| 3474 | struct intel_iommu *iommu = 0; | ||
| 3475 | int index = 0; | 3469 | int index = 0; |
| 3476 | #endif | ||
| 3477 | 3470 | ||
| 3478 | irq_want = nr_irqs_gsi; | 3471 | irq_want = nr_irqs_gsi; |
| 3479 | sub_handle = 0; | 3472 | sub_handle = 0; |
| @@ -3482,7 +3475,6 @@ int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) | |||
| 3482 | if (irq == 0) | 3475 | if (irq == 0) |
| 3483 | return -1; | 3476 | return -1; |
| 3484 | irq_want = irq + 1; | 3477 | irq_want = irq + 1; |
| 3485 | #ifdef CONFIG_INTR_REMAP | ||
| 3486 | if (!intr_remapping_enabled) | 3478 | if (!intr_remapping_enabled) |
| 3487 | goto no_ir; | 3479 | goto no_ir; |
| 3488 | 3480 | ||
| @@ -3510,7 +3502,6 @@ int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) | |||
| 3510 | set_irte_irq(irq, iommu, index, sub_handle); | 3502 | set_irte_irq(irq, iommu, index, sub_handle); |
| 3511 | } | 3503 | } |
| 3512 | no_ir: | 3504 | no_ir: |
| 3513 | #endif | ||
| 3514 | ret = setup_msi_irq(dev, msidesc, irq); | 3505 | ret = setup_msi_irq(dev, msidesc, irq); |
| 3515 | if (ret < 0) | 3506 | if (ret < 0) |
| 3516 | goto error; | 3507 | goto error; |
| @@ -3528,7 +3519,7 @@ void arch_teardown_msi_irq(unsigned int irq) | |||
| 3528 | destroy_irq(irq); | 3519 | destroy_irq(irq); |
| 3529 | } | 3520 | } |
| 3530 | 3521 | ||
| 3531 | #ifdef CONFIG_DMAR | 3522 | #if defined (CONFIG_DMAR) || defined (CONFIG_INTR_REMAP) |
| 3532 | #ifdef CONFIG_SMP | 3523 | #ifdef CONFIG_SMP |
| 3533 | static void dmar_msi_set_affinity(unsigned int irq, const struct cpumask *mask) | 3524 | static void dmar_msi_set_affinity(unsigned int irq, const struct cpumask *mask) |
| 3534 | { | 3525 | { |
| @@ -3609,7 +3600,7 @@ static void hpet_msi_set_affinity(unsigned int irq, const struct cpumask *mask) | |||
| 3609 | 3600 | ||
| 3610 | #endif /* CONFIG_SMP */ | 3601 | #endif /* CONFIG_SMP */ |
| 3611 | 3602 | ||
| 3612 | struct irq_chip hpet_msi_type = { | 3603 | static struct irq_chip hpet_msi_type = { |
| 3613 | .name = "HPET_MSI", | 3604 | .name = "HPET_MSI", |
| 3614 | .unmask = hpet_msi_unmask, | 3605 | .unmask = hpet_msi_unmask, |
| 3615 | .mask = hpet_msi_mask, | 3606 | .mask = hpet_msi_mask, |
| @@ -4045,11 +4036,9 @@ void __init setup_ioapic_dest(void) | |||
| 4045 | else | 4036 | else |
| 4046 | mask = apic->target_cpus(); | 4037 | mask = apic->target_cpus(); |
| 4047 | 4038 | ||
| 4048 | #ifdef CONFIG_INTR_REMAP | ||
| 4049 | if (intr_remapping_enabled) | 4039 | if (intr_remapping_enabled) |
| 4050 | set_ir_ioapic_affinity_irq_desc(desc, mask); | 4040 | set_ir_ioapic_affinity_irq_desc(desc, mask); |
| 4051 | else | 4041 | else |
| 4052 | #endif | ||
| 4053 | set_ioapic_affinity_irq_desc(desc, mask); | 4042 | set_ioapic_affinity_irq_desc(desc, mask); |
| 4054 | } | 4043 | } |
| 4055 | 4044 | ||
| @@ -4142,9 +4131,12 @@ static int __init ioapic_insert_resources(void) | |||
| 4142 | struct resource *r = ioapic_resources; | 4131 | struct resource *r = ioapic_resources; |
| 4143 | 4132 | ||
| 4144 | if (!r) { | 4133 | if (!r) { |
| 4145 | printk(KERN_ERR | 4134 | if (nr_ioapics > 0) { |
| 4146 | "IO APIC resources could be not be allocated.\n"); | 4135 | printk(KERN_ERR |
| 4147 | return -1; | 4136 | "IO APIC resources couldn't be allocated.\n"); |
| 4137 | return -1; | ||
| 4138 | } | ||
| 4139 | return 0; | ||
| 4148 | } | 4140 | } |
| 4149 | 4141 | ||
| 4150 | for (i = 0; i < nr_ioapics; i++) { | 4142 | for (i = 0; i < nr_ioapics; i++) { |
diff --git a/arch/x86/kernel/apic/probe_64.c b/arch/x86/kernel/apic/probe_64.c index 8d7748efe6a8..1783652bb0e5 100644 --- a/arch/x86/kernel/apic/probe_64.c +++ b/arch/x86/kernel/apic/probe_64.c | |||
| @@ -68,6 +68,13 @@ void __init default_setup_apic_routing(void) | |||
| 68 | apic = &apic_physflat; | 68 | apic = &apic_physflat; |
| 69 | printk(KERN_INFO "Setting APIC routing to %s\n", apic->name); | 69 | printk(KERN_INFO "Setting APIC routing to %s\n", apic->name); |
| 70 | } | 70 | } |
| 71 | |||
| 72 | /* | ||
| 73 | * Now that apic routing model is selected, configure the | ||
| 74 | * fault handling for intr remapping. | ||
| 75 | */ | ||
| 76 | if (intr_remapping_enabled) | ||
| 77 | enable_drhd_fault_handling(); | ||
| 71 | } | 78 | } |
| 72 | 79 | ||
| 73 | /* Same for both flat and physical. */ | 80 | /* Same for both flat and physical. */ |
diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c index 8fb87b6dd633..4a903e2f0d17 100644 --- a/arch/x86/kernel/apic/x2apic_cluster.c +++ b/arch/x86/kernel/apic/x2apic_cluster.c | |||
| @@ -57,6 +57,8 @@ static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector) | |||
| 57 | unsigned long query_cpu; | 57 | unsigned long query_cpu; |
| 58 | unsigned long flags; | 58 | unsigned long flags; |
| 59 | 59 | ||
| 60 | x2apic_wrmsr_fence(); | ||
| 61 | |||
| 60 | local_irq_save(flags); | 62 | local_irq_save(flags); |
| 61 | for_each_cpu(query_cpu, mask) { | 63 | for_each_cpu(query_cpu, mask) { |
| 62 | __x2apic_send_IPI_dest( | 64 | __x2apic_send_IPI_dest( |
| @@ -73,6 +75,8 @@ static void | |||
| 73 | unsigned long query_cpu; | 75 | unsigned long query_cpu; |
| 74 | unsigned long flags; | 76 | unsigned long flags; |
| 75 | 77 | ||
| 78 | x2apic_wrmsr_fence(); | ||
| 79 | |||
| 76 | local_irq_save(flags); | 80 | local_irq_save(flags); |
| 77 | for_each_cpu(query_cpu, mask) { | 81 | for_each_cpu(query_cpu, mask) { |
| 78 | if (query_cpu == this_cpu) | 82 | if (query_cpu == this_cpu) |
| @@ -90,6 +94,8 @@ static void x2apic_send_IPI_allbutself(int vector) | |||
| 90 | unsigned long query_cpu; | 94 | unsigned long query_cpu; |
| 91 | unsigned long flags; | 95 | unsigned long flags; |
| 92 | 96 | ||
| 97 | x2apic_wrmsr_fence(); | ||
| 98 | |||
| 93 | local_irq_save(flags); | 99 | local_irq_save(flags); |
| 94 | for_each_online_cpu(query_cpu) { | 100 | for_each_online_cpu(query_cpu) { |
| 95 | if (query_cpu == this_cpu) | 101 | if (query_cpu == this_cpu) |
diff --git a/arch/x86/kernel/apic/x2apic_phys.c b/arch/x86/kernel/apic/x2apic_phys.c index 23625b9f98b2..a284359627e7 100644 --- a/arch/x86/kernel/apic/x2apic_phys.c +++ b/arch/x86/kernel/apic/x2apic_phys.c | |||
| @@ -58,6 +58,8 @@ static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector) | |||
| 58 | unsigned long query_cpu; | 58 | unsigned long query_cpu; |
| 59 | unsigned long flags; | 59 | unsigned long flags; |
| 60 | 60 | ||
| 61 | x2apic_wrmsr_fence(); | ||
| 62 | |||
| 61 | local_irq_save(flags); | 63 | local_irq_save(flags); |
| 62 | for_each_cpu(query_cpu, mask) { | 64 | for_each_cpu(query_cpu, mask) { |
| 63 | __x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu), | 65 | __x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu), |
| @@ -73,6 +75,8 @@ static void | |||
| 73 | unsigned long query_cpu; | 75 | unsigned long query_cpu; |
| 74 | unsigned long flags; | 76 | unsigned long flags; |
| 75 | 77 | ||
| 78 | x2apic_wrmsr_fence(); | ||
| 79 | |||
| 76 | local_irq_save(flags); | 80 | local_irq_save(flags); |
| 77 | for_each_cpu(query_cpu, mask) { | 81 | for_each_cpu(query_cpu, mask) { |
| 78 | if (query_cpu != this_cpu) | 82 | if (query_cpu != this_cpu) |
| @@ -89,6 +93,8 @@ static void x2apic_send_IPI_allbutself(int vector) | |||
| 89 | unsigned long query_cpu; | 93 | unsigned long query_cpu; |
| 90 | unsigned long flags; | 94 | unsigned long flags; |
| 91 | 95 | ||
| 96 | x2apic_wrmsr_fence(); | ||
| 97 | |||
| 92 | local_irq_save(flags); | 98 | local_irq_save(flags); |
| 93 | for_each_online_cpu(query_cpu) { | 99 | for_each_online_cpu(query_cpu) { |
| 94 | if (query_cpu == this_cpu) | 100 | if (query_cpu == this_cpu) |
diff --git a/arch/x86/kernel/check.c b/arch/x86/kernel/check.c index 2ac0ab71412a..fc999e6fc46a 100644 --- a/arch/x86/kernel/check.c +++ b/arch/x86/kernel/check.c | |||
| @@ -83,15 +83,15 @@ void __init setup_bios_corruption_check(void) | |||
| 83 | u64 size; | 83 | u64 size; |
| 84 | addr = find_e820_area_size(addr, &size, PAGE_SIZE); | 84 | addr = find_e820_area_size(addr, &size, PAGE_SIZE); |
| 85 | 85 | ||
| 86 | if (addr == 0) | 86 | if (!(addr + 1)) |
| 87 | break; | ||
| 88 | |||
| 89 | if (addr >= corruption_check_size) | ||
| 87 | break; | 90 | break; |
| 88 | 91 | ||
| 89 | if ((addr + size) > corruption_check_size) | 92 | if ((addr + size) > corruption_check_size) |
| 90 | size = corruption_check_size - addr; | 93 | size = corruption_check_size - addr; |
| 91 | 94 | ||
| 92 | if (size == 0) | ||
| 93 | break; | ||
| 94 | |||
| 95 | e820_update_range(addr, size, E820_RAM, E820_RESERVED); | 95 | e820_update_range(addr, size, E820_RAM, E820_RESERVED); |
| 96 | scan_areas[num_scan_areas].addr = addr; | 96 | scan_areas[num_scan_areas].addr = addr; |
| 97 | scan_areas[num_scan_areas].size = size; | 97 | scan_areas[num_scan_areas].size = size; |
diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile index 82db7f45e2de..4e242f9a06e4 100644 --- a/arch/x86/kernel/cpu/Makefile +++ b/arch/x86/kernel/cpu/Makefile | |||
| @@ -14,11 +14,12 @@ obj-y += vmware.o hypervisor.o | |||
| 14 | obj-$(CONFIG_X86_32) += bugs.o cmpxchg.o | 14 | obj-$(CONFIG_X86_32) += bugs.o cmpxchg.o |
| 15 | obj-$(CONFIG_X86_64) += bugs_64.o | 15 | obj-$(CONFIG_X86_64) += bugs_64.o |
| 16 | 16 | ||
| 17 | obj-$(CONFIG_X86_CPU_DEBUG) += cpu_debug.o | ||
| 18 | |||
| 17 | obj-$(CONFIG_CPU_SUP_INTEL) += intel.o | 19 | obj-$(CONFIG_CPU_SUP_INTEL) += intel.o |
| 18 | obj-$(CONFIG_CPU_SUP_AMD) += amd.o | 20 | obj-$(CONFIG_CPU_SUP_AMD) += amd.o |
| 19 | obj-$(CONFIG_CPU_SUP_CYRIX_32) += cyrix.o | 21 | obj-$(CONFIG_CPU_SUP_CYRIX_32) += cyrix.o |
| 20 | obj-$(CONFIG_CPU_SUP_CENTAUR_32) += centaur.o | 22 | obj-$(CONFIG_CPU_SUP_CENTAUR) += centaur.o |
| 21 | obj-$(CONFIG_CPU_SUP_CENTAUR_64) += centaur_64.o | ||
| 22 | obj-$(CONFIG_CPU_SUP_TRANSMETA_32) += transmeta.o | 23 | obj-$(CONFIG_CPU_SUP_TRANSMETA_32) += transmeta.o |
| 23 | obj-$(CONFIG_CPU_SUP_UMC_32) += umc.o | 24 | obj-$(CONFIG_CPU_SUP_UMC_32) += umc.o |
| 24 | 25 | ||
diff --git a/arch/x86/kernel/cpu/addon_cpuid_features.c b/arch/x86/kernel/cpu/addon_cpuid_features.c index 6882a735d9c0..8220ae69849d 100644 --- a/arch/x86/kernel/cpu/addon_cpuid_features.c +++ b/arch/x86/kernel/cpu/addon_cpuid_features.c | |||
| @@ -29,7 +29,7 @@ void __cpuinit init_scattered_cpuid_features(struct cpuinfo_x86 *c) | |||
| 29 | u32 regs[4]; | 29 | u32 regs[4]; |
| 30 | const struct cpuid_bit *cb; | 30 | const struct cpuid_bit *cb; |
| 31 | 31 | ||
| 32 | static const struct cpuid_bit cpuid_bits[] = { | 32 | static const struct cpuid_bit __cpuinitconst cpuid_bits[] = { |
| 33 | { X86_FEATURE_IDA, CR_EAX, 1, 0x00000006 }, | 33 | { X86_FEATURE_IDA, CR_EAX, 1, 0x00000006 }, |
| 34 | { 0, 0, 0, 0 } | 34 | { 0, 0, 0, 0 } |
| 35 | }; | 35 | }; |
diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c index 25423a5b80ed..7e4a459daa64 100644 --- a/arch/x86/kernel/cpu/amd.c +++ b/arch/x86/kernel/cpu/amd.c | |||
| @@ -5,6 +5,7 @@ | |||
| 5 | #include <asm/io.h> | 5 | #include <asm/io.h> |
| 6 | #include <asm/processor.h> | 6 | #include <asm/processor.h> |
| 7 | #include <asm/apic.h> | 7 | #include <asm/apic.h> |
| 8 | #include <asm/cpu.h> | ||
| 8 | 9 | ||
| 9 | #ifdef CONFIG_X86_64 | 10 | #ifdef CONFIG_X86_64 |
| 10 | # include <asm/numa_64.h> | 11 | # include <asm/numa_64.h> |
| @@ -141,6 +142,55 @@ static void __cpuinit init_amd_k6(struct cpuinfo_x86 *c) | |||
| 141 | } | 142 | } |
| 142 | } | 143 | } |
| 143 | 144 | ||
| 145 | static void __cpuinit amd_k7_smp_check(struct cpuinfo_x86 *c) | ||
| 146 | { | ||
| 147 | #ifdef CONFIG_SMP | ||
| 148 | /* calling is from identify_secondary_cpu() ? */ | ||
| 149 | if (c->cpu_index == boot_cpu_id) | ||
| 150 | return; | ||
| 151 | |||
| 152 | /* | ||
| 153 | * Certain Athlons might work (for various values of 'work') in SMP | ||
| 154 | * but they are not certified as MP capable. | ||
| 155 | */ | ||
| 156 | /* Athlon 660/661 is valid. */ | ||
| 157 | if ((c->x86_model == 6) && ((c->x86_mask == 0) || | ||
| 158 | (c->x86_mask == 1))) | ||
| 159 | goto valid_k7; | ||
| 160 | |||
| 161 | /* Duron 670 is valid */ | ||
| 162 | if ((c->x86_model == 7) && (c->x86_mask == 0)) | ||
| 163 | goto valid_k7; | ||
| 164 | |||
| 165 | /* | ||
| 166 | * Athlon 662, Duron 671, and Athlon >model 7 have capability | ||
| 167 | * bit. It's worth noting that the A5 stepping (662) of some | ||
| 168 | * Athlon XP's have the MP bit set. | ||
| 169 | * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for | ||
| 170 | * more. | ||
| 171 | */ | ||
| 172 | if (((c->x86_model == 6) && (c->x86_mask >= 2)) || | ||
| 173 | ((c->x86_model == 7) && (c->x86_mask >= 1)) || | ||
| 174 | (c->x86_model > 7)) | ||
| 175 | if (cpu_has_mp) | ||
| 176 | goto valid_k7; | ||
| 177 | |||
| 178 | /* If we get here, not a certified SMP capable AMD system. */ | ||
| 179 | |||
| 180 | /* | ||
| 181 | * Don't taint if we are running SMP kernel on a single non-MP | ||
| 182 | * approved Athlon | ||
| 183 | */ | ||
| 184 | WARN_ONCE(1, "WARNING: This combination of AMD" | ||
| 185 | "processors is not suitable for SMP.\n"); | ||
| 186 | if (!test_taint(TAINT_UNSAFE_SMP)) | ||
| 187 | add_taint(TAINT_UNSAFE_SMP); | ||
| 188 | |||
| 189 | valid_k7: | ||
| 190 | ; | ||
| 191 | #endif | ||
| 192 | } | ||
| 193 | |||
| 144 | static void __cpuinit init_amd_k7(struct cpuinfo_x86 *c) | 194 | static void __cpuinit init_amd_k7(struct cpuinfo_x86 *c) |
| 145 | { | 195 | { |
| 146 | u32 l, h; | 196 | u32 l, h; |
| @@ -175,6 +225,8 @@ static void __cpuinit init_amd_k7(struct cpuinfo_x86 *c) | |||
| 175 | } | 225 | } |
| 176 | 226 | ||
| 177 | set_cpu_cap(c, X86_FEATURE_K7); | 227 | set_cpu_cap(c, X86_FEATURE_K7); |
| 228 | |||
| 229 | amd_k7_smp_check(c); | ||
| 178 | } | 230 | } |
| 179 | #endif | 231 | #endif |
| 180 | 232 | ||
| @@ -450,7 +502,7 @@ static unsigned int __cpuinit amd_size_cache(struct cpuinfo_x86 *c, unsigned int | |||
| 450 | } | 502 | } |
| 451 | #endif | 503 | #endif |
| 452 | 504 | ||
| 453 | static struct cpu_dev amd_cpu_dev __cpuinitdata = { | 505 | static const struct cpu_dev __cpuinitconst amd_cpu_dev = { |
| 454 | .c_vendor = "AMD", | 506 | .c_vendor = "AMD", |
| 455 | .c_ident = { "AuthenticAMD" }, | 507 | .c_ident = { "AuthenticAMD" }, |
| 456 | #ifdef CONFIG_X86_32 | 508 | #ifdef CONFIG_X86_32 |
diff --git a/arch/x86/kernel/cpu/centaur.c b/arch/x86/kernel/cpu/centaur.c index 89bfdd9cacc6..c95e831bb095 100644 --- a/arch/x86/kernel/cpu/centaur.c +++ b/arch/x86/kernel/cpu/centaur.c | |||
| @@ -1,11 +1,11 @@ | |||
| 1 | #include <linux/bitops.h> | ||
| 1 | #include <linux/kernel.h> | 2 | #include <linux/kernel.h> |
| 2 | #include <linux/init.h> | 3 | #include <linux/init.h> |
| 3 | #include <linux/bitops.h> | ||
| 4 | 4 | ||
| 5 | #include <asm/processor.h> | 5 | #include <asm/processor.h> |
| 6 | #include <asm/msr.h> | ||
| 7 | #include <asm/e820.h> | 6 | #include <asm/e820.h> |
| 8 | #include <asm/mtrr.h> | 7 | #include <asm/mtrr.h> |
| 8 | #include <asm/msr.h> | ||
| 9 | 9 | ||
| 10 | #include "cpu.h" | 10 | #include "cpu.h" |
| 11 | 11 | ||
| @@ -276,7 +276,7 @@ static void __cpuinit init_c3(struct cpuinfo_x86 *c) | |||
| 276 | */ | 276 | */ |
| 277 | c->x86_capability[5] = cpuid_edx(0xC0000001); | 277 | c->x86_capability[5] = cpuid_edx(0xC0000001); |
| 278 | } | 278 | } |
| 279 | 279 | #ifdef CONFIG_X86_32 | |
| 280 | /* Cyrix III family needs CX8 & PGE explicitly enabled. */ | 280 | /* Cyrix III family needs CX8 & PGE explicitly enabled. */ |
| 281 | if (c->x86_model >= 6 && c->x86_model <= 9) { | 281 | if (c->x86_model >= 6 && c->x86_model <= 9) { |
| 282 | rdmsr(MSR_VIA_FCR, lo, hi); | 282 | rdmsr(MSR_VIA_FCR, lo, hi); |
| @@ -288,6 +288,11 @@ static void __cpuinit init_c3(struct cpuinfo_x86 *c) | |||
| 288 | /* Before Nehemiah, the C3's had 3dNOW! */ | 288 | /* Before Nehemiah, the C3's had 3dNOW! */ |
| 289 | if (c->x86_model >= 6 && c->x86_model < 9) | 289 | if (c->x86_model >= 6 && c->x86_model < 9) |
| 290 | set_cpu_cap(c, X86_FEATURE_3DNOW); | 290 | set_cpu_cap(c, X86_FEATURE_3DNOW); |
| 291 | #endif | ||
| 292 | if (c->x86 == 0x6 && c->x86_model >= 0xf) { | ||
| 293 | c->x86_cache_alignment = c->x86_clflush_size * 2; | ||
| 294 | set_cpu_cap(c, X86_FEATURE_REP_GOOD); | ||
| 295 | } | ||
| 291 | 296 | ||
| 292 | display_cacheinfo(c); | 297 | display_cacheinfo(c); |
| 293 | } | 298 | } |
| @@ -316,16 +321,25 @@ enum { | |||
| 316 | static void __cpuinit early_init_centaur(struct cpuinfo_x86 *c) | 321 | static void __cpuinit early_init_centaur(struct cpuinfo_x86 *c) |
| 317 | { | 322 | { |
| 318 | switch (c->x86) { | 323 | switch (c->x86) { |
| 324 | #ifdef CONFIG_X86_32 | ||
| 319 | case 5: | 325 | case 5: |
| 320 | /* Emulate MTRRs using Centaur's MCR. */ | 326 | /* Emulate MTRRs using Centaur's MCR. */ |
| 321 | set_cpu_cap(c, X86_FEATURE_CENTAUR_MCR); | 327 | set_cpu_cap(c, X86_FEATURE_CENTAUR_MCR); |
| 322 | break; | 328 | break; |
| 329 | #endif | ||
| 330 | case 6: | ||
| 331 | if (c->x86_model >= 0xf) | ||
| 332 | set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC); | ||
| 333 | break; | ||
| 323 | } | 334 | } |
| 335 | #ifdef CONFIG_X86_64 | ||
| 336 | set_cpu_cap(c, X86_FEATURE_SYSENTER32); | ||
| 337 | #endif | ||
| 324 | } | 338 | } |
| 325 | 339 | ||
| 326 | static void __cpuinit init_centaur(struct cpuinfo_x86 *c) | 340 | static void __cpuinit init_centaur(struct cpuinfo_x86 *c) |
| 327 | { | 341 | { |
| 328 | 342 | #ifdef CONFIG_X86_32 | |
| 329 | char *name; | 343 | char *name; |
| 330 | u32 fcr_set = 0; | 344 | u32 fcr_set = 0; |
| 331 | u32 fcr_clr = 0; | 345 | u32 fcr_clr = 0; |
| @@ -337,8 +351,10 @@ static void __cpuinit init_centaur(struct cpuinfo_x86 *c) | |||
| 337 | * 3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway | 351 | * 3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway |
| 338 | */ | 352 | */ |
| 339 | clear_cpu_cap(c, 0*32+31); | 353 | clear_cpu_cap(c, 0*32+31); |
| 340 | 354 | #endif | |
| 355 | early_init_centaur(c); | ||
| 341 | switch (c->x86) { | 356 | switch (c->x86) { |
| 357 | #ifdef CONFIG_X86_32 | ||
| 342 | case 5: | 358 | case 5: |
| 343 | switch (c->x86_model) { | 359 | switch (c->x86_model) { |
| 344 | case 4: | 360 | case 4: |
| @@ -442,16 +458,20 @@ static void __cpuinit init_centaur(struct cpuinfo_x86 *c) | |||
| 442 | } | 458 | } |
| 443 | sprintf(c->x86_model_id, "WinChip %s", name); | 459 | sprintf(c->x86_model_id, "WinChip %s", name); |
| 444 | break; | 460 | break; |
| 445 | 461 | #endif | |
| 446 | case 6: | 462 | case 6: |
| 447 | init_c3(c); | 463 | init_c3(c); |
| 448 | break; | 464 | break; |
| 449 | } | 465 | } |
| 466 | #ifdef CONFIG_X86_64 | ||
| 467 | set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC); | ||
| 468 | #endif | ||
| 450 | } | 469 | } |
| 451 | 470 | ||
| 452 | static unsigned int __cpuinit | 471 | static unsigned int __cpuinit |
| 453 | centaur_size_cache(struct cpuinfo_x86 *c, unsigned int size) | 472 | centaur_size_cache(struct cpuinfo_x86 *c, unsigned int size) |
| 454 | { | 473 | { |
| 474 | #ifdef CONFIG_X86_32 | ||
| 455 | /* VIA C3 CPUs (670-68F) need further shifting. */ | 475 | /* VIA C3 CPUs (670-68F) need further shifting. */ |
| 456 | if ((c->x86 == 6) && ((c->x86_model == 7) || (c->x86_model == 8))) | 476 | if ((c->x86 == 6) && ((c->x86_model == 7) || (c->x86_model == 8))) |
| 457 | size >>= 8; | 477 | size >>= 8; |
| @@ -464,11 +484,11 @@ centaur_size_cache(struct cpuinfo_x86 *c, unsigned int size) | |||
| 464 | if ((c->x86 == 6) && (c->x86_model == 9) && | 484 | if ((c->x86 == 6) && (c->x86_model == 9) && |
| 465 | (c->x86_mask == 1) && (size == 65)) | 485 | (c->x86_mask == 1) && (size == 65)) |
| 466 | size -= 1; | 486 | size -= 1; |
| 467 | 487 | #endif | |
| 468 | return size; | 488 | return size; |
| 469 | } | 489 | } |
| 470 | 490 | ||
| 471 | static struct cpu_dev centaur_cpu_dev __cpuinitdata = { | 491 | static const struct cpu_dev __cpuinitconst centaur_cpu_dev = { |
| 472 | .c_vendor = "Centaur", | 492 | .c_vendor = "Centaur", |
| 473 | .c_ident = { "CentaurHauls" }, | 493 | .c_ident = { "CentaurHauls" }, |
| 474 | .c_early_init = early_init_centaur, | 494 | .c_early_init = early_init_centaur, |
diff --git a/arch/x86/kernel/cpu/centaur_64.c b/arch/x86/kernel/cpu/centaur_64.c deleted file mode 100644 index a1625f5a1e78..000000000000 --- a/arch/x86/kernel/cpu/centaur_64.c +++ /dev/null | |||
| @@ -1,37 +0,0 @@ | |||
| 1 | #include <linux/init.h> | ||
| 2 | #include <linux/smp.h> | ||
| 3 | |||
| 4 | #include <asm/cpufeature.h> | ||
| 5 | #include <asm/processor.h> | ||
| 6 | |||
| 7 | #include "cpu.h" | ||
| 8 | |||
| 9 | static void __cpuinit early_init_centaur(struct cpuinfo_x86 *c) | ||
| 10 | { | ||
| 11 | if (c->x86 == 0x6 && c->x86_model >= 0xf) | ||
| 12 | set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC); | ||
| 13 | |||
| 14 | set_cpu_cap(c, X86_FEATURE_SYSENTER32); | ||
| 15 | } | ||
| 16 | |||
| 17 | static void __cpuinit init_centaur(struct cpuinfo_x86 *c) | ||
| 18 | { | ||
| 19 | early_init_centaur(c); | ||
| 20 | |||
| 21 | if (c->x86 == 0x6 && c->x86_model >= 0xf) { | ||
| 22 | c->x86_cache_alignment = c->x86_clflush_size * 2; | ||
| 23 | set_cpu_cap(c, X86_FEATURE_REP_GOOD); | ||
| 24 | } | ||
| 25 | set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC); | ||
| 26 | } | ||
| 27 | |||
| 28 | static struct cpu_dev centaur_cpu_dev __cpuinitdata = { | ||
| 29 | .c_vendor = "Centaur", | ||
| 30 | .c_ident = { "CentaurHauls" }, | ||
| 31 | .c_early_init = early_init_centaur, | ||
| 32 | .c_init = init_centaur, | ||
| 33 | .c_x86_vendor = X86_VENDOR_CENTAUR, | ||
| 34 | }; | ||
| 35 | |||
| 36 | cpu_dev_register(centaur_cpu_dev); | ||
| 37 | |||
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c index 826d5c876278..e2962cc1e27b 100644 --- a/arch/x86/kernel/cpu/common.c +++ b/arch/x86/kernel/cpu/common.c | |||
| @@ -1,52 +1,52 @@ | |||
| 1 | #include <linux/init.h> | ||
| 2 | #include <linux/kernel.h> | ||
| 3 | #include <linux/sched.h> | ||
| 4 | #include <linux/string.h> | ||
| 5 | #include <linux/bootmem.h> | 1 | #include <linux/bootmem.h> |
| 2 | #include <linux/linkage.h> | ||
| 6 | #include <linux/bitops.h> | 3 | #include <linux/bitops.h> |
| 4 | #include <linux/kernel.h> | ||
| 7 | #include <linux/module.h> | 5 | #include <linux/module.h> |
| 8 | #include <linux/kgdb.h> | 6 | #include <linux/percpu.h> |
| 9 | #include <linux/topology.h> | 7 | #include <linux/string.h> |
| 10 | #include <linux/delay.h> | 8 | #include <linux/delay.h> |
| 9 | #include <linux/sched.h> | ||
| 10 | #include <linux/init.h> | ||
| 11 | #include <linux/kgdb.h> | ||
| 11 | #include <linux/smp.h> | 12 | #include <linux/smp.h> |
| 12 | #include <linux/percpu.h> | 13 | #include <linux/io.h> |
| 13 | #include <asm/i387.h> | 14 | |
| 14 | #include <asm/msr.h> | 15 | #include <asm/stackprotector.h> |
| 15 | #include <asm/io.h> | ||
| 16 | #include <asm/linkage.h> | ||
| 17 | #include <asm/mmu_context.h> | 16 | #include <asm/mmu_context.h> |
| 17 | #include <asm/hypervisor.h> | ||
| 18 | #include <asm/processor.h> | ||
| 19 | #include <asm/sections.h> | ||
| 20 | #include <asm/topology.h> | ||
| 21 | #include <asm/cpumask.h> | ||
| 22 | #include <asm/pgtable.h> | ||
| 23 | #include <asm/atomic.h> | ||
| 24 | #include <asm/proto.h> | ||
| 25 | #include <asm/setup.h> | ||
| 26 | #include <asm/apic.h> | ||
| 27 | #include <asm/desc.h> | ||
| 28 | #include <asm/i387.h> | ||
| 18 | #include <asm/mtrr.h> | 29 | #include <asm/mtrr.h> |
| 30 | #include <asm/numa.h> | ||
| 31 | #include <asm/asm.h> | ||
| 32 | #include <asm/cpu.h> | ||
| 19 | #include <asm/mce.h> | 33 | #include <asm/mce.h> |
| 34 | #include <asm/msr.h> | ||
| 20 | #include <asm/pat.h> | 35 | #include <asm/pat.h> |
| 21 | #include <asm/asm.h> | ||
| 22 | #include <asm/numa.h> | ||
| 23 | #include <asm/smp.h> | 36 | #include <asm/smp.h> |
| 24 | #include <asm/cpu.h> | ||
| 25 | #include <asm/cpumask.h> | ||
| 26 | #include <asm/apic.h> | ||
| 27 | 37 | ||
| 28 | #ifdef CONFIG_X86_LOCAL_APIC | 38 | #ifdef CONFIG_X86_LOCAL_APIC |
| 29 | #include <asm/uv/uv.h> | 39 | #include <asm/uv/uv.h> |
| 30 | #endif | 40 | #endif |
| 31 | 41 | ||
| 32 | #include <asm/pgtable.h> | ||
| 33 | #include <asm/processor.h> | ||
| 34 | #include <asm/desc.h> | ||
| 35 | #include <asm/atomic.h> | ||
| 36 | #include <asm/proto.h> | ||
| 37 | #include <asm/sections.h> | ||
| 38 | #include <asm/setup.h> | ||
| 39 | #include <asm/hypervisor.h> | ||
| 40 | #include <asm/stackprotector.h> | ||
| 41 | |||
| 42 | #include "cpu.h" | 42 | #include "cpu.h" |
| 43 | 43 | ||
| 44 | #ifdef CONFIG_X86_64 | 44 | #ifdef CONFIG_X86_64 |
| 45 | 45 | ||
| 46 | /* all of these masks are initialized in setup_cpu_local_masks() */ | 46 | /* all of these masks are initialized in setup_cpu_local_masks() */ |
| 47 | cpumask_var_t cpu_callin_mask; | ||
| 48 | cpumask_var_t cpu_callout_mask; | ||
| 49 | cpumask_var_t cpu_initialized_mask; | 47 | cpumask_var_t cpu_initialized_mask; |
| 48 | cpumask_var_t cpu_callout_mask; | ||
| 49 | cpumask_var_t cpu_callin_mask; | ||
| 50 | 50 | ||
| 51 | /* representing cpus for which sibling maps can be computed */ | 51 | /* representing cpus for which sibling maps can be computed */ |
| 52 | cpumask_var_t cpu_sibling_setup_mask; | 52 | cpumask_var_t cpu_sibling_setup_mask; |
| @@ -62,15 +62,15 @@ void __init setup_cpu_local_masks(void) | |||
| 62 | 62 | ||
| 63 | #else /* CONFIG_X86_32 */ | 63 | #else /* CONFIG_X86_32 */ |
| 64 | 64 | ||
| 65 | cpumask_t cpu_callin_map; | 65 | cpumask_t cpu_sibling_setup_map; |
| 66 | cpumask_t cpu_callout_map; | 66 | cpumask_t cpu_callout_map; |
| 67 | cpumask_t cpu_initialized; | 67 | cpumask_t cpu_initialized; |
| 68 | cpumask_t cpu_sibling_setup_map; | 68 | cpumask_t cpu_callin_map; |
| 69 | 69 | ||
| 70 | #endif /* CONFIG_X86_32 */ | 70 | #endif /* CONFIG_X86_32 */ |
| 71 | 71 | ||
| 72 | 72 | ||
| 73 | static struct cpu_dev *this_cpu __cpuinitdata; | 73 | static const struct cpu_dev *this_cpu __cpuinitdata; |
| 74 | 74 | ||
| 75 | DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = { | 75 | DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = { |
| 76 | #ifdef CONFIG_X86_64 | 76 | #ifdef CONFIG_X86_64 |
| @@ -79,48 +79,48 @@ DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = { | |||
| 79 | * IRET will check the segment types kkeil 2000/10/28 | 79 | * IRET will check the segment types kkeil 2000/10/28 |
| 80 | * Also sysret mandates a special GDT layout | 80 | * Also sysret mandates a special GDT layout |
| 81 | * | 81 | * |
| 82 | * The TLS descriptors are currently at a different place compared to i386. | 82 | * TLS descriptors are currently at a different place compared to i386. |
| 83 | * Hopefully nobody expects them at a fixed place (Wine?) | 83 | * Hopefully nobody expects them at a fixed place (Wine?) |
| 84 | */ | 84 | */ |
| 85 | [GDT_ENTRY_KERNEL32_CS] = { { { 0x0000ffff, 0x00cf9b00 } } }, | 85 | [GDT_ENTRY_KERNEL32_CS] = { { { 0x0000ffff, 0x00cf9b00 } } }, |
| 86 | [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00af9b00 } } }, | 86 | [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00af9b00 } } }, |
| 87 | [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9300 } } }, | 87 | [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9300 } } }, |
| 88 | [GDT_ENTRY_DEFAULT_USER32_CS] = { { { 0x0000ffff, 0x00cffb00 } } }, | 88 | [GDT_ENTRY_DEFAULT_USER32_CS] = { { { 0x0000ffff, 0x00cffb00 } } }, |
| 89 | [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff300 } } }, | 89 | [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff300 } } }, |
| 90 | [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00affb00 } } }, | 90 | [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00affb00 } } }, |
| 91 | #else | 91 | #else |
| 92 | [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } }, | 92 | [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } }, |
| 93 | [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } }, | 93 | [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } }, |
| 94 | [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } }, | 94 | [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } }, |
| 95 | [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } }, | 95 | [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } }, |
| 96 | /* | 96 | /* |
| 97 | * Segments used for calling PnP BIOS have byte granularity. | 97 | * Segments used for calling PnP BIOS have byte granularity. |
| 98 | * They code segments and data segments have fixed 64k limits, | 98 | * They code segments and data segments have fixed 64k limits, |
| 99 | * the transfer segment sizes are set at run time. | 99 | * the transfer segment sizes are set at run time. |
| 100 | */ | 100 | */ |
| 101 | /* 32-bit code */ | 101 | /* 32-bit code */ |
| 102 | [GDT_ENTRY_PNPBIOS_CS32] = { { { 0x0000ffff, 0x00409a00 } } }, | 102 | [GDT_ENTRY_PNPBIOS_CS32] = { { { 0x0000ffff, 0x00409a00 } } }, |
| 103 | /* 16-bit code */ | 103 | /* 16-bit code */ |
| 104 | [GDT_ENTRY_PNPBIOS_CS16] = { { { 0x0000ffff, 0x00009a00 } } }, | 104 | [GDT_ENTRY_PNPBIOS_CS16] = { { { 0x0000ffff, 0x00009a00 } } }, |
| 105 | /* 16-bit data */ | 105 | /* 16-bit data */ |
| 106 | [GDT_ENTRY_PNPBIOS_DS] = { { { 0x0000ffff, 0x00009200 } } }, | 106 | [GDT_ENTRY_PNPBIOS_DS] = { { { 0x0000ffff, 0x00009200 } } }, |
| 107 | /* 16-bit data */ | 107 | /* 16-bit data */ |
| 108 | [GDT_ENTRY_PNPBIOS_TS1] = { { { 0x00000000, 0x00009200 } } }, | 108 | [GDT_ENTRY_PNPBIOS_TS1] = { { { 0x00000000, 0x00009200 } } }, |
| 109 | /* 16-bit data */ | 109 | /* 16-bit data */ |
| 110 | [GDT_ENTRY_PNPBIOS_TS2] = { { { 0x00000000, 0x00009200 } } }, | 110 | [GDT_ENTRY_PNPBIOS_TS2] = { { { 0x00000000, 0x00009200 } } }, |
| 111 | /* | 111 | /* |
| 112 | * The APM segments have byte granularity and their bases | 112 | * The APM segments have byte granularity and their bases |
| 113 | * are set at run time. All have 64k limits. | 113 | * are set at run time. All have 64k limits. |
| 114 | */ | 114 | */ |
| 115 | /* 32-bit code */ | 115 | /* 32-bit code */ |
| 116 | [GDT_ENTRY_APMBIOS_BASE] = { { { 0x0000ffff, 0x00409a00 } } }, | 116 | [GDT_ENTRY_APMBIOS_BASE] = { { { 0x0000ffff, 0x00409a00 } } }, |
| 117 | /* 16-bit code */ | 117 | /* 16-bit code */ |
| 118 | [GDT_ENTRY_APMBIOS_BASE+1] = { { { 0x0000ffff, 0x00009a00 } } }, | 118 | [GDT_ENTRY_APMBIOS_BASE+1] = { { { 0x0000ffff, 0x00009a00 } } }, |
| 119 | /* data */ | 119 | /* data */ |
| 120 | [GDT_ENTRY_APMBIOS_BASE+2] = { { { 0x0000ffff, 0x00409200 } } }, | 120 | [GDT_ENTRY_APMBIOS_BASE+2] = { { { 0x0000ffff, 0x00409200 } } }, |
| 121 | 121 | ||
| 122 | [GDT_ENTRY_ESPFIX_SS] = { { { 0x00000000, 0x00c09200 } } }, | 122 | [GDT_ENTRY_ESPFIX_SS] = { { { 0x00000000, 0x00c09200 } } }, |
| 123 | [GDT_ENTRY_PERCPU] = { { { 0x0000ffff, 0x00cf9200 } } }, | 123 | [GDT_ENTRY_PERCPU] = { { { 0x0000ffff, 0x00cf9200 } } }, |
| 124 | GDT_STACK_CANARY_INIT | 124 | GDT_STACK_CANARY_INIT |
| 125 | #endif | 125 | #endif |
| 126 | } }; | 126 | } }; |
| @@ -164,16 +164,17 @@ static inline int flag_is_changeable_p(u32 flag) | |||
| 164 | * the CPUID. Add "volatile" to not allow gcc to | 164 | * the CPUID. Add "volatile" to not allow gcc to |
| 165 | * optimize the subsequent calls to this function. | 165 | * optimize the subsequent calls to this function. |
| 166 | */ | 166 | */ |
| 167 | asm volatile ("pushfl\n\t" | 167 | asm volatile ("pushfl \n\t" |
| 168 | "pushfl\n\t" | 168 | "pushfl \n\t" |
| 169 | "popl %0\n\t" | 169 | "popl %0 \n\t" |
| 170 | "movl %0,%1\n\t" | 170 | "movl %0, %1 \n\t" |
| 171 | "xorl %2,%0\n\t" | 171 | "xorl %2, %0 \n\t" |
| 172 | "pushl %0\n\t" | 172 | "pushl %0 \n\t" |
| 173 | "popfl\n\t" | 173 | "popfl \n\t" |
| 174 | "pushfl\n\t" | 174 | "pushfl \n\t" |
| 175 | "popl %0\n\t" | 175 | "popl %0 \n\t" |
| 176 | "popfl\n\t" | 176 | "popfl \n\t" |
| 177 | |||
| 177 | : "=&r" (f1), "=&r" (f2) | 178 | : "=&r" (f1), "=&r" (f2) |
| 178 | : "ir" (flag)); | 179 | : "ir" (flag)); |
| 179 | 180 | ||
| @@ -188,18 +189,22 @@ static int __cpuinit have_cpuid_p(void) | |||
| 188 | 189 | ||
| 189 | static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c) | 190 | static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c) |
| 190 | { | 191 | { |
| 191 | if (cpu_has(c, X86_FEATURE_PN) && disable_x86_serial_nr) { | 192 | unsigned long lo, hi; |
| 192 | /* Disable processor serial number */ | 193 | |
| 193 | unsigned long lo, hi; | 194 | if (!cpu_has(c, X86_FEATURE_PN) || !disable_x86_serial_nr) |
| 194 | rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi); | 195 | return; |
| 195 | lo |= 0x200000; | 196 | |
| 196 | wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi); | 197 | /* Disable processor serial number: */ |
| 197 | printk(KERN_NOTICE "CPU serial number disabled.\n"); | 198 | |
| 198 | clear_cpu_cap(c, X86_FEATURE_PN); | 199 | rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi); |
| 199 | 200 | lo |= 0x200000; | |
| 200 | /* Disabling the serial number may affect the cpuid level */ | 201 | wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi); |
| 201 | c->cpuid_level = cpuid_eax(0); | 202 | |
| 202 | } | 203 | printk(KERN_NOTICE "CPU serial number disabled.\n"); |
| 204 | clear_cpu_cap(c, X86_FEATURE_PN); | ||
| 205 | |||
| 206 | /* Disabling the serial number may affect the cpuid level */ | ||
| 207 | c->cpuid_level = cpuid_eax(0); | ||
| 203 | } | 208 | } |
| 204 | 209 | ||
| 205 | static int __init x86_serial_nr_setup(char *s) | 210 | static int __init x86_serial_nr_setup(char *s) |
| @@ -232,6 +237,7 @@ struct cpuid_dependent_feature { | |||
| 232 | u32 feature; | 237 | u32 feature; |
| 233 | u32 level; | 238 | u32 level; |
| 234 | }; | 239 | }; |
| 240 | |||
| 235 | static const struct cpuid_dependent_feature __cpuinitconst | 241 | static const struct cpuid_dependent_feature __cpuinitconst |
| 236 | cpuid_dependent_features[] = { | 242 | cpuid_dependent_features[] = { |
| 237 | { X86_FEATURE_MWAIT, 0x00000005 }, | 243 | { X86_FEATURE_MWAIT, 0x00000005 }, |
| @@ -243,7 +249,11 @@ cpuid_dependent_features[] = { | |||
| 243 | static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn) | 249 | static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn) |
| 244 | { | 250 | { |
| 245 | const struct cpuid_dependent_feature *df; | 251 | const struct cpuid_dependent_feature *df; |
| 252 | |||
| 246 | for (df = cpuid_dependent_features; df->feature; df++) { | 253 | for (df = cpuid_dependent_features; df->feature; df++) { |
| 254 | |||
| 255 | if (!cpu_has(c, df->feature)) | ||
| 256 | continue; | ||
| 247 | /* | 257 | /* |
| 248 | * Note: cpuid_level is set to -1 if unavailable, but | 258 | * Note: cpuid_level is set to -1 if unavailable, but |
| 249 | * extended_extended_level is set to 0 if unavailable | 259 | * extended_extended_level is set to 0 if unavailable |
| @@ -251,32 +261,32 @@ static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn) | |||
| 251 | * when signed; hence the weird messing around with | 261 | * when signed; hence the weird messing around with |
| 252 | * signs here... | 262 | * signs here... |
| 253 | */ | 263 | */ |
| 254 | if (cpu_has(c, df->feature) && | 264 | if (!((s32)df->level < 0 ? |
| 255 | ((s32)df->level < 0 ? | ||
| 256 | (u32)df->level > (u32)c->extended_cpuid_level : | 265 | (u32)df->level > (u32)c->extended_cpuid_level : |
| 257 | (s32)df->level > (s32)c->cpuid_level)) { | 266 | (s32)df->level > (s32)c->cpuid_level)) |
| 258 | clear_cpu_cap(c, df->feature); | 267 | continue; |
| 259 | if (warn) | 268 | |
| 260 | printk(KERN_WARNING | 269 | clear_cpu_cap(c, df->feature); |
| 261 | "CPU: CPU feature %s disabled " | 270 | if (!warn) |
| 262 | "due to lack of CPUID level 0x%x\n", | 271 | continue; |
| 263 | x86_cap_flags[df->feature], | 272 | |
| 264 | df->level); | 273 | printk(KERN_WARNING |
| 265 | } | 274 | "CPU: CPU feature %s disabled, no CPUID level 0x%x\n", |
| 275 | x86_cap_flags[df->feature], df->level); | ||
| 266 | } | 276 | } |
| 267 | } | 277 | } |
| 268 | 278 | ||
| 269 | /* | 279 | /* |
| 270 | * Naming convention should be: <Name> [(<Codename>)] | 280 | * Naming convention should be: <Name> [(<Codename>)] |
| 271 | * This table only is used unless init_<vendor>() below doesn't set it; | 281 | * This table only is used unless init_<vendor>() below doesn't set it; |
| 272 | * in particular, if CPUID levels 0x80000002..4 are supported, this isn't used | 282 | * in particular, if CPUID levels 0x80000002..4 are supported, this |
| 273 | * | 283 | * isn't used |
| 274 | */ | 284 | */ |
| 275 | 285 | ||
| 276 | /* Look up CPU names by table lookup. */ | 286 | /* Look up CPU names by table lookup. */ |
| 277 | static char __cpuinit *table_lookup_model(struct cpuinfo_x86 *c) | 287 | static const char *__cpuinit table_lookup_model(struct cpuinfo_x86 *c) |
| 278 | { | 288 | { |
| 279 | struct cpu_model_info *info; | 289 | const struct cpu_model_info *info; |
| 280 | 290 | ||
| 281 | if (c->x86_model >= 16) | 291 | if (c->x86_model >= 16) |
| 282 | return NULL; /* Range check */ | 292 | return NULL; /* Range check */ |
| @@ -307,8 +317,10 @@ void load_percpu_segment(int cpu) | |||
| 307 | load_stack_canary_segment(); | 317 | load_stack_canary_segment(); |
| 308 | } | 318 | } |
| 309 | 319 | ||
| 310 | /* Current gdt points %fs at the "master" per-cpu area: after this, | 320 | /* |
| 311 | * it's on the real one. */ | 321 | * Current gdt points %fs at the "master" per-cpu area: after this, |
| 322 | * it's on the real one. | ||
| 323 | */ | ||
| 312 | void switch_to_new_gdt(int cpu) | 324 | void switch_to_new_gdt(int cpu) |
| 313 | { | 325 | { |
| 314 | struct desc_ptr gdt_descr; | 326 | struct desc_ptr gdt_descr; |
| @@ -321,7 +333,7 @@ void switch_to_new_gdt(int cpu) | |||
| 321 | load_percpu_segment(cpu); | 333 | load_percpu_segment(cpu); |
| 322 | } | 334 | } |
| 323 | 335 | ||
| 324 | static struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {}; | 336 | static const struct cpu_dev *__cpuinitdata cpu_devs[X86_VENDOR_NUM] = {}; |
| 325 | 337 | ||
| 326 | static void __cpuinit default_init(struct cpuinfo_x86 *c) | 338 | static void __cpuinit default_init(struct cpuinfo_x86 *c) |
| 327 | { | 339 | { |
| @@ -340,7 +352,7 @@ static void __cpuinit default_init(struct cpuinfo_x86 *c) | |||
| 340 | #endif | 352 | #endif |
| 341 | } | 353 | } |
| 342 | 354 | ||
| 343 | static struct cpu_dev __cpuinitdata default_cpu = { | 355 | static const struct cpu_dev __cpuinitconst default_cpu = { |
| 344 | .c_init = default_init, | 356 | .c_init = default_init, |
| 345 | .c_vendor = "Unknown", | 357 | .c_vendor = "Unknown", |
| 346 | .c_x86_vendor = X86_VENDOR_UNKNOWN, | 358 | .c_x86_vendor = X86_VENDOR_UNKNOWN, |
| @@ -354,22 +366,24 @@ static void __cpuinit get_model_name(struct cpuinfo_x86 *c) | |||
| 354 | if (c->extended_cpuid_level < 0x80000004) | 366 | if (c->extended_cpuid_level < 0x80000004) |
| 355 | return; | 367 | return; |
| 356 | 368 | ||
| 357 | v = (unsigned int *) c->x86_model_id; | 369 | v = (unsigned int *)c->x86_model_id; |
| 358 | cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]); | 370 | cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]); |
| 359 | cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]); | 371 | cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]); |
| 360 | cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]); | 372 | cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]); |
| 361 | c->x86_model_id[48] = 0; | 373 | c->x86_model_id[48] = 0; |
| 362 | 374 | ||
| 363 | /* Intel chips right-justify this string for some dumb reason; | 375 | /* |
| 364 | undo that brain damage */ | 376 | * Intel chips right-justify this string for some dumb reason; |
| 377 | * undo that brain damage: | ||
| 378 | */ | ||
| 365 | p = q = &c->x86_model_id[0]; | 379 | p = q = &c->x86_model_id[0]; |
| 366 | while (*p == ' ') | 380 | while (*p == ' ') |
| 367 | p++; | 381 | p++; |
| 368 | if (p != q) { | 382 | if (p != q) { |
| 369 | while (*p) | 383 | while (*p) |
| 370 | *q++ = *p++; | 384 | *q++ = *p++; |
| 371 | while (q <= &c->x86_model_id[48]) | 385 | while (q <= &c->x86_model_id[48]) |
| 372 | *q++ = '\0'; /* Zero-pad the rest */ | 386 | *q++ = '\0'; /* Zero-pad the rest */ |
| 373 | } | 387 | } |
| 374 | } | 388 | } |
| 375 | 389 | ||
| @@ -438,27 +452,30 @@ void __cpuinit detect_ht(struct cpuinfo_x86 *c) | |||
| 438 | 452 | ||
| 439 | if (smp_num_siblings == 1) { | 453 | if (smp_num_siblings == 1) { |
| 440 | printk(KERN_INFO "CPU: Hyper-Threading is disabled\n"); | 454 | printk(KERN_INFO "CPU: Hyper-Threading is disabled\n"); |
| 441 | } else if (smp_num_siblings > 1) { | 455 | goto out; |
| 456 | } | ||
| 442 | 457 | ||
| 443 | if (smp_num_siblings > nr_cpu_ids) { | 458 | if (smp_num_siblings <= 1) |
| 444 | printk(KERN_WARNING "CPU: Unsupported number of siblings %d", | 459 | goto out; |
| 445 | smp_num_siblings); | 460 | |
| 446 | smp_num_siblings = 1; | 461 | if (smp_num_siblings > nr_cpu_ids) { |
| 447 | return; | 462 | pr_warning("CPU: Unsupported number of siblings %d", |
| 448 | } | 463 | smp_num_siblings); |
| 464 | smp_num_siblings = 1; | ||
| 465 | return; | ||
| 466 | } | ||
| 449 | 467 | ||
| 450 | index_msb = get_count_order(smp_num_siblings); | 468 | index_msb = get_count_order(smp_num_siblings); |
| 451 | c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb); | 469 | c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb); |
| 452 | 470 | ||
| 453 | smp_num_siblings = smp_num_siblings / c->x86_max_cores; | 471 | smp_num_siblings = smp_num_siblings / c->x86_max_cores; |
| 454 | 472 | ||
| 455 | index_msb = get_count_order(smp_num_siblings); | 473 | index_msb = get_count_order(smp_num_siblings); |
| 456 | 474 | ||
| 457 | core_bits = get_count_order(c->x86_max_cores); | 475 | core_bits = get_count_order(c->x86_max_cores); |
| 458 | 476 | ||
| 459 | c->cpu_core_id = apic->phys_pkg_id(c->initial_apicid, index_msb) & | 477 | c->cpu_core_id = apic->phys_pkg_id(c->initial_apicid, index_msb) & |
| 460 | ((1 << core_bits) - 1); | 478 | ((1 << core_bits) - 1); |
| 461 | } | ||
| 462 | 479 | ||
| 463 | out: | 480 | out: |
| 464 | if ((c->x86_max_cores * smp_num_siblings) > 1) { | 481 | if ((c->x86_max_cores * smp_num_siblings) > 1) { |
| @@ -473,8 +490,8 @@ out: | |||
| 473 | static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c) | 490 | static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c) |
| 474 | { | 491 | { |
| 475 | char *v = c->x86_vendor_id; | 492 | char *v = c->x86_vendor_id; |
| 476 | int i; | ||
| 477 | static int printed; | 493 | static int printed; |
| 494 | int i; | ||
| 478 | 495 | ||
| 479 | for (i = 0; i < X86_VENDOR_NUM; i++) { | 496 | for (i = 0; i < X86_VENDOR_NUM; i++) { |
| 480 | if (!cpu_devs[i]) | 497 | if (!cpu_devs[i]) |
| @@ -483,6 +500,7 @@ static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c) | |||
| 483 | if (!strcmp(v, cpu_devs[i]->c_ident[0]) || | 500 | if (!strcmp(v, cpu_devs[i]->c_ident[0]) || |
| 484 | (cpu_devs[i]->c_ident[1] && | 501 | (cpu_devs[i]->c_ident[1] && |
| 485 | !strcmp(v, cpu_devs[i]->c_ident[1]))) { | 502 | !strcmp(v, cpu_devs[i]->c_ident[1]))) { |
| 503 | |||
| 486 | this_cpu = cpu_devs[i]; | 504 | this_cpu = cpu_devs[i]; |
| 487 | c->x86_vendor = this_cpu->c_x86_vendor; | 505 | c->x86_vendor = this_cpu->c_x86_vendor; |
| 488 | return; | 506 | return; |
| @@ -491,7 +509,9 @@ static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c) | |||
| 491 | 509 | ||
| 492 | if (!printed) { | 510 | if (!printed) { |
| 493 | printed++; | 511 | printed++; |
| 494 | printk(KERN_ERR "CPU: vendor_id '%s' unknown, using generic init.\n", v); | 512 | printk(KERN_ERR |
| 513 | "CPU: vendor_id '%s' unknown, using generic init.\n", v); | ||
| 514 | |||
| 495 | printk(KERN_ERR "CPU: Your system may be unstable.\n"); | 515 | printk(KERN_ERR "CPU: Your system may be unstable.\n"); |
| 496 | } | 516 | } |
| 497 | 517 | ||
| @@ -511,14 +531,17 @@ void __cpuinit cpu_detect(struct cpuinfo_x86 *c) | |||
| 511 | /* Intel-defined flags: level 0x00000001 */ | 531 | /* Intel-defined flags: level 0x00000001 */ |
| 512 | if (c->cpuid_level >= 0x00000001) { | 532 | if (c->cpuid_level >= 0x00000001) { |
| 513 | u32 junk, tfms, cap0, misc; | 533 | u32 junk, tfms, cap0, misc; |
| 534 | |||
| 514 | cpuid(0x00000001, &tfms, &misc, &junk, &cap0); | 535 | cpuid(0x00000001, &tfms, &misc, &junk, &cap0); |
| 515 | c->x86 = (tfms >> 8) & 0xf; | 536 | c->x86 = (tfms >> 8) & 0xf; |
| 516 | c->x86_model = (tfms >> 4) & 0xf; | 537 | c->x86_model = (tfms >> 4) & 0xf; |
| 517 | c->x86_mask = tfms & 0xf; | 538 | c->x86_mask = tfms & 0xf; |
| 539 | |||
| 518 | if (c->x86 == 0xf) | 540 | if (c->x86 == 0xf) |
| 519 | c->x86 += (tfms >> 20) & 0xff; | 541 | c->x86 += (tfms >> 20) & 0xff; |
| 520 | if (c->x86 >= 0x6) | 542 | if (c->x86 >= 0x6) |
| 521 | c->x86_model += ((tfms >> 16) & 0xf) << 4; | 543 | c->x86_model += ((tfms >> 16) & 0xf) << 4; |
| 544 | |||
| 522 | if (cap0 & (1<<19)) { | 545 | if (cap0 & (1<<19)) { |
| 523 | c->x86_clflush_size = ((misc >> 8) & 0xff) * 8; | 546 | c->x86_clflush_size = ((misc >> 8) & 0xff) * 8; |
| 524 | c->x86_cache_alignment = c->x86_clflush_size; | 547 | c->x86_cache_alignment = c->x86_clflush_size; |
| @@ -534,6 +557,7 @@ static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c) | |||
| 534 | /* Intel-defined flags: level 0x00000001 */ | 557 | /* Intel-defined flags: level 0x00000001 */ |
| 535 | if (c->cpuid_level >= 0x00000001) { | 558 | if (c->cpuid_level >= 0x00000001) { |
| 536 | u32 capability, excap; | 559 | u32 capability, excap; |
| 560 | |||
| 537 | cpuid(0x00000001, &tfms, &ebx, &excap, &capability); | 561 | cpuid(0x00000001, &tfms, &ebx, &excap, &capability); |
| 538 | c->x86_capability[0] = capability; | 562 | c->x86_capability[0] = capability; |
| 539 | c->x86_capability[4] = excap; | 563 | c->x86_capability[4] = excap; |
| @@ -542,6 +566,7 @@ static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c) | |||
| 542 | /* AMD-defined flags: level 0x80000001 */ | 566 | /* AMD-defined flags: level 0x80000001 */ |
| 543 | xlvl = cpuid_eax(0x80000000); | 567 | xlvl = cpuid_eax(0x80000000); |
| 544 | c->extended_cpuid_level = xlvl; | 568 | c->extended_cpuid_level = xlvl; |
| 569 | |||
| 545 | if ((xlvl & 0xffff0000) == 0x80000000) { | 570 | if ((xlvl & 0xffff0000) == 0x80000000) { |
| 546 | if (xlvl >= 0x80000001) { | 571 | if (xlvl >= 0x80000001) { |
| 547 | c->x86_capability[1] = cpuid_edx(0x80000001); | 572 | c->x86_capability[1] = cpuid_edx(0x80000001); |
| @@ -549,13 +574,15 @@ static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c) | |||
| 549 | } | 574 | } |
| 550 | } | 575 | } |
| 551 | 576 | ||
| 552 | #ifdef CONFIG_X86_64 | ||
| 553 | if (c->extended_cpuid_level >= 0x80000008) { | 577 | if (c->extended_cpuid_level >= 0x80000008) { |
| 554 | u32 eax = cpuid_eax(0x80000008); | 578 | u32 eax = cpuid_eax(0x80000008); |
| 555 | 579 | ||
| 556 | c->x86_virt_bits = (eax >> 8) & 0xff; | 580 | c->x86_virt_bits = (eax >> 8) & 0xff; |
| 557 | c->x86_phys_bits = eax & 0xff; | 581 | c->x86_phys_bits = eax & 0xff; |
| 558 | } | 582 | } |
| 583 | #ifdef CONFIG_X86_32 | ||
| 584 | else if (cpu_has(c, X86_FEATURE_PAE) || cpu_has(c, X86_FEATURE_PSE36)) | ||
| 585 | c->x86_phys_bits = 36; | ||
| 559 | #endif | 586 | #endif |
| 560 | 587 | ||
| 561 | if (c->extended_cpuid_level >= 0x80000007) | 588 | if (c->extended_cpuid_level >= 0x80000007) |
| @@ -602,8 +629,12 @@ static void __init early_identify_cpu(struct cpuinfo_x86 *c) | |||
| 602 | { | 629 | { |
| 603 | #ifdef CONFIG_X86_64 | 630 | #ifdef CONFIG_X86_64 |
| 604 | c->x86_clflush_size = 64; | 631 | c->x86_clflush_size = 64; |
| 632 | c->x86_phys_bits = 36; | ||
| 633 | c->x86_virt_bits = 48; | ||
| 605 | #else | 634 | #else |
| 606 | c->x86_clflush_size = 32; | 635 | c->x86_clflush_size = 32; |
| 636 | c->x86_phys_bits = 32; | ||
| 637 | c->x86_virt_bits = 32; | ||
| 607 | #endif | 638 | #endif |
| 608 | c->x86_cache_alignment = c->x86_clflush_size; | 639 | c->x86_cache_alignment = c->x86_clflush_size; |
| 609 | 640 | ||
| @@ -634,12 +665,12 @@ static void __init early_identify_cpu(struct cpuinfo_x86 *c) | |||
| 634 | 665 | ||
| 635 | void __init early_cpu_init(void) | 666 | void __init early_cpu_init(void) |
| 636 | { | 667 | { |
| 637 | struct cpu_dev **cdev; | 668 | const struct cpu_dev *const *cdev; |
| 638 | int count = 0; | 669 | int count = 0; |
| 639 | 670 | ||
| 640 | printk("KERNEL supported cpus:\n"); | 671 | printk(KERN_INFO "KERNEL supported cpus:\n"); |
| 641 | for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) { | 672 | for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) { |
| 642 | struct cpu_dev *cpudev = *cdev; | 673 | const struct cpu_dev *cpudev = *cdev; |
| 643 | unsigned int j; | 674 | unsigned int j; |
| 644 | 675 | ||
| 645 | if (count >= X86_VENDOR_NUM) | 676 | if (count >= X86_VENDOR_NUM) |
| @@ -650,7 +681,7 @@ void __init early_cpu_init(void) | |||
| 650 | for (j = 0; j < 2; j++) { | 681 | for (j = 0; j < 2; j++) { |
| 651 | if (!cpudev->c_ident[j]) | 682 | if (!cpudev->c_ident[j]) |
| 652 | continue; | 683 | continue; |
| 653 | printk(" %s %s\n", cpudev->c_vendor, | 684 | printk(KERN_INFO " %s %s\n", cpudev->c_vendor, |
| 654 | cpudev->c_ident[j]); | 685 | cpudev->c_ident[j]); |
| 655 | } | 686 | } |
| 656 | } | 687 | } |
| @@ -726,9 +757,13 @@ static void __cpuinit identify_cpu(struct cpuinfo_x86 *c) | |||
| 726 | c->x86_coreid_bits = 0; | 757 | c->x86_coreid_bits = 0; |
| 727 | #ifdef CONFIG_X86_64 | 758 | #ifdef CONFIG_X86_64 |
| 728 | c->x86_clflush_size = 64; | 759 | c->x86_clflush_size = 64; |
| 760 | c->x86_phys_bits = 36; | ||
| 761 | c->x86_virt_bits = 48; | ||
| 729 | #else | 762 | #else |
| 730 | c->cpuid_level = -1; /* CPUID not detected */ | 763 | c->cpuid_level = -1; /* CPUID not detected */ |
| 731 | c->x86_clflush_size = 32; | 764 | c->x86_clflush_size = 32; |
| 765 | c->x86_phys_bits = 32; | ||
| 766 | c->x86_virt_bits = 32; | ||
| 732 | #endif | 767 | #endif |
| 733 | c->x86_cache_alignment = c->x86_clflush_size; | 768 | c->x86_cache_alignment = c->x86_clflush_size; |
| 734 | memset(&c->x86_capability, 0, sizeof c->x86_capability); | 769 | memset(&c->x86_capability, 0, sizeof c->x86_capability); |
| @@ -759,8 +794,8 @@ static void __cpuinit identify_cpu(struct cpuinfo_x86 *c) | |||
| 759 | squash_the_stupid_serial_number(c); | 794 | squash_the_stupid_serial_number(c); |
| 760 | 795 | ||
| 761 | /* | 796 | /* |
| 762 | * The vendor-specific functions might have changed features. Now | 797 | * The vendor-specific functions might have changed features. |
| 763 | * we do "generic changes." | 798 | * Now we do "generic changes." |
| 764 | */ | 799 | */ |
| 765 | 800 | ||
| 766 | /* Filter out anything that depends on CPUID levels we don't have */ | 801 | /* Filter out anything that depends on CPUID levels we don't have */ |
| @@ -768,7 +803,7 @@ static void __cpuinit identify_cpu(struct cpuinfo_x86 *c) | |||
| 768 | 803 | ||
| 769 | /* If the model name is still unset, do table lookup. */ | 804 | /* If the model name is still unset, do table lookup. */ |
| 770 | if (!c->x86_model_id[0]) { | 805 | if (!c->x86_model_id[0]) { |
| 771 | char *p; | 806 | const char *p; |
| 772 | p = table_lookup_model(c); | 807 | p = table_lookup_model(c); |
| 773 | if (p) | 808 | if (p) |
| 774 | strcpy(c->x86_model_id, p); | 809 | strcpy(c->x86_model_id, p); |
| @@ -843,11 +878,11 @@ void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c) | |||
| 843 | } | 878 | } |
| 844 | 879 | ||
| 845 | struct msr_range { | 880 | struct msr_range { |
| 846 | unsigned min; | 881 | unsigned min; |
| 847 | unsigned max; | 882 | unsigned max; |
| 848 | }; | 883 | }; |
| 849 | 884 | ||
| 850 | static struct msr_range msr_range_array[] __cpuinitdata = { | 885 | static const struct msr_range msr_range_array[] __cpuinitconst = { |
| 851 | { 0x00000000, 0x00000418}, | 886 | { 0x00000000, 0x00000418}, |
| 852 | { 0xc0000000, 0xc000040b}, | 887 | { 0xc0000000, 0xc000040b}, |
| 853 | { 0xc0010000, 0xc0010142}, | 888 | { 0xc0010000, 0xc0010142}, |
| @@ -856,14 +891,15 @@ static struct msr_range msr_range_array[] __cpuinitdata = { | |||
| 856 | 891 | ||
| 857 | static void __cpuinit print_cpu_msr(void) | 892 | static void __cpuinit print_cpu_msr(void) |
| 858 | { | 893 | { |
| 894 | unsigned index_min, index_max; | ||
| 859 | unsigned index; | 895 | unsigned index; |
| 860 | u64 val; | 896 | u64 val; |
| 861 | int i; | 897 | int i; |
| 862 | unsigned index_min, index_max; | ||
| 863 | 898 | ||
| 864 | for (i = 0; i < ARRAY_SIZE(msr_range_array); i++) { | 899 | for (i = 0; i < ARRAY_SIZE(msr_range_array); i++) { |
| 865 | index_min = msr_range_array[i].min; | 900 | index_min = msr_range_array[i].min; |
| 866 | index_max = msr_range_array[i].max; | 901 | index_max = msr_range_array[i].max; |
| 902 | |||
| 867 | for (index = index_min; index < index_max; index++) { | 903 | for (index = index_min; index < index_max; index++) { |
| 868 | if (rdmsrl_amd_safe(index, &val)) | 904 | if (rdmsrl_amd_safe(index, &val)) |
| 869 | continue; | 905 | continue; |
| @@ -873,6 +909,7 @@ static void __cpuinit print_cpu_msr(void) | |||
| 873 | } | 909 | } |
| 874 | 910 | ||
| 875 | static int show_msr __cpuinitdata; | 911 | static int show_msr __cpuinitdata; |
| 912 | |||
| 876 | static __init int setup_show_msr(char *arg) | 913 | static __init int setup_show_msr(char *arg) |
| 877 | { | 914 | { |
| 878 | int num; | 915 | int num; |
| @@ -894,12 +931,14 @@ __setup("noclflush", setup_noclflush); | |||
| 894 | 931 | ||
| 895 | void __cpuinit print_cpu_info(struct cpuinfo_x86 *c) | 932 | void __cpuinit print_cpu_info(struct cpuinfo_x86 *c) |
| 896 | { | 933 | { |
| 897 | char *vendor = NULL; | 934 | const char *vendor = NULL; |
| 898 | 935 | ||
| 899 | if (c->x86_vendor < X86_VENDOR_NUM) | 936 | if (c->x86_vendor < X86_VENDOR_NUM) { |
| 900 | vendor = this_cpu->c_vendor; | 937 | vendor = this_cpu->c_vendor; |
| 901 | else if (c->cpuid_level >= 0) | 938 | } else { |
| 902 | vendor = c->x86_vendor_id; | 939 | if (c->cpuid_level >= 0) |
| 940 | vendor = c->x86_vendor_id; | ||
| 941 | } | ||
| 903 | 942 | ||
| 904 | if (vendor && !strstr(c->x86_model_id, vendor)) | 943 | if (vendor && !strstr(c->x86_model_id, vendor)) |
| 905 | printk(KERN_CONT "%s ", vendor); | 944 | printk(KERN_CONT "%s ", vendor); |
| @@ -926,10 +965,12 @@ void __cpuinit print_cpu_info(struct cpuinfo_x86 *c) | |||
| 926 | static __init int setup_disablecpuid(char *arg) | 965 | static __init int setup_disablecpuid(char *arg) |
| 927 | { | 966 | { |
| 928 | int bit; | 967 | int bit; |
| 968 | |||
| 929 | if (get_option(&arg, &bit) && bit < NCAPINTS*32) | 969 | if (get_option(&arg, &bit) && bit < NCAPINTS*32) |
| 930 | setup_clear_cpu_cap(bit); | 970 | setup_clear_cpu_cap(bit); |
| 931 | else | 971 | else |
| 932 | return 0; | 972 | return 0; |
| 973 | |||
| 933 | return 1; | 974 | return 1; |
| 934 | } | 975 | } |
| 935 | __setup("clearcpuid=", setup_disablecpuid); | 976 | __setup("clearcpuid=", setup_disablecpuid); |
| @@ -939,6 +980,7 @@ struct desc_ptr idt_descr = { 256 * 16 - 1, (unsigned long) idt_table }; | |||
| 939 | 980 | ||
| 940 | DEFINE_PER_CPU_FIRST(union irq_stack_union, | 981 | DEFINE_PER_CPU_FIRST(union irq_stack_union, |
| 941 | irq_stack_union) __aligned(PAGE_SIZE); | 982 | irq_stack_union) __aligned(PAGE_SIZE); |
| 983 | |||
| 942 | DEFINE_PER_CPU(char *, irq_stack_ptr) = | 984 | DEFINE_PER_CPU(char *, irq_stack_ptr) = |
| 943 | init_per_cpu_var(irq_stack_union.irq_stack) + IRQ_STACK_SIZE - 64; | 985 | init_per_cpu_var(irq_stack_union.irq_stack) + IRQ_STACK_SIZE - 64; |
| 944 | 986 | ||
| @@ -948,12 +990,21 @@ EXPORT_PER_CPU_SYMBOL(kernel_stack); | |||
| 948 | 990 | ||
| 949 | DEFINE_PER_CPU(unsigned int, irq_count) = -1; | 991 | DEFINE_PER_CPU(unsigned int, irq_count) = -1; |
| 950 | 992 | ||
| 993 | /* | ||
| 994 | * Special IST stacks which the CPU switches to when it calls | ||
| 995 | * an IST-marked descriptor entry. Up to 7 stacks (hardware | ||
| 996 | * limit), all of them are 4K, except the debug stack which | ||
| 997 | * is 8K. | ||
| 998 | */ | ||
| 999 | static const unsigned int exception_stack_sizes[N_EXCEPTION_STACKS] = { | ||
| 1000 | [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ, | ||
| 1001 | [DEBUG_STACK - 1] = DEBUG_STKSZ | ||
| 1002 | }; | ||
| 1003 | |||
| 951 | static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks | 1004 | static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks |
| 952 | [(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]) | 1005 | [(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]) |
| 953 | __aligned(PAGE_SIZE); | 1006 | __aligned(PAGE_SIZE); |
| 954 | 1007 | ||
| 955 | extern asmlinkage void ignore_sysret(void); | ||
| 956 | |||
| 957 | /* May not be marked __init: used by software suspend */ | 1008 | /* May not be marked __init: used by software suspend */ |
| 958 | void syscall_init(void) | 1009 | void syscall_init(void) |
| 959 | { | 1010 | { |
| @@ -983,7 +1034,7 @@ unsigned long kernel_eflags; | |||
| 983 | */ | 1034 | */ |
| 984 | DEFINE_PER_CPU(struct orig_ist, orig_ist); | 1035 | DEFINE_PER_CPU(struct orig_ist, orig_ist); |
| 985 | 1036 | ||
| 986 | #else /* x86_64 */ | 1037 | #else /* CONFIG_X86_64 */ |
| 987 | 1038 | ||
| 988 | #ifdef CONFIG_CC_STACKPROTECTOR | 1039 | #ifdef CONFIG_CC_STACKPROTECTOR |
| 989 | DEFINE_PER_CPU(unsigned long, stack_canary); | 1040 | DEFINE_PER_CPU(unsigned long, stack_canary); |
| @@ -995,9 +1046,26 @@ struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs) | |||
| 995 | memset(regs, 0, sizeof(struct pt_regs)); | 1046 | memset(regs, 0, sizeof(struct pt_regs)); |
| 996 | regs->fs = __KERNEL_PERCPU; | 1047 | regs->fs = __KERNEL_PERCPU; |
| 997 | regs->gs = __KERNEL_STACK_CANARY; | 1048 | regs->gs = __KERNEL_STACK_CANARY; |
| 1049 | |||
| 998 | return regs; | 1050 | return regs; |
| 999 | } | 1051 | } |
| 1000 | #endif /* x86_64 */ | 1052 | #endif /* CONFIG_X86_64 */ |
| 1053 | |||
| 1054 | /* | ||
| 1055 | * Clear all 6 debug registers: | ||
| 1056 | */ | ||
| 1057 | static void clear_all_debug_regs(void) | ||
| 1058 | { | ||
| 1059 | int i; | ||
| 1060 | |||
| 1061 | for (i = 0; i < 8; i++) { | ||
| 1062 | /* Ignore db4, db5 */ | ||
| 1063 | if ((i == 4) || (i == 5)) | ||
| 1064 | continue; | ||
| 1065 | |||
| 1066 | set_debugreg(0, i); | ||
| 1067 | } | ||
| 1068 | } | ||
| 1001 | 1069 | ||
| 1002 | /* | 1070 | /* |
| 1003 | * cpu_init() initializes state that is per-CPU. Some data is already | 1071 | * cpu_init() initializes state that is per-CPU. Some data is already |
| @@ -1007,15 +1075,20 @@ struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs) | |||
| 1007 | * A lot of state is already set up in PDA init for 64 bit | 1075 | * A lot of state is already set up in PDA init for 64 bit |
| 1008 | */ | 1076 | */ |
| 1009 | #ifdef CONFIG_X86_64 | 1077 | #ifdef CONFIG_X86_64 |
| 1078 | |||
| 1010 | void __cpuinit cpu_init(void) | 1079 | void __cpuinit cpu_init(void) |
| 1011 | { | 1080 | { |
| 1012 | int cpu = stack_smp_processor_id(); | 1081 | struct orig_ist *orig_ist; |
| 1013 | struct tss_struct *t = &per_cpu(init_tss, cpu); | ||
| 1014 | struct orig_ist *orig_ist = &per_cpu(orig_ist, cpu); | ||
| 1015 | unsigned long v; | ||
| 1016 | struct task_struct *me; | 1082 | struct task_struct *me; |
| 1083 | struct tss_struct *t; | ||
| 1084 | unsigned long v; | ||
| 1085 | int cpu; | ||
| 1017 | int i; | 1086 | int i; |
| 1018 | 1087 | ||
| 1088 | cpu = stack_smp_processor_id(); | ||
| 1089 | t = &per_cpu(init_tss, cpu); | ||
| 1090 | orig_ist = &per_cpu(orig_ist, cpu); | ||
| 1091 | |||
| 1019 | #ifdef CONFIG_NUMA | 1092 | #ifdef CONFIG_NUMA |
| 1020 | if (cpu != 0 && percpu_read(node_number) == 0 && | 1093 | if (cpu != 0 && percpu_read(node_number) == 0 && |
| 1021 | cpu_to_node(cpu) != NUMA_NO_NODE) | 1094 | cpu_to_node(cpu) != NUMA_NO_NODE) |
| @@ -1056,19 +1129,17 @@ void __cpuinit cpu_init(void) | |||
| 1056 | * set up and load the per-CPU TSS | 1129 | * set up and load the per-CPU TSS |
| 1057 | */ | 1130 | */ |
| 1058 | if (!orig_ist->ist[0]) { | 1131 | if (!orig_ist->ist[0]) { |
| 1059 | static const unsigned int sizes[N_EXCEPTION_STACKS] = { | ||
| 1060 | [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ, | ||
| 1061 | [DEBUG_STACK - 1] = DEBUG_STKSZ | ||
| 1062 | }; | ||
| 1063 | char *estacks = per_cpu(exception_stacks, cpu); | 1132 | char *estacks = per_cpu(exception_stacks, cpu); |
| 1133 | |||
| 1064 | for (v = 0; v < N_EXCEPTION_STACKS; v++) { | 1134 | for (v = 0; v < N_EXCEPTION_STACKS; v++) { |
| 1065 | estacks += sizes[v]; | 1135 | estacks += exception_stack_sizes[v]; |
| 1066 | orig_ist->ist[v] = t->x86_tss.ist[v] = | 1136 | orig_ist->ist[v] = t->x86_tss.ist[v] = |
| 1067 | (unsigned long)estacks; | 1137 | (unsigned long)estacks; |
| 1068 | } | 1138 | } |
| 1069 | } | 1139 | } |
| 1070 | 1140 | ||
| 1071 | t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap); | 1141 | t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap); |
| 1142 | |||
| 1072 | /* | 1143 | /* |
| 1073 | * <= is required because the CPU will access up to | 1144 | * <= is required because the CPU will access up to |
| 1074 | * 8 bits beyond the end of the IO permission bitmap. | 1145 | * 8 bits beyond the end of the IO permission bitmap. |
| @@ -1078,8 +1149,7 @@ void __cpuinit cpu_init(void) | |||
| 1078 | 1149 | ||
| 1079 | atomic_inc(&init_mm.mm_count); | 1150 | atomic_inc(&init_mm.mm_count); |
| 1080 | me->active_mm = &init_mm; | 1151 | me->active_mm = &init_mm; |
| 1081 | if (me->mm) | 1152 | BUG_ON(me->mm); |
| 1082 | BUG(); | ||
| 1083 | enter_lazy_tlb(&init_mm, me); | 1153 | enter_lazy_tlb(&init_mm, me); |
| 1084 | 1154 | ||
| 1085 | load_sp0(t, ¤t->thread); | 1155 | load_sp0(t, ¤t->thread); |
| @@ -1098,17 +1168,7 @@ void __cpuinit cpu_init(void) | |||
| 1098 | arch_kgdb_ops.correct_hw_break(); | 1168 | arch_kgdb_ops.correct_hw_break(); |
| 1099 | else | 1169 | else |
| 1100 | #endif | 1170 | #endif |
| 1101 | { | 1171 | clear_all_debug_regs(); |
| 1102 | /* | ||
| 1103 | * Clear all 6 debug registers: | ||
| 1104 | */ | ||
| 1105 | set_debugreg(0UL, 0); | ||
| 1106 | set_debugreg(0UL, 1); | ||
| 1107 | set_debugreg(0UL, 2); | ||
| 1108 | set_debugreg(0UL, 3); | ||
| 1109 | set_debugreg(0UL, 6); | ||
| 1110 | set_debugreg(0UL, 7); | ||
| 1111 | } | ||
| 1112 | 1172 | ||
| 1113 | fpu_init(); | 1173 | fpu_init(); |
| 1114 | 1174 | ||
| @@ -1129,7 +1189,8 @@ void __cpuinit cpu_init(void) | |||
| 1129 | 1189 | ||
| 1130 | if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) { | 1190 | if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) { |
| 1131 | printk(KERN_WARNING "CPU#%d already initialized!\n", cpu); | 1191 | printk(KERN_WARNING "CPU#%d already initialized!\n", cpu); |
| 1132 | for (;;) local_irq_enable(); | 1192 | for (;;) |
| 1193 | local_irq_enable(); | ||
| 1133 | } | 1194 | } |
| 1134 | 1195 | ||
| 1135 | printk(KERN_INFO "Initializing CPU#%d\n", cpu); | 1196 | printk(KERN_INFO "Initializing CPU#%d\n", cpu); |
| @@ -1145,8 +1206,7 @@ void __cpuinit cpu_init(void) | |||
| 1145 | */ | 1206 | */ |
| 1146 | atomic_inc(&init_mm.mm_count); | 1207 | atomic_inc(&init_mm.mm_count); |
| 1147 | curr->active_mm = &init_mm; | 1208 | curr->active_mm = &init_mm; |
| 1148 | if (curr->mm) | 1209 | BUG_ON(curr->mm); |
| 1149 | BUG(); | ||
| 1150 | enter_lazy_tlb(&init_mm, curr); | 1210 | enter_lazy_tlb(&init_mm, curr); |
| 1151 | 1211 | ||
| 1152 | load_sp0(t, thread); | 1212 | load_sp0(t, thread); |
| @@ -1159,13 +1219,7 @@ void __cpuinit cpu_init(void) | |||
| 1159 | __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss); | 1219 | __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss); |
| 1160 | #endif | 1220 | #endif |
| 1161 | 1221 | ||
| 1162 | /* Clear all 6 debug registers: */ | 1222 | clear_all_debug_regs(); |
| 1163 | set_debugreg(0, 0); | ||
| 1164 | set_debugreg(0, 1); | ||
| 1165 | set_debugreg(0, 2); | ||
| 1166 | set_debugreg(0, 3); | ||
| 1167 | set_debugreg(0, 6); | ||
| 1168 | set_debugreg(0, 7); | ||
| 1169 | 1223 | ||
| 1170 | /* | 1224 | /* |
| 1171 | * Force FPU initialization: | 1225 | * Force FPU initialization: |
| @@ -1185,6 +1239,4 @@ void __cpuinit cpu_init(void) | |||
| 1185 | 1239 | ||
| 1186 | xsave_init(); | 1240 | xsave_init(); |
| 1187 | } | 1241 | } |
| 1188 | |||
| 1189 | |||
| 1190 | #endif | 1242 | #endif |
diff --git a/arch/x86/kernel/cpu/cpu.h b/arch/x86/kernel/cpu/cpu.h index de4094a39210..6de9a908e400 100644 --- a/arch/x86/kernel/cpu/cpu.h +++ b/arch/x86/kernel/cpu/cpu.h | |||
| @@ -3,33 +3,34 @@ | |||
| 3 | #define ARCH_X86_CPU_H | 3 | #define ARCH_X86_CPU_H |
| 4 | 4 | ||
| 5 | struct cpu_model_info { | 5 | struct cpu_model_info { |
| 6 | int vendor; | 6 | int vendor; |
| 7 | int family; | 7 | int family; |
| 8 | char *model_names[16]; | 8 | const char *model_names[16]; |
| 9 | }; | 9 | }; |
| 10 | 10 | ||
| 11 | /* attempt to consolidate cpu attributes */ | 11 | /* attempt to consolidate cpu attributes */ |
| 12 | struct cpu_dev { | 12 | struct cpu_dev { |
| 13 | char * c_vendor; | 13 | const char *c_vendor; |
| 14 | 14 | ||
| 15 | /* some have two possibilities for cpuid string */ | 15 | /* some have two possibilities for cpuid string */ |
| 16 | char * c_ident[2]; | 16 | const char *c_ident[2]; |
| 17 | 17 | ||
| 18 | struct cpu_model_info c_models[4]; | 18 | struct cpu_model_info c_models[4]; |
| 19 | 19 | ||
| 20 | void (*c_early_init)(struct cpuinfo_x86 *c); | 20 | void (*c_early_init)(struct cpuinfo_x86 *); |
| 21 | void (*c_init)(struct cpuinfo_x86 * c); | 21 | void (*c_init)(struct cpuinfo_x86 *); |
| 22 | void (*c_identify)(struct cpuinfo_x86 * c); | 22 | void (*c_identify)(struct cpuinfo_x86 *); |
| 23 | unsigned int (*c_size_cache)(struct cpuinfo_x86 * c, unsigned int size); | 23 | unsigned int (*c_size_cache)(struct cpuinfo_x86 *, unsigned int); |
| 24 | int c_x86_vendor; | 24 | int c_x86_vendor; |
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | #define cpu_dev_register(cpu_devX) \ | 27 | #define cpu_dev_register(cpu_devX) \ |
| 28 | static struct cpu_dev *__cpu_dev_##cpu_devX __used \ | 28 | static const struct cpu_dev *const __cpu_dev_##cpu_devX __used \ |
| 29 | __attribute__((__section__(".x86_cpu_dev.init"))) = \ | 29 | __attribute__((__section__(".x86_cpu_dev.init"))) = \ |
| 30 | &cpu_devX; | 30 | &cpu_devX; |
| 31 | 31 | ||
| 32 | extern struct cpu_dev *__x86_cpu_dev_start[], *__x86_cpu_dev_end[]; | 32 | extern const struct cpu_dev *const __x86_cpu_dev_start[], |
| 33 | *const __x86_cpu_dev_end[]; | ||
| 33 | 34 | ||
| 34 | extern void display_cacheinfo(struct cpuinfo_x86 *c); | 35 | extern void display_cacheinfo(struct cpuinfo_x86 *c); |
| 35 | 36 | ||
diff --git a/arch/x86/kernel/cpu/cpu_debug.c b/arch/x86/kernel/cpu/cpu_debug.c new file mode 100755 index 000000000000..46e29ab96c6a --- /dev/null +++ b/arch/x86/kernel/cpu/cpu_debug.c | |||
| @@ -0,0 +1,901 @@ | |||
| 1 | /* | ||
| 2 | * CPU x86 architecture debug code | ||
| 3 | * | ||
| 4 | * Copyright(C) 2009 Jaswinder Singh Rajput | ||
| 5 | * | ||
| 6 | * For licencing details see kernel-base/COPYING | ||
| 7 | */ | ||
| 8 | |||
| 9 | #include <linux/interrupt.h> | ||
| 10 | #include <linux/compiler.h> | ||
| 11 | #include <linux/seq_file.h> | ||
| 12 | #include <linux/debugfs.h> | ||
| 13 | #include <linux/kprobes.h> | ||
| 14 | #include <linux/uaccess.h> | ||
| 15 | #include <linux/kernel.h> | ||
| 16 | #include <linux/module.h> | ||
| 17 | #include <linux/percpu.h> | ||
| 18 | #include <linux/signal.h> | ||
| 19 | #include <linux/errno.h> | ||
| 20 | #include <linux/sched.h> | ||
| 21 | #include <linux/types.h> | ||
| 22 | #include <linux/init.h> | ||
| 23 | #include <linux/slab.h> | ||
| 24 | #include <linux/smp.h> | ||
| 25 | |||
| 26 | #include <asm/cpu_debug.h> | ||
| 27 | #include <asm/paravirt.h> | ||
| 28 | #include <asm/system.h> | ||
| 29 | #include <asm/traps.h> | ||
| 30 | #include <asm/apic.h> | ||
| 31 | #include <asm/desc.h> | ||
| 32 | |||
| 33 | static DEFINE_PER_CPU(struct cpu_cpuX_base, cpu_arr[CPU_REG_ALL_BIT]); | ||
| 34 | static DEFINE_PER_CPU(struct cpu_private *, priv_arr[MAX_CPU_FILES]); | ||
| 35 | static DEFINE_PER_CPU(unsigned, cpu_modelflag); | ||
| 36 | static DEFINE_PER_CPU(int, cpu_priv_count); | ||
| 37 | static DEFINE_PER_CPU(unsigned, cpu_model); | ||
| 38 | |||
| 39 | static DEFINE_MUTEX(cpu_debug_lock); | ||
| 40 | |||
| 41 | static struct dentry *cpu_debugfs_dir; | ||
| 42 | |||
| 43 | static struct cpu_debug_base cpu_base[] = { | ||
| 44 | { "mc", CPU_MC, 0 }, | ||
| 45 | { "monitor", CPU_MONITOR, 0 }, | ||
| 46 | { "time", CPU_TIME, 0 }, | ||
| 47 | { "pmc", CPU_PMC, 1 }, | ||
| 48 | { "platform", CPU_PLATFORM, 0 }, | ||
| 49 | { "apic", CPU_APIC, 0 }, | ||
| 50 | { "poweron", CPU_POWERON, 0 }, | ||
| 51 | { "control", CPU_CONTROL, 0 }, | ||
| 52 | { "features", CPU_FEATURES, 0 }, | ||
| 53 | { "lastbranch", CPU_LBRANCH, 0 }, | ||
| 54 | { "bios", CPU_BIOS, 0 }, | ||
| 55 | { "freq", CPU_FREQ, 0 }, | ||
| 56 | { "mtrr", CPU_MTRR, 0 }, | ||
| 57 | { "perf", CPU_PERF, 0 }, | ||
| 58 | { "cache", CPU_CACHE, 0 }, | ||
| 59 | { "sysenter", CPU_SYSENTER, 0 }, | ||
| 60 | { "therm", CPU_THERM, 0 }, | ||
| 61 | { "misc", CPU_MISC, 0 }, | ||
| 62 | { "debug", CPU_DEBUG, 0 }, | ||
| 63 | { "pat", CPU_PAT, 0 }, | ||
| 64 | { "vmx", CPU_VMX, 0 }, | ||
| 65 | { "call", CPU_CALL, 0 }, | ||
| 66 | { "base", CPU_BASE, 0 }, | ||
| 67 | { "ver", CPU_VER, 0 }, | ||
| 68 | { "conf", CPU_CONF, 0 }, | ||
| 69 | { "smm", CPU_SMM, 0 }, | ||
| 70 | { "svm", CPU_SVM, 0 }, | ||
| 71 | { "osvm", CPU_OSVM, 0 }, | ||
| 72 | { "tss", CPU_TSS, 0 }, | ||
| 73 | { "cr", CPU_CR, 0 }, | ||
| 74 | { "dt", CPU_DT, 0 }, | ||
| 75 | { "registers", CPU_REG_ALL, 0 }, | ||
| 76 | }; | ||
| 77 | |||
| 78 | static struct cpu_file_base cpu_file[] = { | ||
| 79 | { "index", CPU_REG_ALL, 0 }, | ||
| 80 | { "value", CPU_REG_ALL, 1 }, | ||
| 81 | }; | ||
| 82 | |||
| 83 | /* Intel Registers Range */ | ||
| 84 | static struct cpu_debug_range cpu_intel_range[] = { | ||
| 85 | { 0x00000000, 0x00000001, CPU_MC, CPU_INTEL_ALL }, | ||
| 86 | { 0x00000006, 0x00000007, CPU_MONITOR, CPU_CX_AT_XE }, | ||
| 87 | { 0x00000010, 0x00000010, CPU_TIME, CPU_INTEL_ALL }, | ||
| 88 | { 0x00000011, 0x00000013, CPU_PMC, CPU_INTEL_PENTIUM }, | ||
| 89 | { 0x00000017, 0x00000017, CPU_PLATFORM, CPU_PX_CX_AT_XE }, | ||
| 90 | { 0x0000001B, 0x0000001B, CPU_APIC, CPU_P6_CX_AT_XE }, | ||
| 91 | |||
| 92 | { 0x0000002A, 0x0000002A, CPU_POWERON, CPU_PX_CX_AT_XE }, | ||
| 93 | { 0x0000002B, 0x0000002B, CPU_POWERON, CPU_INTEL_XEON }, | ||
| 94 | { 0x0000002C, 0x0000002C, CPU_FREQ, CPU_INTEL_XEON }, | ||
| 95 | { 0x0000003A, 0x0000003A, CPU_CONTROL, CPU_CX_AT_XE }, | ||
| 96 | |||
| 97 | { 0x00000040, 0x00000043, CPU_LBRANCH, CPU_PM_CX_AT_XE }, | ||
| 98 | { 0x00000044, 0x00000047, CPU_LBRANCH, CPU_PM_CO_AT }, | ||
| 99 | { 0x00000060, 0x00000063, CPU_LBRANCH, CPU_C2_AT }, | ||
| 100 | { 0x00000064, 0x00000067, CPU_LBRANCH, CPU_INTEL_ATOM }, | ||
| 101 | |||
| 102 | { 0x00000079, 0x00000079, CPU_BIOS, CPU_P6_CX_AT_XE }, | ||
| 103 | { 0x00000088, 0x0000008A, CPU_CACHE, CPU_INTEL_P6 }, | ||
| 104 | { 0x0000008B, 0x0000008B, CPU_BIOS, CPU_P6_CX_AT_XE }, | ||
| 105 | { 0x0000009B, 0x0000009B, CPU_MONITOR, CPU_INTEL_XEON }, | ||
| 106 | |||
| 107 | { 0x000000C1, 0x000000C2, CPU_PMC, CPU_P6_CX_AT }, | ||
| 108 | { 0x000000CD, 0x000000CD, CPU_FREQ, CPU_CX_AT }, | ||
| 109 | { 0x000000E7, 0x000000E8, CPU_PERF, CPU_CX_AT }, | ||
| 110 | { 0x000000FE, 0x000000FE, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 111 | |||
| 112 | { 0x00000116, 0x00000116, CPU_CACHE, CPU_INTEL_P6 }, | ||
| 113 | { 0x00000118, 0x00000118, CPU_CACHE, CPU_INTEL_P6 }, | ||
| 114 | { 0x00000119, 0x00000119, CPU_CACHE, CPU_INTEL_PX }, | ||
| 115 | { 0x0000011A, 0x0000011B, CPU_CACHE, CPU_INTEL_P6 }, | ||
| 116 | { 0x0000011E, 0x0000011E, CPU_CACHE, CPU_PX_CX_AT }, | ||
| 117 | |||
| 118 | { 0x00000174, 0x00000176, CPU_SYSENTER, CPU_P6_CX_AT_XE }, | ||
| 119 | { 0x00000179, 0x0000017A, CPU_MC, CPU_PX_CX_AT_XE }, | ||
| 120 | { 0x0000017B, 0x0000017B, CPU_MC, CPU_P6_XE }, | ||
| 121 | { 0x00000186, 0x00000187, CPU_PMC, CPU_P6_CX_AT }, | ||
| 122 | { 0x00000198, 0x00000199, CPU_PERF, CPU_PM_CX_AT_XE }, | ||
| 123 | { 0x0000019A, 0x0000019A, CPU_TIME, CPU_PM_CX_AT_XE }, | ||
| 124 | { 0x0000019B, 0x0000019D, CPU_THERM, CPU_PM_CX_AT_XE }, | ||
| 125 | { 0x000001A0, 0x000001A0, CPU_MISC, CPU_PM_CX_AT_XE }, | ||
| 126 | |||
| 127 | { 0x000001C9, 0x000001C9, CPU_LBRANCH, CPU_PM_CX_AT }, | ||
| 128 | { 0x000001D7, 0x000001D8, CPU_LBRANCH, CPU_INTEL_XEON }, | ||
| 129 | { 0x000001D9, 0x000001D9, CPU_DEBUG, CPU_CX_AT_XE }, | ||
| 130 | { 0x000001DA, 0x000001DA, CPU_LBRANCH, CPU_INTEL_XEON }, | ||
| 131 | { 0x000001DB, 0x000001DB, CPU_LBRANCH, CPU_P6_XE }, | ||
| 132 | { 0x000001DC, 0x000001DC, CPU_LBRANCH, CPU_INTEL_P6 }, | ||
| 133 | { 0x000001DD, 0x000001DE, CPU_LBRANCH, CPU_PX_CX_AT_XE }, | ||
| 134 | { 0x000001E0, 0x000001E0, CPU_LBRANCH, CPU_INTEL_P6 }, | ||
| 135 | |||
| 136 | { 0x00000200, 0x0000020F, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 137 | { 0x00000250, 0x00000250, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 138 | { 0x00000258, 0x00000259, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 139 | { 0x00000268, 0x0000026F, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 140 | { 0x00000277, 0x00000277, CPU_PAT, CPU_C2_AT_XE }, | ||
| 141 | { 0x000002FF, 0x000002FF, CPU_MTRR, CPU_P6_CX_XE }, | ||
| 142 | |||
| 143 | { 0x00000300, 0x00000308, CPU_PMC, CPU_INTEL_XEON }, | ||
| 144 | { 0x00000309, 0x0000030B, CPU_PMC, CPU_C2_AT_XE }, | ||
| 145 | { 0x0000030C, 0x00000311, CPU_PMC, CPU_INTEL_XEON }, | ||
| 146 | { 0x00000345, 0x00000345, CPU_PMC, CPU_C2_AT }, | ||
| 147 | { 0x00000360, 0x00000371, CPU_PMC, CPU_INTEL_XEON }, | ||
| 148 | { 0x0000038D, 0x00000390, CPU_PMC, CPU_C2_AT }, | ||
| 149 | { 0x000003A0, 0x000003BE, CPU_PMC, CPU_INTEL_XEON }, | ||
| 150 | { 0x000003C0, 0x000003CD, CPU_PMC, CPU_INTEL_XEON }, | ||
| 151 | { 0x000003E0, 0x000003E1, CPU_PMC, CPU_INTEL_XEON }, | ||
| 152 | { 0x000003F0, 0x000003F0, CPU_PMC, CPU_INTEL_XEON }, | ||
| 153 | { 0x000003F1, 0x000003F1, CPU_PMC, CPU_C2_AT_XE }, | ||
| 154 | { 0x000003F2, 0x000003F2, CPU_PMC, CPU_INTEL_XEON }, | ||
| 155 | |||
| 156 | { 0x00000400, 0x00000402, CPU_MC, CPU_PM_CX_AT_XE }, | ||
| 157 | { 0x00000403, 0x00000403, CPU_MC, CPU_INTEL_XEON }, | ||
| 158 | { 0x00000404, 0x00000406, CPU_MC, CPU_PM_CX_AT_XE }, | ||
| 159 | { 0x00000407, 0x00000407, CPU_MC, CPU_INTEL_XEON }, | ||
| 160 | { 0x00000408, 0x0000040A, CPU_MC, CPU_PM_CX_AT_XE }, | ||
| 161 | { 0x0000040B, 0x0000040B, CPU_MC, CPU_INTEL_XEON }, | ||
| 162 | { 0x0000040C, 0x0000040E, CPU_MC, CPU_PM_CX_XE }, | ||
| 163 | { 0x0000040F, 0x0000040F, CPU_MC, CPU_INTEL_XEON }, | ||
| 164 | { 0x00000410, 0x00000412, CPU_MC, CPU_PM_CX_AT_XE }, | ||
| 165 | { 0x00000413, 0x00000417, CPU_MC, CPU_CX_AT_XE }, | ||
| 166 | { 0x00000480, 0x0000048B, CPU_VMX, CPU_CX_AT_XE }, | ||
| 167 | |||
| 168 | { 0x00000600, 0x00000600, CPU_DEBUG, CPU_PM_CX_AT_XE }, | ||
| 169 | { 0x00000680, 0x0000068F, CPU_LBRANCH, CPU_INTEL_XEON }, | ||
| 170 | { 0x000006C0, 0x000006CF, CPU_LBRANCH, CPU_INTEL_XEON }, | ||
| 171 | |||
| 172 | { 0x000107CC, 0x000107D3, CPU_PMC, CPU_INTEL_XEON_MP }, | ||
| 173 | |||
| 174 | { 0xC0000080, 0xC0000080, CPU_FEATURES, CPU_INTEL_XEON }, | ||
| 175 | { 0xC0000081, 0xC0000082, CPU_CALL, CPU_INTEL_XEON }, | ||
| 176 | { 0xC0000084, 0xC0000084, CPU_CALL, CPU_INTEL_XEON }, | ||
| 177 | { 0xC0000100, 0xC0000102, CPU_BASE, CPU_INTEL_XEON }, | ||
| 178 | }; | ||
| 179 | |||
| 180 | /* AMD Registers Range */ | ||
| 181 | static struct cpu_debug_range cpu_amd_range[] = { | ||
| 182 | { 0x00000000, 0x00000001, CPU_MC, CPU_K10_PLUS, }, | ||
| 183 | { 0x00000010, 0x00000010, CPU_TIME, CPU_K8_PLUS, }, | ||
| 184 | { 0x0000001B, 0x0000001B, CPU_APIC, CPU_K8_PLUS, }, | ||
| 185 | { 0x0000002A, 0x0000002A, CPU_POWERON, CPU_K7_PLUS }, | ||
| 186 | { 0x0000008B, 0x0000008B, CPU_VER, CPU_K8_PLUS }, | ||
| 187 | { 0x000000FE, 0x000000FE, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 188 | |||
| 189 | { 0x00000174, 0x00000176, CPU_SYSENTER, CPU_K8_PLUS, }, | ||
| 190 | { 0x00000179, 0x0000017B, CPU_MC, CPU_K8_PLUS, }, | ||
| 191 | { 0x000001D9, 0x000001D9, CPU_DEBUG, CPU_K8_PLUS, }, | ||
| 192 | { 0x000001DB, 0x000001DE, CPU_LBRANCH, CPU_K8_PLUS, }, | ||
| 193 | |||
| 194 | { 0x00000200, 0x0000020F, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 195 | { 0x00000250, 0x00000250, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 196 | { 0x00000258, 0x00000259, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 197 | { 0x00000268, 0x0000026F, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 198 | { 0x00000277, 0x00000277, CPU_PAT, CPU_K8_PLUS, }, | ||
| 199 | { 0x000002FF, 0x000002FF, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 200 | |||
| 201 | { 0x00000400, 0x00000413, CPU_MC, CPU_K8_PLUS, }, | ||
| 202 | |||
| 203 | { 0xC0000080, 0xC0000080, CPU_FEATURES, CPU_AMD_ALL, }, | ||
| 204 | { 0xC0000081, 0xC0000084, CPU_CALL, CPU_K8_PLUS, }, | ||
| 205 | { 0xC0000100, 0xC0000102, CPU_BASE, CPU_K8_PLUS, }, | ||
| 206 | { 0xC0000103, 0xC0000103, CPU_TIME, CPU_K10_PLUS, }, | ||
| 207 | |||
| 208 | { 0xC0010000, 0xC0010007, CPU_PMC, CPU_K8_PLUS, }, | ||
| 209 | { 0xC0010010, 0xC0010010, CPU_CONF, CPU_K7_PLUS, }, | ||
| 210 | { 0xC0010015, 0xC0010015, CPU_CONF, CPU_K7_PLUS, }, | ||
| 211 | { 0xC0010016, 0xC001001A, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 212 | { 0xC001001D, 0xC001001D, CPU_MTRR, CPU_K8_PLUS, }, | ||
| 213 | { 0xC001001F, 0xC001001F, CPU_CONF, CPU_K8_PLUS, }, | ||
| 214 | { 0xC0010030, 0xC0010035, CPU_BIOS, CPU_K8_PLUS, }, | ||
| 215 | { 0xC0010044, 0xC0010048, CPU_MC, CPU_K8_PLUS, }, | ||
| 216 | { 0xC0010050, 0xC0010056, CPU_SMM, CPU_K0F_PLUS, }, | ||
| 217 | { 0xC0010058, 0xC0010058, CPU_CONF, CPU_K10_PLUS, }, | ||
| 218 | { 0xC0010060, 0xC0010060, CPU_CACHE, CPU_AMD_11, }, | ||
| 219 | { 0xC0010061, 0xC0010068, CPU_SMM, CPU_K10_PLUS, }, | ||
| 220 | { 0xC0010069, 0xC001006B, CPU_SMM, CPU_AMD_11, }, | ||
| 221 | { 0xC0010070, 0xC0010071, CPU_SMM, CPU_K10_PLUS, }, | ||
| 222 | { 0xC0010111, 0xC0010113, CPU_SMM, CPU_K8_PLUS, }, | ||
| 223 | { 0xC0010114, 0xC0010118, CPU_SVM, CPU_K10_PLUS, }, | ||
| 224 | { 0xC0010140, 0xC0010141, CPU_OSVM, CPU_K10_PLUS, }, | ||
| 225 | { 0xC0011022, 0xC0011023, CPU_CONF, CPU_K10_PLUS, }, | ||
| 226 | }; | ||
| 227 | |||
| 228 | |||
| 229 | /* Intel */ | ||
| 230 | static int get_intel_modelflag(unsigned model) | ||
| 231 | { | ||
| 232 | int flag; | ||
| 233 | |||
| 234 | switch (model) { | ||
| 235 | case 0x0501: | ||
| 236 | case 0x0502: | ||
| 237 | case 0x0504: | ||
| 238 | flag = CPU_INTEL_PENTIUM; | ||
| 239 | break; | ||
| 240 | case 0x0601: | ||
| 241 | case 0x0603: | ||
| 242 | case 0x0605: | ||
| 243 | case 0x0607: | ||
| 244 | case 0x0608: | ||
| 245 | case 0x060A: | ||
| 246 | case 0x060B: | ||
| 247 | flag = CPU_INTEL_P6; | ||
| 248 | break; | ||
| 249 | case 0x0609: | ||
| 250 | case 0x060D: | ||
| 251 | flag = CPU_INTEL_PENTIUM_M; | ||
| 252 | break; | ||
| 253 | case 0x060E: | ||
| 254 | flag = CPU_INTEL_CORE; | ||
| 255 | break; | ||
| 256 | case 0x060F: | ||
| 257 | case 0x0617: | ||
| 258 | flag = CPU_INTEL_CORE2; | ||
| 259 | break; | ||
| 260 | case 0x061C: | ||
| 261 | flag = CPU_INTEL_ATOM; | ||
| 262 | break; | ||
| 263 | case 0x0F00: | ||
| 264 | case 0x0F01: | ||
| 265 | case 0x0F02: | ||
| 266 | case 0x0F03: | ||
| 267 | case 0x0F04: | ||
| 268 | flag = CPU_INTEL_XEON_P4; | ||
| 269 | break; | ||
| 270 | case 0x0F06: | ||
| 271 | flag = CPU_INTEL_XEON_MP; | ||
| 272 | break; | ||
| 273 | default: | ||
| 274 | flag = CPU_NONE; | ||
| 275 | break; | ||
| 276 | } | ||
| 277 | |||
| 278 | return flag; | ||
| 279 | } | ||
| 280 | |||
| 281 | /* AMD */ | ||
| 282 | static int get_amd_modelflag(unsigned model) | ||
| 283 | { | ||
| 284 | int flag; | ||
| 285 | |||
| 286 | switch (model >> 8) { | ||
| 287 | case 0x6: | ||
| 288 | flag = CPU_AMD_K6; | ||
| 289 | break; | ||
| 290 | case 0x7: | ||
| 291 | flag = CPU_AMD_K7; | ||
| 292 | break; | ||
| 293 | case 0x8: | ||
| 294 | flag = CPU_AMD_K8; | ||
| 295 | break; | ||
| 296 | case 0xf: | ||
| 297 | flag = CPU_AMD_0F; | ||
| 298 | break; | ||
| 299 | case 0x10: | ||
| 300 | flag = CPU_AMD_10; | ||
| 301 | break; | ||
| 302 | case 0x11: | ||
| 303 | flag = CPU_AMD_11; | ||
| 304 | break; | ||
| 305 | default: | ||
| 306 | flag = CPU_NONE; | ||
| 307 | break; | ||
| 308 | } | ||
| 309 | |||
| 310 | return flag; | ||
| 311 | } | ||
| 312 | |||
| 313 | static int get_cpu_modelflag(unsigned cpu) | ||
| 314 | { | ||
| 315 | int flag; | ||
| 316 | |||
| 317 | flag = per_cpu(cpu_model, cpu); | ||
| 318 | |||
| 319 | switch (flag >> 16) { | ||
| 320 | case X86_VENDOR_INTEL: | ||
| 321 | flag = get_intel_modelflag(flag); | ||
| 322 | break; | ||
| 323 | case X86_VENDOR_AMD: | ||
| 324 | flag = get_amd_modelflag(flag & 0xffff); | ||
| 325 | break; | ||
| 326 | default: | ||
| 327 | flag = CPU_NONE; | ||
| 328 | break; | ||
| 329 | } | ||
| 330 | |||
| 331 | return flag; | ||
| 332 | } | ||
| 333 | |||
| 334 | static int get_cpu_range_count(unsigned cpu) | ||
| 335 | { | ||
| 336 | int index; | ||
| 337 | |||
| 338 | switch (per_cpu(cpu_model, cpu) >> 16) { | ||
| 339 | case X86_VENDOR_INTEL: | ||
| 340 | index = ARRAY_SIZE(cpu_intel_range); | ||
| 341 | break; | ||
| 342 | case X86_VENDOR_AMD: | ||
| 343 | index = ARRAY_SIZE(cpu_amd_range); | ||
| 344 | break; | ||
| 345 | default: | ||
| 346 | index = 0; | ||
| 347 | break; | ||
| 348 | } | ||
| 349 | |||
| 350 | return index; | ||
| 351 | } | ||
| 352 | |||
| 353 | static int is_typeflag_valid(unsigned cpu, unsigned flag) | ||
| 354 | { | ||
| 355 | unsigned vendor, modelflag; | ||
| 356 | int i, index; | ||
| 357 | |||
| 358 | /* Standard Registers should be always valid */ | ||
| 359 | if (flag >= CPU_TSS) | ||
| 360 | return 1; | ||
| 361 | |||
| 362 | modelflag = per_cpu(cpu_modelflag, cpu); | ||
| 363 | vendor = per_cpu(cpu_model, cpu) >> 16; | ||
| 364 | index = get_cpu_range_count(cpu); | ||
| 365 | |||
| 366 | for (i = 0; i < index; i++) { | ||
| 367 | switch (vendor) { | ||
| 368 | case X86_VENDOR_INTEL: | ||
| 369 | if ((cpu_intel_range[i].model & modelflag) && | ||
| 370 | (cpu_intel_range[i].flag & flag)) | ||
| 371 | return 1; | ||
| 372 | break; | ||
| 373 | case X86_VENDOR_AMD: | ||
| 374 | if ((cpu_amd_range[i].model & modelflag) && | ||
| 375 | (cpu_amd_range[i].flag & flag)) | ||
| 376 | return 1; | ||
| 377 | break; | ||
| 378 | } | ||
| 379 | } | ||
| 380 | |||
| 381 | /* Invalid */ | ||
| 382 | return 0; | ||
| 383 | } | ||
| 384 | |||
| 385 | static unsigned get_cpu_range(unsigned cpu, unsigned *min, unsigned *max, | ||
| 386 | int index, unsigned flag) | ||
| 387 | { | ||
| 388 | unsigned modelflag; | ||
| 389 | |||
| 390 | modelflag = per_cpu(cpu_modelflag, cpu); | ||
| 391 | *max = 0; | ||
| 392 | switch (per_cpu(cpu_model, cpu) >> 16) { | ||
| 393 | case X86_VENDOR_INTEL: | ||
| 394 | if ((cpu_intel_range[index].model & modelflag) && | ||
| 395 | (cpu_intel_range[index].flag & flag)) { | ||
| 396 | *min = cpu_intel_range[index].min; | ||
| 397 | *max = cpu_intel_range[index].max; | ||
| 398 | } | ||
| 399 | break; | ||
| 400 | case X86_VENDOR_AMD: | ||
| 401 | if ((cpu_amd_range[index].model & modelflag) && | ||
| 402 | (cpu_amd_range[index].flag & flag)) { | ||
| 403 | *min = cpu_amd_range[index].min; | ||
| 404 | *max = cpu_amd_range[index].max; | ||
| 405 | } | ||
| 406 | break; | ||
| 407 | } | ||
| 408 | |||
| 409 | return *max; | ||
| 410 | } | ||
| 411 | |||
| 412 | /* This function can also be called with seq = NULL for printk */ | ||
| 413 | static void print_cpu_data(struct seq_file *seq, unsigned type, | ||
| 414 | u32 low, u32 high) | ||
| 415 | { | ||
| 416 | struct cpu_private *priv; | ||
| 417 | u64 val = high; | ||
| 418 | |||
| 419 | if (seq) { | ||
| 420 | priv = seq->private; | ||
| 421 | if (priv->file) { | ||
| 422 | val = (val << 32) | low; | ||
| 423 | seq_printf(seq, "0x%llx\n", val); | ||
| 424 | } else | ||
| 425 | seq_printf(seq, " %08x: %08x_%08x\n", | ||
| 426 | type, high, low); | ||
| 427 | } else | ||
| 428 | printk(KERN_INFO " %08x: %08x_%08x\n", type, high, low); | ||
| 429 | } | ||
| 430 | |||
| 431 | /* This function can also be called with seq = NULL for printk */ | ||
| 432 | static void print_msr(struct seq_file *seq, unsigned cpu, unsigned flag) | ||
| 433 | { | ||
| 434 | unsigned msr, msr_min, msr_max; | ||
| 435 | struct cpu_private *priv; | ||
| 436 | u32 low, high; | ||
| 437 | int i, range; | ||
| 438 | |||
| 439 | if (seq) { | ||
| 440 | priv = seq->private; | ||
| 441 | if (priv->file) { | ||
| 442 | if (!rdmsr_safe_on_cpu(priv->cpu, priv->reg, | ||
| 443 | &low, &high)) | ||
| 444 | print_cpu_data(seq, priv->reg, low, high); | ||
| 445 | return; | ||
| 446 | } | ||
| 447 | } | ||
| 448 | |||
| 449 | range = get_cpu_range_count(cpu); | ||
| 450 | |||
| 451 | for (i = 0; i < range; i++) { | ||
| 452 | if (!get_cpu_range(cpu, &msr_min, &msr_max, i, flag)) | ||
| 453 | continue; | ||
| 454 | |||
| 455 | for (msr = msr_min; msr <= msr_max; msr++) { | ||
| 456 | if (rdmsr_safe_on_cpu(cpu, msr, &low, &high)) | ||
| 457 | continue; | ||
| 458 | print_cpu_data(seq, msr, low, high); | ||
| 459 | } | ||
| 460 | } | ||
| 461 | } | ||
| 462 | |||
| 463 | static void print_tss(void *arg) | ||
| 464 | { | ||
| 465 | struct pt_regs *regs = task_pt_regs(current); | ||
| 466 | struct seq_file *seq = arg; | ||
| 467 | unsigned int seg; | ||
| 468 | |||
| 469 | seq_printf(seq, " RAX\t: %016lx\n", regs->ax); | ||
| 470 | seq_printf(seq, " RBX\t: %016lx\n", regs->bx); | ||
| 471 | seq_printf(seq, " RCX\t: %016lx\n", regs->cx); | ||
| 472 | seq_printf(seq, " RDX\t: %016lx\n", regs->dx); | ||
| 473 | |||
| 474 | seq_printf(seq, " RSI\t: %016lx\n", regs->si); | ||
| 475 | seq_printf(seq, " RDI\t: %016lx\n", regs->di); | ||
| 476 | seq_printf(seq, " RBP\t: %016lx\n", regs->bp); | ||
| 477 | seq_printf(seq, " ESP\t: %016lx\n", regs->sp); | ||
| 478 | |||
| 479 | #ifdef CONFIG_X86_64 | ||
| 480 | seq_printf(seq, " R08\t: %016lx\n", regs->r8); | ||
| 481 | seq_printf(seq, " R09\t: %016lx\n", regs->r9); | ||
| 482 | seq_printf(seq, " R10\t: %016lx\n", regs->r10); | ||
| 483 | seq_printf(seq, " R11\t: %016lx\n", regs->r11); | ||
| 484 | seq_printf(seq, " R12\t: %016lx\n", regs->r12); | ||
| 485 | seq_printf(seq, " R13\t: %016lx\n", regs->r13); | ||
| 486 | seq_printf(seq, " R14\t: %016lx\n", regs->r14); | ||
| 487 | seq_printf(seq, " R15\t: %016lx\n", regs->r15); | ||
| 488 | #endif | ||
| 489 | |||
| 490 | asm("movl %%cs,%0" : "=r" (seg)); | ||
| 491 | seq_printf(seq, " CS\t: %04x\n", seg); | ||
| 492 | asm("movl %%ds,%0" : "=r" (seg)); | ||
| 493 | seq_printf(seq, " DS\t: %04x\n", seg); | ||
| 494 | seq_printf(seq, " SS\t: %04lx\n", regs->ss & 0xffff); | ||
| 495 | asm("movl %%es,%0" : "=r" (seg)); | ||
| 496 | seq_printf(seq, " ES\t: %04x\n", seg); | ||
| 497 | asm("movl %%fs,%0" : "=r" (seg)); | ||
| 498 | seq_printf(seq, " FS\t: %04x\n", seg); | ||
| 499 | asm("movl %%gs,%0" : "=r" (seg)); | ||
| 500 | seq_printf(seq, " GS\t: %04x\n", seg); | ||
| 501 | |||
| 502 | seq_printf(seq, " EFLAGS\t: %016lx\n", regs->flags); | ||
| 503 | |||
| 504 | seq_printf(seq, " EIP\t: %016lx\n", regs->ip); | ||
| 505 | } | ||
| 506 | |||
| 507 | static void print_cr(void *arg) | ||
| 508 | { | ||
| 509 | struct seq_file *seq = arg; | ||
| 510 | |||
| 511 | seq_printf(seq, " cr0\t: %016lx\n", read_cr0()); | ||
| 512 | seq_printf(seq, " cr2\t: %016lx\n", read_cr2()); | ||
| 513 | seq_printf(seq, " cr3\t: %016lx\n", read_cr3()); | ||
| 514 | seq_printf(seq, " cr4\t: %016lx\n", read_cr4_safe()); | ||
| 515 | #ifdef CONFIG_X86_64 | ||
| 516 | seq_printf(seq, " cr8\t: %016lx\n", read_cr8()); | ||
| 517 | #endif | ||
| 518 | } | ||
| 519 | |||
| 520 | static void print_desc_ptr(char *str, struct seq_file *seq, struct desc_ptr dt) | ||
| 521 | { | ||
| 522 | seq_printf(seq, " %s\t: %016llx\n", str, (u64)(dt.address | dt.size)); | ||
| 523 | } | ||
| 524 | |||
| 525 | static void print_dt(void *seq) | ||
| 526 | { | ||
| 527 | struct desc_ptr dt; | ||
| 528 | unsigned long ldt; | ||
| 529 | |||
| 530 | /* IDT */ | ||
| 531 | store_idt((struct desc_ptr *)&dt); | ||
| 532 | print_desc_ptr("IDT", seq, dt); | ||
| 533 | |||
| 534 | /* GDT */ | ||
| 535 | store_gdt((struct desc_ptr *)&dt); | ||
| 536 | print_desc_ptr("GDT", seq, dt); | ||
| 537 | |||
| 538 | /* LDT */ | ||
| 539 | store_ldt(ldt); | ||
| 540 | seq_printf(seq, " LDT\t: %016lx\n", ldt); | ||
| 541 | |||
| 542 | /* TR */ | ||
| 543 | store_tr(ldt); | ||
| 544 | seq_printf(seq, " TR\t: %016lx\n", ldt); | ||
| 545 | } | ||
| 546 | |||
| 547 | static void print_dr(void *arg) | ||
| 548 | { | ||
| 549 | struct seq_file *seq = arg; | ||
| 550 | unsigned long dr; | ||
| 551 | int i; | ||
| 552 | |||
| 553 | for (i = 0; i < 8; i++) { | ||
| 554 | /* Ignore db4, db5 */ | ||
| 555 | if ((i == 4) || (i == 5)) | ||
| 556 | continue; | ||
| 557 | get_debugreg(dr, i); | ||
| 558 | seq_printf(seq, " dr%d\t: %016lx\n", i, dr); | ||
| 559 | } | ||
| 560 | |||
| 561 | seq_printf(seq, "\n MSR\t:\n"); | ||
| 562 | } | ||
| 563 | |||
| 564 | static void print_apic(void *arg) | ||
| 565 | { | ||
| 566 | struct seq_file *seq = arg; | ||
| 567 | |||
| 568 | #ifdef CONFIG_X86_LOCAL_APIC | ||
| 569 | seq_printf(seq, " LAPIC\t:\n"); | ||
| 570 | seq_printf(seq, " ID\t\t: %08x\n", apic_read(APIC_ID) >> 24); | ||
| 571 | seq_printf(seq, " LVR\t\t: %08x\n", apic_read(APIC_LVR)); | ||
| 572 | seq_printf(seq, " TASKPRI\t: %08x\n", apic_read(APIC_TASKPRI)); | ||
| 573 | seq_printf(seq, " ARBPRI\t\t: %08x\n", apic_read(APIC_ARBPRI)); | ||
| 574 | seq_printf(seq, " PROCPRI\t: %08x\n", apic_read(APIC_PROCPRI)); | ||
| 575 | seq_printf(seq, " LDR\t\t: %08x\n", apic_read(APIC_LDR)); | ||
| 576 | seq_printf(seq, " DFR\t\t: %08x\n", apic_read(APIC_DFR)); | ||
| 577 | seq_printf(seq, " SPIV\t\t: %08x\n", apic_read(APIC_SPIV)); | ||
| 578 | seq_printf(seq, " ISR\t\t: %08x\n", apic_read(APIC_ISR)); | ||
| 579 | seq_printf(seq, " ESR\t\t: %08x\n", apic_read(APIC_ESR)); | ||
| 580 | seq_printf(seq, " ICR\t\t: %08x\n", apic_read(APIC_ICR)); | ||
| 581 | seq_printf(seq, " ICR2\t\t: %08x\n", apic_read(APIC_ICR2)); | ||
| 582 | seq_printf(seq, " LVTT\t\t: %08x\n", apic_read(APIC_LVTT)); | ||
| 583 | seq_printf(seq, " LVTTHMR\t: %08x\n", apic_read(APIC_LVTTHMR)); | ||
| 584 | seq_printf(seq, " LVTPC\t\t: %08x\n", apic_read(APIC_LVTPC)); | ||
| 585 | seq_printf(seq, " LVT0\t\t: %08x\n", apic_read(APIC_LVT0)); | ||
| 586 | seq_printf(seq, " LVT1\t\t: %08x\n", apic_read(APIC_LVT1)); | ||
| 587 | seq_printf(seq, " LVTERR\t\t: %08x\n", apic_read(APIC_LVTERR)); | ||
| 588 | seq_printf(seq, " TMICT\t\t: %08x\n", apic_read(APIC_TMICT)); | ||
| 589 | seq_printf(seq, " TMCCT\t\t: %08x\n", apic_read(APIC_TMCCT)); | ||
| 590 | seq_printf(seq, " TDCR\t\t: %08x\n", apic_read(APIC_TDCR)); | ||
| 591 | #endif /* CONFIG_X86_LOCAL_APIC */ | ||
| 592 | |||
| 593 | seq_printf(seq, "\n MSR\t:\n"); | ||
| 594 | } | ||
| 595 | |||
| 596 | static int cpu_seq_show(struct seq_file *seq, void *v) | ||
| 597 | { | ||
| 598 | struct cpu_private *priv = seq->private; | ||
| 599 | |||
| 600 | if (priv == NULL) | ||
| 601 | return -EINVAL; | ||
| 602 | |||
| 603 | switch (cpu_base[priv->type].flag) { | ||
| 604 | case CPU_TSS: | ||
| 605 | smp_call_function_single(priv->cpu, print_tss, seq, 1); | ||
| 606 | break; | ||
| 607 | case CPU_CR: | ||
| 608 | smp_call_function_single(priv->cpu, print_cr, seq, 1); | ||
| 609 | break; | ||
| 610 | case CPU_DT: | ||
| 611 | smp_call_function_single(priv->cpu, print_dt, seq, 1); | ||
| 612 | break; | ||
| 613 | case CPU_DEBUG: | ||
| 614 | if (priv->file == CPU_INDEX_BIT) | ||
| 615 | smp_call_function_single(priv->cpu, print_dr, seq, 1); | ||
| 616 | print_msr(seq, priv->cpu, cpu_base[priv->type].flag); | ||
| 617 | break; | ||
| 618 | case CPU_APIC: | ||
| 619 | if (priv->file == CPU_INDEX_BIT) | ||
| 620 | smp_call_function_single(priv->cpu, print_apic, seq, 1); | ||
| 621 | print_msr(seq, priv->cpu, cpu_base[priv->type].flag); | ||
| 622 | break; | ||
| 623 | |||
| 624 | default: | ||
| 625 | print_msr(seq, priv->cpu, cpu_base[priv->type].flag); | ||
| 626 | break; | ||
| 627 | } | ||
| 628 | seq_printf(seq, "\n"); | ||
| 629 | |||
| 630 | return 0; | ||
| 631 | } | ||
| 632 | |||
| 633 | static void *cpu_seq_start(struct seq_file *seq, loff_t *pos) | ||
| 634 | { | ||
| 635 | if (*pos == 0) /* One time is enough ;-) */ | ||
| 636 | return seq; | ||
| 637 | |||
| 638 | return NULL; | ||
| 639 | } | ||
| 640 | |||
| 641 | static void *cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos) | ||
| 642 | { | ||
| 643 | (*pos)++; | ||
| 644 | |||
| 645 | return cpu_seq_start(seq, pos); | ||
| 646 | } | ||
| 647 | |||
| 648 | static void cpu_seq_stop(struct seq_file *seq, void *v) | ||
| 649 | { | ||
| 650 | } | ||
| 651 | |||
| 652 | static const struct seq_operations cpu_seq_ops = { | ||
| 653 | .start = cpu_seq_start, | ||
| 654 | .next = cpu_seq_next, | ||
| 655 | .stop = cpu_seq_stop, | ||
| 656 | .show = cpu_seq_show, | ||
| 657 | }; | ||
| 658 | |||
| 659 | static int cpu_seq_open(struct inode *inode, struct file *file) | ||
| 660 | { | ||
| 661 | struct cpu_private *priv = inode->i_private; | ||
| 662 | struct seq_file *seq; | ||
| 663 | int err; | ||
| 664 | |||
| 665 | err = seq_open(file, &cpu_seq_ops); | ||
| 666 | if (!err) { | ||
| 667 | seq = file->private_data; | ||
| 668 | seq->private = priv; | ||
| 669 | } | ||
| 670 | |||
| 671 | return err; | ||
| 672 | } | ||
| 673 | |||
| 674 | static int write_msr(struct cpu_private *priv, u64 val) | ||
| 675 | { | ||
| 676 | u32 low, high; | ||
| 677 | |||
| 678 | high = (val >> 32) & 0xffffffff; | ||
| 679 | low = val & 0xffffffff; | ||
| 680 | |||
| 681 | if (!wrmsr_safe_on_cpu(priv->cpu, priv->reg, low, high)) | ||
| 682 | return 0; | ||
| 683 | |||
| 684 | return -EPERM; | ||
| 685 | } | ||
| 686 | |||
| 687 | static int write_cpu_register(struct cpu_private *priv, const char *buf) | ||
| 688 | { | ||
| 689 | int ret = -EPERM; | ||
| 690 | u64 val; | ||
| 691 | |||
| 692 | ret = strict_strtoull(buf, 0, &val); | ||
| 693 | if (ret < 0) | ||
| 694 | return ret; | ||
| 695 | |||
| 696 | /* Supporting only MSRs */ | ||
| 697 | if (priv->type < CPU_TSS_BIT) | ||
| 698 | return write_msr(priv, val); | ||
| 699 | |||
| 700 | return ret; | ||
| 701 | } | ||
| 702 | |||
| 703 | static ssize_t cpu_write(struct file *file, const char __user *ubuf, | ||
| 704 | size_t count, loff_t *off) | ||
| 705 | { | ||
| 706 | struct seq_file *seq = file->private_data; | ||
| 707 | struct cpu_private *priv = seq->private; | ||
| 708 | char buf[19]; | ||
| 709 | |||
| 710 | if ((priv == NULL) || (count >= sizeof(buf))) | ||
| 711 | return -EINVAL; | ||
| 712 | |||
| 713 | if (copy_from_user(&buf, ubuf, count)) | ||
| 714 | return -EFAULT; | ||
| 715 | |||
| 716 | buf[count] = 0; | ||
| 717 | |||
| 718 | if ((cpu_base[priv->type].write) && (cpu_file[priv->file].write)) | ||
| 719 | if (!write_cpu_register(priv, buf)) | ||
| 720 | return count; | ||
| 721 | |||
| 722 | return -EACCES; | ||
| 723 | } | ||
| 724 | |||
| 725 | static const struct file_operations cpu_fops = { | ||
| 726 | .owner = THIS_MODULE, | ||
| 727 | .open = cpu_seq_open, | ||
| 728 | .read = seq_read, | ||
| 729 | .write = cpu_write, | ||
| 730 | .llseek = seq_lseek, | ||
| 731 | .release = seq_release, | ||
| 732 | }; | ||
| 733 | |||
| 734 | static int cpu_create_file(unsigned cpu, unsigned type, unsigned reg, | ||
| 735 | unsigned file, struct dentry *dentry) | ||
| 736 | { | ||
| 737 | struct cpu_private *priv = NULL; | ||
| 738 | |||
| 739 | /* Already intialized */ | ||
| 740 | if (file == CPU_INDEX_BIT) | ||
| 741 | if (per_cpu(cpu_arr[type].init, cpu)) | ||
| 742 | return 0; | ||
| 743 | |||
| 744 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); | ||
| 745 | if (priv == NULL) | ||
| 746 | return -ENOMEM; | ||
| 747 | |||
| 748 | priv->cpu = cpu; | ||
| 749 | priv->type = type; | ||
| 750 | priv->reg = reg; | ||
| 751 | priv->file = file; | ||
| 752 | mutex_lock(&cpu_debug_lock); | ||
| 753 | per_cpu(priv_arr[type], cpu) = priv; | ||
| 754 | per_cpu(cpu_priv_count, cpu)++; | ||
| 755 | mutex_unlock(&cpu_debug_lock); | ||
| 756 | |||
| 757 | if (file) | ||
| 758 | debugfs_create_file(cpu_file[file].name, S_IRUGO, | ||
| 759 | dentry, (void *)priv, &cpu_fops); | ||
| 760 | else { | ||
| 761 | debugfs_create_file(cpu_base[type].name, S_IRUGO, | ||
| 762 | per_cpu(cpu_arr[type].dentry, cpu), | ||
| 763 | (void *)priv, &cpu_fops); | ||
| 764 | mutex_lock(&cpu_debug_lock); | ||
| 765 | per_cpu(cpu_arr[type].init, cpu) = 1; | ||
| 766 | mutex_unlock(&cpu_debug_lock); | ||
| 767 | } | ||
| 768 | |||
| 769 | return 0; | ||
| 770 | } | ||
| 771 | |||
| 772 | static int cpu_init_regfiles(unsigned cpu, unsigned int type, unsigned reg, | ||
| 773 | struct dentry *dentry) | ||
| 774 | { | ||
| 775 | unsigned file; | ||
| 776 | int err = 0; | ||
| 777 | |||
| 778 | for (file = 0; file < ARRAY_SIZE(cpu_file); file++) { | ||
| 779 | err = cpu_create_file(cpu, type, reg, file, dentry); | ||
| 780 | if (err) | ||
| 781 | return err; | ||
| 782 | } | ||
| 783 | |||
| 784 | return err; | ||
| 785 | } | ||
| 786 | |||
| 787 | static int cpu_init_msr(unsigned cpu, unsigned type, struct dentry *dentry) | ||
| 788 | { | ||
| 789 | struct dentry *cpu_dentry = NULL; | ||
| 790 | unsigned reg, reg_min, reg_max; | ||
| 791 | int i, range, err = 0; | ||
| 792 | char reg_dir[12]; | ||
| 793 | u32 low, high; | ||
| 794 | |||
| 795 | range = get_cpu_range_count(cpu); | ||
| 796 | |||
| 797 | for (i = 0; i < range; i++) { | ||
| 798 | if (!get_cpu_range(cpu, ®_min, ®_max, i, | ||
| 799 | cpu_base[type].flag)) | ||
| 800 | continue; | ||
| 801 | |||
| 802 | for (reg = reg_min; reg <= reg_max; reg++) { | ||
| 803 | if (rdmsr_safe_on_cpu(cpu, reg, &low, &high)) | ||
| 804 | continue; | ||
| 805 | |||
| 806 | sprintf(reg_dir, "0x%x", reg); | ||
| 807 | cpu_dentry = debugfs_create_dir(reg_dir, dentry); | ||
| 808 | err = cpu_init_regfiles(cpu, type, reg, cpu_dentry); | ||
| 809 | if (err) | ||
| 810 | return err; | ||
| 811 | } | ||
| 812 | } | ||
| 813 | |||
| 814 | return err; | ||
| 815 | } | ||
| 816 | |||
| 817 | static int cpu_init_allreg(unsigned cpu, struct dentry *dentry) | ||
| 818 | { | ||
| 819 | struct dentry *cpu_dentry = NULL; | ||
| 820 | unsigned type; | ||
| 821 | int err = 0; | ||
| 822 | |||
| 823 | for (type = 0; type < ARRAY_SIZE(cpu_base) - 1; type++) { | ||
| 824 | if (!is_typeflag_valid(cpu, cpu_base[type].flag)) | ||
| 825 | continue; | ||
| 826 | cpu_dentry = debugfs_create_dir(cpu_base[type].name, dentry); | ||
| 827 | per_cpu(cpu_arr[type].dentry, cpu) = cpu_dentry; | ||
| 828 | |||
| 829 | if (type < CPU_TSS_BIT) | ||
| 830 | err = cpu_init_msr(cpu, type, cpu_dentry); | ||
| 831 | else | ||
| 832 | err = cpu_create_file(cpu, type, 0, CPU_INDEX_BIT, | ||
| 833 | cpu_dentry); | ||
| 834 | if (err) | ||
| 835 | return err; | ||
| 836 | } | ||
| 837 | |||
| 838 | return err; | ||
| 839 | } | ||
| 840 | |||
| 841 | static int cpu_init_cpu(void) | ||
| 842 | { | ||
| 843 | struct dentry *cpu_dentry = NULL; | ||
| 844 | struct cpuinfo_x86 *cpui; | ||
| 845 | char cpu_dir[12]; | ||
| 846 | unsigned cpu; | ||
| 847 | int err = 0; | ||
| 848 | |||
| 849 | for (cpu = 0; cpu < nr_cpu_ids; cpu++) { | ||
| 850 | cpui = &cpu_data(cpu); | ||
| 851 | if (!cpu_has(cpui, X86_FEATURE_MSR)) | ||
| 852 | continue; | ||
| 853 | per_cpu(cpu_model, cpu) = ((cpui->x86_vendor << 16) | | ||
| 854 | (cpui->x86 << 8) | | ||
| 855 | (cpui->x86_model)); | ||
| 856 | per_cpu(cpu_modelflag, cpu) = get_cpu_modelflag(cpu); | ||
| 857 | |||
| 858 | sprintf(cpu_dir, "cpu%d", cpu); | ||
| 859 | cpu_dentry = debugfs_create_dir(cpu_dir, cpu_debugfs_dir); | ||
| 860 | err = cpu_init_allreg(cpu, cpu_dentry); | ||
| 861 | |||
| 862 | pr_info("cpu%d(%d) debug files %d\n", | ||
| 863 | cpu, nr_cpu_ids, per_cpu(cpu_priv_count, cpu)); | ||
| 864 | if (per_cpu(cpu_priv_count, cpu) > MAX_CPU_FILES) { | ||
| 865 | pr_err("Register files count %d exceeds limit %d\n", | ||
| 866 | per_cpu(cpu_priv_count, cpu), MAX_CPU_FILES); | ||
| 867 | per_cpu(cpu_priv_count, cpu) = MAX_CPU_FILES; | ||
| 868 | err = -ENFILE; | ||
| 869 | } | ||
| 870 | if (err) | ||
| 871 | return err; | ||
| 872 | } | ||
| 873 | |||
| 874 | return err; | ||
| 875 | } | ||
| 876 | |||
| 877 | static int __init cpu_debug_init(void) | ||
| 878 | { | ||
| 879 | cpu_debugfs_dir = debugfs_create_dir("cpu", arch_debugfs_dir); | ||
| 880 | |||
| 881 | return cpu_init_cpu(); | ||
| 882 | } | ||
| 883 | |||
| 884 | static void __exit cpu_debug_exit(void) | ||
| 885 | { | ||
| 886 | int i, cpu; | ||
| 887 | |||
| 888 | if (cpu_debugfs_dir) | ||
| 889 | debugfs_remove_recursive(cpu_debugfs_dir); | ||
| 890 | |||
| 891 | for (cpu = 0; cpu < nr_cpu_ids; cpu++) | ||
| 892 | for (i = 0; i < per_cpu(cpu_priv_count, cpu); i++) | ||
| 893 | kfree(per_cpu(priv_arr[i], cpu)); | ||
| 894 | } | ||
| 895 | |||
| 896 | module_init(cpu_debug_init); | ||
| 897 | module_exit(cpu_debug_exit); | ||
| 898 | |||
| 899 | MODULE_AUTHOR("Jaswinder Singh Rajput"); | ||
| 900 | MODULE_DESCRIPTION("CPU Debug module"); | ||
| 901 | MODULE_LICENSE("GPL"); | ||
diff --git a/arch/x86/kernel/cpu/cyrix.c b/arch/x86/kernel/cpu/cyrix.c index ffd0f5ed071a..593171e967ef 100644 --- a/arch/x86/kernel/cpu/cyrix.c +++ b/arch/x86/kernel/cpu/cyrix.c | |||
| @@ -61,23 +61,23 @@ static void __cpuinit do_cyrix_devid(unsigned char *dir0, unsigned char *dir1) | |||
| 61 | */ | 61 | */ |
| 62 | static unsigned char Cx86_dir0_msb __cpuinitdata = 0; | 62 | static unsigned char Cx86_dir0_msb __cpuinitdata = 0; |
| 63 | 63 | ||
| 64 | static char Cx86_model[][9] __cpuinitdata = { | 64 | static const char __cpuinitconst Cx86_model[][9] = { |
| 65 | "Cx486", "Cx486", "5x86 ", "6x86", "MediaGX ", "6x86MX ", | 65 | "Cx486", "Cx486", "5x86 ", "6x86", "MediaGX ", "6x86MX ", |
| 66 | "M II ", "Unknown" | 66 | "M II ", "Unknown" |
| 67 | }; | 67 | }; |
| 68 | static char Cx486_name[][5] __cpuinitdata = { | 68 | static const char __cpuinitconst Cx486_name[][5] = { |
| 69 | "SLC", "DLC", "SLC2", "DLC2", "SRx", "DRx", | 69 | "SLC", "DLC", "SLC2", "DLC2", "SRx", "DRx", |
| 70 | "SRx2", "DRx2" | 70 | "SRx2", "DRx2" |
| 71 | }; | 71 | }; |
| 72 | static char Cx486S_name[][4] __cpuinitdata = { | 72 | static const char __cpuinitconst Cx486S_name[][4] = { |
| 73 | "S", "S2", "Se", "S2e" | 73 | "S", "S2", "Se", "S2e" |
| 74 | }; | 74 | }; |
| 75 | static char Cx486D_name[][4] __cpuinitdata = { | 75 | static const char __cpuinitconst Cx486D_name[][4] = { |
| 76 | "DX", "DX2", "?", "?", "?", "DX4" | 76 | "DX", "DX2", "?", "?", "?", "DX4" |
| 77 | }; | 77 | }; |
| 78 | static char Cx86_cb[] __cpuinitdata = "?.5x Core/Bus Clock"; | 78 | static char Cx86_cb[] __cpuinitdata = "?.5x Core/Bus Clock"; |
| 79 | static char cyrix_model_mult1[] __cpuinitdata = "12??43"; | 79 | static const char __cpuinitconst cyrix_model_mult1[] = "12??43"; |
| 80 | static char cyrix_model_mult2[] __cpuinitdata = "12233445"; | 80 | static const char __cpuinitconst cyrix_model_mult2[] = "12233445"; |
| 81 | 81 | ||
| 82 | /* | 82 | /* |
| 83 | * Reset the slow-loop (SLOP) bit on the 686(L) which is set by some old | 83 | * Reset the slow-loop (SLOP) bit on the 686(L) which is set by some old |
| @@ -435,7 +435,7 @@ static void __cpuinit cyrix_identify(struct cpuinfo_x86 *c) | |||
| 435 | } | 435 | } |
| 436 | } | 436 | } |
| 437 | 437 | ||
| 438 | static struct cpu_dev cyrix_cpu_dev __cpuinitdata = { | 438 | static const struct cpu_dev __cpuinitconst cyrix_cpu_dev = { |
| 439 | .c_vendor = "Cyrix", | 439 | .c_vendor = "Cyrix", |
| 440 | .c_ident = { "CyrixInstead" }, | 440 | .c_ident = { "CyrixInstead" }, |
| 441 | .c_early_init = early_init_cyrix, | 441 | .c_early_init = early_init_cyrix, |
| @@ -446,7 +446,7 @@ static struct cpu_dev cyrix_cpu_dev __cpuinitdata = { | |||
| 446 | 446 | ||
| 447 | cpu_dev_register(cyrix_cpu_dev); | 447 | cpu_dev_register(cyrix_cpu_dev); |
| 448 | 448 | ||
| 449 | static struct cpu_dev nsc_cpu_dev __cpuinitdata = { | 449 | static const struct cpu_dev __cpuinitconst nsc_cpu_dev = { |
| 450 | .c_vendor = "NSC", | 450 | .c_vendor = "NSC", |
| 451 | .c_ident = { "Geode by NSC" }, | 451 | .c_ident = { "Geode by NSC" }, |
| 452 | .c_init = init_nsc, | 452 | .c_init = init_nsc, |
diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c index 1a89a2b68d15..7437fa133c02 100644 --- a/arch/x86/kernel/cpu/intel.c +++ b/arch/x86/kernel/cpu/intel.c | |||
| @@ -14,6 +14,7 @@ | |||
| 14 | #include <asm/uaccess.h> | 14 | #include <asm/uaccess.h> |
| 15 | #include <asm/ds.h> | 15 | #include <asm/ds.h> |
| 16 | #include <asm/bugs.h> | 16 | #include <asm/bugs.h> |
| 17 | #include <asm/cpu.h> | ||
| 17 | 18 | ||
| 18 | #ifdef CONFIG_X86_64 | 19 | #ifdef CONFIG_X86_64 |
| 19 | #include <asm/topology.h> | 20 | #include <asm/topology.h> |
| @@ -54,6 +55,11 @@ static void __cpuinit early_init_intel(struct cpuinfo_x86 *c) | |||
| 54 | c->x86_cache_alignment = 128; | 55 | c->x86_cache_alignment = 128; |
| 55 | #endif | 56 | #endif |
| 56 | 57 | ||
| 58 | /* CPUID workaround for 0F33/0F34 CPU */ | ||
| 59 | if (c->x86 == 0xF && c->x86_model == 0x3 | ||
| 60 | && (c->x86_mask == 0x3 || c->x86_mask == 0x4)) | ||
| 61 | c->x86_phys_bits = 36; | ||
| 62 | |||
| 57 | /* | 63 | /* |
| 58 | * c->x86_power is 8000_0007 edx. Bit 8 is TSC runs at constant rate | 64 | * c->x86_power is 8000_0007 edx. Bit 8 is TSC runs at constant rate |
| 59 | * with P/T states and does not stop in deep C-states. | 65 | * with P/T states and does not stop in deep C-states. |
| @@ -116,6 +122,28 @@ static void __cpuinit trap_init_f00f_bug(void) | |||
| 116 | } | 122 | } |
| 117 | #endif | 123 | #endif |
| 118 | 124 | ||
| 125 | static void __cpuinit intel_smp_check(struct cpuinfo_x86 *c) | ||
| 126 | { | ||
| 127 | #ifdef CONFIG_SMP | ||
| 128 | /* calling is from identify_secondary_cpu() ? */ | ||
| 129 | if (c->cpu_index == boot_cpu_id) | ||
| 130 | return; | ||
| 131 | |||
| 132 | /* | ||
| 133 | * Mask B, Pentium, but not Pentium MMX | ||
| 134 | */ | ||
| 135 | if (c->x86 == 5 && | ||
| 136 | c->x86_mask >= 1 && c->x86_mask <= 4 && | ||
| 137 | c->x86_model <= 3) { | ||
| 138 | /* | ||
| 139 | * Remember we have B step Pentia with bugs | ||
| 140 | */ | ||
| 141 | WARN_ONCE(1, "WARNING: SMP operation may be unreliable" | ||
| 142 | "with B stepping processors.\n"); | ||
| 143 | } | ||
| 144 | #endif | ||
| 145 | } | ||
| 146 | |||
| 119 | static void __cpuinit intel_workarounds(struct cpuinfo_x86 *c) | 147 | static void __cpuinit intel_workarounds(struct cpuinfo_x86 *c) |
| 120 | { | 148 | { |
| 121 | unsigned long lo, hi; | 149 | unsigned long lo, hi; |
| @@ -192,6 +220,8 @@ static void __cpuinit intel_workarounds(struct cpuinfo_x86 *c) | |||
| 192 | #ifdef CONFIG_X86_NUMAQ | 220 | #ifdef CONFIG_X86_NUMAQ |
| 193 | numaq_tsc_disable(); | 221 | numaq_tsc_disable(); |
| 194 | #endif | 222 | #endif |
| 223 | |||
| 224 | intel_smp_check(c); | ||
| 195 | } | 225 | } |
| 196 | #else | 226 | #else |
| 197 | static void __cpuinit intel_workarounds(struct cpuinfo_x86 *c) | 227 | static void __cpuinit intel_workarounds(struct cpuinfo_x86 *c) |
| @@ -391,7 +421,7 @@ static unsigned int __cpuinit intel_size_cache(struct cpuinfo_x86 *c, unsigned i | |||
| 391 | } | 421 | } |
| 392 | #endif | 422 | #endif |
| 393 | 423 | ||
| 394 | static struct cpu_dev intel_cpu_dev __cpuinitdata = { | 424 | static const struct cpu_dev __cpuinitconst intel_cpu_dev = { |
| 395 | .c_vendor = "Intel", | 425 | .c_vendor = "Intel", |
| 396 | .c_ident = { "GenuineIntel" }, | 426 | .c_ident = { "GenuineIntel" }, |
| 397 | #ifdef CONFIG_X86_32 | 427 | #ifdef CONFIG_X86_32 |
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c index 7293508d8f5c..c471eb1a389c 100644 --- a/arch/x86/kernel/cpu/intel_cacheinfo.c +++ b/arch/x86/kernel/cpu/intel_cacheinfo.c | |||
| @@ -32,7 +32,7 @@ struct _cache_table | |||
| 32 | }; | 32 | }; |
| 33 | 33 | ||
| 34 | /* all the cache descriptor types we care about (no TLB or trace cache entries) */ | 34 | /* all the cache descriptor types we care about (no TLB or trace cache entries) */ |
| 35 | static struct _cache_table cache_table[] __cpuinitdata = | 35 | static const struct _cache_table __cpuinitconst cache_table[] = |
| 36 | { | 36 | { |
| 37 | { 0x06, LVL_1_INST, 8 }, /* 4-way set assoc, 32 byte line size */ | 37 | { 0x06, LVL_1_INST, 8 }, /* 4-way set assoc, 32 byte line size */ |
| 38 | { 0x08, LVL_1_INST, 16 }, /* 4-way set assoc, 32 byte line size */ | 38 | { 0x08, LVL_1_INST, 16 }, /* 4-way set assoc, 32 byte line size */ |
| @@ -206,15 +206,15 @@ union l3_cache { | |||
| 206 | unsigned val; | 206 | unsigned val; |
| 207 | }; | 207 | }; |
| 208 | 208 | ||
| 209 | static unsigned short assocs[] __cpuinitdata = { | 209 | static const unsigned short __cpuinitconst assocs[] = { |
| 210 | [1] = 1, [2] = 2, [4] = 4, [6] = 8, | 210 | [1] = 1, [2] = 2, [4] = 4, [6] = 8, |
| 211 | [8] = 16, [0xa] = 32, [0xb] = 48, | 211 | [8] = 16, [0xa] = 32, [0xb] = 48, |
| 212 | [0xc] = 64, | 212 | [0xc] = 64, |
| 213 | [0xf] = 0xffff // ?? | 213 | [0xf] = 0xffff // ?? |
| 214 | }; | 214 | }; |
| 215 | 215 | ||
| 216 | static unsigned char levels[] __cpuinitdata = { 1, 1, 2, 3 }; | 216 | static const unsigned char __cpuinitconst levels[] = { 1, 1, 2, 3 }; |
| 217 | static unsigned char types[] __cpuinitdata = { 1, 2, 3, 3 }; | 217 | static const unsigned char __cpuinitconst types[] = { 1, 2, 3, 3 }; |
| 218 | 218 | ||
| 219 | static void __cpuinit | 219 | static void __cpuinit |
| 220 | amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax, | 220 | amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax, |
diff --git a/arch/x86/kernel/cpu/mcheck/Makefile b/arch/x86/kernel/cpu/mcheck/Makefile index d7d2323bbb69..b2f89829bbe8 100644 --- a/arch/x86/kernel/cpu/mcheck/Makefile +++ b/arch/x86/kernel/cpu/mcheck/Makefile | |||
| @@ -4,3 +4,4 @@ obj-$(CONFIG_X86_32) += k7.o p4.o p5.o p6.o winchip.o | |||
| 4 | obj-$(CONFIG_X86_MCE_INTEL) += mce_intel_64.o | 4 | obj-$(CONFIG_X86_MCE_INTEL) += mce_intel_64.o |
| 5 | obj-$(CONFIG_X86_MCE_AMD) += mce_amd_64.o | 5 | obj-$(CONFIG_X86_MCE_AMD) += mce_amd_64.o |
| 6 | obj-$(CONFIG_X86_MCE_NONFATAL) += non-fatal.o | 6 | obj-$(CONFIG_X86_MCE_NONFATAL) += non-fatal.o |
| 7 | obj-$(CONFIG_X86_MCE_THRESHOLD) += threshold.o | ||
diff --git a/arch/x86/kernel/cpu/mcheck/mce_32.c b/arch/x86/kernel/cpu/mcheck/mce_32.c index dfaebce3633e..3552119b091d 100644 --- a/arch/x86/kernel/cpu/mcheck/mce_32.c +++ b/arch/x86/kernel/cpu/mcheck/mce_32.c | |||
| @@ -60,20 +60,6 @@ void mcheck_init(struct cpuinfo_x86 *c) | |||
| 60 | } | 60 | } |
| 61 | } | 61 | } |
| 62 | 62 | ||
| 63 | static unsigned long old_cr4 __initdata; | ||
| 64 | |||
| 65 | void __init stop_mce(void) | ||
| 66 | { | ||
| 67 | old_cr4 = read_cr4(); | ||
| 68 | clear_in_cr4(X86_CR4_MCE); | ||
| 69 | } | ||
| 70 | |||
| 71 | void __init restart_mce(void) | ||
| 72 | { | ||
| 73 | if (old_cr4 & X86_CR4_MCE) | ||
| 74 | set_in_cr4(X86_CR4_MCE); | ||
| 75 | } | ||
| 76 | |||
| 77 | static int __init mcheck_disable(char *str) | 63 | static int __init mcheck_disable(char *str) |
| 78 | { | 64 | { |
| 79 | mce_disabled = 1; | 65 | mce_disabled = 1; |
diff --git a/arch/x86/kernel/cpu/mcheck/mce_64.c b/arch/x86/kernel/cpu/mcheck/mce_64.c index fe79985ce0f2..ca14604611ec 100644 --- a/arch/x86/kernel/cpu/mcheck/mce_64.c +++ b/arch/x86/kernel/cpu/mcheck/mce_64.c | |||
| @@ -3,6 +3,8 @@ | |||
| 3 | * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs. | 3 | * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs. |
| 4 | * Rest from unknown author(s). | 4 | * Rest from unknown author(s). |
| 5 | * 2004 Andi Kleen. Rewrote most of it. | 5 | * 2004 Andi Kleen. Rewrote most of it. |
| 6 | * Copyright 2008 Intel Corporation | ||
| 7 | * Author: Andi Kleen | ||
| 6 | */ | 8 | */ |
| 7 | 9 | ||
| 8 | #include <linux/init.h> | 10 | #include <linux/init.h> |
| @@ -24,6 +26,9 @@ | |||
| 24 | #include <linux/ctype.h> | 26 | #include <linux/ctype.h> |
| 25 | #include <linux/kmod.h> | 27 | #include <linux/kmod.h> |
| 26 | #include <linux/kdebug.h> | 28 | #include <linux/kdebug.h> |
| 29 | #include <linux/kobject.h> | ||
| 30 | #include <linux/sysfs.h> | ||
| 31 | #include <linux/ratelimit.h> | ||
| 27 | #include <asm/processor.h> | 32 | #include <asm/processor.h> |
| 28 | #include <asm/msr.h> | 33 | #include <asm/msr.h> |
| 29 | #include <asm/mce.h> | 34 | #include <asm/mce.h> |
| @@ -32,7 +37,6 @@ | |||
| 32 | #include <asm/idle.h> | 37 | #include <asm/idle.h> |
| 33 | 38 | ||
| 34 | #define MISC_MCELOG_MINOR 227 | 39 | #define MISC_MCELOG_MINOR 227 |
| 35 | #define NR_SYSFS_BANKS 6 | ||
| 36 | 40 | ||
| 37 | atomic_t mce_entry; | 41 | atomic_t mce_entry; |
| 38 | 42 | ||
| @@ -47,7 +51,7 @@ static int mce_dont_init; | |||
| 47 | */ | 51 | */ |
| 48 | static int tolerant = 1; | 52 | static int tolerant = 1; |
| 49 | static int banks; | 53 | static int banks; |
| 50 | static unsigned long bank[NR_SYSFS_BANKS] = { [0 ... NR_SYSFS_BANKS-1] = ~0UL }; | 54 | static u64 *bank; |
| 51 | static unsigned long notify_user; | 55 | static unsigned long notify_user; |
| 52 | static int rip_msr; | 56 | static int rip_msr; |
| 53 | static int mce_bootlog = -1; | 57 | static int mce_bootlog = -1; |
| @@ -58,6 +62,19 @@ static char *trigger_argv[2] = { trigger, NULL }; | |||
| 58 | 62 | ||
| 59 | static DECLARE_WAIT_QUEUE_HEAD(mce_wait); | 63 | static DECLARE_WAIT_QUEUE_HEAD(mce_wait); |
| 60 | 64 | ||
| 65 | /* MCA banks polled by the period polling timer for corrected events */ | ||
| 66 | DEFINE_PER_CPU(mce_banks_t, mce_poll_banks) = { | ||
| 67 | [0 ... BITS_TO_LONGS(MAX_NR_BANKS)-1] = ~0UL | ||
| 68 | }; | ||
| 69 | |||
| 70 | /* Do initial initialization of a struct mce */ | ||
| 71 | void mce_setup(struct mce *m) | ||
| 72 | { | ||
| 73 | memset(m, 0, sizeof(struct mce)); | ||
| 74 | m->cpu = smp_processor_id(); | ||
| 75 | rdtscll(m->tsc); | ||
| 76 | } | ||
| 77 | |||
| 61 | /* | 78 | /* |
| 62 | * Lockless MCE logging infrastructure. | 79 | * Lockless MCE logging infrastructure. |
| 63 | * This avoids deadlocks on printk locks without having to break locks. Also | 80 | * This avoids deadlocks on printk locks without having to break locks. Also |
| @@ -119,11 +136,11 @@ static void print_mce(struct mce *m) | |||
| 119 | print_symbol("{%s}", m->ip); | 136 | print_symbol("{%s}", m->ip); |
| 120 | printk("\n"); | 137 | printk("\n"); |
| 121 | } | 138 | } |
| 122 | printk(KERN_EMERG "TSC %Lx ", m->tsc); | 139 | printk(KERN_EMERG "TSC %llx ", m->tsc); |
| 123 | if (m->addr) | 140 | if (m->addr) |
| 124 | printk("ADDR %Lx ", m->addr); | 141 | printk("ADDR %llx ", m->addr); |
| 125 | if (m->misc) | 142 | if (m->misc) |
| 126 | printk("MISC %Lx ", m->misc); | 143 | printk("MISC %llx ", m->misc); |
| 127 | printk("\n"); | 144 | printk("\n"); |
| 128 | printk(KERN_EMERG "This is not a software problem!\n"); | 145 | printk(KERN_EMERG "This is not a software problem!\n"); |
| 129 | printk(KERN_EMERG "Run through mcelog --ascii to decode " | 146 | printk(KERN_EMERG "Run through mcelog --ascii to decode " |
| @@ -149,8 +166,10 @@ static void mce_panic(char *msg, struct mce *backup, unsigned long start) | |||
| 149 | panic(msg); | 166 | panic(msg); |
| 150 | } | 167 | } |
| 151 | 168 | ||
| 152 | static int mce_available(struct cpuinfo_x86 *c) | 169 | int mce_available(struct cpuinfo_x86 *c) |
| 153 | { | 170 | { |
| 171 | if (mce_dont_init) | ||
| 172 | return 0; | ||
| 154 | return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA); | 173 | return cpu_has(c, X86_FEATURE_MCE) && cpu_has(c, X86_FEATURE_MCA); |
| 155 | } | 174 | } |
| 156 | 175 | ||
| @@ -172,7 +191,77 @@ static inline void mce_get_rip(struct mce *m, struct pt_regs *regs) | |||
| 172 | } | 191 | } |
| 173 | 192 | ||
| 174 | /* | 193 | /* |
| 175 | * The actual machine check handler | 194 | * Poll for corrected events or events that happened before reset. |
| 195 | * Those are just logged through /dev/mcelog. | ||
| 196 | * | ||
| 197 | * This is executed in standard interrupt context. | ||
| 198 | */ | ||
| 199 | void machine_check_poll(enum mcp_flags flags, mce_banks_t *b) | ||
| 200 | { | ||
| 201 | struct mce m; | ||
| 202 | int i; | ||
| 203 | |||
| 204 | mce_setup(&m); | ||
| 205 | |||
| 206 | rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus); | ||
| 207 | for (i = 0; i < banks; i++) { | ||
| 208 | if (!bank[i] || !test_bit(i, *b)) | ||
| 209 | continue; | ||
| 210 | |||
| 211 | m.misc = 0; | ||
| 212 | m.addr = 0; | ||
| 213 | m.bank = i; | ||
| 214 | m.tsc = 0; | ||
| 215 | |||
| 216 | barrier(); | ||
| 217 | rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status); | ||
| 218 | if (!(m.status & MCI_STATUS_VAL)) | ||
| 219 | continue; | ||
| 220 | |||
| 221 | /* | ||
| 222 | * Uncorrected events are handled by the exception handler | ||
| 223 | * when it is enabled. But when the exception is disabled log | ||
| 224 | * everything. | ||
| 225 | * | ||
| 226 | * TBD do the same check for MCI_STATUS_EN here? | ||
| 227 | */ | ||
| 228 | if ((m.status & MCI_STATUS_UC) && !(flags & MCP_UC)) | ||
| 229 | continue; | ||
| 230 | |||
| 231 | if (m.status & MCI_STATUS_MISCV) | ||
| 232 | rdmsrl(MSR_IA32_MC0_MISC + i*4, m.misc); | ||
| 233 | if (m.status & MCI_STATUS_ADDRV) | ||
| 234 | rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr); | ||
| 235 | |||
| 236 | if (!(flags & MCP_TIMESTAMP)) | ||
| 237 | m.tsc = 0; | ||
| 238 | /* | ||
| 239 | * Don't get the IP here because it's unlikely to | ||
| 240 | * have anything to do with the actual error location. | ||
| 241 | */ | ||
| 242 | |||
| 243 | mce_log(&m); | ||
| 244 | add_taint(TAINT_MACHINE_CHECK); | ||
| 245 | |||
| 246 | /* | ||
| 247 | * Clear state for this bank. | ||
| 248 | */ | ||
| 249 | wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0); | ||
| 250 | } | ||
| 251 | |||
| 252 | /* | ||
| 253 | * Don't clear MCG_STATUS here because it's only defined for | ||
| 254 | * exceptions. | ||
| 255 | */ | ||
| 256 | } | ||
| 257 | |||
| 258 | /* | ||
| 259 | * The actual machine check handler. This only handles real | ||
| 260 | * exceptions when something got corrupted coming in through int 18. | ||
| 261 | * | ||
| 262 | * This is executed in NMI context not subject to normal locking rules. This | ||
| 263 | * implies that most kernel services cannot be safely used. Don't even | ||
| 264 | * think about putting a printk in there! | ||
| 176 | */ | 265 | */ |
| 177 | void do_machine_check(struct pt_regs * regs, long error_code) | 266 | void do_machine_check(struct pt_regs * regs, long error_code) |
| 178 | { | 267 | { |
| @@ -190,17 +279,18 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 190 | * error. | 279 | * error. |
| 191 | */ | 280 | */ |
| 192 | int kill_it = 0; | 281 | int kill_it = 0; |
| 282 | DECLARE_BITMAP(toclear, MAX_NR_BANKS); | ||
| 193 | 283 | ||
| 194 | atomic_inc(&mce_entry); | 284 | atomic_inc(&mce_entry); |
| 195 | 285 | ||
| 196 | if ((regs | 286 | if (notify_die(DIE_NMI, "machine check", regs, error_code, |
| 197 | && notify_die(DIE_NMI, "machine check", regs, error_code, | ||
| 198 | 18, SIGKILL) == NOTIFY_STOP) | 287 | 18, SIGKILL) == NOTIFY_STOP) |
| 199 | || !banks) | 288 | goto out2; |
| 289 | if (!banks) | ||
| 200 | goto out2; | 290 | goto out2; |
| 201 | 291 | ||
| 202 | memset(&m, 0, sizeof(struct mce)); | 292 | mce_setup(&m); |
| 203 | m.cpu = smp_processor_id(); | 293 | |
| 204 | rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus); | 294 | rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus); |
| 205 | /* if the restart IP is not valid, we're done for */ | 295 | /* if the restart IP is not valid, we're done for */ |
| 206 | if (!(m.mcgstatus & MCG_STATUS_RIPV)) | 296 | if (!(m.mcgstatus & MCG_STATUS_RIPV)) |
| @@ -210,18 +300,32 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 210 | barrier(); | 300 | barrier(); |
| 211 | 301 | ||
| 212 | for (i = 0; i < banks; i++) { | 302 | for (i = 0; i < banks; i++) { |
| 213 | if (i < NR_SYSFS_BANKS && !bank[i]) | 303 | __clear_bit(i, toclear); |
| 304 | if (!bank[i]) | ||
| 214 | continue; | 305 | continue; |
| 215 | 306 | ||
| 216 | m.misc = 0; | 307 | m.misc = 0; |
| 217 | m.addr = 0; | 308 | m.addr = 0; |
| 218 | m.bank = i; | 309 | m.bank = i; |
| 219 | m.tsc = 0; | ||
| 220 | 310 | ||
| 221 | rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status); | 311 | rdmsrl(MSR_IA32_MC0_STATUS + i*4, m.status); |
| 222 | if ((m.status & MCI_STATUS_VAL) == 0) | 312 | if ((m.status & MCI_STATUS_VAL) == 0) |
| 223 | continue; | 313 | continue; |
| 224 | 314 | ||
| 315 | /* | ||
| 316 | * Non uncorrected errors are handled by machine_check_poll | ||
| 317 | * Leave them alone. | ||
| 318 | */ | ||
| 319 | if ((m.status & MCI_STATUS_UC) == 0) | ||
| 320 | continue; | ||
| 321 | |||
| 322 | /* | ||
| 323 | * Set taint even when machine check was not enabled. | ||
| 324 | */ | ||
| 325 | add_taint(TAINT_MACHINE_CHECK); | ||
| 326 | |||
| 327 | __set_bit(i, toclear); | ||
| 328 | |||
| 225 | if (m.status & MCI_STATUS_EN) { | 329 | if (m.status & MCI_STATUS_EN) { |
| 226 | /* if PCC was set, there's no way out */ | 330 | /* if PCC was set, there's no way out */ |
| 227 | no_way_out |= !!(m.status & MCI_STATUS_PCC); | 331 | no_way_out |= !!(m.status & MCI_STATUS_PCC); |
| @@ -235,6 +339,12 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 235 | no_way_out = 1; | 339 | no_way_out = 1; |
| 236 | kill_it = 1; | 340 | kill_it = 1; |
| 237 | } | 341 | } |
| 342 | } else { | ||
| 343 | /* | ||
| 344 | * Machine check event was not enabled. Clear, but | ||
| 345 | * ignore. | ||
| 346 | */ | ||
| 347 | continue; | ||
| 238 | } | 348 | } |
| 239 | 349 | ||
| 240 | if (m.status & MCI_STATUS_MISCV) | 350 | if (m.status & MCI_STATUS_MISCV) |
| @@ -243,10 +353,7 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 243 | rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr); | 353 | rdmsrl(MSR_IA32_MC0_ADDR + i*4, m.addr); |
| 244 | 354 | ||
| 245 | mce_get_rip(&m, regs); | 355 | mce_get_rip(&m, regs); |
| 246 | if (error_code >= 0) | 356 | mce_log(&m); |
| 247 | rdtscll(m.tsc); | ||
| 248 | if (error_code != -2) | ||
| 249 | mce_log(&m); | ||
| 250 | 357 | ||
| 251 | /* Did this bank cause the exception? */ | 358 | /* Did this bank cause the exception? */ |
| 252 | /* Assume that the bank with uncorrectable errors did it, | 359 | /* Assume that the bank with uncorrectable errors did it, |
| @@ -255,14 +362,8 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 255 | panicm = m; | 362 | panicm = m; |
| 256 | panicm_found = 1; | 363 | panicm_found = 1; |
| 257 | } | 364 | } |
| 258 | |||
| 259 | add_taint(TAINT_MACHINE_CHECK); | ||
| 260 | } | 365 | } |
| 261 | 366 | ||
| 262 | /* Never do anything final in the polling timer */ | ||
| 263 | if (!regs) | ||
| 264 | goto out; | ||
| 265 | |||
| 266 | /* If we didn't find an uncorrectable error, pick | 367 | /* If we didn't find an uncorrectable error, pick |
| 267 | the last one (shouldn't happen, just being safe). */ | 368 | the last one (shouldn't happen, just being safe). */ |
| 268 | if (!panicm_found) | 369 | if (!panicm_found) |
| @@ -309,10 +410,11 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 309 | /* notify userspace ASAP */ | 410 | /* notify userspace ASAP */ |
| 310 | set_thread_flag(TIF_MCE_NOTIFY); | 411 | set_thread_flag(TIF_MCE_NOTIFY); |
| 311 | 412 | ||
| 312 | out: | ||
| 313 | /* the last thing we do is clear state */ | 413 | /* the last thing we do is clear state */ |
| 314 | for (i = 0; i < banks; i++) | 414 | for (i = 0; i < banks; i++) { |
| 315 | wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0); | 415 | if (test_bit(i, toclear)) |
| 416 | wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0); | ||
| 417 | } | ||
| 316 | wrmsrl(MSR_IA32_MCG_STATUS, 0); | 418 | wrmsrl(MSR_IA32_MCG_STATUS, 0); |
| 317 | out2: | 419 | out2: |
| 318 | atomic_dec(&mce_entry); | 420 | atomic_dec(&mce_entry); |
| @@ -332,15 +434,13 @@ void do_machine_check(struct pt_regs * regs, long error_code) | |||
| 332 | * and historically has been the register value of the | 434 | * and historically has been the register value of the |
| 333 | * MSR_IA32_THERMAL_STATUS (Intel) msr. | 435 | * MSR_IA32_THERMAL_STATUS (Intel) msr. |
| 334 | */ | 436 | */ |
| 335 | void mce_log_therm_throt_event(unsigned int cpu, __u64 status) | 437 | void mce_log_therm_throt_event(__u64 status) |
| 336 | { | 438 | { |
| 337 | struct mce m; | 439 | struct mce m; |
| 338 | 440 | ||
| 339 | memset(&m, 0, sizeof(m)); | 441 | mce_setup(&m); |
| 340 | m.cpu = cpu; | ||
| 341 | m.bank = MCE_THERMAL_BANK; | 442 | m.bank = MCE_THERMAL_BANK; |
| 342 | m.status = status; | 443 | m.status = status; |
| 343 | rdtscll(m.tsc); | ||
| 344 | mce_log(&m); | 444 | mce_log(&m); |
| 345 | } | 445 | } |
| 346 | #endif /* CONFIG_X86_MCE_INTEL */ | 446 | #endif /* CONFIG_X86_MCE_INTEL */ |
| @@ -353,18 +453,18 @@ void mce_log_therm_throt_event(unsigned int cpu, __u64 status) | |||
| 353 | 453 | ||
| 354 | static int check_interval = 5 * 60; /* 5 minutes */ | 454 | static int check_interval = 5 * 60; /* 5 minutes */ |
| 355 | static int next_interval; /* in jiffies */ | 455 | static int next_interval; /* in jiffies */ |
| 356 | static void mcheck_timer(struct work_struct *work); | 456 | static void mcheck_timer(unsigned long); |
| 357 | static DECLARE_DELAYED_WORK(mcheck_work, mcheck_timer); | 457 | static DEFINE_PER_CPU(struct timer_list, mce_timer); |
| 358 | 458 | ||
| 359 | static void mcheck_check_cpu(void *info) | 459 | static void mcheck_timer(unsigned long data) |
| 360 | { | 460 | { |
| 361 | if (mce_available(¤t_cpu_data)) | 461 | struct timer_list *t = &per_cpu(mce_timer, data); |
| 362 | do_machine_check(NULL, 0); | ||
| 363 | } | ||
| 364 | 462 | ||
| 365 | static void mcheck_timer(struct work_struct *work) | 463 | WARN_ON(smp_processor_id() != data); |
| 366 | { | 464 | |
| 367 | on_each_cpu(mcheck_check_cpu, NULL, 1); | 465 | if (mce_available(¤t_cpu_data)) |
| 466 | machine_check_poll(MCP_TIMESTAMP, | ||
| 467 | &__get_cpu_var(mce_poll_banks)); | ||
| 368 | 468 | ||
| 369 | /* | 469 | /* |
| 370 | * Alert userspace if needed. If we logged an MCE, reduce the | 470 | * Alert userspace if needed. If we logged an MCE, reduce the |
| @@ -377,31 +477,41 @@ static void mcheck_timer(struct work_struct *work) | |||
| 377 | (int)round_jiffies_relative(check_interval*HZ)); | 477 | (int)round_jiffies_relative(check_interval*HZ)); |
| 378 | } | 478 | } |
| 379 | 479 | ||
| 380 | schedule_delayed_work(&mcheck_work, next_interval); | 480 | t->expires = jiffies + next_interval; |
| 481 | add_timer(t); | ||
| 482 | } | ||
| 483 | |||
| 484 | static void mce_do_trigger(struct work_struct *work) | ||
| 485 | { | ||
| 486 | call_usermodehelper(trigger, trigger_argv, NULL, UMH_NO_WAIT); | ||
| 381 | } | 487 | } |
| 382 | 488 | ||
| 489 | static DECLARE_WORK(mce_trigger_work, mce_do_trigger); | ||
| 490 | |||
| 383 | /* | 491 | /* |
| 384 | * This is only called from process context. This is where we do | 492 | * Notify the user(s) about new machine check events. |
| 385 | * anything we need to alert userspace about new MCEs. This is called | 493 | * Can be called from interrupt context, but not from machine check/NMI |
| 386 | * directly from the poller and also from entry.S and idle, thanks to | 494 | * context. |
| 387 | * TIF_MCE_NOTIFY. | ||
| 388 | */ | 495 | */ |
| 389 | int mce_notify_user(void) | 496 | int mce_notify_user(void) |
| 390 | { | 497 | { |
| 498 | /* Not more than two messages every minute */ | ||
| 499 | static DEFINE_RATELIMIT_STATE(ratelimit, 60*HZ, 2); | ||
| 500 | |||
| 391 | clear_thread_flag(TIF_MCE_NOTIFY); | 501 | clear_thread_flag(TIF_MCE_NOTIFY); |
| 392 | if (test_and_clear_bit(0, ¬ify_user)) { | 502 | if (test_and_clear_bit(0, ¬ify_user)) { |
| 393 | static unsigned long last_print; | ||
| 394 | unsigned long now = jiffies; | ||
| 395 | |||
| 396 | wake_up_interruptible(&mce_wait); | 503 | wake_up_interruptible(&mce_wait); |
| 397 | if (trigger[0]) | ||
| 398 | call_usermodehelper(trigger, trigger_argv, NULL, | ||
| 399 | UMH_NO_WAIT); | ||
| 400 | 504 | ||
| 401 | if (time_after_eq(now, last_print + (check_interval*HZ))) { | 505 | /* |
| 402 | last_print = now; | 506 | * There is no risk of missing notifications because |
| 507 | * work_pending is always cleared before the function is | ||
| 508 | * executed. | ||
| 509 | */ | ||
| 510 | if (trigger[0] && !work_pending(&mce_trigger_work)) | ||
| 511 | schedule_work(&mce_trigger_work); | ||
| 512 | |||
| 513 | if (__ratelimit(&ratelimit)) | ||
| 403 | printk(KERN_INFO "Machine check events logged\n"); | 514 | printk(KERN_INFO "Machine check events logged\n"); |
| 404 | } | ||
| 405 | 515 | ||
| 406 | return 1; | 516 | return 1; |
| 407 | } | 517 | } |
| @@ -425,63 +535,78 @@ static struct notifier_block mce_idle_notifier = { | |||
| 425 | 535 | ||
| 426 | static __init int periodic_mcheck_init(void) | 536 | static __init int periodic_mcheck_init(void) |
| 427 | { | 537 | { |
| 428 | next_interval = check_interval * HZ; | 538 | idle_notifier_register(&mce_idle_notifier); |
| 429 | if (next_interval) | 539 | return 0; |
| 430 | schedule_delayed_work(&mcheck_work, | ||
| 431 | round_jiffies_relative(next_interval)); | ||
| 432 | idle_notifier_register(&mce_idle_notifier); | ||
| 433 | return 0; | ||
| 434 | } | 540 | } |
| 435 | __initcall(periodic_mcheck_init); | 541 | __initcall(periodic_mcheck_init); |
| 436 | 542 | ||
| 437 | |||
| 438 | /* | 543 | /* |
| 439 | * Initialize Machine Checks for a CPU. | 544 | * Initialize Machine Checks for a CPU. |
| 440 | */ | 545 | */ |
| 441 | static void mce_init(void *dummy) | 546 | static int mce_cap_init(void) |
| 442 | { | 547 | { |
| 443 | u64 cap; | 548 | u64 cap; |
| 444 | int i; | 549 | unsigned b; |
| 445 | 550 | ||
| 446 | rdmsrl(MSR_IA32_MCG_CAP, cap); | 551 | rdmsrl(MSR_IA32_MCG_CAP, cap); |
| 447 | banks = cap & 0xff; | 552 | b = cap & 0xff; |
| 448 | if (banks > MCE_EXTENDED_BANK) { | 553 | if (b > MAX_NR_BANKS) { |
| 449 | banks = MCE_EXTENDED_BANK; | 554 | printk(KERN_WARNING |
| 450 | printk(KERN_INFO "MCE: warning: using only %d banks\n", | 555 | "MCE: Using only %u machine check banks out of %u\n", |
| 451 | MCE_EXTENDED_BANK); | 556 | MAX_NR_BANKS, b); |
| 557 | b = MAX_NR_BANKS; | ||
| 452 | } | 558 | } |
| 559 | |||
| 560 | /* Don't support asymmetric configurations today */ | ||
| 561 | WARN_ON(banks != 0 && b != banks); | ||
| 562 | banks = b; | ||
| 563 | if (!bank) { | ||
| 564 | bank = kmalloc(banks * sizeof(u64), GFP_KERNEL); | ||
| 565 | if (!bank) | ||
| 566 | return -ENOMEM; | ||
| 567 | memset(bank, 0xff, banks * sizeof(u64)); | ||
| 568 | } | ||
| 569 | |||
| 453 | /* Use accurate RIP reporting if available. */ | 570 | /* Use accurate RIP reporting if available. */ |
| 454 | if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9) | 571 | if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9) |
| 455 | rip_msr = MSR_IA32_MCG_EIP; | 572 | rip_msr = MSR_IA32_MCG_EIP; |
| 456 | 573 | ||
| 457 | /* Log the machine checks left over from the previous reset. | 574 | return 0; |
| 458 | This also clears all registers */ | 575 | } |
| 459 | do_machine_check(NULL, mce_bootlog ? -1 : -2); | 576 | |
| 577 | static void mce_init(void *dummy) | ||
| 578 | { | ||
| 579 | u64 cap; | ||
| 580 | int i; | ||
| 581 | mce_banks_t all_banks; | ||
| 582 | |||
| 583 | /* | ||
| 584 | * Log the machine checks left over from the previous reset. | ||
| 585 | */ | ||
| 586 | bitmap_fill(all_banks, MAX_NR_BANKS); | ||
| 587 | machine_check_poll(MCP_UC, &all_banks); | ||
| 460 | 588 | ||
| 461 | set_in_cr4(X86_CR4_MCE); | 589 | set_in_cr4(X86_CR4_MCE); |
| 462 | 590 | ||
| 591 | rdmsrl(MSR_IA32_MCG_CAP, cap); | ||
| 463 | if (cap & MCG_CTL_P) | 592 | if (cap & MCG_CTL_P) |
| 464 | wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff); | 593 | wrmsr(MSR_IA32_MCG_CTL, 0xffffffff, 0xffffffff); |
| 465 | 594 | ||
| 466 | for (i = 0; i < banks; i++) { | 595 | for (i = 0; i < banks; i++) { |
| 467 | if (i < NR_SYSFS_BANKS) | 596 | wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]); |
| 468 | wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]); | ||
| 469 | else | ||
| 470 | wrmsrl(MSR_IA32_MC0_CTL+4*i, ~0UL); | ||
| 471 | |||
| 472 | wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0); | 597 | wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0); |
| 473 | } | 598 | } |
| 474 | } | 599 | } |
| 475 | 600 | ||
| 476 | /* Add per CPU specific workarounds here */ | 601 | /* Add per CPU specific workarounds here */ |
| 477 | static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c) | 602 | static void mce_cpu_quirks(struct cpuinfo_x86 *c) |
| 478 | { | 603 | { |
| 479 | /* This should be disabled by the BIOS, but isn't always */ | 604 | /* This should be disabled by the BIOS, but isn't always */ |
| 480 | if (c->x86_vendor == X86_VENDOR_AMD) { | 605 | if (c->x86_vendor == X86_VENDOR_AMD) { |
| 481 | if(c->x86 == 15) | 606 | if (c->x86 == 15 && banks > 4) |
| 482 | /* disable GART TBL walk error reporting, which trips off | 607 | /* disable GART TBL walk error reporting, which trips off |
| 483 | incorrectly with the IOMMU & 3ware & Cerberus. */ | 608 | incorrectly with the IOMMU & 3ware & Cerberus. */ |
| 484 | clear_bit(10, &bank[4]); | 609 | clear_bit(10, (unsigned long *)&bank[4]); |
| 485 | if(c->x86 <= 17 && mce_bootlog < 0) | 610 | if(c->x86 <= 17 && mce_bootlog < 0) |
| 486 | /* Lots of broken BIOS around that don't clear them | 611 | /* Lots of broken BIOS around that don't clear them |
| 487 | by default and leave crap in there. Don't log. */ | 612 | by default and leave crap in there. Don't log. */ |
| @@ -504,20 +629,38 @@ static void mce_cpu_features(struct cpuinfo_x86 *c) | |||
| 504 | } | 629 | } |
| 505 | } | 630 | } |
| 506 | 631 | ||
| 632 | static void mce_init_timer(void) | ||
| 633 | { | ||
| 634 | struct timer_list *t = &__get_cpu_var(mce_timer); | ||
| 635 | |||
| 636 | /* data race harmless because everyone sets to the same value */ | ||
| 637 | if (!next_interval) | ||
| 638 | next_interval = check_interval * HZ; | ||
| 639 | if (!next_interval) | ||
| 640 | return; | ||
| 641 | setup_timer(t, mcheck_timer, smp_processor_id()); | ||
| 642 | t->expires = round_jiffies(jiffies + next_interval); | ||
| 643 | add_timer(t); | ||
| 644 | } | ||
| 645 | |||
| 507 | /* | 646 | /* |
| 508 | * Called for each booted CPU to set up machine checks. | 647 | * Called for each booted CPU to set up machine checks. |
| 509 | * Must be called with preempt off. | 648 | * Must be called with preempt off. |
| 510 | */ | 649 | */ |
| 511 | void __cpuinit mcheck_init(struct cpuinfo_x86 *c) | 650 | void __cpuinit mcheck_init(struct cpuinfo_x86 *c) |
| 512 | { | 651 | { |
| 513 | mce_cpu_quirks(c); | 652 | if (!mce_available(c)) |
| 653 | return; | ||
| 514 | 654 | ||
| 515 | if (mce_dont_init || | 655 | if (mce_cap_init() < 0) { |
| 516 | !mce_available(c)) | 656 | mce_dont_init = 1; |
| 517 | return; | 657 | return; |
| 658 | } | ||
| 659 | mce_cpu_quirks(c); | ||
| 518 | 660 | ||
| 519 | mce_init(NULL); | 661 | mce_init(NULL); |
| 520 | mce_cpu_features(c); | 662 | mce_cpu_features(c); |
| 663 | mce_init_timer(); | ||
| 521 | } | 664 | } |
| 522 | 665 | ||
| 523 | /* | 666 | /* |
| @@ -573,7 +716,7 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, | |||
| 573 | { | 716 | { |
| 574 | unsigned long *cpu_tsc; | 717 | unsigned long *cpu_tsc; |
| 575 | static DEFINE_MUTEX(mce_read_mutex); | 718 | static DEFINE_MUTEX(mce_read_mutex); |
| 576 | unsigned next; | 719 | unsigned prev, next; |
| 577 | char __user *buf = ubuf; | 720 | char __user *buf = ubuf; |
| 578 | int i, err; | 721 | int i, err; |
| 579 | 722 | ||
| @@ -592,25 +735,32 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, | |||
| 592 | } | 735 | } |
| 593 | 736 | ||
| 594 | err = 0; | 737 | err = 0; |
| 595 | for (i = 0; i < next; i++) { | 738 | prev = 0; |
| 596 | unsigned long start = jiffies; | 739 | do { |
| 597 | 740 | for (i = prev; i < next; i++) { | |
| 598 | while (!mcelog.entry[i].finished) { | 741 | unsigned long start = jiffies; |
| 599 | if (time_after_eq(jiffies, start + 2)) { | 742 | |
| 600 | memset(mcelog.entry + i,0, sizeof(struct mce)); | 743 | while (!mcelog.entry[i].finished) { |
| 601 | goto timeout; | 744 | if (time_after_eq(jiffies, start + 2)) { |
| 745 | memset(mcelog.entry + i, 0, | ||
| 746 | sizeof(struct mce)); | ||
| 747 | goto timeout; | ||
| 748 | } | ||
| 749 | cpu_relax(); | ||
| 602 | } | 750 | } |
| 603 | cpu_relax(); | 751 | smp_rmb(); |
| 752 | err |= copy_to_user(buf, mcelog.entry + i, | ||
| 753 | sizeof(struct mce)); | ||
| 754 | buf += sizeof(struct mce); | ||
| 755 | timeout: | ||
| 756 | ; | ||
| 604 | } | 757 | } |
| 605 | smp_rmb(); | ||
| 606 | err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce)); | ||
| 607 | buf += sizeof(struct mce); | ||
| 608 | timeout: | ||
| 609 | ; | ||
| 610 | } | ||
| 611 | 758 | ||
| 612 | memset(mcelog.entry, 0, next * sizeof(struct mce)); | 759 | memset(mcelog.entry + prev, 0, |
| 613 | mcelog.next = 0; | 760 | (next - prev) * sizeof(struct mce)); |
| 761 | prev = next; | ||
| 762 | next = cmpxchg(&mcelog.next, prev, 0); | ||
| 763 | } while (next != prev); | ||
| 614 | 764 | ||
| 615 | synchronize_sched(); | 765 | synchronize_sched(); |
| 616 | 766 | ||
| @@ -680,20 +830,6 @@ static struct miscdevice mce_log_device = { | |||
| 680 | &mce_chrdev_ops, | 830 | &mce_chrdev_ops, |
| 681 | }; | 831 | }; |
| 682 | 832 | ||
| 683 | static unsigned long old_cr4 __initdata; | ||
| 684 | |||
| 685 | void __init stop_mce(void) | ||
| 686 | { | ||
| 687 | old_cr4 = read_cr4(); | ||
| 688 | clear_in_cr4(X86_CR4_MCE); | ||
| 689 | } | ||
| 690 | |||
| 691 | void __init restart_mce(void) | ||
| 692 | { | ||
| 693 | if (old_cr4 & X86_CR4_MCE) | ||
| 694 | set_in_cr4(X86_CR4_MCE); | ||
| 695 | } | ||
| 696 | |||
| 697 | /* | 833 | /* |
| 698 | * Old style boot options parsing. Only for compatibility. | 834 | * Old style boot options parsing. Only for compatibility. |
| 699 | */ | 835 | */ |
| @@ -703,8 +839,7 @@ static int __init mcheck_disable(char *str) | |||
| 703 | return 1; | 839 | return 1; |
| 704 | } | 840 | } |
| 705 | 841 | ||
| 706 | /* mce=off disables machine check. Note you can re-enable it later | 842 | /* mce=off disables machine check. |
| 707 | using sysfs. | ||
| 708 | mce=TOLERANCELEVEL (number, see above) | 843 | mce=TOLERANCELEVEL (number, see above) |
| 709 | mce=bootlog Log MCEs from before booting. Disabled by default on AMD. | 844 | mce=bootlog Log MCEs from before booting. Disabled by default on AMD. |
| 710 | mce=nobootlog Don't log MCEs from before booting. */ | 845 | mce=nobootlog Don't log MCEs from before booting. */ |
| @@ -728,6 +863,29 @@ __setup("mce=", mcheck_enable); | |||
| 728 | * Sysfs support | 863 | * Sysfs support |
| 729 | */ | 864 | */ |
| 730 | 865 | ||
| 866 | /* | ||
| 867 | * Disable machine checks on suspend and shutdown. We can't really handle | ||
| 868 | * them later. | ||
| 869 | */ | ||
| 870 | static int mce_disable(void) | ||
| 871 | { | ||
| 872 | int i; | ||
| 873 | |||
| 874 | for (i = 0; i < banks; i++) | ||
| 875 | wrmsrl(MSR_IA32_MC0_CTL + i*4, 0); | ||
| 876 | return 0; | ||
| 877 | } | ||
| 878 | |||
| 879 | static int mce_suspend(struct sys_device *dev, pm_message_t state) | ||
| 880 | { | ||
| 881 | return mce_disable(); | ||
| 882 | } | ||
| 883 | |||
| 884 | static int mce_shutdown(struct sys_device *dev) | ||
| 885 | { | ||
| 886 | return mce_disable(); | ||
| 887 | } | ||
| 888 | |||
| 731 | /* On resume clear all MCE state. Don't want to see leftovers from the BIOS. | 889 | /* On resume clear all MCE state. Don't want to see leftovers from the BIOS. |
| 732 | Only one CPU is active at this time, the others get readded later using | 890 | Only one CPU is active at this time, the others get readded later using |
| 733 | CPU hotplug. */ | 891 | CPU hotplug. */ |
| @@ -738,20 +896,24 @@ static int mce_resume(struct sys_device *dev) | |||
| 738 | return 0; | 896 | return 0; |
| 739 | } | 897 | } |
| 740 | 898 | ||
| 899 | static void mce_cpu_restart(void *data) | ||
| 900 | { | ||
| 901 | del_timer_sync(&__get_cpu_var(mce_timer)); | ||
| 902 | if (mce_available(¤t_cpu_data)) | ||
| 903 | mce_init(NULL); | ||
| 904 | mce_init_timer(); | ||
| 905 | } | ||
| 906 | |||
| 741 | /* Reinit MCEs after user configuration changes */ | 907 | /* Reinit MCEs after user configuration changes */ |
| 742 | static void mce_restart(void) | 908 | static void mce_restart(void) |
| 743 | { | 909 | { |
| 744 | if (next_interval) | ||
| 745 | cancel_delayed_work(&mcheck_work); | ||
| 746 | /* Timer race is harmless here */ | ||
| 747 | on_each_cpu(mce_init, NULL, 1); | ||
| 748 | next_interval = check_interval * HZ; | 910 | next_interval = check_interval * HZ; |
| 749 | if (next_interval) | 911 | on_each_cpu(mce_cpu_restart, NULL, 1); |
| 750 | schedule_delayed_work(&mcheck_work, | ||
| 751 | round_jiffies_relative(next_interval)); | ||
| 752 | } | 912 | } |
| 753 | 913 | ||
| 754 | static struct sysdev_class mce_sysclass = { | 914 | static struct sysdev_class mce_sysclass = { |
| 915 | .suspend = mce_suspend, | ||
| 916 | .shutdown = mce_shutdown, | ||
| 755 | .resume = mce_resume, | 917 | .resume = mce_resume, |
| 756 | .name = "machinecheck", | 918 | .name = "machinecheck", |
| 757 | }; | 919 | }; |
| @@ -778,16 +940,26 @@ void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu) __cpuinit | |||
| 778 | } \ | 940 | } \ |
| 779 | static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name); | 941 | static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name); |
| 780 | 942 | ||
| 781 | /* | 943 | static struct sysdev_attribute *bank_attrs; |
| 782 | * TBD should generate these dynamically based on number of available banks. | 944 | |
| 783 | * Have only 6 contol banks in /sysfs until then. | 945 | static ssize_t show_bank(struct sys_device *s, struct sysdev_attribute *attr, |
| 784 | */ | 946 | char *buf) |
| 785 | ACCESSOR(bank0ctl,bank[0],mce_restart()) | 947 | { |
| 786 | ACCESSOR(bank1ctl,bank[1],mce_restart()) | 948 | u64 b = bank[attr - bank_attrs]; |
| 787 | ACCESSOR(bank2ctl,bank[2],mce_restart()) | 949 | return sprintf(buf, "%llx\n", b); |
| 788 | ACCESSOR(bank3ctl,bank[3],mce_restart()) | 950 | } |
| 789 | ACCESSOR(bank4ctl,bank[4],mce_restart()) | 951 | |
| 790 | ACCESSOR(bank5ctl,bank[5],mce_restart()) | 952 | static ssize_t set_bank(struct sys_device *s, struct sysdev_attribute *attr, |
| 953 | const char *buf, size_t siz) | ||
| 954 | { | ||
| 955 | char *end; | ||
| 956 | u64 new = simple_strtoull(buf, &end, 0); | ||
| 957 | if (end == buf) | ||
| 958 | return -EINVAL; | ||
| 959 | bank[attr - bank_attrs] = new; | ||
| 960 | mce_restart(); | ||
| 961 | return end-buf; | ||
| 962 | } | ||
| 791 | 963 | ||
| 792 | static ssize_t show_trigger(struct sys_device *s, struct sysdev_attribute *attr, | 964 | static ssize_t show_trigger(struct sys_device *s, struct sysdev_attribute *attr, |
| 793 | char *buf) | 965 | char *buf) |
| @@ -814,8 +986,6 @@ static SYSDEV_ATTR(trigger, 0644, show_trigger, set_trigger); | |||
| 814 | static SYSDEV_INT_ATTR(tolerant, 0644, tolerant); | 986 | static SYSDEV_INT_ATTR(tolerant, 0644, tolerant); |
| 815 | ACCESSOR(check_interval,check_interval,mce_restart()) | 987 | ACCESSOR(check_interval,check_interval,mce_restart()) |
| 816 | static struct sysdev_attribute *mce_attributes[] = { | 988 | static struct sysdev_attribute *mce_attributes[] = { |
| 817 | &attr_bank0ctl, &attr_bank1ctl, &attr_bank2ctl, | ||
| 818 | &attr_bank3ctl, &attr_bank4ctl, &attr_bank5ctl, | ||
| 819 | &attr_tolerant.attr, &attr_check_interval, &attr_trigger, | 989 | &attr_tolerant.attr, &attr_check_interval, &attr_trigger, |
| 820 | NULL | 990 | NULL |
| 821 | }; | 991 | }; |
| @@ -845,11 +1015,22 @@ static __cpuinit int mce_create_device(unsigned int cpu) | |||
| 845 | if (err) | 1015 | if (err) |
| 846 | goto error; | 1016 | goto error; |
| 847 | } | 1017 | } |
| 1018 | for (i = 0; i < banks; i++) { | ||
| 1019 | err = sysdev_create_file(&per_cpu(device_mce, cpu), | ||
| 1020 | &bank_attrs[i]); | ||
| 1021 | if (err) | ||
| 1022 | goto error2; | ||
| 1023 | } | ||
| 848 | cpu_set(cpu, mce_device_initialized); | 1024 | cpu_set(cpu, mce_device_initialized); |
| 849 | 1025 | ||
| 850 | return 0; | 1026 | return 0; |
| 1027 | error2: | ||
| 1028 | while (--i >= 0) { | ||
| 1029 | sysdev_remove_file(&per_cpu(device_mce, cpu), | ||
| 1030 | &bank_attrs[i]); | ||
| 1031 | } | ||
| 851 | error: | 1032 | error: |
| 852 | while (i--) { | 1033 | while (--i >= 0) { |
| 853 | sysdev_remove_file(&per_cpu(device_mce,cpu), | 1034 | sysdev_remove_file(&per_cpu(device_mce,cpu), |
| 854 | mce_attributes[i]); | 1035 | mce_attributes[i]); |
| 855 | } | 1036 | } |
| @@ -868,15 +1049,46 @@ static __cpuinit void mce_remove_device(unsigned int cpu) | |||
| 868 | for (i = 0; mce_attributes[i]; i++) | 1049 | for (i = 0; mce_attributes[i]; i++) |
| 869 | sysdev_remove_file(&per_cpu(device_mce,cpu), | 1050 | sysdev_remove_file(&per_cpu(device_mce,cpu), |
| 870 | mce_attributes[i]); | 1051 | mce_attributes[i]); |
| 1052 | for (i = 0; i < banks; i++) | ||
| 1053 | sysdev_remove_file(&per_cpu(device_mce, cpu), | ||
| 1054 | &bank_attrs[i]); | ||
| 871 | sysdev_unregister(&per_cpu(device_mce,cpu)); | 1055 | sysdev_unregister(&per_cpu(device_mce,cpu)); |
| 872 | cpu_clear(cpu, mce_device_initialized); | 1056 | cpu_clear(cpu, mce_device_initialized); |
| 873 | } | 1057 | } |
| 874 | 1058 | ||
| 1059 | /* Make sure there are no machine checks on offlined CPUs. */ | ||
| 1060 | static void mce_disable_cpu(void *h) | ||
| 1061 | { | ||
| 1062 | int i; | ||
| 1063 | unsigned long action = *(unsigned long *)h; | ||
| 1064 | |||
| 1065 | if (!mce_available(¤t_cpu_data)) | ||
| 1066 | return; | ||
| 1067 | if (!(action & CPU_TASKS_FROZEN)) | ||
| 1068 | cmci_clear(); | ||
| 1069 | for (i = 0; i < banks; i++) | ||
| 1070 | wrmsrl(MSR_IA32_MC0_CTL + i*4, 0); | ||
| 1071 | } | ||
| 1072 | |||
| 1073 | static void mce_reenable_cpu(void *h) | ||
| 1074 | { | ||
| 1075 | int i; | ||
| 1076 | unsigned long action = *(unsigned long *)h; | ||
| 1077 | |||
| 1078 | if (!mce_available(¤t_cpu_data)) | ||
| 1079 | return; | ||
| 1080 | if (!(action & CPU_TASKS_FROZEN)) | ||
| 1081 | cmci_reenable(); | ||
| 1082 | for (i = 0; i < banks; i++) | ||
| 1083 | wrmsrl(MSR_IA32_MC0_CTL + i*4, bank[i]); | ||
| 1084 | } | ||
| 1085 | |||
| 875 | /* Get notified when a cpu comes on/off. Be hotplug friendly. */ | 1086 | /* Get notified when a cpu comes on/off. Be hotplug friendly. */ |
| 876 | static int __cpuinit mce_cpu_callback(struct notifier_block *nfb, | 1087 | static int __cpuinit mce_cpu_callback(struct notifier_block *nfb, |
| 877 | unsigned long action, void *hcpu) | 1088 | unsigned long action, void *hcpu) |
| 878 | { | 1089 | { |
| 879 | unsigned int cpu = (unsigned long)hcpu; | 1090 | unsigned int cpu = (unsigned long)hcpu; |
| 1091 | struct timer_list *t = &per_cpu(mce_timer, cpu); | ||
| 880 | 1092 | ||
| 881 | switch (action) { | 1093 | switch (action) { |
| 882 | case CPU_ONLINE: | 1094 | case CPU_ONLINE: |
| @@ -891,6 +1103,21 @@ static int __cpuinit mce_cpu_callback(struct notifier_block *nfb, | |||
| 891 | threshold_cpu_callback(action, cpu); | 1103 | threshold_cpu_callback(action, cpu); |
| 892 | mce_remove_device(cpu); | 1104 | mce_remove_device(cpu); |
| 893 | break; | 1105 | break; |
| 1106 | case CPU_DOWN_PREPARE: | ||
| 1107 | case CPU_DOWN_PREPARE_FROZEN: | ||
| 1108 | del_timer_sync(t); | ||
| 1109 | smp_call_function_single(cpu, mce_disable_cpu, &action, 1); | ||
| 1110 | break; | ||
| 1111 | case CPU_DOWN_FAILED: | ||
| 1112 | case CPU_DOWN_FAILED_FROZEN: | ||
| 1113 | t->expires = round_jiffies(jiffies + next_interval); | ||
| 1114 | add_timer_on(t, cpu); | ||
| 1115 | smp_call_function_single(cpu, mce_reenable_cpu, &action, 1); | ||
| 1116 | break; | ||
| 1117 | case CPU_POST_DEAD: | ||
| 1118 | /* intentionally ignoring frozen here */ | ||
| 1119 | cmci_rediscover(cpu); | ||
| 1120 | break; | ||
| 894 | } | 1121 | } |
| 895 | return NOTIFY_OK; | 1122 | return NOTIFY_OK; |
| 896 | } | 1123 | } |
| @@ -899,6 +1126,34 @@ static struct notifier_block mce_cpu_notifier __cpuinitdata = { | |||
| 899 | .notifier_call = mce_cpu_callback, | 1126 | .notifier_call = mce_cpu_callback, |
| 900 | }; | 1127 | }; |
| 901 | 1128 | ||
| 1129 | static __init int mce_init_banks(void) | ||
| 1130 | { | ||
| 1131 | int i; | ||
| 1132 | |||
| 1133 | bank_attrs = kzalloc(sizeof(struct sysdev_attribute) * banks, | ||
| 1134 | GFP_KERNEL); | ||
| 1135 | if (!bank_attrs) | ||
| 1136 | return -ENOMEM; | ||
| 1137 | |||
| 1138 | for (i = 0; i < banks; i++) { | ||
| 1139 | struct sysdev_attribute *a = &bank_attrs[i]; | ||
| 1140 | a->attr.name = kasprintf(GFP_KERNEL, "bank%d", i); | ||
| 1141 | if (!a->attr.name) | ||
| 1142 | goto nomem; | ||
| 1143 | a->attr.mode = 0644; | ||
| 1144 | a->show = show_bank; | ||
| 1145 | a->store = set_bank; | ||
| 1146 | } | ||
| 1147 | return 0; | ||
| 1148 | |||
| 1149 | nomem: | ||
| 1150 | while (--i >= 0) | ||
| 1151 | kfree(bank_attrs[i].attr.name); | ||
| 1152 | kfree(bank_attrs); | ||
| 1153 | bank_attrs = NULL; | ||
| 1154 | return -ENOMEM; | ||
| 1155 | } | ||
| 1156 | |||
| 902 | static __init int mce_init_device(void) | 1157 | static __init int mce_init_device(void) |
| 903 | { | 1158 | { |
| 904 | int err; | 1159 | int err; |
| @@ -906,6 +1161,11 @@ static __init int mce_init_device(void) | |||
| 906 | 1161 | ||
| 907 | if (!mce_available(&boot_cpu_data)) | 1162 | if (!mce_available(&boot_cpu_data)) |
| 908 | return -EIO; | 1163 | return -EIO; |
| 1164 | |||
| 1165 | err = mce_init_banks(); | ||
| 1166 | if (err) | ||
| 1167 | return err; | ||
| 1168 | |||
| 909 | err = sysdev_class_register(&mce_sysclass); | 1169 | err = sysdev_class_register(&mce_sysclass); |
| 910 | if (err) | 1170 | if (err) |
| 911 | return err; | 1171 | return err; |
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c index 9817506dd469..7d01be868870 100644 --- a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c +++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c | |||
| @@ -79,6 +79,8 @@ static unsigned char shared_bank[NR_BANKS] = { | |||
| 79 | 79 | ||
| 80 | static DEFINE_PER_CPU(unsigned char, bank_map); /* see which banks are on */ | 80 | static DEFINE_PER_CPU(unsigned char, bank_map); /* see which banks are on */ |
| 81 | 81 | ||
| 82 | static void amd_threshold_interrupt(void); | ||
| 83 | |||
| 82 | /* | 84 | /* |
| 83 | * CPU Initialization | 85 | * CPU Initialization |
| 84 | */ | 86 | */ |
| @@ -90,7 +92,8 @@ struct thresh_restart { | |||
| 90 | }; | 92 | }; |
| 91 | 93 | ||
| 92 | /* must be called with correct cpu affinity */ | 94 | /* must be called with correct cpu affinity */ |
| 93 | static long threshold_restart_bank(void *_tr) | 95 | /* Called via smp_call_function_single() */ |
| 96 | static void threshold_restart_bank(void *_tr) | ||
| 94 | { | 97 | { |
| 95 | struct thresh_restart *tr = _tr; | 98 | struct thresh_restart *tr = _tr; |
| 96 | u32 mci_misc_hi, mci_misc_lo; | 99 | u32 mci_misc_hi, mci_misc_lo; |
| @@ -117,7 +120,6 @@ static long threshold_restart_bank(void *_tr) | |||
| 117 | 120 | ||
| 118 | mci_misc_hi |= MASK_COUNT_EN_HI; | 121 | mci_misc_hi |= MASK_COUNT_EN_HI; |
| 119 | wrmsr(tr->b->address, mci_misc_lo, mci_misc_hi); | 122 | wrmsr(tr->b->address, mci_misc_lo, mci_misc_hi); |
| 120 | return 0; | ||
| 121 | } | 123 | } |
| 122 | 124 | ||
| 123 | /* cpu init entry point, called from mce.c with preempt off */ | 125 | /* cpu init entry point, called from mce.c with preempt off */ |
| @@ -174,6 +176,8 @@ void mce_amd_feature_init(struct cpuinfo_x86 *c) | |||
| 174 | tr.reset = 0; | 176 | tr.reset = 0; |
| 175 | tr.old_limit = 0; | 177 | tr.old_limit = 0; |
| 176 | threshold_restart_bank(&tr); | 178 | threshold_restart_bank(&tr); |
| 179 | |||
| 180 | mce_threshold_vector = amd_threshold_interrupt; | ||
| 177 | } | 181 | } |
| 178 | } | 182 | } |
| 179 | } | 183 | } |
| @@ -187,19 +191,13 @@ void mce_amd_feature_init(struct cpuinfo_x86 *c) | |||
| 187 | * the interrupt goes off when error_count reaches threshold_limit. | 191 | * the interrupt goes off when error_count reaches threshold_limit. |
| 188 | * the handler will simply log mcelog w/ software defined bank number. | 192 | * the handler will simply log mcelog w/ software defined bank number. |
| 189 | */ | 193 | */ |
| 190 | asmlinkage void mce_threshold_interrupt(void) | 194 | static void amd_threshold_interrupt(void) |
| 191 | { | 195 | { |
| 192 | unsigned int bank, block; | 196 | unsigned int bank, block; |
| 193 | struct mce m; | 197 | struct mce m; |
| 194 | u32 low = 0, high = 0, address = 0; | 198 | u32 low = 0, high = 0, address = 0; |
| 195 | 199 | ||
| 196 | ack_APIC_irq(); | 200 | mce_setup(&m); |
| 197 | exit_idle(); | ||
| 198 | irq_enter(); | ||
| 199 | |||
| 200 | memset(&m, 0, sizeof(m)); | ||
| 201 | rdtscll(m.tsc); | ||
| 202 | m.cpu = smp_processor_id(); | ||
| 203 | 201 | ||
| 204 | /* assume first bank caused it */ | 202 | /* assume first bank caused it */ |
| 205 | for (bank = 0; bank < NR_BANKS; ++bank) { | 203 | for (bank = 0; bank < NR_BANKS; ++bank) { |
| @@ -233,7 +231,8 @@ asmlinkage void mce_threshold_interrupt(void) | |||
| 233 | 231 | ||
| 234 | /* Log the machine check that caused the threshold | 232 | /* Log the machine check that caused the threshold |
| 235 | event. */ | 233 | event. */ |
| 236 | do_machine_check(NULL, 0); | 234 | machine_check_poll(MCP_TIMESTAMP, |
| 235 | &__get_cpu_var(mce_poll_banks)); | ||
| 237 | 236 | ||
| 238 | if (high & MASK_OVERFLOW_HI) { | 237 | if (high & MASK_OVERFLOW_HI) { |
| 239 | rdmsrl(address, m.misc); | 238 | rdmsrl(address, m.misc); |
| @@ -243,13 +242,10 @@ asmlinkage void mce_threshold_interrupt(void) | |||
| 243 | + bank * NR_BLOCKS | 242 | + bank * NR_BLOCKS |
| 244 | + block; | 243 | + block; |
| 245 | mce_log(&m); | 244 | mce_log(&m); |
| 246 | goto out; | 245 | return; |
| 247 | } | 246 | } |
| 248 | } | 247 | } |
| 249 | } | 248 | } |
| 250 | out: | ||
| 251 | inc_irq_stat(irq_threshold_count); | ||
| 252 | irq_exit(); | ||
| 253 | } | 249 | } |
| 254 | 250 | ||
| 255 | /* | 251 | /* |
| @@ -283,7 +279,7 @@ static ssize_t store_interrupt_enable(struct threshold_block *b, | |||
| 283 | tr.b = b; | 279 | tr.b = b; |
| 284 | tr.reset = 0; | 280 | tr.reset = 0; |
| 285 | tr.old_limit = 0; | 281 | tr.old_limit = 0; |
| 286 | work_on_cpu(b->cpu, threshold_restart_bank, &tr); | 282 | smp_call_function_single(b->cpu, threshold_restart_bank, &tr, 1); |
| 287 | 283 | ||
| 288 | return end - buf; | 284 | return end - buf; |
| 289 | } | 285 | } |
| @@ -305,23 +301,32 @@ static ssize_t store_threshold_limit(struct threshold_block *b, | |||
| 305 | tr.b = b; | 301 | tr.b = b; |
| 306 | tr.reset = 0; | 302 | tr.reset = 0; |
| 307 | 303 | ||
| 308 | work_on_cpu(b->cpu, threshold_restart_bank, &tr); | 304 | smp_call_function_single(b->cpu, threshold_restart_bank, &tr, 1); |
| 309 | 305 | ||
| 310 | return end - buf; | 306 | return end - buf; |
| 311 | } | 307 | } |
| 312 | 308 | ||
| 313 | static long local_error_count(void *_b) | 309 | struct threshold_block_cross_cpu { |
| 310 | struct threshold_block *tb; | ||
| 311 | long retval; | ||
| 312 | }; | ||
| 313 | |||
| 314 | static void local_error_count_handler(void *_tbcc) | ||
| 314 | { | 315 | { |
| 315 | struct threshold_block *b = _b; | 316 | struct threshold_block_cross_cpu *tbcc = _tbcc; |
| 317 | struct threshold_block *b = tbcc->tb; | ||
| 316 | u32 low, high; | 318 | u32 low, high; |
| 317 | 319 | ||
| 318 | rdmsr(b->address, low, high); | 320 | rdmsr(b->address, low, high); |
| 319 | return (high & 0xFFF) - (THRESHOLD_MAX - b->threshold_limit); | 321 | tbcc->retval = (high & 0xFFF) - (THRESHOLD_MAX - b->threshold_limit); |
| 320 | } | 322 | } |
| 321 | 323 | ||
| 322 | static ssize_t show_error_count(struct threshold_block *b, char *buf) | 324 | static ssize_t show_error_count(struct threshold_block *b, char *buf) |
| 323 | { | 325 | { |
| 324 | return sprintf(buf, "%lx\n", work_on_cpu(b->cpu, local_error_count, b)); | 326 | struct threshold_block_cross_cpu tbcc = { .tb = b, }; |
| 327 | |||
| 328 | smp_call_function_single(b->cpu, local_error_count_handler, &tbcc, 1); | ||
| 329 | return sprintf(buf, "%lx\n", tbcc.retval); | ||
| 325 | } | 330 | } |
| 326 | 331 | ||
| 327 | static ssize_t store_error_count(struct threshold_block *b, | 332 | static ssize_t store_error_count(struct threshold_block *b, |
| @@ -329,7 +334,7 @@ static ssize_t store_error_count(struct threshold_block *b, | |||
| 329 | { | 334 | { |
| 330 | struct thresh_restart tr = { .b = b, .reset = 1, .old_limit = 0 }; | 335 | struct thresh_restart tr = { .b = b, .reset = 1, .old_limit = 0 }; |
| 331 | 336 | ||
| 332 | work_on_cpu(b->cpu, threshold_restart_bank, &tr); | 337 | smp_call_function_single(b->cpu, threshold_restart_bank, &tr, 1); |
| 333 | return 1; | 338 | return 1; |
| 334 | } | 339 | } |
| 335 | 340 | ||
| @@ -398,7 +403,7 @@ static __cpuinit int allocate_threshold_blocks(unsigned int cpu, | |||
| 398 | if ((bank >= NR_BANKS) || (block >= NR_BLOCKS)) | 403 | if ((bank >= NR_BANKS) || (block >= NR_BLOCKS)) |
| 399 | return 0; | 404 | return 0; |
| 400 | 405 | ||
| 401 | if (rdmsr_safe(address, &low, &high)) | 406 | if (rdmsr_safe_on_cpu(cpu, address, &low, &high)) |
| 402 | return 0; | 407 | return 0; |
| 403 | 408 | ||
| 404 | if (!(high & MASK_VALID_HI)) { | 409 | if (!(high & MASK_VALID_HI)) { |
| @@ -462,12 +467,11 @@ out_free: | |||
| 462 | return err; | 467 | return err; |
| 463 | } | 468 | } |
| 464 | 469 | ||
| 465 | static __cpuinit long local_allocate_threshold_blocks(void *_bank) | 470 | static __cpuinit long |
| 471 | local_allocate_threshold_blocks(int cpu, unsigned int bank) | ||
| 466 | { | 472 | { |
| 467 | unsigned int *bank = _bank; | 473 | return allocate_threshold_blocks(cpu, bank, 0, |
| 468 | 474 | MSR_IA32_MC0_MISC + bank * 4); | |
| 469 | return allocate_threshold_blocks(smp_processor_id(), *bank, 0, | ||
| 470 | MSR_IA32_MC0_MISC + *bank * 4); | ||
| 471 | } | 475 | } |
| 472 | 476 | ||
| 473 | /* symlinks sibling shared banks to first core. first core owns dir/files. */ | 477 | /* symlinks sibling shared banks to first core. first core owns dir/files. */ |
| @@ -530,7 +534,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank) | |||
| 530 | 534 | ||
| 531 | per_cpu(threshold_banks, cpu)[bank] = b; | 535 | per_cpu(threshold_banks, cpu)[bank] = b; |
| 532 | 536 | ||
| 533 | err = work_on_cpu(cpu, local_allocate_threshold_blocks, &bank); | 537 | err = local_allocate_threshold_blocks(cpu, bank); |
| 534 | if (err) | 538 | if (err) |
| 535 | goto out_free; | 539 | goto out_free; |
| 536 | 540 | ||
diff --git a/arch/x86/kernel/cpu/mcheck/mce_intel_64.c b/arch/x86/kernel/cpu/mcheck/mce_intel_64.c index aa5e287c98e0..57df3d383470 100644 --- a/arch/x86/kernel/cpu/mcheck/mce_intel_64.c +++ b/arch/x86/kernel/cpu/mcheck/mce_intel_64.c | |||
| @@ -1,6 +1,8 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * Intel specific MCE features. | 2 | * Intel specific MCE features. |
| 3 | * Copyright 2004 Zwane Mwaikambo <zwane@linuxpower.ca> | 3 | * Copyright 2004 Zwane Mwaikambo <zwane@linuxpower.ca> |
| 4 | * Copyright (C) 2008, 2009 Intel Corporation | ||
| 5 | * Author: Andi Kleen | ||
| 4 | */ | 6 | */ |
| 5 | 7 | ||
| 6 | #include <linux/init.h> | 8 | #include <linux/init.h> |
| @@ -13,6 +15,7 @@ | |||
| 13 | #include <asm/hw_irq.h> | 15 | #include <asm/hw_irq.h> |
| 14 | #include <asm/idle.h> | 16 | #include <asm/idle.h> |
| 15 | #include <asm/therm_throt.h> | 17 | #include <asm/therm_throt.h> |
| 18 | #include <asm/apic.h> | ||
| 16 | 19 | ||
| 17 | asmlinkage void smp_thermal_interrupt(void) | 20 | asmlinkage void smp_thermal_interrupt(void) |
| 18 | { | 21 | { |
| @@ -25,7 +28,7 @@ asmlinkage void smp_thermal_interrupt(void) | |||
| 25 | 28 | ||
| 26 | rdmsrl(MSR_IA32_THERM_STATUS, msr_val); | 29 | rdmsrl(MSR_IA32_THERM_STATUS, msr_val); |
| 27 | if (therm_throt_process(msr_val & 1)) | 30 | if (therm_throt_process(msr_val & 1)) |
| 28 | mce_log_therm_throt_event(smp_processor_id(), msr_val); | 31 | mce_log_therm_throt_event(msr_val); |
| 29 | 32 | ||
| 30 | inc_irq_stat(irq_thermal_count); | 33 | inc_irq_stat(irq_thermal_count); |
| 31 | irq_exit(); | 34 | irq_exit(); |
| @@ -85,7 +88,209 @@ static void intel_init_thermal(struct cpuinfo_x86 *c) | |||
| 85 | return; | 88 | return; |
| 86 | } | 89 | } |
| 87 | 90 | ||
| 91 | /* | ||
| 92 | * Support for Intel Correct Machine Check Interrupts. This allows | ||
| 93 | * the CPU to raise an interrupt when a corrected machine check happened. | ||
| 94 | * Normally we pick those up using a regular polling timer. | ||
| 95 | * Also supports reliable discovery of shared banks. | ||
| 96 | */ | ||
| 97 | |||
| 98 | static DEFINE_PER_CPU(mce_banks_t, mce_banks_owned); | ||
| 99 | |||
| 100 | /* | ||
| 101 | * cmci_discover_lock protects against parallel discovery attempts | ||
| 102 | * which could race against each other. | ||
| 103 | */ | ||
| 104 | static DEFINE_SPINLOCK(cmci_discover_lock); | ||
| 105 | |||
| 106 | #define CMCI_THRESHOLD 1 | ||
| 107 | |||
| 108 | static int cmci_supported(int *banks) | ||
| 109 | { | ||
| 110 | u64 cap; | ||
| 111 | |||
| 112 | /* | ||
| 113 | * Vendor check is not strictly needed, but the initial | ||
| 114 | * initialization is vendor keyed and this | ||
| 115 | * makes sure none of the backdoors are entered otherwise. | ||
| 116 | */ | ||
| 117 | if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) | ||
| 118 | return 0; | ||
| 119 | if (!cpu_has_apic || lapic_get_maxlvt() < 6) | ||
| 120 | return 0; | ||
| 121 | rdmsrl(MSR_IA32_MCG_CAP, cap); | ||
| 122 | *banks = min_t(unsigned, MAX_NR_BANKS, cap & 0xff); | ||
| 123 | return !!(cap & MCG_CMCI_P); | ||
| 124 | } | ||
| 125 | |||
| 126 | /* | ||
| 127 | * The interrupt handler. This is called on every event. | ||
| 128 | * Just call the poller directly to log any events. | ||
| 129 | * This could in theory increase the threshold under high load, | ||
| 130 | * but doesn't for now. | ||
| 131 | */ | ||
| 132 | static void intel_threshold_interrupt(void) | ||
| 133 | { | ||
| 134 | machine_check_poll(MCP_TIMESTAMP, &__get_cpu_var(mce_banks_owned)); | ||
| 135 | mce_notify_user(); | ||
| 136 | } | ||
| 137 | |||
| 138 | static void print_update(char *type, int *hdr, int num) | ||
| 139 | { | ||
| 140 | if (*hdr == 0) | ||
| 141 | printk(KERN_INFO "CPU %d MCA banks", smp_processor_id()); | ||
| 142 | *hdr = 1; | ||
| 143 | printk(KERN_CONT " %s:%d", type, num); | ||
| 144 | } | ||
| 145 | |||
| 146 | /* | ||
| 147 | * Enable CMCI (Corrected Machine Check Interrupt) for available MCE banks | ||
| 148 | * on this CPU. Use the algorithm recommended in the SDM to discover shared | ||
| 149 | * banks. | ||
| 150 | */ | ||
| 151 | static void cmci_discover(int banks, int boot) | ||
| 152 | { | ||
| 153 | unsigned long *owned = (void *)&__get_cpu_var(mce_banks_owned); | ||
| 154 | int hdr = 0; | ||
| 155 | int i; | ||
| 156 | |||
| 157 | spin_lock(&cmci_discover_lock); | ||
| 158 | for (i = 0; i < banks; i++) { | ||
| 159 | u64 val; | ||
| 160 | |||
| 161 | if (test_bit(i, owned)) | ||
| 162 | continue; | ||
| 163 | |||
| 164 | rdmsrl(MSR_IA32_MC0_CTL2 + i, val); | ||
| 165 | |||
| 166 | /* Already owned by someone else? */ | ||
| 167 | if (val & CMCI_EN) { | ||
| 168 | if (test_and_clear_bit(i, owned) || boot) | ||
| 169 | print_update("SHD", &hdr, i); | ||
| 170 | __clear_bit(i, __get_cpu_var(mce_poll_banks)); | ||
| 171 | continue; | ||
| 172 | } | ||
| 173 | |||
| 174 | val |= CMCI_EN | CMCI_THRESHOLD; | ||
| 175 | wrmsrl(MSR_IA32_MC0_CTL2 + i, val); | ||
| 176 | rdmsrl(MSR_IA32_MC0_CTL2 + i, val); | ||
| 177 | |||
| 178 | /* Did the enable bit stick? -- the bank supports CMCI */ | ||
| 179 | if (val & CMCI_EN) { | ||
| 180 | if (!test_and_set_bit(i, owned) || boot) | ||
| 181 | print_update("CMCI", &hdr, i); | ||
| 182 | __clear_bit(i, __get_cpu_var(mce_poll_banks)); | ||
| 183 | } else { | ||
| 184 | WARN_ON(!test_bit(i, __get_cpu_var(mce_poll_banks))); | ||
| 185 | } | ||
| 186 | } | ||
| 187 | spin_unlock(&cmci_discover_lock); | ||
| 188 | if (hdr) | ||
| 189 | printk(KERN_CONT "\n"); | ||
| 190 | } | ||
| 191 | |||
| 192 | /* | ||
| 193 | * Just in case we missed an event during initialization check | ||
| 194 | * all the CMCI owned banks. | ||
| 195 | */ | ||
| 196 | void cmci_recheck(void) | ||
| 197 | { | ||
| 198 | unsigned long flags; | ||
| 199 | int banks; | ||
| 200 | |||
| 201 | if (!mce_available(¤t_cpu_data) || !cmci_supported(&banks)) | ||
| 202 | return; | ||
| 203 | local_irq_save(flags); | ||
| 204 | machine_check_poll(MCP_TIMESTAMP, &__get_cpu_var(mce_banks_owned)); | ||
| 205 | local_irq_restore(flags); | ||
| 206 | } | ||
| 207 | |||
| 208 | /* | ||
| 209 | * Disable CMCI on this CPU for all banks it owns when it goes down. | ||
| 210 | * This allows other CPUs to claim the banks on rediscovery. | ||
| 211 | */ | ||
| 212 | void cmci_clear(void) | ||
| 213 | { | ||
| 214 | int i; | ||
| 215 | int banks; | ||
| 216 | u64 val; | ||
| 217 | |||
| 218 | if (!cmci_supported(&banks)) | ||
| 219 | return; | ||
| 220 | spin_lock(&cmci_discover_lock); | ||
| 221 | for (i = 0; i < banks; i++) { | ||
| 222 | if (!test_bit(i, __get_cpu_var(mce_banks_owned))) | ||
| 223 | continue; | ||
| 224 | /* Disable CMCI */ | ||
| 225 | rdmsrl(MSR_IA32_MC0_CTL2 + i, val); | ||
| 226 | val &= ~(CMCI_EN|CMCI_THRESHOLD_MASK); | ||
| 227 | wrmsrl(MSR_IA32_MC0_CTL2 + i, val); | ||
| 228 | __clear_bit(i, __get_cpu_var(mce_banks_owned)); | ||
| 229 | } | ||
| 230 | spin_unlock(&cmci_discover_lock); | ||
| 231 | } | ||
| 232 | |||
| 233 | /* | ||
| 234 | * After a CPU went down cycle through all the others and rediscover | ||
| 235 | * Must run in process context. | ||
| 236 | */ | ||
| 237 | void cmci_rediscover(int dying) | ||
| 238 | { | ||
| 239 | int banks; | ||
| 240 | int cpu; | ||
| 241 | cpumask_var_t old; | ||
| 242 | |||
| 243 | if (!cmci_supported(&banks)) | ||
| 244 | return; | ||
| 245 | if (!alloc_cpumask_var(&old, GFP_KERNEL)) | ||
| 246 | return; | ||
| 247 | cpumask_copy(old, ¤t->cpus_allowed); | ||
| 248 | |||
| 249 | for_each_online_cpu (cpu) { | ||
| 250 | if (cpu == dying) | ||
| 251 | continue; | ||
| 252 | if (set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu))) | ||
| 253 | continue; | ||
| 254 | /* Recheck banks in case CPUs don't all have the same */ | ||
| 255 | if (cmci_supported(&banks)) | ||
| 256 | cmci_discover(banks, 0); | ||
| 257 | } | ||
| 258 | |||
| 259 | set_cpus_allowed_ptr(current, old); | ||
| 260 | free_cpumask_var(old); | ||
| 261 | } | ||
| 262 | |||
| 263 | /* | ||
| 264 | * Reenable CMCI on this CPU in case a CPU down failed. | ||
| 265 | */ | ||
| 266 | void cmci_reenable(void) | ||
| 267 | { | ||
| 268 | int banks; | ||
| 269 | if (cmci_supported(&banks)) | ||
| 270 | cmci_discover(banks, 0); | ||
| 271 | } | ||
| 272 | |||
| 273 | static void intel_init_cmci(void) | ||
| 274 | { | ||
| 275 | int banks; | ||
| 276 | |||
| 277 | if (!cmci_supported(&banks)) | ||
| 278 | return; | ||
| 279 | |||
| 280 | mce_threshold_vector = intel_threshold_interrupt; | ||
| 281 | cmci_discover(banks, 1); | ||
| 282 | /* | ||
| 283 | * For CPU #0 this runs with still disabled APIC, but that's | ||
| 284 | * ok because only the vector is set up. We still do another | ||
| 285 | * check for the banks later for CPU #0 just to make sure | ||
| 286 | * to not miss any events. | ||
| 287 | */ | ||
| 288 | apic_write(APIC_LVTCMCI, THRESHOLD_APIC_VECTOR|APIC_DM_FIXED); | ||
| 289 | cmci_recheck(); | ||
| 290 | } | ||
| 291 | |||
| 88 | void mce_intel_feature_init(struct cpuinfo_x86 *c) | 292 | void mce_intel_feature_init(struct cpuinfo_x86 *c) |
| 89 | { | 293 | { |
| 90 | intel_init_thermal(c); | 294 | intel_init_thermal(c); |
| 295 | intel_init_cmci(); | ||
| 91 | } | 296 | } |
diff --git a/arch/x86/kernel/cpu/mcheck/threshold.c b/arch/x86/kernel/cpu/mcheck/threshold.c new file mode 100644 index 000000000000..23ee9e730f78 --- /dev/null +++ b/arch/x86/kernel/cpu/mcheck/threshold.c | |||
| @@ -0,0 +1,29 @@ | |||
| 1 | /* | ||
| 2 | * Common corrected MCE threshold handler code: | ||
| 3 | */ | ||
| 4 | #include <linux/interrupt.h> | ||
| 5 | #include <linux/kernel.h> | ||
| 6 | |||
| 7 | #include <asm/irq_vectors.h> | ||
| 8 | #include <asm/apic.h> | ||
| 9 | #include <asm/idle.h> | ||
| 10 | #include <asm/mce.h> | ||
| 11 | |||
| 12 | static void default_threshold_interrupt(void) | ||
| 13 | { | ||
| 14 | printk(KERN_ERR "Unexpected threshold interrupt at vector %x\n", | ||
| 15 | THRESHOLD_APIC_VECTOR); | ||
| 16 | } | ||
| 17 | |||
| 18 | void (*mce_threshold_vector)(void) = default_threshold_interrupt; | ||
| 19 | |||
| 20 | asmlinkage void mce_threshold_interrupt(void) | ||
| 21 | { | ||
| 22 | exit_idle(); | ||
| 23 | irq_enter(); | ||
| 24 | inc_irq_stat(irq_threshold_count); | ||
| 25 | mce_threshold_vector(); | ||
| 26 | irq_exit(); | ||
| 27 | /* Ack only at the end to avoid potential reentry */ | ||
| 28 | ack_APIC_irq(); | ||
| 29 | } | ||
diff --git a/arch/x86/kernel/cpu/mtrr/Makefile b/arch/x86/kernel/cpu/mtrr/Makefile index 191fc0533649..f4361b56f8e9 100644 --- a/arch/x86/kernel/cpu/mtrr/Makefile +++ b/arch/x86/kernel/cpu/mtrr/Makefile | |||
| @@ -1,3 +1,3 @@ | |||
| 1 | obj-y := main.o if.o generic.o state.o | 1 | obj-y := main.o if.o generic.o state.o cleanup.o |
| 2 | obj-$(CONFIG_X86_32) += amd.o cyrix.o centaur.o | 2 | obj-$(CONFIG_X86_32) += amd.o cyrix.o centaur.o |
| 3 | 3 | ||
diff --git a/arch/x86/kernel/cpu/mtrr/cleanup.c b/arch/x86/kernel/cpu/mtrr/cleanup.c new file mode 100644 index 000000000000..ce0fe4b5c04f --- /dev/null +++ b/arch/x86/kernel/cpu/mtrr/cleanup.c | |||
| @@ -0,0 +1,1101 @@ | |||
| 1 | /* MTRR (Memory Type Range Register) cleanup | ||
| 2 | |||
| 3 | Copyright (C) 2009 Yinghai Lu | ||
| 4 | |||
| 5 | This library is free software; you can redistribute it and/or | ||
| 6 | modify it under the terms of the GNU Library General Public | ||
| 7 | License as published by the Free Software Foundation; either | ||
| 8 | version 2 of the License, or (at your option) any later version. | ||
| 9 | |||
| 10 | This library is distributed in the hope that it will be useful, | ||
| 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 13 | Library General Public License for more details. | ||
| 14 | |||
| 15 | You should have received a copy of the GNU Library General Public | ||
| 16 | License along with this library; if not, write to the Free | ||
| 17 | Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 18 | */ | ||
| 19 | |||
| 20 | #include <linux/module.h> | ||
| 21 | #include <linux/init.h> | ||
| 22 | #include <linux/pci.h> | ||
| 23 | #include <linux/smp.h> | ||
| 24 | #include <linux/cpu.h> | ||
| 25 | #include <linux/mutex.h> | ||
| 26 | #include <linux/sort.h> | ||
| 27 | |||
| 28 | #include <asm/e820.h> | ||
| 29 | #include <asm/mtrr.h> | ||
| 30 | #include <asm/uaccess.h> | ||
| 31 | #include <asm/processor.h> | ||
| 32 | #include <asm/msr.h> | ||
| 33 | #include <asm/kvm_para.h> | ||
| 34 | #include "mtrr.h" | ||
| 35 | |||
| 36 | /* should be related to MTRR_VAR_RANGES nums */ | ||
| 37 | #define RANGE_NUM 256 | ||
| 38 | |||
| 39 | struct res_range { | ||
| 40 | unsigned long start; | ||
| 41 | unsigned long end; | ||
| 42 | }; | ||
| 43 | |||
| 44 | static int __init | ||
| 45 | add_range(struct res_range *range, int nr_range, unsigned long start, | ||
| 46 | unsigned long end) | ||
| 47 | { | ||
| 48 | /* out of slots */ | ||
| 49 | if (nr_range >= RANGE_NUM) | ||
| 50 | return nr_range; | ||
| 51 | |||
| 52 | range[nr_range].start = start; | ||
| 53 | range[nr_range].end = end; | ||
| 54 | |||
| 55 | nr_range++; | ||
| 56 | |||
| 57 | return nr_range; | ||
| 58 | } | ||
| 59 | |||
| 60 | static int __init | ||
| 61 | add_range_with_merge(struct res_range *range, int nr_range, unsigned long start, | ||
| 62 | unsigned long end) | ||
| 63 | { | ||
| 64 | int i; | ||
| 65 | |||
| 66 | /* try to merge it with old one */ | ||
| 67 | for (i = 0; i < nr_range; i++) { | ||
| 68 | unsigned long final_start, final_end; | ||
| 69 | unsigned long common_start, common_end; | ||
| 70 | |||
| 71 | if (!range[i].end) | ||
| 72 | continue; | ||
| 73 | |||
| 74 | common_start = max(range[i].start, start); | ||
| 75 | common_end = min(range[i].end, end); | ||
| 76 | if (common_start > common_end + 1) | ||
| 77 | continue; | ||
| 78 | |||
| 79 | final_start = min(range[i].start, start); | ||
| 80 | final_end = max(range[i].end, end); | ||
| 81 | |||
| 82 | range[i].start = final_start; | ||
| 83 | range[i].end = final_end; | ||
| 84 | return nr_range; | ||
| 85 | } | ||
| 86 | |||
| 87 | /* need to add that */ | ||
| 88 | return add_range(range, nr_range, start, end); | ||
| 89 | } | ||
| 90 | |||
| 91 | static void __init | ||
| 92 | subtract_range(struct res_range *range, unsigned long start, unsigned long end) | ||
| 93 | { | ||
| 94 | int i, j; | ||
| 95 | |||
| 96 | for (j = 0; j < RANGE_NUM; j++) { | ||
| 97 | if (!range[j].end) | ||
| 98 | continue; | ||
| 99 | |||
| 100 | if (start <= range[j].start && end >= range[j].end) { | ||
| 101 | range[j].start = 0; | ||
| 102 | range[j].end = 0; | ||
| 103 | continue; | ||
| 104 | } | ||
| 105 | |||
| 106 | if (start <= range[j].start && end < range[j].end && | ||
| 107 | range[j].start < end + 1) { | ||
| 108 | range[j].start = end + 1; | ||
| 109 | continue; | ||
| 110 | } | ||
| 111 | |||
| 112 | |||
| 113 | if (start > range[j].start && end >= range[j].end && | ||
| 114 | range[j].end > start - 1) { | ||
| 115 | range[j].end = start - 1; | ||
| 116 | continue; | ||
| 117 | } | ||
| 118 | |||
| 119 | if (start > range[j].start && end < range[j].end) { | ||
| 120 | /* find the new spare */ | ||
| 121 | for (i = 0; i < RANGE_NUM; i++) { | ||
| 122 | if (range[i].end == 0) | ||
| 123 | break; | ||
| 124 | } | ||
| 125 | if (i < RANGE_NUM) { | ||
| 126 | range[i].end = range[j].end; | ||
| 127 | range[i].start = end + 1; | ||
| 128 | } else { | ||
| 129 | printk(KERN_ERR "run of slot in ranges\n"); | ||
| 130 | } | ||
| 131 | range[j].end = start - 1; | ||
| 132 | continue; | ||
| 133 | } | ||
| 134 | } | ||
| 135 | } | ||
| 136 | |||
| 137 | static int __init cmp_range(const void *x1, const void *x2) | ||
| 138 | { | ||
| 139 | const struct res_range *r1 = x1; | ||
| 140 | const struct res_range *r2 = x2; | ||
| 141 | long start1, start2; | ||
| 142 | |||
| 143 | start1 = r1->start; | ||
| 144 | start2 = r2->start; | ||
| 145 | |||
| 146 | return start1 - start2; | ||
| 147 | } | ||
| 148 | |||
| 149 | struct var_mtrr_range_state { | ||
| 150 | unsigned long base_pfn; | ||
| 151 | unsigned long size_pfn; | ||
| 152 | mtrr_type type; | ||
| 153 | }; | ||
| 154 | |||
| 155 | static struct var_mtrr_range_state __initdata range_state[RANGE_NUM]; | ||
| 156 | static int __initdata debug_print; | ||
| 157 | |||
| 158 | static int __init | ||
| 159 | x86_get_mtrr_mem_range(struct res_range *range, int nr_range, | ||
| 160 | unsigned long extra_remove_base, | ||
| 161 | unsigned long extra_remove_size) | ||
| 162 | { | ||
| 163 | unsigned long base, size; | ||
| 164 | mtrr_type type; | ||
| 165 | int i; | ||
| 166 | |||
| 167 | for (i = 0; i < num_var_ranges; i++) { | ||
| 168 | type = range_state[i].type; | ||
| 169 | if (type != MTRR_TYPE_WRBACK) | ||
| 170 | continue; | ||
| 171 | base = range_state[i].base_pfn; | ||
| 172 | size = range_state[i].size_pfn; | ||
| 173 | nr_range = add_range_with_merge(range, nr_range, base, | ||
| 174 | base + size - 1); | ||
| 175 | } | ||
| 176 | if (debug_print) { | ||
| 177 | printk(KERN_DEBUG "After WB checking\n"); | ||
| 178 | for (i = 0; i < nr_range; i++) | ||
| 179 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 180 | range[i].start, range[i].end + 1); | ||
| 181 | } | ||
| 182 | |||
| 183 | /* take out UC ranges */ | ||
| 184 | for (i = 0; i < num_var_ranges; i++) { | ||
| 185 | type = range_state[i].type; | ||
| 186 | if (type != MTRR_TYPE_UNCACHABLE && | ||
| 187 | type != MTRR_TYPE_WRPROT) | ||
| 188 | continue; | ||
| 189 | size = range_state[i].size_pfn; | ||
| 190 | if (!size) | ||
| 191 | continue; | ||
| 192 | base = range_state[i].base_pfn; | ||
| 193 | if (base < (1<<(20-PAGE_SHIFT)) && mtrr_state.have_fixed && | ||
| 194 | (mtrr_state.enabled & 1)) { | ||
| 195 | /* Var MTRR contains UC entry below 1M? Skip it: */ | ||
| 196 | printk(KERN_WARNING "WARNING: BIOS bug: VAR MTRR %d " | ||
| 197 | "contains strange UC entry under 1M, check " | ||
| 198 | "with your system vendor!\n", i); | ||
| 199 | if (base + size <= (1<<(20-PAGE_SHIFT))) | ||
| 200 | continue; | ||
| 201 | size -= (1<<(20-PAGE_SHIFT)) - base; | ||
| 202 | base = 1<<(20-PAGE_SHIFT); | ||
| 203 | } | ||
| 204 | subtract_range(range, base, base + size - 1); | ||
| 205 | } | ||
| 206 | if (extra_remove_size) | ||
| 207 | subtract_range(range, extra_remove_base, | ||
| 208 | extra_remove_base + extra_remove_size - 1); | ||
| 209 | |||
| 210 | /* get new range num */ | ||
| 211 | nr_range = 0; | ||
| 212 | for (i = 0; i < RANGE_NUM; i++) { | ||
| 213 | if (!range[i].end) | ||
| 214 | continue; | ||
| 215 | nr_range++; | ||
| 216 | } | ||
| 217 | if (debug_print) { | ||
| 218 | printk(KERN_DEBUG "After UC checking\n"); | ||
| 219 | for (i = 0; i < nr_range; i++) | ||
| 220 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 221 | range[i].start, range[i].end + 1); | ||
| 222 | } | ||
| 223 | |||
| 224 | /* sort the ranges */ | ||
| 225 | sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL); | ||
| 226 | if (debug_print) { | ||
| 227 | printk(KERN_DEBUG "After sorting\n"); | ||
| 228 | for (i = 0; i < nr_range; i++) | ||
| 229 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 230 | range[i].start, range[i].end + 1); | ||
| 231 | } | ||
| 232 | |||
| 233 | /* clear those is not used */ | ||
| 234 | for (i = nr_range; i < RANGE_NUM; i++) | ||
| 235 | memset(&range[i], 0, sizeof(range[i])); | ||
| 236 | |||
| 237 | return nr_range; | ||
| 238 | } | ||
| 239 | |||
| 240 | static struct res_range __initdata range[RANGE_NUM]; | ||
| 241 | static int __initdata nr_range; | ||
| 242 | |||
| 243 | #ifdef CONFIG_MTRR_SANITIZER | ||
| 244 | |||
| 245 | static unsigned long __init sum_ranges(struct res_range *range, int nr_range) | ||
| 246 | { | ||
| 247 | unsigned long sum; | ||
| 248 | int i; | ||
| 249 | |||
| 250 | sum = 0; | ||
| 251 | for (i = 0; i < nr_range; i++) | ||
| 252 | sum += range[i].end + 1 - range[i].start; | ||
| 253 | |||
| 254 | return sum; | ||
| 255 | } | ||
| 256 | |||
| 257 | static int enable_mtrr_cleanup __initdata = | ||
| 258 | CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT; | ||
| 259 | |||
| 260 | static int __init disable_mtrr_cleanup_setup(char *str) | ||
| 261 | { | ||
| 262 | enable_mtrr_cleanup = 0; | ||
| 263 | return 0; | ||
| 264 | } | ||
| 265 | early_param("disable_mtrr_cleanup", disable_mtrr_cleanup_setup); | ||
| 266 | |||
| 267 | static int __init enable_mtrr_cleanup_setup(char *str) | ||
| 268 | { | ||
| 269 | enable_mtrr_cleanup = 1; | ||
| 270 | return 0; | ||
| 271 | } | ||
| 272 | early_param("enable_mtrr_cleanup", enable_mtrr_cleanup_setup); | ||
| 273 | |||
| 274 | static int __init mtrr_cleanup_debug_setup(char *str) | ||
| 275 | { | ||
| 276 | debug_print = 1; | ||
| 277 | return 0; | ||
| 278 | } | ||
| 279 | early_param("mtrr_cleanup_debug", mtrr_cleanup_debug_setup); | ||
| 280 | |||
| 281 | struct var_mtrr_state { | ||
| 282 | unsigned long range_startk; | ||
| 283 | unsigned long range_sizek; | ||
| 284 | unsigned long chunk_sizek; | ||
| 285 | unsigned long gran_sizek; | ||
| 286 | unsigned int reg; | ||
| 287 | }; | ||
| 288 | |||
| 289 | static void __init | ||
| 290 | set_var_mtrr(unsigned int reg, unsigned long basek, unsigned long sizek, | ||
| 291 | unsigned char type, unsigned int address_bits) | ||
| 292 | { | ||
| 293 | u32 base_lo, base_hi, mask_lo, mask_hi; | ||
| 294 | u64 base, mask; | ||
| 295 | |||
| 296 | if (!sizek) { | ||
| 297 | fill_mtrr_var_range(reg, 0, 0, 0, 0); | ||
| 298 | return; | ||
| 299 | } | ||
| 300 | |||
| 301 | mask = (1ULL << address_bits) - 1; | ||
| 302 | mask &= ~((((u64)sizek) << 10) - 1); | ||
| 303 | |||
| 304 | base = ((u64)basek) << 10; | ||
| 305 | |||
| 306 | base |= type; | ||
| 307 | mask |= 0x800; | ||
| 308 | |||
| 309 | base_lo = base & ((1ULL<<32) - 1); | ||
| 310 | base_hi = base >> 32; | ||
| 311 | |||
| 312 | mask_lo = mask & ((1ULL<<32) - 1); | ||
| 313 | mask_hi = mask >> 32; | ||
| 314 | |||
| 315 | fill_mtrr_var_range(reg, base_lo, base_hi, mask_lo, mask_hi); | ||
| 316 | } | ||
| 317 | |||
| 318 | static void __init | ||
| 319 | save_var_mtrr(unsigned int reg, unsigned long basek, unsigned long sizek, | ||
| 320 | unsigned char type) | ||
| 321 | { | ||
| 322 | range_state[reg].base_pfn = basek >> (PAGE_SHIFT - 10); | ||
| 323 | range_state[reg].size_pfn = sizek >> (PAGE_SHIFT - 10); | ||
| 324 | range_state[reg].type = type; | ||
| 325 | } | ||
| 326 | |||
| 327 | static void __init | ||
| 328 | set_var_mtrr_all(unsigned int address_bits) | ||
| 329 | { | ||
| 330 | unsigned long basek, sizek; | ||
| 331 | unsigned char type; | ||
| 332 | unsigned int reg; | ||
| 333 | |||
| 334 | for (reg = 0; reg < num_var_ranges; reg++) { | ||
| 335 | basek = range_state[reg].base_pfn << (PAGE_SHIFT - 10); | ||
| 336 | sizek = range_state[reg].size_pfn << (PAGE_SHIFT - 10); | ||
| 337 | type = range_state[reg].type; | ||
| 338 | |||
| 339 | set_var_mtrr(reg, basek, sizek, type, address_bits); | ||
| 340 | } | ||
| 341 | } | ||
| 342 | |||
| 343 | static unsigned long to_size_factor(unsigned long sizek, char *factorp) | ||
| 344 | { | ||
| 345 | char factor; | ||
| 346 | unsigned long base = sizek; | ||
| 347 | |||
| 348 | if (base & ((1<<10) - 1)) { | ||
| 349 | /* not MB alignment */ | ||
| 350 | factor = 'K'; | ||
| 351 | } else if (base & ((1<<20) - 1)) { | ||
| 352 | factor = 'M'; | ||
| 353 | base >>= 10; | ||
| 354 | } else { | ||
| 355 | factor = 'G'; | ||
| 356 | base >>= 20; | ||
| 357 | } | ||
| 358 | |||
| 359 | *factorp = factor; | ||
| 360 | |||
| 361 | return base; | ||
| 362 | } | ||
| 363 | |||
| 364 | static unsigned int __init | ||
| 365 | range_to_mtrr(unsigned int reg, unsigned long range_startk, | ||
| 366 | unsigned long range_sizek, unsigned char type) | ||
| 367 | { | ||
| 368 | if (!range_sizek || (reg >= num_var_ranges)) | ||
| 369 | return reg; | ||
| 370 | |||
| 371 | while (range_sizek) { | ||
| 372 | unsigned long max_align, align; | ||
| 373 | unsigned long sizek; | ||
| 374 | |||
| 375 | /* Compute the maximum size I can make a range */ | ||
| 376 | if (range_startk) | ||
| 377 | max_align = ffs(range_startk) - 1; | ||
| 378 | else | ||
| 379 | max_align = 32; | ||
| 380 | align = fls(range_sizek) - 1; | ||
| 381 | if (align > max_align) | ||
| 382 | align = max_align; | ||
| 383 | |||
| 384 | sizek = 1 << align; | ||
| 385 | if (debug_print) { | ||
| 386 | char start_factor = 'K', size_factor = 'K'; | ||
| 387 | unsigned long start_base, size_base; | ||
| 388 | |||
| 389 | start_base = to_size_factor(range_startk, | ||
| 390 | &start_factor), | ||
| 391 | size_base = to_size_factor(sizek, &size_factor), | ||
| 392 | |||
| 393 | printk(KERN_DEBUG "Setting variable MTRR %d, " | ||
| 394 | "base: %ld%cB, range: %ld%cB, type %s\n", | ||
| 395 | reg, start_base, start_factor, | ||
| 396 | size_base, size_factor, | ||
| 397 | (type == MTRR_TYPE_UNCACHABLE) ? "UC" : | ||
| 398 | ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other") | ||
| 399 | ); | ||
| 400 | } | ||
| 401 | save_var_mtrr(reg++, range_startk, sizek, type); | ||
| 402 | range_startk += sizek; | ||
| 403 | range_sizek -= sizek; | ||
| 404 | if (reg >= num_var_ranges) | ||
| 405 | break; | ||
| 406 | } | ||
| 407 | return reg; | ||
| 408 | } | ||
| 409 | |||
| 410 | static unsigned __init | ||
| 411 | range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek, | ||
| 412 | unsigned long sizek) | ||
| 413 | { | ||
| 414 | unsigned long hole_basek, hole_sizek; | ||
| 415 | unsigned long second_basek, second_sizek; | ||
| 416 | unsigned long range0_basek, range0_sizek; | ||
| 417 | unsigned long range_basek, range_sizek; | ||
| 418 | unsigned long chunk_sizek; | ||
| 419 | unsigned long gran_sizek; | ||
| 420 | |||
| 421 | hole_basek = 0; | ||
| 422 | hole_sizek = 0; | ||
| 423 | second_basek = 0; | ||
| 424 | second_sizek = 0; | ||
| 425 | chunk_sizek = state->chunk_sizek; | ||
| 426 | gran_sizek = state->gran_sizek; | ||
| 427 | |||
| 428 | /* align with gran size, prevent small block used up MTRRs */ | ||
| 429 | range_basek = ALIGN(state->range_startk, gran_sizek); | ||
| 430 | if ((range_basek > basek) && basek) | ||
| 431 | return second_sizek; | ||
| 432 | state->range_sizek -= (range_basek - state->range_startk); | ||
| 433 | range_sizek = ALIGN(state->range_sizek, gran_sizek); | ||
| 434 | |||
| 435 | while (range_sizek > state->range_sizek) { | ||
| 436 | range_sizek -= gran_sizek; | ||
| 437 | if (!range_sizek) | ||
| 438 | return 0; | ||
| 439 | } | ||
| 440 | state->range_sizek = range_sizek; | ||
| 441 | |||
| 442 | /* try to append some small hole */ | ||
| 443 | range0_basek = state->range_startk; | ||
| 444 | range0_sizek = ALIGN(state->range_sizek, chunk_sizek); | ||
| 445 | |||
| 446 | /* no increase */ | ||
| 447 | if (range0_sizek == state->range_sizek) { | ||
| 448 | if (debug_print) | ||
| 449 | printk(KERN_DEBUG "rangeX: %016lx - %016lx\n", | ||
| 450 | range0_basek<<10, | ||
| 451 | (range0_basek + state->range_sizek)<<10); | ||
| 452 | state->reg = range_to_mtrr(state->reg, range0_basek, | ||
| 453 | state->range_sizek, MTRR_TYPE_WRBACK); | ||
| 454 | return 0; | ||
| 455 | } | ||
| 456 | |||
| 457 | /* only cut back, when it is not the last */ | ||
| 458 | if (sizek) { | ||
| 459 | while (range0_basek + range0_sizek > (basek + sizek)) { | ||
| 460 | if (range0_sizek >= chunk_sizek) | ||
| 461 | range0_sizek -= chunk_sizek; | ||
| 462 | else | ||
| 463 | range0_sizek = 0; | ||
| 464 | |||
| 465 | if (!range0_sizek) | ||
| 466 | break; | ||
| 467 | } | ||
| 468 | } | ||
| 469 | |||
| 470 | second_try: | ||
| 471 | range_basek = range0_basek + range0_sizek; | ||
| 472 | |||
| 473 | /* one hole in the middle */ | ||
| 474 | if (range_basek > basek && range_basek <= (basek + sizek)) | ||
| 475 | second_sizek = range_basek - basek; | ||
| 476 | |||
| 477 | if (range0_sizek > state->range_sizek) { | ||
| 478 | |||
| 479 | /* one hole in middle or at end */ | ||
| 480 | hole_sizek = range0_sizek - state->range_sizek - second_sizek; | ||
| 481 | |||
| 482 | /* hole size should be less than half of range0 size */ | ||
| 483 | if (hole_sizek >= (range0_sizek >> 1) && | ||
| 484 | range0_sizek >= chunk_sizek) { | ||
| 485 | range0_sizek -= chunk_sizek; | ||
| 486 | second_sizek = 0; | ||
| 487 | hole_sizek = 0; | ||
| 488 | |||
| 489 | goto second_try; | ||
| 490 | } | ||
| 491 | } | ||
| 492 | |||
| 493 | if (range0_sizek) { | ||
| 494 | if (debug_print) | ||
| 495 | printk(KERN_DEBUG "range0: %016lx - %016lx\n", | ||
| 496 | range0_basek<<10, | ||
| 497 | (range0_basek + range0_sizek)<<10); | ||
| 498 | state->reg = range_to_mtrr(state->reg, range0_basek, | ||
| 499 | range0_sizek, MTRR_TYPE_WRBACK); | ||
| 500 | } | ||
| 501 | |||
| 502 | if (range0_sizek < state->range_sizek) { | ||
| 503 | /* need to handle left over */ | ||
| 504 | range_sizek = state->range_sizek - range0_sizek; | ||
| 505 | |||
| 506 | if (debug_print) | ||
| 507 | printk(KERN_DEBUG "range: %016lx - %016lx\n", | ||
| 508 | range_basek<<10, | ||
| 509 | (range_basek + range_sizek)<<10); | ||
| 510 | state->reg = range_to_mtrr(state->reg, range_basek, | ||
| 511 | range_sizek, MTRR_TYPE_WRBACK); | ||
| 512 | } | ||
| 513 | |||
| 514 | if (hole_sizek) { | ||
| 515 | hole_basek = range_basek - hole_sizek - second_sizek; | ||
| 516 | if (debug_print) | ||
| 517 | printk(KERN_DEBUG "hole: %016lx - %016lx\n", | ||
| 518 | hole_basek<<10, | ||
| 519 | (hole_basek + hole_sizek)<<10); | ||
| 520 | state->reg = range_to_mtrr(state->reg, hole_basek, | ||
| 521 | hole_sizek, MTRR_TYPE_UNCACHABLE); | ||
| 522 | } | ||
| 523 | |||
| 524 | return second_sizek; | ||
| 525 | } | ||
| 526 | |||
| 527 | static void __init | ||
| 528 | set_var_mtrr_range(struct var_mtrr_state *state, unsigned long base_pfn, | ||
| 529 | unsigned long size_pfn) | ||
| 530 | { | ||
| 531 | unsigned long basek, sizek; | ||
| 532 | unsigned long second_sizek = 0; | ||
| 533 | |||
| 534 | if (state->reg >= num_var_ranges) | ||
| 535 | return; | ||
| 536 | |||
| 537 | basek = base_pfn << (PAGE_SHIFT - 10); | ||
| 538 | sizek = size_pfn << (PAGE_SHIFT - 10); | ||
| 539 | |||
| 540 | /* See if I can merge with the last range */ | ||
| 541 | if ((basek <= 1024) || | ||
| 542 | (state->range_startk + state->range_sizek == basek)) { | ||
| 543 | unsigned long endk = basek + sizek; | ||
| 544 | state->range_sizek = endk - state->range_startk; | ||
| 545 | return; | ||
| 546 | } | ||
| 547 | /* Write the range mtrrs */ | ||
| 548 | if (state->range_sizek != 0) | ||
| 549 | second_sizek = range_to_mtrr_with_hole(state, basek, sizek); | ||
| 550 | |||
| 551 | /* Allocate an msr */ | ||
| 552 | state->range_startk = basek + second_sizek; | ||
| 553 | state->range_sizek = sizek - second_sizek; | ||
| 554 | } | ||
| 555 | |||
| 556 | /* mininum size of mtrr block that can take hole */ | ||
| 557 | static u64 mtrr_chunk_size __initdata = (256ULL<<20); | ||
| 558 | |||
| 559 | static int __init parse_mtrr_chunk_size_opt(char *p) | ||
| 560 | { | ||
| 561 | if (!p) | ||
| 562 | return -EINVAL; | ||
| 563 | mtrr_chunk_size = memparse(p, &p); | ||
| 564 | return 0; | ||
| 565 | } | ||
| 566 | early_param("mtrr_chunk_size", parse_mtrr_chunk_size_opt); | ||
| 567 | |||
| 568 | /* granity of mtrr of block */ | ||
| 569 | static u64 mtrr_gran_size __initdata; | ||
| 570 | |||
| 571 | static int __init parse_mtrr_gran_size_opt(char *p) | ||
| 572 | { | ||
| 573 | if (!p) | ||
| 574 | return -EINVAL; | ||
| 575 | mtrr_gran_size = memparse(p, &p); | ||
| 576 | return 0; | ||
| 577 | } | ||
| 578 | early_param("mtrr_gran_size", parse_mtrr_gran_size_opt); | ||
| 579 | |||
| 580 | static int nr_mtrr_spare_reg __initdata = | ||
| 581 | CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT; | ||
| 582 | |||
| 583 | static int __init parse_mtrr_spare_reg(char *arg) | ||
| 584 | { | ||
| 585 | if (arg) | ||
| 586 | nr_mtrr_spare_reg = simple_strtoul(arg, NULL, 0); | ||
| 587 | return 0; | ||
| 588 | } | ||
| 589 | |||
| 590 | early_param("mtrr_spare_reg_nr", parse_mtrr_spare_reg); | ||
| 591 | |||
| 592 | static int __init | ||
| 593 | x86_setup_var_mtrrs(struct res_range *range, int nr_range, | ||
| 594 | u64 chunk_size, u64 gran_size) | ||
| 595 | { | ||
| 596 | struct var_mtrr_state var_state; | ||
| 597 | int i; | ||
| 598 | int num_reg; | ||
| 599 | |||
| 600 | var_state.range_startk = 0; | ||
| 601 | var_state.range_sizek = 0; | ||
| 602 | var_state.reg = 0; | ||
| 603 | var_state.chunk_sizek = chunk_size >> 10; | ||
| 604 | var_state.gran_sizek = gran_size >> 10; | ||
| 605 | |||
| 606 | memset(range_state, 0, sizeof(range_state)); | ||
| 607 | |||
| 608 | /* Write the range etc */ | ||
| 609 | for (i = 0; i < nr_range; i++) | ||
| 610 | set_var_mtrr_range(&var_state, range[i].start, | ||
| 611 | range[i].end - range[i].start + 1); | ||
| 612 | |||
| 613 | /* Write the last range */ | ||
| 614 | if (var_state.range_sizek != 0) | ||
| 615 | range_to_mtrr_with_hole(&var_state, 0, 0); | ||
| 616 | |||
| 617 | num_reg = var_state.reg; | ||
| 618 | /* Clear out the extra MTRR's */ | ||
| 619 | while (var_state.reg < num_var_ranges) { | ||
| 620 | save_var_mtrr(var_state.reg, 0, 0, 0); | ||
| 621 | var_state.reg++; | ||
| 622 | } | ||
| 623 | |||
| 624 | return num_reg; | ||
| 625 | } | ||
| 626 | |||
| 627 | struct mtrr_cleanup_result { | ||
| 628 | unsigned long gran_sizek; | ||
| 629 | unsigned long chunk_sizek; | ||
| 630 | unsigned long lose_cover_sizek; | ||
| 631 | unsigned int num_reg; | ||
| 632 | int bad; | ||
| 633 | }; | ||
| 634 | |||
| 635 | /* | ||
| 636 | * gran_size: 64K, 128K, 256K, 512K, 1M, 2M, ..., 2G | ||
| 637 | * chunk size: gran_size, ..., 2G | ||
| 638 | * so we need (1+16)*8 | ||
| 639 | */ | ||
| 640 | #define NUM_RESULT 136 | ||
| 641 | #define PSHIFT (PAGE_SHIFT - 10) | ||
| 642 | |||
| 643 | static struct mtrr_cleanup_result __initdata result[NUM_RESULT]; | ||
| 644 | static unsigned long __initdata min_loss_pfn[RANGE_NUM]; | ||
| 645 | |||
| 646 | static void __init print_out_mtrr_range_state(void) | ||
| 647 | { | ||
| 648 | int i; | ||
| 649 | char start_factor = 'K', size_factor = 'K'; | ||
| 650 | unsigned long start_base, size_base; | ||
| 651 | mtrr_type type; | ||
| 652 | |||
| 653 | for (i = 0; i < num_var_ranges; i++) { | ||
| 654 | |||
| 655 | size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10); | ||
| 656 | if (!size_base) | ||
| 657 | continue; | ||
| 658 | |||
| 659 | size_base = to_size_factor(size_base, &size_factor), | ||
| 660 | start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10); | ||
| 661 | start_base = to_size_factor(start_base, &start_factor), | ||
| 662 | type = range_state[i].type; | ||
| 663 | |||
| 664 | printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n", | ||
| 665 | i, start_base, start_factor, | ||
| 666 | size_base, size_factor, | ||
| 667 | (type == MTRR_TYPE_UNCACHABLE) ? "UC" : | ||
| 668 | ((type == MTRR_TYPE_WRPROT) ? "WP" : | ||
| 669 | ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other")) | ||
| 670 | ); | ||
| 671 | } | ||
| 672 | } | ||
| 673 | |||
| 674 | static int __init mtrr_need_cleanup(void) | ||
| 675 | { | ||
| 676 | int i; | ||
| 677 | mtrr_type type; | ||
| 678 | unsigned long size; | ||
| 679 | /* extra one for all 0 */ | ||
| 680 | int num[MTRR_NUM_TYPES + 1]; | ||
| 681 | |||
| 682 | /* check entries number */ | ||
| 683 | memset(num, 0, sizeof(num)); | ||
| 684 | for (i = 0; i < num_var_ranges; i++) { | ||
| 685 | type = range_state[i].type; | ||
| 686 | size = range_state[i].size_pfn; | ||
| 687 | if (type >= MTRR_NUM_TYPES) | ||
| 688 | continue; | ||
| 689 | if (!size) | ||
| 690 | type = MTRR_NUM_TYPES; | ||
| 691 | if (type == MTRR_TYPE_WRPROT) | ||
| 692 | type = MTRR_TYPE_UNCACHABLE; | ||
| 693 | num[type]++; | ||
| 694 | } | ||
| 695 | |||
| 696 | /* check if we got UC entries */ | ||
| 697 | if (!num[MTRR_TYPE_UNCACHABLE]) | ||
| 698 | return 0; | ||
| 699 | |||
| 700 | /* check if we only had WB and UC */ | ||
| 701 | if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] != | ||
| 702 | num_var_ranges - num[MTRR_NUM_TYPES]) | ||
| 703 | return 0; | ||
| 704 | |||
| 705 | return 1; | ||
| 706 | } | ||
| 707 | |||
| 708 | static unsigned long __initdata range_sums; | ||
| 709 | static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size, | ||
| 710 | unsigned long extra_remove_base, | ||
| 711 | unsigned long extra_remove_size, | ||
| 712 | int i) | ||
| 713 | { | ||
| 714 | int num_reg; | ||
| 715 | static struct res_range range_new[RANGE_NUM]; | ||
| 716 | static int nr_range_new; | ||
| 717 | unsigned long range_sums_new; | ||
| 718 | |||
| 719 | /* convert ranges to var ranges state */ | ||
| 720 | num_reg = x86_setup_var_mtrrs(range, nr_range, | ||
| 721 | chunk_size, gran_size); | ||
| 722 | |||
| 723 | /* we got new setting in range_state, check it */ | ||
| 724 | memset(range_new, 0, sizeof(range_new)); | ||
| 725 | nr_range_new = x86_get_mtrr_mem_range(range_new, 0, | ||
| 726 | extra_remove_base, extra_remove_size); | ||
| 727 | range_sums_new = sum_ranges(range_new, nr_range_new); | ||
| 728 | |||
| 729 | result[i].chunk_sizek = chunk_size >> 10; | ||
| 730 | result[i].gran_sizek = gran_size >> 10; | ||
| 731 | result[i].num_reg = num_reg; | ||
| 732 | if (range_sums < range_sums_new) { | ||
| 733 | result[i].lose_cover_sizek = | ||
| 734 | (range_sums_new - range_sums) << PSHIFT; | ||
| 735 | result[i].bad = 1; | ||
| 736 | } else | ||
| 737 | result[i].lose_cover_sizek = | ||
| 738 | (range_sums - range_sums_new) << PSHIFT; | ||
| 739 | |||
| 740 | /* double check it */ | ||
| 741 | if (!result[i].bad && !result[i].lose_cover_sizek) { | ||
| 742 | if (nr_range_new != nr_range || | ||
| 743 | memcmp(range, range_new, sizeof(range))) | ||
| 744 | result[i].bad = 1; | ||
| 745 | } | ||
| 746 | |||
| 747 | if (!result[i].bad && (range_sums - range_sums_new < | ||
| 748 | min_loss_pfn[num_reg])) { | ||
| 749 | min_loss_pfn[num_reg] = | ||
| 750 | range_sums - range_sums_new; | ||
| 751 | } | ||
| 752 | } | ||
| 753 | |||
| 754 | static void __init mtrr_print_out_one_result(int i) | ||
| 755 | { | ||
| 756 | char gran_factor, chunk_factor, lose_factor; | ||
| 757 | unsigned long gran_base, chunk_base, lose_base; | ||
| 758 | |||
| 759 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | ||
| 760 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | ||
| 761 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
| 762 | printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t", | ||
| 763 | result[i].bad ? "*BAD*" : " ", | ||
| 764 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
| 765 | printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n", | ||
| 766 | result[i].num_reg, result[i].bad ? "-" : "", | ||
| 767 | lose_base, lose_factor); | ||
| 768 | } | ||
| 769 | |||
| 770 | static int __init mtrr_search_optimal_index(void) | ||
| 771 | { | ||
| 772 | int i; | ||
| 773 | int num_reg_good; | ||
| 774 | int index_good; | ||
| 775 | |||
| 776 | if (nr_mtrr_spare_reg >= num_var_ranges) | ||
| 777 | nr_mtrr_spare_reg = num_var_ranges - 1; | ||
| 778 | num_reg_good = -1; | ||
| 779 | for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) { | ||
| 780 | if (!min_loss_pfn[i]) | ||
| 781 | num_reg_good = i; | ||
| 782 | } | ||
| 783 | |||
| 784 | index_good = -1; | ||
| 785 | if (num_reg_good != -1) { | ||
| 786 | for (i = 0; i < NUM_RESULT; i++) { | ||
| 787 | if (!result[i].bad && | ||
| 788 | result[i].num_reg == num_reg_good && | ||
| 789 | !result[i].lose_cover_sizek) { | ||
| 790 | index_good = i; | ||
| 791 | break; | ||
| 792 | } | ||
| 793 | } | ||
| 794 | } | ||
| 795 | |||
| 796 | return index_good; | ||
| 797 | } | ||
| 798 | |||
| 799 | |||
| 800 | int __init mtrr_cleanup(unsigned address_bits) | ||
| 801 | { | ||
| 802 | unsigned long extra_remove_base, extra_remove_size; | ||
| 803 | unsigned long base, size, def, dummy; | ||
| 804 | mtrr_type type; | ||
| 805 | u64 chunk_size, gran_size; | ||
| 806 | int index_good; | ||
| 807 | int i; | ||
| 808 | |||
| 809 | if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1) | ||
| 810 | return 0; | ||
| 811 | rdmsr(MTRRdefType_MSR, def, dummy); | ||
| 812 | def &= 0xff; | ||
| 813 | if (def != MTRR_TYPE_UNCACHABLE) | ||
| 814 | return 0; | ||
| 815 | |||
| 816 | /* get it and store it aside */ | ||
| 817 | memset(range_state, 0, sizeof(range_state)); | ||
| 818 | for (i = 0; i < num_var_ranges; i++) { | ||
| 819 | mtrr_if->get(i, &base, &size, &type); | ||
| 820 | range_state[i].base_pfn = base; | ||
| 821 | range_state[i].size_pfn = size; | ||
| 822 | range_state[i].type = type; | ||
| 823 | } | ||
| 824 | |||
| 825 | /* check if we need handle it and can handle it */ | ||
| 826 | if (!mtrr_need_cleanup()) | ||
| 827 | return 0; | ||
| 828 | |||
| 829 | /* print original var MTRRs at first, for debugging: */ | ||
| 830 | printk(KERN_DEBUG "original variable MTRRs\n"); | ||
| 831 | print_out_mtrr_range_state(); | ||
| 832 | |||
| 833 | memset(range, 0, sizeof(range)); | ||
| 834 | extra_remove_size = 0; | ||
| 835 | extra_remove_base = 1 << (32 - PAGE_SHIFT); | ||
| 836 | if (mtrr_tom2) | ||
| 837 | extra_remove_size = | ||
| 838 | (mtrr_tom2 >> PAGE_SHIFT) - extra_remove_base; | ||
| 839 | nr_range = x86_get_mtrr_mem_range(range, 0, extra_remove_base, | ||
| 840 | extra_remove_size); | ||
| 841 | /* | ||
| 842 | * [0, 1M) should always be coverred by var mtrr with WB | ||
| 843 | * and fixed mtrrs should take effective before var mtrr for it | ||
| 844 | */ | ||
| 845 | nr_range = add_range_with_merge(range, nr_range, 0, | ||
| 846 | (1ULL<<(20 - PAGE_SHIFT)) - 1); | ||
| 847 | /* sort the ranges */ | ||
| 848 | sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL); | ||
| 849 | |||
| 850 | range_sums = sum_ranges(range, nr_range); | ||
| 851 | printk(KERN_INFO "total RAM coverred: %ldM\n", | ||
| 852 | range_sums >> (20 - PAGE_SHIFT)); | ||
| 853 | |||
| 854 | if (mtrr_chunk_size && mtrr_gran_size) { | ||
| 855 | i = 0; | ||
| 856 | mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size, | ||
| 857 | extra_remove_base, extra_remove_size, i); | ||
| 858 | |||
| 859 | mtrr_print_out_one_result(i); | ||
| 860 | |||
| 861 | if (!result[i].bad) { | ||
| 862 | set_var_mtrr_all(address_bits); | ||
| 863 | printk(KERN_DEBUG "New variable MTRRs\n"); | ||
| 864 | print_out_mtrr_range_state(); | ||
| 865 | return 1; | ||
| 866 | } | ||
| 867 | printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, " | ||
| 868 | "will find optimal one\n"); | ||
| 869 | } | ||
| 870 | |||
| 871 | i = 0; | ||
| 872 | memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn)); | ||
| 873 | memset(result, 0, sizeof(result)); | ||
| 874 | for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) { | ||
| 875 | |||
| 876 | for (chunk_size = gran_size; chunk_size < (1ULL<<32); | ||
| 877 | chunk_size <<= 1) { | ||
| 878 | |||
| 879 | if (i >= NUM_RESULT) | ||
| 880 | continue; | ||
| 881 | |||
| 882 | mtrr_calc_range_state(chunk_size, gran_size, | ||
| 883 | extra_remove_base, extra_remove_size, i); | ||
| 884 | if (debug_print) { | ||
| 885 | mtrr_print_out_one_result(i); | ||
| 886 | printk(KERN_INFO "\n"); | ||
| 887 | } | ||
| 888 | |||
| 889 | i++; | ||
| 890 | } | ||
| 891 | } | ||
| 892 | |||
| 893 | /* try to find the optimal index */ | ||
| 894 | index_good = mtrr_search_optimal_index(); | ||
| 895 | |||
| 896 | if (index_good != -1) { | ||
| 897 | printk(KERN_INFO "Found optimal setting for mtrr clean up\n"); | ||
| 898 | i = index_good; | ||
| 899 | mtrr_print_out_one_result(i); | ||
| 900 | |||
| 901 | /* convert ranges to var ranges state */ | ||
| 902 | chunk_size = result[i].chunk_sizek; | ||
| 903 | chunk_size <<= 10; | ||
| 904 | gran_size = result[i].gran_sizek; | ||
| 905 | gran_size <<= 10; | ||
| 906 | x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size); | ||
| 907 | set_var_mtrr_all(address_bits); | ||
| 908 | printk(KERN_DEBUG "New variable MTRRs\n"); | ||
| 909 | print_out_mtrr_range_state(); | ||
| 910 | return 1; | ||
| 911 | } else { | ||
| 912 | /* print out all */ | ||
| 913 | for (i = 0; i < NUM_RESULT; i++) | ||
| 914 | mtrr_print_out_one_result(i); | ||
| 915 | } | ||
| 916 | |||
| 917 | printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n"); | ||
| 918 | printk(KERN_INFO "please specify mtrr_gran_size/mtrr_chunk_size\n"); | ||
| 919 | |||
| 920 | return 0; | ||
| 921 | } | ||
| 922 | #else | ||
| 923 | int __init mtrr_cleanup(unsigned address_bits) | ||
| 924 | { | ||
| 925 | return 0; | ||
| 926 | } | ||
| 927 | #endif | ||
| 928 | |||
| 929 | static int disable_mtrr_trim; | ||
| 930 | |||
| 931 | static int __init disable_mtrr_trim_setup(char *str) | ||
| 932 | { | ||
| 933 | disable_mtrr_trim = 1; | ||
| 934 | return 0; | ||
| 935 | } | ||
| 936 | early_param("disable_mtrr_trim", disable_mtrr_trim_setup); | ||
| 937 | |||
| 938 | /* | ||
| 939 | * Newer AMD K8s and later CPUs have a special magic MSR way to force WB | ||
| 940 | * for memory >4GB. Check for that here. | ||
| 941 | * Note this won't check if the MTRRs < 4GB where the magic bit doesn't | ||
| 942 | * apply to are wrong, but so far we don't know of any such case in the wild. | ||
| 943 | */ | ||
| 944 | #define Tom2Enabled (1U << 21) | ||
| 945 | #define Tom2ForceMemTypeWB (1U << 22) | ||
| 946 | |||
| 947 | int __init amd_special_default_mtrr(void) | ||
| 948 | { | ||
| 949 | u32 l, h; | ||
| 950 | |||
| 951 | if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD) | ||
| 952 | return 0; | ||
| 953 | if (boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x11) | ||
| 954 | return 0; | ||
| 955 | /* In case some hypervisor doesn't pass SYSCFG through */ | ||
| 956 | if (rdmsr_safe(MSR_K8_SYSCFG, &l, &h) < 0) | ||
| 957 | return 0; | ||
| 958 | /* | ||
| 959 | * Memory between 4GB and top of mem is forced WB by this magic bit. | ||
| 960 | * Reserved before K8RevF, but should be zero there. | ||
| 961 | */ | ||
| 962 | if ((l & (Tom2Enabled | Tom2ForceMemTypeWB)) == | ||
| 963 | (Tom2Enabled | Tom2ForceMemTypeWB)) | ||
| 964 | return 1; | ||
| 965 | return 0; | ||
| 966 | } | ||
| 967 | |||
| 968 | static u64 __init real_trim_memory(unsigned long start_pfn, | ||
| 969 | unsigned long limit_pfn) | ||
| 970 | { | ||
| 971 | u64 trim_start, trim_size; | ||
| 972 | trim_start = start_pfn; | ||
| 973 | trim_start <<= PAGE_SHIFT; | ||
| 974 | trim_size = limit_pfn; | ||
| 975 | trim_size <<= PAGE_SHIFT; | ||
| 976 | trim_size -= trim_start; | ||
| 977 | |||
| 978 | return e820_update_range(trim_start, trim_size, E820_RAM, | ||
| 979 | E820_RESERVED); | ||
| 980 | } | ||
| 981 | /** | ||
| 982 | * mtrr_trim_uncached_memory - trim RAM not covered by MTRRs | ||
| 983 | * @end_pfn: ending page frame number | ||
| 984 | * | ||
| 985 | * Some buggy BIOSes don't setup the MTRRs properly for systems with certain | ||
| 986 | * memory configurations. This routine checks that the highest MTRR matches | ||
| 987 | * the end of memory, to make sure the MTRRs having a write back type cover | ||
| 988 | * all of the memory the kernel is intending to use. If not, it'll trim any | ||
| 989 | * memory off the end by adjusting end_pfn, removing it from the kernel's | ||
| 990 | * allocation pools, warning the user with an obnoxious message. | ||
| 991 | */ | ||
| 992 | int __init mtrr_trim_uncached_memory(unsigned long end_pfn) | ||
| 993 | { | ||
| 994 | unsigned long i, base, size, highest_pfn = 0, def, dummy; | ||
| 995 | mtrr_type type; | ||
| 996 | u64 total_trim_size; | ||
| 997 | |||
| 998 | /* extra one for all 0 */ | ||
| 999 | int num[MTRR_NUM_TYPES + 1]; | ||
| 1000 | /* | ||
| 1001 | * Make sure we only trim uncachable memory on machines that | ||
| 1002 | * support the Intel MTRR architecture: | ||
| 1003 | */ | ||
| 1004 | if (!is_cpu(INTEL) || disable_mtrr_trim) | ||
| 1005 | return 0; | ||
| 1006 | rdmsr(MTRRdefType_MSR, def, dummy); | ||
| 1007 | def &= 0xff; | ||
| 1008 | if (def != MTRR_TYPE_UNCACHABLE) | ||
| 1009 | return 0; | ||
| 1010 | |||
| 1011 | /* get it and store it aside */ | ||
| 1012 | memset(range_state, 0, sizeof(range_state)); | ||
| 1013 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1014 | mtrr_if->get(i, &base, &size, &type); | ||
| 1015 | range_state[i].base_pfn = base; | ||
| 1016 | range_state[i].size_pfn = size; | ||
| 1017 | range_state[i].type = type; | ||
| 1018 | } | ||
| 1019 | |||
| 1020 | /* Find highest cached pfn */ | ||
| 1021 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1022 | type = range_state[i].type; | ||
| 1023 | if (type != MTRR_TYPE_WRBACK) | ||
| 1024 | continue; | ||
| 1025 | base = range_state[i].base_pfn; | ||
| 1026 | size = range_state[i].size_pfn; | ||
| 1027 | if (highest_pfn < base + size) | ||
| 1028 | highest_pfn = base + size; | ||
| 1029 | } | ||
| 1030 | |||
| 1031 | /* kvm/qemu doesn't have mtrr set right, don't trim them all */ | ||
| 1032 | if (!highest_pfn) { | ||
| 1033 | printk(KERN_INFO "CPU MTRRs all blank - virtualized system.\n"); | ||
| 1034 | return 0; | ||
| 1035 | } | ||
| 1036 | |||
| 1037 | /* check entries number */ | ||
| 1038 | memset(num, 0, sizeof(num)); | ||
| 1039 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1040 | type = range_state[i].type; | ||
| 1041 | if (type >= MTRR_NUM_TYPES) | ||
| 1042 | continue; | ||
| 1043 | size = range_state[i].size_pfn; | ||
| 1044 | if (!size) | ||
| 1045 | type = MTRR_NUM_TYPES; | ||
| 1046 | num[type]++; | ||
| 1047 | } | ||
| 1048 | |||
| 1049 | /* no entry for WB? */ | ||
| 1050 | if (!num[MTRR_TYPE_WRBACK]) | ||
| 1051 | return 0; | ||
| 1052 | |||
| 1053 | /* check if we only had WB and UC */ | ||
| 1054 | if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] != | ||
| 1055 | num_var_ranges - num[MTRR_NUM_TYPES]) | ||
| 1056 | return 0; | ||
| 1057 | |||
| 1058 | memset(range, 0, sizeof(range)); | ||
| 1059 | nr_range = 0; | ||
| 1060 | if (mtrr_tom2) { | ||
| 1061 | range[nr_range].start = (1ULL<<(32 - PAGE_SHIFT)); | ||
| 1062 | range[nr_range].end = (mtrr_tom2 >> PAGE_SHIFT) - 1; | ||
| 1063 | if (highest_pfn < range[nr_range].end + 1) | ||
| 1064 | highest_pfn = range[nr_range].end + 1; | ||
| 1065 | nr_range++; | ||
| 1066 | } | ||
| 1067 | nr_range = x86_get_mtrr_mem_range(range, nr_range, 0, 0); | ||
| 1068 | |||
| 1069 | total_trim_size = 0; | ||
| 1070 | /* check the head */ | ||
| 1071 | if (range[0].start) | ||
| 1072 | total_trim_size += real_trim_memory(0, range[0].start); | ||
| 1073 | /* check the holes */ | ||
| 1074 | for (i = 0; i < nr_range - 1; i++) { | ||
| 1075 | if (range[i].end + 1 < range[i+1].start) | ||
| 1076 | total_trim_size += real_trim_memory(range[i].end + 1, | ||
| 1077 | range[i+1].start); | ||
| 1078 | } | ||
| 1079 | /* check the top */ | ||
| 1080 | i = nr_range - 1; | ||
| 1081 | if (range[i].end + 1 < end_pfn) | ||
| 1082 | total_trim_size += real_trim_memory(range[i].end + 1, | ||
| 1083 | end_pfn); | ||
| 1084 | |||
| 1085 | if (total_trim_size) { | ||
| 1086 | printk(KERN_WARNING "WARNING: BIOS bug: CPU MTRRs don't cover" | ||
| 1087 | " all of memory, losing %lluMB of RAM.\n", | ||
| 1088 | total_trim_size >> 20); | ||
| 1089 | |||
| 1090 | if (!changed_by_mtrr_cleanup) | ||
| 1091 | WARN_ON(1); | ||
| 1092 | |||
| 1093 | printk(KERN_INFO "update e820 for mtrr\n"); | ||
| 1094 | update_e820(); | ||
| 1095 | |||
| 1096 | return 1; | ||
| 1097 | } | ||
| 1098 | |||
| 1099 | return 0; | ||
| 1100 | } | ||
| 1101 | |||
diff --git a/arch/x86/kernel/cpu/mtrr/generic.c b/arch/x86/kernel/cpu/mtrr/generic.c index 0c0a455fe95c..37f28fc7cf95 100644 --- a/arch/x86/kernel/cpu/mtrr/generic.c +++ b/arch/x86/kernel/cpu/mtrr/generic.c | |||
| @@ -33,13 +33,31 @@ u64 mtrr_tom2; | |||
| 33 | struct mtrr_state_type mtrr_state = {}; | 33 | struct mtrr_state_type mtrr_state = {}; |
| 34 | EXPORT_SYMBOL_GPL(mtrr_state); | 34 | EXPORT_SYMBOL_GPL(mtrr_state); |
| 35 | 35 | ||
| 36 | static int __initdata mtrr_show; | 36 | /** |
| 37 | static int __init mtrr_debug(char *opt) | 37 | * BIOS is expected to clear MtrrFixDramModEn bit, see for example |
| 38 | * "BIOS and Kernel Developer's Guide for the AMD Athlon 64 and AMD | ||
| 39 | * Opteron Processors" (26094 Rev. 3.30 February 2006), section | ||
| 40 | * "13.2.1.2 SYSCFG Register": "The MtrrFixDramModEn bit should be set | ||
| 41 | * to 1 during BIOS initalization of the fixed MTRRs, then cleared to | ||
| 42 | * 0 for operation." | ||
| 43 | */ | ||
| 44 | static inline void k8_check_syscfg_dram_mod_en(void) | ||
| 38 | { | 45 | { |
| 39 | mtrr_show = 1; | 46 | u32 lo, hi; |
| 40 | return 0; | 47 | |
| 48 | if (!((boot_cpu_data.x86_vendor == X86_VENDOR_AMD) && | ||
| 49 | (boot_cpu_data.x86 >= 0x0f))) | ||
| 50 | return; | ||
| 51 | |||
| 52 | rdmsr(MSR_K8_SYSCFG, lo, hi); | ||
| 53 | if (lo & K8_MTRRFIXRANGE_DRAM_MODIFY) { | ||
| 54 | printk(KERN_ERR FW_WARN "MTRR: CPU %u: SYSCFG[MtrrFixDramModEn]" | ||
| 55 | " not cleared by BIOS, clearing this bit\n", | ||
| 56 | smp_processor_id()); | ||
| 57 | lo &= ~K8_MTRRFIXRANGE_DRAM_MODIFY; | ||
| 58 | mtrr_wrmsr(MSR_K8_SYSCFG, lo, hi); | ||
| 59 | } | ||
| 41 | } | 60 | } |
| 42 | early_param("mtrr.show", mtrr_debug); | ||
| 43 | 61 | ||
| 44 | /* | 62 | /* |
| 45 | * Returns the effective MTRR type for the region | 63 | * Returns the effective MTRR type for the region |
| @@ -174,6 +192,8 @@ get_fixed_ranges(mtrr_type * frs) | |||
| 174 | unsigned int *p = (unsigned int *) frs; | 192 | unsigned int *p = (unsigned int *) frs; |
| 175 | int i; | 193 | int i; |
| 176 | 194 | ||
| 195 | k8_check_syscfg_dram_mod_en(); | ||
| 196 | |||
| 177 | rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]); | 197 | rdmsr(MTRRfix64K_00000_MSR, p[0], p[1]); |
| 178 | 198 | ||
| 179 | for (i = 0; i < 2; i++) | 199 | for (i = 0; i < 2; i++) |
| @@ -188,18 +208,94 @@ void mtrr_save_fixed_ranges(void *info) | |||
| 188 | get_fixed_ranges(mtrr_state.fixed_ranges); | 208 | get_fixed_ranges(mtrr_state.fixed_ranges); |
| 189 | } | 209 | } |
| 190 | 210 | ||
| 191 | static void print_fixed(unsigned base, unsigned step, const mtrr_type*types) | 211 | static unsigned __initdata last_fixed_start; |
| 212 | static unsigned __initdata last_fixed_end; | ||
| 213 | static mtrr_type __initdata last_fixed_type; | ||
| 214 | |||
| 215 | static void __init print_fixed_last(void) | ||
| 216 | { | ||
| 217 | if (!last_fixed_end) | ||
| 218 | return; | ||
| 219 | |||
| 220 | printk(KERN_DEBUG " %05X-%05X %s\n", last_fixed_start, | ||
| 221 | last_fixed_end - 1, mtrr_attrib_to_str(last_fixed_type)); | ||
| 222 | |||
| 223 | last_fixed_end = 0; | ||
| 224 | } | ||
| 225 | |||
| 226 | static void __init update_fixed_last(unsigned base, unsigned end, | ||
| 227 | mtrr_type type) | ||
| 228 | { | ||
| 229 | last_fixed_start = base; | ||
| 230 | last_fixed_end = end; | ||
| 231 | last_fixed_type = type; | ||
| 232 | } | ||
| 233 | |||
| 234 | static void __init print_fixed(unsigned base, unsigned step, | ||
| 235 | const mtrr_type *types) | ||
| 192 | { | 236 | { |
| 193 | unsigned i; | 237 | unsigned i; |
| 194 | 238 | ||
| 195 | for (i = 0; i < 8; ++i, ++types, base += step) | 239 | for (i = 0; i < 8; ++i, ++types, base += step) { |
| 196 | printk(KERN_INFO "MTRR %05X-%05X %s\n", | 240 | if (last_fixed_end == 0) { |
| 197 | base, base + step - 1, mtrr_attrib_to_str(*types)); | 241 | update_fixed_last(base, base + step, *types); |
| 242 | continue; | ||
| 243 | } | ||
| 244 | if (last_fixed_end == base && last_fixed_type == *types) { | ||
| 245 | last_fixed_end = base + step; | ||
| 246 | continue; | ||
| 247 | } | ||
| 248 | /* new segments: gap or different type */ | ||
| 249 | print_fixed_last(); | ||
| 250 | update_fixed_last(base, base + step, *types); | ||
| 251 | } | ||
| 198 | } | 252 | } |
| 199 | 253 | ||
| 200 | static void prepare_set(void); | 254 | static void prepare_set(void); |
| 201 | static void post_set(void); | 255 | static void post_set(void); |
| 202 | 256 | ||
| 257 | static void __init print_mtrr_state(void) | ||
| 258 | { | ||
| 259 | unsigned int i; | ||
| 260 | int high_width; | ||
| 261 | |||
| 262 | printk(KERN_DEBUG "MTRR default type: %s\n", | ||
| 263 | mtrr_attrib_to_str(mtrr_state.def_type)); | ||
| 264 | if (mtrr_state.have_fixed) { | ||
| 265 | printk(KERN_DEBUG "MTRR fixed ranges %sabled:\n", | ||
| 266 | mtrr_state.enabled & 1 ? "en" : "dis"); | ||
| 267 | print_fixed(0x00000, 0x10000, mtrr_state.fixed_ranges + 0); | ||
| 268 | for (i = 0; i < 2; ++i) | ||
| 269 | print_fixed(0x80000 + i * 0x20000, 0x04000, mtrr_state.fixed_ranges + (i + 1) * 8); | ||
| 270 | for (i = 0; i < 8; ++i) | ||
| 271 | print_fixed(0xC0000 + i * 0x08000, 0x01000, mtrr_state.fixed_ranges + (i + 3) * 8); | ||
| 272 | |||
| 273 | /* tail */ | ||
| 274 | print_fixed_last(); | ||
| 275 | } | ||
| 276 | printk(KERN_DEBUG "MTRR variable ranges %sabled:\n", | ||
| 277 | mtrr_state.enabled & 2 ? "en" : "dis"); | ||
| 278 | high_width = ((size_or_mask ? ffs(size_or_mask) - 1 : 32) - (32 - PAGE_SHIFT) + 3) / 4; | ||
| 279 | for (i = 0; i < num_var_ranges; ++i) { | ||
| 280 | if (mtrr_state.var_ranges[i].mask_lo & (1 << 11)) | ||
| 281 | printk(KERN_DEBUG " %u base %0*X%05X000 mask %0*X%05X000 %s\n", | ||
| 282 | i, | ||
| 283 | high_width, | ||
| 284 | mtrr_state.var_ranges[i].base_hi, | ||
| 285 | mtrr_state.var_ranges[i].base_lo >> 12, | ||
| 286 | high_width, | ||
| 287 | mtrr_state.var_ranges[i].mask_hi, | ||
| 288 | mtrr_state.var_ranges[i].mask_lo >> 12, | ||
| 289 | mtrr_attrib_to_str(mtrr_state.var_ranges[i].base_lo & 0xff)); | ||
| 290 | else | ||
| 291 | printk(KERN_DEBUG " %u disabled\n", i); | ||
| 292 | } | ||
| 293 | if (mtrr_tom2) { | ||
| 294 | printk(KERN_DEBUG "TOM2: %016llx aka %lldM\n", | ||
| 295 | mtrr_tom2, mtrr_tom2>>20); | ||
| 296 | } | ||
| 297 | } | ||
| 298 | |||
| 203 | /* Grab all of the MTRR state for this CPU into *state */ | 299 | /* Grab all of the MTRR state for this CPU into *state */ |
| 204 | void __init get_mtrr_state(void) | 300 | void __init get_mtrr_state(void) |
| 205 | { | 301 | { |
| @@ -231,41 +327,9 @@ void __init get_mtrr_state(void) | |||
| 231 | mtrr_tom2 |= low; | 327 | mtrr_tom2 |= low; |
| 232 | mtrr_tom2 &= 0xffffff800000ULL; | 328 | mtrr_tom2 &= 0xffffff800000ULL; |
| 233 | } | 329 | } |
| 234 | if (mtrr_show) { | 330 | |
| 235 | int high_width; | 331 | print_mtrr_state(); |
| 236 | 332 | ||
| 237 | printk(KERN_INFO "MTRR default type: %s\n", mtrr_attrib_to_str(mtrr_state.def_type)); | ||
| 238 | if (mtrr_state.have_fixed) { | ||
| 239 | printk(KERN_INFO "MTRR fixed ranges %sabled:\n", | ||
| 240 | mtrr_state.enabled & 1 ? "en" : "dis"); | ||
| 241 | print_fixed(0x00000, 0x10000, mtrr_state.fixed_ranges + 0); | ||
| 242 | for (i = 0; i < 2; ++i) | ||
| 243 | print_fixed(0x80000 + i * 0x20000, 0x04000, mtrr_state.fixed_ranges + (i + 1) * 8); | ||
| 244 | for (i = 0; i < 8; ++i) | ||
| 245 | print_fixed(0xC0000 + i * 0x08000, 0x01000, mtrr_state.fixed_ranges + (i + 3) * 8); | ||
| 246 | } | ||
| 247 | printk(KERN_INFO "MTRR variable ranges %sabled:\n", | ||
| 248 | mtrr_state.enabled & 2 ? "en" : "dis"); | ||
| 249 | high_width = ((size_or_mask ? ffs(size_or_mask) - 1 : 32) - (32 - PAGE_SHIFT) + 3) / 4; | ||
| 250 | for (i = 0; i < num_var_ranges; ++i) { | ||
| 251 | if (mtrr_state.var_ranges[i].mask_lo & (1 << 11)) | ||
| 252 | printk(KERN_INFO "MTRR %u base %0*X%05X000 mask %0*X%05X000 %s\n", | ||
| 253 | i, | ||
| 254 | high_width, | ||
| 255 | mtrr_state.var_ranges[i].base_hi, | ||
| 256 | mtrr_state.var_ranges[i].base_lo >> 12, | ||
| 257 | high_width, | ||
| 258 | mtrr_state.var_ranges[i].mask_hi, | ||
| 259 | mtrr_state.var_ranges[i].mask_lo >> 12, | ||
| 260 | mtrr_attrib_to_str(mtrr_state.var_ranges[i].base_lo & 0xff)); | ||
| 261 | else | ||
| 262 | printk(KERN_INFO "MTRR %u disabled\n", i); | ||
| 263 | } | ||
| 264 | if (mtrr_tom2) { | ||
| 265 | printk(KERN_INFO "TOM2: %016llx aka %lldM\n", | ||
| 266 | mtrr_tom2, mtrr_tom2>>20); | ||
| 267 | } | ||
| 268 | } | ||
| 269 | mtrr_state_set = 1; | 333 | mtrr_state_set = 1; |
| 270 | 334 | ||
| 271 | /* PAT setup for BP. We need to go through sync steps here */ | 335 | /* PAT setup for BP. We need to go through sync steps here */ |
| @@ -308,27 +372,10 @@ void mtrr_wrmsr(unsigned msr, unsigned a, unsigned b) | |||
| 308 | } | 372 | } |
| 309 | 373 | ||
| 310 | /** | 374 | /** |
| 311 | * Enable and allow read/write of extended fixed-range MTRR bits on K8 CPUs | ||
| 312 | * see AMD publication no. 24593, chapter 3.2.1 for more information | ||
| 313 | */ | ||
| 314 | static inline void k8_enable_fixed_iorrs(void) | ||
| 315 | { | ||
| 316 | unsigned lo, hi; | ||
| 317 | |||
| 318 | rdmsr(MSR_K8_SYSCFG, lo, hi); | ||
| 319 | mtrr_wrmsr(MSR_K8_SYSCFG, lo | ||
| 320 | | K8_MTRRFIXRANGE_DRAM_ENABLE | ||
| 321 | | K8_MTRRFIXRANGE_DRAM_MODIFY, hi); | ||
| 322 | } | ||
| 323 | |||
| 324 | /** | ||
| 325 | * set_fixed_range - checks & updates a fixed-range MTRR if it differs from the value it should have | 375 | * set_fixed_range - checks & updates a fixed-range MTRR if it differs from the value it should have |
| 326 | * @msr: MSR address of the MTTR which should be checked and updated | 376 | * @msr: MSR address of the MTTR which should be checked and updated |
| 327 | * @changed: pointer which indicates whether the MTRR needed to be changed | 377 | * @changed: pointer which indicates whether the MTRR needed to be changed |
| 328 | * @msrwords: pointer to the MSR values which the MSR should have | 378 | * @msrwords: pointer to the MSR values which the MSR should have |
| 329 | * | ||
| 330 | * If K8 extentions are wanted, update the K8 SYSCFG MSR also. | ||
| 331 | * See AMD publication no. 24593, chapter 7.8.1, page 233 for more information. | ||
| 332 | */ | 379 | */ |
| 333 | static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords) | 380 | static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords) |
| 334 | { | 381 | { |
| @@ -337,10 +384,6 @@ static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords) | |||
| 337 | rdmsr(msr, lo, hi); | 384 | rdmsr(msr, lo, hi); |
| 338 | 385 | ||
| 339 | if (lo != msrwords[0] || hi != msrwords[1]) { | 386 | if (lo != msrwords[0] || hi != msrwords[1]) { |
| 340 | if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD && | ||
| 341 | (boot_cpu_data.x86 >= 0x0f && boot_cpu_data.x86 <= 0x11) && | ||
| 342 | ((msrwords[0] | msrwords[1]) & K8_MTRR_RDMEM_WRMEM_MASK)) | ||
| 343 | k8_enable_fixed_iorrs(); | ||
| 344 | mtrr_wrmsr(msr, msrwords[0], msrwords[1]); | 387 | mtrr_wrmsr(msr, msrwords[0], msrwords[1]); |
| 345 | *changed = true; | 388 | *changed = true; |
| 346 | } | 389 | } |
| @@ -376,22 +419,31 @@ static void generic_get_mtrr(unsigned int reg, unsigned long *base, | |||
| 376 | { | 419 | { |
| 377 | unsigned int mask_lo, mask_hi, base_lo, base_hi; | 420 | unsigned int mask_lo, mask_hi, base_lo, base_hi; |
| 378 | unsigned int tmp, hi; | 421 | unsigned int tmp, hi; |
| 422 | int cpu; | ||
| 423 | |||
| 424 | /* | ||
| 425 | * get_mtrr doesn't need to update mtrr_state, also it could be called | ||
| 426 | * from any cpu, so try to print it out directly. | ||
| 427 | */ | ||
| 428 | cpu = get_cpu(); | ||
| 379 | 429 | ||
| 380 | rdmsr(MTRRphysMask_MSR(reg), mask_lo, mask_hi); | 430 | rdmsr(MTRRphysMask_MSR(reg), mask_lo, mask_hi); |
| 431 | |||
| 381 | if ((mask_lo & 0x800) == 0) { | 432 | if ((mask_lo & 0x800) == 0) { |
| 382 | /* Invalid (i.e. free) range */ | 433 | /* Invalid (i.e. free) range */ |
| 383 | *base = 0; | 434 | *base = 0; |
| 384 | *size = 0; | 435 | *size = 0; |
| 385 | *type = 0; | 436 | *type = 0; |
| 386 | return; | 437 | goto out_put_cpu; |
| 387 | } | 438 | } |
| 388 | 439 | ||
| 389 | rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi); | 440 | rdmsr(MTRRphysBase_MSR(reg), base_lo, base_hi); |
| 390 | 441 | ||
| 391 | /* Work out the shifted address mask. */ | 442 | /* Work out the shifted address mask: */ |
| 392 | tmp = mask_hi << (32 - PAGE_SHIFT) | mask_lo >> PAGE_SHIFT; | 443 | tmp = mask_hi << (32 - PAGE_SHIFT) | mask_lo >> PAGE_SHIFT; |
| 393 | mask_lo = size_or_mask | tmp; | 444 | mask_lo = size_or_mask | tmp; |
| 394 | /* Expand tmp with high bits to all 1s*/ | 445 | |
| 446 | /* Expand tmp with high bits to all 1s: */ | ||
| 395 | hi = fls(tmp); | 447 | hi = fls(tmp); |
| 396 | if (hi > 0) { | 448 | if (hi > 0) { |
| 397 | tmp |= ~((1<<(hi - 1)) - 1); | 449 | tmp |= ~((1<<(hi - 1)) - 1); |
| @@ -402,11 +454,19 @@ static void generic_get_mtrr(unsigned int reg, unsigned long *base, | |||
| 402 | } | 454 | } |
| 403 | } | 455 | } |
| 404 | 456 | ||
| 405 | /* This works correctly if size is a power of two, i.e. a | 457 | /* |
| 406 | contiguous range. */ | 458 | * This works correctly if size is a power of two, i.e. a |
| 459 | * contiguous range: | ||
| 460 | */ | ||
| 407 | *size = -mask_lo; | 461 | *size = -mask_lo; |
| 408 | *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT; | 462 | *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT; |
| 409 | *type = base_lo & 0xff; | 463 | *type = base_lo & 0xff; |
| 464 | |||
| 465 | printk(KERN_DEBUG " get_mtrr: cpu%d reg%02d base=%010lx size=%010lx %s\n", | ||
| 466 | cpu, reg, *base, *size, | ||
| 467 | mtrr_attrib_to_str(*type & 0xff)); | ||
| 468 | out_put_cpu: | ||
| 469 | put_cpu(); | ||
| 410 | } | 470 | } |
| 411 | 471 | ||
| 412 | /** | 472 | /** |
| @@ -419,6 +479,8 @@ static int set_fixed_ranges(mtrr_type * frs) | |||
| 419 | bool changed = false; | 479 | bool changed = false; |
| 420 | int block=-1, range; | 480 | int block=-1, range; |
| 421 | 481 | ||
| 482 | k8_check_syscfg_dram_mod_en(); | ||
| 483 | |||
| 422 | while (fixed_range_blocks[++block].ranges) | 484 | while (fixed_range_blocks[++block].ranges) |
| 423 | for (range=0; range < fixed_range_blocks[block].ranges; range++) | 485 | for (range=0; range < fixed_range_blocks[block].ranges; range++) |
| 424 | set_fixed_range(fixed_range_blocks[block].base_msr + range, | 486 | set_fixed_range(fixed_range_blocks[block].base_msr + range, |
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c index 236a401b8259..03cda01f57c7 100644 --- a/arch/x86/kernel/cpu/mtrr/main.c +++ b/arch/x86/kernel/cpu/mtrr/main.c | |||
| @@ -574,7 +574,7 @@ struct mtrr_value { | |||
| 574 | unsigned long lsize; | 574 | unsigned long lsize; |
| 575 | }; | 575 | }; |
| 576 | 576 | ||
| 577 | static struct mtrr_value mtrr_state[MTRR_MAX_VAR_RANGES]; | 577 | static struct mtrr_value mtrr_value[MTRR_MAX_VAR_RANGES]; |
| 578 | 578 | ||
| 579 | static int mtrr_save(struct sys_device * sysdev, pm_message_t state) | 579 | static int mtrr_save(struct sys_device * sysdev, pm_message_t state) |
| 580 | { | 580 | { |
| @@ -582,9 +582,9 @@ static int mtrr_save(struct sys_device * sysdev, pm_message_t state) | |||
| 582 | 582 | ||
| 583 | for (i = 0; i < num_var_ranges; i++) { | 583 | for (i = 0; i < num_var_ranges; i++) { |
| 584 | mtrr_if->get(i, | 584 | mtrr_if->get(i, |
| 585 | &mtrr_state[i].lbase, | 585 | &mtrr_value[i].lbase, |
| 586 | &mtrr_state[i].lsize, | 586 | &mtrr_value[i].lsize, |
| 587 | &mtrr_state[i].ltype); | 587 | &mtrr_value[i].ltype); |
| 588 | } | 588 | } |
| 589 | return 0; | 589 | return 0; |
| 590 | } | 590 | } |
| @@ -594,11 +594,11 @@ static int mtrr_restore(struct sys_device * sysdev) | |||
| 594 | int i; | 594 | int i; |
| 595 | 595 | ||
| 596 | for (i = 0; i < num_var_ranges; i++) { | 596 | for (i = 0; i < num_var_ranges; i++) { |
| 597 | if (mtrr_state[i].lsize) | 597 | if (mtrr_value[i].lsize) |
| 598 | set_mtrr(i, | 598 | set_mtrr(i, |
| 599 | mtrr_state[i].lbase, | 599 | mtrr_value[i].lbase, |
| 600 | mtrr_state[i].lsize, | 600 | mtrr_value[i].lsize, |
| 601 | mtrr_state[i].ltype); | 601 | mtrr_value[i].ltype); |
| 602 | } | 602 | } |
| 603 | return 0; | 603 | return 0; |
| 604 | } | 604 | } |
| @@ -610,1058 +610,7 @@ static struct sysdev_driver mtrr_sysdev_driver = { | |||
| 610 | .resume = mtrr_restore, | 610 | .resume = mtrr_restore, |
| 611 | }; | 611 | }; |
| 612 | 612 | ||
| 613 | /* should be related to MTRR_VAR_RANGES nums */ | 613 | int __initdata changed_by_mtrr_cleanup; |
| 614 | #define RANGE_NUM 256 | ||
| 615 | |||
| 616 | struct res_range { | ||
| 617 | unsigned long start; | ||
| 618 | unsigned long end; | ||
| 619 | }; | ||
| 620 | |||
| 621 | static int __init | ||
| 622 | add_range(struct res_range *range, int nr_range, unsigned long start, | ||
| 623 | unsigned long end) | ||
| 624 | { | ||
| 625 | /* out of slots */ | ||
| 626 | if (nr_range >= RANGE_NUM) | ||
| 627 | return nr_range; | ||
| 628 | |||
| 629 | range[nr_range].start = start; | ||
| 630 | range[nr_range].end = end; | ||
| 631 | |||
| 632 | nr_range++; | ||
| 633 | |||
| 634 | return nr_range; | ||
| 635 | } | ||
| 636 | |||
| 637 | static int __init | ||
| 638 | add_range_with_merge(struct res_range *range, int nr_range, unsigned long start, | ||
| 639 | unsigned long end) | ||
| 640 | { | ||
| 641 | int i; | ||
| 642 | |||
| 643 | /* try to merge it with old one */ | ||
| 644 | for (i = 0; i < nr_range; i++) { | ||
| 645 | unsigned long final_start, final_end; | ||
| 646 | unsigned long common_start, common_end; | ||
| 647 | |||
| 648 | if (!range[i].end) | ||
| 649 | continue; | ||
| 650 | |||
| 651 | common_start = max(range[i].start, start); | ||
| 652 | common_end = min(range[i].end, end); | ||
| 653 | if (common_start > common_end + 1) | ||
| 654 | continue; | ||
| 655 | |||
| 656 | final_start = min(range[i].start, start); | ||
| 657 | final_end = max(range[i].end, end); | ||
| 658 | |||
| 659 | range[i].start = final_start; | ||
| 660 | range[i].end = final_end; | ||
| 661 | return nr_range; | ||
| 662 | } | ||
| 663 | |||
| 664 | /* need to add that */ | ||
| 665 | return add_range(range, nr_range, start, end); | ||
| 666 | } | ||
| 667 | |||
| 668 | static void __init | ||
| 669 | subtract_range(struct res_range *range, unsigned long start, unsigned long end) | ||
| 670 | { | ||
| 671 | int i, j; | ||
| 672 | |||
| 673 | for (j = 0; j < RANGE_NUM; j++) { | ||
| 674 | if (!range[j].end) | ||
| 675 | continue; | ||
| 676 | |||
| 677 | if (start <= range[j].start && end >= range[j].end) { | ||
| 678 | range[j].start = 0; | ||
| 679 | range[j].end = 0; | ||
| 680 | continue; | ||
| 681 | } | ||
| 682 | |||
| 683 | if (start <= range[j].start && end < range[j].end && | ||
| 684 | range[j].start < end + 1) { | ||
| 685 | range[j].start = end + 1; | ||
| 686 | continue; | ||
| 687 | } | ||
| 688 | |||
| 689 | |||
| 690 | if (start > range[j].start && end >= range[j].end && | ||
| 691 | range[j].end > start - 1) { | ||
| 692 | range[j].end = start - 1; | ||
| 693 | continue; | ||
| 694 | } | ||
| 695 | |||
| 696 | if (start > range[j].start && end < range[j].end) { | ||
| 697 | /* find the new spare */ | ||
| 698 | for (i = 0; i < RANGE_NUM; i++) { | ||
| 699 | if (range[i].end == 0) | ||
| 700 | break; | ||
| 701 | } | ||
| 702 | if (i < RANGE_NUM) { | ||
| 703 | range[i].end = range[j].end; | ||
| 704 | range[i].start = end + 1; | ||
| 705 | } else { | ||
| 706 | printk(KERN_ERR "run of slot in ranges\n"); | ||
| 707 | } | ||
| 708 | range[j].end = start - 1; | ||
| 709 | continue; | ||
| 710 | } | ||
| 711 | } | ||
| 712 | } | ||
| 713 | |||
| 714 | static int __init cmp_range(const void *x1, const void *x2) | ||
| 715 | { | ||
| 716 | const struct res_range *r1 = x1; | ||
| 717 | const struct res_range *r2 = x2; | ||
| 718 | long start1, start2; | ||
| 719 | |||
| 720 | start1 = r1->start; | ||
| 721 | start2 = r2->start; | ||
| 722 | |||
| 723 | return start1 - start2; | ||
| 724 | } | ||
| 725 | |||
| 726 | struct var_mtrr_range_state { | ||
| 727 | unsigned long base_pfn; | ||
| 728 | unsigned long size_pfn; | ||
| 729 | mtrr_type type; | ||
| 730 | }; | ||
| 731 | |||
| 732 | static struct var_mtrr_range_state __initdata range_state[RANGE_NUM]; | ||
| 733 | static int __initdata debug_print; | ||
| 734 | |||
| 735 | static int __init | ||
| 736 | x86_get_mtrr_mem_range(struct res_range *range, int nr_range, | ||
| 737 | unsigned long extra_remove_base, | ||
| 738 | unsigned long extra_remove_size) | ||
| 739 | { | ||
| 740 | unsigned long i, base, size; | ||
| 741 | mtrr_type type; | ||
| 742 | |||
| 743 | for (i = 0; i < num_var_ranges; i++) { | ||
| 744 | type = range_state[i].type; | ||
| 745 | if (type != MTRR_TYPE_WRBACK) | ||
| 746 | continue; | ||
| 747 | base = range_state[i].base_pfn; | ||
| 748 | size = range_state[i].size_pfn; | ||
| 749 | nr_range = add_range_with_merge(range, nr_range, base, | ||
| 750 | base + size - 1); | ||
| 751 | } | ||
| 752 | if (debug_print) { | ||
| 753 | printk(KERN_DEBUG "After WB checking\n"); | ||
| 754 | for (i = 0; i < nr_range; i++) | ||
| 755 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 756 | range[i].start, range[i].end + 1); | ||
| 757 | } | ||
| 758 | |||
| 759 | /* take out UC ranges */ | ||
| 760 | for (i = 0; i < num_var_ranges; i++) { | ||
| 761 | type = range_state[i].type; | ||
| 762 | if (type != MTRR_TYPE_UNCACHABLE && | ||
| 763 | type != MTRR_TYPE_WRPROT) | ||
| 764 | continue; | ||
| 765 | size = range_state[i].size_pfn; | ||
| 766 | if (!size) | ||
| 767 | continue; | ||
| 768 | base = range_state[i].base_pfn; | ||
| 769 | subtract_range(range, base, base + size - 1); | ||
| 770 | } | ||
| 771 | if (extra_remove_size) | ||
| 772 | subtract_range(range, extra_remove_base, | ||
| 773 | extra_remove_base + extra_remove_size - 1); | ||
| 774 | |||
| 775 | /* get new range num */ | ||
| 776 | nr_range = 0; | ||
| 777 | for (i = 0; i < RANGE_NUM; i++) { | ||
| 778 | if (!range[i].end) | ||
| 779 | continue; | ||
| 780 | nr_range++; | ||
| 781 | } | ||
| 782 | if (debug_print) { | ||
| 783 | printk(KERN_DEBUG "After UC checking\n"); | ||
| 784 | for (i = 0; i < nr_range; i++) | ||
| 785 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 786 | range[i].start, range[i].end + 1); | ||
| 787 | } | ||
| 788 | |||
| 789 | /* sort the ranges */ | ||
| 790 | sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL); | ||
| 791 | if (debug_print) { | ||
| 792 | printk(KERN_DEBUG "After sorting\n"); | ||
| 793 | for (i = 0; i < nr_range; i++) | ||
| 794 | printk(KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n", | ||
| 795 | range[i].start, range[i].end + 1); | ||
| 796 | } | ||
| 797 | |||
| 798 | /* clear those is not used */ | ||
| 799 | for (i = nr_range; i < RANGE_NUM; i++) | ||
| 800 | memset(&range[i], 0, sizeof(range[i])); | ||
| 801 | |||
| 802 | return nr_range; | ||
| 803 | } | ||
| 804 | |||
| 805 | static struct res_range __initdata range[RANGE_NUM]; | ||
| 806 | static int __initdata nr_range; | ||
| 807 | |||
| 808 | #ifdef CONFIG_MTRR_SANITIZER | ||
| 809 | |||
| 810 | static unsigned long __init sum_ranges(struct res_range *range, int nr_range) | ||
| 811 | { | ||
| 812 | unsigned long sum; | ||
| 813 | int i; | ||
| 814 | |||
| 815 | sum = 0; | ||
| 816 | for (i = 0; i < nr_range; i++) | ||
| 817 | sum += range[i].end + 1 - range[i].start; | ||
| 818 | |||
| 819 | return sum; | ||
| 820 | } | ||
| 821 | |||
| 822 | static int enable_mtrr_cleanup __initdata = | ||
| 823 | CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT; | ||
| 824 | |||
| 825 | static int __init disable_mtrr_cleanup_setup(char *str) | ||
| 826 | { | ||
| 827 | enable_mtrr_cleanup = 0; | ||
| 828 | return 0; | ||
| 829 | } | ||
| 830 | early_param("disable_mtrr_cleanup", disable_mtrr_cleanup_setup); | ||
| 831 | |||
| 832 | static int __init enable_mtrr_cleanup_setup(char *str) | ||
| 833 | { | ||
| 834 | enable_mtrr_cleanup = 1; | ||
| 835 | return 0; | ||
| 836 | } | ||
| 837 | early_param("enable_mtrr_cleanup", enable_mtrr_cleanup_setup); | ||
| 838 | |||
| 839 | static int __init mtrr_cleanup_debug_setup(char *str) | ||
| 840 | { | ||
| 841 | debug_print = 1; | ||
| 842 | return 0; | ||
| 843 | } | ||
| 844 | early_param("mtrr_cleanup_debug", mtrr_cleanup_debug_setup); | ||
| 845 | |||
| 846 | struct var_mtrr_state { | ||
| 847 | unsigned long range_startk; | ||
| 848 | unsigned long range_sizek; | ||
| 849 | unsigned long chunk_sizek; | ||
| 850 | unsigned long gran_sizek; | ||
| 851 | unsigned int reg; | ||
| 852 | }; | ||
| 853 | |||
| 854 | static void __init | ||
| 855 | set_var_mtrr(unsigned int reg, unsigned long basek, unsigned long sizek, | ||
| 856 | unsigned char type, unsigned int address_bits) | ||
| 857 | { | ||
| 858 | u32 base_lo, base_hi, mask_lo, mask_hi; | ||
| 859 | u64 base, mask; | ||
| 860 | |||
| 861 | if (!sizek) { | ||
| 862 | fill_mtrr_var_range(reg, 0, 0, 0, 0); | ||
| 863 | return; | ||
| 864 | } | ||
| 865 | |||
| 866 | mask = (1ULL << address_bits) - 1; | ||
| 867 | mask &= ~((((u64)sizek) << 10) - 1); | ||
| 868 | |||
| 869 | base = ((u64)basek) << 10; | ||
| 870 | |||
| 871 | base |= type; | ||
| 872 | mask |= 0x800; | ||
| 873 | |||
| 874 | base_lo = base & ((1ULL<<32) - 1); | ||
| 875 | base_hi = base >> 32; | ||
| 876 | |||
| 877 | mask_lo = mask & ((1ULL<<32) - 1); | ||
| 878 | mask_hi = mask >> 32; | ||
| 879 | |||
| 880 | fill_mtrr_var_range(reg, base_lo, base_hi, mask_lo, mask_hi); | ||
| 881 | } | ||
| 882 | |||
| 883 | static void __init | ||
| 884 | save_var_mtrr(unsigned int reg, unsigned long basek, unsigned long sizek, | ||
| 885 | unsigned char type) | ||
| 886 | { | ||
| 887 | range_state[reg].base_pfn = basek >> (PAGE_SHIFT - 10); | ||
| 888 | range_state[reg].size_pfn = sizek >> (PAGE_SHIFT - 10); | ||
| 889 | range_state[reg].type = type; | ||
| 890 | } | ||
| 891 | |||
| 892 | static void __init | ||
| 893 | set_var_mtrr_all(unsigned int address_bits) | ||
| 894 | { | ||
| 895 | unsigned long basek, sizek; | ||
| 896 | unsigned char type; | ||
| 897 | unsigned int reg; | ||
| 898 | |||
| 899 | for (reg = 0; reg < num_var_ranges; reg++) { | ||
| 900 | basek = range_state[reg].base_pfn << (PAGE_SHIFT - 10); | ||
| 901 | sizek = range_state[reg].size_pfn << (PAGE_SHIFT - 10); | ||
| 902 | type = range_state[reg].type; | ||
| 903 | |||
| 904 | set_var_mtrr(reg, basek, sizek, type, address_bits); | ||
| 905 | } | ||
| 906 | } | ||
| 907 | |||
| 908 | static unsigned long to_size_factor(unsigned long sizek, char *factorp) | ||
| 909 | { | ||
| 910 | char factor; | ||
| 911 | unsigned long base = sizek; | ||
| 912 | |||
| 913 | if (base & ((1<<10) - 1)) { | ||
| 914 | /* not MB alignment */ | ||
| 915 | factor = 'K'; | ||
| 916 | } else if (base & ((1<<20) - 1)){ | ||
| 917 | factor = 'M'; | ||
| 918 | base >>= 10; | ||
| 919 | } else { | ||
| 920 | factor = 'G'; | ||
| 921 | base >>= 20; | ||
| 922 | } | ||
| 923 | |||
| 924 | *factorp = factor; | ||
| 925 | |||
| 926 | return base; | ||
| 927 | } | ||
| 928 | |||
| 929 | static unsigned int __init | ||
| 930 | range_to_mtrr(unsigned int reg, unsigned long range_startk, | ||
| 931 | unsigned long range_sizek, unsigned char type) | ||
| 932 | { | ||
| 933 | if (!range_sizek || (reg >= num_var_ranges)) | ||
| 934 | return reg; | ||
| 935 | |||
| 936 | while (range_sizek) { | ||
| 937 | unsigned long max_align, align; | ||
| 938 | unsigned long sizek; | ||
| 939 | |||
| 940 | /* Compute the maximum size I can make a range */ | ||
| 941 | if (range_startk) | ||
| 942 | max_align = ffs(range_startk) - 1; | ||
| 943 | else | ||
| 944 | max_align = 32; | ||
| 945 | align = fls(range_sizek) - 1; | ||
| 946 | if (align > max_align) | ||
| 947 | align = max_align; | ||
| 948 | |||
| 949 | sizek = 1 << align; | ||
| 950 | if (debug_print) { | ||
| 951 | char start_factor = 'K', size_factor = 'K'; | ||
| 952 | unsigned long start_base, size_base; | ||
| 953 | |||
| 954 | start_base = to_size_factor(range_startk, &start_factor), | ||
| 955 | size_base = to_size_factor(sizek, &size_factor), | ||
| 956 | |||
| 957 | printk(KERN_DEBUG "Setting variable MTRR %d, " | ||
| 958 | "base: %ld%cB, range: %ld%cB, type %s\n", | ||
| 959 | reg, start_base, start_factor, | ||
| 960 | size_base, size_factor, | ||
| 961 | (type == MTRR_TYPE_UNCACHABLE)?"UC": | ||
| 962 | ((type == MTRR_TYPE_WRBACK)?"WB":"Other") | ||
| 963 | ); | ||
| 964 | } | ||
| 965 | save_var_mtrr(reg++, range_startk, sizek, type); | ||
| 966 | range_startk += sizek; | ||
| 967 | range_sizek -= sizek; | ||
| 968 | if (reg >= num_var_ranges) | ||
| 969 | break; | ||
| 970 | } | ||
| 971 | return reg; | ||
| 972 | } | ||
| 973 | |||
| 974 | static unsigned __init | ||
| 975 | range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek, | ||
| 976 | unsigned long sizek) | ||
| 977 | { | ||
| 978 | unsigned long hole_basek, hole_sizek; | ||
| 979 | unsigned long second_basek, second_sizek; | ||
| 980 | unsigned long range0_basek, range0_sizek; | ||
| 981 | unsigned long range_basek, range_sizek; | ||
| 982 | unsigned long chunk_sizek; | ||
| 983 | unsigned long gran_sizek; | ||
| 984 | |||
| 985 | hole_basek = 0; | ||
| 986 | hole_sizek = 0; | ||
| 987 | second_basek = 0; | ||
| 988 | second_sizek = 0; | ||
| 989 | chunk_sizek = state->chunk_sizek; | ||
| 990 | gran_sizek = state->gran_sizek; | ||
| 991 | |||
| 992 | /* align with gran size, prevent small block used up MTRRs */ | ||
| 993 | range_basek = ALIGN(state->range_startk, gran_sizek); | ||
| 994 | if ((range_basek > basek) && basek) | ||
| 995 | return second_sizek; | ||
| 996 | state->range_sizek -= (range_basek - state->range_startk); | ||
| 997 | range_sizek = ALIGN(state->range_sizek, gran_sizek); | ||
| 998 | |||
| 999 | while (range_sizek > state->range_sizek) { | ||
| 1000 | range_sizek -= gran_sizek; | ||
| 1001 | if (!range_sizek) | ||
| 1002 | return 0; | ||
| 1003 | } | ||
| 1004 | state->range_sizek = range_sizek; | ||
| 1005 | |||
| 1006 | /* try to append some small hole */ | ||
| 1007 | range0_basek = state->range_startk; | ||
| 1008 | range0_sizek = ALIGN(state->range_sizek, chunk_sizek); | ||
| 1009 | |||
| 1010 | /* no increase */ | ||
| 1011 | if (range0_sizek == state->range_sizek) { | ||
| 1012 | if (debug_print) | ||
| 1013 | printk(KERN_DEBUG "rangeX: %016lx - %016lx\n", | ||
| 1014 | range0_basek<<10, | ||
| 1015 | (range0_basek + state->range_sizek)<<10); | ||
| 1016 | state->reg = range_to_mtrr(state->reg, range0_basek, | ||
| 1017 | state->range_sizek, MTRR_TYPE_WRBACK); | ||
| 1018 | return 0; | ||
| 1019 | } | ||
| 1020 | |||
| 1021 | /* only cut back, when it is not the last */ | ||
| 1022 | if (sizek) { | ||
| 1023 | while (range0_basek + range0_sizek > (basek + sizek)) { | ||
| 1024 | if (range0_sizek >= chunk_sizek) | ||
| 1025 | range0_sizek -= chunk_sizek; | ||
| 1026 | else | ||
| 1027 | range0_sizek = 0; | ||
| 1028 | |||
| 1029 | if (!range0_sizek) | ||
| 1030 | break; | ||
| 1031 | } | ||
| 1032 | } | ||
| 1033 | |||
| 1034 | second_try: | ||
| 1035 | range_basek = range0_basek + range0_sizek; | ||
| 1036 | |||
| 1037 | /* one hole in the middle */ | ||
| 1038 | if (range_basek > basek && range_basek <= (basek + sizek)) | ||
| 1039 | second_sizek = range_basek - basek; | ||
| 1040 | |||
| 1041 | if (range0_sizek > state->range_sizek) { | ||
| 1042 | |||
| 1043 | /* one hole in middle or at end */ | ||
| 1044 | hole_sizek = range0_sizek - state->range_sizek - second_sizek; | ||
| 1045 | |||
| 1046 | /* hole size should be less than half of range0 size */ | ||
| 1047 | if (hole_sizek >= (range0_sizek >> 1) && | ||
| 1048 | range0_sizek >= chunk_sizek) { | ||
| 1049 | range0_sizek -= chunk_sizek; | ||
| 1050 | second_sizek = 0; | ||
| 1051 | hole_sizek = 0; | ||
| 1052 | |||
| 1053 | goto second_try; | ||
| 1054 | } | ||
| 1055 | } | ||
| 1056 | |||
| 1057 | if (range0_sizek) { | ||
| 1058 | if (debug_print) | ||
| 1059 | printk(KERN_DEBUG "range0: %016lx - %016lx\n", | ||
| 1060 | range0_basek<<10, | ||
| 1061 | (range0_basek + range0_sizek)<<10); | ||
| 1062 | state->reg = range_to_mtrr(state->reg, range0_basek, | ||
| 1063 | range0_sizek, MTRR_TYPE_WRBACK); | ||
| 1064 | } | ||
| 1065 | |||
| 1066 | if (range0_sizek < state->range_sizek) { | ||
| 1067 | /* need to handle left over */ | ||
| 1068 | range_sizek = state->range_sizek - range0_sizek; | ||
| 1069 | |||
| 1070 | if (debug_print) | ||
| 1071 | printk(KERN_DEBUG "range: %016lx - %016lx\n", | ||
| 1072 | range_basek<<10, | ||
| 1073 | (range_basek + range_sizek)<<10); | ||
| 1074 | state->reg = range_to_mtrr(state->reg, range_basek, | ||
| 1075 | range_sizek, MTRR_TYPE_WRBACK); | ||
| 1076 | } | ||
| 1077 | |||
| 1078 | if (hole_sizek) { | ||
| 1079 | hole_basek = range_basek - hole_sizek - second_sizek; | ||
| 1080 | if (debug_print) | ||
| 1081 | printk(KERN_DEBUG "hole: %016lx - %016lx\n", | ||
| 1082 | hole_basek<<10, | ||
| 1083 | (hole_basek + hole_sizek)<<10); | ||
| 1084 | state->reg = range_to_mtrr(state->reg, hole_basek, | ||
| 1085 | hole_sizek, MTRR_TYPE_UNCACHABLE); | ||
| 1086 | } | ||
| 1087 | |||
| 1088 | return second_sizek; | ||
| 1089 | } | ||
| 1090 | |||
| 1091 | static void __init | ||
| 1092 | set_var_mtrr_range(struct var_mtrr_state *state, unsigned long base_pfn, | ||
| 1093 | unsigned long size_pfn) | ||
| 1094 | { | ||
| 1095 | unsigned long basek, sizek; | ||
| 1096 | unsigned long second_sizek = 0; | ||
| 1097 | |||
| 1098 | if (state->reg >= num_var_ranges) | ||
| 1099 | return; | ||
| 1100 | |||
| 1101 | basek = base_pfn << (PAGE_SHIFT - 10); | ||
| 1102 | sizek = size_pfn << (PAGE_SHIFT - 10); | ||
| 1103 | |||
| 1104 | /* See if I can merge with the last range */ | ||
| 1105 | if ((basek <= 1024) || | ||
| 1106 | (state->range_startk + state->range_sizek == basek)) { | ||
| 1107 | unsigned long endk = basek + sizek; | ||
| 1108 | state->range_sizek = endk - state->range_startk; | ||
| 1109 | return; | ||
| 1110 | } | ||
| 1111 | /* Write the range mtrrs */ | ||
| 1112 | if (state->range_sizek != 0) | ||
| 1113 | second_sizek = range_to_mtrr_with_hole(state, basek, sizek); | ||
| 1114 | |||
| 1115 | /* Allocate an msr */ | ||
| 1116 | state->range_startk = basek + second_sizek; | ||
| 1117 | state->range_sizek = sizek - second_sizek; | ||
| 1118 | } | ||
| 1119 | |||
| 1120 | /* mininum size of mtrr block that can take hole */ | ||
| 1121 | static u64 mtrr_chunk_size __initdata = (256ULL<<20); | ||
| 1122 | |||
| 1123 | static int __init parse_mtrr_chunk_size_opt(char *p) | ||
| 1124 | { | ||
| 1125 | if (!p) | ||
| 1126 | return -EINVAL; | ||
| 1127 | mtrr_chunk_size = memparse(p, &p); | ||
| 1128 | return 0; | ||
| 1129 | } | ||
| 1130 | early_param("mtrr_chunk_size", parse_mtrr_chunk_size_opt); | ||
| 1131 | |||
| 1132 | /* granity of mtrr of block */ | ||
| 1133 | static u64 mtrr_gran_size __initdata; | ||
| 1134 | |||
| 1135 | static int __init parse_mtrr_gran_size_opt(char *p) | ||
| 1136 | { | ||
| 1137 | if (!p) | ||
| 1138 | return -EINVAL; | ||
| 1139 | mtrr_gran_size = memparse(p, &p); | ||
| 1140 | return 0; | ||
| 1141 | } | ||
| 1142 | early_param("mtrr_gran_size", parse_mtrr_gran_size_opt); | ||
| 1143 | |||
| 1144 | static int nr_mtrr_spare_reg __initdata = | ||
| 1145 | CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT; | ||
| 1146 | |||
| 1147 | static int __init parse_mtrr_spare_reg(char *arg) | ||
| 1148 | { | ||
| 1149 | if (arg) | ||
| 1150 | nr_mtrr_spare_reg = simple_strtoul(arg, NULL, 0); | ||
| 1151 | return 0; | ||
| 1152 | } | ||
| 1153 | |||
| 1154 | early_param("mtrr_spare_reg_nr", parse_mtrr_spare_reg); | ||
| 1155 | |||
| 1156 | static int __init | ||
| 1157 | x86_setup_var_mtrrs(struct res_range *range, int nr_range, | ||
| 1158 | u64 chunk_size, u64 gran_size) | ||
| 1159 | { | ||
| 1160 | struct var_mtrr_state var_state; | ||
| 1161 | int i; | ||
| 1162 | int num_reg; | ||
| 1163 | |||
| 1164 | var_state.range_startk = 0; | ||
| 1165 | var_state.range_sizek = 0; | ||
| 1166 | var_state.reg = 0; | ||
| 1167 | var_state.chunk_sizek = chunk_size >> 10; | ||
| 1168 | var_state.gran_sizek = gran_size >> 10; | ||
| 1169 | |||
| 1170 | memset(range_state, 0, sizeof(range_state)); | ||
| 1171 | |||
| 1172 | /* Write the range etc */ | ||
| 1173 | for (i = 0; i < nr_range; i++) | ||
| 1174 | set_var_mtrr_range(&var_state, range[i].start, | ||
| 1175 | range[i].end - range[i].start + 1); | ||
| 1176 | |||
| 1177 | /* Write the last range */ | ||
| 1178 | if (var_state.range_sizek != 0) | ||
| 1179 | range_to_mtrr_with_hole(&var_state, 0, 0); | ||
| 1180 | |||
| 1181 | num_reg = var_state.reg; | ||
| 1182 | /* Clear out the extra MTRR's */ | ||
| 1183 | while (var_state.reg < num_var_ranges) { | ||
| 1184 | save_var_mtrr(var_state.reg, 0, 0, 0); | ||
| 1185 | var_state.reg++; | ||
| 1186 | } | ||
| 1187 | |||
| 1188 | return num_reg; | ||
| 1189 | } | ||
| 1190 | |||
| 1191 | struct mtrr_cleanup_result { | ||
| 1192 | unsigned long gran_sizek; | ||
| 1193 | unsigned long chunk_sizek; | ||
| 1194 | unsigned long lose_cover_sizek; | ||
| 1195 | unsigned int num_reg; | ||
| 1196 | int bad; | ||
| 1197 | }; | ||
| 1198 | |||
| 1199 | /* | ||
| 1200 | * gran_size: 64K, 128K, 256K, 512K, 1M, 2M, ..., 2G | ||
| 1201 | * chunk size: gran_size, ..., 2G | ||
| 1202 | * so we need (1+16)*8 | ||
| 1203 | */ | ||
| 1204 | #define NUM_RESULT 136 | ||
| 1205 | #define PSHIFT (PAGE_SHIFT - 10) | ||
| 1206 | |||
| 1207 | static struct mtrr_cleanup_result __initdata result[NUM_RESULT]; | ||
| 1208 | static unsigned long __initdata min_loss_pfn[RANGE_NUM]; | ||
| 1209 | |||
| 1210 | static void __init print_out_mtrr_range_state(void) | ||
| 1211 | { | ||
| 1212 | int i; | ||
| 1213 | char start_factor = 'K', size_factor = 'K'; | ||
| 1214 | unsigned long start_base, size_base; | ||
| 1215 | mtrr_type type; | ||
| 1216 | |||
| 1217 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1218 | |||
| 1219 | size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10); | ||
| 1220 | if (!size_base) | ||
| 1221 | continue; | ||
| 1222 | |||
| 1223 | size_base = to_size_factor(size_base, &size_factor), | ||
| 1224 | start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10); | ||
| 1225 | start_base = to_size_factor(start_base, &start_factor), | ||
| 1226 | type = range_state[i].type; | ||
| 1227 | |||
| 1228 | printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n", | ||
| 1229 | i, start_base, start_factor, | ||
| 1230 | size_base, size_factor, | ||
| 1231 | (type == MTRR_TYPE_UNCACHABLE) ? "UC" : | ||
| 1232 | ((type == MTRR_TYPE_WRPROT) ? "WP" : | ||
| 1233 | ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other")) | ||
| 1234 | ); | ||
| 1235 | } | ||
| 1236 | } | ||
| 1237 | |||
| 1238 | static int __init mtrr_need_cleanup(void) | ||
| 1239 | { | ||
| 1240 | int i; | ||
| 1241 | mtrr_type type; | ||
| 1242 | unsigned long size; | ||
| 1243 | /* extra one for all 0 */ | ||
| 1244 | int num[MTRR_NUM_TYPES + 1]; | ||
| 1245 | |||
| 1246 | /* check entries number */ | ||
| 1247 | memset(num, 0, sizeof(num)); | ||
| 1248 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1249 | type = range_state[i].type; | ||
| 1250 | size = range_state[i].size_pfn; | ||
| 1251 | if (type >= MTRR_NUM_TYPES) | ||
| 1252 | continue; | ||
| 1253 | if (!size) | ||
| 1254 | type = MTRR_NUM_TYPES; | ||
| 1255 | if (type == MTRR_TYPE_WRPROT) | ||
| 1256 | type = MTRR_TYPE_UNCACHABLE; | ||
| 1257 | num[type]++; | ||
| 1258 | } | ||
| 1259 | |||
| 1260 | /* check if we got UC entries */ | ||
| 1261 | if (!num[MTRR_TYPE_UNCACHABLE]) | ||
| 1262 | return 0; | ||
| 1263 | |||
| 1264 | /* check if we only had WB and UC */ | ||
| 1265 | if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] != | ||
| 1266 | num_var_ranges - num[MTRR_NUM_TYPES]) | ||
| 1267 | return 0; | ||
| 1268 | |||
| 1269 | return 1; | ||
| 1270 | } | ||
| 1271 | |||
| 1272 | static unsigned long __initdata range_sums; | ||
| 1273 | static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size, | ||
| 1274 | unsigned long extra_remove_base, | ||
| 1275 | unsigned long extra_remove_size, | ||
| 1276 | int i) | ||
| 1277 | { | ||
| 1278 | int num_reg; | ||
| 1279 | static struct res_range range_new[RANGE_NUM]; | ||
| 1280 | static int nr_range_new; | ||
| 1281 | unsigned long range_sums_new; | ||
| 1282 | |||
| 1283 | /* convert ranges to var ranges state */ | ||
| 1284 | num_reg = x86_setup_var_mtrrs(range, nr_range, | ||
| 1285 | chunk_size, gran_size); | ||
| 1286 | |||
| 1287 | /* we got new setting in range_state, check it */ | ||
| 1288 | memset(range_new, 0, sizeof(range_new)); | ||
| 1289 | nr_range_new = x86_get_mtrr_mem_range(range_new, 0, | ||
| 1290 | extra_remove_base, extra_remove_size); | ||
| 1291 | range_sums_new = sum_ranges(range_new, nr_range_new); | ||
| 1292 | |||
| 1293 | result[i].chunk_sizek = chunk_size >> 10; | ||
| 1294 | result[i].gran_sizek = gran_size >> 10; | ||
| 1295 | result[i].num_reg = num_reg; | ||
| 1296 | if (range_sums < range_sums_new) { | ||
| 1297 | result[i].lose_cover_sizek = | ||
| 1298 | (range_sums_new - range_sums) << PSHIFT; | ||
| 1299 | result[i].bad = 1; | ||
| 1300 | } else | ||
| 1301 | result[i].lose_cover_sizek = | ||
| 1302 | (range_sums - range_sums_new) << PSHIFT; | ||
| 1303 | |||
| 1304 | /* double check it */ | ||
| 1305 | if (!result[i].bad && !result[i].lose_cover_sizek) { | ||
| 1306 | if (nr_range_new != nr_range || | ||
| 1307 | memcmp(range, range_new, sizeof(range))) | ||
| 1308 | result[i].bad = 1; | ||
| 1309 | } | ||
| 1310 | |||
| 1311 | if (!result[i].bad && (range_sums - range_sums_new < | ||
| 1312 | min_loss_pfn[num_reg])) { | ||
| 1313 | min_loss_pfn[num_reg] = | ||
| 1314 | range_sums - range_sums_new; | ||
| 1315 | } | ||
| 1316 | } | ||
| 1317 | |||
| 1318 | static void __init mtrr_print_out_one_result(int i) | ||
| 1319 | { | ||
| 1320 | char gran_factor, chunk_factor, lose_factor; | ||
| 1321 | unsigned long gran_base, chunk_base, lose_base; | ||
| 1322 | |||
| 1323 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | ||
| 1324 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | ||
| 1325 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
| 1326 | printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t", | ||
| 1327 | result[i].bad ? "*BAD*" : " ", | ||
| 1328 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
| 1329 | printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n", | ||
| 1330 | result[i].num_reg, result[i].bad ? "-" : "", | ||
| 1331 | lose_base, lose_factor); | ||
| 1332 | } | ||
| 1333 | |||
| 1334 | static int __init mtrr_search_optimal_index(void) | ||
| 1335 | { | ||
| 1336 | int i; | ||
| 1337 | int num_reg_good; | ||
| 1338 | int index_good; | ||
| 1339 | |||
| 1340 | if (nr_mtrr_spare_reg >= num_var_ranges) | ||
| 1341 | nr_mtrr_spare_reg = num_var_ranges - 1; | ||
| 1342 | num_reg_good = -1; | ||
| 1343 | for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) { | ||
| 1344 | if (!min_loss_pfn[i]) | ||
| 1345 | num_reg_good = i; | ||
| 1346 | } | ||
| 1347 | |||
| 1348 | index_good = -1; | ||
| 1349 | if (num_reg_good != -1) { | ||
| 1350 | for (i = 0; i < NUM_RESULT; i++) { | ||
| 1351 | if (!result[i].bad && | ||
| 1352 | result[i].num_reg == num_reg_good && | ||
| 1353 | !result[i].lose_cover_sizek) { | ||
| 1354 | index_good = i; | ||
| 1355 | break; | ||
| 1356 | } | ||
| 1357 | } | ||
| 1358 | } | ||
| 1359 | |||
| 1360 | return index_good; | ||
| 1361 | } | ||
| 1362 | |||
| 1363 | |||
| 1364 | static int __init mtrr_cleanup(unsigned address_bits) | ||
| 1365 | { | ||
| 1366 | unsigned long extra_remove_base, extra_remove_size; | ||
| 1367 | unsigned long base, size, def, dummy; | ||
| 1368 | mtrr_type type; | ||
| 1369 | u64 chunk_size, gran_size; | ||
| 1370 | int index_good; | ||
| 1371 | int i; | ||
| 1372 | |||
| 1373 | if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1) | ||
| 1374 | return 0; | ||
| 1375 | rdmsr(MTRRdefType_MSR, def, dummy); | ||
| 1376 | def &= 0xff; | ||
| 1377 | if (def != MTRR_TYPE_UNCACHABLE) | ||
| 1378 | return 0; | ||
| 1379 | |||
| 1380 | /* get it and store it aside */ | ||
| 1381 | memset(range_state, 0, sizeof(range_state)); | ||
| 1382 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1383 | mtrr_if->get(i, &base, &size, &type); | ||
| 1384 | range_state[i].base_pfn = base; | ||
| 1385 | range_state[i].size_pfn = size; | ||
| 1386 | range_state[i].type = type; | ||
| 1387 | } | ||
| 1388 | |||
| 1389 | /* check if we need handle it and can handle it */ | ||
| 1390 | if (!mtrr_need_cleanup()) | ||
| 1391 | return 0; | ||
| 1392 | |||
| 1393 | /* print original var MTRRs at first, for debugging: */ | ||
| 1394 | printk(KERN_DEBUG "original variable MTRRs\n"); | ||
| 1395 | print_out_mtrr_range_state(); | ||
| 1396 | |||
| 1397 | memset(range, 0, sizeof(range)); | ||
| 1398 | extra_remove_size = 0; | ||
| 1399 | extra_remove_base = 1 << (32 - PAGE_SHIFT); | ||
| 1400 | if (mtrr_tom2) | ||
| 1401 | extra_remove_size = | ||
| 1402 | (mtrr_tom2 >> PAGE_SHIFT) - extra_remove_base; | ||
| 1403 | nr_range = x86_get_mtrr_mem_range(range, 0, extra_remove_base, | ||
| 1404 | extra_remove_size); | ||
| 1405 | /* | ||
| 1406 | * [0, 1M) should always be coverred by var mtrr with WB | ||
| 1407 | * and fixed mtrrs should take effective before var mtrr for it | ||
| 1408 | */ | ||
| 1409 | nr_range = add_range_with_merge(range, nr_range, 0, | ||
| 1410 | (1ULL<<(20 - PAGE_SHIFT)) - 1); | ||
| 1411 | /* sort the ranges */ | ||
| 1412 | sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL); | ||
| 1413 | |||
| 1414 | range_sums = sum_ranges(range, nr_range); | ||
| 1415 | printk(KERN_INFO "total RAM coverred: %ldM\n", | ||
| 1416 | range_sums >> (20 - PAGE_SHIFT)); | ||
| 1417 | |||
| 1418 | if (mtrr_chunk_size && mtrr_gran_size) { | ||
| 1419 | i = 0; | ||
| 1420 | mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size, | ||
| 1421 | extra_remove_base, extra_remove_size, i); | ||
| 1422 | |||
| 1423 | mtrr_print_out_one_result(i); | ||
| 1424 | |||
| 1425 | if (!result[i].bad) { | ||
| 1426 | set_var_mtrr_all(address_bits); | ||
| 1427 | return 1; | ||
| 1428 | } | ||
| 1429 | printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, " | ||
| 1430 | "will find optimal one\n"); | ||
| 1431 | } | ||
| 1432 | |||
| 1433 | i = 0; | ||
| 1434 | memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn)); | ||
| 1435 | memset(result, 0, sizeof(result)); | ||
| 1436 | for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) { | ||
| 1437 | |||
| 1438 | for (chunk_size = gran_size; chunk_size < (1ULL<<32); | ||
| 1439 | chunk_size <<= 1) { | ||
| 1440 | |||
| 1441 | if (i >= NUM_RESULT) | ||
| 1442 | continue; | ||
| 1443 | |||
| 1444 | mtrr_calc_range_state(chunk_size, gran_size, | ||
| 1445 | extra_remove_base, extra_remove_size, i); | ||
| 1446 | if (debug_print) { | ||
| 1447 | mtrr_print_out_one_result(i); | ||
| 1448 | printk(KERN_INFO "\n"); | ||
| 1449 | } | ||
| 1450 | |||
| 1451 | i++; | ||
| 1452 | } | ||
| 1453 | } | ||
| 1454 | |||
| 1455 | /* try to find the optimal index */ | ||
| 1456 | index_good = mtrr_search_optimal_index(); | ||
| 1457 | |||
| 1458 | if (index_good != -1) { | ||
| 1459 | printk(KERN_INFO "Found optimal setting for mtrr clean up\n"); | ||
| 1460 | i = index_good; | ||
| 1461 | mtrr_print_out_one_result(i); | ||
| 1462 | |||
| 1463 | /* convert ranges to var ranges state */ | ||
| 1464 | chunk_size = result[i].chunk_sizek; | ||
| 1465 | chunk_size <<= 10; | ||
| 1466 | gran_size = result[i].gran_sizek; | ||
| 1467 | gran_size <<= 10; | ||
| 1468 | x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size); | ||
| 1469 | set_var_mtrr_all(address_bits); | ||
| 1470 | printk(KERN_DEBUG "New variable MTRRs\n"); | ||
| 1471 | print_out_mtrr_range_state(); | ||
| 1472 | return 1; | ||
| 1473 | } else { | ||
| 1474 | /* print out all */ | ||
| 1475 | for (i = 0; i < NUM_RESULT; i++) | ||
| 1476 | mtrr_print_out_one_result(i); | ||
| 1477 | } | ||
| 1478 | |||
| 1479 | printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n"); | ||
| 1480 | printk(KERN_INFO "please specify mtrr_gran_size/mtrr_chunk_size\n"); | ||
| 1481 | |||
| 1482 | return 0; | ||
| 1483 | } | ||
| 1484 | #else | ||
| 1485 | static int __init mtrr_cleanup(unsigned address_bits) | ||
| 1486 | { | ||
| 1487 | return 0; | ||
| 1488 | } | ||
| 1489 | #endif | ||
| 1490 | |||
| 1491 | static int __initdata changed_by_mtrr_cleanup; | ||
| 1492 | |||
| 1493 | static int disable_mtrr_trim; | ||
| 1494 | |||
| 1495 | static int __init disable_mtrr_trim_setup(char *str) | ||
| 1496 | { | ||
| 1497 | disable_mtrr_trim = 1; | ||
| 1498 | return 0; | ||
| 1499 | } | ||
| 1500 | early_param("disable_mtrr_trim", disable_mtrr_trim_setup); | ||
| 1501 | |||
| 1502 | /* | ||
| 1503 | * Newer AMD K8s and later CPUs have a special magic MSR way to force WB | ||
| 1504 | * for memory >4GB. Check for that here. | ||
| 1505 | * Note this won't check if the MTRRs < 4GB where the magic bit doesn't | ||
| 1506 | * apply to are wrong, but so far we don't know of any such case in the wild. | ||
| 1507 | */ | ||
| 1508 | #define Tom2Enabled (1U << 21) | ||
| 1509 | #define Tom2ForceMemTypeWB (1U << 22) | ||
| 1510 | |||
| 1511 | int __init amd_special_default_mtrr(void) | ||
| 1512 | { | ||
| 1513 | u32 l, h; | ||
| 1514 | |||
| 1515 | if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD) | ||
| 1516 | return 0; | ||
| 1517 | if (boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x11) | ||
| 1518 | return 0; | ||
| 1519 | /* In case some hypervisor doesn't pass SYSCFG through */ | ||
| 1520 | if (rdmsr_safe(MSR_K8_SYSCFG, &l, &h) < 0) | ||
| 1521 | return 0; | ||
| 1522 | /* | ||
| 1523 | * Memory between 4GB and top of mem is forced WB by this magic bit. | ||
| 1524 | * Reserved before K8RevF, but should be zero there. | ||
| 1525 | */ | ||
| 1526 | if ((l & (Tom2Enabled | Tom2ForceMemTypeWB)) == | ||
| 1527 | (Tom2Enabled | Tom2ForceMemTypeWB)) | ||
| 1528 | return 1; | ||
| 1529 | return 0; | ||
| 1530 | } | ||
| 1531 | |||
| 1532 | static u64 __init real_trim_memory(unsigned long start_pfn, | ||
| 1533 | unsigned long limit_pfn) | ||
| 1534 | { | ||
| 1535 | u64 trim_start, trim_size; | ||
| 1536 | trim_start = start_pfn; | ||
| 1537 | trim_start <<= PAGE_SHIFT; | ||
| 1538 | trim_size = limit_pfn; | ||
| 1539 | trim_size <<= PAGE_SHIFT; | ||
| 1540 | trim_size -= trim_start; | ||
| 1541 | |||
| 1542 | return e820_update_range(trim_start, trim_size, E820_RAM, | ||
| 1543 | E820_RESERVED); | ||
| 1544 | } | ||
| 1545 | /** | ||
| 1546 | * mtrr_trim_uncached_memory - trim RAM not covered by MTRRs | ||
| 1547 | * @end_pfn: ending page frame number | ||
| 1548 | * | ||
| 1549 | * Some buggy BIOSes don't setup the MTRRs properly for systems with certain | ||
| 1550 | * memory configurations. This routine checks that the highest MTRR matches | ||
| 1551 | * the end of memory, to make sure the MTRRs having a write back type cover | ||
| 1552 | * all of the memory the kernel is intending to use. If not, it'll trim any | ||
| 1553 | * memory off the end by adjusting end_pfn, removing it from the kernel's | ||
| 1554 | * allocation pools, warning the user with an obnoxious message. | ||
| 1555 | */ | ||
| 1556 | int __init mtrr_trim_uncached_memory(unsigned long end_pfn) | ||
| 1557 | { | ||
| 1558 | unsigned long i, base, size, highest_pfn = 0, def, dummy; | ||
| 1559 | mtrr_type type; | ||
| 1560 | u64 total_trim_size; | ||
| 1561 | |||
| 1562 | /* extra one for all 0 */ | ||
| 1563 | int num[MTRR_NUM_TYPES + 1]; | ||
| 1564 | /* | ||
| 1565 | * Make sure we only trim uncachable memory on machines that | ||
| 1566 | * support the Intel MTRR architecture: | ||
| 1567 | */ | ||
| 1568 | if (!is_cpu(INTEL) || disable_mtrr_trim) | ||
| 1569 | return 0; | ||
| 1570 | rdmsr(MTRRdefType_MSR, def, dummy); | ||
| 1571 | def &= 0xff; | ||
| 1572 | if (def != MTRR_TYPE_UNCACHABLE) | ||
| 1573 | return 0; | ||
| 1574 | |||
| 1575 | /* get it and store it aside */ | ||
| 1576 | memset(range_state, 0, sizeof(range_state)); | ||
| 1577 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1578 | mtrr_if->get(i, &base, &size, &type); | ||
| 1579 | range_state[i].base_pfn = base; | ||
| 1580 | range_state[i].size_pfn = size; | ||
| 1581 | range_state[i].type = type; | ||
| 1582 | } | ||
| 1583 | |||
| 1584 | /* Find highest cached pfn */ | ||
| 1585 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1586 | type = range_state[i].type; | ||
| 1587 | if (type != MTRR_TYPE_WRBACK) | ||
| 1588 | continue; | ||
| 1589 | base = range_state[i].base_pfn; | ||
| 1590 | size = range_state[i].size_pfn; | ||
| 1591 | if (highest_pfn < base + size) | ||
| 1592 | highest_pfn = base + size; | ||
| 1593 | } | ||
| 1594 | |||
| 1595 | /* kvm/qemu doesn't have mtrr set right, don't trim them all */ | ||
| 1596 | if (!highest_pfn) { | ||
| 1597 | printk(KERN_INFO "CPU MTRRs all blank - virtualized system.\n"); | ||
| 1598 | return 0; | ||
| 1599 | } | ||
| 1600 | |||
| 1601 | /* check entries number */ | ||
| 1602 | memset(num, 0, sizeof(num)); | ||
| 1603 | for (i = 0; i < num_var_ranges; i++) { | ||
| 1604 | type = range_state[i].type; | ||
| 1605 | if (type >= MTRR_NUM_TYPES) | ||
| 1606 | continue; | ||
| 1607 | size = range_state[i].size_pfn; | ||
| 1608 | if (!size) | ||
| 1609 | type = MTRR_NUM_TYPES; | ||
| 1610 | num[type]++; | ||
| 1611 | } | ||
| 1612 | |||
| 1613 | /* no entry for WB? */ | ||
| 1614 | if (!num[MTRR_TYPE_WRBACK]) | ||
| 1615 | return 0; | ||
| 1616 | |||
| 1617 | /* check if we only had WB and UC */ | ||
| 1618 | if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] != | ||
| 1619 | num_var_ranges - num[MTRR_NUM_TYPES]) | ||
| 1620 | return 0; | ||
| 1621 | |||
| 1622 | memset(range, 0, sizeof(range)); | ||
| 1623 | nr_range = 0; | ||
| 1624 | if (mtrr_tom2) { | ||
| 1625 | range[nr_range].start = (1ULL<<(32 - PAGE_SHIFT)); | ||
| 1626 | range[nr_range].end = (mtrr_tom2 >> PAGE_SHIFT) - 1; | ||
| 1627 | if (highest_pfn < range[nr_range].end + 1) | ||
| 1628 | highest_pfn = range[nr_range].end + 1; | ||
| 1629 | nr_range++; | ||
| 1630 | } | ||
| 1631 | nr_range = x86_get_mtrr_mem_range(range, nr_range, 0, 0); | ||
| 1632 | |||
| 1633 | total_trim_size = 0; | ||
| 1634 | /* check the head */ | ||
| 1635 | if (range[0].start) | ||
| 1636 | total_trim_size += real_trim_memory(0, range[0].start); | ||
| 1637 | /* check the holes */ | ||
| 1638 | for (i = 0; i < nr_range - 1; i++) { | ||
| 1639 | if (range[i].end + 1 < range[i+1].start) | ||
| 1640 | total_trim_size += real_trim_memory(range[i].end + 1, | ||
| 1641 | range[i+1].start); | ||
| 1642 | } | ||
| 1643 | /* check the top */ | ||
| 1644 | i = nr_range - 1; | ||
| 1645 | if (range[i].end + 1 < end_pfn) | ||
| 1646 | total_trim_size += real_trim_memory(range[i].end + 1, | ||
| 1647 | end_pfn); | ||
| 1648 | |||
| 1649 | if (total_trim_size) { | ||
| 1650 | printk(KERN_WARNING "WARNING: BIOS bug: CPU MTRRs don't cover" | ||
| 1651 | " all of memory, losing %lluMB of RAM.\n", | ||
| 1652 | total_trim_size >> 20); | ||
| 1653 | |||
| 1654 | if (!changed_by_mtrr_cleanup) | ||
| 1655 | WARN_ON(1); | ||
| 1656 | |||
| 1657 | printk(KERN_INFO "update e820 for mtrr\n"); | ||
| 1658 | update_e820(); | ||
| 1659 | |||
| 1660 | return 1; | ||
| 1661 | } | ||
| 1662 | |||
| 1663 | return 0; | ||
| 1664 | } | ||
| 1665 | 614 | ||
| 1666 | /** | 615 | /** |
| 1667 | * mtrr_bp_init - initialize mtrrs on the boot CPU | 616 | * mtrr_bp_init - initialize mtrrs on the boot CPU |
diff --git a/arch/x86/kernel/cpu/mtrr/mtrr.h b/arch/x86/kernel/cpu/mtrr/mtrr.h index ffd60409cc6d..77f67f7b347a 100644 --- a/arch/x86/kernel/cpu/mtrr/mtrr.h +++ b/arch/x86/kernel/cpu/mtrr/mtrr.h | |||
| @@ -79,6 +79,7 @@ extern struct mtrr_ops * mtrr_if; | |||
| 79 | 79 | ||
| 80 | extern unsigned int num_var_ranges; | 80 | extern unsigned int num_var_ranges; |
| 81 | extern u64 mtrr_tom2; | 81 | extern u64 mtrr_tom2; |
| 82 | extern struct mtrr_state_type mtrr_state; | ||
| 82 | 83 | ||
| 83 | void mtrr_state_warn(void); | 84 | void mtrr_state_warn(void); |
| 84 | const char *mtrr_attrib_to_str(int x); | 85 | const char *mtrr_attrib_to_str(int x); |
| @@ -88,3 +89,6 @@ void mtrr_wrmsr(unsigned, unsigned, unsigned); | |||
| 88 | int amd_init_mtrr(void); | 89 | int amd_init_mtrr(void); |
| 89 | int cyrix_init_mtrr(void); | 90 | int cyrix_init_mtrr(void); |
| 90 | int centaur_init_mtrr(void); | 91 | int centaur_init_mtrr(void); |
| 92 | |||
| 93 | extern int changed_by_mtrr_cleanup; | ||
| 94 | extern int mtrr_cleanup(unsigned address_bits); | ||
diff --git a/arch/x86/kernel/cpu/transmeta.c b/arch/x86/kernel/cpu/transmeta.c index 52b3fefbd5af..bb62b3e5caad 100644 --- a/arch/x86/kernel/cpu/transmeta.c +++ b/arch/x86/kernel/cpu/transmeta.c | |||
| @@ -98,7 +98,7 @@ static void __cpuinit init_transmeta(struct cpuinfo_x86 *c) | |||
| 98 | #endif | 98 | #endif |
| 99 | } | 99 | } |
| 100 | 100 | ||
| 101 | static struct cpu_dev transmeta_cpu_dev __cpuinitdata = { | 101 | static const struct cpu_dev __cpuinitconst transmeta_cpu_dev = { |
| 102 | .c_vendor = "Transmeta", | 102 | .c_vendor = "Transmeta", |
| 103 | .c_ident = { "GenuineTMx86", "TransmetaCPU" }, | 103 | .c_ident = { "GenuineTMx86", "TransmetaCPU" }, |
| 104 | .c_early_init = early_init_transmeta, | 104 | .c_early_init = early_init_transmeta, |
diff --git a/arch/x86/kernel/cpu/umc.c b/arch/x86/kernel/cpu/umc.c index e777f79e0960..fd2c37bf7acb 100644 --- a/arch/x86/kernel/cpu/umc.c +++ b/arch/x86/kernel/cpu/umc.c | |||
| @@ -8,7 +8,7 @@ | |||
| 8 | * so no special init takes place. | 8 | * so no special init takes place. |
| 9 | */ | 9 | */ |
| 10 | 10 | ||
| 11 | static struct cpu_dev umc_cpu_dev __cpuinitdata = { | 11 | static const struct cpu_dev __cpuinitconst umc_cpu_dev = { |
| 12 | .c_vendor = "UMC", | 12 | .c_vendor = "UMC", |
| 13 | .c_ident = { "UMC UMC UMC" }, | 13 | .c_ident = { "UMC UMC UMC" }, |
| 14 | .c_models = { | 14 | .c_models = { |
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c index 508bec1cee27..ef2c3563357d 100644 --- a/arch/x86/kernel/e820.c +++ b/arch/x86/kernel/e820.c | |||
| @@ -110,19 +110,50 @@ int __init e820_all_mapped(u64 start, u64 end, unsigned type) | |||
| 110 | /* | 110 | /* |
| 111 | * Add a memory region to the kernel e820 map. | 111 | * Add a memory region to the kernel e820 map. |
| 112 | */ | 112 | */ |
| 113 | void __init e820_add_region(u64 start, u64 size, int type) | 113 | static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size, |
| 114 | int type) | ||
| 114 | { | 115 | { |
| 115 | int x = e820.nr_map; | 116 | int x = e820x->nr_map; |
| 116 | 117 | ||
| 117 | if (x == ARRAY_SIZE(e820.map)) { | 118 | if (x == ARRAY_SIZE(e820x->map)) { |
| 118 | printk(KERN_ERR "Ooops! Too many entries in the memory map!\n"); | 119 | printk(KERN_ERR "Ooops! Too many entries in the memory map!\n"); |
| 119 | return; | 120 | return; |
| 120 | } | 121 | } |
| 121 | 122 | ||
| 122 | e820.map[x].addr = start; | 123 | e820x->map[x].addr = start; |
| 123 | e820.map[x].size = size; | 124 | e820x->map[x].size = size; |
| 124 | e820.map[x].type = type; | 125 | e820x->map[x].type = type; |
| 125 | e820.nr_map++; | 126 | e820x->nr_map++; |
| 127 | } | ||
| 128 | |||
| 129 | void __init e820_add_region(u64 start, u64 size, int type) | ||
| 130 | { | ||
| 131 | __e820_add_region(&e820, start, size, type); | ||
| 132 | } | ||
| 133 | |||
| 134 | static void __init e820_print_type(u32 type) | ||
| 135 | { | ||
| 136 | switch (type) { | ||
| 137 | case E820_RAM: | ||
| 138 | case E820_RESERVED_KERN: | ||
| 139 | printk(KERN_CONT "(usable)"); | ||
| 140 | break; | ||
| 141 | case E820_RESERVED: | ||
| 142 | printk(KERN_CONT "(reserved)"); | ||
| 143 | break; | ||
| 144 | case E820_ACPI: | ||
| 145 | printk(KERN_CONT "(ACPI data)"); | ||
| 146 | break; | ||
| 147 | case E820_NVS: | ||
| 148 | printk(KERN_CONT "(ACPI NVS)"); | ||
| 149 | break; | ||
| 150 | case E820_UNUSABLE: | ||
| 151 | printk(KERN_CONT "(unusable)"); | ||
| 152 | break; | ||
| 153 | default: | ||
| 154 | printk(KERN_CONT "type %u", type); | ||
| 155 | break; | ||
| 156 | } | ||
| 126 | } | 157 | } |
| 127 | 158 | ||
| 128 | void __init e820_print_map(char *who) | 159 | void __init e820_print_map(char *who) |
| @@ -134,27 +165,8 @@ void __init e820_print_map(char *who) | |||
| 134 | (unsigned long long) e820.map[i].addr, | 165 | (unsigned long long) e820.map[i].addr, |
| 135 | (unsigned long long) | 166 | (unsigned long long) |
| 136 | (e820.map[i].addr + e820.map[i].size)); | 167 | (e820.map[i].addr + e820.map[i].size)); |
| 137 | switch (e820.map[i].type) { | 168 | e820_print_type(e820.map[i].type); |
| 138 | case E820_RAM: | 169 | printk(KERN_CONT "\n"); |
| 139 | case E820_RESERVED_KERN: | ||
| 140 | printk(KERN_CONT "(usable)\n"); | ||
| 141 | break; | ||
| 142 | case E820_RESERVED: | ||
| 143 | printk(KERN_CONT "(reserved)\n"); | ||
| 144 | break; | ||
| 145 | case E820_ACPI: | ||
| 146 | printk(KERN_CONT "(ACPI data)\n"); | ||
| 147 | break; | ||
| 148 | case E820_NVS: | ||
| 149 | printk(KERN_CONT "(ACPI NVS)\n"); | ||
| 150 | break; | ||
| 151 | case E820_UNUSABLE: | ||
| 152 | printk("(unusable)\n"); | ||
| 153 | break; | ||
| 154 | default: | ||
| 155 | printk(KERN_CONT "type %u\n", e820.map[i].type); | ||
| 156 | break; | ||
| 157 | } | ||
| 158 | } | 170 | } |
| 159 | } | 171 | } |
| 160 | 172 | ||
| @@ -221,7 +233,7 @@ void __init e820_print_map(char *who) | |||
| 221 | */ | 233 | */ |
| 222 | 234 | ||
| 223 | int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, | 235 | int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, |
| 224 | int *pnr_map) | 236 | u32 *pnr_map) |
| 225 | { | 237 | { |
| 226 | struct change_member { | 238 | struct change_member { |
| 227 | struct e820entry *pbios; /* pointer to original bios entry */ | 239 | struct e820entry *pbios; /* pointer to original bios entry */ |
| @@ -417,11 +429,12 @@ static int __init append_e820_map(struct e820entry *biosmap, int nr_map) | |||
| 417 | return __append_e820_map(biosmap, nr_map); | 429 | return __append_e820_map(biosmap, nr_map); |
| 418 | } | 430 | } |
| 419 | 431 | ||
| 420 | static u64 __init e820_update_range_map(struct e820map *e820x, u64 start, | 432 | static u64 __init __e820_update_range(struct e820map *e820x, u64 start, |
| 421 | u64 size, unsigned old_type, | 433 | u64 size, unsigned old_type, |
| 422 | unsigned new_type) | 434 | unsigned new_type) |
| 423 | { | 435 | { |
| 424 | int i; | 436 | u64 end; |
| 437 | unsigned int i; | ||
| 425 | u64 real_updated_size = 0; | 438 | u64 real_updated_size = 0; |
| 426 | 439 | ||
| 427 | BUG_ON(old_type == new_type); | 440 | BUG_ON(old_type == new_type); |
| @@ -429,27 +442,55 @@ static u64 __init e820_update_range_map(struct e820map *e820x, u64 start, | |||
| 429 | if (size > (ULLONG_MAX - start)) | 442 | if (size > (ULLONG_MAX - start)) |
| 430 | size = ULLONG_MAX - start; | 443 | size = ULLONG_MAX - start; |
| 431 | 444 | ||
| 432 | for (i = 0; i < e820.nr_map; i++) { | 445 | end = start + size; |
| 446 | printk(KERN_DEBUG "e820 update range: %016Lx - %016Lx ", | ||
| 447 | (unsigned long long) start, | ||
| 448 | (unsigned long long) end); | ||
| 449 | e820_print_type(old_type); | ||
| 450 | printk(KERN_CONT " ==> "); | ||
| 451 | e820_print_type(new_type); | ||
| 452 | printk(KERN_CONT "\n"); | ||
| 453 | |||
| 454 | for (i = 0; i < e820x->nr_map; i++) { | ||
| 433 | struct e820entry *ei = &e820x->map[i]; | 455 | struct e820entry *ei = &e820x->map[i]; |
| 434 | u64 final_start, final_end; | 456 | u64 final_start, final_end; |
| 457 | u64 ei_end; | ||
| 458 | |||
| 435 | if (ei->type != old_type) | 459 | if (ei->type != old_type) |
| 436 | continue; | 460 | continue; |
| 437 | /* totally covered? */ | 461 | |
| 438 | if (ei->addr >= start && | 462 | ei_end = ei->addr + ei->size; |
| 439 | (ei->addr + ei->size) <= (start + size)) { | 463 | /* totally covered by new range? */ |
| 464 | if (ei->addr >= start && ei_end <= end) { | ||
| 440 | ei->type = new_type; | 465 | ei->type = new_type; |
| 441 | real_updated_size += ei->size; | 466 | real_updated_size += ei->size; |
| 442 | continue; | 467 | continue; |
| 443 | } | 468 | } |
| 469 | |||
| 470 | /* new range is totally covered? */ | ||
| 471 | if (ei->addr < start && ei_end > end) { | ||
| 472 | __e820_add_region(e820x, start, size, new_type); | ||
| 473 | __e820_add_region(e820x, end, ei_end - end, ei->type); | ||
| 474 | ei->size = start - ei->addr; | ||
| 475 | real_updated_size += size; | ||
| 476 | continue; | ||
| 477 | } | ||
| 478 | |||
| 444 | /* partially covered */ | 479 | /* partially covered */ |
| 445 | final_start = max(start, ei->addr); | 480 | final_start = max(start, ei->addr); |
| 446 | final_end = min(start + size, ei->addr + ei->size); | 481 | final_end = min(end, ei_end); |
| 447 | if (final_start >= final_end) | 482 | if (final_start >= final_end) |
| 448 | continue; | 483 | continue; |
| 449 | e820_add_region(final_start, final_end - final_start, | 484 | |
| 450 | new_type); | 485 | __e820_add_region(e820x, final_start, final_end - final_start, |
| 486 | new_type); | ||
| 487 | |||
| 451 | real_updated_size += final_end - final_start; | 488 | real_updated_size += final_end - final_start; |
| 452 | 489 | ||
| 490 | /* | ||
| 491 | * left range could be head or tail, so need to update | ||
| 492 | * size at first. | ||
| 493 | */ | ||
| 453 | ei->size -= final_end - final_start; | 494 | ei->size -= final_end - final_start; |
| 454 | if (ei->addr < final_start) | 495 | if (ei->addr < final_start) |
| 455 | continue; | 496 | continue; |
| @@ -461,13 +502,13 @@ static u64 __init e820_update_range_map(struct e820map *e820x, u64 start, | |||
| 461 | u64 __init e820_update_range(u64 start, u64 size, unsigned old_type, | 502 | u64 __init e820_update_range(u64 start, u64 size, unsigned old_type, |
| 462 | unsigned new_type) | 503 | unsigned new_type) |
| 463 | { | 504 | { |
| 464 | return e820_update_range_map(&e820, start, size, old_type, new_type); | 505 | return __e820_update_range(&e820, start, size, old_type, new_type); |
| 465 | } | 506 | } |
| 466 | 507 | ||
| 467 | static u64 __init e820_update_range_saved(u64 start, u64 size, | 508 | static u64 __init e820_update_range_saved(u64 start, u64 size, |
| 468 | unsigned old_type, unsigned new_type) | 509 | unsigned old_type, unsigned new_type) |
| 469 | { | 510 | { |
| 470 | return e820_update_range_map(&e820_saved, start, size, old_type, | 511 | return __e820_update_range(&e820_saved, start, size, old_type, |
| 471 | new_type); | 512 | new_type); |
| 472 | } | 513 | } |
| 473 | 514 | ||
| @@ -511,7 +552,7 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, | |||
| 511 | 552 | ||
| 512 | void __init update_e820(void) | 553 | void __init update_e820(void) |
| 513 | { | 554 | { |
| 514 | int nr_map; | 555 | u32 nr_map; |
| 515 | 556 | ||
| 516 | nr_map = e820.nr_map; | 557 | nr_map = e820.nr_map; |
| 517 | if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map)) | 558 | if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map)) |
| @@ -522,7 +563,7 @@ void __init update_e820(void) | |||
| 522 | } | 563 | } |
| 523 | static void __init update_e820_saved(void) | 564 | static void __init update_e820_saved(void) |
| 524 | { | 565 | { |
| 525 | int nr_map; | 566 | u32 nr_map; |
| 526 | 567 | ||
| 527 | nr_map = e820_saved.nr_map; | 568 | nr_map = e820_saved.nr_map; |
| 528 | if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map)) | 569 | if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map)) |
| @@ -1020,8 +1061,8 @@ u64 __init find_e820_area_size(u64 start, u64 *sizep, u64 align) | |||
| 1020 | continue; | 1061 | continue; |
| 1021 | return addr; | 1062 | return addr; |
| 1022 | } | 1063 | } |
| 1023 | return -1UL; | ||
| 1024 | 1064 | ||
| 1065 | return -1ULL; | ||
| 1025 | } | 1066 | } |
| 1026 | 1067 | ||
| 1027 | /* | 1068 | /* |
| @@ -1034,13 +1075,22 @@ u64 __init early_reserve_e820(u64 startt, u64 sizet, u64 align) | |||
| 1034 | u64 start; | 1075 | u64 start; |
| 1035 | 1076 | ||
| 1036 | start = startt; | 1077 | start = startt; |
| 1037 | while (size < sizet) | 1078 | while (size < sizet && (start + 1)) |
| 1038 | start = find_e820_area_size(start, &size, align); | 1079 | start = find_e820_area_size(start, &size, align); |
| 1039 | 1080 | ||
| 1040 | if (size < sizet) | 1081 | if (size < sizet) |
| 1041 | return 0; | 1082 | return 0; |
| 1042 | 1083 | ||
| 1084 | #ifdef CONFIG_X86_32 | ||
| 1085 | if (start >= MAXMEM) | ||
| 1086 | return 0; | ||
| 1087 | if (start + size > MAXMEM) | ||
| 1088 | size = MAXMEM - start; | ||
| 1089 | #endif | ||
| 1090 | |||
| 1043 | addr = round_down(start + size - sizet, align); | 1091 | addr = round_down(start + size - sizet, align); |
| 1092 | if (addr < start) | ||
| 1093 | return 0; | ||
| 1044 | e820_update_range(addr, sizet, E820_RAM, E820_RESERVED); | 1094 | e820_update_range(addr, sizet, E820_RAM, E820_RESERVED); |
| 1045 | e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED); | 1095 | e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED); |
| 1046 | printk(KERN_INFO "update e820 for early_reserve_e820\n"); | 1096 | printk(KERN_INFO "update e820 for early_reserve_e820\n"); |
| @@ -1253,7 +1303,7 @@ early_param("memmap", parse_memmap_opt); | |||
| 1253 | void __init finish_e820_parsing(void) | 1303 | void __init finish_e820_parsing(void) |
| 1254 | { | 1304 | { |
| 1255 | if (userdef) { | 1305 | if (userdef) { |
| 1256 | int nr = e820.nr_map; | 1306 | u32 nr = e820.nr_map; |
| 1257 | 1307 | ||
| 1258 | if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0) | 1308 | if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0) |
| 1259 | early_panic("Invalid user supplied memory map"); | 1309 | early_panic("Invalid user supplied memory map"); |
| @@ -1336,7 +1386,7 @@ void __init e820_reserve_resources_late(void) | |||
| 1336 | char *__init default_machine_specific_memory_setup(void) | 1386 | char *__init default_machine_specific_memory_setup(void) |
| 1337 | { | 1387 | { |
| 1338 | char *who = "BIOS-e820"; | 1388 | char *who = "BIOS-e820"; |
| 1339 | int new_nr; | 1389 | u32 new_nr; |
| 1340 | /* | 1390 | /* |
| 1341 | * Try to copy the BIOS-supplied E820-map. | 1391 | * Try to copy the BIOS-supplied E820-map. |
| 1342 | * | 1392 | * |
diff --git a/arch/x86/kernel/early_printk.c b/arch/x86/kernel/early_printk.c index 639ad98238a2..335f049d110f 100644 --- a/arch/x86/kernel/early_printk.c +++ b/arch/x86/kernel/early_printk.c | |||
| @@ -250,7 +250,7 @@ static int dbgp_wait_until_complete(void) | |||
| 250 | return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl); | 250 | return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl); |
| 251 | } | 251 | } |
| 252 | 252 | ||
| 253 | static void dbgp_mdelay(int ms) | 253 | static void __init dbgp_mdelay(int ms) |
| 254 | { | 254 | { |
| 255 | int i; | 255 | int i; |
| 256 | 256 | ||
| @@ -311,7 +311,7 @@ static void dbgp_set_data(const void *buf, int size) | |||
| 311 | writel(hi, &ehci_debug->data47); | 311 | writel(hi, &ehci_debug->data47); |
| 312 | } | 312 | } |
| 313 | 313 | ||
| 314 | static void dbgp_get_data(void *buf, int size) | 314 | static void __init dbgp_get_data(void *buf, int size) |
| 315 | { | 315 | { |
| 316 | unsigned char *bytes = buf; | 316 | unsigned char *bytes = buf; |
| 317 | u32 lo, hi; | 317 | u32 lo, hi; |
| @@ -355,7 +355,7 @@ static int dbgp_bulk_write(unsigned devnum, unsigned endpoint, | |||
| 355 | return ret; | 355 | return ret; |
| 356 | } | 356 | } |
| 357 | 357 | ||
| 358 | static int dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data, | 358 | static int __init dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data, |
| 359 | int size) | 359 | int size) |
| 360 | { | 360 | { |
| 361 | u32 pids, addr, ctrl; | 361 | u32 pids, addr, ctrl; |
| @@ -386,8 +386,8 @@ static int dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data, | |||
| 386 | return ret; | 386 | return ret; |
| 387 | } | 387 | } |
| 388 | 388 | ||
| 389 | static int dbgp_control_msg(unsigned devnum, int requesttype, int request, | 389 | static int __init dbgp_control_msg(unsigned devnum, int requesttype, |
| 390 | int value, int index, void *data, int size) | 390 | int request, int value, int index, void *data, int size) |
| 391 | { | 391 | { |
| 392 | u32 pids, addr, ctrl; | 392 | u32 pids, addr, ctrl; |
| 393 | struct usb_ctrlrequest req; | 393 | struct usb_ctrlrequest req; |
| @@ -489,7 +489,7 @@ static u32 __init find_dbgp(int ehci_num, u32 *rbus, u32 *rslot, u32 *rfunc) | |||
| 489 | return 0; | 489 | return 0; |
| 490 | } | 490 | } |
| 491 | 491 | ||
| 492 | static int ehci_reset_port(int port) | 492 | static int __init ehci_reset_port(int port) |
| 493 | { | 493 | { |
| 494 | u32 portsc; | 494 | u32 portsc; |
| 495 | u32 delay_time, delay; | 495 | u32 delay_time, delay; |
| @@ -532,7 +532,7 @@ static int ehci_reset_port(int port) | |||
| 532 | return -EBUSY; | 532 | return -EBUSY; |
| 533 | } | 533 | } |
| 534 | 534 | ||
| 535 | static int ehci_wait_for_port(int port) | 535 | static int __init ehci_wait_for_port(int port) |
| 536 | { | 536 | { |
| 537 | u32 status; | 537 | u32 status; |
| 538 | int ret, reps; | 538 | int ret, reps; |
| @@ -557,13 +557,13 @@ static inline void dbgp_printk(const char *fmt, ...) { } | |||
| 557 | 557 | ||
| 558 | typedef void (*set_debug_port_t)(int port); | 558 | typedef void (*set_debug_port_t)(int port); |
| 559 | 559 | ||
| 560 | static void default_set_debug_port(int port) | 560 | static void __init default_set_debug_port(int port) |
| 561 | { | 561 | { |
| 562 | } | 562 | } |
| 563 | 563 | ||
| 564 | static set_debug_port_t set_debug_port = default_set_debug_port; | 564 | static set_debug_port_t __initdata set_debug_port = default_set_debug_port; |
| 565 | 565 | ||
| 566 | static void nvidia_set_debug_port(int port) | 566 | static void __init nvidia_set_debug_port(int port) |
| 567 | { | 567 | { |
| 568 | u32 dword; | 568 | u32 dword; |
| 569 | dword = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func, | 569 | dword = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func, |
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S index 899e8938e79f..c929add475c9 100644 --- a/arch/x86/kernel/entry_32.S +++ b/arch/x86/kernel/entry_32.S | |||
| @@ -442,8 +442,7 @@ sysenter_past_esp: | |||
| 442 | 442 | ||
| 443 | GET_THREAD_INFO(%ebp) | 443 | GET_THREAD_INFO(%ebp) |
| 444 | 444 | ||
| 445 | /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */ | 445 | testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp) |
| 446 | testw $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp) | ||
| 447 | jnz sysenter_audit | 446 | jnz sysenter_audit |
| 448 | sysenter_do_call: | 447 | sysenter_do_call: |
| 449 | cmpl $(nr_syscalls), %eax | 448 | cmpl $(nr_syscalls), %eax |
| @@ -454,7 +453,7 @@ sysenter_do_call: | |||
| 454 | DISABLE_INTERRUPTS(CLBR_ANY) | 453 | DISABLE_INTERRUPTS(CLBR_ANY) |
| 455 | TRACE_IRQS_OFF | 454 | TRACE_IRQS_OFF |
| 456 | movl TI_flags(%ebp), %ecx | 455 | movl TI_flags(%ebp), %ecx |
| 457 | testw $_TIF_ALLWORK_MASK, %cx | 456 | testl $_TIF_ALLWORK_MASK, %ecx |
| 458 | jne sysexit_audit | 457 | jne sysexit_audit |
| 459 | sysenter_exit: | 458 | sysenter_exit: |
| 460 | /* if something modifies registers it must also disable sysexit */ | 459 | /* if something modifies registers it must also disable sysexit */ |
| @@ -468,7 +467,7 @@ sysenter_exit: | |||
| 468 | 467 | ||
| 469 | #ifdef CONFIG_AUDITSYSCALL | 468 | #ifdef CONFIG_AUDITSYSCALL |
| 470 | sysenter_audit: | 469 | sysenter_audit: |
| 471 | testw $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags(%ebp) | 470 | testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags(%ebp) |
| 472 | jnz syscall_trace_entry | 471 | jnz syscall_trace_entry |
| 473 | addl $4,%esp | 472 | addl $4,%esp |
| 474 | CFI_ADJUST_CFA_OFFSET -4 | 473 | CFI_ADJUST_CFA_OFFSET -4 |
| @@ -485,7 +484,7 @@ sysenter_audit: | |||
| 485 | jmp sysenter_do_call | 484 | jmp sysenter_do_call |
| 486 | 485 | ||
| 487 | sysexit_audit: | 486 | sysexit_audit: |
| 488 | testw $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %cx | 487 | testl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %ecx |
| 489 | jne syscall_exit_work | 488 | jne syscall_exit_work |
| 490 | TRACE_IRQS_ON | 489 | TRACE_IRQS_ON |
| 491 | ENABLE_INTERRUPTS(CLBR_ANY) | 490 | ENABLE_INTERRUPTS(CLBR_ANY) |
| @@ -498,7 +497,7 @@ sysexit_audit: | |||
| 498 | DISABLE_INTERRUPTS(CLBR_ANY) | 497 | DISABLE_INTERRUPTS(CLBR_ANY) |
| 499 | TRACE_IRQS_OFF | 498 | TRACE_IRQS_OFF |
| 500 | movl TI_flags(%ebp), %ecx | 499 | movl TI_flags(%ebp), %ecx |
| 501 | testw $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %cx | 500 | testl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %ecx |
| 502 | jne syscall_exit_work | 501 | jne syscall_exit_work |
| 503 | movl PT_EAX(%esp),%eax /* reload syscall return value */ | 502 | movl PT_EAX(%esp),%eax /* reload syscall return value */ |
| 504 | jmp sysenter_exit | 503 | jmp sysenter_exit |
| @@ -523,8 +522,7 @@ ENTRY(system_call) | |||
| 523 | SAVE_ALL | 522 | SAVE_ALL |
| 524 | GET_THREAD_INFO(%ebp) | 523 | GET_THREAD_INFO(%ebp) |
| 525 | # system call tracing in operation / emulation | 524 | # system call tracing in operation / emulation |
| 526 | /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */ | 525 | testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp) |
| 527 | testw $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp) | ||
| 528 | jnz syscall_trace_entry | 526 | jnz syscall_trace_entry |
| 529 | cmpl $(nr_syscalls), %eax | 527 | cmpl $(nr_syscalls), %eax |
| 530 | jae syscall_badsys | 528 | jae syscall_badsys |
| @@ -538,7 +536,7 @@ syscall_exit: | |||
| 538 | # between sampling and the iret | 536 | # between sampling and the iret |
| 539 | TRACE_IRQS_OFF | 537 | TRACE_IRQS_OFF |
| 540 | movl TI_flags(%ebp), %ecx | 538 | movl TI_flags(%ebp), %ecx |
| 541 | testw $_TIF_ALLWORK_MASK, %cx # current->work | 539 | testl $_TIF_ALLWORK_MASK, %ecx # current->work |
| 542 | jne syscall_exit_work | 540 | jne syscall_exit_work |
| 543 | 541 | ||
| 544 | restore_all: | 542 | restore_all: |
| @@ -673,7 +671,7 @@ END(syscall_trace_entry) | |||
| 673 | # perform syscall exit tracing | 671 | # perform syscall exit tracing |
| 674 | ALIGN | 672 | ALIGN |
| 675 | syscall_exit_work: | 673 | syscall_exit_work: |
| 676 | testb $_TIF_WORK_SYSCALL_EXIT, %cl | 674 | testl $_TIF_WORK_SYSCALL_EXIT, %ecx |
| 677 | jz work_pending | 675 | jz work_pending |
| 678 | TRACE_IRQS_ON | 676 | TRACE_IRQS_ON |
| 679 | ENABLE_INTERRUPTS(CLBR_ANY) # could let syscall_trace_leave() call | 677 | ENABLE_INTERRUPTS(CLBR_ANY) # could let syscall_trace_leave() call |
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S index 83d1836b9467..a331ec38af9e 100644 --- a/arch/x86/kernel/entry_64.S +++ b/arch/x86/kernel/entry_64.S | |||
| @@ -368,6 +368,7 @@ ENTRY(save_rest) | |||
| 368 | END(save_rest) | 368 | END(save_rest) |
| 369 | 369 | ||
| 370 | /* save complete stack frame */ | 370 | /* save complete stack frame */ |
| 371 | .pushsection .kprobes.text, "ax" | ||
| 371 | ENTRY(save_paranoid) | 372 | ENTRY(save_paranoid) |
| 372 | XCPT_FRAME 1 RDI+8 | 373 | XCPT_FRAME 1 RDI+8 |
| 373 | cld | 374 | cld |
| @@ -396,6 +397,7 @@ ENTRY(save_paranoid) | |||
| 396 | 1: ret | 397 | 1: ret |
| 397 | CFI_ENDPROC | 398 | CFI_ENDPROC |
| 398 | END(save_paranoid) | 399 | END(save_paranoid) |
| 400 | .popsection | ||
| 399 | 401 | ||
| 400 | /* | 402 | /* |
| 401 | * A newly forked process directly context switches into this address. | 403 | * A newly forked process directly context switches into this address. |
| @@ -416,7 +418,6 @@ ENTRY(ret_from_fork) | |||
| 416 | 418 | ||
| 417 | GET_THREAD_INFO(%rcx) | 419 | GET_THREAD_INFO(%rcx) |
| 418 | 420 | ||
| 419 | CFI_REMEMBER_STATE | ||
| 420 | RESTORE_REST | 421 | RESTORE_REST |
| 421 | 422 | ||
| 422 | testl $3, CS-ARGOFFSET(%rsp) # from kernel_thread? | 423 | testl $3, CS-ARGOFFSET(%rsp) # from kernel_thread? |
| @@ -428,7 +429,6 @@ ENTRY(ret_from_fork) | |||
| 428 | RESTORE_TOP_OF_STACK %rdi, -ARGOFFSET | 429 | RESTORE_TOP_OF_STACK %rdi, -ARGOFFSET |
| 429 | jmp ret_from_sys_call # go to the SYSRET fastpath | 430 | jmp ret_from_sys_call # go to the SYSRET fastpath |
| 430 | 431 | ||
| 431 | CFI_RESTORE_STATE | ||
| 432 | CFI_ENDPROC | 432 | CFI_ENDPROC |
| 433 | END(ret_from_fork) | 433 | END(ret_from_fork) |
| 434 | 434 | ||
| @@ -984,6 +984,8 @@ apicinterrupt UV_BAU_MESSAGE \ | |||
| 984 | #endif | 984 | #endif |
| 985 | apicinterrupt LOCAL_TIMER_VECTOR \ | 985 | apicinterrupt LOCAL_TIMER_VECTOR \ |
| 986 | apic_timer_interrupt smp_apic_timer_interrupt | 986 | apic_timer_interrupt smp_apic_timer_interrupt |
| 987 | apicinterrupt GENERIC_INTERRUPT_VECTOR \ | ||
| 988 | generic_interrupt smp_generic_interrupt | ||
| 987 | 989 | ||
| 988 | #ifdef CONFIG_SMP | 990 | #ifdef CONFIG_SMP |
| 989 | apicinterrupt INVALIDATE_TLB_VECTOR_START+0 \ | 991 | apicinterrupt INVALIDATE_TLB_VECTOR_START+0 \ |
diff --git a/arch/x86/kernel/head32.c b/arch/x86/kernel/head32.c index ac108d1fe182..3f8579f8d42c 100644 --- a/arch/x86/kernel/head32.c +++ b/arch/x86/kernel/head32.c | |||
| @@ -18,7 +18,7 @@ void __init i386_start_kernel(void) | |||
| 18 | { | 18 | { |
| 19 | reserve_trampoline_memory(); | 19 | reserve_trampoline_memory(); |
| 20 | 20 | ||
| 21 | reserve_early(__pa_symbol(&_text), __pa_symbol(&_end), "TEXT DATA BSS"); | 21 | reserve_early(__pa_symbol(&_text), __pa_symbol(&__bss_stop), "TEXT DATA BSS"); |
| 22 | 22 | ||
| 23 | #ifdef CONFIG_BLK_DEV_INITRD | 23 | #ifdef CONFIG_BLK_DEV_INITRD |
| 24 | /* Reserve INITRD */ | 24 | /* Reserve INITRD */ |
| @@ -29,9 +29,6 @@ void __init i386_start_kernel(void) | |||
| 29 | reserve_early(ramdisk_image, ramdisk_end, "RAMDISK"); | 29 | reserve_early(ramdisk_image, ramdisk_end, "RAMDISK"); |
| 30 | } | 30 | } |
| 31 | #endif | 31 | #endif |
| 32 | reserve_early(init_pg_tables_start, init_pg_tables_end, | ||
| 33 | "INIT_PG_TABLE"); | ||
| 34 | |||
| 35 | reserve_ebda_region(); | 32 | reserve_ebda_region(); |
| 36 | 33 | ||
| 37 | /* | 34 | /* |
diff --git a/arch/x86/kernel/head64.c b/arch/x86/kernel/head64.c index f5b272247690..70eaa852c732 100644 --- a/arch/x86/kernel/head64.c +++ b/arch/x86/kernel/head64.c | |||
| @@ -100,7 +100,7 @@ void __init x86_64_start_reservations(char *real_mode_data) | |||
| 100 | 100 | ||
| 101 | reserve_trampoline_memory(); | 101 | reserve_trampoline_memory(); |
| 102 | 102 | ||
| 103 | reserve_early(__pa_symbol(&_text), __pa_symbol(&_end), "TEXT DATA BSS"); | 103 | reserve_early(__pa_symbol(&_text), __pa_symbol(&__bss_stop), "TEXT DATA BSS"); |
| 104 | 104 | ||
| 105 | #ifdef CONFIG_BLK_DEV_INITRD | 105 | #ifdef CONFIG_BLK_DEV_INITRD |
| 106 | /* Reserve INITRD */ | 106 | /* Reserve INITRD */ |
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S index c32ca19d591a..30683883e0cd 100644 --- a/arch/x86/kernel/head_32.S +++ b/arch/x86/kernel/head_32.S | |||
| @@ -38,42 +38,40 @@ | |||
| 38 | #define X86_VENDOR_ID new_cpu_data+CPUINFO_x86_vendor_id | 38 | #define X86_VENDOR_ID new_cpu_data+CPUINFO_x86_vendor_id |
| 39 | 39 | ||
| 40 | /* | 40 | /* |
| 41 | * This is how much memory *in addition to the memory covered up to | 41 | * This is how much memory in addition to the memory covered up to |
| 42 | * and including _end* we need mapped initially. | 42 | * and including _end we need mapped initially. |
| 43 | * We need: | 43 | * We need: |
| 44 | * - one bit for each possible page, but only in low memory, which means | 44 | * (KERNEL_IMAGE_SIZE/4096) / 1024 pages (worst case, non PAE) |
| 45 | * 2^32/4096/8 = 128K worst case (4G/4G split.) | 45 | * (KERNEL_IMAGE_SIZE/4096) / 512 + 4 pages (worst case for PAE) |
| 46 | * - enough space to map all low memory, which means | ||
| 47 | * (2^32/4096) / 1024 pages (worst case, non PAE) | ||
| 48 | * (2^32/4096) / 512 + 4 pages (worst case for PAE) | ||
| 49 | * - a few pages for allocator use before the kernel pagetable has | ||
| 50 | * been set up | ||
| 51 | * | 46 | * |
| 52 | * Modulo rounding, each megabyte assigned here requires a kilobyte of | 47 | * Modulo rounding, each megabyte assigned here requires a kilobyte of |
| 53 | * memory, which is currently unreclaimed. | 48 | * memory, which is currently unreclaimed. |
| 54 | * | 49 | * |
| 55 | * This should be a multiple of a page. | 50 | * This should be a multiple of a page. |
| 51 | * | ||
| 52 | * KERNEL_IMAGE_SIZE should be greater than pa(_end) | ||
| 53 | * and small than max_low_pfn, otherwise will waste some page table entries | ||
| 56 | */ | 54 | */ |
| 57 | LOW_PAGES = 1<<(32-PAGE_SHIFT_asm) | ||
| 58 | |||
| 59 | /* | ||
| 60 | * To preserve the DMA pool in PAGEALLOC kernels, we'll allocate | ||
| 61 | * pagetables from above the 16MB DMA limit, so we'll have to set | ||
| 62 | * up pagetables 16MB more (worst-case): | ||
| 63 | */ | ||
| 64 | #ifdef CONFIG_DEBUG_PAGEALLOC | ||
| 65 | LOW_PAGES = LOW_PAGES + 0x1000000 | ||
| 66 | #endif | ||
| 67 | 55 | ||
| 68 | #if PTRS_PER_PMD > 1 | 56 | #if PTRS_PER_PMD > 1 |
| 69 | PAGE_TABLE_SIZE = (LOW_PAGES / PTRS_PER_PMD) + PTRS_PER_PGD | 57 | #define PAGE_TABLE_SIZE(pages) (((pages) / PTRS_PER_PMD) + PTRS_PER_PGD) |
| 70 | #else | 58 | #else |
| 71 | PAGE_TABLE_SIZE = (LOW_PAGES / PTRS_PER_PGD) | 59 | #define PAGE_TABLE_SIZE(pages) ((pages) / PTRS_PER_PGD) |
| 72 | #endif | 60 | #endif |
| 73 | BOOTBITMAP_SIZE = LOW_PAGES / 8 | ||
| 74 | ALLOCATOR_SLOP = 4 | ||
| 75 | 61 | ||
| 76 | INIT_MAP_BEYOND_END = BOOTBITMAP_SIZE + (PAGE_TABLE_SIZE + ALLOCATOR_SLOP)*PAGE_SIZE_asm | 62 | /* Enough space to fit pagetables for the low memory linear map */ |
| 63 | MAPPING_BEYOND_END = \ | ||
| 64 | PAGE_TABLE_SIZE(((1<<32) - __PAGE_OFFSET) >> PAGE_SHIFT) << PAGE_SHIFT | ||
| 65 | |||
| 66 | /* | ||
| 67 | * Worst-case size of the kernel mapping we need to make: | ||
| 68 | * the worst-case size of the kernel itself, plus the extra we need | ||
| 69 | * to map for the linear map. | ||
| 70 | */ | ||
| 71 | KERNEL_PAGES = (KERNEL_IMAGE_SIZE + MAPPING_BEYOND_END)>>PAGE_SHIFT | ||
| 72 | |||
| 73 | INIT_MAP_SIZE = PAGE_TABLE_SIZE(KERNEL_PAGES) * PAGE_SIZE_asm | ||
| 74 | RESERVE_BRK(pagetables, INIT_MAP_SIZE) | ||
| 77 | 75 | ||
| 78 | /* | 76 | /* |
| 79 | * 32-bit kernel entrypoint; only used by the boot CPU. On entry, | 77 | * 32-bit kernel entrypoint; only used by the boot CPU. On entry, |
| @@ -166,10 +164,10 @@ num_subarch_entries = (. - subarch_entries) / 4 | |||
| 166 | 164 | ||
| 167 | /* | 165 | /* |
| 168 | * Initialize page tables. This creates a PDE and a set of page | 166 | * Initialize page tables. This creates a PDE and a set of page |
| 169 | * tables, which are located immediately beyond _end. The variable | 167 | * tables, which are located immediately beyond __brk_base. The variable |
| 170 | * init_pg_tables_end is set up to point to the first "safe" location. | 168 | * _brk_end is set up to point to the first "safe" location. |
| 171 | * Mappings are created both at virtual address 0 (identity mapping) | 169 | * Mappings are created both at virtual address 0 (identity mapping) |
| 172 | * and PAGE_OFFSET for up to _end+sizeof(page tables)+INIT_MAP_BEYOND_END. | 170 | * and PAGE_OFFSET for up to _end. |
| 173 | * | 171 | * |
| 174 | * Note that the stack is not yet set up! | 172 | * Note that the stack is not yet set up! |
| 175 | */ | 173 | */ |
| @@ -190,8 +188,7 @@ default_entry: | |||
| 190 | 188 | ||
| 191 | xorl %ebx,%ebx /* %ebx is kept at zero */ | 189 | xorl %ebx,%ebx /* %ebx is kept at zero */ |
| 192 | 190 | ||
| 193 | movl $pa(pg0), %edi | 191 | movl $pa(__brk_base), %edi |
| 194 | movl %edi, pa(init_pg_tables_start) | ||
| 195 | movl $pa(swapper_pg_pmd), %edx | 192 | movl $pa(swapper_pg_pmd), %edx |
| 196 | movl $PTE_IDENT_ATTR, %eax | 193 | movl $PTE_IDENT_ATTR, %eax |
| 197 | 10: | 194 | 10: |
| @@ -209,14 +206,14 @@ default_entry: | |||
| 209 | loop 11b | 206 | loop 11b |
| 210 | 207 | ||
| 211 | /* | 208 | /* |
| 212 | * End condition: we must map up to and including INIT_MAP_BEYOND_END | 209 | * End condition: we must map up to the end + MAPPING_BEYOND_END. |
| 213 | * bytes beyond the end of our own page tables. | ||
| 214 | */ | 210 | */ |
| 215 | leal (INIT_MAP_BEYOND_END+PTE_IDENT_ATTR)(%edi),%ebp | 211 | movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp |
| 216 | cmpl %ebp,%eax | 212 | cmpl %ebp,%eax |
| 217 | jb 10b | 213 | jb 10b |
| 218 | 1: | 214 | 1: |
| 219 | movl %edi,pa(init_pg_tables_end) | 215 | addl $__PAGE_OFFSET, %edi |
| 216 | movl %edi, pa(_brk_end) | ||
| 220 | shrl $12, %eax | 217 | shrl $12, %eax |
| 221 | movl %eax, pa(max_pfn_mapped) | 218 | movl %eax, pa(max_pfn_mapped) |
| 222 | 219 | ||
| @@ -227,8 +224,7 @@ default_entry: | |||
| 227 | 224 | ||
| 228 | page_pde_offset = (__PAGE_OFFSET >> 20); | 225 | page_pde_offset = (__PAGE_OFFSET >> 20); |
| 229 | 226 | ||
| 230 | movl $pa(pg0), %edi | 227 | movl $pa(__brk_base), %edi |
| 231 | movl %edi, pa(init_pg_tables_start) | ||
| 232 | movl $pa(swapper_pg_dir), %edx | 228 | movl $pa(swapper_pg_dir), %edx |
| 233 | movl $PTE_IDENT_ATTR, %eax | 229 | movl $PTE_IDENT_ATTR, %eax |
| 234 | 10: | 230 | 10: |
| @@ -242,14 +238,13 @@ page_pde_offset = (__PAGE_OFFSET >> 20); | |||
| 242 | addl $0x1000,%eax | 238 | addl $0x1000,%eax |
| 243 | loop 11b | 239 | loop 11b |
| 244 | /* | 240 | /* |
| 245 | * End condition: we must map up to and including INIT_MAP_BEYOND_END | 241 | * End condition: we must map up to the end + MAPPING_BEYOND_END. |
| 246 | * bytes beyond the end of our own page tables; the +0x007 is | ||
| 247 | * the attribute bits | ||
| 248 | */ | 242 | */ |
| 249 | leal (INIT_MAP_BEYOND_END+PTE_IDENT_ATTR)(%edi),%ebp | 243 | movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp |
| 250 | cmpl %ebp,%eax | 244 | cmpl %ebp,%eax |
| 251 | jb 10b | 245 | jb 10b |
| 252 | movl %edi,pa(init_pg_tables_end) | 246 | addl $__PAGE_OFFSET, %edi |
| 247 | movl %edi, pa(_brk_end) | ||
| 253 | shrl $12, %eax | 248 | shrl $12, %eax |
| 254 | movl %eax, pa(max_pfn_mapped) | 249 | movl %eax, pa(max_pfn_mapped) |
| 255 | 250 | ||
| @@ -636,6 +631,7 @@ swapper_pg_fixmap: | |||
| 636 | .fill 1024,4,0 | 631 | .fill 1024,4,0 |
| 637 | ENTRY(empty_zero_page) | 632 | ENTRY(empty_zero_page) |
| 638 | .fill 4096,1,0 | 633 | .fill 4096,1,0 |
| 634 | |||
| 639 | /* | 635 | /* |
| 640 | * This starts the data section. | 636 | * This starts the data section. |
| 641 | */ | 637 | */ |
diff --git a/arch/x86/kernel/i8253.c b/arch/x86/kernel/i8253.c index 10f92fb532f3..3475440baa54 100644 --- a/arch/x86/kernel/i8253.c +++ b/arch/x86/kernel/i8253.c | |||
| @@ -3,17 +3,17 @@ | |||
| 3 | * | 3 | * |
| 4 | */ | 4 | */ |
| 5 | #include <linux/clockchips.h> | 5 | #include <linux/clockchips.h> |
| 6 | #include <linux/init.h> | ||
| 7 | #include <linux/interrupt.h> | 6 | #include <linux/interrupt.h> |
| 7 | #include <linux/spinlock.h> | ||
| 8 | #include <linux/jiffies.h> | 8 | #include <linux/jiffies.h> |
| 9 | #include <linux/module.h> | 9 | #include <linux/module.h> |
| 10 | #include <linux/spinlock.h> | 10 | #include <linux/delay.h> |
| 11 | #include <linux/init.h> | ||
| 12 | #include <linux/io.h> | ||
| 11 | 13 | ||
| 12 | #include <asm/smp.h> | ||
| 13 | #include <asm/delay.h> | ||
| 14 | #include <asm/i8253.h> | 14 | #include <asm/i8253.h> |
| 15 | #include <asm/io.h> | ||
| 16 | #include <asm/hpet.h> | 15 | #include <asm/hpet.h> |
| 16 | #include <asm/smp.h> | ||
| 17 | 17 | ||
| 18 | DEFINE_SPINLOCK(i8253_lock); | 18 | DEFINE_SPINLOCK(i8253_lock); |
| 19 | EXPORT_SYMBOL(i8253_lock); | 19 | EXPORT_SYMBOL(i8253_lock); |
| @@ -40,7 +40,7 @@ static void init_pit_timer(enum clock_event_mode mode, | |||
| 40 | { | 40 | { |
| 41 | spin_lock(&i8253_lock); | 41 | spin_lock(&i8253_lock); |
| 42 | 42 | ||
| 43 | switch(mode) { | 43 | switch (mode) { |
| 44 | case CLOCK_EVT_MODE_PERIODIC: | 44 | case CLOCK_EVT_MODE_PERIODIC: |
| 45 | /* binary, mode 2, LSB/MSB, ch 0 */ | 45 | /* binary, mode 2, LSB/MSB, ch 0 */ |
| 46 | outb_pit(0x34, PIT_MODE); | 46 | outb_pit(0x34, PIT_MODE); |
| @@ -95,7 +95,7 @@ static int pit_next_event(unsigned long delta, struct clock_event_device *evt) | |||
| 95 | * registered. This mechanism replaces the previous #ifdef LOCAL_APIC - | 95 | * registered. This mechanism replaces the previous #ifdef LOCAL_APIC - |
| 96 | * !using_apic_timer decisions in do_timer_interrupt_hook() | 96 | * !using_apic_timer decisions in do_timer_interrupt_hook() |
| 97 | */ | 97 | */ |
| 98 | static struct clock_event_device pit_clockevent = { | 98 | static struct clock_event_device pit_ce = { |
| 99 | .name = "pit", | 99 | .name = "pit", |
| 100 | .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, | 100 | .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, |
| 101 | .set_mode = init_pit_timer, | 101 | .set_mode = init_pit_timer, |
| @@ -114,15 +114,13 @@ void __init setup_pit_timer(void) | |||
| 114 | * Start pit with the boot cpu mask and make it global after the | 114 | * Start pit with the boot cpu mask and make it global after the |
| 115 | * IO_APIC has been initialized. | 115 | * IO_APIC has been initialized. |
| 116 | */ | 116 | */ |
| 117 | pit_clockevent.cpumask = cpumask_of(smp_processor_id()); | 117 | pit_ce.cpumask = cpumask_of(smp_processor_id()); |
| 118 | pit_clockevent.mult = div_sc(CLOCK_TICK_RATE, NSEC_PER_SEC, | 118 | pit_ce.mult = div_sc(CLOCK_TICK_RATE, NSEC_PER_SEC, pit_ce.shift); |
| 119 | pit_clockevent.shift); | 119 | pit_ce.max_delta_ns = clockevent_delta2ns(0x7FFF, &pit_ce); |
| 120 | pit_clockevent.max_delta_ns = | 120 | pit_ce.min_delta_ns = clockevent_delta2ns(0xF, &pit_ce); |
| 121 | clockevent_delta2ns(0x7FFF, &pit_clockevent); | 121 | |
| 122 | pit_clockevent.min_delta_ns = | 122 | clockevents_register_device(&pit_ce); |
| 123 | clockevent_delta2ns(0xF, &pit_clockevent); | 123 | global_clock_event = &pit_ce; |
| 124 | clockevents_register_device(&pit_clockevent); | ||
| 125 | global_clock_event = &pit_clockevent; | ||
| 126 | } | 124 | } |
| 127 | 125 | ||
| 128 | #ifndef CONFIG_X86_64 | 126 | #ifndef CONFIG_X86_64 |
| @@ -133,11 +131,11 @@ void __init setup_pit_timer(void) | |||
| 133 | */ | 131 | */ |
| 134 | static cycle_t pit_read(void) | 132 | static cycle_t pit_read(void) |
| 135 | { | 133 | { |
| 134 | static int old_count; | ||
| 135 | static u32 old_jifs; | ||
| 136 | unsigned long flags; | 136 | unsigned long flags; |
| 137 | int count; | 137 | int count; |
| 138 | u32 jifs; | 138 | u32 jifs; |
| 139 | static int old_count; | ||
| 140 | static u32 old_jifs; | ||
| 141 | 139 | ||
| 142 | spin_lock_irqsave(&i8253_lock, flags); | 140 | spin_lock_irqsave(&i8253_lock, flags); |
| 143 | /* | 141 | /* |
| @@ -179,9 +177,9 @@ static cycle_t pit_read(void) | |||
| 179 | * Previous attempts to handle these cases intelligently were | 177 | * Previous attempts to handle these cases intelligently were |
| 180 | * buggy, so we just do the simple thing now. | 178 | * buggy, so we just do the simple thing now. |
| 181 | */ | 179 | */ |
| 182 | if (count > old_count && jifs == old_jifs) { | 180 | if (count > old_count && jifs == old_jifs) |
| 183 | count = old_count; | 181 | count = old_count; |
| 184 | } | 182 | |
| 185 | old_count = count; | 183 | old_count = count; |
| 186 | old_jifs = jifs; | 184 | old_jifs = jifs; |
| 187 | 185 | ||
| @@ -192,13 +190,13 @@ static cycle_t pit_read(void) | |||
| 192 | return (cycle_t)(jifs * LATCH) + count; | 190 | return (cycle_t)(jifs * LATCH) + count; |
| 193 | } | 191 | } |
| 194 | 192 | ||
| 195 | static struct clocksource clocksource_pit = { | 193 | static struct clocksource pit_cs = { |
| 196 | .name = "pit", | 194 | .name = "pit", |
| 197 | .rating = 110, | 195 | .rating = 110, |
| 198 | .read = pit_read, | 196 | .read = pit_read, |
| 199 | .mask = CLOCKSOURCE_MASK(32), | 197 | .mask = CLOCKSOURCE_MASK(32), |
| 200 | .mult = 0, | 198 | .mult = 0, |
| 201 | .shift = 20, | 199 | .shift = 20, |
| 202 | }; | 200 | }; |
| 203 | 201 | ||
| 204 | static void pit_disable_clocksource(void) | 202 | static void pit_disable_clocksource(void) |
| @@ -206,9 +204,9 @@ static void pit_disable_clocksource(void) | |||
| 206 | /* | 204 | /* |
| 207 | * Use mult to check whether it is registered or not | 205 | * Use mult to check whether it is registered or not |
| 208 | */ | 206 | */ |
| 209 | if (clocksource_pit.mult) { | 207 | if (pit_cs.mult) { |
| 210 | clocksource_unregister(&clocksource_pit); | 208 | clocksource_unregister(&pit_cs); |
| 211 | clocksource_pit.mult = 0; | 209 | pit_cs.mult = 0; |
| 212 | } | 210 | } |
| 213 | } | 211 | } |
| 214 | 212 | ||
| @@ -222,13 +220,13 @@ static int __init init_pit_clocksource(void) | |||
| 222 | * - when local APIC timer is active (PIT is switched off) | 220 | * - when local APIC timer is active (PIT is switched off) |
| 223 | */ | 221 | */ |
| 224 | if (num_possible_cpus() > 1 || is_hpet_enabled() || | 222 | if (num_possible_cpus() > 1 || is_hpet_enabled() || |
| 225 | pit_clockevent.mode != CLOCK_EVT_MODE_PERIODIC) | 223 | pit_ce.mode != CLOCK_EVT_MODE_PERIODIC) |
| 226 | return 0; | 224 | return 0; |
| 227 | 225 | ||
| 228 | clocksource_pit.mult = clocksource_hz2mult(CLOCK_TICK_RATE, | 226 | pit_cs.mult = clocksource_hz2mult(CLOCK_TICK_RATE, pit_cs.shift); |
| 229 | clocksource_pit.shift); | 227 | |
| 230 | return clocksource_register(&clocksource_pit); | 228 | return clocksource_register(&pit_cs); |
| 231 | } | 229 | } |
| 232 | arch_initcall(init_pit_clocksource); | 230 | arch_initcall(init_pit_clocksource); |
| 233 | 231 | ||
| 234 | #endif | 232 | #endif /* !CONFIG_X86_64 */ |
diff --git a/arch/x86/kernel/io_delay.c b/arch/x86/kernel/io_delay.c index 720d2607aacb..a979b5bd2fc0 100644 --- a/arch/x86/kernel/io_delay.c +++ b/arch/x86/kernel/io_delay.c | |||
| @@ -7,10 +7,10 @@ | |||
| 7 | */ | 7 | */ |
| 8 | #include <linux/kernel.h> | 8 | #include <linux/kernel.h> |
| 9 | #include <linux/module.h> | 9 | #include <linux/module.h> |
| 10 | #include <linux/init.h> | ||
| 11 | #include <linux/delay.h> | 10 | #include <linux/delay.h> |
| 11 | #include <linux/init.h> | ||
| 12 | #include <linux/dmi.h> | 12 | #include <linux/dmi.h> |
| 13 | #include <asm/io.h> | 13 | #include <linux/io.h> |
| 14 | 14 | ||
| 15 | int io_delay_type __read_mostly = CONFIG_DEFAULT_IO_DELAY_TYPE; | 15 | int io_delay_type __read_mostly = CONFIG_DEFAULT_IO_DELAY_TYPE; |
| 16 | 16 | ||
| @@ -47,8 +47,7 @@ EXPORT_SYMBOL(native_io_delay); | |||
| 47 | static int __init dmi_io_delay_0xed_port(const struct dmi_system_id *id) | 47 | static int __init dmi_io_delay_0xed_port(const struct dmi_system_id *id) |
| 48 | { | 48 | { |
| 49 | if (io_delay_type == CONFIG_IO_DELAY_TYPE_0X80) { | 49 | if (io_delay_type == CONFIG_IO_DELAY_TYPE_0X80) { |
| 50 | printk(KERN_NOTICE "%s: using 0xed I/O delay port\n", | 50 | pr_notice("%s: using 0xed I/O delay port\n", id->ident); |
| 51 | id->ident); | ||
| 52 | io_delay_type = CONFIG_IO_DELAY_TYPE_0XED; | 51 | io_delay_type = CONFIG_IO_DELAY_TYPE_0XED; |
| 53 | } | 52 | } |
| 54 | 53 | ||
| @@ -64,40 +63,40 @@ static struct dmi_system_id __initdata io_delay_0xed_port_dmi_table[] = { | |||
| 64 | .callback = dmi_io_delay_0xed_port, | 63 | .callback = dmi_io_delay_0xed_port, |
| 65 | .ident = "Compaq Presario V6000", | 64 | .ident = "Compaq Presario V6000", |
| 66 | .matches = { | 65 | .matches = { |
| 67 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), | 66 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), |
| 68 | DMI_MATCH(DMI_BOARD_NAME, "30B7") | 67 | DMI_MATCH(DMI_BOARD_NAME, "30B7") |
| 69 | } | 68 | } |
| 70 | }, | 69 | }, |
| 71 | { | 70 | { |
| 72 | .callback = dmi_io_delay_0xed_port, | 71 | .callback = dmi_io_delay_0xed_port, |
| 73 | .ident = "HP Pavilion dv9000z", | 72 | .ident = "HP Pavilion dv9000z", |
| 74 | .matches = { | 73 | .matches = { |
| 75 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), | 74 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), |
| 76 | DMI_MATCH(DMI_BOARD_NAME, "30B9") | 75 | DMI_MATCH(DMI_BOARD_NAME, "30B9") |
| 77 | } | 76 | } |
| 78 | }, | 77 | }, |
| 79 | { | 78 | { |
| 80 | .callback = dmi_io_delay_0xed_port, | 79 | .callback = dmi_io_delay_0xed_port, |
| 81 | .ident = "HP Pavilion dv6000", | 80 | .ident = "HP Pavilion dv6000", |
| 82 | .matches = { | 81 | .matches = { |
| 83 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), | 82 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), |
| 84 | DMI_MATCH(DMI_BOARD_NAME, "30B8") | 83 | DMI_MATCH(DMI_BOARD_NAME, "30B8") |
| 85 | } | 84 | } |
| 86 | }, | 85 | }, |
| 87 | { | 86 | { |
| 88 | .callback = dmi_io_delay_0xed_port, | 87 | .callback = dmi_io_delay_0xed_port, |
| 89 | .ident = "HP Pavilion tx1000", | 88 | .ident = "HP Pavilion tx1000", |
| 90 | .matches = { | 89 | .matches = { |
| 91 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), | 90 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), |
| 92 | DMI_MATCH(DMI_BOARD_NAME, "30BF") | 91 | DMI_MATCH(DMI_BOARD_NAME, "30BF") |
| 93 | } | 92 | } |
| 94 | }, | 93 | }, |
| 95 | { | 94 | { |
| 96 | .callback = dmi_io_delay_0xed_port, | 95 | .callback = dmi_io_delay_0xed_port, |
| 97 | .ident = "Presario F700", | 96 | .ident = "Presario F700", |
| 98 | .matches = { | 97 | .matches = { |
| 99 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), | 98 | DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"), |
| 100 | DMI_MATCH(DMI_BOARD_NAME, "30D3") | 99 | DMI_MATCH(DMI_BOARD_NAME, "30D3") |
| 101 | } | 100 | } |
| 102 | }, | 101 | }, |
| 103 | { } | 102 | { } |
diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c index f13ca1650aaf..3aaf7b9e3a8b 100644 --- a/arch/x86/kernel/irq.c +++ b/arch/x86/kernel/irq.c | |||
| @@ -15,6 +15,9 @@ | |||
| 15 | 15 | ||
| 16 | atomic_t irq_err_count; | 16 | atomic_t irq_err_count; |
| 17 | 17 | ||
| 18 | /* Function pointer for generic interrupt vector handling */ | ||
| 19 | void (*generic_interrupt_extension)(void) = NULL; | ||
| 20 | |||
| 18 | /* | 21 | /* |
| 19 | * 'what should we do if we get a hw irq event on an illegal vector'. | 22 | * 'what should we do if we get a hw irq event on an illegal vector'. |
| 20 | * each architecture has to answer this themselves. | 23 | * each architecture has to answer this themselves. |
| @@ -42,55 +45,60 @@ void ack_bad_irq(unsigned int irq) | |||
| 42 | /* | 45 | /* |
| 43 | * /proc/interrupts printing: | 46 | * /proc/interrupts printing: |
| 44 | */ | 47 | */ |
| 45 | static int show_other_interrupts(struct seq_file *p) | 48 | static int show_other_interrupts(struct seq_file *p, int prec) |
| 46 | { | 49 | { |
| 47 | int j; | 50 | int j; |
| 48 | 51 | ||
| 49 | seq_printf(p, "NMI: "); | 52 | seq_printf(p, "%*s: ", prec, "NMI"); |
| 50 | for_each_online_cpu(j) | 53 | for_each_online_cpu(j) |
| 51 | seq_printf(p, "%10u ", irq_stats(j)->__nmi_count); | 54 | seq_printf(p, "%10u ", irq_stats(j)->__nmi_count); |
| 52 | seq_printf(p, " Non-maskable interrupts\n"); | 55 | seq_printf(p, " Non-maskable interrupts\n"); |
| 53 | #ifdef CONFIG_X86_LOCAL_APIC | 56 | #ifdef CONFIG_X86_LOCAL_APIC |
| 54 | seq_printf(p, "LOC: "); | 57 | seq_printf(p, "%*s: ", prec, "LOC"); |
| 55 | for_each_online_cpu(j) | 58 | for_each_online_cpu(j) |
| 56 | seq_printf(p, "%10u ", irq_stats(j)->apic_timer_irqs); | 59 | seq_printf(p, "%10u ", irq_stats(j)->apic_timer_irqs); |
| 57 | seq_printf(p, " Local timer interrupts\n"); | 60 | seq_printf(p, " Local timer interrupts\n"); |
| 61 | |||
| 62 | seq_printf(p, "%*s: ", prec, "SPU"); | ||
| 63 | for_each_online_cpu(j) | ||
| 64 | seq_printf(p, "%10u ", irq_stats(j)->irq_spurious_count); | ||
| 65 | seq_printf(p, " Spurious interrupts\n"); | ||
| 58 | #endif | 66 | #endif |
| 67 | if (generic_interrupt_extension) { | ||
| 68 | seq_printf(p, "PLT: "); | ||
| 69 | for_each_online_cpu(j) | ||
| 70 | seq_printf(p, "%10u ", irq_stats(j)->generic_irqs); | ||
| 71 | seq_printf(p, " Platform interrupts\n"); | ||
| 72 | } | ||
| 59 | #ifdef CONFIG_SMP | 73 | #ifdef CONFIG_SMP |
| 60 | seq_printf(p, "RES: "); | 74 | seq_printf(p, "%*s: ", prec, "RES"); |
| 61 | for_each_online_cpu(j) | 75 | for_each_online_cpu(j) |
| 62 | seq_printf(p, "%10u ", irq_stats(j)->irq_resched_count); | 76 | seq_printf(p, "%10u ", irq_stats(j)->irq_resched_count); |
| 63 | seq_printf(p, " Rescheduling interrupts\n"); | 77 | seq_printf(p, " Rescheduling interrupts\n"); |
| 64 | seq_printf(p, "CAL: "); | 78 | seq_printf(p, "%*s: ", prec, "CAL"); |
| 65 | for_each_online_cpu(j) | 79 | for_each_online_cpu(j) |
| 66 | seq_printf(p, "%10u ", irq_stats(j)->irq_call_count); | 80 | seq_printf(p, "%10u ", irq_stats(j)->irq_call_count); |
| 67 | seq_printf(p, " Function call interrupts\n"); | 81 | seq_printf(p, " Function call interrupts\n"); |
| 68 | seq_printf(p, "TLB: "); | 82 | seq_printf(p, "%*s: ", prec, "TLB"); |
| 69 | for_each_online_cpu(j) | 83 | for_each_online_cpu(j) |
| 70 | seq_printf(p, "%10u ", irq_stats(j)->irq_tlb_count); | 84 | seq_printf(p, "%10u ", irq_stats(j)->irq_tlb_count); |
| 71 | seq_printf(p, " TLB shootdowns\n"); | 85 | seq_printf(p, " TLB shootdowns\n"); |
| 72 | #endif | 86 | #endif |
| 73 | #ifdef CONFIG_X86_MCE | 87 | #ifdef CONFIG_X86_MCE |
| 74 | seq_printf(p, "TRM: "); | 88 | seq_printf(p, "%*s: ", prec, "TRM"); |
| 75 | for_each_online_cpu(j) | 89 | for_each_online_cpu(j) |
| 76 | seq_printf(p, "%10u ", irq_stats(j)->irq_thermal_count); | 90 | seq_printf(p, "%10u ", irq_stats(j)->irq_thermal_count); |
| 77 | seq_printf(p, " Thermal event interrupts\n"); | 91 | seq_printf(p, " Thermal event interrupts\n"); |
| 78 | # ifdef CONFIG_X86_64 | 92 | # ifdef CONFIG_X86_64 |
| 79 | seq_printf(p, "THR: "); | 93 | seq_printf(p, "%*s: ", prec, "THR"); |
| 80 | for_each_online_cpu(j) | 94 | for_each_online_cpu(j) |
| 81 | seq_printf(p, "%10u ", irq_stats(j)->irq_threshold_count); | 95 | seq_printf(p, "%10u ", irq_stats(j)->irq_threshold_count); |
| 82 | seq_printf(p, " Threshold APIC interrupts\n"); | 96 | seq_printf(p, " Threshold APIC interrupts\n"); |
| 83 | # endif | 97 | # endif |
| 84 | #endif | 98 | #endif |
| 85 | #ifdef CONFIG_X86_LOCAL_APIC | 99 | seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count)); |
| 86 | seq_printf(p, "SPU: "); | ||
| 87 | for_each_online_cpu(j) | ||
| 88 | seq_printf(p, "%10u ", irq_stats(j)->irq_spurious_count); | ||
| 89 | seq_printf(p, " Spurious interrupts\n"); | ||
| 90 | #endif | ||
| 91 | seq_printf(p, "ERR: %10u\n", atomic_read(&irq_err_count)); | ||
| 92 | #if defined(CONFIG_X86_IO_APIC) | 100 | #if defined(CONFIG_X86_IO_APIC) |
| 93 | seq_printf(p, "MIS: %10u\n", atomic_read(&irq_mis_count)); | 101 | seq_printf(p, "%*s: %10u\n", prec, "MIS", atomic_read(&irq_mis_count)); |
| 94 | #endif | 102 | #endif |
| 95 | return 0; | 103 | return 0; |
| 96 | } | 104 | } |
| @@ -98,19 +106,22 @@ static int show_other_interrupts(struct seq_file *p) | |||
| 98 | int show_interrupts(struct seq_file *p, void *v) | 106 | int show_interrupts(struct seq_file *p, void *v) |
| 99 | { | 107 | { |
| 100 | unsigned long flags, any_count = 0; | 108 | unsigned long flags, any_count = 0; |
| 101 | int i = *(loff_t *) v, j; | 109 | int i = *(loff_t *) v, j, prec; |
| 102 | struct irqaction *action; | 110 | struct irqaction *action; |
| 103 | struct irq_desc *desc; | 111 | struct irq_desc *desc; |
| 104 | 112 | ||
| 105 | if (i > nr_irqs) | 113 | if (i > nr_irqs) |
| 106 | return 0; | 114 | return 0; |
| 107 | 115 | ||
| 116 | for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec) | ||
| 117 | j *= 10; | ||
| 118 | |||
| 108 | if (i == nr_irqs) | 119 | if (i == nr_irqs) |
| 109 | return show_other_interrupts(p); | 120 | return show_other_interrupts(p, prec); |
| 110 | 121 | ||
| 111 | /* print header */ | 122 | /* print header */ |
| 112 | if (i == 0) { | 123 | if (i == 0) { |
| 113 | seq_printf(p, " "); | 124 | seq_printf(p, "%*s", prec + 8, ""); |
| 114 | for_each_online_cpu(j) | 125 | for_each_online_cpu(j) |
| 115 | seq_printf(p, "CPU%-8d", j); | 126 | seq_printf(p, "CPU%-8d", j); |
| 116 | seq_putc(p, '\n'); | 127 | seq_putc(p, '\n'); |
| @@ -121,23 +132,15 @@ int show_interrupts(struct seq_file *p, void *v) | |||
| 121 | return 0; | 132 | return 0; |
| 122 | 133 | ||
| 123 | spin_lock_irqsave(&desc->lock, flags); | 134 | spin_lock_irqsave(&desc->lock, flags); |
| 124 | #ifndef CONFIG_SMP | ||
| 125 | any_count = kstat_irqs(i); | ||
| 126 | #else | ||
| 127 | for_each_online_cpu(j) | 135 | for_each_online_cpu(j) |
| 128 | any_count |= kstat_irqs_cpu(i, j); | 136 | any_count |= kstat_irqs_cpu(i, j); |
| 129 | #endif | ||
| 130 | action = desc->action; | 137 | action = desc->action; |
| 131 | if (!action && !any_count) | 138 | if (!action && !any_count) |
| 132 | goto out; | 139 | goto out; |
| 133 | 140 | ||
| 134 | seq_printf(p, "%3d: ", i); | 141 | seq_printf(p, "%*d: ", prec, i); |
| 135 | #ifndef CONFIG_SMP | ||
| 136 | seq_printf(p, "%10u ", kstat_irqs(i)); | ||
| 137 | #else | ||
| 138 | for_each_online_cpu(j) | 142 | for_each_online_cpu(j) |
| 139 | seq_printf(p, "%10u ", kstat_irqs_cpu(i, j)); | 143 | seq_printf(p, "%10u ", kstat_irqs_cpu(i, j)); |
| 140 | #endif | ||
| 141 | seq_printf(p, " %8s", desc->chip->name); | 144 | seq_printf(p, " %8s", desc->chip->name); |
| 142 | seq_printf(p, "-%-8s", desc->name); | 145 | seq_printf(p, "-%-8s", desc->name); |
| 143 | 146 | ||
| @@ -162,7 +165,10 @@ u64 arch_irq_stat_cpu(unsigned int cpu) | |||
| 162 | 165 | ||
| 163 | #ifdef CONFIG_X86_LOCAL_APIC | 166 | #ifdef CONFIG_X86_LOCAL_APIC |
| 164 | sum += irq_stats(cpu)->apic_timer_irqs; | 167 | sum += irq_stats(cpu)->apic_timer_irqs; |
| 168 | sum += irq_stats(cpu)->irq_spurious_count; | ||
| 165 | #endif | 169 | #endif |
| 170 | if (generic_interrupt_extension) | ||
| 171 | sum += irq_stats(cpu)->generic_irqs; | ||
| 166 | #ifdef CONFIG_SMP | 172 | #ifdef CONFIG_SMP |
| 167 | sum += irq_stats(cpu)->irq_resched_count; | 173 | sum += irq_stats(cpu)->irq_resched_count; |
| 168 | sum += irq_stats(cpu)->irq_call_count; | 174 | sum += irq_stats(cpu)->irq_call_count; |
| @@ -174,9 +180,6 @@ u64 arch_irq_stat_cpu(unsigned int cpu) | |||
| 174 | sum += irq_stats(cpu)->irq_threshold_count; | 180 | sum += irq_stats(cpu)->irq_threshold_count; |
| 175 | #endif | 181 | #endif |
| 176 | #endif | 182 | #endif |
| 177 | #ifdef CONFIG_X86_LOCAL_APIC | ||
| 178 | sum += irq_stats(cpu)->irq_spurious_count; | ||
| 179 | #endif | ||
| 180 | return sum; | 183 | return sum; |
| 181 | } | 184 | } |
| 182 | 185 | ||
| @@ -226,4 +229,27 @@ unsigned int __irq_entry do_IRQ(struct pt_regs *regs) | |||
| 226 | return 1; | 229 | return 1; |
| 227 | } | 230 | } |
| 228 | 231 | ||
| 232 | /* | ||
| 233 | * Handler for GENERIC_INTERRUPT_VECTOR. | ||
| 234 | */ | ||
| 235 | void smp_generic_interrupt(struct pt_regs *regs) | ||
| 236 | { | ||
| 237 | struct pt_regs *old_regs = set_irq_regs(regs); | ||
| 238 | |||
| 239 | ack_APIC_irq(); | ||
| 240 | |||
| 241 | exit_idle(); | ||
| 242 | |||
| 243 | irq_enter(); | ||
| 244 | |||
| 245 | inc_irq_stat(generic_irqs); | ||
| 246 | |||
| 247 | if (generic_interrupt_extension) | ||
| 248 | generic_interrupt_extension(); | ||
| 249 | |||
| 250 | irq_exit(); | ||
| 251 | |||
| 252 | set_irq_regs(old_regs); | ||
| 253 | } | ||
| 254 | |||
| 229 | EXPORT_SYMBOL_GPL(vector_used_by_percpu_irq); | 255 | EXPORT_SYMBOL_GPL(vector_used_by_percpu_irq); |
diff --git a/arch/x86/kernel/irqinit_32.c b/arch/x86/kernel/irqinit_32.c index 50b8c3a3006c..bc1326105448 100644 --- a/arch/x86/kernel/irqinit_32.c +++ b/arch/x86/kernel/irqinit_32.c | |||
| @@ -175,6 +175,9 @@ void __init native_init_IRQ(void) | |||
| 175 | /* self generated IPI for local APIC timer */ | 175 | /* self generated IPI for local APIC timer */ |
| 176 | alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt); | 176 | alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt); |
| 177 | 177 | ||
| 178 | /* generic IPI for platform specific use */ | ||
| 179 | alloc_intr_gate(GENERIC_INTERRUPT_VECTOR, generic_interrupt); | ||
| 180 | |||
| 178 | /* IPI vectors for APIC spurious and error interrupts */ | 181 | /* IPI vectors for APIC spurious and error interrupts */ |
| 179 | alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt); | 182 | alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt); |
| 180 | alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt); | 183 | alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt); |
diff --git a/arch/x86/kernel/irqinit_64.c b/arch/x86/kernel/irqinit_64.c index da481a1e3f30..c7a49e0ffbfb 100644 --- a/arch/x86/kernel/irqinit_64.c +++ b/arch/x86/kernel/irqinit_64.c | |||
| @@ -147,6 +147,9 @@ static void __init apic_intr_init(void) | |||
| 147 | /* self generated IPI for local APIC timer */ | 147 | /* self generated IPI for local APIC timer */ |
| 148 | alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt); | 148 | alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt); |
| 149 | 149 | ||
| 150 | /* generic IPI for platform specific use */ | ||
| 151 | alloc_intr_gate(GENERIC_INTERRUPT_VECTOR, generic_interrupt); | ||
| 152 | |||
| 150 | /* IPI vectors for APIC spurious and error interrupts */ | 153 | /* IPI vectors for APIC spurious and error interrupts */ |
| 151 | alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt); | 154 | alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt); |
| 152 | alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt); | 155 | alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt); |
diff --git a/arch/x86/kernel/kdebugfs.c b/arch/x86/kernel/kdebugfs.c index ff7d3b0124f1..e444357375ce 100644 --- a/arch/x86/kernel/kdebugfs.c +++ b/arch/x86/kernel/kdebugfs.c | |||
| @@ -8,11 +8,11 @@ | |||
| 8 | */ | 8 | */ |
| 9 | #include <linux/debugfs.h> | 9 | #include <linux/debugfs.h> |
| 10 | #include <linux/uaccess.h> | 10 | #include <linux/uaccess.h> |
| 11 | #include <linux/stat.h> | 11 | #include <linux/module.h> |
| 12 | #include <linux/init.h> | 12 | #include <linux/init.h> |
| 13 | #include <linux/stat.h> | ||
| 13 | #include <linux/io.h> | 14 | #include <linux/io.h> |
| 14 | #include <linux/mm.h> | 15 | #include <linux/mm.h> |
| 15 | #include <linux/module.h> | ||
| 16 | 16 | ||
| 17 | #include <asm/setup.h> | 17 | #include <asm/setup.h> |
| 18 | 18 | ||
| @@ -26,9 +26,8 @@ struct setup_data_node { | |||
| 26 | u32 len; | 26 | u32 len; |
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | static ssize_t | 29 | static ssize_t setup_data_read(struct file *file, char __user *user_buf, |
| 30 | setup_data_read(struct file *file, char __user *user_buf, size_t count, | 30 | size_t count, loff_t *ppos) |
| 31 | loff_t *ppos) | ||
| 32 | { | 31 | { |
| 33 | struct setup_data_node *node = file->private_data; | 32 | struct setup_data_node *node = file->private_data; |
| 34 | unsigned long remain; | 33 | unsigned long remain; |
| @@ -39,20 +38,21 @@ setup_data_read(struct file *file, char __user *user_buf, size_t count, | |||
| 39 | 38 | ||
| 40 | if (pos < 0) | 39 | if (pos < 0) |
| 41 | return -EINVAL; | 40 | return -EINVAL; |
| 41 | |||
| 42 | if (pos >= node->len) | 42 | if (pos >= node->len) |
| 43 | return 0; | 43 | return 0; |
| 44 | 44 | ||
| 45 | if (count > node->len - pos) | 45 | if (count > node->len - pos) |
| 46 | count = node->len - pos; | 46 | count = node->len - pos; |
| 47 | |||
| 47 | pa = node->paddr + sizeof(struct setup_data) + pos; | 48 | pa = node->paddr + sizeof(struct setup_data) + pos; |
| 48 | pg = pfn_to_page((pa + count - 1) >> PAGE_SHIFT); | 49 | pg = pfn_to_page((pa + count - 1) >> PAGE_SHIFT); |
| 49 | if (PageHighMem(pg)) { | 50 | if (PageHighMem(pg)) { |
| 50 | p = ioremap_cache(pa, count); | 51 | p = ioremap_cache(pa, count); |
| 51 | if (!p) | 52 | if (!p) |
| 52 | return -ENXIO; | 53 | return -ENXIO; |
| 53 | } else { | 54 | } else |
| 54 | p = __va(pa); | 55 | p = __va(pa); |
| 55 | } | ||
| 56 | 56 | ||
| 57 | remain = copy_to_user(user_buf, p, count); | 57 | remain = copy_to_user(user_buf, p, count); |
| 58 | 58 | ||
| @@ -70,12 +70,13 @@ setup_data_read(struct file *file, char __user *user_buf, size_t count, | |||
| 70 | static int setup_data_open(struct inode *inode, struct file *file) | 70 | static int setup_data_open(struct inode *inode, struct file *file) |
| 71 | { | 71 | { |
| 72 | file->private_data = inode->i_private; | 72 | file->private_data = inode->i_private; |
| 73 | |||
| 73 | return 0; | 74 | return 0; |
| 74 | } | 75 | } |
| 75 | 76 | ||
| 76 | static const struct file_operations fops_setup_data = { | 77 | static const struct file_operations fops_setup_data = { |
| 77 | .read = setup_data_read, | 78 | .read = setup_data_read, |
| 78 | .open = setup_data_open, | 79 | .open = setup_data_open, |
| 79 | }; | 80 | }; |
| 80 | 81 | ||
| 81 | static int __init | 82 | static int __init |
| @@ -84,57 +85,50 @@ create_setup_data_node(struct dentry *parent, int no, | |||
| 84 | { | 85 | { |
| 85 | struct dentry *d, *type, *data; | 86 | struct dentry *d, *type, *data; |
| 86 | char buf[16]; | 87 | char buf[16]; |
| 87 | int error; | ||
| 88 | 88 | ||
| 89 | sprintf(buf, "%d", no); | 89 | sprintf(buf, "%d", no); |
| 90 | d = debugfs_create_dir(buf, parent); | 90 | d = debugfs_create_dir(buf, parent); |
| 91 | if (!d) { | 91 | if (!d) |
| 92 | error = -ENOMEM; | 92 | return -ENOMEM; |
| 93 | goto err_return; | 93 | |
| 94 | } | ||
| 95 | type = debugfs_create_x32("type", S_IRUGO, d, &node->type); | 94 | type = debugfs_create_x32("type", S_IRUGO, d, &node->type); |
| 96 | if (!type) { | 95 | if (!type) |
| 97 | error = -ENOMEM; | ||
| 98 | goto err_dir; | 96 | goto err_dir; |
| 99 | } | 97 | |
| 100 | data = debugfs_create_file("data", S_IRUGO, d, node, &fops_setup_data); | 98 | data = debugfs_create_file("data", S_IRUGO, d, node, &fops_setup_data); |
| 101 | if (!data) { | 99 | if (!data) |
| 102 | error = -ENOMEM; | ||
| 103 | goto err_type; | 100 | goto err_type; |
| 104 | } | 101 | |
| 105 | return 0; | 102 | return 0; |
| 106 | 103 | ||
| 107 | err_type: | 104 | err_type: |
| 108 | debugfs_remove(type); | 105 | debugfs_remove(type); |
| 109 | err_dir: | 106 | err_dir: |
| 110 | debugfs_remove(d); | 107 | debugfs_remove(d); |
| 111 | err_return: | 108 | return -ENOMEM; |
| 112 | return error; | ||
| 113 | } | 109 | } |
| 114 | 110 | ||
| 115 | static int __init create_setup_data_nodes(struct dentry *parent) | 111 | static int __init create_setup_data_nodes(struct dentry *parent) |
| 116 | { | 112 | { |
| 117 | struct setup_data_node *node; | 113 | struct setup_data_node *node; |
| 118 | struct setup_data *data; | 114 | struct setup_data *data; |
| 119 | int error, no = 0; | 115 | int error = -ENOMEM; |
| 120 | struct dentry *d; | 116 | struct dentry *d; |
| 121 | struct page *pg; | 117 | struct page *pg; |
| 122 | u64 pa_data; | 118 | u64 pa_data; |
| 119 | int no = 0; | ||
| 123 | 120 | ||
| 124 | d = debugfs_create_dir("setup_data", parent); | 121 | d = debugfs_create_dir("setup_data", parent); |
| 125 | if (!d) { | 122 | if (!d) |
| 126 | error = -ENOMEM; | 123 | return -ENOMEM; |
| 127 | goto err_return; | ||
| 128 | } | ||
| 129 | 124 | ||
| 130 | pa_data = boot_params.hdr.setup_data; | 125 | pa_data = boot_params.hdr.setup_data; |
| 131 | 126 | ||
| 132 | while (pa_data) { | 127 | while (pa_data) { |
| 133 | node = kmalloc(sizeof(*node), GFP_KERNEL); | 128 | node = kmalloc(sizeof(*node), GFP_KERNEL); |
| 134 | if (!node) { | 129 | if (!node) |
| 135 | error = -ENOMEM; | ||
| 136 | goto err_dir; | 130 | goto err_dir; |
| 137 | } | 131 | |
| 138 | pg = pfn_to_page((pa_data+sizeof(*data)-1) >> PAGE_SHIFT); | 132 | pg = pfn_to_page((pa_data+sizeof(*data)-1) >> PAGE_SHIFT); |
| 139 | if (PageHighMem(pg)) { | 133 | if (PageHighMem(pg)) { |
| 140 | data = ioremap_cache(pa_data, sizeof(*data)); | 134 | data = ioremap_cache(pa_data, sizeof(*data)); |
| @@ -143,9 +137,8 @@ static int __init create_setup_data_nodes(struct dentry *parent) | |||
| 143 | error = -ENXIO; | 137 | error = -ENXIO; |
| 144 | goto err_dir; | 138 | goto err_dir; |
| 145 | } | 139 | } |
| 146 | } else { | 140 | } else |
| 147 | data = __va(pa_data); | 141 | data = __va(pa_data); |
| 148 | } | ||
| 149 | 142 | ||
| 150 | node->paddr = pa_data; | 143 | node->paddr = pa_data; |
| 151 | node->type = data->type; | 144 | node->type = data->type; |
| @@ -159,11 +152,11 @@ static int __init create_setup_data_nodes(struct dentry *parent) | |||
| 159 | goto err_dir; | 152 | goto err_dir; |
| 160 | no++; | 153 | no++; |
| 161 | } | 154 | } |
| 155 | |||
| 162 | return 0; | 156 | return 0; |
| 163 | 157 | ||
| 164 | err_dir: | 158 | err_dir: |
| 165 | debugfs_remove(d); | 159 | debugfs_remove(d); |
| 166 | err_return: | ||
| 167 | return error; | 160 | return error; |
| 168 | } | 161 | } |
| 169 | 162 | ||
| @@ -175,28 +168,26 @@ static struct debugfs_blob_wrapper boot_params_blob = { | |||
| 175 | static int __init boot_params_kdebugfs_init(void) | 168 | static int __init boot_params_kdebugfs_init(void) |
| 176 | { | 169 | { |
| 177 | struct dentry *dbp, *version, *data; | 170 | struct dentry *dbp, *version, *data; |
| 178 | int error; | 171 | int error = -ENOMEM; |
| 179 | 172 | ||
| 180 | dbp = debugfs_create_dir("boot_params", NULL); | 173 | dbp = debugfs_create_dir("boot_params", NULL); |
| 181 | if (!dbp) { | 174 | if (!dbp) |
| 182 | error = -ENOMEM; | 175 | return -ENOMEM; |
| 183 | goto err_return; | 176 | |
| 184 | } | ||
| 185 | version = debugfs_create_x16("version", S_IRUGO, dbp, | 177 | version = debugfs_create_x16("version", S_IRUGO, dbp, |
| 186 | &boot_params.hdr.version); | 178 | &boot_params.hdr.version); |
| 187 | if (!version) { | 179 | if (!version) |
| 188 | error = -ENOMEM; | ||
| 189 | goto err_dir; | 180 | goto err_dir; |
| 190 | } | 181 | |
| 191 | data = debugfs_create_blob("data", S_IRUGO, dbp, | 182 | data = debugfs_create_blob("data", S_IRUGO, dbp, |
| 192 | &boot_params_blob); | 183 | &boot_params_blob); |
| 193 | if (!data) { | 184 | if (!data) |
| 194 | error = -ENOMEM; | ||
| 195 | goto err_version; | 185 | goto err_version; |
| 196 | } | 186 | |
| 197 | error = create_setup_data_nodes(dbp); | 187 | error = create_setup_data_nodes(dbp); |
| 198 | if (error) | 188 | if (error) |
| 199 | goto err_data; | 189 | goto err_data; |
| 190 | |||
| 200 | return 0; | 191 | return 0; |
| 201 | 192 | ||
| 202 | err_data: | 193 | err_data: |
| @@ -205,10 +196,9 @@ err_version: | |||
| 205 | debugfs_remove(version); | 196 | debugfs_remove(version); |
| 206 | err_dir: | 197 | err_dir: |
| 207 | debugfs_remove(dbp); | 198 | debugfs_remove(dbp); |
| 208 | err_return: | ||
| 209 | return error; | 199 | return error; |
| 210 | } | 200 | } |
| 211 | #endif | 201 | #endif /* CONFIG_DEBUG_BOOT_PARAMS */ |
| 212 | 202 | ||
| 213 | static int __init arch_kdebugfs_init(void) | 203 | static int __init arch_kdebugfs_init(void) |
| 214 | { | 204 | { |
diff --git a/arch/x86/kernel/kprobes.c b/arch/x86/kernel/kprobes.c index 4558dd3918cf..55b94614e348 100644 --- a/arch/x86/kernel/kprobes.c +++ b/arch/x86/kernel/kprobes.c | |||
| @@ -193,7 +193,7 @@ static int __kprobes can_boost(kprobe_opcode_t *opcodes) | |||
| 193 | kprobe_opcode_t opcode; | 193 | kprobe_opcode_t opcode; |
| 194 | kprobe_opcode_t *orig_opcodes = opcodes; | 194 | kprobe_opcode_t *orig_opcodes = opcodes; |
| 195 | 195 | ||
| 196 | if (search_exception_tables(opcodes)) | 196 | if (search_exception_tables((unsigned long)opcodes)) |
| 197 | return 0; /* Page fault may occur on this address. */ | 197 | return 0; /* Page fault may occur on this address. */ |
| 198 | 198 | ||
| 199 | retry: | 199 | retry: |
diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c index 478bca986eca..33019ddb56b4 100644 --- a/arch/x86/kernel/kvm.c +++ b/arch/x86/kernel/kvm.c | |||
| @@ -138,12 +138,6 @@ static void kvm_set_pte_atomic(pte_t *ptep, pte_t pte) | |||
| 138 | kvm_mmu_write(ptep, pte_val(pte)); | 138 | kvm_mmu_write(ptep, pte_val(pte)); |
| 139 | } | 139 | } |
| 140 | 140 | ||
| 141 | static void kvm_set_pte_present(struct mm_struct *mm, unsigned long addr, | ||
| 142 | pte_t *ptep, pte_t pte) | ||
| 143 | { | ||
| 144 | kvm_mmu_write(ptep, pte_val(pte)); | ||
| 145 | } | ||
| 146 | |||
| 147 | static void kvm_pte_clear(struct mm_struct *mm, | 141 | static void kvm_pte_clear(struct mm_struct *mm, |
| 148 | unsigned long addr, pte_t *ptep) | 142 | unsigned long addr, pte_t *ptep) |
| 149 | { | 143 | { |
| @@ -220,7 +214,6 @@ static void paravirt_ops_setup(void) | |||
| 220 | #if PAGETABLE_LEVELS >= 3 | 214 | #if PAGETABLE_LEVELS >= 3 |
| 221 | #ifdef CONFIG_X86_PAE | 215 | #ifdef CONFIG_X86_PAE |
| 222 | pv_mmu_ops.set_pte_atomic = kvm_set_pte_atomic; | 216 | pv_mmu_ops.set_pte_atomic = kvm_set_pte_atomic; |
| 223 | pv_mmu_ops.set_pte_present = kvm_set_pte_present; | ||
| 224 | pv_mmu_ops.pte_clear = kvm_pte_clear; | 217 | pv_mmu_ops.pte_clear = kvm_pte_clear; |
| 225 | pv_mmu_ops.pmd_clear = kvm_pmd_clear; | 218 | pv_mmu_ops.pmd_clear = kvm_pmd_clear; |
| 226 | #endif | 219 | #endif |
diff --git a/arch/x86/kernel/machine_kexec_32.c b/arch/x86/kernel/machine_kexec_32.c index f5fc8c781a62..e7368c1da01d 100644 --- a/arch/x86/kernel/machine_kexec_32.c +++ b/arch/x86/kernel/machine_kexec_32.c | |||
| @@ -14,12 +14,12 @@ | |||
| 14 | #include <linux/ftrace.h> | 14 | #include <linux/ftrace.h> |
| 15 | #include <linux/suspend.h> | 15 | #include <linux/suspend.h> |
| 16 | #include <linux/gfp.h> | 16 | #include <linux/gfp.h> |
| 17 | #include <linux/io.h> | ||
| 17 | 18 | ||
| 18 | #include <asm/pgtable.h> | 19 | #include <asm/pgtable.h> |
| 19 | #include <asm/pgalloc.h> | 20 | #include <asm/pgalloc.h> |
| 20 | #include <asm/tlbflush.h> | 21 | #include <asm/tlbflush.h> |
| 21 | #include <asm/mmu_context.h> | 22 | #include <asm/mmu_context.h> |
| 22 | #include <asm/io.h> | ||
| 23 | #include <asm/apic.h> | 23 | #include <asm/apic.h> |
| 24 | #include <asm/cpufeature.h> | 24 | #include <asm/cpufeature.h> |
| 25 | #include <asm/desc.h> | 25 | #include <asm/desc.h> |
| @@ -63,7 +63,7 @@ static void load_segments(void) | |||
| 63 | "\tmovl %%eax,%%fs\n" | 63 | "\tmovl %%eax,%%fs\n" |
| 64 | "\tmovl %%eax,%%gs\n" | 64 | "\tmovl %%eax,%%gs\n" |
| 65 | "\tmovl %%eax,%%ss\n" | 65 | "\tmovl %%eax,%%ss\n" |
| 66 | ::: "eax", "memory"); | 66 | : : : "eax", "memory"); |
| 67 | #undef STR | 67 | #undef STR |
| 68 | #undef __STR | 68 | #undef __STR |
| 69 | } | 69 | } |
| @@ -205,7 +205,8 @@ void machine_kexec(struct kimage *image) | |||
| 205 | 205 | ||
| 206 | if (image->preserve_context) { | 206 | if (image->preserve_context) { |
| 207 | #ifdef CONFIG_X86_IO_APIC | 207 | #ifdef CONFIG_X86_IO_APIC |
| 208 | /* We need to put APICs in legacy mode so that we can | 208 | /* |
| 209 | * We need to put APICs in legacy mode so that we can | ||
| 209 | * get timer interrupts in second kernel. kexec/kdump | 210 | * get timer interrupts in second kernel. kexec/kdump |
| 210 | * paths already have calls to disable_IO_APIC() in | 211 | * paths already have calls to disable_IO_APIC() in |
| 211 | * one form or other. kexec jump path also need | 212 | * one form or other. kexec jump path also need |
| @@ -227,7 +228,8 @@ void machine_kexec(struct kimage *image) | |||
| 227 | page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page) | 228 | page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page) |
| 228 | << PAGE_SHIFT); | 229 | << PAGE_SHIFT); |
| 229 | 230 | ||
| 230 | /* The segment registers are funny things, they have both a | 231 | /* |
| 232 | * The segment registers are funny things, they have both a | ||
| 231 | * visible and an invisible part. Whenever the visible part is | 233 | * visible and an invisible part. Whenever the visible part is |
| 232 | * set to a specific selector, the invisible part is loaded | 234 | * set to a specific selector, the invisible part is loaded |
| 233 | * with from a table in memory. At no other time is the | 235 | * with from a table in memory. At no other time is the |
| @@ -237,11 +239,12 @@ void machine_kexec(struct kimage *image) | |||
| 237 | * segments, before I zap the gdt with an invalid value. | 239 | * segments, before I zap the gdt with an invalid value. |
| 238 | */ | 240 | */ |
| 239 | load_segments(); | 241 | load_segments(); |
| 240 | /* The gdt & idt are now invalid. | 242 | /* |
| 243 | * The gdt & idt are now invalid. | ||
| 241 | * If you want to load them you must set up your own idt & gdt. | 244 | * If you want to load them you must set up your own idt & gdt. |
| 242 | */ | 245 | */ |
| 243 | set_gdt(phys_to_virt(0),0); | 246 | set_gdt(phys_to_virt(0), 0); |
| 244 | set_idt(phys_to_virt(0),0); | 247 | set_idt(phys_to_virt(0), 0); |
| 245 | 248 | ||
| 246 | /* now call it */ | 249 | /* now call it */ |
| 247 | image->start = relocate_kernel_ptr((unsigned long)image->head, | 250 | image->start = relocate_kernel_ptr((unsigned long)image->head, |
diff --git a/arch/x86/kernel/machine_kexec_64.c b/arch/x86/kernel/machine_kexec_64.c index 6993d51b7fd8..89cea4d44679 100644 --- a/arch/x86/kernel/machine_kexec_64.c +++ b/arch/x86/kernel/machine_kexec_64.c | |||
| @@ -12,11 +12,47 @@ | |||
| 12 | #include <linux/reboot.h> | 12 | #include <linux/reboot.h> |
| 13 | #include <linux/numa.h> | 13 | #include <linux/numa.h> |
| 14 | #include <linux/ftrace.h> | 14 | #include <linux/ftrace.h> |
| 15 | #include <linux/io.h> | ||
| 16 | #include <linux/suspend.h> | ||
| 15 | 17 | ||
| 16 | #include <asm/pgtable.h> | 18 | #include <asm/pgtable.h> |
| 17 | #include <asm/tlbflush.h> | 19 | #include <asm/tlbflush.h> |
| 18 | #include <asm/mmu_context.h> | 20 | #include <asm/mmu_context.h> |
| 19 | #include <asm/io.h> | 21 | |
| 22 | static int init_one_level2_page(struct kimage *image, pgd_t *pgd, | ||
| 23 | unsigned long addr) | ||
| 24 | { | ||
| 25 | pud_t *pud; | ||
| 26 | pmd_t *pmd; | ||
| 27 | struct page *page; | ||
| 28 | int result = -ENOMEM; | ||
| 29 | |||
| 30 | addr &= PMD_MASK; | ||
| 31 | pgd += pgd_index(addr); | ||
| 32 | if (!pgd_present(*pgd)) { | ||
| 33 | page = kimage_alloc_control_pages(image, 0); | ||
| 34 | if (!page) | ||
| 35 | goto out; | ||
| 36 | pud = (pud_t *)page_address(page); | ||
| 37 | memset(pud, 0, PAGE_SIZE); | ||
| 38 | set_pgd(pgd, __pgd(__pa(pud) | _KERNPG_TABLE)); | ||
| 39 | } | ||
| 40 | pud = pud_offset(pgd, addr); | ||
| 41 | if (!pud_present(*pud)) { | ||
| 42 | page = kimage_alloc_control_pages(image, 0); | ||
| 43 | if (!page) | ||
| 44 | goto out; | ||
| 45 | pmd = (pmd_t *)page_address(page); | ||
| 46 | memset(pmd, 0, PAGE_SIZE); | ||
| 47 | set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE)); | ||
| 48 | } | ||
| 49 | pmd = pmd_offset(pud, addr); | ||
| 50 | if (!pmd_present(*pmd)) | ||
| 51 | set_pmd(pmd, __pmd(addr | __PAGE_KERNEL_LARGE_EXEC)); | ||
| 52 | result = 0; | ||
| 53 | out: | ||
| 54 | return result; | ||
| 55 | } | ||
| 20 | 56 | ||
| 21 | static void init_level2_page(pmd_t *level2p, unsigned long addr) | 57 | static void init_level2_page(pmd_t *level2p, unsigned long addr) |
| 22 | { | 58 | { |
| @@ -83,9 +119,8 @@ static int init_level4_page(struct kimage *image, pgd_t *level4p, | |||
| 83 | } | 119 | } |
| 84 | level3p = (pud_t *)page_address(page); | 120 | level3p = (pud_t *)page_address(page); |
| 85 | result = init_level3_page(image, level3p, addr, last_addr); | 121 | result = init_level3_page(image, level3p, addr, last_addr); |
| 86 | if (result) { | 122 | if (result) |
| 87 | goto out; | 123 | goto out; |
| 88 | } | ||
| 89 | set_pgd(level4p++, __pgd(__pa(level3p) | _KERNPG_TABLE)); | 124 | set_pgd(level4p++, __pgd(__pa(level3p) | _KERNPG_TABLE)); |
| 90 | addr += PGDIR_SIZE; | 125 | addr += PGDIR_SIZE; |
| 91 | } | 126 | } |
| @@ -156,6 +191,13 @@ static int init_pgtable(struct kimage *image, unsigned long start_pgtable) | |||
| 156 | result = init_level4_page(image, level4p, 0, max_pfn << PAGE_SHIFT); | 191 | result = init_level4_page(image, level4p, 0, max_pfn << PAGE_SHIFT); |
| 157 | if (result) | 192 | if (result) |
| 158 | return result; | 193 | return result; |
| 194 | /* | ||
| 195 | * image->start may be outside 0 ~ max_pfn, for example when | ||
| 196 | * jump back to original kernel from kexeced kernel | ||
| 197 | */ | ||
| 198 | result = init_one_level2_page(image, level4p, image->start); | ||
| 199 | if (result) | ||
| 200 | return result; | ||
| 159 | return init_transition_pgtable(image, level4p); | 201 | return init_transition_pgtable(image, level4p); |
| 160 | } | 202 | } |
| 161 | 203 | ||
| @@ -229,20 +271,45 @@ void machine_kexec(struct kimage *image) | |||
| 229 | { | 271 | { |
| 230 | unsigned long page_list[PAGES_NR]; | 272 | unsigned long page_list[PAGES_NR]; |
| 231 | void *control_page; | 273 | void *control_page; |
| 274 | int save_ftrace_enabled; | ||
| 232 | 275 | ||
| 233 | tracer_disable(); | 276 | #ifdef CONFIG_KEXEC_JUMP |
| 277 | if (kexec_image->preserve_context) | ||
| 278 | save_processor_state(); | ||
| 279 | #endif | ||
| 280 | |||
| 281 | save_ftrace_enabled = __ftrace_enabled_save(); | ||
| 234 | 282 | ||
| 235 | /* Interrupts aren't acceptable while we reboot */ | 283 | /* Interrupts aren't acceptable while we reboot */ |
| 236 | local_irq_disable(); | 284 | local_irq_disable(); |
| 237 | 285 | ||
| 286 | if (image->preserve_context) { | ||
| 287 | #ifdef CONFIG_X86_IO_APIC | ||
| 288 | /* | ||
| 289 | * We need to put APICs in legacy mode so that we can | ||
| 290 | * get timer interrupts in second kernel. kexec/kdump | ||
| 291 | * paths already have calls to disable_IO_APIC() in | ||
| 292 | * one form or other. kexec jump path also need | ||
| 293 | * one. | ||
| 294 | */ | ||
| 295 | disable_IO_APIC(); | ||
| 296 | #endif | ||
| 297 | } | ||
| 298 | |||
| 238 | control_page = page_address(image->control_code_page) + PAGE_SIZE; | 299 | control_page = page_address(image->control_code_page) + PAGE_SIZE; |
| 239 | memcpy(control_page, relocate_kernel, PAGE_SIZE); | 300 | memcpy(control_page, relocate_kernel, KEXEC_CONTROL_CODE_MAX_SIZE); |
| 240 | 301 | ||
| 241 | page_list[PA_CONTROL_PAGE] = virt_to_phys(control_page); | 302 | page_list[PA_CONTROL_PAGE] = virt_to_phys(control_page); |
| 303 | page_list[VA_CONTROL_PAGE] = (unsigned long)control_page; | ||
| 242 | page_list[PA_TABLE_PAGE] = | 304 | page_list[PA_TABLE_PAGE] = |
| 243 | (unsigned long)__pa(page_address(image->control_code_page)); | 305 | (unsigned long)__pa(page_address(image->control_code_page)); |
| 244 | 306 | ||
| 245 | /* The segment registers are funny things, they have both a | 307 | if (image->type == KEXEC_TYPE_DEFAULT) |
| 308 | page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page) | ||
| 309 | << PAGE_SHIFT); | ||
| 310 | |||
| 311 | /* | ||
| 312 | * The segment registers are funny things, they have both a | ||
| 246 | * visible and an invisible part. Whenever the visible part is | 313 | * visible and an invisible part. Whenever the visible part is |
| 247 | * set to a specific selector, the invisible part is loaded | 314 | * set to a specific selector, the invisible part is loaded |
| 248 | * with from a table in memory. At no other time is the | 315 | * with from a table in memory. At no other time is the |
| @@ -252,15 +319,25 @@ void machine_kexec(struct kimage *image) | |||
| 252 | * segments, before I zap the gdt with an invalid value. | 319 | * segments, before I zap the gdt with an invalid value. |
| 253 | */ | 320 | */ |
| 254 | load_segments(); | 321 | load_segments(); |
| 255 | /* The gdt & idt are now invalid. | 322 | /* |
| 323 | * The gdt & idt are now invalid. | ||
| 256 | * If you want to load them you must set up your own idt & gdt. | 324 | * If you want to load them you must set up your own idt & gdt. |
| 257 | */ | 325 | */ |
| 258 | set_gdt(phys_to_virt(0),0); | 326 | set_gdt(phys_to_virt(0), 0); |
| 259 | set_idt(phys_to_virt(0),0); | 327 | set_idt(phys_to_virt(0), 0); |
| 260 | 328 | ||
| 261 | /* now call it */ | 329 | /* now call it */ |
| 262 | relocate_kernel((unsigned long)image->head, (unsigned long)page_list, | 330 | image->start = relocate_kernel((unsigned long)image->head, |
| 263 | image->start); | 331 | (unsigned long)page_list, |
| 332 | image->start, | ||
| 333 | image->preserve_context); | ||
| 334 | |||
| 335 | #ifdef CONFIG_KEXEC_JUMP | ||
| 336 | if (kexec_image->preserve_context) | ||
| 337 | restore_processor_state(); | ||
| 338 | #endif | ||
| 339 | |||
| 340 | __ftrace_enabled_restore(save_ftrace_enabled); | ||
| 264 | } | 341 | } |
| 265 | 342 | ||
| 266 | void arch_crash_save_vmcoreinfo(void) | 343 | void arch_crash_save_vmcoreinfo(void) |
diff --git a/arch/x86/kernel/mmconf-fam10h_64.c b/arch/x86/kernel/mmconf-fam10h_64.c index 666e43df51f9..712d15fdc416 100644 --- a/arch/x86/kernel/mmconf-fam10h_64.c +++ b/arch/x86/kernel/mmconf-fam10h_64.c | |||
| @@ -226,7 +226,7 @@ static int __devinit set_check_enable_amd_mmconf(const struct dmi_system_id *d) | |||
| 226 | return 0; | 226 | return 0; |
| 227 | } | 227 | } |
| 228 | 228 | ||
| 229 | static struct dmi_system_id __devinitdata mmconf_dmi_table[] = { | 229 | static const struct dmi_system_id __cpuinitconst mmconf_dmi_table[] = { |
| 230 | { | 230 | { |
| 231 | .callback = set_check_enable_amd_mmconf, | 231 | .callback = set_check_enable_amd_mmconf, |
| 232 | .ident = "Sun Microsystems Machine", | 232 | .ident = "Sun Microsystems Machine", |
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c index 37cb1bda1baf..dce99dca6cf8 100644 --- a/arch/x86/kernel/mpparse.c +++ b/arch/x86/kernel/mpparse.c | |||
| @@ -109,9 +109,6 @@ static void __init MP_bus_info(struct mpc_bus *m) | |||
| 109 | } else | 109 | } else |
| 110 | printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str); | 110 | printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str); |
| 111 | } | 111 | } |
| 112 | #endif | ||
| 113 | |||
| 114 | #ifdef CONFIG_X86_IO_APIC | ||
| 115 | 112 | ||
| 116 | static int bad_ioapic(unsigned long address) | 113 | static int bad_ioapic(unsigned long address) |
| 117 | { | 114 | { |
| @@ -224,8 +221,12 @@ static void __init MP_intsrc_info(struct mpc_intsrc *m) | |||
| 224 | if (++mp_irq_entries == MAX_IRQ_SOURCES) | 221 | if (++mp_irq_entries == MAX_IRQ_SOURCES) |
| 225 | panic("Max # of irq sources exceeded!!\n"); | 222 | panic("Max # of irq sources exceeded!!\n"); |
| 226 | } | 223 | } |
| 224 | #else /* CONFIG_X86_IO_APIC */ | ||
| 225 | static inline void __init MP_bus_info(struct mpc_bus *m) {} | ||
| 226 | static inline void __init MP_ioapic_info(struct mpc_ioapic *m) {} | ||
| 227 | static inline void __init MP_intsrc_info(struct mpc_intsrc *m) {} | ||
| 228 | #endif /* CONFIG_X86_IO_APIC */ | ||
| 227 | 229 | ||
| 228 | #endif | ||
| 229 | 230 | ||
| 230 | static void __init MP_lintsrc_info(struct mpc_lintsrc *m) | 231 | static void __init MP_lintsrc_info(struct mpc_lintsrc *m) |
| 231 | { | 232 | { |
| @@ -275,6 +276,20 @@ static int __init smp_check_mpc(struct mpc_table *mpc, char *oem, char *str) | |||
| 275 | return 1; | 276 | return 1; |
| 276 | } | 277 | } |
| 277 | 278 | ||
| 279 | static void skip_entry(unsigned char **ptr, int *count, int size) | ||
| 280 | { | ||
| 281 | *ptr += size; | ||
| 282 | *count += size; | ||
| 283 | } | ||
| 284 | |||
| 285 | static void __init smp_dump_mptable(struct mpc_table *mpc, unsigned char *mpt) | ||
| 286 | { | ||
| 287 | printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n" | ||
| 288 | "type %x\n", *mpt); | ||
| 289 | print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16, | ||
| 290 | 1, mpc, mpc->length, 1); | ||
| 291 | } | ||
| 292 | |||
| 278 | static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early) | 293 | static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early) |
| 279 | { | 294 | { |
| 280 | char str[16]; | 295 | char str[16]; |
| @@ -310,61 +325,30 @@ static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early) | |||
| 310 | while (count < mpc->length) { | 325 | while (count < mpc->length) { |
| 311 | switch (*mpt) { | 326 | switch (*mpt) { |
| 312 | case MP_PROCESSOR: | 327 | case MP_PROCESSOR: |
| 313 | { | 328 | /* ACPI may have already provided this data */ |
| 314 | struct mpc_cpu *m = (struct mpc_cpu *)mpt; | 329 | if (!acpi_lapic) |
| 315 | /* ACPI may have already provided this data */ | 330 | MP_processor_info((struct mpc_cpu *)mpt); |
| 316 | if (!acpi_lapic) | 331 | skip_entry(&mpt, &count, sizeof(struct mpc_cpu)); |
| 317 | MP_processor_info(m); | 332 | break; |
| 318 | mpt += sizeof(*m); | ||
| 319 | count += sizeof(*m); | ||
| 320 | break; | ||
| 321 | } | ||
| 322 | case MP_BUS: | 333 | case MP_BUS: |
| 323 | { | 334 | MP_bus_info((struct mpc_bus *)mpt); |
| 324 | struct mpc_bus *m = (struct mpc_bus *)mpt; | 335 | skip_entry(&mpt, &count, sizeof(struct mpc_bus)); |
| 325 | #ifdef CONFIG_X86_IO_APIC | 336 | break; |
| 326 | MP_bus_info(m); | ||
| 327 | #endif | ||
| 328 | mpt += sizeof(*m); | ||
| 329 | count += sizeof(*m); | ||
| 330 | break; | ||
| 331 | } | ||
| 332 | case MP_IOAPIC: | 337 | case MP_IOAPIC: |
| 333 | { | 338 | MP_ioapic_info((struct mpc_ioapic *)mpt); |
| 334 | #ifdef CONFIG_X86_IO_APIC | 339 | skip_entry(&mpt, &count, sizeof(struct mpc_ioapic)); |
| 335 | struct mpc_ioapic *m = (struct mpc_ioapic *)mpt; | 340 | break; |
| 336 | MP_ioapic_info(m); | ||
| 337 | #endif | ||
| 338 | mpt += sizeof(struct mpc_ioapic); | ||
| 339 | count += sizeof(struct mpc_ioapic); | ||
| 340 | break; | ||
| 341 | } | ||
| 342 | case MP_INTSRC: | 341 | case MP_INTSRC: |
| 343 | { | 342 | MP_intsrc_info((struct mpc_intsrc *)mpt); |
| 344 | #ifdef CONFIG_X86_IO_APIC | 343 | skip_entry(&mpt, &count, sizeof(struct mpc_intsrc)); |
| 345 | struct mpc_intsrc *m = (struct mpc_intsrc *)mpt; | 344 | break; |
| 346 | |||
| 347 | MP_intsrc_info(m); | ||
| 348 | #endif | ||
| 349 | mpt += sizeof(struct mpc_intsrc); | ||
| 350 | count += sizeof(struct mpc_intsrc); | ||
| 351 | break; | ||
| 352 | } | ||
| 353 | case MP_LINTSRC: | 345 | case MP_LINTSRC: |
| 354 | { | 346 | MP_lintsrc_info((struct mpc_lintsrc *)mpt); |
| 355 | struct mpc_lintsrc *m = | 347 | skip_entry(&mpt, &count, sizeof(struct mpc_lintsrc)); |
| 356 | (struct mpc_lintsrc *)mpt; | 348 | break; |
| 357 | MP_lintsrc_info(m); | ||
| 358 | mpt += sizeof(*m); | ||
| 359 | count += sizeof(*m); | ||
| 360 | break; | ||
| 361 | } | ||
| 362 | default: | 349 | default: |
| 363 | /* wrong mptable */ | 350 | /* wrong mptable */ |
| 364 | printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n"); | 351 | smp_dump_mptable(mpc, mpt); |
| 365 | printk(KERN_ERR "type %x\n", *mpt); | ||
| 366 | print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16, | ||
| 367 | 1, mpc, mpc->length, 1); | ||
| 368 | count = mpc->length; | 352 | count = mpc->length; |
| 369 | break; | 353 | break; |
| 370 | } | 354 | } |
| @@ -558,6 +542,68 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type) | |||
| 558 | 542 | ||
| 559 | static struct mpf_intel *mpf_found; | 543 | static struct mpf_intel *mpf_found; |
| 560 | 544 | ||
| 545 | static unsigned long __init get_mpc_size(unsigned long physptr) | ||
| 546 | { | ||
| 547 | struct mpc_table *mpc; | ||
| 548 | unsigned long size; | ||
| 549 | |||
| 550 | mpc = early_ioremap(physptr, PAGE_SIZE); | ||
| 551 | size = mpc->length; | ||
| 552 | early_iounmap(mpc, PAGE_SIZE); | ||
| 553 | apic_printk(APIC_VERBOSE, " mpc: %lx-%lx\n", physptr, physptr + size); | ||
| 554 | |||
| 555 | return size; | ||
| 556 | } | ||
| 557 | |||
| 558 | static int __init check_physptr(struct mpf_intel *mpf, unsigned int early) | ||
| 559 | { | ||
| 560 | struct mpc_table *mpc; | ||
| 561 | unsigned long size; | ||
| 562 | |||
| 563 | size = get_mpc_size(mpf->physptr); | ||
| 564 | mpc = early_ioremap(mpf->physptr, size); | ||
| 565 | /* | ||
| 566 | * Read the physical hardware table. Anything here will | ||
| 567 | * override the defaults. | ||
| 568 | */ | ||
| 569 | if (!smp_read_mpc(mpc, early)) { | ||
| 570 | #ifdef CONFIG_X86_LOCAL_APIC | ||
| 571 | smp_found_config = 0; | ||
| 572 | #endif | ||
| 573 | printk(KERN_ERR "BIOS bug, MP table errors detected!...\n" | ||
| 574 | "... disabling SMP support. (tell your hw vendor)\n"); | ||
| 575 | early_iounmap(mpc, size); | ||
| 576 | return -1; | ||
| 577 | } | ||
| 578 | early_iounmap(mpc, size); | ||
| 579 | |||
| 580 | if (early) | ||
| 581 | return -1; | ||
| 582 | |||
| 583 | #ifdef CONFIG_X86_IO_APIC | ||
| 584 | /* | ||
| 585 | * If there are no explicit MP IRQ entries, then we are | ||
| 586 | * broken. We set up most of the low 16 IO-APIC pins to | ||
| 587 | * ISA defaults and hope it will work. | ||
| 588 | */ | ||
| 589 | if (!mp_irq_entries) { | ||
| 590 | struct mpc_bus bus; | ||
| 591 | |||
| 592 | printk(KERN_ERR "BIOS bug, no explicit IRQ entries, " | ||
| 593 | "using default mptable. (tell your hw vendor)\n"); | ||
| 594 | |||
| 595 | bus.type = MP_BUS; | ||
| 596 | bus.busid = 0; | ||
| 597 | memcpy(bus.bustype, "ISA ", 6); | ||
| 598 | MP_bus_info(&bus); | ||
| 599 | |||
| 600 | construct_default_ioirq_mptable(0); | ||
| 601 | } | ||
| 602 | #endif | ||
| 603 | |||
| 604 | return 0; | ||
| 605 | } | ||
| 606 | |||
| 561 | /* | 607 | /* |
| 562 | * Scan the memory blocks for an SMP configuration block. | 608 | * Scan the memory blocks for an SMP configuration block. |
| 563 | */ | 609 | */ |
| @@ -611,45 +657,8 @@ static void __init __get_smp_config(unsigned int early) | |||
| 611 | construct_default_ISA_mptable(mpf->feature1); | 657 | construct_default_ISA_mptable(mpf->feature1); |
| 612 | 658 | ||
| 613 | } else if (mpf->physptr) { | 659 | } else if (mpf->physptr) { |
| 614 | 660 | if (check_physptr(mpf, early)) | |
| 615 | /* | ||
| 616 | * Read the physical hardware table. Anything here will | ||
| 617 | * override the defaults. | ||
| 618 | */ | ||
| 619 | if (!smp_read_mpc(phys_to_virt(mpf->physptr), early)) { | ||
| 620 | #ifdef CONFIG_X86_LOCAL_APIC | ||
| 621 | smp_found_config = 0; | ||
| 622 | #endif | ||
| 623 | printk(KERN_ERR | ||
| 624 | "BIOS bug, MP table errors detected!...\n"); | ||
| 625 | printk(KERN_ERR "... disabling SMP support. " | ||
| 626 | "(tell your hw vendor)\n"); | ||
| 627 | return; | ||
| 628 | } | ||
| 629 | |||
| 630 | if (early) | ||
| 631 | return; | 661 | return; |
| 632 | #ifdef CONFIG_X86_IO_APIC | ||
| 633 | /* | ||
| 634 | * If there are no explicit MP IRQ entries, then we are | ||
| 635 | * broken. We set up most of the low 16 IO-APIC pins to | ||
| 636 | * ISA defaults and hope it will work. | ||
| 637 | */ | ||
| 638 | if (!mp_irq_entries) { | ||
| 639 | struct mpc_bus bus; | ||
| 640 | |||
| 641 | printk(KERN_ERR "BIOS bug, no explicit IRQ entries, " | ||
| 642 | "using default mptable. " | ||
| 643 | "(tell your hw vendor)\n"); | ||
| 644 | |||
| 645 | bus.type = MP_BUS; | ||
| 646 | bus.busid = 0; | ||
| 647 | memcpy(bus.bustype, "ISA ", 6); | ||
| 648 | MP_bus_info(&bus); | ||
| 649 | |||
| 650 | construct_default_ioirq_mptable(0); | ||
| 651 | } | ||
| 652 | #endif | ||
| 653 | } else | 662 | } else |
| 654 | BUG(); | 663 | BUG(); |
| 655 | 664 | ||
| @@ -670,6 +679,31 @@ void __init get_smp_config(void) | |||
| 670 | __get_smp_config(0); | 679 | __get_smp_config(0); |
| 671 | } | 680 | } |
| 672 | 681 | ||
| 682 | static void smp_reserve_bootmem(struct mpf_intel *mpf) | ||
| 683 | { | ||
| 684 | unsigned long size = get_mpc_size(mpf->physptr); | ||
| 685 | #ifdef CONFIG_X86_32 | ||
| 686 | /* | ||
| 687 | * We cannot access to MPC table to compute table size yet, | ||
| 688 | * as only few megabytes from the bottom is mapped now. | ||
| 689 | * PC-9800's MPC table places on the very last of physical | ||
| 690 | * memory; so that simply reserving PAGE_SIZE from mpf->physptr | ||
| 691 | * yields BUG() in reserve_bootmem. | ||
| 692 | * also need to make sure physptr is below than max_low_pfn | ||
| 693 | * we don't need reserve the area above max_low_pfn | ||
| 694 | */ | ||
| 695 | unsigned long end = max_low_pfn * PAGE_SIZE; | ||
| 696 | |||
| 697 | if (mpf->physptr < end) { | ||
| 698 | if (mpf->physptr + size > end) | ||
| 699 | size = end - mpf->physptr; | ||
| 700 | reserve_bootmem_generic(mpf->physptr, size, BOOTMEM_DEFAULT); | ||
| 701 | } | ||
| 702 | #else | ||
| 703 | reserve_bootmem_generic(mpf->physptr, size, BOOTMEM_DEFAULT); | ||
| 704 | #endif | ||
| 705 | } | ||
| 706 | |||
| 673 | static int __init smp_scan_config(unsigned long base, unsigned long length, | 707 | static int __init smp_scan_config(unsigned long base, unsigned long length, |
| 674 | unsigned reserve) | 708 | unsigned reserve) |
| 675 | { | 709 | { |
| @@ -697,36 +731,10 @@ static int __init smp_scan_config(unsigned long base, unsigned long length, | |||
| 697 | 731 | ||
| 698 | if (!reserve) | 732 | if (!reserve) |
| 699 | return 1; | 733 | return 1; |
| 700 | reserve_bootmem_generic(virt_to_phys(mpf), PAGE_SIZE, | 734 | reserve_bootmem_generic(virt_to_phys(mpf), sizeof(*mpf), |
| 701 | BOOTMEM_DEFAULT); | ||
| 702 | if (mpf->physptr) { | ||
| 703 | unsigned long size = PAGE_SIZE; | ||
| 704 | #ifdef CONFIG_X86_32 | ||
| 705 | /* | ||
| 706 | * We cannot access to MPC table to compute | ||
| 707 | * table size yet, as only few megabytes from | ||
| 708 | * the bottom is mapped now. | ||
| 709 | * PC-9800's MPC table places on the very last | ||
| 710 | * of physical memory; so that simply reserving | ||
| 711 | * PAGE_SIZE from mpf->physptr yields BUG() | ||
| 712 | * in reserve_bootmem. | ||
| 713 | * also need to make sure physptr is below than | ||
| 714 | * max_low_pfn | ||
| 715 | * we don't need reserve the area above max_low_pfn | ||
| 716 | */ | ||
| 717 | unsigned long end = max_low_pfn * PAGE_SIZE; | ||
| 718 | |||
| 719 | if (mpf->physptr < end) { | ||
| 720 | if (mpf->physptr + size > end) | ||
| 721 | size = end - mpf->physptr; | ||
| 722 | reserve_bootmem_generic(mpf->physptr, size, | ||
| 723 | BOOTMEM_DEFAULT); | ||
| 724 | } | ||
| 725 | #else | ||
| 726 | reserve_bootmem_generic(mpf->physptr, size, | ||
| 727 | BOOTMEM_DEFAULT); | 735 | BOOTMEM_DEFAULT); |
| 728 | #endif | 736 | if (mpf->physptr) |
| 729 | } | 737 | smp_reserve_bootmem(mpf); |
| 730 | 738 | ||
| 731 | return 1; | 739 | return 1; |
| 732 | } | 740 | } |
| @@ -829,7 +837,57 @@ static int __init get_MP_intsrc_index(struct mpc_intsrc *m) | |||
| 829 | #define SPARE_SLOT_NUM 20 | 837 | #define SPARE_SLOT_NUM 20 |
| 830 | 838 | ||
| 831 | static struct mpc_intsrc __initdata *m_spare[SPARE_SLOT_NUM]; | 839 | static struct mpc_intsrc __initdata *m_spare[SPARE_SLOT_NUM]; |
| 832 | #endif | 840 | |
| 841 | static void check_irq_src(struct mpc_intsrc *m, int *nr_m_spare) | ||
| 842 | { | ||
| 843 | int i; | ||
| 844 | |||
| 845 | apic_printk(APIC_VERBOSE, "OLD "); | ||
| 846 | print_MP_intsrc_info(m); | ||
| 847 | |||
| 848 | i = get_MP_intsrc_index(m); | ||
| 849 | if (i > 0) { | ||
| 850 | assign_to_mpc_intsrc(&mp_irqs[i], m); | ||
| 851 | apic_printk(APIC_VERBOSE, "NEW "); | ||
| 852 | print_mp_irq_info(&mp_irqs[i]); | ||
| 853 | return; | ||
| 854 | } | ||
| 855 | if (!i) { | ||
| 856 | /* legacy, do nothing */ | ||
| 857 | return; | ||
| 858 | } | ||
| 859 | if (*nr_m_spare < SPARE_SLOT_NUM) { | ||
| 860 | /* | ||
| 861 | * not found (-1), or duplicated (-2) are invalid entries, | ||
| 862 | * we need to use the slot later | ||
| 863 | */ | ||
| 864 | m_spare[*nr_m_spare] = m; | ||
| 865 | *nr_m_spare += 1; | ||
| 866 | } | ||
| 867 | } | ||
| 868 | #else /* CONFIG_X86_IO_APIC */ | ||
| 869 | static inline void check_irq_src(struct mpc_intsrc *m, int *nr_m_spare) {} | ||
| 870 | #endif /* CONFIG_X86_IO_APIC */ | ||
| 871 | |||
| 872 | static int check_slot(unsigned long mpc_new_phys, unsigned long mpc_new_length, | ||
| 873 | int count) | ||
| 874 | { | ||
| 875 | if (!mpc_new_phys) { | ||
| 876 | pr_info("No spare slots, try to append...take your risk, " | ||
| 877 | "new mpc_length %x\n", count); | ||
| 878 | } else { | ||
| 879 | if (count <= mpc_new_length) | ||
| 880 | pr_info("No spare slots, try to append..., " | ||
| 881 | "new mpc_length %x\n", count); | ||
| 882 | else { | ||
| 883 | pr_err("mpc_new_length %lx is too small\n", | ||
| 884 | mpc_new_length); | ||
| 885 | return -1; | ||
| 886 | } | ||
| 887 | } | ||
| 888 | |||
| 889 | return 0; | ||
| 890 | } | ||
| 833 | 891 | ||
| 834 | static int __init replace_intsrc_all(struct mpc_table *mpc, | 892 | static int __init replace_intsrc_all(struct mpc_table *mpc, |
| 835 | unsigned long mpc_new_phys, | 893 | unsigned long mpc_new_phys, |
| @@ -837,77 +895,33 @@ static int __init replace_intsrc_all(struct mpc_table *mpc, | |||
| 837 | { | 895 | { |
| 838 | #ifdef CONFIG_X86_IO_APIC | 896 | #ifdef CONFIG_X86_IO_APIC |
| 839 | int i; | 897 | int i; |
| 840 | int nr_m_spare = 0; | ||
| 841 | #endif | 898 | #endif |
| 842 | |||
| 843 | int count = sizeof(*mpc); | 899 | int count = sizeof(*mpc); |
| 900 | int nr_m_spare = 0; | ||
| 844 | unsigned char *mpt = ((unsigned char *)mpc) + count; | 901 | unsigned char *mpt = ((unsigned char *)mpc) + count; |
| 845 | 902 | ||
| 846 | printk(KERN_INFO "mpc_length %x\n", mpc->length); | 903 | printk(KERN_INFO "mpc_length %x\n", mpc->length); |
| 847 | while (count < mpc->length) { | 904 | while (count < mpc->length) { |
| 848 | switch (*mpt) { | 905 | switch (*mpt) { |
| 849 | case MP_PROCESSOR: | 906 | case MP_PROCESSOR: |
| 850 | { | 907 | skip_entry(&mpt, &count, sizeof(struct mpc_cpu)); |
| 851 | struct mpc_cpu *m = (struct mpc_cpu *)mpt; | 908 | break; |
| 852 | mpt += sizeof(*m); | ||
| 853 | count += sizeof(*m); | ||
| 854 | break; | ||
| 855 | } | ||
| 856 | case MP_BUS: | 909 | case MP_BUS: |
| 857 | { | 910 | skip_entry(&mpt, &count, sizeof(struct mpc_bus)); |
| 858 | struct mpc_bus *m = (struct mpc_bus *)mpt; | 911 | break; |
| 859 | mpt += sizeof(*m); | ||
| 860 | count += sizeof(*m); | ||
| 861 | break; | ||
| 862 | } | ||
| 863 | case MP_IOAPIC: | 912 | case MP_IOAPIC: |
| 864 | { | 913 | skip_entry(&mpt, &count, sizeof(struct mpc_ioapic)); |
| 865 | mpt += sizeof(struct mpc_ioapic); | 914 | break; |
| 866 | count += sizeof(struct mpc_ioapic); | ||
| 867 | break; | ||
| 868 | } | ||
| 869 | case MP_INTSRC: | 915 | case MP_INTSRC: |
| 870 | { | 916 | check_irq_src((struct mpc_intsrc *)mpt, &nr_m_spare); |
| 871 | #ifdef CONFIG_X86_IO_APIC | 917 | skip_entry(&mpt, &count, sizeof(struct mpc_intsrc)); |
| 872 | struct mpc_intsrc *m = (struct mpc_intsrc *)mpt; | 918 | break; |
| 873 | |||
| 874 | printk(KERN_INFO "OLD "); | ||
| 875 | print_MP_intsrc_info(m); | ||
| 876 | i = get_MP_intsrc_index(m); | ||
| 877 | if (i > 0) { | ||
| 878 | assign_to_mpc_intsrc(&mp_irqs[i], m); | ||
| 879 | printk(KERN_INFO "NEW "); | ||
| 880 | print_mp_irq_info(&mp_irqs[i]); | ||
| 881 | } else if (!i) { | ||
| 882 | /* legacy, do nothing */ | ||
| 883 | } else if (nr_m_spare < SPARE_SLOT_NUM) { | ||
| 884 | /* | ||
| 885 | * not found (-1), or duplicated (-2) | ||
| 886 | * are invalid entries, | ||
| 887 | * we need to use the slot later | ||
| 888 | */ | ||
| 889 | m_spare[nr_m_spare] = m; | ||
| 890 | nr_m_spare++; | ||
| 891 | } | ||
| 892 | #endif | ||
| 893 | mpt += sizeof(struct mpc_intsrc); | ||
| 894 | count += sizeof(struct mpc_intsrc); | ||
| 895 | break; | ||
| 896 | } | ||
| 897 | case MP_LINTSRC: | 919 | case MP_LINTSRC: |
| 898 | { | 920 | skip_entry(&mpt, &count, sizeof(struct mpc_lintsrc)); |
| 899 | struct mpc_lintsrc *m = | 921 | break; |
| 900 | (struct mpc_lintsrc *)mpt; | ||
| 901 | mpt += sizeof(*m); | ||
| 902 | count += sizeof(*m); | ||
| 903 | break; | ||
| 904 | } | ||
| 905 | default: | 922 | default: |
| 906 | /* wrong mptable */ | 923 | /* wrong mptable */ |
| 907 | printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n"); | 924 | smp_dump_mptable(mpc, mpt); |
| 908 | printk(KERN_ERR "type %x\n", *mpt); | ||
| 909 | print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16, | ||
| 910 | 1, mpc, mpc->length, 1); | ||
| 911 | goto out; | 925 | goto out; |
| 912 | } | 926 | } |
| 913 | } | 927 | } |
| @@ -924,23 +938,15 @@ static int __init replace_intsrc_all(struct mpc_table *mpc, | |||
| 924 | continue; | 938 | continue; |
| 925 | 939 | ||
| 926 | if (nr_m_spare > 0) { | 940 | if (nr_m_spare > 0) { |
| 927 | printk(KERN_INFO "*NEW* found "); | 941 | apic_printk(APIC_VERBOSE, "*NEW* found\n"); |
| 928 | nr_m_spare--; | 942 | nr_m_spare--; |
| 929 | assign_to_mpc_intsrc(&mp_irqs[i], m_spare[nr_m_spare]); | 943 | assign_to_mpc_intsrc(&mp_irqs[i], m_spare[nr_m_spare]); |
| 930 | m_spare[nr_m_spare] = NULL; | 944 | m_spare[nr_m_spare] = NULL; |
| 931 | } else { | 945 | } else { |
| 932 | struct mpc_intsrc *m = (struct mpc_intsrc *)mpt; | 946 | struct mpc_intsrc *m = (struct mpc_intsrc *)mpt; |
| 933 | count += sizeof(struct mpc_intsrc); | 947 | count += sizeof(struct mpc_intsrc); |
| 934 | if (!mpc_new_phys) { | 948 | if (!check_slot(mpc_new_phys, mpc_new_length, count)) |
| 935 | printk(KERN_INFO "No spare slots, try to append...take your risk, new mpc_length %x\n", count); | 949 | goto out; |
| 936 | } else { | ||
| 937 | if (count <= mpc_new_length) | ||
| 938 | printk(KERN_INFO "No spare slots, try to append..., new mpc_length %x\n", count); | ||
| 939 | else { | ||
| 940 | printk(KERN_ERR "mpc_new_length %lx is too small\n", mpc_new_length); | ||
| 941 | goto out; | ||
| 942 | } | ||
| 943 | } | ||
| 944 | assign_to_mpc_intsrc(&mp_irqs[i], m); | 950 | assign_to_mpc_intsrc(&mp_irqs[i], m); |
| 945 | mpc->length = count; | 951 | mpc->length = count; |
| 946 | mpt += sizeof(struct mpc_intsrc); | 952 | mpt += sizeof(struct mpc_intsrc); |
diff --git a/arch/x86/kernel/paravirt.c b/arch/x86/kernel/paravirt.c index 63dd358d8ee1..8e45f4464880 100644 --- a/arch/x86/kernel/paravirt.c +++ b/arch/x86/kernel/paravirt.c | |||
| @@ -470,7 +470,6 @@ struct pv_mmu_ops pv_mmu_ops = { | |||
| 470 | #if PAGETABLE_LEVELS >= 3 | 470 | #if PAGETABLE_LEVELS >= 3 |
| 471 | #ifdef CONFIG_X86_PAE | 471 | #ifdef CONFIG_X86_PAE |
| 472 | .set_pte_atomic = native_set_pte_atomic, | 472 | .set_pte_atomic = native_set_pte_atomic, |
| 473 | .set_pte_present = native_set_pte_present, | ||
| 474 | .pte_clear = native_pte_clear, | 473 | .pte_clear = native_pte_clear, |
| 475 | .pmd_clear = native_pmd_clear, | 474 | .pmd_clear = native_pmd_clear, |
| 476 | #endif | 475 | #endif |
diff --git a/arch/x86/kernel/pci-nommu.c b/arch/x86/kernel/pci-nommu.c index c70ab5a5d4c8..8b02a3936d42 100644 --- a/arch/x86/kernel/pci-nommu.c +++ b/arch/x86/kernel/pci-nommu.c | |||
| @@ -1,14 +1,14 @@ | |||
| 1 | /* Fallback functions when the main IOMMU code is not compiled in. This | 1 | /* Fallback functions when the main IOMMU code is not compiled in. This |
| 2 | code is roughly equivalent to i386. */ | 2 | code is roughly equivalent to i386. */ |
| 3 | #include <linux/mm.h> | ||
| 4 | #include <linux/init.h> | ||
| 5 | #include <linux/pci.h> | ||
| 6 | #include <linux/string.h> | ||
| 7 | #include <linux/dma-mapping.h> | 3 | #include <linux/dma-mapping.h> |
| 8 | #include <linux/scatterlist.h> | 4 | #include <linux/scatterlist.h> |
| 5 | #include <linux/string.h> | ||
| 6 | #include <linux/init.h> | ||
| 7 | #include <linux/pci.h> | ||
| 8 | #include <linux/mm.h> | ||
| 9 | 9 | ||
| 10 | #include <asm/iommu.h> | ||
| 11 | #include <asm/processor.h> | 10 | #include <asm/processor.h> |
| 11 | #include <asm/iommu.h> | ||
| 12 | #include <asm/dma.h> | 12 | #include <asm/dma.h> |
| 13 | 13 | ||
| 14 | static int | 14 | static int |
| @@ -79,11 +79,11 @@ static void nommu_free_coherent(struct device *dev, size_t size, void *vaddr, | |||
| 79 | } | 79 | } |
| 80 | 80 | ||
| 81 | struct dma_mapping_ops nommu_dma_ops = { | 81 | struct dma_mapping_ops nommu_dma_ops = { |
| 82 | .alloc_coherent = dma_generic_alloc_coherent, | 82 | .alloc_coherent = dma_generic_alloc_coherent, |
| 83 | .free_coherent = nommu_free_coherent, | 83 | .free_coherent = nommu_free_coherent, |
| 84 | .map_single = nommu_map_single, | 84 | .map_single = nommu_map_single, |
| 85 | .map_sg = nommu_map_sg, | 85 | .map_sg = nommu_map_sg, |
| 86 | .is_phys = 1, | 86 | .is_phys = 1, |
| 87 | }; | 87 | }; |
| 88 | 88 | ||
| 89 | void __init no_iommu_init(void) | 89 | void __init no_iommu_init(void) |
diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c index 6afa5232dbb7..156f87582c6c 100644 --- a/arch/x86/kernel/process.c +++ b/arch/x86/kernel/process.c | |||
| @@ -65,11 +65,11 @@ void exit_thread(void) | |||
| 65 | { | 65 | { |
| 66 | struct task_struct *me = current; | 66 | struct task_struct *me = current; |
| 67 | struct thread_struct *t = &me->thread; | 67 | struct thread_struct *t = &me->thread; |
| 68 | unsigned long *bp = t->io_bitmap_ptr; | ||
| 68 | 69 | ||
| 69 | if (me->thread.io_bitmap_ptr) { | 70 | if (bp) { |
| 70 | struct tss_struct *tss = &per_cpu(init_tss, get_cpu()); | 71 | struct tss_struct *tss = &per_cpu(init_tss, get_cpu()); |
| 71 | 72 | ||
| 72 | kfree(t->io_bitmap_ptr); | ||
| 73 | t->io_bitmap_ptr = NULL; | 73 | t->io_bitmap_ptr = NULL; |
| 74 | clear_thread_flag(TIF_IO_BITMAP); | 74 | clear_thread_flag(TIF_IO_BITMAP); |
| 75 | /* | 75 | /* |
| @@ -78,6 +78,7 @@ void exit_thread(void) | |||
| 78 | memset(tss->io_bitmap, 0xff, t->io_bitmap_max); | 78 | memset(tss->io_bitmap, 0xff, t->io_bitmap_max); |
| 79 | t->io_bitmap_max = 0; | 79 | t->io_bitmap_max = 0; |
| 80 | put_cpu(); | 80 | put_cpu(); |
| 81 | kfree(bp); | ||
| 81 | } | 82 | } |
| 82 | 83 | ||
| 83 | ds_exit_thread(current); | 84 | ds_exit_thread(current); |
diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c index 3d9672e59c16..19378715f415 100644 --- a/arch/x86/kernel/ptrace.c +++ b/arch/x86/kernel/ptrace.c | |||
| @@ -685,9 +685,8 @@ static int ptrace_bts_config(struct task_struct *child, | |||
| 685 | if (!cfg.signal) | 685 | if (!cfg.signal) |
| 686 | return -EINVAL; | 686 | return -EINVAL; |
| 687 | 687 | ||
| 688 | return -EOPNOTSUPP; | ||
| 689 | |||
| 690 | child->thread.bts_ovfl_signal = cfg.signal; | 688 | child->thread.bts_ovfl_signal = cfg.signal; |
| 689 | return -EOPNOTSUPP; | ||
| 691 | } | 690 | } |
| 692 | 691 | ||
| 693 | if ((cfg.flags & PTRACE_BTS_O_ALLOC) && | 692 | if ((cfg.flags & PTRACE_BTS_O_ALLOC) && |
diff --git a/arch/x86/kernel/quirks.c b/arch/x86/kernel/quirks.c index 697d1b78cfbf..e95022e4f5d5 100644 --- a/arch/x86/kernel/quirks.c +++ b/arch/x86/kernel/quirks.c | |||
| @@ -74,8 +74,7 @@ static void ich_force_hpet_resume(void) | |||
| 74 | if (!force_hpet_address) | 74 | if (!force_hpet_address) |
| 75 | return; | 75 | return; |
| 76 | 76 | ||
| 77 | if (rcba_base == NULL) | 77 | BUG_ON(rcba_base == NULL); |
| 78 | BUG(); | ||
| 79 | 78 | ||
| 80 | /* read the Function Disable register, dword mode only */ | 79 | /* read the Function Disable register, dword mode only */ |
| 81 | val = readl(rcba_base + 0x3404); | 80 | val = readl(rcba_base + 0x3404); |
diff --git a/arch/x86/kernel/relocate_kernel_32.S b/arch/x86/kernel/relocate_kernel_32.S index 2064d0aa8d28..41235531b11c 100644 --- a/arch/x86/kernel/relocate_kernel_32.S +++ b/arch/x86/kernel/relocate_kernel_32.S | |||
| @@ -17,7 +17,8 @@ | |||
| 17 | 17 | ||
| 18 | #define PTR(x) (x << 2) | 18 | #define PTR(x) (x << 2) |
| 19 | 19 | ||
| 20 | /* control_page + KEXEC_CONTROL_CODE_MAX_SIZE | 20 | /* |
| 21 | * control_page + KEXEC_CONTROL_CODE_MAX_SIZE | ||
| 21 | * ~ control_page + PAGE_SIZE are used as data storage and stack for | 22 | * ~ control_page + PAGE_SIZE are used as data storage and stack for |
| 22 | * jumping back | 23 | * jumping back |
| 23 | */ | 24 | */ |
| @@ -76,8 +77,10 @@ relocate_kernel: | |||
| 76 | movl %eax, CP_PA_SWAP_PAGE(%edi) | 77 | movl %eax, CP_PA_SWAP_PAGE(%edi) |
| 77 | movl %ebx, CP_PA_BACKUP_PAGES_MAP(%edi) | 78 | movl %ebx, CP_PA_BACKUP_PAGES_MAP(%edi) |
| 78 | 79 | ||
| 79 | /* get physical address of control page now */ | 80 | /* |
| 80 | /* this is impossible after page table switch */ | 81 | * get physical address of control page now |
| 82 | * this is impossible after page table switch | ||
| 83 | */ | ||
| 81 | movl PTR(PA_CONTROL_PAGE)(%ebp), %edi | 84 | movl PTR(PA_CONTROL_PAGE)(%ebp), %edi |
| 82 | 85 | ||
| 83 | /* switch to new set of page tables */ | 86 | /* switch to new set of page tables */ |
| @@ -97,7 +100,8 @@ identity_mapped: | |||
| 97 | /* store the start address on the stack */ | 100 | /* store the start address on the stack */ |
| 98 | pushl %edx | 101 | pushl %edx |
| 99 | 102 | ||
| 100 | /* Set cr0 to a known state: | 103 | /* |
| 104 | * Set cr0 to a known state: | ||
| 101 | * - Paging disabled | 105 | * - Paging disabled |
| 102 | * - Alignment check disabled | 106 | * - Alignment check disabled |
| 103 | * - Write protect disabled | 107 | * - Write protect disabled |
| @@ -113,7 +117,8 @@ identity_mapped: | |||
| 113 | /* clear cr4 if applicable */ | 117 | /* clear cr4 if applicable */ |
| 114 | testl %ecx, %ecx | 118 | testl %ecx, %ecx |
| 115 | jz 1f | 119 | jz 1f |
| 116 | /* Set cr4 to a known state: | 120 | /* |
| 121 | * Set cr4 to a known state: | ||
| 117 | * Setting everything to zero seems safe. | 122 | * Setting everything to zero seems safe. |
| 118 | */ | 123 | */ |
| 119 | xorl %eax, %eax | 124 | xorl %eax, %eax |
| @@ -132,15 +137,18 @@ identity_mapped: | |||
| 132 | call swap_pages | 137 | call swap_pages |
| 133 | addl $8, %esp | 138 | addl $8, %esp |
| 134 | 139 | ||
| 135 | /* To be certain of avoiding problems with self-modifying code | 140 | /* |
| 141 | * To be certain of avoiding problems with self-modifying code | ||
| 136 | * I need to execute a serializing instruction here. | 142 | * I need to execute a serializing instruction here. |
| 137 | * So I flush the TLB, it's handy, and not processor dependent. | 143 | * So I flush the TLB, it's handy, and not processor dependent. |
| 138 | */ | 144 | */ |
| 139 | xorl %eax, %eax | 145 | xorl %eax, %eax |
| 140 | movl %eax, %cr3 | 146 | movl %eax, %cr3 |
| 141 | 147 | ||
| 142 | /* set all of the registers to known values */ | 148 | /* |
| 143 | /* leave %esp alone */ | 149 | * set all of the registers to known values |
| 150 | * leave %esp alone | ||
| 151 | */ | ||
| 144 | 152 | ||
| 145 | testl %esi, %esi | 153 | testl %esi, %esi |
| 146 | jnz 1f | 154 | jnz 1f |
diff --git a/arch/x86/kernel/relocate_kernel_64.S b/arch/x86/kernel/relocate_kernel_64.S index d32cfb27a479..4de8f5b3d476 100644 --- a/arch/x86/kernel/relocate_kernel_64.S +++ b/arch/x86/kernel/relocate_kernel_64.S | |||
| @@ -19,29 +19,77 @@ | |||
| 19 | #define PTR(x) (x << 3) | 19 | #define PTR(x) (x << 3) |
| 20 | #define PAGE_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY) | 20 | #define PAGE_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY) |
| 21 | 21 | ||
| 22 | /* | ||
| 23 | * control_page + KEXEC_CONTROL_CODE_MAX_SIZE | ||
| 24 | * ~ control_page + PAGE_SIZE are used as data storage and stack for | ||
| 25 | * jumping back | ||
| 26 | */ | ||
| 27 | #define DATA(offset) (KEXEC_CONTROL_CODE_MAX_SIZE+(offset)) | ||
| 28 | |||
| 29 | /* Minimal CPU state */ | ||
| 30 | #define RSP DATA(0x0) | ||
| 31 | #define CR0 DATA(0x8) | ||
| 32 | #define CR3 DATA(0x10) | ||
| 33 | #define CR4 DATA(0x18) | ||
| 34 | |||
| 35 | /* other data */ | ||
| 36 | #define CP_PA_TABLE_PAGE DATA(0x20) | ||
| 37 | #define CP_PA_SWAP_PAGE DATA(0x28) | ||
| 38 | #define CP_PA_BACKUP_PAGES_MAP DATA(0x30) | ||
| 39 | |||
| 22 | .text | 40 | .text |
| 23 | .align PAGE_SIZE | 41 | .align PAGE_SIZE |
| 24 | .code64 | 42 | .code64 |
| 25 | .globl relocate_kernel | 43 | .globl relocate_kernel |
| 26 | relocate_kernel: | 44 | relocate_kernel: |
| 27 | /* %rdi indirection_page | 45 | /* |
| 46 | * %rdi indirection_page | ||
| 28 | * %rsi page_list | 47 | * %rsi page_list |
| 29 | * %rdx start address | 48 | * %rdx start address |
| 49 | * %rcx preserve_context | ||
| 30 | */ | 50 | */ |
| 31 | 51 | ||
| 52 | /* Save the CPU context, used for jumping back */ | ||
| 53 | pushq %rbx | ||
| 54 | pushq %rbp | ||
| 55 | pushq %r12 | ||
| 56 | pushq %r13 | ||
| 57 | pushq %r14 | ||
| 58 | pushq %r15 | ||
| 59 | pushf | ||
| 60 | |||
| 61 | movq PTR(VA_CONTROL_PAGE)(%rsi), %r11 | ||
| 62 | movq %rsp, RSP(%r11) | ||
| 63 | movq %cr0, %rax | ||
| 64 | movq %rax, CR0(%r11) | ||
| 65 | movq %cr3, %rax | ||
| 66 | movq %rax, CR3(%r11) | ||
| 67 | movq %cr4, %rax | ||
| 68 | movq %rax, CR4(%r11) | ||
| 69 | |||
| 32 | /* zero out flags, and disable interrupts */ | 70 | /* zero out flags, and disable interrupts */ |
| 33 | pushq $0 | 71 | pushq $0 |
| 34 | popfq | 72 | popfq |
| 35 | 73 | ||
| 36 | /* get physical address of control page now */ | 74 | /* |
| 37 | /* this is impossible after page table switch */ | 75 | * get physical address of control page now |
| 76 | * this is impossible after page table switch | ||
| 77 | */ | ||
| 38 | movq PTR(PA_CONTROL_PAGE)(%rsi), %r8 | 78 | movq PTR(PA_CONTROL_PAGE)(%rsi), %r8 |
| 39 | 79 | ||
| 40 | /* get physical address of page table now too */ | 80 | /* get physical address of page table now too */ |
| 41 | movq PTR(PA_TABLE_PAGE)(%rsi), %rcx | 81 | movq PTR(PA_TABLE_PAGE)(%rsi), %r9 |
| 82 | |||
| 83 | /* get physical address of swap page now */ | ||
| 84 | movq PTR(PA_SWAP_PAGE)(%rsi), %r10 | ||
| 85 | |||
| 86 | /* save some information for jumping back */ | ||
| 87 | movq %r9, CP_PA_TABLE_PAGE(%r11) | ||
| 88 | movq %r10, CP_PA_SWAP_PAGE(%r11) | ||
| 89 | movq %rdi, CP_PA_BACKUP_PAGES_MAP(%r11) | ||
| 42 | 90 | ||
| 43 | /* Switch to the identity mapped page tables */ | 91 | /* Switch to the identity mapped page tables */ |
| 44 | movq %rcx, %cr3 | 92 | movq %r9, %cr3 |
| 45 | 93 | ||
| 46 | /* setup a new stack at the end of the physical control page */ | 94 | /* setup a new stack at the end of the physical control page */ |
| 47 | lea PAGE_SIZE(%r8), %rsp | 95 | lea PAGE_SIZE(%r8), %rsp |
| @@ -55,7 +103,8 @@ identity_mapped: | |||
| 55 | /* store the start address on the stack */ | 103 | /* store the start address on the stack */ |
| 56 | pushq %rdx | 104 | pushq %rdx |
| 57 | 105 | ||
| 58 | /* Set cr0 to a known state: | 106 | /* |
| 107 | * Set cr0 to a known state: | ||
| 59 | * - Paging enabled | 108 | * - Paging enabled |
| 60 | * - Alignment check disabled | 109 | * - Alignment check disabled |
| 61 | * - Write protect disabled | 110 | * - Write protect disabled |
| @@ -68,7 +117,8 @@ identity_mapped: | |||
| 68 | orl $(X86_CR0_PG | X86_CR0_PE), %eax | 117 | orl $(X86_CR0_PG | X86_CR0_PE), %eax |
| 69 | movq %rax, %cr0 | 118 | movq %rax, %cr0 |
| 70 | 119 | ||
| 71 | /* Set cr4 to a known state: | 120 | /* |
| 121 | * Set cr4 to a known state: | ||
| 72 | * - physical address extension enabled | 122 | * - physical address extension enabled |
| 73 | */ | 123 | */ |
| 74 | movq $X86_CR4_PAE, %rax | 124 | movq $X86_CR4_PAE, %rax |
| @@ -78,9 +128,87 @@ identity_mapped: | |||
| 78 | 1: | 128 | 1: |
| 79 | 129 | ||
| 80 | /* Flush the TLB (needed?) */ | 130 | /* Flush the TLB (needed?) */ |
| 81 | movq %rcx, %cr3 | 131 | movq %r9, %cr3 |
| 132 | |||
| 133 | movq %rcx, %r11 | ||
| 134 | call swap_pages | ||
| 135 | |||
| 136 | /* | ||
| 137 | * To be certain of avoiding problems with self-modifying code | ||
| 138 | * I need to execute a serializing instruction here. | ||
| 139 | * So I flush the TLB by reloading %cr3 here, it's handy, | ||
| 140 | * and not processor dependent. | ||
| 141 | */ | ||
| 142 | movq %cr3, %rax | ||
| 143 | movq %rax, %cr3 | ||
| 144 | |||
| 145 | /* | ||
| 146 | * set all of the registers to known values | ||
| 147 | * leave %rsp alone | ||
| 148 | */ | ||
| 149 | |||
| 150 | testq %r11, %r11 | ||
| 151 | jnz 1f | ||
| 152 | xorq %rax, %rax | ||
| 153 | xorq %rbx, %rbx | ||
| 154 | xorq %rcx, %rcx | ||
| 155 | xorq %rdx, %rdx | ||
| 156 | xorq %rsi, %rsi | ||
| 157 | xorq %rdi, %rdi | ||
| 158 | xorq %rbp, %rbp | ||
| 159 | xorq %r8, %r8 | ||
| 160 | xorq %r9, %r9 | ||
| 161 | xorq %r10, %r9 | ||
| 162 | xorq %r11, %r11 | ||
| 163 | xorq %r12, %r12 | ||
| 164 | xorq %r13, %r13 | ||
| 165 | xorq %r14, %r14 | ||
| 166 | xorq %r15, %r15 | ||
| 167 | |||
| 168 | ret | ||
| 169 | |||
| 170 | 1: | ||
| 171 | popq %rdx | ||
| 172 | leaq PAGE_SIZE(%r10), %rsp | ||
| 173 | call *%rdx | ||
| 174 | |||
| 175 | /* get the re-entry point of the peer system */ | ||
| 176 | movq 0(%rsp), %rbp | ||
| 177 | call 1f | ||
| 178 | 1: | ||
| 179 | popq %r8 | ||
| 180 | subq $(1b - relocate_kernel), %r8 | ||
| 181 | movq CP_PA_SWAP_PAGE(%r8), %r10 | ||
| 182 | movq CP_PA_BACKUP_PAGES_MAP(%r8), %rdi | ||
| 183 | movq CP_PA_TABLE_PAGE(%r8), %rax | ||
| 184 | movq %rax, %cr3 | ||
| 185 | lea PAGE_SIZE(%r8), %rsp | ||
| 186 | call swap_pages | ||
| 187 | movq $virtual_mapped, %rax | ||
| 188 | pushq %rax | ||
| 189 | ret | ||
| 190 | |||
| 191 | virtual_mapped: | ||
| 192 | movq RSP(%r8), %rsp | ||
| 193 | movq CR4(%r8), %rax | ||
| 194 | movq %rax, %cr4 | ||
| 195 | movq CR3(%r8), %rax | ||
| 196 | movq CR0(%r8), %r8 | ||
| 197 | movq %rax, %cr3 | ||
| 198 | movq %r8, %cr0 | ||
| 199 | movq %rbp, %rax | ||
| 200 | |||
| 201 | popf | ||
| 202 | popq %r15 | ||
| 203 | popq %r14 | ||
| 204 | popq %r13 | ||
| 205 | popq %r12 | ||
| 206 | popq %rbp | ||
| 207 | popq %rbx | ||
| 208 | ret | ||
| 82 | 209 | ||
| 83 | /* Do the copies */ | 210 | /* Do the copies */ |
| 211 | swap_pages: | ||
| 84 | movq %rdi, %rcx /* Put the page_list in %rcx */ | 212 | movq %rdi, %rcx /* Put the page_list in %rcx */ |
| 85 | xorq %rdi, %rdi | 213 | xorq %rdi, %rdi |
| 86 | xorq %rsi, %rsi | 214 | xorq %rsi, %rsi |
| @@ -112,36 +240,27 @@ identity_mapped: | |||
| 112 | movq %rcx, %rsi /* For ever source page do a copy */ | 240 | movq %rcx, %rsi /* For ever source page do a copy */ |
| 113 | andq $0xfffffffffffff000, %rsi | 241 | andq $0xfffffffffffff000, %rsi |
| 114 | 242 | ||
| 243 | movq %rdi, %rdx | ||
| 244 | movq %rsi, %rax | ||
| 245 | |||
| 246 | movq %r10, %rdi | ||
| 115 | movq $512, %rcx | 247 | movq $512, %rcx |
| 116 | rep ; movsq | 248 | rep ; movsq |
| 117 | jmp 0b | ||
| 118 | 3: | ||
| 119 | |||
| 120 | /* To be certain of avoiding problems with self-modifying code | ||
| 121 | * I need to execute a serializing instruction here. | ||
| 122 | * So I flush the TLB by reloading %cr3 here, it's handy, | ||
| 123 | * and not processor dependent. | ||
| 124 | */ | ||
| 125 | movq %cr3, %rax | ||
| 126 | movq %rax, %cr3 | ||
| 127 | 249 | ||
| 128 | /* set all of the registers to known values */ | 250 | movq %rax, %rdi |
| 129 | /* leave %rsp alone */ | 251 | movq %rdx, %rsi |
| 252 | movq $512, %rcx | ||
| 253 | rep ; movsq | ||
| 130 | 254 | ||
| 131 | xorq %rax, %rax | 255 | movq %rdx, %rdi |
| 132 | xorq %rbx, %rbx | 256 | movq %r10, %rsi |
| 133 | xorq %rcx, %rcx | 257 | movq $512, %rcx |
| 134 | xorq %rdx, %rdx | 258 | rep ; movsq |
| 135 | xorq %rsi, %rsi | ||
| 136 | xorq %rdi, %rdi | ||
| 137 | xorq %rbp, %rbp | ||
| 138 | xorq %r8, %r8 | ||
| 139 | xorq %r9, %r9 | ||
| 140 | xorq %r10, %r9 | ||
| 141 | xorq %r11, %r11 | ||
| 142 | xorq %r12, %r12 | ||
| 143 | xorq %r13, %r13 | ||
| 144 | xorq %r14, %r14 | ||
| 145 | xorq %r15, %r15 | ||
| 146 | 259 | ||
| 260 | lea PAGE_SIZE(%rax), %rsi | ||
| 261 | jmp 0b | ||
| 262 | 3: | ||
| 147 | ret | 263 | ret |
| 264 | |||
| 265 | .globl kexec_control_code_size | ||
| 266 | .set kexec_control_code_size, . - relocate_kernel | ||
diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c index dd6f2b71561b..5d465b207e72 100644 --- a/arch/x86/kernel/rtc.c +++ b/arch/x86/kernel/rtc.c | |||
| @@ -1,14 +1,14 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * RTC related functions | 2 | * RTC related functions |
| 3 | */ | 3 | */ |
| 4 | #include <linux/platform_device.h> | ||
| 5 | #include <linux/mc146818rtc.h> | ||
| 4 | #include <linux/acpi.h> | 6 | #include <linux/acpi.h> |
| 5 | #include <linux/bcd.h> | 7 | #include <linux/bcd.h> |
| 6 | #include <linux/mc146818rtc.h> | ||
| 7 | #include <linux/platform_device.h> | ||
| 8 | #include <linux/pnp.h> | 8 | #include <linux/pnp.h> |
| 9 | 9 | ||
| 10 | #include <asm/time.h> | ||
| 11 | #include <asm/vsyscall.h> | 10 | #include <asm/vsyscall.h> |
| 11 | #include <asm/time.h> | ||
| 12 | 12 | ||
| 13 | #ifdef CONFIG_X86_32 | 13 | #ifdef CONFIG_X86_32 |
| 14 | /* | 14 | /* |
| @@ -16,9 +16,9 @@ | |||
| 16 | * register we are working with. It is required for NMI access to the | 16 | * register we are working with. It is required for NMI access to the |
| 17 | * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details. | 17 | * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details. |
| 18 | */ | 18 | */ |
| 19 | volatile unsigned long cmos_lock = 0; | 19 | volatile unsigned long cmos_lock; |
| 20 | EXPORT_SYMBOL(cmos_lock); | 20 | EXPORT_SYMBOL(cmos_lock); |
| 21 | #endif | 21 | #endif /* CONFIG_X86_32 */ |
| 22 | 22 | ||
| 23 | /* For two digit years assume time is always after that */ | 23 | /* For two digit years assume time is always after that */ |
| 24 | #define CMOS_YEARS_OFFS 2000 | 24 | #define CMOS_YEARS_OFFS 2000 |
| @@ -38,9 +38,9 @@ EXPORT_SYMBOL(rtc_lock); | |||
| 38 | */ | 38 | */ |
| 39 | int mach_set_rtc_mmss(unsigned long nowtime) | 39 | int mach_set_rtc_mmss(unsigned long nowtime) |
| 40 | { | 40 | { |
| 41 | int retval = 0; | ||
| 42 | int real_seconds, real_minutes, cmos_minutes; | 41 | int real_seconds, real_minutes, cmos_minutes; |
| 43 | unsigned char save_control, save_freq_select; | 42 | unsigned char save_control, save_freq_select; |
| 43 | int retval = 0; | ||
| 44 | 44 | ||
| 45 | /* tell the clock it's being set */ | 45 | /* tell the clock it's being set */ |
| 46 | save_control = CMOS_READ(RTC_CONTROL); | 46 | save_control = CMOS_READ(RTC_CONTROL); |
| @@ -72,8 +72,8 @@ int mach_set_rtc_mmss(unsigned long nowtime) | |||
| 72 | real_seconds = bin2bcd(real_seconds); | 72 | real_seconds = bin2bcd(real_seconds); |
| 73 | real_minutes = bin2bcd(real_minutes); | 73 | real_minutes = bin2bcd(real_minutes); |
| 74 | } | 74 | } |
| 75 | CMOS_WRITE(real_seconds,RTC_SECONDS); | 75 | CMOS_WRITE(real_seconds, RTC_SECONDS); |
| 76 | CMOS_WRITE(real_minutes,RTC_MINUTES); | 76 | CMOS_WRITE(real_minutes, RTC_MINUTES); |
| 77 | } else { | 77 | } else { |
| 78 | printk(KERN_WARNING | 78 | printk(KERN_WARNING |
| 79 | "set_rtc_mmss: can't update from %d to %d\n", | 79 | "set_rtc_mmss: can't update from %d to %d\n", |
| @@ -151,6 +151,7 @@ unsigned char rtc_cmos_read(unsigned char addr) | |||
| 151 | outb(addr, RTC_PORT(0)); | 151 | outb(addr, RTC_PORT(0)); |
| 152 | val = inb(RTC_PORT(1)); | 152 | val = inb(RTC_PORT(1)); |
| 153 | lock_cmos_suffix(addr); | 153 | lock_cmos_suffix(addr); |
| 154 | |||
| 154 | return val; | 155 | return val; |
| 155 | } | 156 | } |
| 156 | EXPORT_SYMBOL(rtc_cmos_read); | 157 | EXPORT_SYMBOL(rtc_cmos_read); |
| @@ -166,8 +167,8 @@ EXPORT_SYMBOL(rtc_cmos_write); | |||
| 166 | 167 | ||
| 167 | static int set_rtc_mmss(unsigned long nowtime) | 168 | static int set_rtc_mmss(unsigned long nowtime) |
| 168 | { | 169 | { |
| 169 | int retval; | ||
| 170 | unsigned long flags; | 170 | unsigned long flags; |
| 171 | int retval; | ||
| 171 | 172 | ||
| 172 | spin_lock_irqsave(&rtc_lock, flags); | 173 | spin_lock_irqsave(&rtc_lock, flags); |
| 173 | retval = set_wallclock(nowtime); | 174 | retval = set_wallclock(nowtime); |
| @@ -242,6 +243,7 @@ static __init int add_rtc_cmos(void) | |||
| 242 | platform_device_register(&rtc_device); | 243 | platform_device_register(&rtc_device); |
| 243 | dev_info(&rtc_device.dev, | 244 | dev_info(&rtc_device.dev, |
| 244 | "registered platform RTC device (no PNP device found)\n"); | 245 | "registered platform RTC device (no PNP device found)\n"); |
| 246 | |||
| 245 | return 0; | 247 | return 0; |
| 246 | } | 248 | } |
| 247 | device_initcall(add_rtc_cmos); | 249 | device_initcall(add_rtc_cmos); |
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c index b746deb9ebc6..a0d26237d7cf 100644 --- a/arch/x86/kernel/setup.c +++ b/arch/x86/kernel/setup.c | |||
| @@ -112,8 +112,13 @@ | |||
| 112 | #define ARCH_SETUP | 112 | #define ARCH_SETUP |
| 113 | #endif | 113 | #endif |
| 114 | 114 | ||
| 115 | RESERVE_BRK(dmi_alloc, 65536); | ||
| 116 | |||
| 115 | unsigned int boot_cpu_id __read_mostly; | 117 | unsigned int boot_cpu_id __read_mostly; |
| 116 | 118 | ||
| 119 | static __initdata unsigned long _brk_start = (unsigned long)__brk_base; | ||
| 120 | unsigned long _brk_end = (unsigned long)__brk_base; | ||
| 121 | |||
| 117 | #ifdef CONFIG_X86_64 | 122 | #ifdef CONFIG_X86_64 |
| 118 | int default_cpu_present_to_apicid(int mps_cpu) | 123 | int default_cpu_present_to_apicid(int mps_cpu) |
| 119 | { | 124 | { |
| @@ -158,12 +163,6 @@ static struct resource bss_resource = { | |||
| 158 | 163 | ||
| 159 | 164 | ||
| 160 | #ifdef CONFIG_X86_32 | 165 | #ifdef CONFIG_X86_32 |
| 161 | /* This value is set up by the early boot code to point to the value | ||
| 162 | immediately after the boot time page tables. It contains a *physical* | ||
| 163 | address, and must not be in the .bss segment! */ | ||
| 164 | unsigned long init_pg_tables_start __initdata = ~0UL; | ||
| 165 | unsigned long init_pg_tables_end __initdata = ~0UL; | ||
| 166 | |||
| 167 | static struct resource video_ram_resource = { | 166 | static struct resource video_ram_resource = { |
| 168 | .name = "Video RAM area", | 167 | .name = "Video RAM area", |
| 169 | .start = 0xa0000, | 168 | .start = 0xa0000, |
| @@ -202,7 +201,9 @@ struct ist_info ist_info; | |||
| 202 | #endif | 201 | #endif |
| 203 | 202 | ||
| 204 | #else | 203 | #else |
| 205 | struct cpuinfo_x86 boot_cpu_data __read_mostly; | 204 | struct cpuinfo_x86 boot_cpu_data __read_mostly = { |
| 205 | .x86_phys_bits = MAX_PHYSMEM_BITS, | ||
| 206 | }; | ||
| 206 | EXPORT_SYMBOL(boot_cpu_data); | 207 | EXPORT_SYMBOL(boot_cpu_data); |
| 207 | #endif | 208 | #endif |
| 208 | 209 | ||
| @@ -217,12 +218,6 @@ unsigned long mmu_cr4_features = X86_CR4_PAE; | |||
| 217 | int bootloader_type; | 218 | int bootloader_type; |
| 218 | 219 | ||
| 219 | /* | 220 | /* |
| 220 | * Early DMI memory | ||
| 221 | */ | ||
| 222 | int dmi_alloc_index; | ||
| 223 | char dmi_alloc_data[DMI_MAX_DATA]; | ||
| 224 | |||
| 225 | /* | ||
| 226 | * Setup options | 221 | * Setup options |
| 227 | */ | 222 | */ |
| 228 | struct screen_info screen_info; | 223 | struct screen_info screen_info; |
| @@ -267,6 +262,35 @@ static inline void copy_edd(void) | |||
| 267 | } | 262 | } |
| 268 | #endif | 263 | #endif |
| 269 | 264 | ||
| 265 | void * __init extend_brk(size_t size, size_t align) | ||
| 266 | { | ||
| 267 | size_t mask = align - 1; | ||
| 268 | void *ret; | ||
| 269 | |||
| 270 | BUG_ON(_brk_start == 0); | ||
| 271 | BUG_ON(align & mask); | ||
| 272 | |||
| 273 | _brk_end = (_brk_end + mask) & ~mask; | ||
| 274 | BUG_ON((char *)(_brk_end + size) > __brk_limit); | ||
| 275 | |||
| 276 | ret = (void *)_brk_end; | ||
| 277 | _brk_end += size; | ||
| 278 | |||
| 279 | memset(ret, 0, size); | ||
| 280 | |||
| 281 | return ret; | ||
| 282 | } | ||
| 283 | |||
| 284 | static void __init reserve_brk(void) | ||
| 285 | { | ||
| 286 | if (_brk_end > _brk_start) | ||
| 287 | reserve_early(__pa(_brk_start), __pa(_brk_end), "BRK"); | ||
| 288 | |||
| 289 | /* Mark brk area as locked down and no longer taking any | ||
| 290 | new allocations */ | ||
| 291 | _brk_start = 0; | ||
| 292 | } | ||
| 293 | |||
| 270 | #ifdef CONFIG_BLK_DEV_INITRD | 294 | #ifdef CONFIG_BLK_DEV_INITRD |
| 271 | 295 | ||
| 272 | #ifdef CONFIG_X86_32 | 296 | #ifdef CONFIG_X86_32 |
| @@ -715,11 +739,7 @@ void __init setup_arch(char **cmdline_p) | |||
| 715 | init_mm.start_code = (unsigned long) _text; | 739 | init_mm.start_code = (unsigned long) _text; |
| 716 | init_mm.end_code = (unsigned long) _etext; | 740 | init_mm.end_code = (unsigned long) _etext; |
| 717 | init_mm.end_data = (unsigned long) _edata; | 741 | init_mm.end_data = (unsigned long) _edata; |
| 718 | #ifdef CONFIG_X86_32 | 742 | init_mm.brk = _brk_end; |
| 719 | init_mm.brk = init_pg_tables_end + PAGE_OFFSET; | ||
| 720 | #else | ||
| 721 | init_mm.brk = (unsigned long) &_end; | ||
| 722 | #endif | ||
| 723 | 743 | ||
| 724 | code_resource.start = virt_to_phys(_text); | 744 | code_resource.start = virt_to_phys(_text); |
| 725 | code_resource.end = virt_to_phys(_etext)-1; | 745 | code_resource.end = virt_to_phys(_etext)-1; |
| @@ -840,6 +860,8 @@ void __init setup_arch(char **cmdline_p) | |||
| 840 | setup_bios_corruption_check(); | 860 | setup_bios_corruption_check(); |
| 841 | #endif | 861 | #endif |
| 842 | 862 | ||
| 863 | reserve_brk(); | ||
| 864 | |||
| 843 | /* max_pfn_mapped is updated here */ | 865 | /* max_pfn_mapped is updated here */ |
| 844 | max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT); | 866 | max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT); |
| 845 | max_pfn_mapped = max_low_pfn_mapped; | 867 | max_pfn_mapped = max_low_pfn_mapped; |
diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c index d2cc6428c587..dfcc74ab0ab6 100644 --- a/arch/x86/kernel/signal.c +++ b/arch/x86/kernel/signal.c | |||
| @@ -211,31 +211,27 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, | |||
| 211 | { | 211 | { |
| 212 | /* Default to using normal stack */ | 212 | /* Default to using normal stack */ |
| 213 | unsigned long sp = regs->sp; | 213 | unsigned long sp = regs->sp; |
| 214 | int onsigstack = on_sig_stack(sp); | ||
| 214 | 215 | ||
| 215 | #ifdef CONFIG_X86_64 | 216 | #ifdef CONFIG_X86_64 |
| 216 | /* redzone */ | 217 | /* redzone */ |
| 217 | sp -= 128; | 218 | sp -= 128; |
| 218 | #endif /* CONFIG_X86_64 */ | 219 | #endif /* CONFIG_X86_64 */ |
| 219 | 220 | ||
| 220 | /* | 221 | if (!onsigstack) { |
| 221 | * If we are on the alternate signal stack and would overflow it, don't. | 222 | /* This is the X/Open sanctioned signal stack switching. */ |
| 222 | * Return an always-bogus address instead so we will die with SIGSEGV. | 223 | if (ka->sa.sa_flags & SA_ONSTACK) { |
| 223 | */ | 224 | if (sas_ss_flags(sp) == 0) |
| 224 | if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) | 225 | sp = current->sas_ss_sp + current->sas_ss_size; |
| 225 | return (void __user *) -1L; | 226 | } else { |
| 226 | |||
| 227 | /* This is the X/Open sanctioned signal stack switching. */ | ||
| 228 | if (ka->sa.sa_flags & SA_ONSTACK) { | ||
| 229 | if (sas_ss_flags(sp) == 0) | ||
| 230 | sp = current->sas_ss_sp + current->sas_ss_size; | ||
| 231 | } else { | ||
| 232 | #ifdef CONFIG_X86_32 | 227 | #ifdef CONFIG_X86_32 |
| 233 | /* This is the legacy signal stack switching. */ | 228 | /* This is the legacy signal stack switching. */ |
| 234 | if ((regs->ss & 0xffff) != __USER_DS && | 229 | if ((regs->ss & 0xffff) != __USER_DS && |
| 235 | !(ka->sa.sa_flags & SA_RESTORER) && | 230 | !(ka->sa.sa_flags & SA_RESTORER) && |
| 236 | ka->sa.sa_restorer) | 231 | ka->sa.sa_restorer) |
| 237 | sp = (unsigned long) ka->sa.sa_restorer; | 232 | sp = (unsigned long) ka->sa.sa_restorer; |
| 238 | #endif /* CONFIG_X86_32 */ | 233 | #endif /* CONFIG_X86_32 */ |
| 234 | } | ||
| 239 | } | 235 | } |
| 240 | 236 | ||
| 241 | if (used_math()) { | 237 | if (used_math()) { |
| @@ -244,12 +240,22 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, | |||
| 244 | sp = round_down(sp, 64); | 240 | sp = round_down(sp, 64); |
| 245 | #endif /* CONFIG_X86_64 */ | 241 | #endif /* CONFIG_X86_64 */ |
| 246 | *fpstate = (void __user *)sp; | 242 | *fpstate = (void __user *)sp; |
| 247 | |||
| 248 | if (save_i387_xstate(*fpstate) < 0) | ||
| 249 | return (void __user *)-1L; | ||
| 250 | } | 243 | } |
| 251 | 244 | ||
| 252 | return (void __user *)align_sigframe(sp - frame_size); | 245 | sp = align_sigframe(sp - frame_size); |
| 246 | |||
| 247 | /* | ||
| 248 | * If we are on the alternate signal stack and would overflow it, don't. | ||
| 249 | * Return an always-bogus address instead so we will die with SIGSEGV. | ||
| 250 | */ | ||
| 251 | if (onsigstack && !likely(on_sig_stack(sp))) | ||
| 252 | return (void __user *)-1L; | ||
| 253 | |||
| 254 | /* save i387 state */ | ||
| 255 | if (used_math() && save_i387_xstate(*fpstate) < 0) | ||
| 256 | return (void __user *)-1L; | ||
| 257 | |||
| 258 | return (void __user *)sp; | ||
| 253 | } | 259 | } |
| 254 | 260 | ||
| 255 | #ifdef CONFIG_X86_32 | 261 | #ifdef CONFIG_X86_32 |
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c index 249334f5080a..ef7d10170c30 100644 --- a/arch/x86/kernel/smpboot.c +++ b/arch/x86/kernel/smpboot.c | |||
| @@ -114,10 +114,6 @@ EXPORT_PER_CPU_SYMBOL(cpu_info); | |||
| 114 | 114 | ||
| 115 | atomic_t init_deasserted; | 115 | atomic_t init_deasserted; |
| 116 | 116 | ||
| 117 | |||
| 118 | /* Set if we find a B stepping CPU */ | ||
| 119 | static int __cpuinitdata smp_b_stepping; | ||
| 120 | |||
| 121 | #if defined(CONFIG_NUMA) && defined(CONFIG_X86_32) | 117 | #if defined(CONFIG_NUMA) && defined(CONFIG_X86_32) |
| 122 | 118 | ||
| 123 | /* which logical CPUs are on which nodes */ | 119 | /* which logical CPUs are on which nodes */ |
| @@ -271,8 +267,6 @@ static void __cpuinit smp_callin(void) | |||
| 271 | cpumask_set_cpu(cpuid, cpu_callin_mask); | 267 | cpumask_set_cpu(cpuid, cpu_callin_mask); |
| 272 | } | 268 | } |
| 273 | 269 | ||
| 274 | static int __cpuinitdata unsafe_smp; | ||
| 275 | |||
| 276 | /* | 270 | /* |
| 277 | * Activate a secondary processor. | 271 | * Activate a secondary processor. |
| 278 | */ | 272 | */ |
| @@ -340,76 +334,6 @@ notrace static void __cpuinit start_secondary(void *unused) | |||
| 340 | cpu_idle(); | 334 | cpu_idle(); |
| 341 | } | 335 | } |
| 342 | 336 | ||
| 343 | static void __cpuinit smp_apply_quirks(struct cpuinfo_x86 *c) | ||
| 344 | { | ||
| 345 | /* | ||
| 346 | * Mask B, Pentium, but not Pentium MMX | ||
| 347 | */ | ||
| 348 | if (c->x86_vendor == X86_VENDOR_INTEL && | ||
| 349 | c->x86 == 5 && | ||
| 350 | c->x86_mask >= 1 && c->x86_mask <= 4 && | ||
| 351 | c->x86_model <= 3) | ||
| 352 | /* | ||
| 353 | * Remember we have B step Pentia with bugs | ||
| 354 | */ | ||
| 355 | smp_b_stepping = 1; | ||
| 356 | |||
| 357 | /* | ||
| 358 | * Certain Athlons might work (for various values of 'work') in SMP | ||
| 359 | * but they are not certified as MP capable. | ||
| 360 | */ | ||
| 361 | if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) { | ||
| 362 | |||
| 363 | if (num_possible_cpus() == 1) | ||
| 364 | goto valid_k7; | ||
| 365 | |||
| 366 | /* Athlon 660/661 is valid. */ | ||
| 367 | if ((c->x86_model == 6) && ((c->x86_mask == 0) || | ||
| 368 | (c->x86_mask == 1))) | ||
| 369 | goto valid_k7; | ||
| 370 | |||
| 371 | /* Duron 670 is valid */ | ||
| 372 | if ((c->x86_model == 7) && (c->x86_mask == 0)) | ||
| 373 | goto valid_k7; | ||
| 374 | |||
| 375 | /* | ||
| 376 | * Athlon 662, Duron 671, and Athlon >model 7 have capability | ||
| 377 | * bit. It's worth noting that the A5 stepping (662) of some | ||
| 378 | * Athlon XP's have the MP bit set. | ||
| 379 | * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for | ||
| 380 | * more. | ||
| 381 | */ | ||
| 382 | if (((c->x86_model == 6) && (c->x86_mask >= 2)) || | ||
| 383 | ((c->x86_model == 7) && (c->x86_mask >= 1)) || | ||
| 384 | (c->x86_model > 7)) | ||
| 385 | if (cpu_has_mp) | ||
| 386 | goto valid_k7; | ||
| 387 | |||
| 388 | /* If we get here, not a certified SMP capable AMD system. */ | ||
| 389 | unsafe_smp = 1; | ||
| 390 | } | ||
| 391 | |||
| 392 | valid_k7: | ||
| 393 | ; | ||
| 394 | } | ||
| 395 | |||
| 396 | static void __cpuinit smp_checks(void) | ||
| 397 | { | ||
| 398 | if (smp_b_stepping) | ||
| 399 | printk(KERN_WARNING "WARNING: SMP operation may be unreliable" | ||
| 400 | "with B stepping processors.\n"); | ||
| 401 | |||
| 402 | /* | ||
| 403 | * Don't taint if we are running SMP kernel on a single non-MP | ||
| 404 | * approved Athlon | ||
| 405 | */ | ||
| 406 | if (unsafe_smp && num_online_cpus() > 1) { | ||
| 407 | printk(KERN_INFO "WARNING: This combination of AMD" | ||
| 408 | "processors is not suitable for SMP.\n"); | ||
| 409 | add_taint(TAINT_UNSAFE_SMP); | ||
| 410 | } | ||
| 411 | } | ||
| 412 | |||
| 413 | /* | 337 | /* |
| 414 | * The bootstrap kernel entry code has set these up. Save them for | 338 | * The bootstrap kernel entry code has set these up. Save them for |
| 415 | * a given CPU | 339 | * a given CPU |
| @@ -423,7 +347,6 @@ void __cpuinit smp_store_cpu_info(int id) | |||
| 423 | c->cpu_index = id; | 347 | c->cpu_index = id; |
| 424 | if (id != 0) | 348 | if (id != 0) |
| 425 | identify_secondary_cpu(c); | 349 | identify_secondary_cpu(c); |
| 426 | smp_apply_quirks(c); | ||
| 427 | } | 350 | } |
| 428 | 351 | ||
| 429 | 352 | ||
| @@ -1193,7 +1116,6 @@ void __init native_smp_cpus_done(unsigned int max_cpus) | |||
| 1193 | pr_debug("Boot done.\n"); | 1116 | pr_debug("Boot done.\n"); |
| 1194 | 1117 | ||
| 1195 | impress_friends(); | 1118 | impress_friends(); |
| 1196 | smp_checks(); | ||
| 1197 | #ifdef CONFIG_X86_IO_APIC | 1119 | #ifdef CONFIG_X86_IO_APIC |
| 1198 | setup_ioapic_dest(); | 1120 | setup_ioapic_dest(); |
| 1199 | #endif | 1121 | #endif |
diff --git a/arch/x86/kernel/tlb_uv.c b/arch/x86/kernel/tlb_uv.c index d038b9c45cf8..79c073247284 100644 --- a/arch/x86/kernel/tlb_uv.c +++ b/arch/x86/kernel/tlb_uv.c | |||
| @@ -750,7 +750,7 @@ static int __init uv_bau_init(void) | |||
| 750 | int node; | 750 | int node; |
| 751 | int nblades; | 751 | int nblades; |
| 752 | int last_blade; | 752 | int last_blade; |
| 753 | int cur_cpu = 0; | 753 | int cur_cpu; |
| 754 | 754 | ||
| 755 | if (!is_uv_system()) | 755 | if (!is_uv_system()) |
| 756 | return 0; | 756 | return 0; |
| @@ -760,6 +760,7 @@ static int __init uv_bau_init(void) | |||
| 760 | uv_mmask = (1UL << uv_hub_info->n_val) - 1; | 760 | uv_mmask = (1UL << uv_hub_info->n_val) - 1; |
| 761 | nblades = 0; | 761 | nblades = 0; |
| 762 | last_blade = -1; | 762 | last_blade = -1; |
| 763 | cur_cpu = 0; | ||
| 763 | for_each_online_node(node) { | 764 | for_each_online_node(node) { |
| 764 | blade = uv_node_to_blade_id(node); | 765 | blade = uv_node_to_blade_id(node); |
| 765 | if (blade == last_blade) | 766 | if (blade == last_blade) |
diff --git a/arch/x86/kernel/topology.c b/arch/x86/kernel/topology.c index 0fcc95a354f7..7e4515957a1c 100644 --- a/arch/x86/kernel/topology.c +++ b/arch/x86/kernel/topology.c | |||
| @@ -25,10 +25,10 @@ | |||
| 25 | * | 25 | * |
| 26 | * Send feedback to <colpatch@us.ibm.com> | 26 | * Send feedback to <colpatch@us.ibm.com> |
| 27 | */ | 27 | */ |
| 28 | #include <linux/init.h> | ||
| 29 | #include <linux/smp.h> | ||
| 30 | #include <linux/nodemask.h> | 28 | #include <linux/nodemask.h> |
| 31 | #include <linux/mmzone.h> | 29 | #include <linux/mmzone.h> |
| 30 | #include <linux/init.h> | ||
| 31 | #include <linux/smp.h> | ||
| 32 | #include <asm/cpu.h> | 32 | #include <asm/cpu.h> |
| 33 | 33 | ||
| 34 | static DEFINE_PER_CPU(struct x86_cpu, cpu_devices); | 34 | static DEFINE_PER_CPU(struct x86_cpu, cpu_devices); |
| @@ -47,6 +47,7 @@ int __ref arch_register_cpu(int num) | |||
| 47 | */ | 47 | */ |
| 48 | if (num) | 48 | if (num) |
| 49 | per_cpu(cpu_devices, num).cpu.hotpluggable = 1; | 49 | per_cpu(cpu_devices, num).cpu.hotpluggable = 1; |
| 50 | |||
| 50 | return register_cpu(&per_cpu(cpu_devices, num).cpu, num); | 51 | return register_cpu(&per_cpu(cpu_devices, num).cpu, num); |
| 51 | } | 52 | } |
| 52 | EXPORT_SYMBOL(arch_register_cpu); | 53 | EXPORT_SYMBOL(arch_register_cpu); |
| @@ -56,12 +57,13 @@ void arch_unregister_cpu(int num) | |||
| 56 | unregister_cpu(&per_cpu(cpu_devices, num).cpu); | 57 | unregister_cpu(&per_cpu(cpu_devices, num).cpu); |
| 57 | } | 58 | } |
| 58 | EXPORT_SYMBOL(arch_unregister_cpu); | 59 | EXPORT_SYMBOL(arch_unregister_cpu); |
| 59 | #else | 60 | #else /* CONFIG_HOTPLUG_CPU */ |
| 61 | |||
| 60 | static int __init arch_register_cpu(int num) | 62 | static int __init arch_register_cpu(int num) |
| 61 | { | 63 | { |
| 62 | return register_cpu(&per_cpu(cpu_devices, num).cpu, num); | 64 | return register_cpu(&per_cpu(cpu_devices, num).cpu, num); |
| 63 | } | 65 | } |
| 64 | #endif /*CONFIG_HOTPLUG_CPU*/ | 66 | #endif /* CONFIG_HOTPLUG_CPU */ |
| 65 | 67 | ||
| 66 | static int __init topology_init(void) | 68 | static int __init topology_init(void) |
| 67 | { | 69 | { |
| @@ -70,11 +72,11 @@ static int __init topology_init(void) | |||
| 70 | #ifdef CONFIG_NUMA | 72 | #ifdef CONFIG_NUMA |
| 71 | for_each_online_node(i) | 73 | for_each_online_node(i) |
| 72 | register_one_node(i); | 74 | register_one_node(i); |
| 73 | #endif /* CONFIG_NUMA */ | 75 | #endif |
| 74 | 76 | ||
| 75 | for_each_present_cpu(i) | 77 | for_each_present_cpu(i) |
| 76 | arch_register_cpu(i); | 78 | arch_register_cpu(i); |
| 79 | |||
| 77 | return 0; | 80 | return 0; |
| 78 | } | 81 | } |
| 79 | |||
| 80 | subsys_initcall(topology_init); | 82 | subsys_initcall(topology_init); |
diff --git a/arch/x86/kernel/uv_time.c b/arch/x86/kernel/uv_time.c new file mode 100644 index 000000000000..2ffb6c53326e --- /dev/null +++ b/arch/x86/kernel/uv_time.c | |||
| @@ -0,0 +1,393 @@ | |||
| 1 | /* | ||
| 2 | * SGI RTC clock/timer routines. | ||
| 3 | * | ||
| 4 | * This program is free software; you can redistribute it and/or modify | ||
| 5 | * it under the terms of the GNU General Public License as published by | ||
| 6 | * the Free Software Foundation; either version 2 of the License, or | ||
| 7 | * (at your option) any later version. | ||
| 8 | * | ||
| 9 | * This program is distributed in the hope that it will be useful, | ||
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 12 | * GNU General Public License for more details. | ||
| 13 | * | ||
| 14 | * You should have received a copy of the GNU General Public License | ||
| 15 | * along with this program; if not, write to the Free Software | ||
| 16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
| 17 | * | ||
| 18 | * Copyright (c) 2009 Silicon Graphics, Inc. All Rights Reserved. | ||
| 19 | * Copyright (c) Dimitri Sivanich | ||
| 20 | */ | ||
| 21 | #include <linux/clockchips.h> | ||
| 22 | |||
| 23 | #include <asm/uv/uv_mmrs.h> | ||
| 24 | #include <asm/uv/uv_hub.h> | ||
| 25 | #include <asm/uv/bios.h> | ||
| 26 | #include <asm/uv/uv.h> | ||
| 27 | #include <asm/apic.h> | ||
| 28 | #include <asm/cpu.h> | ||
| 29 | |||
| 30 | #define RTC_NAME "sgi_rtc" | ||
| 31 | |||
| 32 | static cycle_t uv_read_rtc(void); | ||
| 33 | static int uv_rtc_next_event(unsigned long, struct clock_event_device *); | ||
| 34 | static void uv_rtc_timer_setup(enum clock_event_mode, | ||
| 35 | struct clock_event_device *); | ||
| 36 | |||
| 37 | static struct clocksource clocksource_uv = { | ||
| 38 | .name = RTC_NAME, | ||
| 39 | .rating = 400, | ||
| 40 | .read = uv_read_rtc, | ||
| 41 | .mask = (cycle_t)UVH_RTC_REAL_TIME_CLOCK_MASK, | ||
| 42 | .shift = 10, | ||
| 43 | .flags = CLOCK_SOURCE_IS_CONTINUOUS, | ||
| 44 | }; | ||
| 45 | |||
| 46 | static struct clock_event_device clock_event_device_uv = { | ||
| 47 | .name = RTC_NAME, | ||
| 48 | .features = CLOCK_EVT_FEAT_ONESHOT, | ||
| 49 | .shift = 20, | ||
| 50 | .rating = 400, | ||
| 51 | .irq = -1, | ||
| 52 | .set_next_event = uv_rtc_next_event, | ||
| 53 | .set_mode = uv_rtc_timer_setup, | ||
| 54 | .event_handler = NULL, | ||
| 55 | }; | ||
| 56 | |||
| 57 | static DEFINE_PER_CPU(struct clock_event_device, cpu_ced); | ||
| 58 | |||
| 59 | /* There is one of these allocated per node */ | ||
| 60 | struct uv_rtc_timer_head { | ||
| 61 | spinlock_t lock; | ||
| 62 | /* next cpu waiting for timer, local node relative: */ | ||
| 63 | int next_cpu; | ||
| 64 | /* number of cpus on this node: */ | ||
| 65 | int ncpus; | ||
| 66 | struct { | ||
| 67 | int lcpu; /* systemwide logical cpu number */ | ||
| 68 | u64 expires; /* next timer expiration for this cpu */ | ||
| 69 | } cpu[1]; | ||
| 70 | }; | ||
| 71 | |||
| 72 | /* | ||
| 73 | * Access to uv_rtc_timer_head via blade id. | ||
| 74 | */ | ||
| 75 | static struct uv_rtc_timer_head **blade_info __read_mostly; | ||
| 76 | |||
| 77 | static int uv_rtc_enable; | ||
| 78 | |||
| 79 | /* | ||
| 80 | * Hardware interface routines | ||
| 81 | */ | ||
| 82 | |||
| 83 | /* Send IPIs to another node */ | ||
| 84 | static void uv_rtc_send_IPI(int cpu) | ||
| 85 | { | ||
| 86 | unsigned long apicid, val; | ||
| 87 | int pnode; | ||
| 88 | |||
| 89 | apicid = cpu_physical_id(cpu); | ||
| 90 | pnode = uv_apicid_to_pnode(apicid); | ||
| 91 | val = (1UL << UVH_IPI_INT_SEND_SHFT) | | ||
| 92 | (apicid << UVH_IPI_INT_APIC_ID_SHFT) | | ||
| 93 | (GENERIC_INTERRUPT_VECTOR << UVH_IPI_INT_VECTOR_SHFT); | ||
| 94 | |||
| 95 | uv_write_global_mmr64(pnode, UVH_IPI_INT, val); | ||
| 96 | } | ||
| 97 | |||
| 98 | /* Check for an RTC interrupt pending */ | ||
| 99 | static int uv_intr_pending(int pnode) | ||
| 100 | { | ||
| 101 | return uv_read_global_mmr64(pnode, UVH_EVENT_OCCURRED0) & | ||
| 102 | UVH_EVENT_OCCURRED0_RTC1_MASK; | ||
| 103 | } | ||
| 104 | |||
| 105 | /* Setup interrupt and return non-zero if early expiration occurred. */ | ||
| 106 | static int uv_setup_intr(int cpu, u64 expires) | ||
| 107 | { | ||
| 108 | u64 val; | ||
| 109 | int pnode = uv_cpu_to_pnode(cpu); | ||
| 110 | |||
| 111 | uv_write_global_mmr64(pnode, UVH_RTC1_INT_CONFIG, | ||
| 112 | UVH_RTC1_INT_CONFIG_M_MASK); | ||
| 113 | uv_write_global_mmr64(pnode, UVH_INT_CMPB, -1L); | ||
| 114 | |||
| 115 | uv_write_global_mmr64(pnode, UVH_EVENT_OCCURRED0_ALIAS, | ||
| 116 | UVH_EVENT_OCCURRED0_RTC1_MASK); | ||
| 117 | |||
| 118 | val = (GENERIC_INTERRUPT_VECTOR << UVH_RTC1_INT_CONFIG_VECTOR_SHFT) | | ||
| 119 | ((u64)cpu_physical_id(cpu) << UVH_RTC1_INT_CONFIG_APIC_ID_SHFT); | ||
| 120 | |||
| 121 | /* Set configuration */ | ||
| 122 | uv_write_global_mmr64(pnode, UVH_RTC1_INT_CONFIG, val); | ||
| 123 | /* Initialize comparator value */ | ||
| 124 | uv_write_global_mmr64(pnode, UVH_INT_CMPB, expires); | ||
| 125 | |||
| 126 | return (expires < uv_read_rtc() && !uv_intr_pending(pnode)); | ||
| 127 | } | ||
| 128 | |||
| 129 | /* | ||
| 130 | * Per-cpu timer tracking routines | ||
| 131 | */ | ||
| 132 | |||
| 133 | static __init void uv_rtc_deallocate_timers(void) | ||
| 134 | { | ||
| 135 | int bid; | ||
| 136 | |||
| 137 | for_each_possible_blade(bid) { | ||
| 138 | kfree(blade_info[bid]); | ||
| 139 | } | ||
| 140 | kfree(blade_info); | ||
| 141 | } | ||
| 142 | |||
| 143 | /* Allocate per-node list of cpu timer expiration times. */ | ||
| 144 | static __init int uv_rtc_allocate_timers(void) | ||
| 145 | { | ||
| 146 | int cpu; | ||
| 147 | |||
| 148 | blade_info = kmalloc(uv_possible_blades * sizeof(void *), GFP_KERNEL); | ||
| 149 | if (!blade_info) | ||
| 150 | return -ENOMEM; | ||
| 151 | memset(blade_info, 0, uv_possible_blades * sizeof(void *)); | ||
| 152 | |||
| 153 | for_each_present_cpu(cpu) { | ||
| 154 | int nid = cpu_to_node(cpu); | ||
| 155 | int bid = uv_cpu_to_blade_id(cpu); | ||
| 156 | int bcpu = uv_cpu_hub_info(cpu)->blade_processor_id; | ||
| 157 | struct uv_rtc_timer_head *head = blade_info[bid]; | ||
| 158 | |||
| 159 | if (!head) { | ||
| 160 | head = kmalloc_node(sizeof(struct uv_rtc_timer_head) + | ||
| 161 | (uv_blade_nr_possible_cpus(bid) * | ||
| 162 | 2 * sizeof(u64)), | ||
| 163 | GFP_KERNEL, nid); | ||
| 164 | if (!head) { | ||
| 165 | uv_rtc_deallocate_timers(); | ||
| 166 | return -ENOMEM; | ||
| 167 | } | ||
| 168 | spin_lock_init(&head->lock); | ||
| 169 | head->ncpus = uv_blade_nr_possible_cpus(bid); | ||
| 170 | head->next_cpu = -1; | ||
| 171 | blade_info[bid] = head; | ||
| 172 | } | ||
| 173 | |||
| 174 | head->cpu[bcpu].lcpu = cpu; | ||
| 175 | head->cpu[bcpu].expires = ULLONG_MAX; | ||
| 176 | } | ||
| 177 | |||
| 178 | return 0; | ||
| 179 | } | ||
| 180 | |||
| 181 | /* Find and set the next expiring timer. */ | ||
| 182 | static void uv_rtc_find_next_timer(struct uv_rtc_timer_head *head, int pnode) | ||
| 183 | { | ||
| 184 | u64 lowest = ULLONG_MAX; | ||
| 185 | int c, bcpu = -1; | ||
| 186 | |||
| 187 | head->next_cpu = -1; | ||
| 188 | for (c = 0; c < head->ncpus; c++) { | ||
| 189 | u64 exp = head->cpu[c].expires; | ||
| 190 | if (exp < lowest) { | ||
| 191 | bcpu = c; | ||
| 192 | lowest = exp; | ||
| 193 | } | ||
| 194 | } | ||
| 195 | if (bcpu >= 0) { | ||
| 196 | head->next_cpu = bcpu; | ||
| 197 | c = head->cpu[bcpu].lcpu; | ||
| 198 | if (uv_setup_intr(c, lowest)) | ||
| 199 | /* If we didn't set it up in time, trigger */ | ||
| 200 | uv_rtc_send_IPI(c); | ||
| 201 | } else { | ||
| 202 | uv_write_global_mmr64(pnode, UVH_RTC1_INT_CONFIG, | ||
| 203 | UVH_RTC1_INT_CONFIG_M_MASK); | ||
| 204 | } | ||
| 205 | } | ||
| 206 | |||
| 207 | /* | ||
| 208 | * Set expiration time for current cpu. | ||
| 209 | * | ||
| 210 | * Returns 1 if we missed the expiration time. | ||
| 211 | */ | ||
| 212 | static int uv_rtc_set_timer(int cpu, u64 expires) | ||
| 213 | { | ||
| 214 | int pnode = uv_cpu_to_pnode(cpu); | ||
| 215 | int bid = uv_cpu_to_blade_id(cpu); | ||
| 216 | struct uv_rtc_timer_head *head = blade_info[bid]; | ||
| 217 | int bcpu = uv_cpu_hub_info(cpu)->blade_processor_id; | ||
| 218 | u64 *t = &head->cpu[bcpu].expires; | ||
| 219 | unsigned long flags; | ||
| 220 | int next_cpu; | ||
| 221 | |||
| 222 | spin_lock_irqsave(&head->lock, flags); | ||
| 223 | |||
| 224 | next_cpu = head->next_cpu; | ||
| 225 | *t = expires; | ||
| 226 | /* Will this one be next to go off? */ | ||
| 227 | if (next_cpu < 0 || bcpu == next_cpu || | ||
| 228 | expires < head->cpu[next_cpu].expires) { | ||
| 229 | head->next_cpu = bcpu; | ||
| 230 | if (uv_setup_intr(cpu, expires)) { | ||
| 231 | *t = ULLONG_MAX; | ||
| 232 | uv_rtc_find_next_timer(head, pnode); | ||
| 233 | spin_unlock_irqrestore(&head->lock, flags); | ||
| 234 | return 1; | ||
| 235 | } | ||
| 236 | } | ||
| 237 | |||
| 238 | spin_unlock_irqrestore(&head->lock, flags); | ||
| 239 | return 0; | ||
| 240 | } | ||
| 241 | |||
| 242 | /* | ||
| 243 | * Unset expiration time for current cpu. | ||
| 244 | * | ||
| 245 | * Returns 1 if this timer was pending. | ||
| 246 | */ | ||
| 247 | static int uv_rtc_unset_timer(int cpu) | ||
| 248 | { | ||
| 249 | int pnode = uv_cpu_to_pnode(cpu); | ||
| 250 | int bid = uv_cpu_to_blade_id(cpu); | ||
| 251 | struct uv_rtc_timer_head *head = blade_info[bid]; | ||
| 252 | int bcpu = uv_cpu_hub_info(cpu)->blade_processor_id; | ||
| 253 | u64 *t = &head->cpu[bcpu].expires; | ||
| 254 | unsigned long flags; | ||
| 255 | int rc = 0; | ||
| 256 | |||
| 257 | spin_lock_irqsave(&head->lock, flags); | ||
| 258 | |||
| 259 | if (head->next_cpu == bcpu && uv_read_rtc() >= *t) | ||
| 260 | rc = 1; | ||
| 261 | |||
| 262 | *t = ULLONG_MAX; | ||
| 263 | |||
| 264 | /* Was the hardware setup for this timer? */ | ||
| 265 | if (head->next_cpu == bcpu) | ||
| 266 | uv_rtc_find_next_timer(head, pnode); | ||
| 267 | |||
| 268 | spin_unlock_irqrestore(&head->lock, flags); | ||
| 269 | |||
| 270 | return rc; | ||
| 271 | } | ||
| 272 | |||
| 273 | |||
| 274 | /* | ||
| 275 | * Kernel interface routines. | ||
| 276 | */ | ||
| 277 | |||
| 278 | /* | ||
| 279 | * Read the RTC. | ||
| 280 | */ | ||
| 281 | static cycle_t uv_read_rtc(void) | ||
| 282 | { | ||
| 283 | return (cycle_t)uv_read_local_mmr(UVH_RTC); | ||
| 284 | } | ||
| 285 | |||
| 286 | /* | ||
| 287 | * Program the next event, relative to now | ||
| 288 | */ | ||
| 289 | static int uv_rtc_next_event(unsigned long delta, | ||
| 290 | struct clock_event_device *ced) | ||
| 291 | { | ||
| 292 | int ced_cpu = cpumask_first(ced->cpumask); | ||
| 293 | |||
| 294 | return uv_rtc_set_timer(ced_cpu, delta + uv_read_rtc()); | ||
| 295 | } | ||
| 296 | |||
| 297 | /* | ||
| 298 | * Setup the RTC timer in oneshot mode | ||
| 299 | */ | ||
| 300 | static void uv_rtc_timer_setup(enum clock_event_mode mode, | ||
| 301 | struct clock_event_device *evt) | ||
| 302 | { | ||
| 303 | int ced_cpu = cpumask_first(evt->cpumask); | ||
| 304 | |||
| 305 | switch (mode) { | ||
| 306 | case CLOCK_EVT_MODE_PERIODIC: | ||
| 307 | case CLOCK_EVT_MODE_ONESHOT: | ||
| 308 | case CLOCK_EVT_MODE_RESUME: | ||
| 309 | /* Nothing to do here yet */ | ||
| 310 | break; | ||
| 311 | case CLOCK_EVT_MODE_UNUSED: | ||
| 312 | case CLOCK_EVT_MODE_SHUTDOWN: | ||
| 313 | uv_rtc_unset_timer(ced_cpu); | ||
| 314 | break; | ||
| 315 | } | ||
| 316 | } | ||
| 317 | |||
| 318 | static void uv_rtc_interrupt(void) | ||
| 319 | { | ||
| 320 | struct clock_event_device *ced = &__get_cpu_var(cpu_ced); | ||
| 321 | int cpu = smp_processor_id(); | ||
| 322 | |||
| 323 | if (!ced || !ced->event_handler) | ||
| 324 | return; | ||
| 325 | |||
| 326 | if (uv_rtc_unset_timer(cpu) != 1) | ||
| 327 | return; | ||
| 328 | |||
| 329 | ced->event_handler(ced); | ||
| 330 | } | ||
| 331 | |||
| 332 | static int __init uv_enable_rtc(char *str) | ||
| 333 | { | ||
| 334 | uv_rtc_enable = 1; | ||
| 335 | |||
| 336 | return 1; | ||
| 337 | } | ||
| 338 | __setup("uvrtc", uv_enable_rtc); | ||
| 339 | |||
| 340 | static __init void uv_rtc_register_clockevents(struct work_struct *dummy) | ||
| 341 | { | ||
| 342 | struct clock_event_device *ced = &__get_cpu_var(cpu_ced); | ||
| 343 | |||
| 344 | *ced = clock_event_device_uv; | ||
| 345 | ced->cpumask = cpumask_of(smp_processor_id()); | ||
| 346 | clockevents_register_device(ced); | ||
| 347 | } | ||
| 348 | |||
| 349 | static __init int uv_rtc_setup_clock(void) | ||
| 350 | { | ||
| 351 | int rc; | ||
| 352 | |||
| 353 | if (!uv_rtc_enable || !is_uv_system() || generic_interrupt_extension) | ||
| 354 | return -ENODEV; | ||
| 355 | |||
| 356 | generic_interrupt_extension = uv_rtc_interrupt; | ||
| 357 | |||
| 358 | clocksource_uv.mult = clocksource_hz2mult(sn_rtc_cycles_per_second, | ||
| 359 | clocksource_uv.shift); | ||
| 360 | |||
| 361 | rc = clocksource_register(&clocksource_uv); | ||
| 362 | if (rc) { | ||
| 363 | generic_interrupt_extension = NULL; | ||
| 364 | return rc; | ||
| 365 | } | ||
| 366 | |||
| 367 | /* Setup and register clockevents */ | ||
| 368 | rc = uv_rtc_allocate_timers(); | ||
| 369 | if (rc) { | ||
| 370 | clocksource_unregister(&clocksource_uv); | ||
| 371 | generic_interrupt_extension = NULL; | ||
| 372 | return rc; | ||
| 373 | } | ||
| 374 | |||
| 375 | clock_event_device_uv.mult = div_sc(sn_rtc_cycles_per_second, | ||
| 376 | NSEC_PER_SEC, clock_event_device_uv.shift); | ||
| 377 | |||
| 378 | clock_event_device_uv.min_delta_ns = NSEC_PER_SEC / | ||
| 379 | sn_rtc_cycles_per_second; | ||
| 380 | |||
| 381 | clock_event_device_uv.max_delta_ns = clocksource_uv.mask * | ||
| 382 | (NSEC_PER_SEC / sn_rtc_cycles_per_second); | ||
| 383 | |||
| 384 | rc = schedule_on_each_cpu(uv_rtc_register_clockevents); | ||
| 385 | if (rc) { | ||
| 386 | clocksource_unregister(&clocksource_uv); | ||
| 387 | generic_interrupt_extension = NULL; | ||
| 388 | uv_rtc_deallocate_timers(); | ||
| 389 | } | ||
| 390 | |||
| 391 | return rc; | ||
| 392 | } | ||
| 393 | arch_initcall(uv_rtc_setup_clock); | ||
diff --git a/arch/x86/kernel/visws_quirks.c b/arch/x86/kernel/visws_quirks.c index 191a876e9e87..31ffc24eec4d 100644 --- a/arch/x86/kernel/visws_quirks.c +++ b/arch/x86/kernel/visws_quirks.c | |||
| @@ -578,7 +578,7 @@ static struct irq_chip piix4_virtual_irq_type = { | |||
| 578 | static irqreturn_t piix4_master_intr(int irq, void *dev_id) | 578 | static irqreturn_t piix4_master_intr(int irq, void *dev_id) |
| 579 | { | 579 | { |
| 580 | int realirq; | 580 | int realirq; |
| 581 | irq_desc_t *desc; | 581 | struct irq_desc *desc; |
| 582 | unsigned long flags; | 582 | unsigned long flags; |
| 583 | 583 | ||
| 584 | spin_lock_irqsave(&i8259A_lock, flags); | 584 | spin_lock_irqsave(&i8259A_lock, flags); |
diff --git a/arch/x86/kernel/vmi_32.c b/arch/x86/kernel/vmi_32.c index 2cc4a90e2cb3..95deb9f2211e 100644 --- a/arch/x86/kernel/vmi_32.c +++ b/arch/x86/kernel/vmi_32.c | |||
| @@ -395,11 +395,6 @@ static void vmi_set_pte_atomic(pte_t *ptep, pte_t pteval) | |||
| 395 | vmi_ops.update_pte(ptep, VMI_PAGE_PT); | 395 | vmi_ops.update_pte(ptep, VMI_PAGE_PT); |
| 396 | } | 396 | } |
| 397 | 397 | ||
| 398 | static void vmi_set_pte_present(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pte) | ||
| 399 | { | ||
| 400 | vmi_ops.set_pte(pte, ptep, vmi_flags_addr_defer(mm, addr, VMI_PAGE_PT, 1)); | ||
| 401 | } | ||
| 402 | |||
| 403 | static void vmi_set_pud(pud_t *pudp, pud_t pudval) | 398 | static void vmi_set_pud(pud_t *pudp, pud_t pudval) |
| 404 | { | 399 | { |
| 405 | /* Um, eww */ | 400 | /* Um, eww */ |
| @@ -750,7 +745,6 @@ static inline int __init activate_vmi(void) | |||
| 750 | pv_mmu_ops.set_pmd = vmi_set_pmd; | 745 | pv_mmu_ops.set_pmd = vmi_set_pmd; |
| 751 | #ifdef CONFIG_X86_PAE | 746 | #ifdef CONFIG_X86_PAE |
| 752 | pv_mmu_ops.set_pte_atomic = vmi_set_pte_atomic; | 747 | pv_mmu_ops.set_pte_atomic = vmi_set_pte_atomic; |
| 753 | pv_mmu_ops.set_pte_present = vmi_set_pte_present; | ||
| 754 | pv_mmu_ops.set_pud = vmi_set_pud; | 748 | pv_mmu_ops.set_pud = vmi_set_pud; |
| 755 | pv_mmu_ops.pte_clear = vmi_pte_clear; | 749 | pv_mmu_ops.pte_clear = vmi_pte_clear; |
| 756 | pv_mmu_ops.pmd_clear = vmi_pmd_clear; | 750 | pv_mmu_ops.pmd_clear = vmi_pmd_clear; |
diff --git a/arch/x86/kernel/vmlinux_32.lds.S b/arch/x86/kernel/vmlinux_32.lds.S index 0d860963f268..62ad500d55f3 100644 --- a/arch/x86/kernel/vmlinux_32.lds.S +++ b/arch/x86/kernel/vmlinux_32.lds.S | |||
| @@ -189,15 +189,24 @@ SECTIONS | |||
| 189 | *(.bss) | 189 | *(.bss) |
| 190 | . = ALIGN(4); | 190 | . = ALIGN(4); |
| 191 | __bss_stop = .; | 191 | __bss_stop = .; |
| 192 | _end = . ; | 192 | } |
| 193 | /* This is where the kernel creates the early boot page tables */ | 193 | |
| 194 | .brk : AT(ADDR(.brk) - LOAD_OFFSET) { | ||
| 194 | . = ALIGN(PAGE_SIZE); | 195 | . = ALIGN(PAGE_SIZE); |
| 195 | pg0 = . ; | 196 | __brk_base = . ; |
| 197 | . += 64 * 1024 ; /* 64k alignment slop space */ | ||
| 198 | *(.brk_reservation) /* areas brk users have reserved */ | ||
| 199 | __brk_limit = . ; | ||
| 200 | } | ||
| 201 | |||
| 202 | .end : AT(ADDR(.end) - LOAD_OFFSET) { | ||
| 203 | _end = . ; | ||
| 196 | } | 204 | } |
| 197 | 205 | ||
| 198 | /* Sections to be discarded */ | 206 | /* Sections to be discarded */ |
| 199 | /DISCARD/ : { | 207 | /DISCARD/ : { |
| 200 | *(.exitcall.exit) | 208 | *(.exitcall.exit) |
| 209 | *(.discard) | ||
| 201 | } | 210 | } |
| 202 | 211 | ||
| 203 | STABS_DEBUG | 212 | STABS_DEBUG |
| @@ -205,6 +214,12 @@ SECTIONS | |||
| 205 | DWARF_DEBUG | 214 | DWARF_DEBUG |
| 206 | } | 215 | } |
| 207 | 216 | ||
| 217 | /* | ||
| 218 | * Build-time check on the image size: | ||
| 219 | */ | ||
| 220 | ASSERT((_end - LOAD_OFFSET <= KERNEL_IMAGE_SIZE), | ||
| 221 | "kernel image bigger than KERNEL_IMAGE_SIZE") | ||
| 222 | |||
| 208 | #ifdef CONFIG_KEXEC | 223 | #ifdef CONFIG_KEXEC |
| 209 | /* Link time checks */ | 224 | /* Link time checks */ |
| 210 | #include <asm/kexec.h> | 225 | #include <asm/kexec.h> |
diff --git a/arch/x86/kernel/vmlinux_64.lds.S b/arch/x86/kernel/vmlinux_64.lds.S index fbfced6f6800..c8742507b030 100644 --- a/arch/x86/kernel/vmlinux_64.lds.S +++ b/arch/x86/kernel/vmlinux_64.lds.S | |||
| @@ -29,8 +29,8 @@ SECTIONS | |||
| 29 | { | 29 | { |
| 30 | . = __START_KERNEL; | 30 | . = __START_KERNEL; |
| 31 | phys_startup_64 = startup_64 - LOAD_OFFSET; | 31 | phys_startup_64 = startup_64 - LOAD_OFFSET; |
| 32 | _text = .; /* Text and read-only data */ | ||
| 33 | .text : AT(ADDR(.text) - LOAD_OFFSET) { | 32 | .text : AT(ADDR(.text) - LOAD_OFFSET) { |
| 33 | _text = .; /* Text and read-only data */ | ||
| 34 | /* First the code that has to be first for bootstrapping */ | 34 | /* First the code that has to be first for bootstrapping */ |
| 35 | *(.text.head) | 35 | *(.text.head) |
| 36 | _stext = .; | 36 | _stext = .; |
| @@ -61,13 +61,13 @@ SECTIONS | |||
| 61 | .data : AT(ADDR(.data) - LOAD_OFFSET) { | 61 | .data : AT(ADDR(.data) - LOAD_OFFSET) { |
| 62 | DATA_DATA | 62 | DATA_DATA |
| 63 | CONSTRUCTORS | 63 | CONSTRUCTORS |
| 64 | _edata = .; /* End of data section */ | ||
| 64 | } :data | 65 | } :data |
| 65 | 66 | ||
| 66 | _edata = .; /* End of data section */ | ||
| 67 | 67 | ||
| 68 | . = ALIGN(PAGE_SIZE); | ||
| 69 | . = ALIGN(CONFIG_X86_L1_CACHE_BYTES); | ||
| 70 | .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) { | 68 | .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) { |
| 69 | . = ALIGN(PAGE_SIZE); | ||
| 70 | . = ALIGN(CONFIG_X86_L1_CACHE_BYTES); | ||
| 71 | *(.data.cacheline_aligned) | 71 | *(.data.cacheline_aligned) |
| 72 | } | 72 | } |
| 73 | . = ALIGN(CONFIG_X86_INTERNODE_CACHE_BYTES); | 73 | . = ALIGN(CONFIG_X86_INTERNODE_CACHE_BYTES); |
| @@ -125,29 +125,29 @@ SECTIONS | |||
| 125 | #undef VVIRT_OFFSET | 125 | #undef VVIRT_OFFSET |
| 126 | #undef VVIRT | 126 | #undef VVIRT |
| 127 | 127 | ||
| 128 | . = ALIGN(THREAD_SIZE); /* init_task */ | ||
| 129 | .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) { | 128 | .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) { |
| 129 | . = ALIGN(THREAD_SIZE); /* init_task */ | ||
| 130 | *(.data.init_task) | 130 | *(.data.init_task) |
| 131 | }:data.init | 131 | }:data.init |
| 132 | 132 | ||
| 133 | . = ALIGN(PAGE_SIZE); | ||
| 134 | .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) { | 133 | .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) { |
| 134 | . = ALIGN(PAGE_SIZE); | ||
| 135 | *(.data.page_aligned) | 135 | *(.data.page_aligned) |
| 136 | } | 136 | } |
| 137 | 137 | ||
| 138 | /* might get freed after init */ | ||
| 139 | . = ALIGN(PAGE_SIZE); | ||
| 140 | __smp_alt_begin = .; | ||
| 141 | __smp_locks = .; | ||
| 142 | .smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) { | 138 | .smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) { |
| 139 | /* might get freed after init */ | ||
| 140 | . = ALIGN(PAGE_SIZE); | ||
| 141 | __smp_alt_begin = .; | ||
| 142 | __smp_locks = .; | ||
| 143 | *(.smp_locks) | 143 | *(.smp_locks) |
| 144 | __smp_locks_end = .; | ||
| 145 | . = ALIGN(PAGE_SIZE); | ||
| 146 | __smp_alt_end = .; | ||
| 144 | } | 147 | } |
| 145 | __smp_locks_end = .; | ||
| 146 | . = ALIGN(PAGE_SIZE); | ||
| 147 | __smp_alt_end = .; | ||
| 148 | 148 | ||
| 149 | . = ALIGN(PAGE_SIZE); /* Init code and data */ | 149 | . = ALIGN(PAGE_SIZE); /* Init code and data */ |
| 150 | __init_begin = .; | 150 | __init_begin = .; /* paired with __init_end */ |
| 151 | .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) { | 151 | .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) { |
| 152 | _sinittext = .; | 152 | _sinittext = .; |
| 153 | INIT_TEXT | 153 | INIT_TEXT |
| @@ -159,40 +159,42 @@ SECTIONS | |||
| 159 | __initdata_end = .; | 159 | __initdata_end = .; |
| 160 | } | 160 | } |
| 161 | 161 | ||
| 162 | . = ALIGN(16); | 162 | .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) { |
| 163 | __setup_start = .; | 163 | . = ALIGN(16); |
| 164 | .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) { *(.init.setup) } | 164 | __setup_start = .; |
| 165 | __setup_end = .; | 165 | *(.init.setup) |
| 166 | __initcall_start = .; | 166 | __setup_end = .; |
| 167 | } | ||
| 167 | .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) { | 168 | .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) { |
| 169 | __initcall_start = .; | ||
| 168 | INITCALLS | 170 | INITCALLS |
| 171 | __initcall_end = .; | ||
| 169 | } | 172 | } |
| 170 | __initcall_end = .; | ||
| 171 | __con_initcall_start = .; | ||
| 172 | .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) { | 173 | .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) { |
| 174 | __con_initcall_start = .; | ||
| 173 | *(.con_initcall.init) | 175 | *(.con_initcall.init) |
| 176 | __con_initcall_end = .; | ||
| 174 | } | 177 | } |
| 175 | __con_initcall_end = .; | ||
| 176 | __x86_cpu_dev_start = .; | ||
| 177 | .x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) { | 178 | .x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) { |
| 179 | __x86_cpu_dev_start = .; | ||
| 178 | *(.x86_cpu_dev.init) | 180 | *(.x86_cpu_dev.init) |
| 181 | __x86_cpu_dev_end = .; | ||
| 179 | } | 182 | } |
| 180 | __x86_cpu_dev_end = .; | ||
| 181 | SECURITY_INIT | 183 | SECURITY_INIT |
| 182 | 184 | ||
| 183 | . = ALIGN(8); | 185 | . = ALIGN(8); |
| 184 | .parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) { | 186 | .parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) { |
| 185 | __parainstructions = .; | 187 | __parainstructions = .; |
| 186 | *(.parainstructions) | 188 | *(.parainstructions) |
| 187 | __parainstructions_end = .; | 189 | __parainstructions_end = .; |
| 188 | } | 190 | } |
| 189 | 191 | ||
| 190 | . = ALIGN(8); | ||
| 191 | __alt_instructions = .; | ||
| 192 | .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) { | 192 | .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) { |
| 193 | . = ALIGN(8); | ||
| 194 | __alt_instructions = .; | ||
| 193 | *(.altinstructions) | 195 | *(.altinstructions) |
| 196 | __alt_instructions_end = .; | ||
| 194 | } | 197 | } |
| 195 | __alt_instructions_end = .; | ||
| 196 | .altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) { | 198 | .altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) { |
| 197 | *(.altinstr_replacement) | 199 | *(.altinstr_replacement) |
| 198 | } | 200 | } |
| @@ -207,9 +209,11 @@ SECTIONS | |||
| 207 | 209 | ||
| 208 | #ifdef CONFIG_BLK_DEV_INITRD | 210 | #ifdef CONFIG_BLK_DEV_INITRD |
| 209 | . = ALIGN(PAGE_SIZE); | 211 | . = ALIGN(PAGE_SIZE); |
| 210 | __initramfs_start = .; | 212 | .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) { |
| 211 | .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) { *(.init.ramfs) } | 213 | __initramfs_start = .; |
| 212 | __initramfs_end = .; | 214 | *(.init.ramfs) |
| 215 | __initramfs_end = .; | ||
| 216 | } | ||
| 213 | #endif | 217 | #endif |
| 214 | 218 | ||
| 215 | #ifdef CONFIG_SMP | 219 | #ifdef CONFIG_SMP |
| @@ -229,20 +233,29 @@ SECTIONS | |||
| 229 | . = ALIGN(PAGE_SIZE); | 233 | . = ALIGN(PAGE_SIZE); |
| 230 | __init_end = .; | 234 | __init_end = .; |
| 231 | 235 | ||
| 232 | . = ALIGN(PAGE_SIZE); | ||
| 233 | __nosave_begin = .; | ||
| 234 | .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) { | 236 | .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) { |
| 235 | *(.data.nosave) | 237 | . = ALIGN(PAGE_SIZE); |
| 238 | __nosave_begin = .; | ||
| 239 | *(.data.nosave) | ||
| 240 | . = ALIGN(PAGE_SIZE); | ||
| 241 | __nosave_end = .; | ||
| 236 | } :data.init2 /* use another section data.init2, see PERCPU_VADDR() above */ | 242 | } :data.init2 /* use another section data.init2, see PERCPU_VADDR() above */ |
| 237 | . = ALIGN(PAGE_SIZE); | ||
| 238 | __nosave_end = .; | ||
| 239 | 243 | ||
| 240 | __bss_start = .; /* BSS */ | ||
| 241 | .bss : AT(ADDR(.bss) - LOAD_OFFSET) { | 244 | .bss : AT(ADDR(.bss) - LOAD_OFFSET) { |
| 245 | . = ALIGN(PAGE_SIZE); | ||
| 246 | __bss_start = .; /* BSS */ | ||
| 242 | *(.bss.page_aligned) | 247 | *(.bss.page_aligned) |
| 243 | *(.bss) | 248 | *(.bss) |
| 244 | } | 249 | __bss_stop = .; |
| 245 | __bss_stop = .; | 250 | } |
| 251 | |||
| 252 | .brk : AT(ADDR(.brk) - LOAD_OFFSET) { | ||
| 253 | . = ALIGN(PAGE_SIZE); | ||
| 254 | __brk_base = . ; | ||
| 255 | . += 64 * 1024 ; /* 64k alignment slop space */ | ||
| 256 | *(.brk_reservation) /* areas brk users have reserved */ | ||
| 257 | __brk_limit = . ; | ||
| 258 | } | ||
| 246 | 259 | ||
| 247 | _end = . ; | 260 | _end = . ; |
| 248 | 261 | ||
| @@ -250,6 +263,7 @@ SECTIONS | |||
| 250 | /DISCARD/ : { | 263 | /DISCARD/ : { |
| 251 | *(.exitcall.exit) | 264 | *(.exitcall.exit) |
| 252 | *(.eh_frame) | 265 | *(.eh_frame) |
| 266 | *(.discard) | ||
| 253 | } | 267 | } |
| 254 | 268 | ||
| 255 | STABS_DEBUG | 269 | STABS_DEBUG |
| @@ -275,3 +289,10 @@ ASSERT((_end - _text <= KERNEL_IMAGE_SIZE), | |||
| 275 | ASSERT((per_cpu__irq_stack_union == 0), | 289 | ASSERT((per_cpu__irq_stack_union == 0), |
| 276 | "irq_stack_union is not at start of per-cpu area"); | 290 | "irq_stack_union is not at start of per-cpu area"); |
| 277 | #endif | 291 | #endif |
| 292 | |||
| 293 | #ifdef CONFIG_KEXEC | ||
| 294 | #include <asm/kexec.h> | ||
| 295 | |||
| 296 | ASSERT(kexec_control_code_size <= KEXEC_CONTROL_CODE_MAX_SIZE, | ||
| 297 | "kexec control code size is too big") | ||
| 298 | #endif | ||
diff --git a/arch/x86/kernel/vsmp_64.c b/arch/x86/kernel/vsmp_64.c index 74de562812cc..a1d804bcd483 100644 --- a/arch/x86/kernel/vsmp_64.c +++ b/arch/x86/kernel/vsmp_64.c | |||
| @@ -22,7 +22,7 @@ | |||
| 22 | #include <asm/paravirt.h> | 22 | #include <asm/paravirt.h> |
| 23 | #include <asm/setup.h> | 23 | #include <asm/setup.h> |
| 24 | 24 | ||
| 25 | #ifdef CONFIG_PARAVIRT | 25 | #if defined CONFIG_PCI && defined CONFIG_PARAVIRT |
| 26 | /* | 26 | /* |
| 27 | * Interrupt control on vSMPowered systems: | 27 | * Interrupt control on vSMPowered systems: |
| 28 | * ~AC is a shadow of IF. If IF is 'on' AC should be 'off' | 28 | * ~AC is a shadow of IF. If IF is 'on' AC should be 'off' |
| @@ -114,6 +114,7 @@ static void __init set_vsmp_pv_ops(void) | |||
| 114 | } | 114 | } |
| 115 | #endif | 115 | #endif |
| 116 | 116 | ||
| 117 | #ifdef CONFIG_PCI | ||
| 117 | static int is_vsmp = -1; | 118 | static int is_vsmp = -1; |
| 118 | 119 | ||
| 119 | static void __init detect_vsmp_box(void) | 120 | static void __init detect_vsmp_box(void) |
| @@ -139,6 +140,15 @@ int is_vsmp_box(void) | |||
| 139 | } | 140 | } |
| 140 | } | 141 | } |
| 141 | 142 | ||
| 143 | #else | ||
| 144 | static void __init detect_vsmp_box(void) | ||
| 145 | { | ||
| 146 | } | ||
| 147 | int is_vsmp_box(void) | ||
| 148 | { | ||
| 149 | return 0; | ||
| 150 | } | ||
| 151 | #endif | ||
| 142 | void __init vsmp_init(void) | 152 | void __init vsmp_init(void) |
| 143 | { | 153 | { |
| 144 | detect_vsmp_box(); | 154 | detect_vsmp_box(); |
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c index 9fe4ddaa8f6f..90e44a10e68a 100644 --- a/arch/x86/lguest/boot.c +++ b/arch/x86/lguest/boot.c | |||
| @@ -1058,14 +1058,6 @@ __init void lguest_init(void) | |||
| 1058 | * lguest_init() where the rest of the fairly chaotic boot setup | 1058 | * lguest_init() where the rest of the fairly chaotic boot setup |
| 1059 | * occurs. */ | 1059 | * occurs. */ |
| 1060 | 1060 | ||
| 1061 | /* The native boot code sets up initial page tables immediately after | ||
| 1062 | * the kernel itself, and sets init_pg_tables_end so they're not | ||
| 1063 | * clobbered. The Launcher places our initial pagetables somewhere at | ||
| 1064 | * the top of our physical memory, so we don't need extra space: set | ||
| 1065 | * init_pg_tables_end to the end of the kernel. */ | ||
| 1066 | init_pg_tables_start = __pa(pg0); | ||
| 1067 | init_pg_tables_end = __pa(pg0); | ||
| 1068 | |||
| 1069 | /* As described in head_32.S, we map the first 128M of memory. */ | 1061 | /* As described in head_32.S, we map the first 128M of memory. */ |
| 1070 | max_pfn_mapped = (128*1024*1024) >> PAGE_SHIFT; | 1062 | max_pfn_mapped = (128*1024*1024) >> PAGE_SHIFT; |
| 1071 | 1063 | ||
diff --git a/arch/x86/lib/memcpy_64.S b/arch/x86/lib/memcpy_64.S index c22981fa2f3a..ad5441ed1b57 100644 --- a/arch/x86/lib/memcpy_64.S +++ b/arch/x86/lib/memcpy_64.S | |||
| @@ -1,30 +1,38 @@ | |||
| 1 | /* Copyright 2002 Andi Kleen */ | 1 | /* Copyright 2002 Andi Kleen */ |
| 2 | 2 | ||
| 3 | #include <linux/linkage.h> | 3 | #include <linux/linkage.h> |
| 4 | #include <asm/dwarf2.h> | 4 | |
| 5 | #include <asm/cpufeature.h> | 5 | #include <asm/cpufeature.h> |
| 6 | #include <asm/dwarf2.h> | ||
| 6 | 7 | ||
| 7 | /* | 8 | /* |
| 8 | * memcpy - Copy a memory block. | 9 | * memcpy - Copy a memory block. |
| 9 | * | 10 | * |
| 10 | * Input: | 11 | * Input: |
| 11 | * rdi destination | 12 | * rdi destination |
| 12 | * rsi source | 13 | * rsi source |
| 13 | * rdx count | 14 | * rdx count |
| 14 | * | 15 | * |
| 15 | * Output: | 16 | * Output: |
| 16 | * rax original destination | 17 | * rax original destination |
| 17 | */ | 18 | */ |
| 18 | 19 | ||
| 20 | /* | ||
| 21 | * memcpy_c() - fast string ops (REP MOVSQ) based variant. | ||
| 22 | * | ||
| 23 | * Calls to this get patched into the kernel image via the | ||
| 24 | * alternative instructions framework: | ||
| 25 | */ | ||
| 19 | ALIGN | 26 | ALIGN |
| 20 | memcpy_c: | 27 | memcpy_c: |
| 21 | CFI_STARTPROC | 28 | CFI_STARTPROC |
| 22 | movq %rdi,%rax | 29 | movq %rdi, %rax |
| 23 | movl %edx,%ecx | 30 | |
| 24 | shrl $3,%ecx | 31 | movl %edx, %ecx |
| 25 | andl $7,%edx | 32 | shrl $3, %ecx |
| 33 | andl $7, %edx | ||
| 26 | rep movsq | 34 | rep movsq |
| 27 | movl %edx,%ecx | 35 | movl %edx, %ecx |
| 28 | rep movsb | 36 | rep movsb |
| 29 | ret | 37 | ret |
| 30 | CFI_ENDPROC | 38 | CFI_ENDPROC |
| @@ -33,99 +41,110 @@ ENDPROC(memcpy_c) | |||
| 33 | ENTRY(__memcpy) | 41 | ENTRY(__memcpy) |
| 34 | ENTRY(memcpy) | 42 | ENTRY(memcpy) |
| 35 | CFI_STARTPROC | 43 | CFI_STARTPROC |
| 36 | pushq %rbx | ||
| 37 | CFI_ADJUST_CFA_OFFSET 8 | ||
| 38 | CFI_REL_OFFSET rbx, 0 | ||
| 39 | movq %rdi,%rax | ||
| 40 | 44 | ||
| 41 | movl %edx,%ecx | 45 | /* |
| 42 | shrl $6,%ecx | 46 | * Put the number of full 64-byte blocks into %ecx. |
| 47 | * Tail portion is handled at the end: | ||
| 48 | */ | ||
| 49 | movq %rdi, %rax | ||
| 50 | movl %edx, %ecx | ||
| 51 | shrl $6, %ecx | ||
| 43 | jz .Lhandle_tail | 52 | jz .Lhandle_tail |
| 44 | 53 | ||
| 45 | .p2align 4 | 54 | .p2align 4 |
| 46 | .Lloop_64: | 55 | .Lloop_64: |
| 56 | /* | ||
| 57 | * We decrement the loop index here - and the zero-flag is | ||
| 58 | * checked at the end of the loop (instructions inbetween do | ||
| 59 | * not change the zero flag): | ||
| 60 | */ | ||
| 47 | decl %ecx | 61 | decl %ecx |
| 48 | 62 | ||
| 49 | movq (%rsi),%r11 | 63 | /* |
| 50 | movq 8(%rsi),%r8 | 64 | * Move in blocks of 4x16 bytes: |
| 65 | */ | ||
| 66 | movq 0*8(%rsi), %r11 | ||
| 67 | movq 1*8(%rsi), %r8 | ||
| 68 | movq %r11, 0*8(%rdi) | ||
| 69 | movq %r8, 1*8(%rdi) | ||
| 51 | 70 | ||
| 52 | movq %r11,(%rdi) | 71 | movq 2*8(%rsi), %r9 |
| 53 | movq %r8,1*8(%rdi) | 72 | movq 3*8(%rsi), %r10 |
| 73 | movq %r9, 2*8(%rdi) | ||
| 74 | movq %r10, 3*8(%rdi) | ||
| 54 | 75 | ||
| 55 | movq 2*8(%rsi),%r9 | 76 | movq 4*8(%rsi), %r11 |
| 56 | movq 3*8(%rsi),%r10 | 77 | movq 5*8(%rsi), %r8 |
| 78 | movq %r11, 4*8(%rdi) | ||
| 79 | movq %r8, 5*8(%rdi) | ||
| 57 | 80 | ||
| 58 | movq %r9,2*8(%rdi) | 81 | movq 6*8(%rsi), %r9 |
| 59 | movq %r10,3*8(%rdi) | 82 | movq 7*8(%rsi), %r10 |
| 83 | movq %r9, 6*8(%rdi) | ||
| 84 | movq %r10, 7*8(%rdi) | ||
| 60 | 85 | ||
| 61 | movq 4*8(%rsi),%r11 | 86 | leaq 64(%rsi), %rsi |
| 62 | movq 5*8(%rsi),%r8 | 87 | leaq 64(%rdi), %rdi |
| 63 | 88 | ||
| 64 | movq %r11,4*8(%rdi) | ||
| 65 | movq %r8,5*8(%rdi) | ||
| 66 | |||
| 67 | movq 6*8(%rsi),%r9 | ||
| 68 | movq 7*8(%rsi),%r10 | ||
| 69 | |||
| 70 | movq %r9,6*8(%rdi) | ||
| 71 | movq %r10,7*8(%rdi) | ||
| 72 | |||
| 73 | leaq 64(%rsi),%rsi | ||
| 74 | leaq 64(%rdi),%rdi | ||
| 75 | jnz .Lloop_64 | 89 | jnz .Lloop_64 |
| 76 | 90 | ||
| 77 | .Lhandle_tail: | 91 | .Lhandle_tail: |
| 78 | movl %edx,%ecx | 92 | movl %edx, %ecx |
| 79 | andl $63,%ecx | 93 | andl $63, %ecx |
| 80 | shrl $3,%ecx | 94 | shrl $3, %ecx |
| 81 | jz .Lhandle_7 | 95 | jz .Lhandle_7 |
| 96 | |||
| 82 | .p2align 4 | 97 | .p2align 4 |
| 83 | .Lloop_8: | 98 | .Lloop_8: |
| 84 | decl %ecx | 99 | decl %ecx |
| 85 | movq (%rsi),%r8 | 100 | movq (%rsi), %r8 |
| 86 | movq %r8,(%rdi) | 101 | movq %r8, (%rdi) |
| 87 | leaq 8(%rdi),%rdi | 102 | leaq 8(%rdi), %rdi |
| 88 | leaq 8(%rsi),%rsi | 103 | leaq 8(%rsi), %rsi |
| 89 | jnz .Lloop_8 | 104 | jnz .Lloop_8 |
| 90 | 105 | ||
| 91 | .Lhandle_7: | 106 | .Lhandle_7: |
| 92 | movl %edx,%ecx | 107 | movl %edx, %ecx |
| 93 | andl $7,%ecx | 108 | andl $7, %ecx |
| 94 | jz .Lende | 109 | jz .Lend |
| 110 | |||
| 95 | .p2align 4 | 111 | .p2align 4 |
| 96 | .Lloop_1: | 112 | .Lloop_1: |
| 97 | movb (%rsi),%r8b | 113 | movb (%rsi), %r8b |
| 98 | movb %r8b,(%rdi) | 114 | movb %r8b, (%rdi) |
| 99 | incq %rdi | 115 | incq %rdi |
| 100 | incq %rsi | 116 | incq %rsi |
| 101 | decl %ecx | 117 | decl %ecx |
| 102 | jnz .Lloop_1 | 118 | jnz .Lloop_1 |
| 103 | 119 | ||
| 104 | .Lende: | 120 | .Lend: |
| 105 | popq %rbx | ||
| 106 | CFI_ADJUST_CFA_OFFSET -8 | ||
| 107 | CFI_RESTORE rbx | ||
| 108 | ret | 121 | ret |
| 109 | .Lfinal: | ||
| 110 | CFI_ENDPROC | 122 | CFI_ENDPROC |
| 111 | ENDPROC(memcpy) | 123 | ENDPROC(memcpy) |
| 112 | ENDPROC(__memcpy) | 124 | ENDPROC(__memcpy) |
| 113 | 125 | ||
| 114 | /* Some CPUs run faster using the string copy instructions. | 126 | /* |
| 115 | It is also a lot simpler. Use this when possible */ | 127 | * Some CPUs run faster using the string copy instructions. |
| 128 | * It is also a lot simpler. Use this when possible: | ||
| 129 | */ | ||
| 116 | 130 | ||
| 117 | .section .altinstr_replacement,"ax" | 131 | .section .altinstr_replacement, "ax" |
| 118 | 1: .byte 0xeb /* jmp <disp8> */ | 132 | 1: .byte 0xeb /* jmp <disp8> */ |
| 119 | .byte (memcpy_c - memcpy) - (2f - 1b) /* offset */ | 133 | .byte (memcpy_c - memcpy) - (2f - 1b) /* offset */ |
| 120 | 2: | 134 | 2: |
| 121 | .previous | 135 | .previous |
| 122 | .section .altinstructions,"a" | 136 | |
| 137 | .section .altinstructions, "a" | ||
| 123 | .align 8 | 138 | .align 8 |
| 124 | .quad memcpy | 139 | .quad memcpy |
| 125 | .quad 1b | 140 | .quad 1b |
| 126 | .byte X86_FEATURE_REP_GOOD | 141 | .byte X86_FEATURE_REP_GOOD |
| 127 | /* Replace only beginning, memcpy is used to apply alternatives, so it | 142 | |
| 128 | * is silly to overwrite itself with nops - reboot is only outcome... */ | 143 | /* |
| 144 | * Replace only beginning, memcpy is used to apply alternatives, | ||
| 145 | * so it is silly to overwrite itself with nops - reboot is the | ||
| 146 | * only outcome... | ||
| 147 | */ | ||
| 129 | .byte 2b - 1b | 148 | .byte 2b - 1b |
| 130 | .byte 2b - 1b | 149 | .byte 2b - 1b |
| 131 | .previous | 150 | .previous |
diff --git a/arch/x86/mm/highmem_32.c b/arch/x86/mm/highmem_32.c index 00f127c80b0e..522db5e3d0bf 100644 --- a/arch/x86/mm/highmem_32.c +++ b/arch/x86/mm/highmem_32.c | |||
| @@ -121,22 +121,13 @@ void kunmap_atomic(void *kvaddr, enum km_type type) | |||
| 121 | pagefault_enable(); | 121 | pagefault_enable(); |
| 122 | } | 122 | } |
| 123 | 123 | ||
| 124 | /* This is the same as kmap_atomic() but can map memory that doesn't | 124 | /* |
| 125 | * This is the same as kmap_atomic() but can map memory that doesn't | ||
| 125 | * have a struct page associated with it. | 126 | * have a struct page associated with it. |
| 126 | */ | 127 | */ |
| 127 | void *kmap_atomic_pfn(unsigned long pfn, enum km_type type) | 128 | void *kmap_atomic_pfn(unsigned long pfn, enum km_type type) |
| 128 | { | 129 | { |
| 129 | enum fixed_addresses idx; | 130 | return kmap_atomic_prot_pfn(pfn, type, kmap_prot); |
| 130 | unsigned long vaddr; | ||
| 131 | |||
| 132 | pagefault_disable(); | ||
| 133 | |||
| 134 | idx = type + KM_TYPE_NR*smp_processor_id(); | ||
| 135 | vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx); | ||
| 136 | set_pte(kmap_pte-idx, pfn_pte(pfn, kmap_prot)); | ||
| 137 | arch_flush_lazy_mmu_mode(); | ||
| 138 | |||
| 139 | return (void*) vaddr; | ||
| 140 | } | 131 | } |
| 141 | EXPORT_SYMBOL_GPL(kmap_atomic_pfn); /* temporarily in use by i915 GEM until vmap */ | 132 | EXPORT_SYMBOL_GPL(kmap_atomic_pfn); /* temporarily in use by i915 GEM until vmap */ |
| 142 | 133 | ||
| @@ -158,7 +149,6 @@ EXPORT_SYMBOL(kunmap); | |||
| 158 | EXPORT_SYMBOL(kmap_atomic); | 149 | EXPORT_SYMBOL(kmap_atomic); |
| 159 | EXPORT_SYMBOL(kunmap_atomic); | 150 | EXPORT_SYMBOL(kunmap_atomic); |
| 160 | 151 | ||
| 161 | #ifdef CONFIG_NUMA | ||
| 162 | void __init set_highmem_pages_init(void) | 152 | void __init set_highmem_pages_init(void) |
| 163 | { | 153 | { |
| 164 | struct zone *zone; | 154 | struct zone *zone; |
| @@ -182,11 +172,3 @@ void __init set_highmem_pages_init(void) | |||
| 182 | } | 172 | } |
| 183 | totalram_pages += totalhigh_pages; | 173 | totalram_pages += totalhigh_pages; |
| 184 | } | 174 | } |
| 185 | #else | ||
| 186 | void __init set_highmem_pages_init(void) | ||
| 187 | { | ||
| 188 | add_highpages_with_active_regions(0, highstart_pfn, highend_pfn); | ||
| 189 | |||
| 190 | totalram_pages += totalhigh_pages; | ||
| 191 | } | ||
| 192 | #endif /* CONFIG_NUMA */ | ||
diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c index ce6a722587d8..fd3da1dda1c9 100644 --- a/arch/x86/mm/init.c +++ b/arch/x86/mm/init.c | |||
| @@ -1,8 +1,345 @@ | |||
| 1 | #include <linux/ioport.h> | ||
| 1 | #include <linux/swap.h> | 2 | #include <linux/swap.h> |
| 3 | |||
| 2 | #include <asm/cacheflush.h> | 4 | #include <asm/cacheflush.h> |
| 5 | #include <asm/e820.h> | ||
| 6 | #include <asm/init.h> | ||
| 3 | #include <asm/page.h> | 7 | #include <asm/page.h> |
| 8 | #include <asm/page_types.h> | ||
| 4 | #include <asm/sections.h> | 9 | #include <asm/sections.h> |
| 5 | #include <asm/system.h> | 10 | #include <asm/system.h> |
| 11 | #include <asm/tlbflush.h> | ||
| 12 | |||
| 13 | unsigned long __initdata e820_table_start; | ||
| 14 | unsigned long __meminitdata e820_table_end; | ||
| 15 | unsigned long __meminitdata e820_table_top; | ||
| 16 | |||
| 17 | int after_bootmem; | ||
| 18 | |||
| 19 | int direct_gbpages | ||
| 20 | #ifdef CONFIG_DIRECT_GBPAGES | ||
| 21 | = 1 | ||
| 22 | #endif | ||
| 23 | ; | ||
| 24 | |||
| 25 | static void __init find_early_table_space(unsigned long end, int use_pse, | ||
| 26 | int use_gbpages) | ||
| 27 | { | ||
| 28 | unsigned long puds, pmds, ptes, tables, start; | ||
| 29 | |||
| 30 | puds = (end + PUD_SIZE - 1) >> PUD_SHIFT; | ||
| 31 | tables = roundup(puds * sizeof(pud_t), PAGE_SIZE); | ||
| 32 | |||
| 33 | if (use_gbpages) { | ||
| 34 | unsigned long extra; | ||
| 35 | |||
| 36 | extra = end - ((end>>PUD_SHIFT) << PUD_SHIFT); | ||
| 37 | pmds = (extra + PMD_SIZE - 1) >> PMD_SHIFT; | ||
| 38 | } else | ||
| 39 | pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT; | ||
| 40 | |||
| 41 | tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE); | ||
| 42 | |||
| 43 | if (use_pse) { | ||
| 44 | unsigned long extra; | ||
| 45 | |||
| 46 | extra = end - ((end>>PMD_SHIFT) << PMD_SHIFT); | ||
| 47 | #ifdef CONFIG_X86_32 | ||
| 48 | extra += PMD_SIZE; | ||
| 49 | #endif | ||
| 50 | ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 51 | } else | ||
| 52 | ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 53 | |||
| 54 | tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE); | ||
| 55 | |||
| 56 | #ifdef CONFIG_X86_32 | ||
| 57 | /* for fixmap */ | ||
| 58 | tables += roundup(__end_of_fixed_addresses * sizeof(pte_t), PAGE_SIZE); | ||
| 59 | #endif | ||
| 60 | |||
| 61 | /* | ||
| 62 | * RED-PEN putting page tables only on node 0 could | ||
| 63 | * cause a hotspot and fill up ZONE_DMA. The page tables | ||
| 64 | * need roughly 0.5KB per GB. | ||
| 65 | */ | ||
| 66 | #ifdef CONFIG_X86_32 | ||
| 67 | start = 0x7000; | ||
| 68 | e820_table_start = find_e820_area(start, max_pfn_mapped<<PAGE_SHIFT, | ||
| 69 | tables, PAGE_SIZE); | ||
| 70 | #else /* CONFIG_X86_64 */ | ||
| 71 | start = 0x8000; | ||
| 72 | e820_table_start = find_e820_area(start, end, tables, PAGE_SIZE); | ||
| 73 | #endif | ||
| 74 | if (e820_table_start == -1UL) | ||
| 75 | panic("Cannot find space for the kernel page tables"); | ||
| 76 | |||
| 77 | e820_table_start >>= PAGE_SHIFT; | ||
| 78 | e820_table_end = e820_table_start; | ||
| 79 | e820_table_top = e820_table_start + (tables >> PAGE_SHIFT); | ||
| 80 | |||
| 81 | printk(KERN_DEBUG "kernel direct mapping tables up to %lx @ %lx-%lx\n", | ||
| 82 | end, e820_table_start << PAGE_SHIFT, e820_table_top << PAGE_SHIFT); | ||
| 83 | } | ||
| 84 | |||
| 85 | struct map_range { | ||
| 86 | unsigned long start; | ||
| 87 | unsigned long end; | ||
| 88 | unsigned page_size_mask; | ||
| 89 | }; | ||
| 90 | |||
| 91 | #ifdef CONFIG_X86_32 | ||
| 92 | #define NR_RANGE_MR 3 | ||
| 93 | #else /* CONFIG_X86_64 */ | ||
| 94 | #define NR_RANGE_MR 5 | ||
| 95 | #endif | ||
| 96 | |||
| 97 | static int __meminit save_mr(struct map_range *mr, int nr_range, | ||
| 98 | unsigned long start_pfn, unsigned long end_pfn, | ||
| 99 | unsigned long page_size_mask) | ||
| 100 | { | ||
| 101 | if (start_pfn < end_pfn) { | ||
| 102 | if (nr_range >= NR_RANGE_MR) | ||
| 103 | panic("run out of range for init_memory_mapping\n"); | ||
| 104 | mr[nr_range].start = start_pfn<<PAGE_SHIFT; | ||
| 105 | mr[nr_range].end = end_pfn<<PAGE_SHIFT; | ||
| 106 | mr[nr_range].page_size_mask = page_size_mask; | ||
| 107 | nr_range++; | ||
| 108 | } | ||
| 109 | |||
| 110 | return nr_range; | ||
| 111 | } | ||
| 112 | |||
| 113 | #ifdef CONFIG_X86_64 | ||
| 114 | static void __init init_gbpages(void) | ||
| 115 | { | ||
| 116 | if (direct_gbpages && cpu_has_gbpages) | ||
| 117 | printk(KERN_INFO "Using GB pages for direct mapping\n"); | ||
| 118 | else | ||
| 119 | direct_gbpages = 0; | ||
| 120 | } | ||
| 121 | #else | ||
| 122 | static inline void init_gbpages(void) | ||
| 123 | { | ||
| 124 | } | ||
| 125 | #endif | ||
| 126 | |||
| 127 | /* | ||
| 128 | * Setup the direct mapping of the physical memory at PAGE_OFFSET. | ||
| 129 | * This runs before bootmem is initialized and gets pages directly from | ||
| 130 | * the physical memory. To access them they are temporarily mapped. | ||
| 131 | */ | ||
| 132 | unsigned long __init_refok init_memory_mapping(unsigned long start, | ||
| 133 | unsigned long end) | ||
| 134 | { | ||
| 135 | unsigned long page_size_mask = 0; | ||
| 136 | unsigned long start_pfn, end_pfn; | ||
| 137 | unsigned long ret = 0; | ||
| 138 | unsigned long pos; | ||
| 139 | |||
| 140 | struct map_range mr[NR_RANGE_MR]; | ||
| 141 | int nr_range, i; | ||
| 142 | int use_pse, use_gbpages; | ||
| 143 | |||
| 144 | printk(KERN_INFO "init_memory_mapping: %016lx-%016lx\n", start, end); | ||
| 145 | |||
| 146 | if (!after_bootmem) | ||
| 147 | init_gbpages(); | ||
| 148 | |||
| 149 | #ifdef CONFIG_DEBUG_PAGEALLOC | ||
| 150 | /* | ||
| 151 | * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages. | ||
| 152 | * This will simplify cpa(), which otherwise needs to support splitting | ||
| 153 | * large pages into small in interrupt context, etc. | ||
| 154 | */ | ||
| 155 | use_pse = use_gbpages = 0; | ||
| 156 | #else | ||
| 157 | use_pse = cpu_has_pse; | ||
| 158 | use_gbpages = direct_gbpages; | ||
| 159 | #endif | ||
| 160 | |||
| 161 | #ifdef CONFIG_X86_32 | ||
| 162 | #ifdef CONFIG_X86_PAE | ||
| 163 | set_nx(); | ||
| 164 | if (nx_enabled) | ||
| 165 | printk(KERN_INFO "NX (Execute Disable) protection: active\n"); | ||
| 166 | #endif | ||
| 167 | |||
| 168 | /* Enable PSE if available */ | ||
| 169 | if (cpu_has_pse) | ||
| 170 | set_in_cr4(X86_CR4_PSE); | ||
| 171 | |||
| 172 | /* Enable PGE if available */ | ||
| 173 | if (cpu_has_pge) { | ||
| 174 | set_in_cr4(X86_CR4_PGE); | ||
| 175 | __supported_pte_mask |= _PAGE_GLOBAL; | ||
| 176 | } | ||
| 177 | #endif | ||
| 178 | |||
| 179 | if (use_gbpages) | ||
| 180 | page_size_mask |= 1 << PG_LEVEL_1G; | ||
| 181 | if (use_pse) | ||
| 182 | page_size_mask |= 1 << PG_LEVEL_2M; | ||
| 183 | |||
| 184 | memset(mr, 0, sizeof(mr)); | ||
| 185 | nr_range = 0; | ||
| 186 | |||
| 187 | /* head if not big page alignment ? */ | ||
| 188 | start_pfn = start >> PAGE_SHIFT; | ||
| 189 | pos = start_pfn << PAGE_SHIFT; | ||
| 190 | #ifdef CONFIG_X86_32 | ||
| 191 | /* | ||
| 192 | * Don't use a large page for the first 2/4MB of memory | ||
| 193 | * because there are often fixed size MTRRs in there | ||
| 194 | * and overlapping MTRRs into large pages can cause | ||
| 195 | * slowdowns. | ||
| 196 | */ | ||
| 197 | if (pos == 0) | ||
| 198 | end_pfn = 1<<(PMD_SHIFT - PAGE_SHIFT); | ||
| 199 | else | ||
| 200 | end_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 201 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 202 | #else /* CONFIG_X86_64 */ | ||
| 203 | end_pfn = ((pos + (PMD_SIZE - 1)) >> PMD_SHIFT) | ||
| 204 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 205 | #endif | ||
| 206 | if (end_pfn > (end >> PAGE_SHIFT)) | ||
| 207 | end_pfn = end >> PAGE_SHIFT; | ||
| 208 | if (start_pfn < end_pfn) { | ||
| 209 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0); | ||
| 210 | pos = end_pfn << PAGE_SHIFT; | ||
| 211 | } | ||
| 212 | |||
| 213 | /* big page (2M) range */ | ||
| 214 | start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 215 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 216 | #ifdef CONFIG_X86_32 | ||
| 217 | end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT); | ||
| 218 | #else /* CONFIG_X86_64 */ | ||
| 219 | end_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT) | ||
| 220 | << (PUD_SHIFT - PAGE_SHIFT); | ||
| 221 | if (end_pfn > ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT))) | ||
| 222 | end_pfn = ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT)); | ||
| 223 | #endif | ||
| 224 | |||
| 225 | if (start_pfn < end_pfn) { | ||
| 226 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 227 | page_size_mask & (1<<PG_LEVEL_2M)); | ||
| 228 | pos = end_pfn << PAGE_SHIFT; | ||
| 229 | } | ||
| 230 | |||
| 231 | #ifdef CONFIG_X86_64 | ||
| 232 | /* big page (1G) range */ | ||
| 233 | start_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT) | ||
| 234 | << (PUD_SHIFT - PAGE_SHIFT); | ||
| 235 | end_pfn = (end >> PUD_SHIFT) << (PUD_SHIFT - PAGE_SHIFT); | ||
| 236 | if (start_pfn < end_pfn) { | ||
| 237 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 238 | page_size_mask & | ||
| 239 | ((1<<PG_LEVEL_2M)|(1<<PG_LEVEL_1G))); | ||
| 240 | pos = end_pfn << PAGE_SHIFT; | ||
| 241 | } | ||
| 242 | |||
| 243 | /* tail is not big page (1G) alignment */ | ||
| 244 | start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 245 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 246 | end_pfn = (end >> PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT); | ||
| 247 | if (start_pfn < end_pfn) { | ||
| 248 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 249 | page_size_mask & (1<<PG_LEVEL_2M)); | ||
| 250 | pos = end_pfn << PAGE_SHIFT; | ||
| 251 | } | ||
| 252 | #endif | ||
| 253 | |||
| 254 | /* tail is not big page (2M) alignment */ | ||
| 255 | start_pfn = pos>>PAGE_SHIFT; | ||
| 256 | end_pfn = end>>PAGE_SHIFT; | ||
| 257 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0); | ||
| 258 | |||
| 259 | /* try to merge same page size and continuous */ | ||
| 260 | for (i = 0; nr_range > 1 && i < nr_range - 1; i++) { | ||
| 261 | unsigned long old_start; | ||
| 262 | if (mr[i].end != mr[i+1].start || | ||
| 263 | mr[i].page_size_mask != mr[i+1].page_size_mask) | ||
| 264 | continue; | ||
| 265 | /* move it */ | ||
| 266 | old_start = mr[i].start; | ||
| 267 | memmove(&mr[i], &mr[i+1], | ||
| 268 | (nr_range - 1 - i) * sizeof(struct map_range)); | ||
| 269 | mr[i--].start = old_start; | ||
| 270 | nr_range--; | ||
| 271 | } | ||
| 272 | |||
| 273 | for (i = 0; i < nr_range; i++) | ||
| 274 | printk(KERN_DEBUG " %010lx - %010lx page %s\n", | ||
| 275 | mr[i].start, mr[i].end, | ||
| 276 | (mr[i].page_size_mask & (1<<PG_LEVEL_1G))?"1G":( | ||
| 277 | (mr[i].page_size_mask & (1<<PG_LEVEL_2M))?"2M":"4k")); | ||
| 278 | |||
| 279 | /* | ||
| 280 | * Find space for the kernel direct mapping tables. | ||
| 281 | * | ||
| 282 | * Later we should allocate these tables in the local node of the | ||
| 283 | * memory mapped. Unfortunately this is done currently before the | ||
| 284 | * nodes are discovered. | ||
| 285 | */ | ||
| 286 | if (!after_bootmem) | ||
| 287 | find_early_table_space(end, use_pse, use_gbpages); | ||
| 288 | |||
| 289 | #ifdef CONFIG_X86_32 | ||
| 290 | for (i = 0; i < nr_range; i++) | ||
| 291 | kernel_physical_mapping_init(mr[i].start, mr[i].end, | ||
| 292 | mr[i].page_size_mask); | ||
| 293 | ret = end; | ||
| 294 | #else /* CONFIG_X86_64 */ | ||
| 295 | for (i = 0; i < nr_range; i++) | ||
| 296 | ret = kernel_physical_mapping_init(mr[i].start, mr[i].end, | ||
| 297 | mr[i].page_size_mask); | ||
| 298 | #endif | ||
| 299 | |||
| 300 | #ifdef CONFIG_X86_32 | ||
| 301 | early_ioremap_page_table_range_init(); | ||
| 302 | |||
| 303 | load_cr3(swapper_pg_dir); | ||
| 304 | #endif | ||
| 305 | |||
| 306 | #ifdef CONFIG_X86_64 | ||
| 307 | if (!after_bootmem) | ||
| 308 | mmu_cr4_features = read_cr4(); | ||
| 309 | #endif | ||
| 310 | __flush_tlb_all(); | ||
| 311 | |||
| 312 | if (!after_bootmem && e820_table_end > e820_table_start) | ||
| 313 | reserve_early(e820_table_start << PAGE_SHIFT, | ||
| 314 | e820_table_end << PAGE_SHIFT, "PGTABLE"); | ||
| 315 | |||
| 316 | if (!after_bootmem) | ||
| 317 | early_memtest(start, end); | ||
| 318 | |||
| 319 | return ret >> PAGE_SHIFT; | ||
| 320 | } | ||
| 321 | |||
| 322 | |||
| 323 | /* | ||
| 324 | * devmem_is_allowed() checks to see if /dev/mem access to a certain address | ||
| 325 | * is valid. The argument is a physical page number. | ||
| 326 | * | ||
| 327 | * | ||
| 328 | * On x86, access has to be given to the first megabyte of ram because that area | ||
| 329 | * contains bios code and data regions used by X and dosemu and similar apps. | ||
| 330 | * Access has to be given to non-kernel-ram areas as well, these contain the PCI | ||
| 331 | * mmio resources as well as potential bios/acpi data regions. | ||
| 332 | */ | ||
| 333 | int devmem_is_allowed(unsigned long pagenr) | ||
| 334 | { | ||
| 335 | if (pagenr <= 256) | ||
| 336 | return 1; | ||
| 337 | if (iomem_is_exclusive(pagenr << PAGE_SHIFT)) | ||
| 338 | return 0; | ||
| 339 | if (!page_is_ram(pagenr)) | ||
| 340 | return 1; | ||
| 341 | return 0; | ||
| 342 | } | ||
| 6 | 343 | ||
| 7 | void free_init_pages(char *what, unsigned long begin, unsigned long end) | 344 | void free_init_pages(char *what, unsigned long begin, unsigned long end) |
| 8 | { | 345 | { |
| @@ -47,3 +384,10 @@ void free_initmem(void) | |||
| 47 | (unsigned long)(&__init_begin), | 384 | (unsigned long)(&__init_begin), |
| 48 | (unsigned long)(&__init_end)); | 385 | (unsigned long)(&__init_end)); |
| 49 | } | 386 | } |
| 387 | |||
| 388 | #ifdef CONFIG_BLK_DEV_INITRD | ||
| 389 | void free_initrd_mem(unsigned long start, unsigned long end) | ||
| 390 | { | ||
| 391 | free_init_pages("initrd memory", start, end); | ||
| 392 | } | ||
| 393 | #endif | ||
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c index 47df0e1bbeb9..db81e9a8556b 100644 --- a/arch/x86/mm/init_32.c +++ b/arch/x86/mm/init_32.c | |||
| @@ -49,6 +49,7 @@ | |||
| 49 | #include <asm/paravirt.h> | 49 | #include <asm/paravirt.h> |
| 50 | #include <asm/setup.h> | 50 | #include <asm/setup.h> |
| 51 | #include <asm/cacheflush.h> | 51 | #include <asm/cacheflush.h> |
| 52 | #include <asm/init.h> | ||
| 52 | 53 | ||
| 53 | unsigned long max_low_pfn_mapped; | 54 | unsigned long max_low_pfn_mapped; |
| 54 | unsigned long max_pfn_mapped; | 55 | unsigned long max_pfn_mapped; |
| @@ -58,19 +59,14 @@ unsigned long highstart_pfn, highend_pfn; | |||
| 58 | 59 | ||
| 59 | static noinline int do_test_wp_bit(void); | 60 | static noinline int do_test_wp_bit(void); |
| 60 | 61 | ||
| 61 | 62 | bool __read_mostly __vmalloc_start_set = false; | |
| 62 | static unsigned long __initdata table_start; | ||
| 63 | static unsigned long __meminitdata table_end; | ||
| 64 | static unsigned long __meminitdata table_top; | ||
| 65 | |||
| 66 | static int __initdata after_init_bootmem; | ||
| 67 | 63 | ||
| 68 | static __init void *alloc_low_page(void) | 64 | static __init void *alloc_low_page(void) |
| 69 | { | 65 | { |
| 70 | unsigned long pfn = table_end++; | 66 | unsigned long pfn = e820_table_end++; |
| 71 | void *adr; | 67 | void *adr; |
| 72 | 68 | ||
| 73 | if (pfn >= table_top) | 69 | if (pfn >= e820_table_top) |
| 74 | panic("alloc_low_page: ran out of memory"); | 70 | panic("alloc_low_page: ran out of memory"); |
| 75 | 71 | ||
| 76 | adr = __va(pfn * PAGE_SIZE); | 72 | adr = __va(pfn * PAGE_SIZE); |
| @@ -90,7 +86,7 @@ static pmd_t * __init one_md_table_init(pgd_t *pgd) | |||
| 90 | 86 | ||
| 91 | #ifdef CONFIG_X86_PAE | 87 | #ifdef CONFIG_X86_PAE |
| 92 | if (!(pgd_val(*pgd) & _PAGE_PRESENT)) { | 88 | if (!(pgd_val(*pgd) & _PAGE_PRESENT)) { |
| 93 | if (after_init_bootmem) | 89 | if (after_bootmem) |
| 94 | pmd_table = (pmd_t *)alloc_bootmem_low_pages(PAGE_SIZE); | 90 | pmd_table = (pmd_t *)alloc_bootmem_low_pages(PAGE_SIZE); |
| 95 | else | 91 | else |
| 96 | pmd_table = (pmd_t *)alloc_low_page(); | 92 | pmd_table = (pmd_t *)alloc_low_page(); |
| @@ -117,7 +113,7 @@ static pte_t * __init one_page_table_init(pmd_t *pmd) | |||
| 117 | if (!(pmd_val(*pmd) & _PAGE_PRESENT)) { | 113 | if (!(pmd_val(*pmd) & _PAGE_PRESENT)) { |
| 118 | pte_t *page_table = NULL; | 114 | pte_t *page_table = NULL; |
| 119 | 115 | ||
| 120 | if (after_init_bootmem) { | 116 | if (after_bootmem) { |
| 121 | #ifdef CONFIG_DEBUG_PAGEALLOC | 117 | #ifdef CONFIG_DEBUG_PAGEALLOC |
| 122 | page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE); | 118 | page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE); |
| 123 | #endif | 119 | #endif |
| @@ -168,12 +164,12 @@ static pte_t *__init page_table_kmap_check(pte_t *pte, pmd_t *pmd, | |||
| 168 | if (pmd_idx_kmap_begin != pmd_idx_kmap_end | 164 | if (pmd_idx_kmap_begin != pmd_idx_kmap_end |
| 169 | && (vaddr >> PMD_SHIFT) >= pmd_idx_kmap_begin | 165 | && (vaddr >> PMD_SHIFT) >= pmd_idx_kmap_begin |
| 170 | && (vaddr >> PMD_SHIFT) <= pmd_idx_kmap_end | 166 | && (vaddr >> PMD_SHIFT) <= pmd_idx_kmap_end |
| 171 | && ((__pa(pte) >> PAGE_SHIFT) < table_start | 167 | && ((__pa(pte) >> PAGE_SHIFT) < e820_table_start |
| 172 | || (__pa(pte) >> PAGE_SHIFT) >= table_end)) { | 168 | || (__pa(pte) >> PAGE_SHIFT) >= e820_table_end)) { |
| 173 | pte_t *newpte; | 169 | pte_t *newpte; |
| 174 | int i; | 170 | int i; |
| 175 | 171 | ||
| 176 | BUG_ON(after_init_bootmem); | 172 | BUG_ON(after_bootmem); |
| 177 | newpte = alloc_low_page(); | 173 | newpte = alloc_low_page(); |
| 178 | for (i = 0; i < PTRS_PER_PTE; i++) | 174 | for (i = 0; i < PTRS_PER_PTE; i++) |
| 179 | set_pte(newpte + i, pte[i]); | 175 | set_pte(newpte + i, pte[i]); |
| @@ -242,11 +238,14 @@ static inline int is_kernel_text(unsigned long addr) | |||
| 242 | * of max_low_pfn pages, by creating page tables starting from address | 238 | * of max_low_pfn pages, by creating page tables starting from address |
| 243 | * PAGE_OFFSET: | 239 | * PAGE_OFFSET: |
| 244 | */ | 240 | */ |
| 245 | static void __init kernel_physical_mapping_init(pgd_t *pgd_base, | 241 | unsigned long __init |
| 246 | unsigned long start_pfn, | 242 | kernel_physical_mapping_init(unsigned long start, |
| 247 | unsigned long end_pfn, | 243 | unsigned long end, |
| 248 | int use_pse) | 244 | unsigned long page_size_mask) |
| 249 | { | 245 | { |
| 246 | int use_pse = page_size_mask == (1<<PG_LEVEL_2M); | ||
| 247 | unsigned long start_pfn, end_pfn; | ||
| 248 | pgd_t *pgd_base = swapper_pg_dir; | ||
| 250 | int pgd_idx, pmd_idx, pte_ofs; | 249 | int pgd_idx, pmd_idx, pte_ofs; |
| 251 | unsigned long pfn; | 250 | unsigned long pfn; |
| 252 | pgd_t *pgd; | 251 | pgd_t *pgd; |
| @@ -255,6 +254,9 @@ static void __init kernel_physical_mapping_init(pgd_t *pgd_base, | |||
| 255 | unsigned pages_2m, pages_4k; | 254 | unsigned pages_2m, pages_4k; |
| 256 | int mapping_iter; | 255 | int mapping_iter; |
| 257 | 256 | ||
| 257 | start_pfn = start >> PAGE_SHIFT; | ||
| 258 | end_pfn = end >> PAGE_SHIFT; | ||
| 259 | |||
| 258 | /* | 260 | /* |
| 259 | * First iteration will setup identity mapping using large/small pages | 261 | * First iteration will setup identity mapping using large/small pages |
| 260 | * based on use_pse, with other attributes same as set by | 262 | * based on use_pse, with other attributes same as set by |
| @@ -369,26 +371,6 @@ repeat: | |||
| 369 | mapping_iter = 2; | 371 | mapping_iter = 2; |
| 370 | goto repeat; | 372 | goto repeat; |
| 371 | } | 373 | } |
| 372 | } | ||
| 373 | |||
| 374 | /* | ||
| 375 | * devmem_is_allowed() checks to see if /dev/mem access to a certain address | ||
| 376 | * is valid. The argument is a physical page number. | ||
| 377 | * | ||
| 378 | * | ||
| 379 | * On x86, access has to be given to the first megabyte of ram because that area | ||
| 380 | * contains bios code and data regions used by X and dosemu and similar apps. | ||
| 381 | * Access has to be given to non-kernel-ram areas as well, these contain the PCI | ||
| 382 | * mmio resources as well as potential bios/acpi data regions. | ||
| 383 | */ | ||
| 384 | int devmem_is_allowed(unsigned long pagenr) | ||
| 385 | { | ||
| 386 | if (pagenr <= 256) | ||
| 387 | return 1; | ||
| 388 | if (iomem_is_exclusive(pagenr << PAGE_SHIFT)) | ||
| 389 | return 0; | ||
| 390 | if (!page_is_ram(pagenr)) | ||
| 391 | return 1; | ||
| 392 | return 0; | 374 | return 0; |
| 393 | } | 375 | } |
| 394 | 376 | ||
| @@ -545,8 +527,9 @@ void __init native_pagetable_setup_done(pgd_t *base) | |||
| 545 | * be partially populated, and so it avoids stomping on any existing | 527 | * be partially populated, and so it avoids stomping on any existing |
| 546 | * mappings. | 528 | * mappings. |
| 547 | */ | 529 | */ |
| 548 | static void __init early_ioremap_page_table_range_init(pgd_t *pgd_base) | 530 | void __init early_ioremap_page_table_range_init(void) |
| 549 | { | 531 | { |
| 532 | pgd_t *pgd_base = swapper_pg_dir; | ||
| 550 | unsigned long vaddr, end; | 533 | unsigned long vaddr, end; |
| 551 | 534 | ||
| 552 | /* | 535 | /* |
| @@ -641,7 +624,7 @@ static int __init noexec_setup(char *str) | |||
| 641 | } | 624 | } |
| 642 | early_param("noexec", noexec_setup); | 625 | early_param("noexec", noexec_setup); |
| 643 | 626 | ||
| 644 | static void __init set_nx(void) | 627 | void __init set_nx(void) |
| 645 | { | 628 | { |
| 646 | unsigned int v[4], l, h; | 629 | unsigned int v[4], l, h; |
| 647 | 630 | ||
| @@ -793,6 +776,8 @@ void __init initmem_init(unsigned long start_pfn, | |||
| 793 | #ifdef CONFIG_FLATMEM | 776 | #ifdef CONFIG_FLATMEM |
| 794 | max_mapnr = num_physpages; | 777 | max_mapnr = num_physpages; |
| 795 | #endif | 778 | #endif |
| 779 | __vmalloc_start_set = true; | ||
| 780 | |||
| 796 | printk(KERN_NOTICE "%ldMB LOWMEM available.\n", | 781 | printk(KERN_NOTICE "%ldMB LOWMEM available.\n", |
| 797 | pages_to_mb(max_low_pfn)); | 782 | pages_to_mb(max_low_pfn)); |
| 798 | 783 | ||
| @@ -814,176 +799,66 @@ static void __init zone_sizes_init(void) | |||
| 814 | free_area_init_nodes(max_zone_pfns); | 799 | free_area_init_nodes(max_zone_pfns); |
| 815 | } | 800 | } |
| 816 | 801 | ||
| 802 | static unsigned long __init setup_node_bootmem(int nodeid, | ||
| 803 | unsigned long start_pfn, | ||
| 804 | unsigned long end_pfn, | ||
| 805 | unsigned long bootmap) | ||
| 806 | { | ||
| 807 | unsigned long bootmap_size; | ||
| 808 | |||
| 809 | /* don't touch min_low_pfn */ | ||
| 810 | bootmap_size = init_bootmem_node(NODE_DATA(nodeid), | ||
| 811 | bootmap >> PAGE_SHIFT, | ||
| 812 | start_pfn, end_pfn); | ||
| 813 | printk(KERN_INFO " node %d low ram: %08lx - %08lx\n", | ||
| 814 | nodeid, start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT); | ||
| 815 | printk(KERN_INFO " node %d bootmap %08lx - %08lx\n", | ||
| 816 | nodeid, bootmap, bootmap + bootmap_size); | ||
| 817 | free_bootmem_with_active_regions(nodeid, end_pfn); | ||
| 818 | early_res_to_bootmem(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT); | ||
| 819 | |||
| 820 | return bootmap + bootmap_size; | ||
| 821 | } | ||
| 822 | |||
| 817 | void __init setup_bootmem_allocator(void) | 823 | void __init setup_bootmem_allocator(void) |
| 818 | { | 824 | { |
| 819 | int i; | 825 | int nodeid; |
| 820 | unsigned long bootmap_size, bootmap; | 826 | unsigned long bootmap_size, bootmap; |
| 821 | /* | 827 | /* |
| 822 | * Initialize the boot-time allocator (with low memory only): | 828 | * Initialize the boot-time allocator (with low memory only): |
| 823 | */ | 829 | */ |
| 824 | bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT; | 830 | bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT; |
| 825 | bootmap = find_e820_area(min_low_pfn<<PAGE_SHIFT, | 831 | bootmap = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, bootmap_size, |
| 826 | max_pfn_mapped<<PAGE_SHIFT, bootmap_size, | ||
| 827 | PAGE_SIZE); | 832 | PAGE_SIZE); |
| 828 | if (bootmap == -1L) | 833 | if (bootmap == -1L) |
| 829 | panic("Cannot find bootmem map of size %ld\n", bootmap_size); | 834 | panic("Cannot find bootmem map of size %ld\n", bootmap_size); |
| 830 | reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP"); | 835 | reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP"); |
| 831 | 836 | ||
| 832 | /* don't touch min_low_pfn */ | ||
| 833 | bootmap_size = init_bootmem_node(NODE_DATA(0), bootmap >> PAGE_SHIFT, | ||
| 834 | min_low_pfn, max_low_pfn); | ||
| 835 | printk(KERN_INFO " mapped low ram: 0 - %08lx\n", | 837 | printk(KERN_INFO " mapped low ram: 0 - %08lx\n", |
| 836 | max_pfn_mapped<<PAGE_SHIFT); | 838 | max_pfn_mapped<<PAGE_SHIFT); |
| 837 | printk(KERN_INFO " low ram: %08lx - %08lx\n", | 839 | printk(KERN_INFO " low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT); |
| 838 | min_low_pfn<<PAGE_SHIFT, max_low_pfn<<PAGE_SHIFT); | ||
| 839 | printk(KERN_INFO " bootmap %08lx - %08lx\n", | ||
| 840 | bootmap, bootmap + bootmap_size); | ||
| 841 | for_each_online_node(i) | ||
| 842 | free_bootmem_with_active_regions(i, max_low_pfn); | ||
| 843 | early_res_to_bootmem(0, max_low_pfn<<PAGE_SHIFT); | ||
| 844 | |||
| 845 | after_init_bootmem = 1; | ||
| 846 | } | ||
| 847 | |||
| 848 | static void __init find_early_table_space(unsigned long end, int use_pse) | ||
| 849 | { | ||
| 850 | unsigned long puds, pmds, ptes, tables, start; | ||
| 851 | 840 | ||
| 852 | puds = (end + PUD_SIZE - 1) >> PUD_SHIFT; | 841 | for_each_online_node(nodeid) { |
| 853 | tables = roundup(puds * sizeof(pud_t), PAGE_SIZE); | 842 | unsigned long start_pfn, end_pfn; |
| 854 | 843 | ||
| 855 | pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT; | 844 | #ifdef CONFIG_NEED_MULTIPLE_NODES |
| 856 | tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE); | 845 | start_pfn = node_start_pfn[nodeid]; |
| 857 | 846 | end_pfn = node_end_pfn[nodeid]; | |
| 858 | if (use_pse) { | 847 | if (start_pfn > max_low_pfn) |
| 859 | unsigned long extra; | 848 | continue; |
| 860 | 849 | if (end_pfn > max_low_pfn) | |
| 861 | extra = end - ((end>>PMD_SHIFT) << PMD_SHIFT); | 850 | end_pfn = max_low_pfn; |
| 862 | extra += PMD_SIZE; | ||
| 863 | ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 864 | } else | ||
| 865 | ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 866 | |||
| 867 | tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE); | ||
| 868 | |||
| 869 | /* for fixmap */ | ||
| 870 | tables += roundup(__end_of_fixed_addresses * sizeof(pte_t), PAGE_SIZE); | ||
| 871 | |||
| 872 | /* | ||
| 873 | * RED-PEN putting page tables only on node 0 could | ||
| 874 | * cause a hotspot and fill up ZONE_DMA. The page tables | ||
| 875 | * need roughly 0.5KB per GB. | ||
| 876 | */ | ||
| 877 | start = 0x7000; | ||
| 878 | table_start = find_e820_area(start, max_pfn_mapped<<PAGE_SHIFT, | ||
| 879 | tables, PAGE_SIZE); | ||
| 880 | if (table_start == -1UL) | ||
| 881 | panic("Cannot find space for the kernel page tables"); | ||
| 882 | |||
| 883 | table_start >>= PAGE_SHIFT; | ||
| 884 | table_end = table_start; | ||
| 885 | table_top = table_start + (tables>>PAGE_SHIFT); | ||
| 886 | |||
| 887 | printk(KERN_DEBUG "kernel direct mapping tables up to %lx @ %lx-%lx\n", | ||
| 888 | end, table_start << PAGE_SHIFT, | ||
| 889 | (table_start << PAGE_SHIFT) + tables); | ||
| 890 | } | ||
| 891 | |||
| 892 | unsigned long __init_refok init_memory_mapping(unsigned long start, | ||
| 893 | unsigned long end) | ||
| 894 | { | ||
| 895 | pgd_t *pgd_base = swapper_pg_dir; | ||
| 896 | unsigned long start_pfn, end_pfn; | ||
| 897 | unsigned long big_page_start; | ||
| 898 | #ifdef CONFIG_DEBUG_PAGEALLOC | ||
| 899 | /* | ||
| 900 | * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages. | ||
| 901 | * This will simplify cpa(), which otherwise needs to support splitting | ||
| 902 | * large pages into small in interrupt context, etc. | ||
| 903 | */ | ||
| 904 | int use_pse = 0; | ||
| 905 | #else | 851 | #else |
| 906 | int use_pse = cpu_has_pse; | 852 | start_pfn = 0; |
| 853 | end_pfn = max_low_pfn; | ||
| 907 | #endif | 854 | #endif |
| 908 | 855 | bootmap = setup_node_bootmem(nodeid, start_pfn, end_pfn, | |
| 909 | /* | 856 | bootmap); |
| 910 | * Find space for the kernel direct mapping tables. | ||
| 911 | */ | ||
| 912 | if (!after_init_bootmem) | ||
| 913 | find_early_table_space(end, use_pse); | ||
| 914 | |||
| 915 | #ifdef CONFIG_X86_PAE | ||
| 916 | set_nx(); | ||
| 917 | if (nx_enabled) | ||
| 918 | printk(KERN_INFO "NX (Execute Disable) protection: active\n"); | ||
| 919 | #endif | ||
| 920 | |||
| 921 | /* Enable PSE if available */ | ||
| 922 | if (cpu_has_pse) | ||
| 923 | set_in_cr4(X86_CR4_PSE); | ||
| 924 | |||
| 925 | /* Enable PGE if available */ | ||
| 926 | if (cpu_has_pge) { | ||
| 927 | set_in_cr4(X86_CR4_PGE); | ||
| 928 | __supported_pte_mask |= _PAGE_GLOBAL; | ||
| 929 | } | ||
| 930 | |||
| 931 | /* | ||
| 932 | * Don't use a large page for the first 2/4MB of memory | ||
| 933 | * because there are often fixed size MTRRs in there | ||
| 934 | * and overlapping MTRRs into large pages can cause | ||
| 935 | * slowdowns. | ||
| 936 | */ | ||
| 937 | big_page_start = PMD_SIZE; | ||
| 938 | |||
| 939 | if (start < big_page_start) { | ||
| 940 | start_pfn = start >> PAGE_SHIFT; | ||
| 941 | end_pfn = min(big_page_start>>PAGE_SHIFT, end>>PAGE_SHIFT); | ||
| 942 | } else { | ||
| 943 | /* head is not big page alignment ? */ | ||
| 944 | start_pfn = start >> PAGE_SHIFT; | ||
| 945 | end_pfn = ((start + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 946 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 947 | } | 857 | } |
| 948 | if (start_pfn < end_pfn) | ||
| 949 | kernel_physical_mapping_init(pgd_base, start_pfn, end_pfn, 0); | ||
| 950 | |||
| 951 | /* big page range */ | ||
| 952 | start_pfn = ((start + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 953 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 954 | if (start_pfn < (big_page_start >> PAGE_SHIFT)) | ||
| 955 | start_pfn = big_page_start >> PAGE_SHIFT; | ||
| 956 | end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT); | ||
| 957 | if (start_pfn < end_pfn) | ||
| 958 | kernel_physical_mapping_init(pgd_base, start_pfn, end_pfn, | ||
| 959 | use_pse); | ||
| 960 | |||
| 961 | /* tail is not big page alignment ? */ | ||
| 962 | start_pfn = end_pfn; | ||
| 963 | if (start_pfn > (big_page_start>>PAGE_SHIFT)) { | ||
| 964 | end_pfn = end >> PAGE_SHIFT; | ||
| 965 | if (start_pfn < end_pfn) | ||
| 966 | kernel_physical_mapping_init(pgd_base, start_pfn, | ||
| 967 | end_pfn, 0); | ||
| 968 | } | ||
| 969 | |||
| 970 | early_ioremap_page_table_range_init(pgd_base); | ||
| 971 | 858 | ||
| 972 | load_cr3(swapper_pg_dir); | 859 | after_bootmem = 1; |
| 973 | |||
| 974 | __flush_tlb_all(); | ||
| 975 | |||
| 976 | if (!after_init_bootmem) | ||
| 977 | reserve_early(table_start << PAGE_SHIFT, | ||
| 978 | table_end << PAGE_SHIFT, "PGTABLE"); | ||
| 979 | |||
| 980 | if (!after_init_bootmem) | ||
| 981 | early_memtest(start, end); | ||
| 982 | |||
| 983 | return end >> PAGE_SHIFT; | ||
| 984 | } | 860 | } |
| 985 | 861 | ||
| 986 | |||
| 987 | /* | 862 | /* |
| 988 | * paging_init() sets up the page tables - note that the first 8MB are | 863 | * paging_init() sets up the page tables - note that the first 8MB are |
| 989 | * already mapped by head.S. | 864 | * already mapped by head.S. |
| @@ -1217,13 +1092,6 @@ void mark_rodata_ro(void) | |||
| 1217 | } | 1092 | } |
| 1218 | #endif | 1093 | #endif |
| 1219 | 1094 | ||
| 1220 | #ifdef CONFIG_BLK_DEV_INITRD | ||
| 1221 | void free_initrd_mem(unsigned long start, unsigned long end) | ||
| 1222 | { | ||
| 1223 | free_init_pages("initrd memory", start, end); | ||
| 1224 | } | ||
| 1225 | #endif | ||
| 1226 | |||
| 1227 | int __init reserve_bootmem_generic(unsigned long phys, unsigned long len, | 1095 | int __init reserve_bootmem_generic(unsigned long phys, unsigned long len, |
| 1228 | int flags) | 1096 | int flags) |
| 1229 | { | 1097 | { |
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c index 07f44d491df1..54efa57d1c03 100644 --- a/arch/x86/mm/init_64.c +++ b/arch/x86/mm/init_64.c | |||
| @@ -48,6 +48,7 @@ | |||
| 48 | #include <asm/kdebug.h> | 48 | #include <asm/kdebug.h> |
| 49 | #include <asm/numa.h> | 49 | #include <asm/numa.h> |
| 50 | #include <asm/cacheflush.h> | 50 | #include <asm/cacheflush.h> |
| 51 | #include <asm/init.h> | ||
| 51 | 52 | ||
| 52 | /* | 53 | /* |
| 53 | * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries. | 54 | * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries. |
| @@ -61,12 +62,6 @@ static unsigned long dma_reserve __initdata; | |||
| 61 | 62 | ||
| 62 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); | 63 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); |
| 63 | 64 | ||
| 64 | int direct_gbpages | ||
| 65 | #ifdef CONFIG_DIRECT_GBPAGES | ||
| 66 | = 1 | ||
| 67 | #endif | ||
| 68 | ; | ||
| 69 | |||
| 70 | static int __init parse_direct_gbpages_off(char *arg) | 65 | static int __init parse_direct_gbpages_off(char *arg) |
| 71 | { | 66 | { |
| 72 | direct_gbpages = 0; | 67 | direct_gbpages = 0; |
| @@ -87,12 +82,10 @@ early_param("gbpages", parse_direct_gbpages_on); | |||
| 87 | * around without checking the pgd every time. | 82 | * around without checking the pgd every time. |
| 88 | */ | 83 | */ |
| 89 | 84 | ||
| 90 | int after_bootmem; | ||
| 91 | |||
| 92 | pteval_t __supported_pte_mask __read_mostly = ~_PAGE_IOMAP; | 85 | pteval_t __supported_pte_mask __read_mostly = ~_PAGE_IOMAP; |
| 93 | EXPORT_SYMBOL_GPL(__supported_pte_mask); | 86 | EXPORT_SYMBOL_GPL(__supported_pte_mask); |
| 94 | 87 | ||
| 95 | static int do_not_nx __cpuinitdata; | 88 | static int disable_nx __cpuinitdata; |
| 96 | 89 | ||
| 97 | /* | 90 | /* |
| 98 | * noexec=on|off | 91 | * noexec=on|off |
| @@ -107,9 +100,9 @@ static int __init nonx_setup(char *str) | |||
| 107 | return -EINVAL; | 100 | return -EINVAL; |
| 108 | if (!strncmp(str, "on", 2)) { | 101 | if (!strncmp(str, "on", 2)) { |
| 109 | __supported_pte_mask |= _PAGE_NX; | 102 | __supported_pte_mask |= _PAGE_NX; |
| 110 | do_not_nx = 0; | 103 | disable_nx = 0; |
| 111 | } else if (!strncmp(str, "off", 3)) { | 104 | } else if (!strncmp(str, "off", 3)) { |
| 112 | do_not_nx = 1; | 105 | disable_nx = 1; |
| 113 | __supported_pte_mask &= ~_PAGE_NX; | 106 | __supported_pte_mask &= ~_PAGE_NX; |
| 114 | } | 107 | } |
| 115 | return 0; | 108 | return 0; |
| @@ -121,7 +114,7 @@ void __cpuinit check_efer(void) | |||
| 121 | unsigned long efer; | 114 | unsigned long efer; |
| 122 | 115 | ||
| 123 | rdmsrl(MSR_EFER, efer); | 116 | rdmsrl(MSR_EFER, efer); |
| 124 | if (!(efer & EFER_NX) || do_not_nx) | 117 | if (!(efer & EFER_NX) || disable_nx) |
| 125 | __supported_pte_mask &= ~_PAGE_NX; | 118 | __supported_pte_mask &= ~_PAGE_NX; |
| 126 | } | 119 | } |
| 127 | 120 | ||
| @@ -325,13 +318,9 @@ void __init cleanup_highmap(void) | |||
| 325 | } | 318 | } |
| 326 | } | 319 | } |
| 327 | 320 | ||
| 328 | static unsigned long __initdata table_start; | ||
| 329 | static unsigned long __meminitdata table_end; | ||
| 330 | static unsigned long __meminitdata table_top; | ||
| 331 | |||
| 332 | static __ref void *alloc_low_page(unsigned long *phys) | 321 | static __ref void *alloc_low_page(unsigned long *phys) |
| 333 | { | 322 | { |
| 334 | unsigned long pfn = table_end++; | 323 | unsigned long pfn = e820_table_end++; |
| 335 | void *adr; | 324 | void *adr; |
| 336 | 325 | ||
| 337 | if (after_bootmem) { | 326 | if (after_bootmem) { |
| @@ -341,7 +330,7 @@ static __ref void *alloc_low_page(unsigned long *phys) | |||
| 341 | return adr; | 330 | return adr; |
| 342 | } | 331 | } |
| 343 | 332 | ||
| 344 | if (pfn >= table_top) | 333 | if (pfn >= e820_table_top) |
| 345 | panic("alloc_low_page: ran out of memory"); | 334 | panic("alloc_low_page: ran out of memory"); |
| 346 | 335 | ||
| 347 | adr = early_memremap(pfn * PAGE_SIZE, PAGE_SIZE); | 336 | adr = early_memremap(pfn * PAGE_SIZE, PAGE_SIZE); |
| @@ -581,58 +570,10 @@ phys_pud_update(pgd_t *pgd, unsigned long addr, unsigned long end, | |||
| 581 | return phys_pud_init(pud, addr, end, page_size_mask); | 570 | return phys_pud_init(pud, addr, end, page_size_mask); |
| 582 | } | 571 | } |
| 583 | 572 | ||
| 584 | static void __init find_early_table_space(unsigned long end, int use_pse, | 573 | unsigned long __init |
| 585 | int use_gbpages) | 574 | kernel_physical_mapping_init(unsigned long start, |
| 586 | { | 575 | unsigned long end, |
| 587 | unsigned long puds, pmds, ptes, tables, start; | 576 | unsigned long page_size_mask) |
| 588 | |||
| 589 | puds = (end + PUD_SIZE - 1) >> PUD_SHIFT; | ||
| 590 | tables = roundup(puds * sizeof(pud_t), PAGE_SIZE); | ||
| 591 | if (use_gbpages) { | ||
| 592 | unsigned long extra; | ||
| 593 | extra = end - ((end>>PUD_SHIFT) << PUD_SHIFT); | ||
| 594 | pmds = (extra + PMD_SIZE - 1) >> PMD_SHIFT; | ||
| 595 | } else | ||
| 596 | pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT; | ||
| 597 | tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE); | ||
| 598 | |||
| 599 | if (use_pse) { | ||
| 600 | unsigned long extra; | ||
| 601 | extra = end - ((end>>PMD_SHIFT) << PMD_SHIFT); | ||
| 602 | ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 603 | } else | ||
| 604 | ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT; | ||
| 605 | tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE); | ||
| 606 | |||
| 607 | /* | ||
| 608 | * RED-PEN putting page tables only on node 0 could | ||
| 609 | * cause a hotspot and fill up ZONE_DMA. The page tables | ||
| 610 | * need roughly 0.5KB per GB. | ||
| 611 | */ | ||
| 612 | start = 0x8000; | ||
| 613 | table_start = find_e820_area(start, end, tables, PAGE_SIZE); | ||
| 614 | if (table_start == -1UL) | ||
| 615 | panic("Cannot find space for the kernel page tables"); | ||
| 616 | |||
| 617 | table_start >>= PAGE_SHIFT; | ||
| 618 | table_end = table_start; | ||
| 619 | table_top = table_start + (tables >> PAGE_SHIFT); | ||
| 620 | |||
| 621 | printk(KERN_DEBUG "kernel direct mapping tables up to %lx @ %lx-%lx\n", | ||
| 622 | end, table_start << PAGE_SHIFT, table_top << PAGE_SHIFT); | ||
| 623 | } | ||
| 624 | |||
| 625 | static void __init init_gbpages(void) | ||
| 626 | { | ||
| 627 | if (direct_gbpages && cpu_has_gbpages) | ||
| 628 | printk(KERN_INFO "Using GB pages for direct mapping\n"); | ||
| 629 | else | ||
| 630 | direct_gbpages = 0; | ||
| 631 | } | ||
| 632 | |||
| 633 | static unsigned long __meminit kernel_physical_mapping_init(unsigned long start, | ||
| 634 | unsigned long end, | ||
| 635 | unsigned long page_size_mask) | ||
| 636 | { | 577 | { |
| 637 | 578 | ||
| 638 | unsigned long next, last_map_addr = end; | 579 | unsigned long next, last_map_addr = end; |
| @@ -669,176 +610,6 @@ static unsigned long __meminit kernel_physical_mapping_init(unsigned long start, | |||
| 669 | return last_map_addr; | 610 | return last_map_addr; |
| 670 | } | 611 | } |
| 671 | 612 | ||
| 672 | struct map_range { | ||
| 673 | unsigned long start; | ||
| 674 | unsigned long end; | ||
| 675 | unsigned page_size_mask; | ||
| 676 | }; | ||
| 677 | |||
| 678 | #define NR_RANGE_MR 5 | ||
| 679 | |||
| 680 | static int save_mr(struct map_range *mr, int nr_range, | ||
| 681 | unsigned long start_pfn, unsigned long end_pfn, | ||
| 682 | unsigned long page_size_mask) | ||
| 683 | { | ||
| 684 | |||
| 685 | if (start_pfn < end_pfn) { | ||
| 686 | if (nr_range >= NR_RANGE_MR) | ||
| 687 | panic("run out of range for init_memory_mapping\n"); | ||
| 688 | mr[nr_range].start = start_pfn<<PAGE_SHIFT; | ||
| 689 | mr[nr_range].end = end_pfn<<PAGE_SHIFT; | ||
| 690 | mr[nr_range].page_size_mask = page_size_mask; | ||
| 691 | nr_range++; | ||
| 692 | } | ||
| 693 | |||
| 694 | return nr_range; | ||
| 695 | } | ||
| 696 | |||
| 697 | /* | ||
| 698 | * Setup the direct mapping of the physical memory at PAGE_OFFSET. | ||
| 699 | * This runs before bootmem is initialized and gets pages directly from | ||
| 700 | * the physical memory. To access them they are temporarily mapped. | ||
| 701 | */ | ||
| 702 | unsigned long __init_refok init_memory_mapping(unsigned long start, | ||
| 703 | unsigned long end) | ||
| 704 | { | ||
| 705 | unsigned long last_map_addr = 0; | ||
| 706 | unsigned long page_size_mask = 0; | ||
| 707 | unsigned long start_pfn, end_pfn; | ||
| 708 | unsigned long pos; | ||
| 709 | |||
| 710 | struct map_range mr[NR_RANGE_MR]; | ||
| 711 | int nr_range, i; | ||
| 712 | int use_pse, use_gbpages; | ||
| 713 | |||
| 714 | printk(KERN_INFO "init_memory_mapping: %016lx-%016lx\n", start, end); | ||
| 715 | |||
| 716 | /* | ||
| 717 | * Find space for the kernel direct mapping tables. | ||
| 718 | * | ||
| 719 | * Later we should allocate these tables in the local node of the | ||
| 720 | * memory mapped. Unfortunately this is done currently before the | ||
| 721 | * nodes are discovered. | ||
| 722 | */ | ||
| 723 | if (!after_bootmem) | ||
| 724 | init_gbpages(); | ||
| 725 | |||
| 726 | #ifdef CONFIG_DEBUG_PAGEALLOC | ||
| 727 | /* | ||
| 728 | * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages. | ||
| 729 | * This will simplify cpa(), which otherwise needs to support splitting | ||
| 730 | * large pages into small in interrupt context, etc. | ||
| 731 | */ | ||
| 732 | use_pse = use_gbpages = 0; | ||
| 733 | #else | ||
| 734 | use_pse = cpu_has_pse; | ||
| 735 | use_gbpages = direct_gbpages; | ||
| 736 | #endif | ||
| 737 | |||
| 738 | if (use_gbpages) | ||
| 739 | page_size_mask |= 1 << PG_LEVEL_1G; | ||
| 740 | if (use_pse) | ||
| 741 | page_size_mask |= 1 << PG_LEVEL_2M; | ||
| 742 | |||
| 743 | memset(mr, 0, sizeof(mr)); | ||
| 744 | nr_range = 0; | ||
| 745 | |||
| 746 | /* head if not big page alignment ?*/ | ||
| 747 | start_pfn = start >> PAGE_SHIFT; | ||
| 748 | pos = start_pfn << PAGE_SHIFT; | ||
| 749 | end_pfn = ((pos + (PMD_SIZE - 1)) >> PMD_SHIFT) | ||
| 750 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 751 | if (end_pfn > (end >> PAGE_SHIFT)) | ||
| 752 | end_pfn = end >> PAGE_SHIFT; | ||
| 753 | if (start_pfn < end_pfn) { | ||
| 754 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0); | ||
| 755 | pos = end_pfn << PAGE_SHIFT; | ||
| 756 | } | ||
| 757 | |||
| 758 | /* big page (2M) range*/ | ||
| 759 | start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 760 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 761 | end_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT) | ||
| 762 | << (PUD_SHIFT - PAGE_SHIFT); | ||
| 763 | if (end_pfn > ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT))) | ||
| 764 | end_pfn = ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT)); | ||
| 765 | if (start_pfn < end_pfn) { | ||
| 766 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 767 | page_size_mask & (1<<PG_LEVEL_2M)); | ||
| 768 | pos = end_pfn << PAGE_SHIFT; | ||
| 769 | } | ||
| 770 | |||
| 771 | /* big page (1G) range */ | ||
| 772 | start_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT) | ||
| 773 | << (PUD_SHIFT - PAGE_SHIFT); | ||
| 774 | end_pfn = (end >> PUD_SHIFT) << (PUD_SHIFT - PAGE_SHIFT); | ||
| 775 | if (start_pfn < end_pfn) { | ||
| 776 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 777 | page_size_mask & | ||
| 778 | ((1<<PG_LEVEL_2M)|(1<<PG_LEVEL_1G))); | ||
| 779 | pos = end_pfn << PAGE_SHIFT; | ||
| 780 | } | ||
| 781 | |||
| 782 | /* tail is not big page (1G) alignment */ | ||
| 783 | start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT) | ||
| 784 | << (PMD_SHIFT - PAGE_SHIFT); | ||
| 785 | end_pfn = (end >> PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT); | ||
| 786 | if (start_pfn < end_pfn) { | ||
| 787 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, | ||
| 788 | page_size_mask & (1<<PG_LEVEL_2M)); | ||
| 789 | pos = end_pfn << PAGE_SHIFT; | ||
| 790 | } | ||
| 791 | |||
| 792 | /* tail is not big page (2M) alignment */ | ||
| 793 | start_pfn = pos>>PAGE_SHIFT; | ||
| 794 | end_pfn = end>>PAGE_SHIFT; | ||
| 795 | nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0); | ||
| 796 | |||
| 797 | /* try to merge same page size and continuous */ | ||
| 798 | for (i = 0; nr_range > 1 && i < nr_range - 1; i++) { | ||
| 799 | unsigned long old_start; | ||
| 800 | if (mr[i].end != mr[i+1].start || | ||
| 801 | mr[i].page_size_mask != mr[i+1].page_size_mask) | ||
| 802 | continue; | ||
| 803 | /* move it */ | ||
| 804 | old_start = mr[i].start; | ||
| 805 | memmove(&mr[i], &mr[i+1], | ||
| 806 | (nr_range - 1 - i) * sizeof (struct map_range)); | ||
| 807 | mr[i--].start = old_start; | ||
| 808 | nr_range--; | ||
| 809 | } | ||
| 810 | |||
| 811 | for (i = 0; i < nr_range; i++) | ||
| 812 | printk(KERN_DEBUG " %010lx - %010lx page %s\n", | ||
| 813 | mr[i].start, mr[i].end, | ||
| 814 | (mr[i].page_size_mask & (1<<PG_LEVEL_1G))?"1G":( | ||
| 815 | (mr[i].page_size_mask & (1<<PG_LEVEL_2M))?"2M":"4k")); | ||
| 816 | |||
| 817 | if (!after_bootmem) | ||
| 818 | find_early_table_space(end, use_pse, use_gbpages); | ||
| 819 | |||
| 820 | for (i = 0; i < nr_range; i++) | ||
| 821 | last_map_addr = kernel_physical_mapping_init( | ||
| 822 | mr[i].start, mr[i].end, | ||
| 823 | mr[i].page_size_mask); | ||
| 824 | |||
| 825 | if (!after_bootmem) | ||
| 826 | mmu_cr4_features = read_cr4(); | ||
| 827 | __flush_tlb_all(); | ||
| 828 | |||
| 829 | if (!after_bootmem && table_end > table_start) | ||
| 830 | reserve_early(table_start << PAGE_SHIFT, | ||
| 831 | table_end << PAGE_SHIFT, "PGTABLE"); | ||
| 832 | |||
| 833 | printk(KERN_INFO "last_map_addr: %lx end: %lx\n", | ||
| 834 | last_map_addr, end); | ||
| 835 | |||
| 836 | if (!after_bootmem) | ||
| 837 | early_memtest(start, end); | ||
| 838 | |||
| 839 | return last_map_addr >> PAGE_SHIFT; | ||
| 840 | } | ||
| 841 | |||
| 842 | #ifndef CONFIG_NUMA | 613 | #ifndef CONFIG_NUMA |
| 843 | void __init initmem_init(unsigned long start_pfn, unsigned long end_pfn) | 614 | void __init initmem_init(unsigned long start_pfn, unsigned long end_pfn) |
| 844 | { | 615 | { |
| @@ -910,28 +681,6 @@ EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid); | |||
| 910 | 681 | ||
| 911 | #endif /* CONFIG_MEMORY_HOTPLUG */ | 682 | #endif /* CONFIG_MEMORY_HOTPLUG */ |
| 912 | 683 | ||
| 913 | /* | ||
| 914 | * devmem_is_allowed() checks to see if /dev/mem access to a certain address | ||
| 915 | * is valid. The argument is a physical page number. | ||
| 916 | * | ||
| 917 | * | ||
| 918 | * On x86, access has to be given to the first megabyte of ram because that area | ||
| 919 | * contains bios code and data regions used by X and dosemu and similar apps. | ||
| 920 | * Access has to be given to non-kernel-ram areas as well, these contain the PCI | ||
| 921 | * mmio resources as well as potential bios/acpi data regions. | ||
| 922 | */ | ||
| 923 | int devmem_is_allowed(unsigned long pagenr) | ||
| 924 | { | ||
| 925 | if (pagenr <= 256) | ||
| 926 | return 1; | ||
| 927 | if (iomem_is_exclusive(pagenr << PAGE_SHIFT)) | ||
| 928 | return 0; | ||
| 929 | if (!page_is_ram(pagenr)) | ||
| 930 | return 1; | ||
| 931 | return 0; | ||
| 932 | } | ||
| 933 | |||
| 934 | |||
| 935 | static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, | 684 | static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, |
| 936 | kcore_modules, kcore_vsyscall; | 685 | kcore_modules, kcore_vsyscall; |
| 937 | 686 | ||
| @@ -1019,13 +768,6 @@ void mark_rodata_ro(void) | |||
| 1019 | 768 | ||
| 1020 | #endif | 769 | #endif |
| 1021 | 770 | ||
| 1022 | #ifdef CONFIG_BLK_DEV_INITRD | ||
| 1023 | void free_initrd_mem(unsigned long start, unsigned long end) | ||
| 1024 | { | ||
| 1025 | free_init_pages("initrd memory", start, end); | ||
| 1026 | } | ||
| 1027 | #endif | ||
| 1028 | |||
| 1029 | int __init reserve_bootmem_generic(unsigned long phys, unsigned long len, | 771 | int __init reserve_bootmem_generic(unsigned long phys, unsigned long len, |
| 1030 | int flags) | 772 | int flags) |
| 1031 | { | 773 | { |
diff --git a/arch/x86/mm/iomap_32.c b/arch/x86/mm/iomap_32.c index 04102d42ff42..699c9b2895ae 100644 --- a/arch/x86/mm/iomap_32.c +++ b/arch/x86/mm/iomap_32.c | |||
| @@ -31,16 +31,27 @@ int is_io_mapping_possible(resource_size_t base, unsigned long size) | |||
| 31 | } | 31 | } |
| 32 | EXPORT_SYMBOL_GPL(is_io_mapping_possible); | 32 | EXPORT_SYMBOL_GPL(is_io_mapping_possible); |
| 33 | 33 | ||
| 34 | /* Map 'pfn' using fixed map 'type' and protections 'prot' | 34 | void *kmap_atomic_prot_pfn(unsigned long pfn, enum km_type type, pgprot_t prot) |
| 35 | */ | ||
| 36 | void * | ||
| 37 | iomap_atomic_prot_pfn(unsigned long pfn, enum km_type type, pgprot_t prot) | ||
| 38 | { | 35 | { |
| 39 | enum fixed_addresses idx; | 36 | enum fixed_addresses idx; |
| 40 | unsigned long vaddr; | 37 | unsigned long vaddr; |
| 41 | 38 | ||
| 42 | pagefault_disable(); | 39 | pagefault_disable(); |
| 43 | 40 | ||
| 41 | idx = type + KM_TYPE_NR * smp_processor_id(); | ||
| 42 | vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx); | ||
| 43 | set_pte(kmap_pte - idx, pfn_pte(pfn, prot)); | ||
| 44 | arch_flush_lazy_mmu_mode(); | ||
| 45 | |||
| 46 | return (void *)vaddr; | ||
| 47 | } | ||
| 48 | |||
| 49 | /* | ||
| 50 | * Map 'pfn' using fixed map 'type' and protections 'prot' | ||
| 51 | */ | ||
| 52 | void * | ||
| 53 | iomap_atomic_prot_pfn(unsigned long pfn, enum km_type type, pgprot_t prot) | ||
| 54 | { | ||
| 44 | /* | 55 | /* |
| 45 | * For non-PAT systems, promote PAGE_KERNEL_WC to PAGE_KERNEL_UC_MINUS. | 56 | * For non-PAT systems, promote PAGE_KERNEL_WC to PAGE_KERNEL_UC_MINUS. |
| 46 | * PAGE_KERNEL_WC maps to PWT, which translates to uncached if the | 57 | * PAGE_KERNEL_WC maps to PWT, which translates to uncached if the |
| @@ -50,12 +61,7 @@ iomap_atomic_prot_pfn(unsigned long pfn, enum km_type type, pgprot_t prot) | |||
| 50 | if (!pat_enabled && pgprot_val(prot) == pgprot_val(PAGE_KERNEL_WC)) | 61 | if (!pat_enabled && pgprot_val(prot) == pgprot_val(PAGE_KERNEL_WC)) |
| 51 | prot = PAGE_KERNEL_UC_MINUS; | 62 | prot = PAGE_KERNEL_UC_MINUS; |
| 52 | 63 | ||
| 53 | idx = type + KM_TYPE_NR*smp_processor_id(); | 64 | return kmap_atomic_prot_pfn(pfn, type, prot); |
| 54 | vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx); | ||
| 55 | set_pte(kmap_pte-idx, pfn_pte(pfn, prot)); | ||
| 56 | arch_flush_lazy_mmu_mode(); | ||
| 57 | |||
| 58 | return (void*) vaddr; | ||
| 59 | } | 65 | } |
| 60 | EXPORT_SYMBOL_GPL(iomap_atomic_prot_pfn); | 66 | EXPORT_SYMBOL_GPL(iomap_atomic_prot_pfn); |
| 61 | 67 | ||
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c index 433f7bd4648a..0dfa09d69e80 100644 --- a/arch/x86/mm/ioremap.c +++ b/arch/x86/mm/ioremap.c | |||
| @@ -22,13 +22,17 @@ | |||
| 22 | #include <asm/pgalloc.h> | 22 | #include <asm/pgalloc.h> |
| 23 | #include <asm/pat.h> | 23 | #include <asm/pat.h> |
| 24 | 24 | ||
| 25 | #ifdef CONFIG_X86_64 | 25 | static inline int phys_addr_valid(resource_size_t addr) |
| 26 | |||
| 27 | static inline int phys_addr_valid(unsigned long addr) | ||
| 28 | { | 26 | { |
| 29 | return addr < (1UL << boot_cpu_data.x86_phys_bits); | 27 | #ifdef CONFIG_PHYS_ADDR_T_64BIT |
| 28 | return !(addr >> boot_cpu_data.x86_phys_bits); | ||
| 29 | #else | ||
| 30 | return 1; | ||
| 31 | #endif | ||
| 30 | } | 32 | } |
| 31 | 33 | ||
| 34 | #ifdef CONFIG_X86_64 | ||
| 35 | |||
| 32 | unsigned long __phys_addr(unsigned long x) | 36 | unsigned long __phys_addr(unsigned long x) |
| 33 | { | 37 | { |
| 34 | if (x >= __START_KERNEL_map) { | 38 | if (x >= __START_KERNEL_map) { |
| @@ -38,8 +42,7 @@ unsigned long __phys_addr(unsigned long x) | |||
| 38 | } else { | 42 | } else { |
| 39 | VIRTUAL_BUG_ON(x < PAGE_OFFSET); | 43 | VIRTUAL_BUG_ON(x < PAGE_OFFSET); |
| 40 | x -= PAGE_OFFSET; | 44 | x -= PAGE_OFFSET; |
| 41 | VIRTUAL_BUG_ON(system_state == SYSTEM_BOOTING ? x > MAXMEM : | 45 | VIRTUAL_BUG_ON(!phys_addr_valid(x)); |
| 42 | !phys_addr_valid(x)); | ||
| 43 | } | 46 | } |
| 44 | return x; | 47 | return x; |
| 45 | } | 48 | } |
| @@ -56,10 +59,8 @@ bool __virt_addr_valid(unsigned long x) | |||
| 56 | if (x < PAGE_OFFSET) | 59 | if (x < PAGE_OFFSET) |
| 57 | return false; | 60 | return false; |
| 58 | x -= PAGE_OFFSET; | 61 | x -= PAGE_OFFSET; |
| 59 | if (system_state == SYSTEM_BOOTING ? | 62 | if (!phys_addr_valid(x)) |
| 60 | x > MAXMEM : !phys_addr_valid(x)) { | ||
| 61 | return false; | 63 | return false; |
| 62 | } | ||
| 63 | } | 64 | } |
| 64 | 65 | ||
| 65 | return pfn_valid(x >> PAGE_SHIFT); | 66 | return pfn_valid(x >> PAGE_SHIFT); |
| @@ -68,18 +69,12 @@ EXPORT_SYMBOL(__virt_addr_valid); | |||
| 68 | 69 | ||
| 69 | #else | 70 | #else |
| 70 | 71 | ||
| 71 | static inline int phys_addr_valid(unsigned long addr) | ||
| 72 | { | ||
| 73 | return 1; | ||
| 74 | } | ||
| 75 | |||
| 76 | #ifdef CONFIG_DEBUG_VIRTUAL | 72 | #ifdef CONFIG_DEBUG_VIRTUAL |
| 77 | unsigned long __phys_addr(unsigned long x) | 73 | unsigned long __phys_addr(unsigned long x) |
| 78 | { | 74 | { |
| 79 | /* VMALLOC_* aren't constants; not available at the boot time */ | 75 | /* VMALLOC_* aren't constants */ |
| 80 | VIRTUAL_BUG_ON(x < PAGE_OFFSET); | 76 | VIRTUAL_BUG_ON(x < PAGE_OFFSET); |
| 81 | VIRTUAL_BUG_ON(system_state != SYSTEM_BOOTING && | 77 | VIRTUAL_BUG_ON(__vmalloc_start_set && is_vmalloc_addr((void *) x)); |
| 82 | is_vmalloc_addr((void *) x)); | ||
| 83 | return x - PAGE_OFFSET; | 78 | return x - PAGE_OFFSET; |
| 84 | } | 79 | } |
| 85 | EXPORT_SYMBOL(__phys_addr); | 80 | EXPORT_SYMBOL(__phys_addr); |
| @@ -89,7 +84,9 @@ bool __virt_addr_valid(unsigned long x) | |||
| 89 | { | 84 | { |
| 90 | if (x < PAGE_OFFSET) | 85 | if (x < PAGE_OFFSET) |
| 91 | return false; | 86 | return false; |
| 92 | if (system_state != SYSTEM_BOOTING && is_vmalloc_addr((void *) x)) | 87 | if (__vmalloc_start_set && is_vmalloc_addr((void *) x)) |
| 88 | return false; | ||
| 89 | if (x >= FIXADDR_START) | ||
| 93 | return false; | 90 | return false; |
| 94 | return pfn_valid((x - PAGE_OFFSET) >> PAGE_SHIFT); | 91 | return pfn_valid((x - PAGE_OFFSET) >> PAGE_SHIFT); |
| 95 | } | 92 | } |
| @@ -508,13 +505,19 @@ static inline pte_t * __init early_ioremap_pte(unsigned long addr) | |||
| 508 | return &bm_pte[pte_index(addr)]; | 505 | return &bm_pte[pte_index(addr)]; |
| 509 | } | 506 | } |
| 510 | 507 | ||
| 508 | static unsigned long slot_virt[FIX_BTMAPS_SLOTS] __initdata; | ||
| 509 | |||
| 511 | void __init early_ioremap_init(void) | 510 | void __init early_ioremap_init(void) |
| 512 | { | 511 | { |
| 513 | pmd_t *pmd; | 512 | pmd_t *pmd; |
| 513 | int i; | ||
| 514 | 514 | ||
| 515 | if (early_ioremap_debug) | 515 | if (early_ioremap_debug) |
| 516 | printk(KERN_INFO "early_ioremap_init()\n"); | 516 | printk(KERN_INFO "early_ioremap_init()\n"); |
| 517 | 517 | ||
| 518 | for (i = 0; i < FIX_BTMAPS_SLOTS; i++) | ||
| 519 | slot_virt[i] = __fix_to_virt(FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*i); | ||
| 520 | |||
| 518 | pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN)); | 521 | pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN)); |
| 519 | memset(bm_pte, 0, sizeof(bm_pte)); | 522 | memset(bm_pte, 0, sizeof(bm_pte)); |
| 520 | pmd_populate_kernel(&init_mm, pmd, bm_pte); | 523 | pmd_populate_kernel(&init_mm, pmd, bm_pte); |
| @@ -581,6 +584,7 @@ static inline void __init early_clear_fixmap(enum fixed_addresses idx) | |||
| 581 | 584 | ||
| 582 | static void __iomem *prev_map[FIX_BTMAPS_SLOTS] __initdata; | 585 | static void __iomem *prev_map[FIX_BTMAPS_SLOTS] __initdata; |
| 583 | static unsigned long prev_size[FIX_BTMAPS_SLOTS] __initdata; | 586 | static unsigned long prev_size[FIX_BTMAPS_SLOTS] __initdata; |
| 587 | |||
| 584 | static int __init check_early_ioremap_leak(void) | 588 | static int __init check_early_ioremap_leak(void) |
| 585 | { | 589 | { |
| 586 | int count = 0; | 590 | int count = 0; |
| @@ -602,7 +606,8 @@ static int __init check_early_ioremap_leak(void) | |||
| 602 | } | 606 | } |
| 603 | late_initcall(check_early_ioremap_leak); | 607 | late_initcall(check_early_ioremap_leak); |
| 604 | 608 | ||
| 605 | static void __init __iomem *__early_ioremap(unsigned long phys_addr, unsigned long size, pgprot_t prot) | 609 | static void __init __iomem * |
| 610 | __early_ioremap(unsigned long phys_addr, unsigned long size, pgprot_t prot) | ||
| 606 | { | 611 | { |
| 607 | unsigned long offset, last_addr; | 612 | unsigned long offset, last_addr; |
| 608 | unsigned int nrpages; | 613 | unsigned int nrpages; |
| @@ -668,9 +673,9 @@ static void __init __iomem *__early_ioremap(unsigned long phys_addr, unsigned lo | |||
| 668 | --nrpages; | 673 | --nrpages; |
| 669 | } | 674 | } |
| 670 | if (early_ioremap_debug) | 675 | if (early_ioremap_debug) |
| 671 | printk(KERN_CONT "%08lx + %08lx\n", offset, fix_to_virt(idx0)); | 676 | printk(KERN_CONT "%08lx + %08lx\n", offset, slot_virt[slot]); |
| 672 | 677 | ||
| 673 | prev_map[slot] = (void __iomem *)(offset + fix_to_virt(idx0)); | 678 | prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]); |
| 674 | return prev_map[slot]; | 679 | return prev_map[slot]; |
| 675 | } | 680 | } |
| 676 | 681 | ||
| @@ -738,8 +743,3 @@ void __init early_iounmap(void __iomem *addr, unsigned long size) | |||
| 738 | } | 743 | } |
| 739 | prev_map[slot] = NULL; | 744 | prev_map[slot] = NULL; |
| 740 | } | 745 | } |
| 741 | |||
| 742 | void __this_fixmap_does_not_exist(void) | ||
| 743 | { | ||
| 744 | WARN_ON(1); | ||
| 745 | } | ||
diff --git a/arch/x86/mm/kmmio.c b/arch/x86/mm/kmmio.c index 6a518dd08a36..4f115e00486b 100644 --- a/arch/x86/mm/kmmio.c +++ b/arch/x86/mm/kmmio.c | |||
| @@ -310,7 +310,7 @@ static int post_kmmio_handler(unsigned long condition, struct pt_regs *regs) | |||
| 310 | struct kmmio_context *ctx = &get_cpu_var(kmmio_ctx); | 310 | struct kmmio_context *ctx = &get_cpu_var(kmmio_ctx); |
| 311 | 311 | ||
| 312 | if (!ctx->active) { | 312 | if (!ctx->active) { |
| 313 | pr_warning("kmmio: spurious debug trap on CPU %d.\n", | 313 | pr_debug("kmmio: spurious debug trap on CPU %d.\n", |
| 314 | smp_processor_id()); | 314 | smp_processor_id()); |
| 315 | goto out; | 315 | goto out; |
| 316 | } | 316 | } |
diff --git a/arch/x86/mm/memtest.c b/arch/x86/mm/memtest.c index 0bcd7883d036..605c8be06217 100644 --- a/arch/x86/mm/memtest.c +++ b/arch/x86/mm/memtest.c | |||
| @@ -100,6 +100,9 @@ static int __init parse_memtest(char *arg) | |||
| 100 | { | 100 | { |
| 101 | if (arg) | 101 | if (arg) |
| 102 | memtest_pattern = simple_strtoul(arg, NULL, 0); | 102 | memtest_pattern = simple_strtoul(arg, NULL, 0); |
| 103 | else | ||
| 104 | memtest_pattern = ARRAY_SIZE(patterns); | ||
| 105 | |||
| 103 | return 0; | 106 | return 0; |
| 104 | } | 107 | } |
| 105 | 108 | ||
diff --git a/arch/x86/mm/numa_32.c b/arch/x86/mm/numa_32.c index 451fe95a0352..3daefa04ace5 100644 --- a/arch/x86/mm/numa_32.c +++ b/arch/x86/mm/numa_32.c | |||
| @@ -416,10 +416,11 @@ void __init initmem_init(unsigned long start_pfn, | |||
| 416 | for_each_online_node(nid) | 416 | for_each_online_node(nid) |
| 417 | propagate_e820_map_node(nid); | 417 | propagate_e820_map_node(nid); |
| 418 | 418 | ||
| 419 | for_each_online_node(nid) | 419 | for_each_online_node(nid) { |
| 420 | memset(NODE_DATA(nid), 0, sizeof(struct pglist_data)); | 420 | memset(NODE_DATA(nid), 0, sizeof(struct pglist_data)); |
| 421 | NODE_DATA(nid)->bdata = &bootmem_node_data[nid]; | ||
| 422 | } | ||
| 421 | 423 | ||
| 422 | NODE_DATA(0)->bdata = &bootmem_node_data[0]; | ||
| 423 | setup_bootmem_allocator(); | 424 | setup_bootmem_allocator(); |
| 424 | } | 425 | } |
| 425 | 426 | ||
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c index 9c4294986af7..d71e1b636ce6 100644 --- a/arch/x86/mm/pageattr.c +++ b/arch/x86/mm/pageattr.c | |||
| @@ -16,6 +16,7 @@ | |||
| 16 | #include <asm/processor.h> | 16 | #include <asm/processor.h> |
| 17 | #include <asm/tlbflush.h> | 17 | #include <asm/tlbflush.h> |
| 18 | #include <asm/sections.h> | 18 | #include <asm/sections.h> |
| 19 | #include <asm/setup.h> | ||
| 19 | #include <asm/uaccess.h> | 20 | #include <asm/uaccess.h> |
| 20 | #include <asm/pgalloc.h> | 21 | #include <asm/pgalloc.h> |
| 21 | #include <asm/proto.h> | 22 | #include <asm/proto.h> |
| @@ -33,6 +34,7 @@ struct cpa_data { | |||
| 33 | unsigned long pfn; | 34 | unsigned long pfn; |
| 34 | unsigned force_split : 1; | 35 | unsigned force_split : 1; |
| 35 | int curpage; | 36 | int curpage; |
| 37 | struct page **pages; | ||
| 36 | }; | 38 | }; |
| 37 | 39 | ||
| 38 | /* | 40 | /* |
| @@ -45,6 +47,7 @@ static DEFINE_SPINLOCK(cpa_lock); | |||
| 45 | 47 | ||
| 46 | #define CPA_FLUSHTLB 1 | 48 | #define CPA_FLUSHTLB 1 |
| 47 | #define CPA_ARRAY 2 | 49 | #define CPA_ARRAY 2 |
| 50 | #define CPA_PAGES_ARRAY 4 | ||
| 48 | 51 | ||
| 49 | #ifdef CONFIG_PROC_FS | 52 | #ifdef CONFIG_PROC_FS |
| 50 | static unsigned long direct_pages_count[PG_LEVEL_NUM]; | 53 | static unsigned long direct_pages_count[PG_LEVEL_NUM]; |
| @@ -95,7 +98,7 @@ static inline unsigned long highmap_start_pfn(void) | |||
| 95 | 98 | ||
| 96 | static inline unsigned long highmap_end_pfn(void) | 99 | static inline unsigned long highmap_end_pfn(void) |
| 97 | { | 100 | { |
| 98 | return __pa(roundup((unsigned long)_end, PMD_SIZE)) >> PAGE_SHIFT; | 101 | return __pa(roundup(_brk_end, PMD_SIZE)) >> PAGE_SHIFT; |
| 99 | } | 102 | } |
| 100 | 103 | ||
| 101 | #endif | 104 | #endif |
| @@ -201,10 +204,10 @@ static void cpa_flush_range(unsigned long start, int numpages, int cache) | |||
| 201 | } | 204 | } |
| 202 | } | 205 | } |
| 203 | 206 | ||
| 204 | static void cpa_flush_array(unsigned long *start, int numpages, int cache) | 207 | static void cpa_flush_array(unsigned long *start, int numpages, int cache, |
| 208 | int in_flags, struct page **pages) | ||
| 205 | { | 209 | { |
| 206 | unsigned int i, level; | 210 | unsigned int i, level; |
| 207 | unsigned long *addr; | ||
| 208 | 211 | ||
| 209 | BUG_ON(irqs_disabled()); | 212 | BUG_ON(irqs_disabled()); |
| 210 | 213 | ||
| @@ -225,14 +228,22 @@ static void cpa_flush_array(unsigned long *start, int numpages, int cache) | |||
| 225 | * will cause all other CPUs to flush the same | 228 | * will cause all other CPUs to flush the same |
| 226 | * cachelines: | 229 | * cachelines: |
| 227 | */ | 230 | */ |
| 228 | for (i = 0, addr = start; i < numpages; i++, addr++) { | 231 | for (i = 0; i < numpages; i++) { |
| 229 | pte_t *pte = lookup_address(*addr, &level); | 232 | unsigned long addr; |
| 233 | pte_t *pte; | ||
| 234 | |||
| 235 | if (in_flags & CPA_PAGES_ARRAY) | ||
| 236 | addr = (unsigned long)page_address(pages[i]); | ||
| 237 | else | ||
| 238 | addr = start[i]; | ||
| 239 | |||
| 240 | pte = lookup_address(addr, &level); | ||
| 230 | 241 | ||
| 231 | /* | 242 | /* |
| 232 | * Only flush present addresses: | 243 | * Only flush present addresses: |
| 233 | */ | 244 | */ |
| 234 | if (pte && (pte_val(*pte) & _PAGE_PRESENT)) | 245 | if (pte && (pte_val(*pte) & _PAGE_PRESENT)) |
| 235 | clflush_cache_range((void *) *addr, PAGE_SIZE); | 246 | clflush_cache_range((void *)addr, PAGE_SIZE); |
| 236 | } | 247 | } |
| 237 | } | 248 | } |
| 238 | 249 | ||
| @@ -584,7 +595,9 @@ static int __change_page_attr(struct cpa_data *cpa, int primary) | |||
| 584 | unsigned int level; | 595 | unsigned int level; |
| 585 | pte_t *kpte, old_pte; | 596 | pte_t *kpte, old_pte; |
| 586 | 597 | ||
| 587 | if (cpa->flags & CPA_ARRAY) | 598 | if (cpa->flags & CPA_PAGES_ARRAY) |
| 599 | address = (unsigned long)page_address(cpa->pages[cpa->curpage]); | ||
| 600 | else if (cpa->flags & CPA_ARRAY) | ||
| 588 | address = cpa->vaddr[cpa->curpage]; | 601 | address = cpa->vaddr[cpa->curpage]; |
| 589 | else | 602 | else |
| 590 | address = *cpa->vaddr; | 603 | address = *cpa->vaddr; |
| @@ -687,7 +700,9 @@ static int cpa_process_alias(struct cpa_data *cpa) | |||
| 687 | * No need to redo, when the primary call touched the direct | 700 | * No need to redo, when the primary call touched the direct |
| 688 | * mapping already: | 701 | * mapping already: |
| 689 | */ | 702 | */ |
| 690 | if (cpa->flags & CPA_ARRAY) | 703 | if (cpa->flags & CPA_PAGES_ARRAY) |
| 704 | vaddr = (unsigned long)page_address(cpa->pages[cpa->curpage]); | ||
| 705 | else if (cpa->flags & CPA_ARRAY) | ||
| 691 | vaddr = cpa->vaddr[cpa->curpage]; | 706 | vaddr = cpa->vaddr[cpa->curpage]; |
| 692 | else | 707 | else |
| 693 | vaddr = *cpa->vaddr; | 708 | vaddr = *cpa->vaddr; |
| @@ -698,7 +713,7 @@ static int cpa_process_alias(struct cpa_data *cpa) | |||
| 698 | alias_cpa = *cpa; | 713 | alias_cpa = *cpa; |
| 699 | temp_cpa_vaddr = (unsigned long) __va(cpa->pfn << PAGE_SHIFT); | 714 | temp_cpa_vaddr = (unsigned long) __va(cpa->pfn << PAGE_SHIFT); |
| 700 | alias_cpa.vaddr = &temp_cpa_vaddr; | 715 | alias_cpa.vaddr = &temp_cpa_vaddr; |
| 701 | alias_cpa.flags &= ~CPA_ARRAY; | 716 | alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY); |
| 702 | 717 | ||
| 703 | 718 | ||
| 704 | ret = __change_page_attr_set_clr(&alias_cpa, 0); | 719 | ret = __change_page_attr_set_clr(&alias_cpa, 0); |
| @@ -711,7 +726,7 @@ static int cpa_process_alias(struct cpa_data *cpa) | |||
| 711 | * No need to redo, when the primary call touched the high | 726 | * No need to redo, when the primary call touched the high |
| 712 | * mapping already: | 727 | * mapping already: |
| 713 | */ | 728 | */ |
| 714 | if (within(vaddr, (unsigned long) _text, (unsigned long) _end)) | 729 | if (within(vaddr, (unsigned long) _text, _brk_end)) |
| 715 | return 0; | 730 | return 0; |
| 716 | 731 | ||
| 717 | /* | 732 | /* |
| @@ -724,7 +739,7 @@ static int cpa_process_alias(struct cpa_data *cpa) | |||
| 724 | alias_cpa = *cpa; | 739 | alias_cpa = *cpa; |
| 725 | temp_cpa_vaddr = (cpa->pfn << PAGE_SHIFT) + __START_KERNEL_map - phys_base; | 740 | temp_cpa_vaddr = (cpa->pfn << PAGE_SHIFT) + __START_KERNEL_map - phys_base; |
| 726 | alias_cpa.vaddr = &temp_cpa_vaddr; | 741 | alias_cpa.vaddr = &temp_cpa_vaddr; |
| 727 | alias_cpa.flags &= ~CPA_ARRAY; | 742 | alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY); |
| 728 | 743 | ||
| 729 | /* | 744 | /* |
| 730 | * The high mapping range is imprecise, so ignore the return value. | 745 | * The high mapping range is imprecise, so ignore the return value. |
| @@ -745,7 +760,7 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias) | |||
| 745 | */ | 760 | */ |
| 746 | cpa->numpages = numpages; | 761 | cpa->numpages = numpages; |
| 747 | /* for array changes, we can't use large page */ | 762 | /* for array changes, we can't use large page */ |
| 748 | if (cpa->flags & CPA_ARRAY) | 763 | if (cpa->flags & (CPA_ARRAY | CPA_PAGES_ARRAY)) |
| 749 | cpa->numpages = 1; | 764 | cpa->numpages = 1; |
| 750 | 765 | ||
| 751 | if (!debug_pagealloc) | 766 | if (!debug_pagealloc) |
| @@ -769,7 +784,7 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias) | |||
| 769 | */ | 784 | */ |
| 770 | BUG_ON(cpa->numpages > numpages); | 785 | BUG_ON(cpa->numpages > numpages); |
| 771 | numpages -= cpa->numpages; | 786 | numpages -= cpa->numpages; |
| 772 | if (cpa->flags & CPA_ARRAY) | 787 | if (cpa->flags & (CPA_PAGES_ARRAY | CPA_ARRAY)) |
| 773 | cpa->curpage++; | 788 | cpa->curpage++; |
| 774 | else | 789 | else |
| 775 | *cpa->vaddr += cpa->numpages * PAGE_SIZE; | 790 | *cpa->vaddr += cpa->numpages * PAGE_SIZE; |
| @@ -786,7 +801,8 @@ static inline int cache_attr(pgprot_t attr) | |||
| 786 | 801 | ||
| 787 | static int change_page_attr_set_clr(unsigned long *addr, int numpages, | 802 | static int change_page_attr_set_clr(unsigned long *addr, int numpages, |
| 788 | pgprot_t mask_set, pgprot_t mask_clr, | 803 | pgprot_t mask_set, pgprot_t mask_clr, |
| 789 | int force_split, int array) | 804 | int force_split, int in_flag, |
| 805 | struct page **pages) | ||
| 790 | { | 806 | { |
| 791 | struct cpa_data cpa; | 807 | struct cpa_data cpa; |
| 792 | int ret, cache, checkalias; | 808 | int ret, cache, checkalias; |
| @@ -801,15 +817,7 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages, | |||
| 801 | return 0; | 817 | return 0; |
| 802 | 818 | ||
| 803 | /* Ensure we are PAGE_SIZE aligned */ | 819 | /* Ensure we are PAGE_SIZE aligned */ |
| 804 | if (!array) { | 820 | if (in_flag & CPA_ARRAY) { |
| 805 | if (*addr & ~PAGE_MASK) { | ||
| 806 | *addr &= PAGE_MASK; | ||
| 807 | /* | ||
| 808 | * People should not be passing in unaligned addresses: | ||
| 809 | */ | ||
| 810 | WARN_ON_ONCE(1); | ||
| 811 | } | ||
| 812 | } else { | ||
| 813 | int i; | 821 | int i; |
| 814 | for (i = 0; i < numpages; i++) { | 822 | for (i = 0; i < numpages; i++) { |
| 815 | if (addr[i] & ~PAGE_MASK) { | 823 | if (addr[i] & ~PAGE_MASK) { |
| @@ -817,6 +825,18 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages, | |||
| 817 | WARN_ON_ONCE(1); | 825 | WARN_ON_ONCE(1); |
| 818 | } | 826 | } |
| 819 | } | 827 | } |
| 828 | } else if (!(in_flag & CPA_PAGES_ARRAY)) { | ||
| 829 | /* | ||
| 830 | * in_flag of CPA_PAGES_ARRAY implies it is aligned. | ||
| 831 | * No need to cehck in that case | ||
| 832 | */ | ||
| 833 | if (*addr & ~PAGE_MASK) { | ||
| 834 | *addr &= PAGE_MASK; | ||
| 835 | /* | ||
| 836 | * People should not be passing in unaligned addresses: | ||
| 837 | */ | ||
| 838 | WARN_ON_ONCE(1); | ||
| 839 | } | ||
| 820 | } | 840 | } |
| 821 | 841 | ||
| 822 | /* Must avoid aliasing mappings in the highmem code */ | 842 | /* Must avoid aliasing mappings in the highmem code */ |
| @@ -832,6 +852,7 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages, | |||
| 832 | arch_flush_lazy_mmu_mode(); | 852 | arch_flush_lazy_mmu_mode(); |
| 833 | 853 | ||
| 834 | cpa.vaddr = addr; | 854 | cpa.vaddr = addr; |
| 855 | cpa.pages = pages; | ||
| 835 | cpa.numpages = numpages; | 856 | cpa.numpages = numpages; |
| 836 | cpa.mask_set = mask_set; | 857 | cpa.mask_set = mask_set; |
| 837 | cpa.mask_clr = mask_clr; | 858 | cpa.mask_clr = mask_clr; |
| @@ -839,8 +860,8 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages, | |||
| 839 | cpa.curpage = 0; | 860 | cpa.curpage = 0; |
| 840 | cpa.force_split = force_split; | 861 | cpa.force_split = force_split; |
| 841 | 862 | ||
| 842 | if (array) | 863 | if (in_flag & (CPA_ARRAY | CPA_PAGES_ARRAY)) |
| 843 | cpa.flags |= CPA_ARRAY; | 864 | cpa.flags |= in_flag; |
| 844 | 865 | ||
| 845 | /* No alias checking for _NX bit modifications */ | 866 | /* No alias checking for _NX bit modifications */ |
| 846 | checkalias = (pgprot_val(mask_set) | pgprot_val(mask_clr)) != _PAGE_NX; | 867 | checkalias = (pgprot_val(mask_set) | pgprot_val(mask_clr)) != _PAGE_NX; |
| @@ -866,9 +887,10 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages, | |||
| 866 | * wbindv): | 887 | * wbindv): |
| 867 | */ | 888 | */ |
| 868 | if (!ret && cpu_has_clflush) { | 889 | if (!ret && cpu_has_clflush) { |
| 869 | if (cpa.flags & CPA_ARRAY) | 890 | if (cpa.flags & (CPA_PAGES_ARRAY | CPA_ARRAY)) { |
| 870 | cpa_flush_array(addr, numpages, cache); | 891 | cpa_flush_array(addr, numpages, cache, |
| 871 | else | 892 | cpa.flags, pages); |
| 893 | } else | ||
| 872 | cpa_flush_range(*addr, numpages, cache); | 894 | cpa_flush_range(*addr, numpages, cache); |
| 873 | } else | 895 | } else |
| 874 | cpa_flush_all(cache); | 896 | cpa_flush_all(cache); |
| @@ -888,14 +910,28 @@ static inline int change_page_attr_set(unsigned long *addr, int numpages, | |||
| 888 | pgprot_t mask, int array) | 910 | pgprot_t mask, int array) |
| 889 | { | 911 | { |
| 890 | return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0), 0, | 912 | return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0), 0, |
| 891 | array); | 913 | (array ? CPA_ARRAY : 0), NULL); |
| 892 | } | 914 | } |
| 893 | 915 | ||
| 894 | static inline int change_page_attr_clear(unsigned long *addr, int numpages, | 916 | static inline int change_page_attr_clear(unsigned long *addr, int numpages, |
| 895 | pgprot_t mask, int array) | 917 | pgprot_t mask, int array) |
| 896 | { | 918 | { |
| 897 | return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask, 0, | 919 | return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask, 0, |
| 898 | array); | 920 | (array ? CPA_ARRAY : 0), NULL); |
| 921 | } | ||
| 922 | |||
| 923 | static inline int cpa_set_pages_array(struct page **pages, int numpages, | ||
| 924 | pgprot_t mask) | ||
| 925 | { | ||
| 926 | return change_page_attr_set_clr(NULL, numpages, mask, __pgprot(0), 0, | ||
| 927 | CPA_PAGES_ARRAY, pages); | ||
| 928 | } | ||
| 929 | |||
| 930 | static inline int cpa_clear_pages_array(struct page **pages, int numpages, | ||
| 931 | pgprot_t mask) | ||
| 932 | { | ||
| 933 | return change_page_attr_set_clr(NULL, numpages, __pgprot(0), mask, 0, | ||
| 934 | CPA_PAGES_ARRAY, pages); | ||
| 899 | } | 935 | } |
| 900 | 936 | ||
| 901 | int _set_memory_uc(unsigned long addr, int numpages) | 937 | int _set_memory_uc(unsigned long addr, int numpages) |
| @@ -1043,7 +1079,7 @@ int set_memory_np(unsigned long addr, int numpages) | |||
| 1043 | int set_memory_4k(unsigned long addr, int numpages) | 1079 | int set_memory_4k(unsigned long addr, int numpages) |
| 1044 | { | 1080 | { |
| 1045 | return change_page_attr_set_clr(&addr, numpages, __pgprot(0), | 1081 | return change_page_attr_set_clr(&addr, numpages, __pgprot(0), |
| 1046 | __pgprot(0), 1, 0); | 1082 | __pgprot(0), 1, 0, NULL); |
| 1047 | } | 1083 | } |
| 1048 | 1084 | ||
| 1049 | int set_pages_uc(struct page *page, int numpages) | 1085 | int set_pages_uc(struct page *page, int numpages) |
| @@ -1054,6 +1090,35 @@ int set_pages_uc(struct page *page, int numpages) | |||
| 1054 | } | 1090 | } |
| 1055 | EXPORT_SYMBOL(set_pages_uc); | 1091 | EXPORT_SYMBOL(set_pages_uc); |
| 1056 | 1092 | ||
| 1093 | int set_pages_array_uc(struct page **pages, int addrinarray) | ||
| 1094 | { | ||
| 1095 | unsigned long start; | ||
| 1096 | unsigned long end; | ||
| 1097 | int i; | ||
| 1098 | int free_idx; | ||
| 1099 | |||
| 1100 | for (i = 0; i < addrinarray; i++) { | ||
| 1101 | start = (unsigned long)page_address(pages[i]); | ||
| 1102 | end = start + PAGE_SIZE; | ||
| 1103 | if (reserve_memtype(start, end, _PAGE_CACHE_UC_MINUS, NULL)) | ||
| 1104 | goto err_out; | ||
| 1105 | } | ||
| 1106 | |||
| 1107 | if (cpa_set_pages_array(pages, addrinarray, | ||
| 1108 | __pgprot(_PAGE_CACHE_UC_MINUS)) == 0) { | ||
| 1109 | return 0; /* Success */ | ||
| 1110 | } | ||
| 1111 | err_out: | ||
| 1112 | free_idx = i; | ||
| 1113 | for (i = 0; i < free_idx; i++) { | ||
| 1114 | start = (unsigned long)page_address(pages[i]); | ||
| 1115 | end = start + PAGE_SIZE; | ||
| 1116 | free_memtype(start, end); | ||
| 1117 | } | ||
| 1118 | return -EINVAL; | ||
| 1119 | } | ||
| 1120 | EXPORT_SYMBOL(set_pages_array_uc); | ||
| 1121 | |||
| 1057 | int set_pages_wb(struct page *page, int numpages) | 1122 | int set_pages_wb(struct page *page, int numpages) |
| 1058 | { | 1123 | { |
| 1059 | unsigned long addr = (unsigned long)page_address(page); | 1124 | unsigned long addr = (unsigned long)page_address(page); |
| @@ -1062,6 +1127,26 @@ int set_pages_wb(struct page *page, int numpages) | |||
| 1062 | } | 1127 | } |
| 1063 | EXPORT_SYMBOL(set_pages_wb); | 1128 | EXPORT_SYMBOL(set_pages_wb); |
| 1064 | 1129 | ||
| 1130 | int set_pages_array_wb(struct page **pages, int addrinarray) | ||
| 1131 | { | ||
| 1132 | int retval; | ||
| 1133 | unsigned long start; | ||
| 1134 | unsigned long end; | ||
| 1135 | int i; | ||
| 1136 | |||
| 1137 | retval = cpa_clear_pages_array(pages, addrinarray, | ||
| 1138 | __pgprot(_PAGE_CACHE_MASK)); | ||
| 1139 | |||
| 1140 | for (i = 0; i < addrinarray; i++) { | ||
| 1141 | start = (unsigned long)page_address(pages[i]); | ||
| 1142 | end = start + PAGE_SIZE; | ||
| 1143 | free_memtype(start, end); | ||
| 1144 | } | ||
| 1145 | |||
| 1146 | return retval; | ||
| 1147 | } | ||
| 1148 | EXPORT_SYMBOL(set_pages_array_wb); | ||
| 1149 | |||
| 1065 | int set_pages_x(struct page *page, int numpages) | 1150 | int set_pages_x(struct page *page, int numpages) |
| 1066 | { | 1151 | { |
| 1067 | unsigned long addr = (unsigned long)page_address(page); | 1152 | unsigned long addr = (unsigned long)page_address(page); |
diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c index 2ed37158012d..640339ee4fb2 100644 --- a/arch/x86/mm/pat.c +++ b/arch/x86/mm/pat.c | |||
| @@ -677,10 +677,11 @@ static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot, | |||
| 677 | is_ram = pat_pagerange_is_ram(paddr, paddr + size); | 677 | is_ram = pat_pagerange_is_ram(paddr, paddr + size); |
| 678 | 678 | ||
| 679 | /* | 679 | /* |
| 680 | * reserve_pfn_range() doesn't support RAM pages. | 680 | * reserve_pfn_range() doesn't support RAM pages. Maintain the current |
| 681 | * behavior with RAM pages by returning success. | ||
| 681 | */ | 682 | */ |
| 682 | if (is_ram != 0) | 683 | if (is_ram != 0) |
| 683 | return -EINVAL; | 684 | return 0; |
| 684 | 685 | ||
| 685 | ret = reserve_memtype(paddr, paddr + size, want_flags, &flags); | 686 | ret = reserve_memtype(paddr, paddr + size, want_flags, &flags); |
| 686 | if (ret) | 687 | if (ret) |
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c index f2e477c91c1b..46c8834aedc0 100644 --- a/arch/x86/mm/pgtable_32.c +++ b/arch/x86/mm/pgtable_32.c | |||
| @@ -50,7 +50,7 @@ void set_pte_vaddr(unsigned long vaddr, pte_t pteval) | |||
| 50 | } | 50 | } |
| 51 | pte = pte_offset_kernel(pmd, vaddr); | 51 | pte = pte_offset_kernel(pmd, vaddr); |
| 52 | if (pte_val(pteval)) | 52 | if (pte_val(pteval)) |
| 53 | set_pte_present(&init_mm, vaddr, pte, pteval); | 53 | set_pte_at(&init_mm, vaddr, pte, pteval); |
| 54 | else | 54 | else |
| 55 | pte_clear(&init_mm, vaddr, pte); | 55 | pte_clear(&init_mm, vaddr, pte); |
| 56 | 56 | ||
diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c index a654d59e4483..821e97017e95 100644 --- a/arch/x86/mm/tlb.c +++ b/arch/x86/mm/tlb.c | |||
| @@ -187,11 +187,6 @@ static void flush_tlb_others_ipi(const struct cpumask *cpumask, | |||
| 187 | cpumask, cpumask_of(smp_processor_id())); | 187 | cpumask, cpumask_of(smp_processor_id())); |
| 188 | 188 | ||
| 189 | /* | 189 | /* |
| 190 | * Make the above memory operations globally visible before | ||
| 191 | * sending the IPI. | ||
| 192 | */ | ||
| 193 | smp_mb(); | ||
| 194 | /* | ||
| 195 | * We have to send the IPI only to | 190 | * We have to send the IPI only to |
| 196 | * CPUs affected. | 191 | * CPUs affected. |
| 197 | */ | 192 | */ |
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c index 82d22fc601ae..8c362b96b644 100644 --- a/arch/x86/pci/common.c +++ b/arch/x86/pci/common.c | |||
| @@ -90,7 +90,7 @@ static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d) | |||
| 90 | return 0; | 90 | return 0; |
| 91 | } | 91 | } |
| 92 | 92 | ||
| 93 | static struct dmi_system_id can_skip_pciprobe_dmi_table[] __devinitdata = { | 93 | static const struct dmi_system_id can_skip_pciprobe_dmi_table[] __devinitconst = { |
| 94 | /* | 94 | /* |
| 95 | * Systems where PCI IO resource ISA alignment can be skipped | 95 | * Systems where PCI IO resource ISA alignment can be skipped |
| 96 | * when the ISA enable bit in the bridge control is not set | 96 | * when the ISA enable bit in the bridge control is not set |
| @@ -183,7 +183,7 @@ static int __devinit assign_all_busses(const struct dmi_system_id *d) | |||
| 183 | } | 183 | } |
| 184 | #endif | 184 | #endif |
| 185 | 185 | ||
| 186 | static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = { | 186 | static const struct dmi_system_id __devinitconst pciprobe_dmi_table[] = { |
| 187 | #ifdef __i386__ | 187 | #ifdef __i386__ |
| 188 | /* | 188 | /* |
| 189 | * Laptops which need pci=assign-busses to see Cardbus cards | 189 | * Laptops which need pci=assign-busses to see Cardbus cards |
diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c index 7d388d5cf548..9c49919e4d1c 100644 --- a/arch/x86/pci/fixup.c +++ b/arch/x86/pci/fixup.c | |||
| @@ -356,7 +356,7 @@ static void __devinit pci_fixup_video(struct pci_dev *pdev) | |||
| 356 | DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_video); | 356 | DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_video); |
| 357 | 357 | ||
| 358 | 358 | ||
| 359 | static struct dmi_system_id __devinitdata msi_k8t_dmi_table[] = { | 359 | static const struct dmi_system_id __devinitconst msi_k8t_dmi_table[] = { |
| 360 | { | 360 | { |
| 361 | .ident = "MSI-K8T-Neo2Fir", | 361 | .ident = "MSI-K8T-Neo2Fir", |
| 362 | .matches = { | 362 | .matches = { |
| @@ -413,7 +413,7 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237, | |||
| 413 | */ | 413 | */ |
| 414 | static u16 toshiba_line_size; | 414 | static u16 toshiba_line_size; |
| 415 | 415 | ||
| 416 | static struct dmi_system_id __devinitdata toshiba_ohci1394_dmi_table[] = { | 416 | static const struct dmi_system_id __devinitconst toshiba_ohci1394_dmi_table[] = { |
| 417 | { | 417 | { |
| 418 | .ident = "Toshiba PS5 based laptop", | 418 | .ident = "Toshiba PS5 based laptop", |
| 419 | .matches = { | 419 | .matches = { |
diff --git a/arch/x86/pci/i386.c b/arch/x86/pci/i386.c index 5ead808dd70c..f234a37bd428 100644 --- a/arch/x86/pci/i386.c +++ b/arch/x86/pci/i386.c | |||
| @@ -319,6 +319,9 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma, | |||
| 319 | return -EINVAL; | 319 | return -EINVAL; |
| 320 | } | 320 | } |
| 321 | flags = new_flags; | 321 | flags = new_flags; |
| 322 | vma->vm_page_prot = __pgprot( | ||
| 323 | (pgprot_val(vma->vm_page_prot) & ~_PAGE_CACHE_MASK) | | ||
| 324 | flags); | ||
| 322 | } | 325 | } |
| 323 | 326 | ||
| 324 | if (((vma->vm_pgoff < max_low_pfn_mapped) || | 327 | if (((vma->vm_pgoff < max_low_pfn_mapped) || |
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c index cb6afa4ec95c..db3802fb7b84 100644 --- a/arch/x86/xen/mmu.c +++ b/arch/x86/xen/mmu.c | |||
| @@ -1723,9 +1723,9 @@ __init pgd_t *xen_setup_kernel_pagetable(pgd_t *pgd, | |||
| 1723 | { | 1723 | { |
| 1724 | pmd_t *kernel_pmd; | 1724 | pmd_t *kernel_pmd; |
| 1725 | 1725 | ||
| 1726 | init_pg_tables_start = __pa(pgd); | 1726 | max_pfn_mapped = PFN_DOWN(__pa(xen_start_info->pt_base) + |
| 1727 | init_pg_tables_end = __pa(pgd) + xen_start_info->nr_pt_frames*PAGE_SIZE; | 1727 | xen_start_info->nr_pt_frames * PAGE_SIZE + |
| 1728 | max_pfn_mapped = PFN_DOWN(init_pg_tables_end + 512*1024); | 1728 | 512*1024); |
| 1729 | 1729 | ||
| 1730 | kernel_pmd = m2v(pgd[KERNEL_PGD_BOUNDARY].pgd); | 1730 | kernel_pmd = m2v(pgd[KERNEL_PGD_BOUNDARY].pgd); |
| 1731 | memcpy(level2_kernel_pgt, kernel_pmd, sizeof(pmd_t) * PTRS_PER_PMD); | 1731 | memcpy(level2_kernel_pgt, kernel_pmd, sizeof(pmd_t) * PTRS_PER_PMD); |
| @@ -1870,7 +1870,6 @@ const struct pv_mmu_ops xen_mmu_ops __initdata = { | |||
| 1870 | 1870 | ||
| 1871 | #ifdef CONFIG_X86_PAE | 1871 | #ifdef CONFIG_X86_PAE |
| 1872 | .set_pte_atomic = xen_set_pte_atomic, | 1872 | .set_pte_atomic = xen_set_pte_atomic, |
| 1873 | .set_pte_present = xen_set_pte_at, | ||
| 1874 | .pte_clear = xen_pte_clear, | 1873 | .pte_clear = xen_pte_clear, |
| 1875 | .pmd_clear = xen_pmd_clear, | 1874 | .pmd_clear = xen_pmd_clear, |
| 1876 | #endif /* CONFIG_X86_PAE */ | 1875 | #endif /* CONFIG_X86_PAE */ |
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c index 5f333403c2ea..d313039e2fdf 100644 --- a/drivers/pci/dmar.c +++ b/drivers/pci/dmar.c | |||
| @@ -31,6 +31,8 @@ | |||
| 31 | #include <linux/iova.h> | 31 | #include <linux/iova.h> |
| 32 | #include <linux/intel-iommu.h> | 32 | #include <linux/intel-iommu.h> |
| 33 | #include <linux/timer.h> | 33 | #include <linux/timer.h> |
| 34 | #include <linux/irq.h> | ||
| 35 | #include <linux/interrupt.h> | ||
| 34 | 36 | ||
| 35 | #undef PREFIX | 37 | #undef PREFIX |
| 36 | #define PREFIX "DMAR:" | 38 | #define PREFIX "DMAR:" |
| @@ -509,6 +511,7 @@ int alloc_iommu(struct dmar_drhd_unit *drhd) | |||
| 509 | return -ENOMEM; | 511 | return -ENOMEM; |
| 510 | 512 | ||
| 511 | iommu->seq_id = iommu_allocated++; | 513 | iommu->seq_id = iommu_allocated++; |
| 514 | sprintf (iommu->name, "dmar%d", iommu->seq_id); | ||
| 512 | 515 | ||
| 513 | iommu->reg = ioremap(drhd->reg_base_addr, VTD_PAGE_SIZE); | 516 | iommu->reg = ioremap(drhd->reg_base_addr, VTD_PAGE_SIZE); |
| 514 | if (!iommu->reg) { | 517 | if (!iommu->reg) { |
| @@ -751,6 +754,42 @@ int qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr, | |||
| 751 | } | 754 | } |
| 752 | 755 | ||
| 753 | /* | 756 | /* |
| 757 | * Disable Queued Invalidation interface. | ||
| 758 | */ | ||
| 759 | void dmar_disable_qi(struct intel_iommu *iommu) | ||
| 760 | { | ||
| 761 | unsigned long flags; | ||
| 762 | u32 sts; | ||
| 763 | cycles_t start_time = get_cycles(); | ||
| 764 | |||
| 765 | if (!ecap_qis(iommu->ecap)) | ||
| 766 | return; | ||
| 767 | |||
| 768 | spin_lock_irqsave(&iommu->register_lock, flags); | ||
| 769 | |||
| 770 | sts = dmar_readq(iommu->reg + DMAR_GSTS_REG); | ||
| 771 | if (!(sts & DMA_GSTS_QIES)) | ||
| 772 | goto end; | ||
| 773 | |||
| 774 | /* | ||
| 775 | * Give a chance to HW to complete the pending invalidation requests. | ||
| 776 | */ | ||
| 777 | while ((readl(iommu->reg + DMAR_IQT_REG) != | ||
| 778 | readl(iommu->reg + DMAR_IQH_REG)) && | ||
| 779 | (DMAR_OPERATION_TIMEOUT > (get_cycles() - start_time))) | ||
| 780 | cpu_relax(); | ||
| 781 | |||
| 782 | iommu->gcmd &= ~DMA_GCMD_QIE; | ||
| 783 | |||
| 784 | writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG); | ||
| 785 | |||
| 786 | IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, readl, | ||
| 787 | !(sts & DMA_GSTS_QIES), sts); | ||
| 788 | end: | ||
| 789 | spin_unlock_irqrestore(&iommu->register_lock, flags); | ||
| 790 | } | ||
| 791 | |||
| 792 | /* | ||
| 754 | * Enable Queued Invalidation interface. This is a must to support | 793 | * Enable Queued Invalidation interface. This is a must to support |
| 755 | * interrupt-remapping. Also used by DMA-remapping, which replaces | 794 | * interrupt-remapping. Also used by DMA-remapping, which replaces |
| 756 | * register based IOTLB invalidation. | 795 | * register based IOTLB invalidation. |
| @@ -770,20 +809,20 @@ int dmar_enable_qi(struct intel_iommu *iommu) | |||
| 770 | if (iommu->qi) | 809 | if (iommu->qi) |
| 771 | return 0; | 810 | return 0; |
| 772 | 811 | ||
| 773 | iommu->qi = kmalloc(sizeof(*qi), GFP_KERNEL); | 812 | iommu->qi = kmalloc(sizeof(*qi), GFP_ATOMIC); |
| 774 | if (!iommu->qi) | 813 | if (!iommu->qi) |
| 775 | return -ENOMEM; | 814 | return -ENOMEM; |
| 776 | 815 | ||
| 777 | qi = iommu->qi; | 816 | qi = iommu->qi; |
| 778 | 817 | ||
| 779 | qi->desc = (void *)(get_zeroed_page(GFP_KERNEL)); | 818 | qi->desc = (void *)(get_zeroed_page(GFP_ATOMIC)); |
| 780 | if (!qi->desc) { | 819 | if (!qi->desc) { |
| 781 | kfree(qi); | 820 | kfree(qi); |
| 782 | iommu->qi = 0; | 821 | iommu->qi = 0; |
| 783 | return -ENOMEM; | 822 | return -ENOMEM; |
| 784 | } | 823 | } |
| 785 | 824 | ||
| 786 | qi->desc_status = kmalloc(QI_LENGTH * sizeof(int), GFP_KERNEL); | 825 | qi->desc_status = kmalloc(QI_LENGTH * sizeof(int), GFP_ATOMIC); |
| 787 | if (!qi->desc_status) { | 826 | if (!qi->desc_status) { |
| 788 | free_page((unsigned long) qi->desc); | 827 | free_page((unsigned long) qi->desc); |
| 789 | kfree(qi); | 828 | kfree(qi); |
| @@ -812,3 +851,254 @@ int dmar_enable_qi(struct intel_iommu *iommu) | |||
| 812 | 851 | ||
| 813 | return 0; | 852 | return 0; |
| 814 | } | 853 | } |
| 854 | |||
| 855 | /* iommu interrupt handling. Most stuff are MSI-like. */ | ||
| 856 | |||
| 857 | enum faulttype { | ||
| 858 | DMA_REMAP, | ||
| 859 | INTR_REMAP, | ||
| 860 | UNKNOWN, | ||
| 861 | }; | ||
| 862 | |||
| 863 | static const char *dma_remap_fault_reasons[] = | ||
| 864 | { | ||
| 865 | "Software", | ||
| 866 | "Present bit in root entry is clear", | ||
| 867 | "Present bit in context entry is clear", | ||
| 868 | "Invalid context entry", | ||
| 869 | "Access beyond MGAW", | ||
| 870 | "PTE Write access is not set", | ||
| 871 | "PTE Read access is not set", | ||
| 872 | "Next page table ptr is invalid", | ||
| 873 | "Root table address invalid", | ||
| 874 | "Context table ptr is invalid", | ||
| 875 | "non-zero reserved fields in RTP", | ||
| 876 | "non-zero reserved fields in CTP", | ||
| 877 | "non-zero reserved fields in PTE", | ||
| 878 | }; | ||
| 879 | |||
| 880 | static const char *intr_remap_fault_reasons[] = | ||
| 881 | { | ||
| 882 | "Detected reserved fields in the decoded interrupt-remapped request", | ||
| 883 | "Interrupt index exceeded the interrupt-remapping table size", | ||
| 884 | "Present field in the IRTE entry is clear", | ||
| 885 | "Error accessing interrupt-remapping table pointed by IRTA_REG", | ||
| 886 | "Detected reserved fields in the IRTE entry", | ||
| 887 | "Blocked a compatibility format interrupt request", | ||
| 888 | "Blocked an interrupt request due to source-id verification failure", | ||
| 889 | }; | ||
| 890 | |||
| 891 | #define MAX_FAULT_REASON_IDX (ARRAY_SIZE(fault_reason_strings) - 1) | ||
| 892 | |||
| 893 | const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type) | ||
| 894 | { | ||
| 895 | if (fault_reason >= 0x20 && (fault_reason <= 0x20 + | ||
| 896 | ARRAY_SIZE(intr_remap_fault_reasons))) { | ||
| 897 | *fault_type = INTR_REMAP; | ||
| 898 | return intr_remap_fault_reasons[fault_reason - 0x20]; | ||
| 899 | } else if (fault_reason < ARRAY_SIZE(dma_remap_fault_reasons)) { | ||
| 900 | *fault_type = DMA_REMAP; | ||
| 901 | return dma_remap_fault_reasons[fault_reason]; | ||
| 902 | } else { | ||
| 903 | *fault_type = UNKNOWN; | ||
| 904 | return "Unknown"; | ||
| 905 | } | ||
| 906 | } | ||
| 907 | |||
| 908 | void dmar_msi_unmask(unsigned int irq) | ||
| 909 | { | ||
| 910 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 911 | unsigned long flag; | ||
| 912 | |||
| 913 | /* unmask it */ | ||
| 914 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 915 | writel(0, iommu->reg + DMAR_FECTL_REG); | ||
| 916 | /* Read a reg to force flush the post write */ | ||
| 917 | readl(iommu->reg + DMAR_FECTL_REG); | ||
| 918 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 919 | } | ||
| 920 | |||
| 921 | void dmar_msi_mask(unsigned int irq) | ||
| 922 | { | ||
| 923 | unsigned long flag; | ||
| 924 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 925 | |||
| 926 | /* mask it */ | ||
| 927 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 928 | writel(DMA_FECTL_IM, iommu->reg + DMAR_FECTL_REG); | ||
| 929 | /* Read a reg to force flush the post write */ | ||
| 930 | readl(iommu->reg + DMAR_FECTL_REG); | ||
| 931 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 932 | } | ||
| 933 | |||
| 934 | void dmar_msi_write(int irq, struct msi_msg *msg) | ||
| 935 | { | ||
| 936 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 937 | unsigned long flag; | ||
| 938 | |||
| 939 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 940 | writel(msg->data, iommu->reg + DMAR_FEDATA_REG); | ||
| 941 | writel(msg->address_lo, iommu->reg + DMAR_FEADDR_REG); | ||
| 942 | writel(msg->address_hi, iommu->reg + DMAR_FEUADDR_REG); | ||
| 943 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 944 | } | ||
| 945 | |||
| 946 | void dmar_msi_read(int irq, struct msi_msg *msg) | ||
| 947 | { | ||
| 948 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 949 | unsigned long flag; | ||
| 950 | |||
| 951 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 952 | msg->data = readl(iommu->reg + DMAR_FEDATA_REG); | ||
| 953 | msg->address_lo = readl(iommu->reg + DMAR_FEADDR_REG); | ||
| 954 | msg->address_hi = readl(iommu->reg + DMAR_FEUADDR_REG); | ||
| 955 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 956 | } | ||
| 957 | |||
| 958 | static int dmar_fault_do_one(struct intel_iommu *iommu, int type, | ||
| 959 | u8 fault_reason, u16 source_id, unsigned long long addr) | ||
| 960 | { | ||
| 961 | const char *reason; | ||
| 962 | int fault_type; | ||
| 963 | |||
| 964 | reason = dmar_get_fault_reason(fault_reason, &fault_type); | ||
| 965 | |||
| 966 | if (fault_type == INTR_REMAP) | ||
| 967 | printk(KERN_ERR "INTR-REMAP: Request device [[%02x:%02x.%d] " | ||
| 968 | "fault index %llx\n" | ||
| 969 | "INTR-REMAP:[fault reason %02d] %s\n", | ||
| 970 | (source_id >> 8), PCI_SLOT(source_id & 0xFF), | ||
| 971 | PCI_FUNC(source_id & 0xFF), addr >> 48, | ||
| 972 | fault_reason, reason); | ||
| 973 | else | ||
| 974 | printk(KERN_ERR | ||
| 975 | "DMAR:[%s] Request device [%02x:%02x.%d] " | ||
| 976 | "fault addr %llx \n" | ||
| 977 | "DMAR:[fault reason %02d] %s\n", | ||
| 978 | (type ? "DMA Read" : "DMA Write"), | ||
| 979 | (source_id >> 8), PCI_SLOT(source_id & 0xFF), | ||
| 980 | PCI_FUNC(source_id & 0xFF), addr, fault_reason, reason); | ||
| 981 | return 0; | ||
| 982 | } | ||
| 983 | |||
| 984 | #define PRIMARY_FAULT_REG_LEN (16) | ||
| 985 | irqreturn_t dmar_fault(int irq, void *dev_id) | ||
| 986 | { | ||
| 987 | struct intel_iommu *iommu = dev_id; | ||
| 988 | int reg, fault_index; | ||
| 989 | u32 fault_status; | ||
| 990 | unsigned long flag; | ||
| 991 | |||
| 992 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 993 | fault_status = readl(iommu->reg + DMAR_FSTS_REG); | ||
| 994 | if (fault_status) | ||
| 995 | printk(KERN_ERR "DRHD: handling fault status reg %x\n", | ||
| 996 | fault_status); | ||
| 997 | |||
| 998 | /* TBD: ignore advanced fault log currently */ | ||
| 999 | if (!(fault_status & DMA_FSTS_PPF)) | ||
| 1000 | goto clear_rest; | ||
| 1001 | |||
| 1002 | fault_index = dma_fsts_fault_record_index(fault_status); | ||
| 1003 | reg = cap_fault_reg_offset(iommu->cap); | ||
| 1004 | while (1) { | ||
| 1005 | u8 fault_reason; | ||
| 1006 | u16 source_id; | ||
| 1007 | u64 guest_addr; | ||
| 1008 | int type; | ||
| 1009 | u32 data; | ||
| 1010 | |||
| 1011 | /* highest 32 bits */ | ||
| 1012 | data = readl(iommu->reg + reg + | ||
| 1013 | fault_index * PRIMARY_FAULT_REG_LEN + 12); | ||
| 1014 | if (!(data & DMA_FRCD_F)) | ||
| 1015 | break; | ||
| 1016 | |||
| 1017 | fault_reason = dma_frcd_fault_reason(data); | ||
| 1018 | type = dma_frcd_type(data); | ||
| 1019 | |||
| 1020 | data = readl(iommu->reg + reg + | ||
| 1021 | fault_index * PRIMARY_FAULT_REG_LEN + 8); | ||
| 1022 | source_id = dma_frcd_source_id(data); | ||
| 1023 | |||
| 1024 | guest_addr = dmar_readq(iommu->reg + reg + | ||
| 1025 | fault_index * PRIMARY_FAULT_REG_LEN); | ||
| 1026 | guest_addr = dma_frcd_page_addr(guest_addr); | ||
| 1027 | /* clear the fault */ | ||
| 1028 | writel(DMA_FRCD_F, iommu->reg + reg + | ||
| 1029 | fault_index * PRIMARY_FAULT_REG_LEN + 12); | ||
| 1030 | |||
| 1031 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1032 | |||
| 1033 | dmar_fault_do_one(iommu, type, fault_reason, | ||
| 1034 | source_id, guest_addr); | ||
| 1035 | |||
| 1036 | fault_index++; | ||
| 1037 | if (fault_index > cap_num_fault_regs(iommu->cap)) | ||
| 1038 | fault_index = 0; | ||
| 1039 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1040 | } | ||
| 1041 | clear_rest: | ||
| 1042 | /* clear all the other faults */ | ||
| 1043 | fault_status = readl(iommu->reg + DMAR_FSTS_REG); | ||
| 1044 | writel(fault_status, iommu->reg + DMAR_FSTS_REG); | ||
| 1045 | |||
| 1046 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1047 | return IRQ_HANDLED; | ||
| 1048 | } | ||
| 1049 | |||
| 1050 | int dmar_set_interrupt(struct intel_iommu *iommu) | ||
| 1051 | { | ||
| 1052 | int irq, ret; | ||
| 1053 | |||
| 1054 | /* | ||
| 1055 | * Check if the fault interrupt is already initialized. | ||
| 1056 | */ | ||
| 1057 | if (iommu->irq) | ||
| 1058 | return 0; | ||
| 1059 | |||
| 1060 | irq = create_irq(); | ||
| 1061 | if (!irq) { | ||
| 1062 | printk(KERN_ERR "IOMMU: no free vectors\n"); | ||
| 1063 | return -EINVAL; | ||
| 1064 | } | ||
| 1065 | |||
| 1066 | set_irq_data(irq, iommu); | ||
| 1067 | iommu->irq = irq; | ||
| 1068 | |||
| 1069 | ret = arch_setup_dmar_msi(irq); | ||
| 1070 | if (ret) { | ||
| 1071 | set_irq_data(irq, NULL); | ||
| 1072 | iommu->irq = 0; | ||
| 1073 | destroy_irq(irq); | ||
| 1074 | return 0; | ||
| 1075 | } | ||
| 1076 | |||
| 1077 | ret = request_irq(irq, dmar_fault, 0, iommu->name, iommu); | ||
| 1078 | if (ret) | ||
| 1079 | printk(KERN_ERR "IOMMU: can't request irq\n"); | ||
| 1080 | return ret; | ||
| 1081 | } | ||
| 1082 | |||
| 1083 | int __init enable_drhd_fault_handling(void) | ||
| 1084 | { | ||
| 1085 | struct dmar_drhd_unit *drhd; | ||
| 1086 | |||
| 1087 | /* | ||
| 1088 | * Enable fault control interrupt. | ||
| 1089 | */ | ||
| 1090 | for_each_drhd_unit(drhd) { | ||
| 1091 | int ret; | ||
| 1092 | struct intel_iommu *iommu = drhd->iommu; | ||
| 1093 | ret = dmar_set_interrupt(iommu); | ||
| 1094 | |||
| 1095 | if (ret) { | ||
| 1096 | printk(KERN_ERR "DRHD %Lx: failed to enable fault, " | ||
| 1097 | " interrupt, ret %d\n", | ||
| 1098 | (unsigned long long)drhd->reg_base_addr, ret); | ||
| 1099 | return -1; | ||
| 1100 | } | ||
| 1101 | } | ||
| 1102 | |||
| 1103 | return 0; | ||
| 1104 | } | ||
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c index f3f686581a90..ef167b8b047d 100644 --- a/drivers/pci/intel-iommu.c +++ b/drivers/pci/intel-iommu.c | |||
| @@ -1004,194 +1004,6 @@ static int iommu_disable_translation(struct intel_iommu *iommu) | |||
| 1004 | return 0; | 1004 | return 0; |
| 1005 | } | 1005 | } |
| 1006 | 1006 | ||
| 1007 | /* iommu interrupt handling. Most stuff are MSI-like. */ | ||
| 1008 | |||
| 1009 | static const char *fault_reason_strings[] = | ||
| 1010 | { | ||
| 1011 | "Software", | ||
| 1012 | "Present bit in root entry is clear", | ||
| 1013 | "Present bit in context entry is clear", | ||
| 1014 | "Invalid context entry", | ||
| 1015 | "Access beyond MGAW", | ||
| 1016 | "PTE Write access is not set", | ||
| 1017 | "PTE Read access is not set", | ||
| 1018 | "Next page table ptr is invalid", | ||
| 1019 | "Root table address invalid", | ||
| 1020 | "Context table ptr is invalid", | ||
| 1021 | "non-zero reserved fields in RTP", | ||
| 1022 | "non-zero reserved fields in CTP", | ||
| 1023 | "non-zero reserved fields in PTE", | ||
| 1024 | }; | ||
| 1025 | #define MAX_FAULT_REASON_IDX (ARRAY_SIZE(fault_reason_strings) - 1) | ||
| 1026 | |||
| 1027 | const char *dmar_get_fault_reason(u8 fault_reason) | ||
| 1028 | { | ||
| 1029 | if (fault_reason > MAX_FAULT_REASON_IDX) | ||
| 1030 | return "Unknown"; | ||
| 1031 | else | ||
| 1032 | return fault_reason_strings[fault_reason]; | ||
| 1033 | } | ||
| 1034 | |||
| 1035 | void dmar_msi_unmask(unsigned int irq) | ||
| 1036 | { | ||
| 1037 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 1038 | unsigned long flag; | ||
| 1039 | |||
| 1040 | /* unmask it */ | ||
| 1041 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1042 | writel(0, iommu->reg + DMAR_FECTL_REG); | ||
| 1043 | /* Read a reg to force flush the post write */ | ||
| 1044 | readl(iommu->reg + DMAR_FECTL_REG); | ||
| 1045 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1046 | } | ||
| 1047 | |||
| 1048 | void dmar_msi_mask(unsigned int irq) | ||
| 1049 | { | ||
| 1050 | unsigned long flag; | ||
| 1051 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 1052 | |||
| 1053 | /* mask it */ | ||
| 1054 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1055 | writel(DMA_FECTL_IM, iommu->reg + DMAR_FECTL_REG); | ||
| 1056 | /* Read a reg to force flush the post write */ | ||
| 1057 | readl(iommu->reg + DMAR_FECTL_REG); | ||
| 1058 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1059 | } | ||
| 1060 | |||
| 1061 | void dmar_msi_write(int irq, struct msi_msg *msg) | ||
| 1062 | { | ||
| 1063 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 1064 | unsigned long flag; | ||
| 1065 | |||
| 1066 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1067 | writel(msg->data, iommu->reg + DMAR_FEDATA_REG); | ||
| 1068 | writel(msg->address_lo, iommu->reg + DMAR_FEADDR_REG); | ||
| 1069 | writel(msg->address_hi, iommu->reg + DMAR_FEUADDR_REG); | ||
| 1070 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1071 | } | ||
| 1072 | |||
| 1073 | void dmar_msi_read(int irq, struct msi_msg *msg) | ||
| 1074 | { | ||
| 1075 | struct intel_iommu *iommu = get_irq_data(irq); | ||
| 1076 | unsigned long flag; | ||
| 1077 | |||
| 1078 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1079 | msg->data = readl(iommu->reg + DMAR_FEDATA_REG); | ||
| 1080 | msg->address_lo = readl(iommu->reg + DMAR_FEADDR_REG); | ||
| 1081 | msg->address_hi = readl(iommu->reg + DMAR_FEUADDR_REG); | ||
| 1082 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1083 | } | ||
| 1084 | |||
| 1085 | static int iommu_page_fault_do_one(struct intel_iommu *iommu, int type, | ||
| 1086 | u8 fault_reason, u16 source_id, unsigned long long addr) | ||
| 1087 | { | ||
| 1088 | const char *reason; | ||
| 1089 | |||
| 1090 | reason = dmar_get_fault_reason(fault_reason); | ||
| 1091 | |||
| 1092 | printk(KERN_ERR | ||
| 1093 | "DMAR:[%s] Request device [%02x:%02x.%d] " | ||
| 1094 | "fault addr %llx \n" | ||
| 1095 | "DMAR:[fault reason %02d] %s\n", | ||
| 1096 | (type ? "DMA Read" : "DMA Write"), | ||
| 1097 | (source_id >> 8), PCI_SLOT(source_id & 0xFF), | ||
| 1098 | PCI_FUNC(source_id & 0xFF), addr, fault_reason, reason); | ||
| 1099 | return 0; | ||
| 1100 | } | ||
| 1101 | |||
| 1102 | #define PRIMARY_FAULT_REG_LEN (16) | ||
| 1103 | static irqreturn_t iommu_page_fault(int irq, void *dev_id) | ||
| 1104 | { | ||
| 1105 | struct intel_iommu *iommu = dev_id; | ||
| 1106 | int reg, fault_index; | ||
| 1107 | u32 fault_status; | ||
| 1108 | unsigned long flag; | ||
| 1109 | |||
| 1110 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1111 | fault_status = readl(iommu->reg + DMAR_FSTS_REG); | ||
| 1112 | |||
| 1113 | /* TBD: ignore advanced fault log currently */ | ||
| 1114 | if (!(fault_status & DMA_FSTS_PPF)) | ||
| 1115 | goto clear_overflow; | ||
| 1116 | |||
| 1117 | fault_index = dma_fsts_fault_record_index(fault_status); | ||
| 1118 | reg = cap_fault_reg_offset(iommu->cap); | ||
| 1119 | while (1) { | ||
| 1120 | u8 fault_reason; | ||
| 1121 | u16 source_id; | ||
| 1122 | u64 guest_addr; | ||
| 1123 | int type; | ||
| 1124 | u32 data; | ||
| 1125 | |||
| 1126 | /* highest 32 bits */ | ||
| 1127 | data = readl(iommu->reg + reg + | ||
| 1128 | fault_index * PRIMARY_FAULT_REG_LEN + 12); | ||
| 1129 | if (!(data & DMA_FRCD_F)) | ||
| 1130 | break; | ||
| 1131 | |||
| 1132 | fault_reason = dma_frcd_fault_reason(data); | ||
| 1133 | type = dma_frcd_type(data); | ||
| 1134 | |||
| 1135 | data = readl(iommu->reg + reg + | ||
| 1136 | fault_index * PRIMARY_FAULT_REG_LEN + 8); | ||
| 1137 | source_id = dma_frcd_source_id(data); | ||
| 1138 | |||
| 1139 | guest_addr = dmar_readq(iommu->reg + reg + | ||
| 1140 | fault_index * PRIMARY_FAULT_REG_LEN); | ||
| 1141 | guest_addr = dma_frcd_page_addr(guest_addr); | ||
| 1142 | /* clear the fault */ | ||
| 1143 | writel(DMA_FRCD_F, iommu->reg + reg + | ||
| 1144 | fault_index * PRIMARY_FAULT_REG_LEN + 12); | ||
| 1145 | |||
| 1146 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1147 | |||
| 1148 | iommu_page_fault_do_one(iommu, type, fault_reason, | ||
| 1149 | source_id, guest_addr); | ||
| 1150 | |||
| 1151 | fault_index++; | ||
| 1152 | if (fault_index > cap_num_fault_regs(iommu->cap)) | ||
| 1153 | fault_index = 0; | ||
| 1154 | spin_lock_irqsave(&iommu->register_lock, flag); | ||
| 1155 | } | ||
| 1156 | clear_overflow: | ||
| 1157 | /* clear primary fault overflow */ | ||
| 1158 | fault_status = readl(iommu->reg + DMAR_FSTS_REG); | ||
| 1159 | if (fault_status & DMA_FSTS_PFO) | ||
| 1160 | writel(DMA_FSTS_PFO, iommu->reg + DMAR_FSTS_REG); | ||
| 1161 | |||
| 1162 | spin_unlock_irqrestore(&iommu->register_lock, flag); | ||
| 1163 | return IRQ_HANDLED; | ||
| 1164 | } | ||
| 1165 | |||
| 1166 | int dmar_set_interrupt(struct intel_iommu *iommu) | ||
| 1167 | { | ||
| 1168 | int irq, ret; | ||
| 1169 | |||
| 1170 | irq = create_irq(); | ||
| 1171 | if (!irq) { | ||
| 1172 | printk(KERN_ERR "IOMMU: no free vectors\n"); | ||
| 1173 | return -EINVAL; | ||
| 1174 | } | ||
| 1175 | |||
| 1176 | set_irq_data(irq, iommu); | ||
| 1177 | iommu->irq = irq; | ||
| 1178 | |||
| 1179 | ret = arch_setup_dmar_msi(irq); | ||
| 1180 | if (ret) { | ||
| 1181 | set_irq_data(irq, NULL); | ||
| 1182 | iommu->irq = 0; | ||
| 1183 | destroy_irq(irq); | ||
| 1184 | return 0; | ||
| 1185 | } | ||
| 1186 | |||
| 1187 | /* Force fault register is cleared */ | ||
| 1188 | iommu_page_fault(irq, iommu); | ||
| 1189 | |||
| 1190 | ret = request_irq(irq, iommu_page_fault, 0, iommu->name, iommu); | ||
| 1191 | if (ret) | ||
| 1192 | printk(KERN_ERR "IOMMU: can't request irq\n"); | ||
| 1193 | return ret; | ||
| 1194 | } | ||
| 1195 | 1007 | ||
| 1196 | static int iommu_init_domains(struct intel_iommu *iommu) | 1008 | static int iommu_init_domains(struct intel_iommu *iommu) |
| 1197 | { | 1009 | { |
| @@ -1987,7 +1799,7 @@ static int __init init_dmars(void) | |||
| 1987 | struct dmar_rmrr_unit *rmrr; | 1799 | struct dmar_rmrr_unit *rmrr; |
| 1988 | struct pci_dev *pdev; | 1800 | struct pci_dev *pdev; |
| 1989 | struct intel_iommu *iommu; | 1801 | struct intel_iommu *iommu; |
| 1990 | int i, ret, unit = 0; | 1802 | int i, ret; |
| 1991 | 1803 | ||
| 1992 | /* | 1804 | /* |
| 1993 | * for each drhd | 1805 | * for each drhd |
| @@ -2043,11 +1855,40 @@ static int __init init_dmars(void) | |||
| 2043 | } | 1855 | } |
| 2044 | } | 1856 | } |
| 2045 | 1857 | ||
| 1858 | /* | ||
| 1859 | * Start from the sane iommu hardware state. | ||
| 1860 | */ | ||
| 1861 | for_each_drhd_unit(drhd) { | ||
| 1862 | if (drhd->ignored) | ||
| 1863 | continue; | ||
| 1864 | |||
| 1865 | iommu = drhd->iommu; | ||
| 1866 | |||
| 1867 | /* | ||
| 1868 | * If the queued invalidation is already initialized by us | ||
| 1869 | * (for example, while enabling interrupt-remapping) then | ||
| 1870 | * we got the things already rolling from a sane state. | ||
| 1871 | */ | ||
| 1872 | if (iommu->qi) | ||
| 1873 | continue; | ||
| 1874 | |||
| 1875 | /* | ||
| 1876 | * Clear any previous faults. | ||
| 1877 | */ | ||
| 1878 | dmar_fault(-1, iommu); | ||
| 1879 | /* | ||
| 1880 | * Disable queued invalidation if supported and already enabled | ||
| 1881 | * before OS handover. | ||
| 1882 | */ | ||
| 1883 | dmar_disable_qi(iommu); | ||
| 1884 | } | ||
| 1885 | |||
| 2046 | for_each_drhd_unit(drhd) { | 1886 | for_each_drhd_unit(drhd) { |
| 2047 | if (drhd->ignored) | 1887 | if (drhd->ignored) |
| 2048 | continue; | 1888 | continue; |
| 2049 | 1889 | ||
| 2050 | iommu = drhd->iommu; | 1890 | iommu = drhd->iommu; |
| 1891 | |||
| 2051 | if (dmar_enable_qi(iommu)) { | 1892 | if (dmar_enable_qi(iommu)) { |
| 2052 | /* | 1893 | /* |
| 2053 | * Queued Invalidate not enabled, use Register Based | 1894 | * Queued Invalidate not enabled, use Register Based |
| @@ -2109,7 +1950,6 @@ static int __init init_dmars(void) | |||
| 2109 | if (drhd->ignored) | 1950 | if (drhd->ignored) |
| 2110 | continue; | 1951 | continue; |
| 2111 | iommu = drhd->iommu; | 1952 | iommu = drhd->iommu; |
| 2112 | sprintf (iommu->name, "dmar%d", unit++); | ||
| 2113 | 1953 | ||
| 2114 | iommu_flush_write_buffer(iommu); | 1954 | iommu_flush_write_buffer(iommu); |
| 2115 | 1955 | ||
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c index 9d07a05d26f1..b041a409f4a7 100644 --- a/drivers/pci/intr_remapping.c +++ b/drivers/pci/intr_remapping.c | |||
| @@ -117,21 +117,22 @@ int get_irte(int irq, struct irte *entry) | |||
| 117 | { | 117 | { |
| 118 | int index; | 118 | int index; |
| 119 | struct irq_2_iommu *irq_iommu; | 119 | struct irq_2_iommu *irq_iommu; |
| 120 | unsigned long flags; | ||
| 120 | 121 | ||
| 121 | if (!entry) | 122 | if (!entry) |
| 122 | return -1; | 123 | return -1; |
| 123 | 124 | ||
| 124 | spin_lock(&irq_2_ir_lock); | 125 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 125 | irq_iommu = valid_irq_2_iommu(irq); | 126 | irq_iommu = valid_irq_2_iommu(irq); |
| 126 | if (!irq_iommu) { | 127 | if (!irq_iommu) { |
| 127 | spin_unlock(&irq_2_ir_lock); | 128 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 128 | return -1; | 129 | return -1; |
| 129 | } | 130 | } |
| 130 | 131 | ||
| 131 | index = irq_iommu->irte_index + irq_iommu->sub_handle; | 132 | index = irq_iommu->irte_index + irq_iommu->sub_handle; |
| 132 | *entry = *(irq_iommu->iommu->ir_table->base + index); | 133 | *entry = *(irq_iommu->iommu->ir_table->base + index); |
| 133 | 134 | ||
| 134 | spin_unlock(&irq_2_ir_lock); | 135 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 135 | return 0; | 136 | return 0; |
| 136 | } | 137 | } |
| 137 | 138 | ||
| @@ -141,6 +142,7 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | |||
| 141 | struct irq_2_iommu *irq_iommu; | 142 | struct irq_2_iommu *irq_iommu; |
| 142 | u16 index, start_index; | 143 | u16 index, start_index; |
| 143 | unsigned int mask = 0; | 144 | unsigned int mask = 0; |
| 145 | unsigned long flags; | ||
| 144 | int i; | 146 | int i; |
| 145 | 147 | ||
| 146 | if (!count) | 148 | if (!count) |
| @@ -170,7 +172,7 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | |||
| 170 | return -1; | 172 | return -1; |
| 171 | } | 173 | } |
| 172 | 174 | ||
| 173 | spin_lock(&irq_2_ir_lock); | 175 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 174 | do { | 176 | do { |
| 175 | for (i = index; i < index + count; i++) | 177 | for (i = index; i < index + count; i++) |
| 176 | if (table->base[i].present) | 178 | if (table->base[i].present) |
| @@ -182,7 +184,7 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | |||
| 182 | index = (index + count) % INTR_REMAP_TABLE_ENTRIES; | 184 | index = (index + count) % INTR_REMAP_TABLE_ENTRIES; |
| 183 | 185 | ||
| 184 | if (index == start_index) { | 186 | if (index == start_index) { |
| 185 | spin_unlock(&irq_2_ir_lock); | 187 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 186 | printk(KERN_ERR "can't allocate an IRTE\n"); | 188 | printk(KERN_ERR "can't allocate an IRTE\n"); |
| 187 | return -1; | 189 | return -1; |
| 188 | } | 190 | } |
| @@ -193,7 +195,7 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | |||
| 193 | 195 | ||
| 194 | irq_iommu = irq_2_iommu_alloc(irq); | 196 | irq_iommu = irq_2_iommu_alloc(irq); |
| 195 | if (!irq_iommu) { | 197 | if (!irq_iommu) { |
| 196 | spin_unlock(&irq_2_ir_lock); | 198 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 197 | printk(KERN_ERR "can't allocate irq_2_iommu\n"); | 199 | printk(KERN_ERR "can't allocate irq_2_iommu\n"); |
| 198 | return -1; | 200 | return -1; |
| 199 | } | 201 | } |
| @@ -203,7 +205,7 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | |||
| 203 | irq_iommu->sub_handle = 0; | 205 | irq_iommu->sub_handle = 0; |
| 204 | irq_iommu->irte_mask = mask; | 206 | irq_iommu->irte_mask = mask; |
| 205 | 207 | ||
| 206 | spin_unlock(&irq_2_ir_lock); | 208 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 207 | 209 | ||
| 208 | return index; | 210 | return index; |
| 209 | } | 211 | } |
| @@ -223,30 +225,32 @@ int map_irq_to_irte_handle(int irq, u16 *sub_handle) | |||
| 223 | { | 225 | { |
| 224 | int index; | 226 | int index; |
| 225 | struct irq_2_iommu *irq_iommu; | 227 | struct irq_2_iommu *irq_iommu; |
| 228 | unsigned long flags; | ||
| 226 | 229 | ||
| 227 | spin_lock(&irq_2_ir_lock); | 230 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 228 | irq_iommu = valid_irq_2_iommu(irq); | 231 | irq_iommu = valid_irq_2_iommu(irq); |
| 229 | if (!irq_iommu) { | 232 | if (!irq_iommu) { |
| 230 | spin_unlock(&irq_2_ir_lock); | 233 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 231 | return -1; | 234 | return -1; |
| 232 | } | 235 | } |
| 233 | 236 | ||
| 234 | *sub_handle = irq_iommu->sub_handle; | 237 | *sub_handle = irq_iommu->sub_handle; |
| 235 | index = irq_iommu->irte_index; | 238 | index = irq_iommu->irte_index; |
| 236 | spin_unlock(&irq_2_ir_lock); | 239 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 237 | return index; | 240 | return index; |
| 238 | } | 241 | } |
| 239 | 242 | ||
| 240 | int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle) | 243 | int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle) |
| 241 | { | 244 | { |
| 242 | struct irq_2_iommu *irq_iommu; | 245 | struct irq_2_iommu *irq_iommu; |
| 246 | unsigned long flags; | ||
| 243 | 247 | ||
| 244 | spin_lock(&irq_2_ir_lock); | 248 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 245 | 249 | ||
| 246 | irq_iommu = irq_2_iommu_alloc(irq); | 250 | irq_iommu = irq_2_iommu_alloc(irq); |
| 247 | 251 | ||
| 248 | if (!irq_iommu) { | 252 | if (!irq_iommu) { |
| 249 | spin_unlock(&irq_2_ir_lock); | 253 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 250 | printk(KERN_ERR "can't allocate irq_2_iommu\n"); | 254 | printk(KERN_ERR "can't allocate irq_2_iommu\n"); |
| 251 | return -1; | 255 | return -1; |
| 252 | } | 256 | } |
| @@ -256,7 +260,7 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle) | |||
| 256 | irq_iommu->sub_handle = subhandle; | 260 | irq_iommu->sub_handle = subhandle; |
| 257 | irq_iommu->irte_mask = 0; | 261 | irq_iommu->irte_mask = 0; |
| 258 | 262 | ||
| 259 | spin_unlock(&irq_2_ir_lock); | 263 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 260 | 264 | ||
| 261 | return 0; | 265 | return 0; |
| 262 | } | 266 | } |
| @@ -264,11 +268,12 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle) | |||
| 264 | int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index) | 268 | int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index) |
| 265 | { | 269 | { |
| 266 | struct irq_2_iommu *irq_iommu; | 270 | struct irq_2_iommu *irq_iommu; |
| 271 | unsigned long flags; | ||
| 267 | 272 | ||
| 268 | spin_lock(&irq_2_ir_lock); | 273 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 269 | irq_iommu = valid_irq_2_iommu(irq); | 274 | irq_iommu = valid_irq_2_iommu(irq); |
| 270 | if (!irq_iommu) { | 275 | if (!irq_iommu) { |
| 271 | spin_unlock(&irq_2_ir_lock); | 276 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 272 | return -1; | 277 | return -1; |
| 273 | } | 278 | } |
| 274 | 279 | ||
| @@ -277,7 +282,7 @@ int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index) | |||
| 277 | irq_iommu->sub_handle = 0; | 282 | irq_iommu->sub_handle = 0; |
| 278 | irq_2_iommu(irq)->irte_mask = 0; | 283 | irq_2_iommu(irq)->irte_mask = 0; |
| 279 | 284 | ||
| 280 | spin_unlock(&irq_2_ir_lock); | 285 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 281 | 286 | ||
| 282 | return 0; | 287 | return 0; |
| 283 | } | 288 | } |
| @@ -289,11 +294,12 @@ int modify_irte(int irq, struct irte *irte_modified) | |||
| 289 | struct irte *irte; | 294 | struct irte *irte; |
| 290 | struct intel_iommu *iommu; | 295 | struct intel_iommu *iommu; |
| 291 | struct irq_2_iommu *irq_iommu; | 296 | struct irq_2_iommu *irq_iommu; |
| 297 | unsigned long flags; | ||
| 292 | 298 | ||
| 293 | spin_lock(&irq_2_ir_lock); | 299 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 294 | irq_iommu = valid_irq_2_iommu(irq); | 300 | irq_iommu = valid_irq_2_iommu(irq); |
| 295 | if (!irq_iommu) { | 301 | if (!irq_iommu) { |
| 296 | spin_unlock(&irq_2_ir_lock); | 302 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 297 | return -1; | 303 | return -1; |
| 298 | } | 304 | } |
| 299 | 305 | ||
| @@ -302,11 +308,11 @@ int modify_irte(int irq, struct irte *irte_modified) | |||
| 302 | index = irq_iommu->irte_index + irq_iommu->sub_handle; | 308 | index = irq_iommu->irte_index + irq_iommu->sub_handle; |
| 303 | irte = &iommu->ir_table->base[index]; | 309 | irte = &iommu->ir_table->base[index]; |
| 304 | 310 | ||
| 305 | set_64bit((unsigned long *)irte, irte_modified->low | (1 << 1)); | 311 | set_64bit((unsigned long *)irte, irte_modified->low); |
| 306 | __iommu_flush_cache(iommu, irte, sizeof(*irte)); | 312 | __iommu_flush_cache(iommu, irte, sizeof(*irte)); |
| 307 | 313 | ||
| 308 | rc = qi_flush_iec(iommu, index, 0); | 314 | rc = qi_flush_iec(iommu, index, 0); |
| 309 | spin_unlock(&irq_2_ir_lock); | 315 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 310 | 316 | ||
| 311 | return rc; | 317 | return rc; |
| 312 | } | 318 | } |
| @@ -317,11 +323,12 @@ int flush_irte(int irq) | |||
| 317 | int index; | 323 | int index; |
| 318 | struct intel_iommu *iommu; | 324 | struct intel_iommu *iommu; |
| 319 | struct irq_2_iommu *irq_iommu; | 325 | struct irq_2_iommu *irq_iommu; |
| 326 | unsigned long flags; | ||
| 320 | 327 | ||
| 321 | spin_lock(&irq_2_ir_lock); | 328 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 322 | irq_iommu = valid_irq_2_iommu(irq); | 329 | irq_iommu = valid_irq_2_iommu(irq); |
| 323 | if (!irq_iommu) { | 330 | if (!irq_iommu) { |
| 324 | spin_unlock(&irq_2_ir_lock); | 331 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 325 | return -1; | 332 | return -1; |
| 326 | } | 333 | } |
| 327 | 334 | ||
| @@ -330,7 +337,7 @@ int flush_irte(int irq) | |||
| 330 | index = irq_iommu->irte_index + irq_iommu->sub_handle; | 337 | index = irq_iommu->irte_index + irq_iommu->sub_handle; |
| 331 | 338 | ||
| 332 | rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask); | 339 | rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask); |
| 333 | spin_unlock(&irq_2_ir_lock); | 340 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 334 | 341 | ||
| 335 | return rc; | 342 | return rc; |
| 336 | } | 343 | } |
| @@ -363,11 +370,12 @@ int free_irte(int irq) | |||
| 363 | struct irte *irte; | 370 | struct irte *irte; |
| 364 | struct intel_iommu *iommu; | 371 | struct intel_iommu *iommu; |
| 365 | struct irq_2_iommu *irq_iommu; | 372 | struct irq_2_iommu *irq_iommu; |
| 373 | unsigned long flags; | ||
| 366 | 374 | ||
| 367 | spin_lock(&irq_2_ir_lock); | 375 | spin_lock_irqsave(&irq_2_ir_lock, flags); |
| 368 | irq_iommu = valid_irq_2_iommu(irq); | 376 | irq_iommu = valid_irq_2_iommu(irq); |
| 369 | if (!irq_iommu) { | 377 | if (!irq_iommu) { |
| 370 | spin_unlock(&irq_2_ir_lock); | 378 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 371 | return -1; | 379 | return -1; |
| 372 | } | 380 | } |
| 373 | 381 | ||
| @@ -378,7 +386,7 @@ int free_irte(int irq) | |||
| 378 | 386 | ||
| 379 | if (!irq_iommu->sub_handle) { | 387 | if (!irq_iommu->sub_handle) { |
| 380 | for (i = 0; i < (1 << irq_iommu->irte_mask); i++) | 388 | for (i = 0; i < (1 << irq_iommu->irte_mask); i++) |
| 381 | set_64bit((unsigned long *)irte, 0); | 389 | set_64bit((unsigned long *)(irte + i), 0); |
| 382 | rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask); | 390 | rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask); |
| 383 | } | 391 | } |
| 384 | 392 | ||
| @@ -387,7 +395,7 @@ int free_irte(int irq) | |||
| 387 | irq_iommu->sub_handle = 0; | 395 | irq_iommu->sub_handle = 0; |
| 388 | irq_iommu->irte_mask = 0; | 396 | irq_iommu->irte_mask = 0; |
| 389 | 397 | ||
| 390 | spin_unlock(&irq_2_ir_lock); | 398 | spin_unlock_irqrestore(&irq_2_ir_lock, flags); |
| 391 | 399 | ||
| 392 | return rc; | 400 | return rc; |
| 393 | } | 401 | } |
| @@ -439,12 +447,12 @@ static int setup_intr_remapping(struct intel_iommu *iommu, int mode) | |||
| 439 | struct page *pages; | 447 | struct page *pages; |
| 440 | 448 | ||
| 441 | ir_table = iommu->ir_table = kzalloc(sizeof(struct ir_table), | 449 | ir_table = iommu->ir_table = kzalloc(sizeof(struct ir_table), |
| 442 | GFP_KERNEL); | 450 | GFP_ATOMIC); |
| 443 | 451 | ||
| 444 | if (!iommu->ir_table) | 452 | if (!iommu->ir_table) |
| 445 | return -ENOMEM; | 453 | return -ENOMEM; |
| 446 | 454 | ||
| 447 | pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, INTR_REMAP_PAGE_ORDER); | 455 | pages = alloc_pages(GFP_ATOMIC | __GFP_ZERO, INTR_REMAP_PAGE_ORDER); |
| 448 | 456 | ||
| 449 | if (!pages) { | 457 | if (!pages) { |
| 450 | printk(KERN_ERR "failed to allocate pages of order %d\n", | 458 | printk(KERN_ERR "failed to allocate pages of order %d\n", |
| @@ -459,11 +467,55 @@ static int setup_intr_remapping(struct intel_iommu *iommu, int mode) | |||
| 459 | return 0; | 467 | return 0; |
| 460 | } | 468 | } |
| 461 | 469 | ||
| 470 | /* | ||
| 471 | * Disable Interrupt Remapping. | ||
| 472 | */ | ||
| 473 | static void disable_intr_remapping(struct intel_iommu *iommu) | ||
| 474 | { | ||
| 475 | unsigned long flags; | ||
| 476 | u32 sts; | ||
| 477 | |||
| 478 | if (!ecap_ir_support(iommu->ecap)) | ||
| 479 | return; | ||
| 480 | |||
| 481 | spin_lock_irqsave(&iommu->register_lock, flags); | ||
| 482 | |||
| 483 | sts = dmar_readq(iommu->reg + DMAR_GSTS_REG); | ||
| 484 | if (!(sts & DMA_GSTS_IRES)) | ||
| 485 | goto end; | ||
| 486 | |||
| 487 | iommu->gcmd &= ~DMA_GCMD_IRE; | ||
| 488 | writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG); | ||
| 489 | |||
| 490 | IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, | ||
| 491 | readl, !(sts & DMA_GSTS_IRES), sts); | ||
| 492 | |||
| 493 | end: | ||
| 494 | spin_unlock_irqrestore(&iommu->register_lock, flags); | ||
| 495 | } | ||
| 496 | |||
| 462 | int __init enable_intr_remapping(int eim) | 497 | int __init enable_intr_remapping(int eim) |
| 463 | { | 498 | { |
| 464 | struct dmar_drhd_unit *drhd; | 499 | struct dmar_drhd_unit *drhd; |
| 465 | int setup = 0; | 500 | int setup = 0; |
| 466 | 501 | ||
| 502 | for_each_drhd_unit(drhd) { | ||
| 503 | struct intel_iommu *iommu = drhd->iommu; | ||
| 504 | |||
| 505 | /* | ||
| 506 | * Clear previous faults. | ||
| 507 | */ | ||
| 508 | dmar_fault(-1, iommu); | ||
| 509 | |||
| 510 | /* | ||
| 511 | * Disable intr remapping and queued invalidation, if already | ||
| 512 | * enabled prior to OS handover. | ||
| 513 | */ | ||
| 514 | disable_intr_remapping(iommu); | ||
| 515 | |||
| 516 | dmar_disable_qi(iommu); | ||
| 517 | } | ||
| 518 | |||
| 467 | /* | 519 | /* |
| 468 | * check for the Interrupt-remapping support | 520 | * check for the Interrupt-remapping support |
| 469 | */ | 521 | */ |
diff --git a/include/linux/dmar.h b/include/linux/dmar.h index f28440784cf0..2f3427468956 100644 --- a/include/linux/dmar.h +++ b/include/linux/dmar.h | |||
| @@ -24,10 +24,10 @@ | |||
| 24 | #include <linux/acpi.h> | 24 | #include <linux/acpi.h> |
| 25 | #include <linux/types.h> | 25 | #include <linux/types.h> |
| 26 | #include <linux/msi.h> | 26 | #include <linux/msi.h> |
| 27 | #include <linux/irqreturn.h> | ||
| 27 | 28 | ||
| 28 | #if defined(CONFIG_DMAR) || defined(CONFIG_INTR_REMAP) | ||
| 29 | struct intel_iommu; | 29 | struct intel_iommu; |
| 30 | 30 | #if defined(CONFIG_DMAR) || defined(CONFIG_INTR_REMAP) | |
| 31 | struct dmar_drhd_unit { | 31 | struct dmar_drhd_unit { |
| 32 | struct list_head list; /* list of drhd units */ | 32 | struct list_head list; /* list of drhd units */ |
| 33 | struct acpi_dmar_header *hdr; /* ACPI header */ | 33 | struct acpi_dmar_header *hdr; /* ACPI header */ |
| @@ -49,7 +49,7 @@ extern int dmar_dev_scope_init(void); | |||
| 49 | 49 | ||
| 50 | /* Intel IOMMU detection */ | 50 | /* Intel IOMMU detection */ |
| 51 | extern void detect_intel_iommu(void); | 51 | extern void detect_intel_iommu(void); |
| 52 | 52 | extern int enable_drhd_fault_handling(void); | |
| 53 | 53 | ||
| 54 | extern int parse_ioapics_under_ir(void); | 54 | extern int parse_ioapics_under_ir(void); |
| 55 | extern int alloc_iommu(struct dmar_drhd_unit *); | 55 | extern int alloc_iommu(struct dmar_drhd_unit *); |
| @@ -63,12 +63,12 @@ static inline int dmar_table_init(void) | |||
| 63 | { | 63 | { |
| 64 | return -ENODEV; | 64 | return -ENODEV; |
| 65 | } | 65 | } |
| 66 | static inline int enable_drhd_fault_handling(void) | ||
| 67 | { | ||
| 68 | return -1; | ||
| 69 | } | ||
| 66 | #endif /* !CONFIG_DMAR && !CONFIG_INTR_REMAP */ | 70 | #endif /* !CONFIG_DMAR && !CONFIG_INTR_REMAP */ |
| 67 | 71 | ||
| 68 | #ifdef CONFIG_INTR_REMAP | ||
| 69 | extern int intr_remapping_enabled; | ||
| 70 | extern int enable_intr_remapping(int); | ||
| 71 | |||
| 72 | struct irte { | 72 | struct irte { |
| 73 | union { | 73 | union { |
| 74 | struct { | 74 | struct { |
| @@ -97,6 +97,10 @@ struct irte { | |||
| 97 | __u64 high; | 97 | __u64 high; |
| 98 | }; | 98 | }; |
| 99 | }; | 99 | }; |
| 100 | #ifdef CONFIG_INTR_REMAP | ||
| 101 | extern int intr_remapping_enabled; | ||
| 102 | extern int enable_intr_remapping(int); | ||
| 103 | |||
| 100 | extern int get_irte(int irq, struct irte *entry); | 104 | extern int get_irte(int irq, struct irte *entry); |
| 101 | extern int modify_irte(int irq, struct irte *irte_modified); | 105 | extern int modify_irte(int irq, struct irte *irte_modified); |
| 102 | extern int alloc_irte(struct intel_iommu *iommu, int irq, u16 count); | 106 | extern int alloc_irte(struct intel_iommu *iommu, int irq, u16 count); |
| @@ -111,14 +115,40 @@ extern int irq_remapped(int irq); | |||
| 111 | extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev); | 115 | extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev); |
| 112 | extern struct intel_iommu *map_ioapic_to_ir(int apic); | 116 | extern struct intel_iommu *map_ioapic_to_ir(int apic); |
| 113 | #else | 117 | #else |
| 118 | static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count) | ||
| 119 | { | ||
| 120 | return -1; | ||
| 121 | } | ||
| 122 | static inline int modify_irte(int irq, struct irte *irte_modified) | ||
| 123 | { | ||
| 124 | return -1; | ||
| 125 | } | ||
| 126 | static inline int free_irte(int irq) | ||
| 127 | { | ||
| 128 | return -1; | ||
| 129 | } | ||
| 130 | static inline int map_irq_to_irte_handle(int irq, u16 *sub_handle) | ||
| 131 | { | ||
| 132 | return -1; | ||
| 133 | } | ||
| 134 | static inline int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, | ||
| 135 | u16 sub_handle) | ||
| 136 | { | ||
| 137 | return -1; | ||
| 138 | } | ||
| 139 | static inline struct intel_iommu *map_dev_to_ir(struct pci_dev *dev) | ||
| 140 | { | ||
| 141 | return NULL; | ||
| 142 | } | ||
| 143 | static inline struct intel_iommu *map_ioapic_to_ir(int apic) | ||
| 144 | { | ||
| 145 | return NULL; | ||
| 146 | } | ||
| 114 | #define irq_remapped(irq) (0) | 147 | #define irq_remapped(irq) (0) |
| 115 | #define enable_intr_remapping(mode) (-1) | 148 | #define enable_intr_remapping(mode) (-1) |
| 116 | #define intr_remapping_enabled (0) | 149 | #define intr_remapping_enabled (0) |
| 117 | #endif | 150 | #endif |
| 118 | 151 | ||
| 119 | #ifdef CONFIG_DMAR | ||
| 120 | extern const char *dmar_get_fault_reason(u8 fault_reason); | ||
| 121 | |||
| 122 | /* Can't use the common MSI interrupt functions | 152 | /* Can't use the common MSI interrupt functions |
| 123 | * since DMAR is not a pci device | 153 | * since DMAR is not a pci device |
| 124 | */ | 154 | */ |
| @@ -127,8 +157,10 @@ extern void dmar_msi_mask(unsigned int irq); | |||
| 127 | extern void dmar_msi_read(int irq, struct msi_msg *msg); | 157 | extern void dmar_msi_read(int irq, struct msi_msg *msg); |
| 128 | extern void dmar_msi_write(int irq, struct msi_msg *msg); | 158 | extern void dmar_msi_write(int irq, struct msi_msg *msg); |
| 129 | extern int dmar_set_interrupt(struct intel_iommu *iommu); | 159 | extern int dmar_set_interrupt(struct intel_iommu *iommu); |
| 160 | extern irqreturn_t dmar_fault(int irq, void *dev_id); | ||
| 130 | extern int arch_setup_dmar_msi(unsigned int irq); | 161 | extern int arch_setup_dmar_msi(unsigned int irq); |
| 131 | 162 | ||
| 163 | #ifdef CONFIG_DMAR | ||
| 132 | extern int iommu_detected, no_iommu; | 164 | extern int iommu_detected, no_iommu; |
| 133 | extern struct list_head dmar_rmrr_units; | 165 | extern struct list_head dmar_rmrr_units; |
| 134 | struct dmar_rmrr_unit { | 166 | struct dmar_rmrr_unit { |
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h index d2e3cbfba14f..78c1262e8704 100644 --- a/include/linux/intel-iommu.h +++ b/include/linux/intel-iommu.h | |||
| @@ -292,6 +292,8 @@ struct intel_iommu { | |||
| 292 | spinlock_t register_lock; /* protect register handling */ | 292 | spinlock_t register_lock; /* protect register handling */ |
| 293 | int seq_id; /* sequence id of the iommu */ | 293 | int seq_id; /* sequence id of the iommu */ |
| 294 | int agaw; /* agaw of this iommu */ | 294 | int agaw; /* agaw of this iommu */ |
| 295 | unsigned int irq; | ||
| 296 | unsigned char name[13]; /* Device Name */ | ||
| 295 | 297 | ||
| 296 | #ifdef CONFIG_DMAR | 298 | #ifdef CONFIG_DMAR |
| 297 | unsigned long *domain_ids; /* bitmap of domains */ | 299 | unsigned long *domain_ids; /* bitmap of domains */ |
| @@ -299,8 +301,6 @@ struct intel_iommu { | |||
| 299 | spinlock_t lock; /* protect context, domain ids */ | 301 | spinlock_t lock; /* protect context, domain ids */ |
| 300 | struct root_entry *root_entry; /* virtual address */ | 302 | struct root_entry *root_entry; /* virtual address */ |
| 301 | 303 | ||
| 302 | unsigned int irq; | ||
| 303 | unsigned char name[7]; /* Device Name */ | ||
| 304 | struct iommu_flush flush; | 304 | struct iommu_flush flush; |
| 305 | #endif | 305 | #endif |
| 306 | struct q_inval *qi; /* Queued invalidation info */ | 306 | struct q_inval *qi; /* Queued invalidation info */ |
| @@ -321,6 +321,7 @@ extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev); | |||
| 321 | extern int alloc_iommu(struct dmar_drhd_unit *drhd); | 321 | extern int alloc_iommu(struct dmar_drhd_unit *drhd); |
| 322 | extern void free_iommu(struct intel_iommu *iommu); | 322 | extern void free_iommu(struct intel_iommu *iommu); |
| 323 | extern int dmar_enable_qi(struct intel_iommu *iommu); | 323 | extern int dmar_enable_qi(struct intel_iommu *iommu); |
| 324 | extern void dmar_disable_qi(struct intel_iommu *iommu); | ||
| 324 | extern void qi_global_iec(struct intel_iommu *iommu); | 325 | extern void qi_global_iec(struct intel_iommu *iommu); |
| 325 | 326 | ||
| 326 | extern int qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, | 327 | extern int qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, |
diff --git a/include/linux/mm.h b/include/linux/mm.h index 065cdf8c09fb..b1ea37fc7a24 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h | |||
| @@ -104,6 +104,7 @@ extern unsigned int kobjsize(const void *objp); | |||
| 104 | #define VM_CAN_NONLINEAR 0x08000000 /* Has ->fault & does nonlinear pages */ | 104 | #define VM_CAN_NONLINEAR 0x08000000 /* Has ->fault & does nonlinear pages */ |
| 105 | #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */ | 105 | #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */ |
| 106 | #define VM_SAO 0x20000000 /* Strong Access Ordering (powerpc) */ | 106 | #define VM_SAO 0x20000000 /* Strong Access Ordering (powerpc) */ |
| 107 | #define VM_PFN_AT_MMAP 0x40000000 /* PFNMAP vma that is fully mapped at mmap time */ | ||
| 107 | 108 | ||
| 108 | #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */ | 109 | #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */ |
| 109 | #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS | 110 | #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS |
| @@ -145,7 +146,7 @@ extern pgprot_t protection_map[16]; | |||
| 145 | */ | 146 | */ |
| 146 | static inline int is_linear_pfn_mapping(struct vm_area_struct *vma) | 147 | static inline int is_linear_pfn_mapping(struct vm_area_struct *vma) |
| 147 | { | 148 | { |
| 148 | return ((vma->vm_flags & VM_PFNMAP) && vma->vm_pgoff); | 149 | return (vma->vm_flags & VM_PFN_AT_MMAP); |
| 149 | } | 150 | } |
| 150 | 151 | ||
| 151 | static inline int is_pfn_mapping(struct vm_area_struct *vma) | 152 | static inline int is_pfn_mapping(struct vm_area_struct *vma) |
diff --git a/mm/memory.c b/mm/memory.c index baa999e87cd2..2032ad2fc34b 100644 --- a/mm/memory.c +++ b/mm/memory.c | |||
| @@ -1665,9 +1665,10 @@ int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr, | |||
| 1665 | * behaviour that some programs depend on. We mark the "original" | 1665 | * behaviour that some programs depend on. We mark the "original" |
| 1666 | * un-COW'ed pages by matching them up with "vma->vm_pgoff". | 1666 | * un-COW'ed pages by matching them up with "vma->vm_pgoff". |
| 1667 | */ | 1667 | */ |
| 1668 | if (addr == vma->vm_start && end == vma->vm_end) | 1668 | if (addr == vma->vm_start && end == vma->vm_end) { |
| 1669 | vma->vm_pgoff = pfn; | 1669 | vma->vm_pgoff = pfn; |
| 1670 | else if (is_cow_mapping(vma->vm_flags)) | 1670 | vma->vm_flags |= VM_PFN_AT_MMAP; |
| 1671 | } else if (is_cow_mapping(vma->vm_flags)) | ||
| 1671 | return -EINVAL; | 1672 | return -EINVAL; |
| 1672 | 1673 | ||
| 1673 | vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP; | 1674 | vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP; |
| @@ -1679,6 +1680,7 @@ int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr, | |||
| 1679 | * needed from higher level routine calling unmap_vmas | 1680 | * needed from higher level routine calling unmap_vmas |
| 1680 | */ | 1681 | */ |
| 1681 | vma->vm_flags &= ~(VM_IO | VM_RESERVED | VM_PFNMAP); | 1682 | vma->vm_flags &= ~(VM_IO | VM_RESERVED | VM_PFNMAP); |
| 1683 | vma->vm_flags &= ~VM_PFN_AT_MMAP; | ||
| 1682 | return -EINVAL; | 1684 | return -EINVAL; |
| 1683 | } | 1685 | } |
| 1684 | 1686 | ||
