diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-12 15:04:59 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-12 15:05:14 -0400 |
commit | 807f4f8cdd5b65a8a5fcfda266c074f6a23818dd (patch) | |
tree | 395afdf45badd02d03871c827b8baa850cbe5841 /drivers | |
parent | 1a2217a9516b134e0a0e54cb4629e1e075d97b17 (diff) | |
parent | 8daf14cf56816303d64d1a705fcbc389211ba36e (diff) |
Merge branch 'x86-core-v2-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip
This merges in:
x86/build, x86/microcode, x86/spinlocks, x86/memory-corruption-check,
x86/early-printk, x86/xsave, x86/quirks, x86/setup, x86/signal,
core/signal, x86/urgent, x86/xen
* 'x86-core-v2-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (142 commits)
x86: make processor type select depend on CONFIG_EMBEDDED
x86: extend processor type select help text
x86, amd-iommu: propagate PCI device enabling error
warnings: fix arch/x86/kernel/io_apic_64.c
warnings: fix arch/x86/kernel/early_printk.c
x86, fpu: check __clear_user() return value
x86: memory corruption check - cleanup
x86: ioperm user_regset
xen: do not reserve 2 pages of padding between hypervisor and fixmap.
xen: use spin_lock_nest_lock when pinning a pagetable
x86: xsave: set FP, SSE bits in the xsave header in the user sigcontext
x86: xsave: fix error condition in save_i387_xstate()
x86: SB450: deprioritize DMI quirks
x86: SB450: skip IRQ0 override if it is not routed to INT2 of IOAPIC
x86: replace a magic number with a named constant in the VESA boot code
x86 setup: remove IMAGE_OFFSET
x86 setup: remove DEF_INITSEG and DEF_SETUPSEG
Revert "x86: fix ghost EDD devices in /sys again"
x86 setup: fix ghost entries under /sys/firmware/edd take 3
x86: signal: remove indent in restore_sigcontext()
...
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/block/xen-blkfront.c | 2 | ||||
-rw-r--r-- | drivers/char/hvc_xen.c | 6 | ||||
-rw-r--r-- | drivers/input/xen-kbdfront.c | 4 | ||||
-rw-r--r-- | drivers/net/xen-netfront.c | 6 | ||||
-rw-r--r-- | drivers/usb/host/ehci.h | 138 | ||||
-rw-r--r-- | drivers/video/Kconfig | 2 | ||||
-rw-r--r-- | drivers/video/console/Kconfig | 16 | ||||
-rw-r--r-- | drivers/video/xen-fbfront.c | 4 | ||||
-rw-r--r-- | drivers/xen/Makefile | 1 | ||||
-rw-r--r-- | drivers/xen/balloon.c | 175 | ||||
-rw-r--r-- | drivers/xen/cpu_hotplug.c | 90 | ||||
-rw-r--r-- | drivers/xen/events.c | 40 | ||||
-rw-r--r-- | drivers/xen/grant-table.c | 2 | ||||
-rw-r--r-- | drivers/xen/xenbus/xenbus_probe.c | 8 |
14 files changed, 152 insertions, 342 deletions
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c index bff602ccccf3..1a50ae70f716 100644 --- a/drivers/block/xen-blkfront.c +++ b/drivers/block/xen-blkfront.c | |||
@@ -1066,7 +1066,7 @@ static struct xenbus_driver blkfront = { | |||
1066 | 1066 | ||
1067 | static int __init xlblk_init(void) | 1067 | static int __init xlblk_init(void) |
1068 | { | 1068 | { |
1069 | if (!is_running_on_xen()) | 1069 | if (!xen_domain()) |
1070 | return -ENODEV; | 1070 | return -ENODEV; |
1071 | 1071 | ||
1072 | if (register_blkdev(XENVBD_MAJOR, DEV_NAME)) { | 1072 | if (register_blkdev(XENVBD_MAJOR, DEV_NAME)) { |
diff --git a/drivers/char/hvc_xen.c b/drivers/char/hvc_xen.c index 6b70aa66a587..538ceea5e7df 100644 --- a/drivers/char/hvc_xen.c +++ b/drivers/char/hvc_xen.c | |||
@@ -108,8 +108,8 @@ static int __init xen_init(void) | |||
108 | { | 108 | { |
109 | struct hvc_struct *hp; | 109 | struct hvc_struct *hp; |
110 | 110 | ||
111 | if (!is_running_on_xen() || | 111 | if (!xen_pv_domain() || |
112 | is_initial_xendomain() || | 112 | xen_initial_domain() || |
113 | !xen_start_info->console.domU.evtchn) | 113 | !xen_start_info->console.domU.evtchn) |
114 | return -ENODEV; | 114 | return -ENODEV; |
115 | 115 | ||
@@ -142,7 +142,7 @@ static void __exit xen_fini(void) | |||
142 | 142 | ||
143 | static int xen_cons_init(void) | 143 | static int xen_cons_init(void) |
144 | { | 144 | { |
145 | if (!is_running_on_xen()) | 145 | if (!xen_pv_domain()) |
146 | return 0; | 146 | return 0; |
147 | 147 | ||
148 | hvc_instantiate(HVC_COOKIE, 0, &hvc_ops); | 148 | hvc_instantiate(HVC_COOKIE, 0, &hvc_ops); |
diff --git a/drivers/input/xen-kbdfront.c b/drivers/input/xen-kbdfront.c index 9ce3b3baf3a2..3ab6362f043c 100644 --- a/drivers/input/xen-kbdfront.c +++ b/drivers/input/xen-kbdfront.c | |||
@@ -335,11 +335,11 @@ static struct xenbus_driver xenkbd = { | |||
335 | 335 | ||
336 | static int __init xenkbd_init(void) | 336 | static int __init xenkbd_init(void) |
337 | { | 337 | { |
338 | if (!is_running_on_xen()) | 338 | if (!xen_domain()) |
339 | return -ENODEV; | 339 | return -ENODEV; |
340 | 340 | ||
341 | /* Nothing to do if running in dom0. */ | 341 | /* Nothing to do if running in dom0. */ |
342 | if (is_initial_xendomain()) | 342 | if (xen_initial_domain()) |
343 | return -ENODEV; | 343 | return -ENODEV; |
344 | 344 | ||
345 | return xenbus_register_frontend(&xenkbd); | 345 | return xenbus_register_frontend(&xenkbd); |
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c index c749bdba214c..3c3dd403f5dd 100644 --- a/drivers/net/xen-netfront.c +++ b/drivers/net/xen-netfront.c | |||
@@ -1794,10 +1794,10 @@ static struct xenbus_driver netfront = { | |||
1794 | 1794 | ||
1795 | static int __init netif_init(void) | 1795 | static int __init netif_init(void) |
1796 | { | 1796 | { |
1797 | if (!is_running_on_xen()) | 1797 | if (!xen_domain()) |
1798 | return -ENODEV; | 1798 | return -ENODEV; |
1799 | 1799 | ||
1800 | if (is_initial_xendomain()) | 1800 | if (xen_initial_domain()) |
1801 | return 0; | 1801 | return 0; |
1802 | 1802 | ||
1803 | printk(KERN_INFO "Initialising Xen virtual ethernet driver.\n"); | 1803 | printk(KERN_INFO "Initialising Xen virtual ethernet driver.\n"); |
@@ -1809,7 +1809,7 @@ module_init(netif_init); | |||
1809 | 1809 | ||
1810 | static void __exit netif_exit(void) | 1810 | static void __exit netif_exit(void) |
1811 | { | 1811 | { |
1812 | if (is_initial_xendomain()) | 1812 | if (xen_initial_domain()) |
1813 | return; | 1813 | return; |
1814 | 1814 | ||
1815 | xenbus_unregister_driver(&netfront); | 1815 | xenbus_unregister_driver(&netfront); |
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h index 5799298364fb..b697a13364ec 100644 --- a/drivers/usb/host/ehci.h +++ b/drivers/usb/host/ehci.h | |||
@@ -210,143 +210,7 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action) | |||
210 | 210 | ||
211 | /*-------------------------------------------------------------------------*/ | 211 | /*-------------------------------------------------------------------------*/ |
212 | 212 | ||
213 | /* EHCI register interface, corresponds to EHCI Revision 0.95 specification */ | 213 | #include <linux/usb/ehci_def.h> |
214 | |||
215 | /* Section 2.2 Host Controller Capability Registers */ | ||
216 | struct ehci_caps { | ||
217 | /* these fields are specified as 8 and 16 bit registers, | ||
218 | * but some hosts can't perform 8 or 16 bit PCI accesses. | ||
219 | */ | ||
220 | u32 hc_capbase; | ||
221 | #define HC_LENGTH(p) (((p)>>00)&0x00ff) /* bits 7:0 */ | ||
222 | #define HC_VERSION(p) (((p)>>16)&0xffff) /* bits 31:16 */ | ||
223 | u32 hcs_params; /* HCSPARAMS - offset 0x4 */ | ||
224 | #define HCS_DEBUG_PORT(p) (((p)>>20)&0xf) /* bits 23:20, debug port? */ | ||
225 | #define HCS_INDICATOR(p) ((p)&(1 << 16)) /* true: has port indicators */ | ||
226 | #define HCS_N_CC(p) (((p)>>12)&0xf) /* bits 15:12, #companion HCs */ | ||
227 | #define HCS_N_PCC(p) (((p)>>8)&0xf) /* bits 11:8, ports per CC */ | ||
228 | #define HCS_PORTROUTED(p) ((p)&(1 << 7)) /* true: port routing */ | ||
229 | #define HCS_PPC(p) ((p)&(1 << 4)) /* true: port power control */ | ||
230 | #define HCS_N_PORTS(p) (((p)>>0)&0xf) /* bits 3:0, ports on HC */ | ||
231 | |||
232 | u32 hcc_params; /* HCCPARAMS - offset 0x8 */ | ||
233 | #define HCC_EXT_CAPS(p) (((p)>>8)&0xff) /* for pci extended caps */ | ||
234 | #define HCC_ISOC_CACHE(p) ((p)&(1 << 7)) /* true: can cache isoc frame */ | ||
235 | #define HCC_ISOC_THRES(p) (((p)>>4)&0x7) /* bits 6:4, uframes cached */ | ||
236 | #define HCC_CANPARK(p) ((p)&(1 << 2)) /* true: can park on async qh */ | ||
237 | #define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1)) /* true: periodic_size changes*/ | ||
238 | #define HCC_64BIT_ADDR(p) ((p)&(1)) /* true: can use 64-bit addr */ | ||
239 | u8 portroute [8]; /* nibbles for routing - offset 0xC */ | ||
240 | } __attribute__ ((packed)); | ||
241 | |||
242 | |||
243 | /* Section 2.3 Host Controller Operational Registers */ | ||
244 | struct ehci_regs { | ||
245 | |||
246 | /* USBCMD: offset 0x00 */ | ||
247 | u32 command; | ||
248 | /* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */ | ||
249 | #define CMD_PARK (1<<11) /* enable "park" on async qh */ | ||
250 | #define CMD_PARK_CNT(c) (((c)>>8)&3) /* how many transfers to park for */ | ||
251 | #define CMD_LRESET (1<<7) /* partial reset (no ports, etc) */ | ||
252 | #define CMD_IAAD (1<<6) /* "doorbell" interrupt async advance */ | ||
253 | #define CMD_ASE (1<<5) /* async schedule enable */ | ||
254 | #define CMD_PSE (1<<4) /* periodic schedule enable */ | ||
255 | /* 3:2 is periodic frame list size */ | ||
256 | #define CMD_RESET (1<<1) /* reset HC not bus */ | ||
257 | #define CMD_RUN (1<<0) /* start/stop HC */ | ||
258 | |||
259 | /* USBSTS: offset 0x04 */ | ||
260 | u32 status; | ||
261 | #define STS_ASS (1<<15) /* Async Schedule Status */ | ||
262 | #define STS_PSS (1<<14) /* Periodic Schedule Status */ | ||
263 | #define STS_RECL (1<<13) /* Reclamation */ | ||
264 | #define STS_HALT (1<<12) /* Not running (any reason) */ | ||
265 | /* some bits reserved */ | ||
266 | /* these STS_* flags are also intr_enable bits (USBINTR) */ | ||
267 | #define STS_IAA (1<<5) /* Interrupted on async advance */ | ||
268 | #define STS_FATAL (1<<4) /* such as some PCI access errors */ | ||
269 | #define STS_FLR (1<<3) /* frame list rolled over */ | ||
270 | #define STS_PCD (1<<2) /* port change detect */ | ||
271 | #define STS_ERR (1<<1) /* "error" completion (overflow, ...) */ | ||
272 | #define STS_INT (1<<0) /* "normal" completion (short, ...) */ | ||
273 | |||
274 | /* USBINTR: offset 0x08 */ | ||
275 | u32 intr_enable; | ||
276 | |||
277 | /* FRINDEX: offset 0x0C */ | ||
278 | u32 frame_index; /* current microframe number */ | ||
279 | /* CTRLDSSEGMENT: offset 0x10 */ | ||
280 | u32 segment; /* address bits 63:32 if needed */ | ||
281 | /* PERIODICLISTBASE: offset 0x14 */ | ||
282 | u32 frame_list; /* points to periodic list */ | ||
283 | /* ASYNCLISTADDR: offset 0x18 */ | ||
284 | u32 async_next; /* address of next async queue head */ | ||
285 | |||
286 | u32 reserved [9]; | ||
287 | |||
288 | /* CONFIGFLAG: offset 0x40 */ | ||
289 | u32 configured_flag; | ||
290 | #define FLAG_CF (1<<0) /* true: we'll support "high speed" */ | ||
291 | |||
292 | /* PORTSC: offset 0x44 */ | ||
293 | u32 port_status [0]; /* up to N_PORTS */ | ||
294 | /* 31:23 reserved */ | ||
295 | #define PORT_WKOC_E (1<<22) /* wake on overcurrent (enable) */ | ||
296 | #define PORT_WKDISC_E (1<<21) /* wake on disconnect (enable) */ | ||
297 | #define PORT_WKCONN_E (1<<20) /* wake on connect (enable) */ | ||
298 | /* 19:16 for port testing */ | ||
299 | #define PORT_LED_OFF (0<<14) | ||
300 | #define PORT_LED_AMBER (1<<14) | ||
301 | #define PORT_LED_GREEN (2<<14) | ||
302 | #define PORT_LED_MASK (3<<14) | ||
303 | #define PORT_OWNER (1<<13) /* true: companion hc owns this port */ | ||
304 | #define PORT_POWER (1<<12) /* true: has power (see PPC) */ | ||
305 | #define PORT_USB11(x) (((x)&(3<<10))==(1<<10)) /* USB 1.1 device */ | ||
306 | /* 11:10 for detecting lowspeed devices (reset vs release ownership) */ | ||
307 | /* 9 reserved */ | ||
308 | #define PORT_RESET (1<<8) /* reset port */ | ||
309 | #define PORT_SUSPEND (1<<7) /* suspend port */ | ||
310 | #define PORT_RESUME (1<<6) /* resume it */ | ||
311 | #define PORT_OCC (1<<5) /* over current change */ | ||
312 | #define PORT_OC (1<<4) /* over current active */ | ||
313 | #define PORT_PEC (1<<3) /* port enable change */ | ||
314 | #define PORT_PE (1<<2) /* port enable */ | ||
315 | #define PORT_CSC (1<<1) /* connect status change */ | ||
316 | #define PORT_CONNECT (1<<0) /* device connected */ | ||
317 | #define PORT_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC) | ||
318 | } __attribute__ ((packed)); | ||
319 | |||
320 | #define USBMODE 0x68 /* USB Device mode */ | ||
321 | #define USBMODE_SDIS (1<<3) /* Stream disable */ | ||
322 | #define USBMODE_BE (1<<2) /* BE/LE endianness select */ | ||
323 | #define USBMODE_CM_HC (3<<0) /* host controller mode */ | ||
324 | #define USBMODE_CM_IDLE (0<<0) /* idle state */ | ||
325 | |||
326 | /* Appendix C, Debug port ... intended for use with special "debug devices" | ||
327 | * that can help if there's no serial console. (nonstandard enumeration.) | ||
328 | */ | ||
329 | struct ehci_dbg_port { | ||
330 | u32 control; | ||
331 | #define DBGP_OWNER (1<<30) | ||
332 | #define DBGP_ENABLED (1<<28) | ||
333 | #define DBGP_DONE (1<<16) | ||
334 | #define DBGP_INUSE (1<<10) | ||
335 | #define DBGP_ERRCODE(x) (((x)>>7)&0x07) | ||
336 | # define DBGP_ERR_BAD 1 | ||
337 | # define DBGP_ERR_SIGNAL 2 | ||
338 | #define DBGP_ERROR (1<<6) | ||
339 | #define DBGP_GO (1<<5) | ||
340 | #define DBGP_OUT (1<<4) | ||
341 | #define DBGP_LEN(x) (((x)>>0)&0x0f) | ||
342 | u32 pids; | ||
343 | #define DBGP_PID_GET(x) (((x)>>16)&0xff) | ||
344 | #define DBGP_PID_SET(data,tok) (((data)<<8)|(tok)) | ||
345 | u32 data03; | ||
346 | u32 data47; | ||
347 | u32 address; | ||
348 | #define DBGP_EPADDR(dev,ep) (((dev)<<8)|(ep)) | ||
349 | } __attribute__ ((packed)); | ||
350 | 214 | ||
351 | /*-------------------------------------------------------------------------*/ | 215 | /*-------------------------------------------------------------------------*/ |
352 | 216 | ||
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index d85a74c64b54..f79c2040758b 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig | |||
@@ -673,7 +673,6 @@ config FB_VESA | |||
673 | select FB_CFB_FILLRECT | 673 | select FB_CFB_FILLRECT |
674 | select FB_CFB_COPYAREA | 674 | select FB_CFB_COPYAREA |
675 | select FB_CFB_IMAGEBLIT | 675 | select FB_CFB_IMAGEBLIT |
676 | select VIDEO_SELECT | ||
677 | help | 676 | help |
678 | This is the frame buffer device driver for generic VESA 2.0 | 677 | This is the frame buffer device driver for generic VESA 2.0 |
679 | compliant graphic cards. The older VESA 1.2 cards are not supported. | 678 | compliant graphic cards. The older VESA 1.2 cards are not supported. |
@@ -1578,7 +1577,6 @@ config FB_CYBLA | |||
1578 | tristate "Cyberblade/i1 support" | 1577 | tristate "Cyberblade/i1 support" |
1579 | depends on FB && PCI && X86_32 && !64BIT | 1578 | depends on FB && PCI && X86_32 && !64BIT |
1580 | select FB_CFB_IMAGEBLIT | 1579 | select FB_CFB_IMAGEBLIT |
1581 | select VIDEO_SELECT | ||
1582 | ---help--- | 1580 | ---help--- |
1583 | This driver is supposed to support the Trident Cyberblade/i1 | 1581 | This driver is supposed to support the Trident Cyberblade/i1 |
1584 | graphics core integrated in the VIA VT8601A North Bridge, | 1582 | graphics core integrated in the VIA VT8601A North Bridge, |
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig index 06f87b04f207..2f50a80b413e 100644 --- a/drivers/video/console/Kconfig +++ b/drivers/video/console/Kconfig | |||
@@ -43,22 +43,6 @@ config VGACON_SOFT_SCROLLBACK_SIZE | |||
43 | buffer. Each 64KB will give you approximately 16 80x25 | 43 | buffer. Each 64KB will give you approximately 16 80x25 |
44 | screenfuls of scrollback buffer | 44 | screenfuls of scrollback buffer |
45 | 45 | ||
46 | config VIDEO_SELECT | ||
47 | bool "Video mode selection support" | ||
48 | depends on X86 && VGA_CONSOLE | ||
49 | ---help--- | ||
50 | This enables support for text mode selection on kernel startup. If | ||
51 | you want to take advantage of some high-resolution text mode your | ||
52 | card's BIOS offers, but the traditional Linux utilities like | ||
53 | SVGATextMode don't, you can say Y here and set the mode using the | ||
54 | "vga=" option from your boot loader (lilo or loadlin) or set | ||
55 | "vga=ask" which brings up a video mode menu on kernel startup. (Try | ||
56 | "man bootparam" or see the documentation of your boot loader about | ||
57 | how to pass options to the kernel.) | ||
58 | |||
59 | Read the file <file:Documentation/svga.txt> for more information | ||
60 | about the Video mode selection support. If unsure, say N. | ||
61 | |||
62 | config MDA_CONSOLE | 46 | config MDA_CONSOLE |
63 | depends on !M68K && !PARISC && ISA | 47 | depends on !M68K && !PARISC && ISA |
64 | tristate "MDA text console (dual-headed) (EXPERIMENTAL)" | 48 | tristate "MDA text console (dual-headed) (EXPERIMENTAL)" |
diff --git a/drivers/video/xen-fbfront.c b/drivers/video/xen-fbfront.c index 47ed39b52f9c..a463b3dd837b 100644 --- a/drivers/video/xen-fbfront.c +++ b/drivers/video/xen-fbfront.c | |||
@@ -680,11 +680,11 @@ static struct xenbus_driver xenfb = { | |||
680 | 680 | ||
681 | static int __init xenfb_init(void) | 681 | static int __init xenfb_init(void) |
682 | { | 682 | { |
683 | if (!is_running_on_xen()) | 683 | if (!xen_domain()) |
684 | return -ENODEV; | 684 | return -ENODEV; |
685 | 685 | ||
686 | /* Nothing to do if running in dom0. */ | 686 | /* Nothing to do if running in dom0. */ |
687 | if (is_initial_xendomain()) | 687 | if (xen_initial_domain()) |
688 | return -ENODEV; | 688 | return -ENODEV; |
689 | 689 | ||
690 | return xenbus_register_frontend(&xenfb); | 690 | return xenbus_register_frontend(&xenfb); |
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index 363286c54290..d2a8fdf0e191 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile | |||
@@ -1,4 +1,5 @@ | |||
1 | obj-y += grant-table.o features.o events.o manage.o | 1 | obj-y += grant-table.o features.o events.o manage.o |
2 | obj-y += xenbus/ | 2 | obj-y += xenbus/ |
3 | obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o | ||
3 | obj-$(CONFIG_XEN_XENCOMM) += xencomm.o | 4 | obj-$(CONFIG_XEN_XENCOMM) += xencomm.o |
4 | obj-$(CONFIG_XEN_BALLOON) += balloon.o | 5 | obj-$(CONFIG_XEN_BALLOON) += balloon.o |
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index 2e15da5459cf..8c83abc73400 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c | |||
@@ -53,7 +53,6 @@ | |||
53 | #include <asm/tlb.h> | 53 | #include <asm/tlb.h> |
54 | 54 | ||
55 | #include <xen/interface/memory.h> | 55 | #include <xen/interface/memory.h> |
56 | #include <xen/balloon.h> | ||
57 | #include <xen/xenbus.h> | 56 | #include <xen/xenbus.h> |
58 | #include <xen/features.h> | 57 | #include <xen/features.h> |
59 | #include <xen/page.h> | 58 | #include <xen/page.h> |
@@ -226,9 +225,8 @@ static int increase_reservation(unsigned long nr_pages) | |||
226 | } | 225 | } |
227 | 226 | ||
228 | set_xen_guest_handle(reservation.extent_start, frame_list); | 227 | set_xen_guest_handle(reservation.extent_start, frame_list); |
229 | reservation.nr_extents = nr_pages; | 228 | reservation.nr_extents = nr_pages; |
230 | rc = HYPERVISOR_memory_op( | 229 | rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); |
231 | XENMEM_populate_physmap, &reservation); | ||
232 | if (rc < nr_pages) { | 230 | if (rc < nr_pages) { |
233 | if (rc > 0) { | 231 | if (rc > 0) { |
234 | int ret; | 232 | int ret; |
@@ -236,7 +234,7 @@ static int increase_reservation(unsigned long nr_pages) | |||
236 | /* We hit the Xen hard limit: reprobe. */ | 234 | /* We hit the Xen hard limit: reprobe. */ |
237 | reservation.nr_extents = rc; | 235 | reservation.nr_extents = rc; |
238 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, | 236 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, |
239 | &reservation); | 237 | &reservation); |
240 | BUG_ON(ret != rc); | 238 | BUG_ON(ret != rc); |
241 | } | 239 | } |
242 | if (rc >= 0) | 240 | if (rc >= 0) |
@@ -420,7 +418,7 @@ static int __init balloon_init(void) | |||
420 | unsigned long pfn; | 418 | unsigned long pfn; |
421 | struct page *page; | 419 | struct page *page; |
422 | 420 | ||
423 | if (!is_running_on_xen()) | 421 | if (!xen_pv_domain()) |
424 | return -ENODEV; | 422 | return -ENODEV; |
425 | 423 | ||
426 | pr_info("xen_balloon: Initialising balloon driver.\n"); | 424 | pr_info("xen_balloon: Initialising balloon driver.\n"); |
@@ -464,136 +462,13 @@ static void balloon_exit(void) | |||
464 | 462 | ||
465 | module_exit(balloon_exit); | 463 | module_exit(balloon_exit); |
466 | 464 | ||
467 | static void balloon_update_driver_allowance(long delta) | 465 | #define BALLOON_SHOW(name, format, args...) \ |
468 | { | 466 | static ssize_t show_##name(struct sys_device *dev, \ |
469 | unsigned long flags; | 467 | struct sysdev_attribute *attr, \ |
470 | 468 | char *buf) \ | |
471 | spin_lock_irqsave(&balloon_lock, flags); | 469 | { \ |
472 | balloon_stats.driver_pages += delta; | 470 | return sprintf(buf, format, ##args); \ |
473 | spin_unlock_irqrestore(&balloon_lock, flags); | 471 | } \ |
474 | } | ||
475 | |||
476 | static int dealloc_pte_fn( | ||
477 | pte_t *pte, struct page *pmd_page, unsigned long addr, void *data) | ||
478 | { | ||
479 | unsigned long mfn = pte_mfn(*pte); | ||
480 | int ret; | ||
481 | struct xen_memory_reservation reservation = { | ||
482 | .nr_extents = 1, | ||
483 | .extent_order = 0, | ||
484 | .domid = DOMID_SELF | ||
485 | }; | ||
486 | set_xen_guest_handle(reservation.extent_start, &mfn); | ||
487 | set_pte_at(&init_mm, addr, pte, __pte_ma(0ull)); | ||
488 | set_phys_to_machine(__pa(addr) >> PAGE_SHIFT, INVALID_P2M_ENTRY); | ||
489 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation); | ||
490 | BUG_ON(ret != 1); | ||
491 | return 0; | ||
492 | } | ||
493 | |||
494 | static struct page **alloc_empty_pages_and_pagevec(int nr_pages) | ||
495 | { | ||
496 | unsigned long vaddr, flags; | ||
497 | struct page *page, **pagevec; | ||
498 | int i, ret; | ||
499 | |||
500 | pagevec = kmalloc(sizeof(page) * nr_pages, GFP_KERNEL); | ||
501 | if (pagevec == NULL) | ||
502 | return NULL; | ||
503 | |||
504 | for (i = 0; i < nr_pages; i++) { | ||
505 | page = pagevec[i] = alloc_page(GFP_KERNEL); | ||
506 | if (page == NULL) | ||
507 | goto err; | ||
508 | |||
509 | vaddr = (unsigned long)page_address(page); | ||
510 | |||
511 | scrub_page(page); | ||
512 | |||
513 | spin_lock_irqsave(&balloon_lock, flags); | ||
514 | |||
515 | if (xen_feature(XENFEAT_auto_translated_physmap)) { | ||
516 | unsigned long gmfn = page_to_pfn(page); | ||
517 | struct xen_memory_reservation reservation = { | ||
518 | .nr_extents = 1, | ||
519 | .extent_order = 0, | ||
520 | .domid = DOMID_SELF | ||
521 | }; | ||
522 | set_xen_guest_handle(reservation.extent_start, &gmfn); | ||
523 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, | ||
524 | &reservation); | ||
525 | if (ret == 1) | ||
526 | ret = 0; /* success */ | ||
527 | } else { | ||
528 | ret = apply_to_page_range(&init_mm, vaddr, PAGE_SIZE, | ||
529 | dealloc_pte_fn, NULL); | ||
530 | } | ||
531 | |||
532 | if (ret != 0) { | ||
533 | spin_unlock_irqrestore(&balloon_lock, flags); | ||
534 | __free_page(page); | ||
535 | goto err; | ||
536 | } | ||
537 | |||
538 | totalram_pages = --balloon_stats.current_pages; | ||
539 | |||
540 | spin_unlock_irqrestore(&balloon_lock, flags); | ||
541 | } | ||
542 | |||
543 | out: | ||
544 | schedule_work(&balloon_worker); | ||
545 | flush_tlb_all(); | ||
546 | return pagevec; | ||
547 | |||
548 | err: | ||
549 | spin_lock_irqsave(&balloon_lock, flags); | ||
550 | while (--i >= 0) | ||
551 | balloon_append(pagevec[i]); | ||
552 | spin_unlock_irqrestore(&balloon_lock, flags); | ||
553 | kfree(pagevec); | ||
554 | pagevec = NULL; | ||
555 | goto out; | ||
556 | } | ||
557 | |||
558 | static void free_empty_pages_and_pagevec(struct page **pagevec, int nr_pages) | ||
559 | { | ||
560 | unsigned long flags; | ||
561 | int i; | ||
562 | |||
563 | if (pagevec == NULL) | ||
564 | return; | ||
565 | |||
566 | spin_lock_irqsave(&balloon_lock, flags); | ||
567 | for (i = 0; i < nr_pages; i++) { | ||
568 | BUG_ON(page_count(pagevec[i]) != 1); | ||
569 | balloon_append(pagevec[i]); | ||
570 | } | ||
571 | spin_unlock_irqrestore(&balloon_lock, flags); | ||
572 | |||
573 | kfree(pagevec); | ||
574 | |||
575 | schedule_work(&balloon_worker); | ||
576 | } | ||
577 | |||
578 | static void balloon_release_driver_page(struct page *page) | ||
579 | { | ||
580 | unsigned long flags; | ||
581 | |||
582 | spin_lock_irqsave(&balloon_lock, flags); | ||
583 | balloon_append(page); | ||
584 | balloon_stats.driver_pages--; | ||
585 | spin_unlock_irqrestore(&balloon_lock, flags); | ||
586 | |||
587 | schedule_work(&balloon_worker); | ||
588 | } | ||
589 | |||
590 | |||
591 | #define BALLOON_SHOW(name, format, args...) \ | ||
592 | static ssize_t show_##name(struct sys_device *dev, \ | ||
593 | char *buf) \ | ||
594 | { \ | ||
595 | return sprintf(buf, format, ##args); \ | ||
596 | } \ | ||
597 | static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL) | 472 | static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL) |
598 | 473 | ||
599 | BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages)); | 474 | BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages)); |
@@ -604,7 +479,8 @@ BALLOON_SHOW(hard_limit_kb, | |||
604 | (balloon_stats.hard_limit!=~0UL) ? PAGES2KB(balloon_stats.hard_limit) : 0); | 479 | (balloon_stats.hard_limit!=~0UL) ? PAGES2KB(balloon_stats.hard_limit) : 0); |
605 | BALLOON_SHOW(driver_kb, "%lu\n", PAGES2KB(balloon_stats.driver_pages)); | 480 | BALLOON_SHOW(driver_kb, "%lu\n", PAGES2KB(balloon_stats.driver_pages)); |
606 | 481 | ||
607 | static ssize_t show_target_kb(struct sys_device *dev, char *buf) | 482 | static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr, |
483 | char *buf) | ||
608 | { | 484 | { |
609 | return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); | 485 | return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); |
610 | } | 486 | } |
@@ -614,19 +490,14 @@ static ssize_t store_target_kb(struct sys_device *dev, | |||
614 | const char *buf, | 490 | const char *buf, |
615 | size_t count) | 491 | size_t count) |
616 | { | 492 | { |
617 | char memstring[64], *endchar; | 493 | char *endchar; |
618 | unsigned long long target_bytes; | 494 | unsigned long long target_bytes; |
619 | 495 | ||
620 | if (!capable(CAP_SYS_ADMIN)) | 496 | if (!capable(CAP_SYS_ADMIN)) |
621 | return -EPERM; | 497 | return -EPERM; |
622 | 498 | ||
623 | if (count <= 1) | 499 | target_bytes = memparse(buf, &endchar); |
624 | return -EBADMSG; /* runt */ | ||
625 | if (count > sizeof(memstring)) | ||
626 | return -EFBIG; /* too long */ | ||
627 | strcpy(memstring, buf); | ||
628 | 500 | ||
629 | target_bytes = memparse(memstring, &endchar); | ||
630 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); | 501 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); |
631 | 502 | ||
632 | return count; | 503 | return count; |
@@ -694,20 +565,4 @@ static int register_balloon(struct sys_device *sysdev) | |||
694 | return error; | 565 | return error; |
695 | } | 566 | } |
696 | 567 | ||
697 | static void unregister_balloon(struct sys_device *sysdev) | ||
698 | { | ||
699 | int i; | ||
700 | |||
701 | sysfs_remove_group(&sysdev->kobj, &balloon_info_group); | ||
702 | for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) | ||
703 | sysdev_remove_file(sysdev, balloon_attrs[i]); | ||
704 | sysdev_unregister(sysdev); | ||
705 | sysdev_class_unregister(&balloon_sysdev_class); | ||
706 | } | ||
707 | |||
708 | static void balloon_sysfs_exit(void) | ||
709 | { | ||
710 | unregister_balloon(&balloon_sysdev); | ||
711 | } | ||
712 | |||
713 | MODULE_LICENSE("GPL"); | 568 | MODULE_LICENSE("GPL"); |
diff --git a/drivers/xen/cpu_hotplug.c b/drivers/xen/cpu_hotplug.c new file mode 100644 index 000000000000..565280ec1c6a --- /dev/null +++ b/drivers/xen/cpu_hotplug.c | |||
@@ -0,0 +1,90 @@ | |||
1 | #include <linux/notifier.h> | ||
2 | |||
3 | #include <xen/xenbus.h> | ||
4 | |||
5 | #include <asm-x86/xen/hypervisor.h> | ||
6 | #include <asm/cpu.h> | ||
7 | |||
8 | static void enable_hotplug_cpu(int cpu) | ||
9 | { | ||
10 | if (!cpu_present(cpu)) | ||
11 | arch_register_cpu(cpu); | ||
12 | |||
13 | cpu_set(cpu, cpu_present_map); | ||
14 | } | ||
15 | |||
16 | static void disable_hotplug_cpu(int cpu) | ||
17 | { | ||
18 | if (cpu_present(cpu)) | ||
19 | arch_unregister_cpu(cpu); | ||
20 | |||
21 | cpu_clear(cpu, cpu_present_map); | ||
22 | } | ||
23 | |||
24 | static void vcpu_hotplug(unsigned int cpu) | ||
25 | { | ||
26 | int err; | ||
27 | char dir[32], state[32]; | ||
28 | |||
29 | if (!cpu_possible(cpu)) | ||
30 | return; | ||
31 | |||
32 | sprintf(dir, "cpu/%u", cpu); | ||
33 | err = xenbus_scanf(XBT_NIL, dir, "availability", "%s", state); | ||
34 | if (err != 1) { | ||
35 | printk(KERN_ERR "XENBUS: Unable to read cpu state\n"); | ||
36 | return; | ||
37 | } | ||
38 | |||
39 | if (strcmp(state, "online") == 0) { | ||
40 | enable_hotplug_cpu(cpu); | ||
41 | } else if (strcmp(state, "offline") == 0) { | ||
42 | (void)cpu_down(cpu); | ||
43 | disable_hotplug_cpu(cpu); | ||
44 | } else { | ||
45 | printk(KERN_ERR "XENBUS: unknown state(%s) on CPU%d\n", | ||
46 | state, cpu); | ||
47 | } | ||
48 | } | ||
49 | |||
50 | static void handle_vcpu_hotplug_event(struct xenbus_watch *watch, | ||
51 | const char **vec, unsigned int len) | ||
52 | { | ||
53 | unsigned int cpu; | ||
54 | char *cpustr; | ||
55 | const char *node = vec[XS_WATCH_PATH]; | ||
56 | |||
57 | cpustr = strstr(node, "cpu/"); | ||
58 | if (cpustr != NULL) { | ||
59 | sscanf(cpustr, "cpu/%u", &cpu); | ||
60 | vcpu_hotplug(cpu); | ||
61 | } | ||
62 | } | ||
63 | |||
64 | static int setup_cpu_watcher(struct notifier_block *notifier, | ||
65 | unsigned long event, void *data) | ||
66 | { | ||
67 | static struct xenbus_watch cpu_watch = { | ||
68 | .node = "cpu", | ||
69 | .callback = handle_vcpu_hotplug_event}; | ||
70 | |||
71 | (void)register_xenbus_watch(&cpu_watch); | ||
72 | |||
73 | return NOTIFY_DONE; | ||
74 | } | ||
75 | |||
76 | static int __init setup_vcpu_hotplug_event(void) | ||
77 | { | ||
78 | static struct notifier_block xsn_cpu = { | ||
79 | .notifier_call = setup_cpu_watcher }; | ||
80 | |||
81 | if (!xen_pv_domain()) | ||
82 | return -ENODEV; | ||
83 | |||
84 | register_xenstore_notifier(&xsn_cpu); | ||
85 | |||
86 | return 0; | ||
87 | } | ||
88 | |||
89 | arch_initcall(setup_vcpu_hotplug_event); | ||
90 | |||
diff --git a/drivers/xen/events.c b/drivers/xen/events.c index 0e0c28574af8..c3290bc186a0 100644 --- a/drivers/xen/events.c +++ b/drivers/xen/events.c | |||
@@ -84,17 +84,6 @@ static int irq_bindcount[NR_IRQS]; | |||
84 | /* Xen will never allocate port zero for any purpose. */ | 84 | /* Xen will never allocate port zero for any purpose. */ |
85 | #define VALID_EVTCHN(chn) ((chn) != 0) | 85 | #define VALID_EVTCHN(chn) ((chn) != 0) |
86 | 86 | ||
87 | /* | ||
88 | * Force a proper event-channel callback from Xen after clearing the | ||
89 | * callback mask. We do this in a very simple manner, by making a call | ||
90 | * down into Xen. The pending flag will be checked by Xen on return. | ||
91 | */ | ||
92 | void force_evtchn_callback(void) | ||
93 | { | ||
94 | (void)HYPERVISOR_xen_version(0, NULL); | ||
95 | } | ||
96 | EXPORT_SYMBOL_GPL(force_evtchn_callback); | ||
97 | |||
98 | static struct irq_chip xen_dynamic_chip; | 87 | static struct irq_chip xen_dynamic_chip; |
99 | 88 | ||
100 | /* Constructor for packed IRQ information. */ | 89 | /* Constructor for packed IRQ information. */ |
@@ -175,6 +164,12 @@ static inline void set_evtchn(int port) | |||
175 | sync_set_bit(port, &s->evtchn_pending[0]); | 164 | sync_set_bit(port, &s->evtchn_pending[0]); |
176 | } | 165 | } |
177 | 166 | ||
167 | static inline int test_evtchn(int port) | ||
168 | { | ||
169 | struct shared_info *s = HYPERVISOR_shared_info; | ||
170 | return sync_test_bit(port, &s->evtchn_pending[0]); | ||
171 | } | ||
172 | |||
178 | 173 | ||
179 | /** | 174 | /** |
180 | * notify_remote_via_irq - send event to remote end of event channel via irq | 175 | * notify_remote_via_irq - send event to remote end of event channel via irq |
@@ -365,6 +360,10 @@ static void unbind_from_irq(unsigned int irq) | |||
365 | per_cpu(virq_to_irq, cpu_from_evtchn(evtchn)) | 360 | per_cpu(virq_to_irq, cpu_from_evtchn(evtchn)) |
366 | [index_from_irq(irq)] = -1; | 361 | [index_from_irq(irq)] = -1; |
367 | break; | 362 | break; |
363 | case IRQT_IPI: | ||
364 | per_cpu(ipi_to_irq, cpu_from_evtchn(evtchn)) | ||
365 | [index_from_irq(irq)] = -1; | ||
366 | break; | ||
368 | default: | 367 | default: |
369 | break; | 368 | break; |
370 | } | 369 | } |
@@ -743,6 +742,25 @@ void xen_clear_irq_pending(int irq) | |||
743 | clear_evtchn(evtchn); | 742 | clear_evtchn(evtchn); |
744 | } | 743 | } |
745 | 744 | ||
745 | void xen_set_irq_pending(int irq) | ||
746 | { | ||
747 | int evtchn = evtchn_from_irq(irq); | ||
748 | |||
749 | if (VALID_EVTCHN(evtchn)) | ||
750 | set_evtchn(evtchn); | ||
751 | } | ||
752 | |||
753 | bool xen_test_irq_pending(int irq) | ||
754 | { | ||
755 | int evtchn = evtchn_from_irq(irq); | ||
756 | bool ret = false; | ||
757 | |||
758 | if (VALID_EVTCHN(evtchn)) | ||
759 | ret = test_evtchn(evtchn); | ||
760 | |||
761 | return ret; | ||
762 | } | ||
763 | |||
746 | /* Poll waiting for an irq to become pending. In the usual case, the | 764 | /* Poll waiting for an irq to become pending. In the usual case, the |
747 | irq will be disabled so it won't deliver an interrupt. */ | 765 | irq will be disabled so it won't deliver an interrupt. */ |
748 | void xen_poll_irq(int irq) | 766 | void xen_poll_irq(int irq) |
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c index e9e11168616a..06592b9da83c 100644 --- a/drivers/xen/grant-table.c +++ b/drivers/xen/grant-table.c | |||
@@ -508,7 +508,7 @@ static int __devinit gnttab_init(void) | |||
508 | unsigned int max_nr_glist_frames, nr_glist_frames; | 508 | unsigned int max_nr_glist_frames, nr_glist_frames; |
509 | unsigned int nr_init_grefs; | 509 | unsigned int nr_init_grefs; |
510 | 510 | ||
511 | if (!is_running_on_xen()) | 511 | if (!xen_domain()) |
512 | return -ENODEV; | 512 | return -ENODEV; |
513 | 513 | ||
514 | nr_grant_frames = 1; | 514 | nr_grant_frames = 1; |
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c index 57ceb5346b74..7f24a98a446f 100644 --- a/drivers/xen/xenbus/xenbus_probe.c +++ b/drivers/xen/xenbus/xenbus_probe.c | |||
@@ -814,7 +814,7 @@ static int __init xenbus_probe_init(void) | |||
814 | DPRINTK(""); | 814 | DPRINTK(""); |
815 | 815 | ||
816 | err = -ENODEV; | 816 | err = -ENODEV; |
817 | if (!is_running_on_xen()) | 817 | if (!xen_domain()) |
818 | goto out_error; | 818 | goto out_error; |
819 | 819 | ||
820 | /* Register ourselves with the kernel bus subsystem */ | 820 | /* Register ourselves with the kernel bus subsystem */ |
@@ -829,7 +829,7 @@ static int __init xenbus_probe_init(void) | |||
829 | /* | 829 | /* |
830 | * Domain0 doesn't have a store_evtchn or store_mfn yet. | 830 | * Domain0 doesn't have a store_evtchn or store_mfn yet. |
831 | */ | 831 | */ |
832 | if (is_initial_xendomain()) { | 832 | if (xen_initial_domain()) { |
833 | /* dom0 not yet supported */ | 833 | /* dom0 not yet supported */ |
834 | } else { | 834 | } else { |
835 | xenstored_ready = 1; | 835 | xenstored_ready = 1; |
@@ -846,7 +846,7 @@ static int __init xenbus_probe_init(void) | |||
846 | goto out_unreg_back; | 846 | goto out_unreg_back; |
847 | } | 847 | } |
848 | 848 | ||
849 | if (!is_initial_xendomain()) | 849 | if (!xen_initial_domain()) |
850 | xenbus_probe(NULL); | 850 | xenbus_probe(NULL); |
851 | 851 | ||
852 | return 0; | 852 | return 0; |
@@ -937,7 +937,7 @@ static void wait_for_devices(struct xenbus_driver *xendrv) | |||
937 | unsigned long timeout = jiffies + 10*HZ; | 937 | unsigned long timeout = jiffies + 10*HZ; |
938 | struct device_driver *drv = xendrv ? &xendrv->driver : NULL; | 938 | struct device_driver *drv = xendrv ? &xendrv->driver : NULL; |
939 | 939 | ||
940 | if (!ready_to_wait_for_devices || !is_running_on_xen()) | 940 | if (!ready_to_wait_for_devices || !xen_domain()) |
941 | return; | 941 | return; |
942 | 942 | ||
943 | while (exists_disconnected_device(drv)) { | 943 | while (exists_disconnected_device(drv)) { |