]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/suse-2.6.27.31/patches.xen/xen3-fixup-xen
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add a patch to fix Intel E100 wake-on-lan problems.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.xen / xen3-fixup-xen
CommitLineData
2cb7cef9
BS		 1Subject: Fix Xen build wrt. Xen files coming from mainline.
2From: http://xenbits.xensource.com/linux-2.6.18-xen.hg (tip 728:832aac894efd)
3Patch-mainline: obsolete
4
5Acked-by: jbeulich@novell.com
6
7Index: head-2008-11-25/drivers/xen/Makefile
8===================================================================
9--- head-2008-11-25.orig/drivers/xen/Makefile 2008-11-25 12:33:06.000000000 +0100
10+++ head-2008-11-25/drivers/xen/Makefile 2008-11-25 12:35:56.000000000 +0100
11@@ -1,4 +1,25 @@
12-obj-y += grant-table.o features.o events.o manage.o
13+obj-y += core/
14+obj-y += console/
15+obj-y += evtchn/
16 obj-y += xenbus/
17-obj-$(CONFIG_XEN_XENCOMM) += xencomm.o
18-obj-$(CONFIG_XEN_BALLOON) += balloon.o
19+obj-y += char/
20+
21+obj-y += util.o
22+obj-$(CONFIG_XEN_BALLOON) += balloon/
23+obj-$(CONFIG_XEN_BLKDEV_BACKEND) += blkback/
24+obj-$(CONFIG_XEN_BLKDEV_TAP) += blktap/
25+obj-$(CONFIG_XEN_NETDEV_BACKEND) += netback/
26+obj-$(CONFIG_XEN_TPMDEV_BACKEND) += tpmback/
27+obj-$(CONFIG_XEN_BLKDEV_FRONTEND) += blkfront/
28+obj-$(CONFIG_XEN_NETDEV_FRONTEND) += netfront/
29+obj-$(CONFIG_XEN_PCIDEV_BACKEND) += pciback/
30+obj-$(CONFIG_XEN_PCIDEV_FRONTEND) += pcifront/
31+obj-$(CONFIG_XEN_FRAMEBUFFER) += fbfront/
32+obj-$(CONFIG_XEN_KEYBOARD) += fbfront/
33+obj-$(CONFIG_XEN_SCSI_BACKEND) += scsiback/
34+obj-$(CONFIG_XEN_SCSI_FRONTEND) += scsifront/
35+obj-$(CONFIG_XEN_PRIVCMD) += privcmd/
36+obj-$(CONFIG_XEN_GRANT_DEV) += gntdev/
37+obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_UTIL) += sfc_netutil/
38+obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_FRONTEND) += sfc_netfront/
39+obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_BACKEND) += sfc_netback/
40Index: head-2008-11-25/drivers/xen/xenbus/Makefile
41===================================================================
42--- head-2008-11-25.orig/drivers/xen/xenbus/Makefile 2008-11-25 12:33:06.000000000 +0100
43+++ head-2008-11-25/drivers/xen/xenbus/Makefile 2008-11-25 12:35:56.000000000 +0100
44@@ -1,7 +1,9 @@
45-obj-y += xenbus.o
46+obj-y += xenbus_client.o xenbus_comms.o xenbus_xs.o xenbus_probe.o
47+obj-$(CONFIG_XEN_BACKEND) += xenbus_be.o
48
49-xenbus-objs =
50-xenbus-objs += xenbus_client.o
51-xenbus-objs += xenbus_comms.o
52-xenbus-objs += xenbus_xs.o
53-xenbus-objs += xenbus_probe.o
54+xenbus_be-objs =
55+xenbus_be-objs += xenbus_backend_client.o
56+
57+xenbus-$(CONFIG_XEN_BACKEND) += xenbus_probe_backend.o
58+obj-y += $(xenbus-y) $(xenbus-m)
59+obj-$(CONFIG_XEN_XENBUS_DEV) += xenbus_dev.o
60Index: head-2008-11-25/drivers/xen/xenbus/xenbus_client.c
61===================================================================
62--- head-2008-11-25.orig/drivers/xen/xenbus/xenbus_client.c 2008-11-25 12:33:06.000000000 +0100
63+++ head-2008-11-25/drivers/xen/xenbus/xenbus_client.c 2008-11-25 12:35:56.000000000 +0100
64@@ -30,14 +30,18 @@
65 * IN THE SOFTWARE.
66 */
67
68-#include <linux/types.h>
69-#include <linux/vmalloc.h>
70-#include <asm/xen/hypervisor.h>
71-#include <xen/interface/xen.h>
72-#include <xen/interface/event_channel.h>
73-#include <xen/events.h>
74-#include <xen/grant_table.h>
75+#include <linux/slab.h>
76+#include <xen/evtchn.h>
77+#include <xen/gnttab.h>
78 #include <xen/xenbus.h>
79+#include <xen/driver_util.h>
80+
81+#ifdef HAVE_XEN_PLATFORM_COMPAT_H
82+#include <xen/platform-compat.h>
83+#endif
84+
85+#define DPRINTK(fmt, args...) \
86+ pr_debug("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
87
88 const char *xenbus_strstate(enum xenbus_state state)
89 {
90@@ -54,20 +58,6 @@ const char *xenbus_strstate(enum xenbus_
91 }
92 EXPORT_SYMBOL_GPL(xenbus_strstate);
93
94-/**
95- * xenbus_watch_path - register a watch
96- * @dev: xenbus device
97- * @path: path to watch
98- * @watch: watch to register
99- * @callback: callback to register
100- *
101- * Register a @watch on the given path, using the given xenbus_watch structure
102- * for storage, and the given @callback function as the callback. Return 0 on
103- * success, or -errno on error. On success, the given @path will be saved as
104- * @watch->node, and remains the caller's to free. On error, @watch->node will
105- * be NULL, the device will switch to %XenbusStateClosing, and the error will
106- * be saved in the store.
107- */
108 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
109 struct xenbus_watch *watch,
110 void (*callback)(struct xenbus_watch *,
111@@ -91,58 +81,26 @@ int xenbus_watch_path(struct xenbus_devi
112 EXPORT_SYMBOL_GPL(xenbus_watch_path);
113
114
115-/**
116- * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
117- * @dev: xenbus device
118- * @watch: watch to register
119- * @callback: callback to register
120- * @pathfmt: format of path to watch
121- *
122- * Register a watch on the given @path, using the given xenbus_watch
123- * structure for storage, and the given @callback function as the callback.
124- * Return 0 on success, or -errno on error. On success, the watched path
125- * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
126- * kfree(). On error, watch->node will be NULL, so the caller has nothing to
127- * free, the device will switch to %XenbusStateClosing, and the error will be
128- * saved in the store.
129- */
130-int xenbus_watch_pathfmt(struct xenbus_device *dev,
131- struct xenbus_watch *watch,
132- void (*callback)(struct xenbus_watch *,
133- const char **, unsigned int),
134- const char *pathfmt, ...)
135+int xenbus_watch_path2(struct xenbus_device *dev, const char *path,
136+ const char *path2, struct xenbus_watch *watch,
137+ void (*callback)(struct xenbus_watch *,
138+ const char **, unsigned int))
139 {
140 int err;
141- va_list ap;
142- char *path;
143-
144- va_start(ap, pathfmt);
145- path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
146- va_end(ap);
147-
148- if (!path) {
149+ char *state = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/%s", path, path2);
150+ if (!state) {
151 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
152 return -ENOMEM;
153 }
154- err = xenbus_watch_path(dev, path, watch, callback);
155+ err = xenbus_watch_path(dev, state, watch, callback);
156
157 if (err)
158- kfree(path);
159+ kfree(state);
160 return err;
161 }
162-EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
163+EXPORT_SYMBOL_GPL(xenbus_watch_path2);
164
165
166-/**
167- * xenbus_switch_state
168- * @dev: xenbus device
169- * @xbt: transaction handle
170- * @state: new state
171- *
172- * Advertise in the store a change of the given driver to the given new_state.
173- * Return 0 on success, or -errno on error. On error, the device will switch
174- * to XenbusStateClosing, and the error will be saved in the store.
175- */
176 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
177 {
178 /* We check whether the state is currently set to the given value, and
179@@ -201,13 +159,12 @@ static char *error_path(struct xenbus_de
180 }
181
182
183-static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
184- const char *fmt, va_list ap)
185+void _dev_error(struct xenbus_device *dev, int err, const char *fmt,
186+ va_list ap)
187 {
188 int ret;
189 unsigned int len;
190- char *printf_buffer = NULL;
191- char *path_buffer = NULL;
192+ char *printf_buffer = NULL, *path_buffer = NULL;
193
194 #define PRINTF_BUFFER_SIZE 4096
195 printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
196@@ -224,74 +181,51 @@ static void xenbus_va_dev_error(struct x
197 path_buffer = error_path(dev);
198
199 if (path_buffer == NULL) {
200- dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
201+ printk("xenbus: failed to write error node for %s (%s)\n",
202 dev->nodename, printf_buffer);
203 goto fail;
204 }
205
206 if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
207- dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
208+ printk("xenbus: failed to write error node for %s (%s)\n",
209 dev->nodename, printf_buffer);
210 goto fail;
211 }
212
213 fail:
214- kfree(printf_buffer);
215- kfree(path_buffer);
216+ if (printf_buffer)
217+ kfree(printf_buffer);
218+ if (path_buffer)
219+ kfree(path_buffer);
220 }
221
222
223-/**
224- * xenbus_dev_error
225- * @dev: xenbus device
226- * @err: error to report
227- * @fmt: error message format
228- *
229- * Report the given negative errno into the store, along with the given
230- * formatted message.
231- */
232-void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
233+void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,
234+ ...)
235 {
236 va_list ap;
237
238 va_start(ap, fmt);
239- xenbus_va_dev_error(dev, err, fmt, ap);
240+ _dev_error(dev, err, fmt, ap);
241 va_end(ap);
242 }
243 EXPORT_SYMBOL_GPL(xenbus_dev_error);
244
245-/**
246- * xenbus_dev_fatal
247- * @dev: xenbus device
248- * @err: error to report
249- * @fmt: error message format
250- *
251- * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
252- * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
253- * closedown of this driver and its peer.
254- */
255
256-void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
257+void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt,
258+ ...)
259 {
260 va_list ap;
261
262 va_start(ap, fmt);
263- xenbus_va_dev_error(dev, err, fmt, ap);
264+ _dev_error(dev, err, fmt, ap);
265 va_end(ap);
266
267 xenbus_switch_state(dev, XenbusStateClosing);
268 }
269 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
270
271-/**
272- * xenbus_grant_ring
273- * @dev: xenbus device
274- * @ring_mfn: mfn of ring to grant
275-
276- * Grant access to the given @ring_mfn to the peer of the given device. Return
277- * 0 on success, or -errno on error. On error, the device will switch to
278- * XenbusStateClosing, and the error will be saved in the store.
279- */
280+
281 int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn)
282 {
283 int err = gnttab_grant_foreign_access(dev->otherend_id, ring_mfn, 0);
284@@ -302,18 +236,12 @@ int xenbus_grant_ring(struct xenbus_devi
285 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
286
287
288-/**
289- * Allocate an event channel for the given xenbus_device, assigning the newly
290- * created local port to *port. Return 0 on success, or -errno on error. On
291- * error, the device will switch to XenbusStateClosing, and the error will be
292- * saved in the store.
293- */
294 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port)
295 {
296 struct evtchn_alloc_unbound alloc_unbound;
297 int err;
298
299- alloc_unbound.dom = DOMID_SELF;
300+ alloc_unbound.dom = DOMID_SELF;
301 alloc_unbound.remote_dom = dev->otherend_id;
302
303 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
304@@ -328,36 +256,6 @@ int xenbus_alloc_evtchn(struct xenbus_de
305 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
306
307
308-/**
309- * Bind to an existing interdomain event channel in another domain. Returns 0
310- * on success and stores the local port in *port. On error, returns -errno,
311- * switches the device to XenbusStateClosing, and saves the error in XenStore.
312- */
313-int xenbus_bind_evtchn(struct xenbus_device *dev, int remote_port, int *port)
314-{
315- struct evtchn_bind_interdomain bind_interdomain;
316- int err;
317-
318- bind_interdomain.remote_dom = dev->otherend_id;
319- bind_interdomain.remote_port = remote_port;
320-
321- err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
322- &bind_interdomain);
323- if (err)
324- xenbus_dev_fatal(dev, err,
325- "binding to event channel %d from domain %d",
326- remote_port, dev->otherend_id);
327- else
328- *port = bind_interdomain.local_port;
329-
330- return err;
331-}
332-EXPORT_SYMBOL_GPL(xenbus_bind_evtchn);
333-
334-
335-/**
336- * Free an existing event channel. Returns 0 on success or -errno on error.
337- */
338 int xenbus_free_evtchn(struct xenbus_device *dev, int port)
339 {
340 struct evtchn_close close;
341@@ -374,189 +272,6 @@ int xenbus_free_evtchn(struct xenbus_dev
342 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
343
344
345-/**
346- * xenbus_map_ring_valloc
347- * @dev: xenbus device
348- * @gnt_ref: grant reference
349- * @vaddr: pointer to address to be filled out by mapping
350- *
351- * Based on Rusty Russell's skeleton driver's map_page.
352- * Map a page of memory into this domain from another domain's grant table.
353- * xenbus_map_ring_valloc allocates a page of virtual address space, maps the
354- * page to that address, and sets *vaddr to that address.
355- * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
356- * or -ENOMEM on error. If an error is returned, device will switch to
357- * XenbusStateClosing and the error message will be saved in XenStore.
358- */
359-int xenbus_map_ring_valloc(struct xenbus_device *dev, int gnt_ref, void **vaddr)
360-{
361- struct gnttab_map_grant_ref op = {
362- .flags = GNTMAP_host_map,
363- .ref = gnt_ref,
364- .dom = dev->otherend_id,
365- };
366- struct vm_struct *area;
367-
368- *vaddr = NULL;
369-
370- area = xen_alloc_vm_area(PAGE_SIZE);
371- if (!area)
372- return -ENOMEM;
373-
374- op.host_addr = (unsigned long)area->addr;
375-
376- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
377- BUG();
378-
379- if (op.status != GNTST_okay) {
380- xen_free_vm_area(area);
381- xenbus_dev_fatal(dev, op.status,
382- "mapping in shared page %d from domain %d",
383- gnt_ref, dev->otherend_id);
384- return op.status;
385- }
386-
387- /* Stuff the handle in an unused field */
388- area->phys_addr = (unsigned long)op.handle;
389-
390- *vaddr = area->addr;
391- return 0;
392-}
393-EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
394-
395-
396-/**
397- * xenbus_map_ring
398- * @dev: xenbus device
399- * @gnt_ref: grant reference
400- * @handle: pointer to grant handle to be filled
401- * @vaddr: address to be mapped to
402- *
403- * Map a page of memory into this domain from another domain's grant table.
404- * xenbus_map_ring does not allocate the virtual address space (you must do
405- * this yourself!). It only maps in the page to the specified address.
406- * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
407- * or -ENOMEM on error. If an error is returned, device will switch to
408- * XenbusStateClosing and the error message will be saved in XenStore.
409- */
410-int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
411- grant_handle_t *handle, void *vaddr)
412-{
413- struct gnttab_map_grant_ref op = {
414- .host_addr = (unsigned long)vaddr,
415- .flags = GNTMAP_host_map,
416- .ref = gnt_ref,
417- .dom = dev->otherend_id,
418- };
419-
420- if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
421- BUG();
422-
423- if (op.status != GNTST_okay) {
424- xenbus_dev_fatal(dev, op.status,
425- "mapping in shared page %d from domain %d",
426- gnt_ref, dev->otherend_id);
427- } else
428- *handle = op.handle;
429-
430- return op.status;
431-}
432-EXPORT_SYMBOL_GPL(xenbus_map_ring);
433-
434-
435-/**
436- * xenbus_unmap_ring_vfree
437- * @dev: xenbus device
438- * @vaddr: addr to unmap
439- *
440- * Based on Rusty Russell's skeleton driver's unmap_page.
441- * Unmap a page of memory in this domain that was imported from another domain.
442- * Use xenbus_unmap_ring_vfree if you mapped in your memory with
443- * xenbus_map_ring_valloc (it will free the virtual address space).
444- * Returns 0 on success and returns GNTST_* on error
445- * (see xen/include/interface/grant_table.h).
446- */
447-int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
448-{
449- struct vm_struct *area;
450- struct gnttab_unmap_grant_ref op = {
451- .host_addr = (unsigned long)vaddr,
452- };
453-
454- /* It'd be nice if linux/vmalloc.h provided a find_vm_area(void *addr)
455- * method so that we don't have to muck with vmalloc internals here.
456- * We could force the user to hang on to their struct vm_struct from
457- * xenbus_map_ring_valloc, but these 6 lines considerably simplify
458- * this API.
459- */
460- read_lock(&vmlist_lock);
461- for (area = vmlist; area != NULL; area = area->next) {
462- if (area->addr == vaddr)
463- break;
464- }
465- read_unlock(&vmlist_lock);
466-
467- if (!area) {
468- xenbus_dev_error(dev, -ENOENT,
469- "can't find mapped virtual address %p", vaddr);
470- return GNTST_bad_virt_addr;
471- }
472-
473- op.handle = (grant_handle_t)area->phys_addr;
474-
475- if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
476- BUG();
477-
478- if (op.status == GNTST_okay)
479- xen_free_vm_area(area);
480- else
481- xenbus_dev_error(dev, op.status,
482- "unmapping page at handle %d error %d",
483- (int16_t)area->phys_addr, op.status);
484-
485- return op.status;
486-}
487-EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
488-
489-
490-/**
491- * xenbus_unmap_ring
492- * @dev: xenbus device
493- * @handle: grant handle
494- * @vaddr: addr to unmap
495- *
496- * Unmap a page of memory in this domain that was imported from another domain.
497- * Returns 0 on success and returns GNTST_* on error
498- * (see xen/include/interface/grant_table.h).
499- */
500-int xenbus_unmap_ring(struct xenbus_device *dev,
501- grant_handle_t handle, void *vaddr)
502-{
503- struct gnttab_unmap_grant_ref op = {
504- .host_addr = (unsigned long)vaddr,
505- .handle = handle,
506- };
507-
508- if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
509- BUG();
510-
511- if (op.status != GNTST_okay)
512- xenbus_dev_error(dev, op.status,
513- "unmapping page at handle %d error %d",
514- handle, op.status);
515-
516- return op.status;
517-}
518-EXPORT_SYMBOL_GPL(xenbus_unmap_ring);
519-
520-
521-/**
522- * xenbus_read_driver_state
523- * @path: path for driver
524- *
525- * Return the state of the driver rooted at the given store path, or
526- * XenbusStateUnknown if no state can be read.
527- */
528 enum xenbus_state xenbus_read_driver_state(const char *path)
529 {
530 enum xenbus_state result;
531Index: head-2008-11-25/drivers/xen/xenbus/xenbus_comms.c
532===================================================================
533--- head-2008-11-25.orig/drivers/xen/xenbus/xenbus_comms.c 2008-11-25 12:33:06.000000000 +0100
534+++ head-2008-11-25/drivers/xen/xenbus/xenbus_comms.c 2008-11-25 12:35:56.000000000 +0100
535@@ -34,19 +34,28 @@
536 #include <linux/interrupt.h>
537 #include <linux/sched.h>
538 #include <linux/err.h>
539+#include <linux/ptrace.h>
540+#include <linux/workqueue.h>
541+#include <xen/evtchn.h>
542 #include <xen/xenbus.h>
543-#include <asm/xen/hypervisor.h>
544-#include <xen/events.h>
545-#include <xen/page.h>
546+
547+#include <asm/hypervisor.h>
548+
549 #include "xenbus_comms.h"
550
551+#ifdef HAVE_XEN_PLATFORM_COMPAT_H
552+#include <xen/platform-compat.h>
553+#endif
554+
555 static int xenbus_irq;
556
557-static DECLARE_WORK(probe_work, xenbus_probe);
558+extern void xenbus_probe(void *);
559+extern int xenstored_ready;
560+static DECLARE_WORK(probe_work, xenbus_probe, NULL);
561
562 static DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
563
564-static irqreturn_t wake_waiting(int irq, void *unused)
565+static irqreturn_t wake_waiting(int irq, void *unused, struct pt_regs *regs)
566 {
567 if (unlikely(xenstored_ready == 0)) {
568 xenstored_ready = 1;
569@@ -82,13 +91,6 @@ static const void *get_input_chunk(XENST
570 return buf + MASK_XENSTORE_IDX(cons);
571 }
572
573-/**
574- * xb_write - low level write
575- * @data: buffer to send
576- * @len: length of buffer
577- *
578- * Returns 0 on success, error otherwise.
579- */
580 int xb_write(const void *data, unsigned len)
581 {
582 struct xenstore_domain_interface *intf = xen_store_interface;
583@@ -197,12 +199,11 @@ int xb_read(void *data, unsigned len)
584 return 0;
585 }
586
587-/**
588- * xb_init_comms - Set up interrupt handler off store event channel.
589- */
590+/* Set up interrupt handler off store event channel. */
591 int xb_init_comms(void)
592 {
593 struct xenstore_domain_interface *intf = xen_store_interface;
594+ int err;
595
596 if (intf->req_prod != intf->req_cons)
597 printk(KERN_ERR "XENBUS request ring is not quiescent "
598@@ -215,20 +216,18 @@ int xb_init_comms(void)
599 intf->rsp_cons = intf->rsp_prod;
600 }
601
602- if (xenbus_irq) {
603- /* Already have an irq; assume we're resuming */
604- rebind_evtchn_irq(xen_store_evtchn, xenbus_irq);
605- } else {
606- int err;
607- err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
608- 0, "xenbus", &xb_waitq);
609- if (err <= 0) {
610- printk(KERN_ERR "XENBUS request irq failed %i\n", err);
611- return err;
612- }
613+ if (xenbus_irq)
614+ unbind_from_irqhandler(xenbus_irq, &xb_waitq);
615
616- xenbus_irq = err;
617+ err = bind_caller_port_to_irqhandler(
618+ xen_store_evtchn, wake_waiting,
619+ 0, "xenbus", &xb_waitq);
620+ if (err <= 0) {
621+ printk(KERN_ERR "XENBUS request irq failed %i\n", err);
622+ return err;
623 }
624
625+ xenbus_irq = err;
626+
627 return 0;
628 }
629Index: head-2008-11-25/drivers/xen/xenbus/xenbus_probe.c
630===================================================================
631--- head-2008-11-25.orig/drivers/xen/xenbus/xenbus_probe.c 2008-11-25 12:33:06.000000000 +0100
632+++ head-2008-11-25/drivers/xen/xenbus/xenbus_probe.c 2008-11-25 12:35:56.000000000 +0100
633@@ -4,6 +4,7 @@
634 * Copyright (C) 2005 Rusty Russell, IBM Corporation
635 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
636 * Copyright (C) 2005, 2006 XenSource Ltd
637+ * Copyright (C) 2007 Solarflare Communications, Inc.
638 *
639 * This program is free software; you can redistribute it and/or
640 * modify it under the terms of the GNU General Public License version 2
641@@ -32,7 +33,7 @@
642
643 #define DPRINTK(fmt, args...) \
644 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
645- __func__, __LINE__, ##args)
646+ __FUNCTION__, __LINE__, ##args)
647
648 #include <linux/kernel.h>
649 #include <linux/err.h>
650@@ -41,24 +42,35 @@
651 #include <linux/fcntl.h>
652 #include <linux/mm.h>
653 #include <linux/notifier.h>
654-#include <linux/kthread.h>
655 #include <linux/mutex.h>
656-#include <linux/io.h>
657+#include <linux/module.h>
658
659+#include <asm/io.h>
660 #include <asm/page.h>
661+#include <asm/maddr.h>
662 #include <asm/pgtable.h>
663-#include <asm/xen/hypervisor.h>
664+#include <asm/hypervisor.h>
665 #include <xen/xenbus.h>
666-#include <xen/events.h>
667-#include <xen/page.h>
668+#include <xen/xen_proc.h>
669+#include <xen/evtchn.h>
670+#include <xen/features.h>
671+#ifdef MODULE
672+#include <xen/hvm.h>
673+#endif
674
675 #include "xenbus_comms.h"
676 #include "xenbus_probe.h"
677
678+#ifdef HAVE_XEN_PLATFORM_COMPAT_H
679+#include <xen/platform-compat.h>
680+#endif
681+
682 int xen_store_evtchn;
683 struct xenstore_domain_interface *xen_store_interface;
684 static unsigned long xen_store_mfn;
685
686+extern struct mutex xenwatch_mutex;
687+
688 static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
689
690 static void wait_for_devices(struct xenbus_driver *xendrv);
691@@ -88,16 +100,6 @@ int xenbus_match(struct device *_dev, st
692 return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
693 }
694
695-static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)
696-{
697- struct xenbus_device *dev = to_xenbus_device(_dev);
698-
699- if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
700- return -ENOMEM;
701-
702- return 0;
703-}
704-
705 /* device/<type>/<id> => <type>-<id> */
706 static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename)
707 {
708@@ -166,6 +168,30 @@ static int read_backend_details(struct x
709 return read_otherend_details(xendev, "backend-id", "backend");
710 }
711
712+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
713+static int xenbus_uevent_frontend(struct device *dev, char **envp,
714+ int num_envp, char *buffer, int buffer_size)
715+{
716+ struct xenbus_device *xdev;
717+ int length = 0, i = 0;
718+
719+ if (dev == NULL)
720+ return -ENODEV;
721+ xdev = to_xenbus_device(dev);
722+ if (xdev == NULL)
723+ return -ENODEV;
724+
725+ /* stuff we want to pass to /sbin/hotplug */
726+ add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
727+ "XENBUS_TYPE=%s", xdev->devicetype);
728+ add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
729+ "XENBUS_PATH=%s", xdev->nodename);
730+ add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
731+ "MODALIAS=xen:%s", xdev->devicetype);
732+
733+ return 0;
734+}
735+#endif
736
737 /* Bus type for frontend drivers. */
738 static struct xen_bus_type xenbus_frontend = {
739@@ -173,13 +199,19 @@ static struct xen_bus_type xenbus_fronte
740 .levels = 2, /* device/type/<id> */
741 .get_bus_id = frontend_bus_id,
742 .probe = xenbus_probe_frontend,
743+ .error = -ENODEV,
744 .bus = {
745 .name = "xen",
746 .match = xenbus_match,
747- .uevent = xenbus_uevent,
748+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
749 .probe = xenbus_dev_probe,
750 .remove = xenbus_dev_remove,
751 .shutdown = xenbus_dev_shutdown,
752+ .uevent = xenbus_uevent_frontend,
753+#endif
754+ },
755+ .dev = {
756+ .bus_id = "xen",
757 },
758 };
759
760@@ -196,17 +228,16 @@ static void otherend_changed(struct xenb
761 if (!dev->otherend ||
762 strncmp(dev->otherend, vec[XS_WATCH_PATH],
763 strlen(dev->otherend))) {
764- dev_dbg(&dev->dev, "Ignoring watch at %s\n",
765- vec[XS_WATCH_PATH]);
766+ DPRINTK("Ignoring watch at %s", vec[XS_WATCH_PATH]);
767 return;
768 }
769
770 state = xenbus_read_driver_state(dev->otherend);
771
772- dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
773- state, xenbus_strstate(state), dev->otherend_watch.node,
774- vec[XS_WATCH_PATH]);
775+ DPRINTK("state is %d (%s), %s, %s", state, xenbus_strstate(state),
776+ dev->otherend_watch.node, vec[XS_WATCH_PATH]);
777
778+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
779 /*
780 * Ignore xenbus transitions during shutdown. This prevents us doing
781 * work that can fail e.g., when the rootfs is gone.
782@@ -220,6 +251,7 @@ static void otherend_changed(struct xenb
783 xenbus_frontend_closed(dev);
784 return;
785 }
786+#endif
787
788 if (drv->otherend_changed)
789 drv->otherend_changed(dev, state);
790@@ -239,8 +271,8 @@ static int talk_to_otherend(struct xenbu
791
792 static int watch_otherend(struct xenbus_device *dev)
793 {
794- return xenbus_watch_pathfmt(dev, &dev->otherend_watch, otherend_changed,
795- "%s/%s", dev->otherend, "state");
796+ return xenbus_watch_path2(dev, dev->otherend, "state",
797+ &dev->otherend_watch, otherend_changed);
798 }
799
800
801@@ -266,8 +298,9 @@ int xenbus_dev_probe(struct device *_dev
802
803 err = talk_to_otherend(dev);
804 if (err) {
805- dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n",
806- dev->nodename);
807+ printk(KERN_WARNING
808+ "xenbus_probe: talk_to_otherend on %s failed.\n",
809+ dev->nodename);
810 return err;
811 }
812
813@@ -277,7 +310,8 @@ int xenbus_dev_probe(struct device *_dev
814
815 err = watch_otherend(dev);
816 if (err) {
817- dev_warn(&dev->dev, "watch_otherend on %s failed.\n",
818+ printk(KERN_WARNING
819+ "xenbus_probe: watch_otherend on %s failed.\n",
820 dev->nodename);
821 return err;
822 }
823@@ -313,43 +347,55 @@ static void xenbus_dev_shutdown(struct d
824
825 DPRINTK("%s", dev->nodename);
826
827+ if (is_initial_xendomain())
828+ return;
829+
830 get_device(&dev->dev);
831 if (dev->state != XenbusStateConnected) {
832- printk(KERN_INFO "%s: %s: %s != Connected, skipping\n", __func__,
833+ printk("%s: %s: %s != Connected, skipping\n", __FUNCTION__,
834 dev->nodename, xenbus_strstate(dev->state));
835 goto out;
836 }
837 xenbus_switch_state(dev, XenbusStateClosing);
838 timeout = wait_for_completion_timeout(&dev->down, timeout);
839 if (!timeout)
840- printk(KERN_INFO "%s: %s timeout closing device\n",
841- __func__, dev->nodename);
842+ printk("%s: %s timeout closing device\n", __FUNCTION__, dev->nodename);
843 out:
844 put_device(&dev->dev);
845 }
846
847 int xenbus_register_driver_common(struct xenbus_driver *drv,
848- struct xen_bus_type *bus,
849- struct module *owner,
850- const char *mod_name)
851+ struct xen_bus_type *bus)
852 {
853+ int ret;
854+
855+ if (bus->error)
856+ return bus->error;
857+
858 drv->driver.name = drv->name;
859 drv->driver.bus = &bus->bus;
860- drv->driver.owner = owner;
861- drv->driver.mod_name = mod_name;
862+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
863+ drv->driver.owner = drv->owner;
864+#endif
865+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
866+ drv->driver.probe = xenbus_dev_probe;
867+ drv->driver.remove = xenbus_dev_remove;
868+ drv->driver.shutdown = xenbus_dev_shutdown;
869+#endif
870
871- return driver_register(&drv->driver);
872+ mutex_lock(&xenwatch_mutex);
873+ ret = driver_register(&drv->driver);
874+ mutex_unlock(&xenwatch_mutex);
875+ return ret;
876 }
877
878-int __xenbus_register_frontend(struct xenbus_driver *drv,
879- struct module *owner, const char *mod_name)
880+int xenbus_register_frontend(struct xenbus_driver *drv)
881 {
882 int ret;
883
884 drv->read_otherend_details = read_backend_details;
885
886- ret = xenbus_register_driver_common(drv, &xenbus_frontend,
887- owner, mod_name);
888+ ret = xenbus_register_driver_common(drv, &xenbus_frontend);
889 if (ret)
890 return ret;
891
892@@ -358,7 +404,7 @@ int __xenbus_register_frontend(struct xe
893
894 return 0;
895 }
896-EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
897+EXPORT_SYMBOL_GPL(xenbus_register_frontend);
898
899 void xenbus_unregister_driver(struct xenbus_driver *drv)
900 {
901@@ -436,25 +482,25 @@ static void xenbus_dev_release(struct de
902 }
903
904 static ssize_t xendev_show_nodename(struct device *dev,
905- struct device_attribute *attr, char *buf)
906+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
907+ struct device_attribute *attr,
908+#endif
909+ char *buf)
910 {
911 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
912 }
913 DEVICE_ATTR(nodename, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_nodename, NULL);
914
915 static ssize_t xendev_show_devtype(struct device *dev,
916- struct device_attribute *attr, char *buf)
917+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
918+ struct device_attribute *attr,
919+#endif
920+ char *buf)
921 {
922 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
923 }
924 DEVICE_ATTR(devtype, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_devtype, NULL);
925
926-static ssize_t xendev_show_modalias(struct device *dev,
927- struct device_attribute *attr, char *buf)
928-{
929- return sprintf(buf, "xen:%s\n", to_xenbus_device(dev)->devicetype);
930-}
931-DEVICE_ATTR(modalias, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_modalias, NULL);
932
933 int xenbus_probe_node(struct xen_bus_type *bus,
934 const char *type,
935@@ -467,6 +513,9 @@ int xenbus_probe_node(struct xen_bus_typ
936
937 enum xenbus_state state = xenbus_read_driver_state(nodename);
938
939+ if (bus->error)
940+ return bus->error;
941+
942 if (state != XenbusStateInitialising) {
943 /* Device is not new, so ignore it. This can happen if a
944 device is going away after switching to Closed. */
945@@ -491,6 +540,7 @@ int xenbus_probe_node(struct xen_bus_typ
946 xendev->devicetype = tmpstring;
947 init_completion(&xendev->down);
948
949+ xendev->dev.parent = &bus->dev;
950 xendev->dev.bus = &bus->bus;
951 xendev->dev.release = xenbus_dev_release;
952
953@@ -505,22 +555,15 @@ int xenbus_probe_node(struct xen_bus_typ
954
955 err = device_create_file(&xendev->dev, &dev_attr_nodename);
956 if (err)
957- goto fail_unregister;
958-
959+ goto unregister;
960 err = device_create_file(&xendev->dev, &dev_attr_devtype);
961 if (err)
962- goto fail_remove_nodename;
963-
964- err = device_create_file(&xendev->dev, &dev_attr_modalias);
965- if (err)
966- goto fail_remove_devtype;
967+ goto unregister;
968
969 return 0;
970-fail_remove_devtype:
971- device_remove_file(&xendev->dev, &dev_attr_devtype);
972-fail_remove_nodename:
973+unregister:
974 device_remove_file(&xendev->dev, &dev_attr_nodename);
975-fail_unregister:
976+ device_remove_file(&xendev->dev, &dev_attr_devtype);
977 device_unregister(&xendev->dev);
978 fail:
979 kfree(xendev);
980@@ -533,8 +576,7 @@ static int xenbus_probe_frontend(const c
981 char *nodename;
982 int err;
983
984- nodename = kasprintf(GFP_KERNEL, "%s/%s/%s",
985- xenbus_frontend.root, type, name);
986+ nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", xenbus_frontend.root, type, name);
987 if (!nodename)
988 return -ENOMEM;
989
990@@ -571,6 +613,9 @@ int xenbus_probe_devices(struct xen_bus_
991 char **dir;
992 unsigned int i, dir_n;
993
994+ if (bus->error)
995+ return bus->error;
996+
997 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);
998 if (IS_ERR(dir))
999 return PTR_ERR(dir);
1000@@ -607,15 +652,15 @@ static int strsep_len(const char *str, c
1001 return (len == 0) ? i : -ERANGE;
1002 }
1003
1004-void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
1005+void dev_changed(const char *node, struct xen_bus_type *bus)
1006 {
1007 int exists, rootlen;
1008 struct xenbus_device *dev;
1009 char type[BUS_ID_SIZE];
1010 const char *p, *root;
1011
1012- if (char_count(node, '/') < 2)
1013- return;
1014+ if (bus->error || char_count(node, '/') < 2)
1015+ return;
1016
1017 exists = xenbus_exists(XBT_NIL, node, "");
1018 if (!exists) {
1019@@ -649,7 +694,7 @@ static void frontend_changed(struct xenb
1020 {
1021 DPRINTK("");
1022
1023- xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
1024+ dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
1025 }
1026
1027 /* We watch for devices appearing and vanishing. */
1028@@ -748,7 +793,8 @@ void xenbus_suspend(void)
1029 {
1030 DPRINTK("");
1031
1032- bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_dev);
1033+ if (!xenbus_frontend.error)
1034+ bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_dev);
1035 xenbus_backend_suspend(suspend_dev);
1036 xs_suspend();
1037 }
1038@@ -758,7 +804,8 @@ void xenbus_resume(void)
1039 {
1040 xb_init_comms();
1041 xs_resume();
1042- bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, resume_dev);
1043+ if (!xenbus_frontend.error)
1044+ bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, resume_dev);
1045 xenbus_backend_resume(resume_dev);
1046 }
1047 EXPORT_SYMBOL_GPL(xenbus_resume);
1048@@ -766,7 +813,8 @@ EXPORT_SYMBOL_GPL(xenbus_resume);
1049 void xenbus_suspend_cancel(void)
1050 {
1051 xs_suspend_cancel();
1052- bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_cancel_dev);
1053+ if (!xenbus_frontend.error)
1054+ bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_cancel_dev);
1055 xenbus_backend_resume(suspend_cancel_dev);
1056 }
1057 EXPORT_SYMBOL_GPL(xenbus_suspend_cancel);
1058@@ -794,7 +842,8 @@ void unregister_xenstore_notifier(struct
1059 }
1060 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
1061
1062-void xenbus_probe(struct work_struct *unused)
1063+
1064+void xenbus_probe(void *unused)
1065 {
1066 BUG_ON((xenstored_ready <= 0));
1067
1068@@ -807,63 +856,171 @@ void xenbus_probe(struct work_struct *un
1069 blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
1070 }
1071
1072-static int __init xenbus_probe_init(void)
1073+
1074+#if defined(CONFIG_PROC_FS) && defined(CONFIG_XEN_PRIVILEGED_GUEST)
1075+static struct file_operations xsd_kva_fops;
1076+static struct proc_dir_entry *xsd_kva_intf;
1077+static struct proc_dir_entry *xsd_port_intf;
1078+
1079+static int xsd_kva_mmap(struct file *file, struct vm_area_struct *vma)
1080+{
1081+ size_t size = vma->vm_end - vma->vm_start;
1082+
1083+ if ((size > PAGE_SIZE) || (vma->vm_pgoff != 0))
1084+ return -EINVAL;
1085+
1086+ if (remap_pfn_range(vma, vma->vm_start, mfn_to_pfn(xen_store_mfn),
1087+ size, vma->vm_page_prot))
1088+ return -EAGAIN;
1089+
1090+ return 0;
1091+}
1092+
1093+static int xsd_kva_read(char *page, char **start, off_t off,
1094+ int count, int *eof, void *data)
1095+{
1096+ int len;
1097+
1098+ len = sprintf(page, "0x%p", xen_store_interface);
1099+ *eof = 1;
1100+ return len;
1101+}
1102+
1103+static int xsd_port_read(char *page, char **start, off_t off,
1104+ int count, int *eof, void *data)
1105+{
1106+ int len;
1107+
1108+ len = sprintf(page, "%d", xen_store_evtchn);
1109+ *eof = 1;
1110+ return len;
1111+}
1112+#endif
1113+
1114+static int xenbus_probe_init(void)
1115 {
1116 int err = 0;
1117+ unsigned long page = 0;
1118
1119 DPRINTK("");
1120
1121- err = -ENODEV;
1122 if (!is_running_on_xen())
1123- goto out_error;
1124+ return -ENODEV;
1125
1126 /* Register ourselves with the kernel bus subsystem */
1127- err = bus_register(&xenbus_frontend.bus);
1128- if (err)
1129- goto out_error;
1130-
1131- err = xenbus_backend_bus_register();
1132- if (err)
1133- goto out_unreg_front;
1134+ xenbus_frontend.error = bus_register(&xenbus_frontend.bus);
1135+ if (xenbus_frontend.error)
1136+ printk(KERN_WARNING
1137+ "XENBUS: Error registering frontend bus: %i\n",
1138+ xenbus_frontend.error);
1139+ xenbus_backend_bus_register();
1140
1141 /*
1142 * Domain0 doesn't have a store_evtchn or store_mfn yet.
1143 */
1144 if (is_initial_xendomain()) {
1145- /* dom0 not yet supported */
1146+ struct evtchn_alloc_unbound alloc_unbound;
1147+
1148+ /* Allocate page. */
1149+ page = get_zeroed_page(GFP_KERNEL);
1150+ if (!page)
1151+ return -ENOMEM;
1152+
1153+ xen_store_mfn = xen_start_info->store_mfn =
1154+ pfn_to_mfn(virt_to_phys((void *)page) >>
1155+ PAGE_SHIFT);
1156+
1157+ /* Next allocate a local port which xenstored can bind to */
1158+ alloc_unbound.dom = DOMID_SELF;
1159+ alloc_unbound.remote_dom = 0;
1160+
1161+ err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
1162+ &alloc_unbound);
1163+ if (err == -ENOSYS)
1164+ goto err;
1165+ BUG_ON(err);
1166+ xen_store_evtchn = xen_start_info->store_evtchn =
1167+ alloc_unbound.port;
1168+
1169+#if defined(CONFIG_PROC_FS) && defined(CONFIG_XEN_PRIVILEGED_GUEST)
1170+ /* And finally publish the above info in /proc/xen */
1171+ xsd_kva_intf = create_xen_proc_entry("xsd_kva", 0600);
1172+ if (xsd_kva_intf) {
1173+ memcpy(&xsd_kva_fops, xsd_kva_intf->proc_fops,
1174+ sizeof(xsd_kva_fops));
1175+ xsd_kva_fops.mmap = xsd_kva_mmap;
1176+ xsd_kva_intf->proc_fops = &xsd_kva_fops;
1177+ xsd_kva_intf->read_proc = xsd_kva_read;
1178+ }
1179+ xsd_port_intf = create_xen_proc_entry("xsd_port", 0400);
1180+ if (xsd_port_intf)
1181+ xsd_port_intf->read_proc = xsd_port_read;
1182+#endif
1183+ xen_store_interface = mfn_to_virt(xen_store_mfn);
1184 } else {
1185 xenstored_ready = 1;
1186+#ifdef CONFIG_XEN
1187 xen_store_evtchn = xen_start_info->store_evtchn;
1188 xen_store_mfn = xen_start_info->store_mfn;
1189+ xen_store_interface = mfn_to_virt(xen_store_mfn);
1190+#else
1191+ xen_store_evtchn = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN);
1192+ xen_store_mfn = hvm_get_parameter(HVM_PARAM_STORE_PFN);
1193+ xen_store_interface = ioremap(xen_store_mfn << PAGE_SHIFT,
1194+ PAGE_SIZE);
1195+#endif
1196 }
1197- xen_store_interface = mfn_to_virt(xen_store_mfn);
1198+
1199+
1200+ xenbus_dev_init();
1201
1202 /* Initialize the interface to xenstore. */
1203 err = xs_init();
1204 if (err) {
1205 printk(KERN_WARNING
1206 "XENBUS: Error initializing xenstore comms: %i\n", err);
1207- goto out_unreg_back;
1208+ goto err;
1209 }
1210
1211+ /* Register ourselves with the kernel device subsystem */
1212+ if (!xenbus_frontend.error) {
1213+ xenbus_frontend.error = device_register(&xenbus_frontend.dev);
1214+ if (xenbus_frontend.error) {
1215+ bus_unregister(&xenbus_frontend.bus);
1216+ printk(KERN_WARNING
1217+ "XENBUS: Error registering frontend device: %i\n",
1218+ xenbus_frontend.error);
1219+ }
1220+ }
1221+ xenbus_backend_device_register();
1222+
1223 if (!is_initial_xendomain())
1224 xenbus_probe(NULL);
1225
1226 return 0;
1227
1228- out_unreg_back:
1229- xenbus_backend_bus_unregister();
1230+ err:
1231+ if (page)
1232+ free_page(page);
1233
1234- out_unreg_front:
1235- bus_unregister(&xenbus_frontend.bus);
1236+ /*
1237+ * Do not unregister the xenbus front/backend buses here. The buses
1238+ * must exist because front/backend drivers will use them when they are
1239+ * registered.
1240+ */
1241
1242- out_error:
1243 return err;
1244 }
1245
1246+#ifdef CONFIG_XEN
1247 postcore_initcall(xenbus_probe_init);
1248-
1249-MODULE_LICENSE("GPL");
1250+MODULE_LICENSE("Dual BSD/GPL");
1251+#else
1252+int xenbus_init(void)
1253+{
1254+ return xenbus_probe_init();
1255+}
1256+#endif
1257
1258 static int is_disconnected_device(struct device *dev, void *data)
1259 {
1260@@ -883,12 +1040,14 @@ static int is_disconnected_device(struct
1261 return 0;
1262
1263 xendrv = to_xenbus_driver(dev->driver);
1264- return (xendev->state != XenbusStateConnected ||
1265+ return (xendev->state < XenbusStateConnected ||
1266 (xendrv->is_ready && !xendrv->is_ready(xendev)));
1267 }
1268
1269 static int exists_disconnected_device(struct device_driver *drv)
1270 {
1271+ if (xenbus_frontend.error)
1272+ return xenbus_frontend.error;
1273 return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
1274 is_disconnected_device);
1275 }
1276@@ -897,6 +1056,7 @@ static int print_device_status(struct de
1277 {
1278 struct xenbus_device *xendev = to_xenbus_device(dev);
1279 struct device_driver *drv = data;
1280+ struct xenbus_driver *xendrv;
1281
1282 /* Is this operation limited to a particular driver? */
1283 if (drv && (dev->driver != drv))
1284@@ -906,12 +1066,23 @@ static int print_device_status(struct de
1285 /* Information only: is this too noisy? */
1286 printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
1287 xendev->nodename);
1288- } else if (xendev->state != XenbusStateConnected) {
1289+ return 0;
1290+ }
1291+
1292+ if (xendev->state < XenbusStateConnected) {
1293+ enum xenbus_state rstate = XenbusStateUnknown;
1294+ if (xendev->otherend)
1295+ rstate = xenbus_read_driver_state(xendev->otherend);
1296 printk(KERN_WARNING "XENBUS: Timeout connecting "
1297- "to device: %s (state %d)\n",
1298- xendev->nodename, xendev->state);
1299+ "to device: %s (local state %d, remote state %d)\n",
1300+ xendev->nodename, xendev->state, rstate);
1301 }
1302
1303+ xendrv = to_xenbus_driver(dev->driver);
1304+ if (xendrv->is_ready && !xendrv->is_ready(xendev))
1305+ printk(KERN_WARNING "XENBUS: Device not ready: %s\n",
1306+ xendev->nodename);
1307+
1308 return 0;
1309 }
1310
1311@@ -919,7 +1090,7 @@ static int print_device_status(struct de
1312 static int ready_to_wait_for_devices;
1313
1314 /*
1315- * On a 10 second timeout, wait for all devices currently configured. We need
1316+ * On a 5-minute timeout, wait for all devices currently configured. We need
1317 * to do this to guarantee that the filesystems and / or network devices
1318 * needed for boot are available, before we can allow the boot to proceed.
1319 *
1320@@ -934,18 +1105,30 @@ static int ready_to_wait_for_devices;
1321 */
1322 static void wait_for_devices(struct xenbus_driver *xendrv)
1323 {
1324- unsigned long timeout = jiffies + 10*HZ;
1325+ unsigned long start = jiffies;
1326 struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
1327+ unsigned int seconds_waited = 0;
1328
1329 if (!ready_to_wait_for_devices || !is_running_on_xen())
1330 return;
1331
1332 while (exists_disconnected_device(drv)) {
1333- if (time_after(jiffies, timeout))
1334- break;
1335+ if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
1336+ if (!seconds_waited)
1337+ printk(KERN_WARNING "XENBUS: Waiting for "
1338+ "devices to initialise: ");
1339+ seconds_waited += 5;
1340+ printk("%us...", 300 - seconds_waited);
1341+ if (seconds_waited == 300)
1342+ break;
1343+ }
1344+
1345 schedule_timeout_interruptible(HZ/10);
1346 }
1347
1348+ if (seconds_waited)
1349+ printk("\n");
1350+
1351 bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
1352 print_device_status);
1353 }
1354@@ -953,10 +1136,18 @@ static void wait_for_devices(struct xenb
1355 #ifndef MODULE
1356 static int __init boot_wait_for_devices(void)
1357 {
1358- ready_to_wait_for_devices = 1;
1359- wait_for_devices(NULL);
1360+ if (!xenbus_frontend.error) {
1361+ ready_to_wait_for_devices = 1;
1362+ wait_for_devices(NULL);
1363+ }
1364 return 0;
1365 }
1366
1367 late_initcall(boot_wait_for_devices);
1368 #endif
1369+
1370+int xenbus_for_each_frontend(void *arg, int (*fn)(struct device *, void *))
1371+{
1372+ return bus_for_each_dev(&xenbus_frontend.bus, NULL, arg, fn);
1373+}
1374+EXPORT_SYMBOL_GPL(xenbus_for_each_frontend);
1375Index: head-2008-11-25/drivers/xen/xenbus/xenbus_probe.h
1376===================================================================
1377--- head-2008-11-25.orig/drivers/xen/xenbus/xenbus_probe.h 2008-11-25 12:33:06.000000000 +0100
1378+++ head-2008-11-25/drivers/xen/xenbus/xenbus_probe.h 2008-11-25 12:35:56.000000000 +0100
1379@@ -34,41 +34,42 @@
1380 #ifndef _XENBUS_PROBE_H
1381 #define _XENBUS_PROBE_H
1382
1383-#ifdef CONFIG_XEN_BACKEND
1384+#if defined(CONFIG_XEN_BACKEND) || defined(CONFIG_XEN_BACKEND_MODULE)
1385 extern void xenbus_backend_suspend(int (*fn)(struct device *, void *));
1386 extern void xenbus_backend_resume(int (*fn)(struct device *, void *));
1387 extern void xenbus_backend_probe_and_watch(void);
1388-extern int xenbus_backend_bus_register(void);
1389-extern void xenbus_backend_bus_unregister(void);
1390+extern void xenbus_backend_bus_register(void);
1391+extern void xenbus_backend_device_register(void);
1392 #else
1393 static inline void xenbus_backend_suspend(int (*fn)(struct device *, void *)) {}
1394 static inline void xenbus_backend_resume(int (*fn)(struct device *, void *)) {}
1395 static inline void xenbus_backend_probe_and_watch(void) {}
1396-static inline int xenbus_backend_bus_register(void) { return 0; }
1397-static inline void xenbus_backend_bus_unregister(void) {}
1398+static inline void xenbus_backend_bus_register(void) {}
1399+static inline void xenbus_backend_device_register(void) {}
1400 #endif
1401
1402 struct xen_bus_type
1403 {
1404 char *root;
1405+ int error;
1406 unsigned int levels;
1407 int (*get_bus_id)(char bus_id[BUS_ID_SIZE], const char *nodename);
1408 int (*probe)(const char *type, const char *dir);
1409 struct bus_type bus;
1410+ struct device dev;
1411 };
1412
1413 extern int xenbus_match(struct device *_dev, struct device_driver *_drv);
1414 extern int xenbus_dev_probe(struct device *_dev);
1415 extern int xenbus_dev_remove(struct device *_dev);
1416 extern int xenbus_register_driver_common(struct xenbus_driver *drv,
1417- struct xen_bus_type *bus,
1418- struct module *owner,
1419- const char *mod_name);
1420+ struct xen_bus_type *bus);
1421 extern int xenbus_probe_node(struct xen_bus_type *bus,
1422 const char *type,
1423 const char *nodename);
1424 extern int xenbus_probe_devices(struct xen_bus_type *bus);
1425
1426-extern void xenbus_dev_changed(const char *node, struct xen_bus_type *bus);
1427+extern void dev_changed(const char *node, struct xen_bus_type *bus);
1428
1429 #endif
1430+
1431Index: head-2008-11-25/drivers/xen/xenbus/xenbus_xs.c
1432===================================================================
1433--- head-2008-11-25.orig/drivers/xen/xenbus/xenbus_xs.c 2008-11-25 12:33:06.000000000 +0100
1434+++ head-2008-11-25/drivers/xen/xenbus/xenbus_xs.c 2008-11-25 12:35:56.000000000 +0100
1435@@ -47,6 +47,14 @@
1436 #include <xen/xenbus.h>
1437 #include "xenbus_comms.h"
1438
1439+#ifdef HAVE_XEN_PLATFORM_COMPAT_H
1440+#include <xen/platform-compat.h>
1441+#endif
1442+
1443+#ifndef PF_NOFREEZE /* Old kernel (pre-2.6.6). */
1444+#define PF_NOFREEZE 0
1445+#endif
1446+
1447 struct xs_stored_msg {
1448 struct list_head list;
1449
1450@@ -108,7 +116,7 @@ static DEFINE_SPINLOCK(watch_events_lock
1451 * carrying out work.
1452 */
1453 static pid_t xenwatch_pid;
1454-static DEFINE_MUTEX(xenwatch_mutex);
1455+/* static */ DEFINE_MUTEX(xenwatch_mutex);
1456 static DECLARE_WAIT_QUEUE_HEAD(watch_events_waitq);
1457
1458 static int get_error(const char *errorstring)
1459@@ -177,7 +185,7 @@ void *xenbus_dev_request_and_reply(struc
1460
1461 mutex_unlock(&xs_state.request_mutex);
1462
1463- if ((msg->type == XS_TRANSACTION_END) ||
1464+ if ((req_msg.type == XS_TRANSACTION_END) ||
1465 ((req_msg.type == XS_TRANSACTION_START) &&
1466 (msg->type == XS_ERROR)))
1467 up_read(&xs_state.transaction_mutex);
1468@@ -213,7 +221,7 @@ static void *xs_talkv(struct xenbus_tran
1469 }
1470
1471 for (i = 0; i < num_vecs; i++) {
1472- err = xb_write(iovec[i].iov_base, iovec[i].iov_len);
1473+ err = xb_write(iovec[i].iov_base, iovec[i].iov_len);;
1474 if (err) {
1475 mutex_unlock(&xs_state.request_mutex);
1476 return ERR_PTR(err);
1477@@ -294,7 +302,7 @@ static char **split(char *strings, unsig
1478 char *p, **ret;
1479
1480 /* Count the strings. */
1481- *num = count_strings(strings, len);
1482+ *num = count_strings(strings, len) + 1;
1483
1484 /* Transfer to one big alloc for easy freeing. */
1485 ret = kmalloc(*num * sizeof(char *) + len, GFP_NOIO | __GFP_HIGH);
1486@@ -308,6 +316,7 @@ static char **split(char *strings, unsig
1487 strings = (char *)&ret[*num];
1488 for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
1489 ret[(*num)++] = p;
1490+ ret[*num] = strings + len;
1491
1492 return ret;
1493 }
1494@@ -498,7 +507,7 @@ int xenbus_printf(struct xenbus_transact
1495 #define PRINTF_BUFFER_SIZE 4096
1496 char *printf_buffer;
1497
1498- printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
1499+ printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_NOIO | __GFP_HIGH);
1500 if (printf_buffer == NULL)
1501 return -ENOMEM;
1502
1503@@ -621,6 +630,8 @@ void unregister_xenbus_watch(struct xenb
1504 char token[sizeof(watch) * 2 + 1];
1505 int err;
1506
1507+ BUG_ON(watch->flags & XBWF_new_thread);
1508+
1509 sprintf(token, "%lX", (long)watch);
1510
1511 down_read(&xs_state.watch_mutex);
1512@@ -638,11 +649,6 @@ void unregister_xenbus_watch(struct xenb
1513
1514 up_read(&xs_state.watch_mutex);
1515
1516- /* Make sure there are no callbacks running currently (unless
1517- its us) */
1518- if (current->pid != xenwatch_pid)
1519- mutex_lock(&xenwatch_mutex);
1520-
1521 /* Cancel pending watch events. */
1522 spin_lock(&watch_events_lock);
1523 list_for_each_entry_safe(msg, tmp, &watch_events, list) {
1524@@ -654,8 +660,11 @@ void unregister_xenbus_watch(struct xenb
1525 }
1526 spin_unlock(&watch_events_lock);
1527
1528- if (current->pid != xenwatch_pid)
1529+ /* Flush any currently-executing callback, unless we are it. :-) */
1530+ if (current->pid != xenwatch_pid) {
1531+ mutex_lock(&xenwatch_mutex);
1532 mutex_unlock(&xenwatch_mutex);
1533+ }
1534 }
1535 EXPORT_SYMBOL_GPL(unregister_xenbus_watch);
1536
1537@@ -693,11 +702,30 @@ void xs_suspend_cancel(void)
1538 up_write(&xs_state.transaction_mutex);
1539 }
1540
1541+static int xenwatch_handle_callback(void *data)
1542+{
1543+ struct xs_stored_msg *msg = data;
1544+
1545+ msg->u.watch.handle->callback(msg->u.watch.handle,
1546+ (const char **)msg->u.watch.vec,
1547+ msg->u.watch.vec_size);
1548+
1549+ kfree(msg->u.watch.vec);
1550+ kfree(msg);
1551+
1552+ /* Kill this kthread if we were spawned just for this callback. */
1553+ if (current->pid != xenwatch_pid)
1554+ do_exit(0);
1555+
1556+ return 0;
1557+}
1558+
1559 static int xenwatch_thread(void *unused)
1560 {
1561 struct list_head *ent;
1562 struct xs_stored_msg *msg;
1563
1564+ current->flags |= PF_NOFREEZE;
1565 for (;;) {
1566 wait_event_interruptible(watch_events_waitq,
1567 !list_empty(&watch_events));
1568@@ -713,17 +741,29 @@ static int xenwatch_thread(void *unused)
1569 list_del(ent);
1570 spin_unlock(&watch_events_lock);
1571
1572- if (ent != &watch_events) {
1573- msg = list_entry(ent, struct xs_stored_msg, list);
1574- msg->u.watch.handle->callback(
1575- msg->u.watch.handle,
1576- (const char **)msg->u.watch.vec,
1577- msg->u.watch.vec_size);
1578- kfree(msg->u.watch.vec);
1579- kfree(msg);
1580+ if (ent == &watch_events) {
1581+ mutex_unlock(&xenwatch_mutex);
1582+ continue;
1583 }
1584
1585- mutex_unlock(&xenwatch_mutex);
1586+ msg = list_entry(ent, struct xs_stored_msg, list);
1587+
1588+ /*
1589+ * Unlock the mutex before running an XBWF_new_thread
1590+ * handler. kthread_run can block which can deadlock
1591+ * against unregister_xenbus_watch() if we need to
1592+ * unregister other watches in order to make
1593+ * progress. This can occur on resume before the swap
1594+ * device is attached.
1595+ */
1596+ if (msg->u.watch.handle->flags & XBWF_new_thread) {
1597+ mutex_unlock(&xenwatch_mutex);
1598+ kthread_run(xenwatch_handle_callback,
1599+ msg, "xenwatch_cb");
1600+ } else {
1601+ xenwatch_handle_callback(msg);
1602+ mutex_unlock(&xenwatch_mutex);
1603+ }
1604 }
1605
1606 return 0;
1607@@ -817,6 +857,7 @@ static int xenbus_thread(void *unused)
1608 {
1609 int err;
1610
1611+ current->flags |= PF_NOFREEZE;
1612 for (;;) {
1613 err = process_msg();
1614 if (err)
1615Index: head-2008-11-25/include/xen/balloon.h
1616===================================================================
1617--- head-2008-11-25.orig/include/xen/balloon.h 2008-11-25 12:33:06.000000000 +0100
1618+++ head-2008-11-25/include/xen/balloon.h 2008-11-25 12:35:56.000000000 +0100
1619@@ -31,12 +31,9 @@
1620 * IN THE SOFTWARE.
1621 */
1622
1623-#ifndef __XEN_BALLOON_H__
1624-#define __XEN_BALLOON_H__
1625+#ifndef __ASM_BALLOON_H__
1626+#define __ASM_BALLOON_H__
1627
1628-#include <linux/spinlock.h>
1629-
1630-#if 0
1631 /*
1632 * Inform the balloon driver that it should allow some slop for device-driver
1633 * memory activities.
1634@@ -56,6 +53,5 @@ void balloon_release_driver_page(struct
1635 extern spinlock_t balloon_lock;
1636 #define balloon_lock(__flags) spin_lock_irqsave(&balloon_lock, __flags)
1637 #define balloon_unlock(__flags) spin_unlock_irqrestore(&balloon_lock, __flags)
1638-#endif
1639
1640-#endif /* __XEN_BALLOON_H__ */
1641+#endif /* __ASM_BALLOON_H__ */
1642Index: head-2008-11-25/include/xen/interface/callback.h
1643===================================================================
1644--- head-2008-11-25.orig/include/xen/interface/callback.h 2008-11-25 12:33:06.000000000 +0100
1645+++ head-2008-11-25/include/xen/interface/callback.h 2008-11-25 12:35:56.000000000 +0100
1646@@ -86,6 +86,8 @@ struct callback_register {
1647 uint16_t flags;
1648 xen_callback_t address;
1649 };
1650+typedef struct callback_register callback_register_t;
1651+DEFINE_XEN_GUEST_HANDLE(callback_register_t);
1652
1653 /*
1654 * Unregister a callback.
1655@@ -98,5 +100,22 @@ struct callback_unregister {
1656 uint16_t type;
1657 uint16_t _unused;
1658 };
1659+typedef struct callback_unregister callback_unregister_t;
1660+DEFINE_XEN_GUEST_HANDLE(callback_unregister_t);
1661+
1662+#if __XEN_INTERFACE_VERSION__ < 0x00030207
1663+#undef CALLBACKTYPE_sysenter
1664+#define CALLBACKTYPE_sysenter CALLBACKTYPE_sysenter_deprecated
1665+#endif
1666
1667 #endif /* __XEN_PUBLIC_CALLBACK_H__ */
1668+
1669+/*
1670+ * Local variables:
1671+ * mode: C
1672+ * c-set-style: "BSD"
1673+ * c-basic-offset: 4
1674+ * tab-width: 4
1675+ * indent-tabs-mode: nil
1676+ * End:
1677+ */
1678Index: head-2008-11-25/include/xen/interface/elfnote.h
1679===================================================================
1680--- head-2008-11-25.orig/include/xen/interface/elfnote.h 2008-11-25 12:33:06.000000000 +0100
1681+++ head-2008-11-25/include/xen/interface/elfnote.h 2008-11-25 12:35:56.000000000 +0100
1682@@ -3,6 +3,24 @@
1683 *
1684 * Definitions used for the Xen ELF notes.
1685 *
1686+ * Permission is hereby granted, free of charge, to any person obtaining a copy
1687+ * of this software and associated documentation files (the "Software"), to
1688+ * deal in the Software without restriction, including without limitation the
1689+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
1690+ * sell copies of the Software, and to permit persons to whom the Software is
1691+ * furnished to do so, subject to the following conditions:
1692+ *
1693+ * The above copyright notice and this permission notice shall be included in
1694+ * all copies or substantial portions of the Software.
1695+ *
1696+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1697+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1698+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1699+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1700+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
1701+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
1702+ * DEALINGS IN THE SOFTWARE.
1703+ *
1704 * Copyright (c) 2006, Ian Campbell, XenSource Ltd.
1705 */
1706
1707@@ -10,7 +28,7 @@
1708 #define __XEN_PUBLIC_ELFNOTE_H__
1709
1710 /*
1711- * The notes should live in a SHT_NOTE segment and have "Xen" in the
1712+ * The notes should live in a PT_NOTE segment and have "Xen" in the
1713 * name field.
1714 *
1715 * Numeric types are either 4 or 8 bytes depending on the content of
1716@@ -22,8 +40,6 @@
1717
1718 /*
1719 * NAME=VALUE pair (string).
1720- *
1721- * LEGACY: FEATURES and PAE
1722 */
1723 #define XEN_ELFNOTE_INFO 0
1724
1725@@ -90,7 +106,12 @@
1726 #define XEN_ELFNOTE_LOADER 8
1727
1728 /*
1729- * The kernel supports PAE (x86/32 only, string = "yes" or "no").
1730+ * The kernel supports PAE (x86/32 only, string = "yes", "no" or
1731+ * "bimodal").
1732+ *
1733+ * For compatibility with Xen 3.0.3 and earlier the "bimodal" setting
1734+ * may be given as "yes,bimodal" which will cause older Xen to treat
1735+ * this kernel as PAE.
1736 *
1737 * LEGACY: PAE (n.b. The legacy interface included a provision to
1738 * indicate 'extended-cr3' support allowing L3 page tables to be
1739@@ -140,6 +161,65 @@
1740 */
1741 #define XEN_ELFNOTE_SUSPEND_CANCEL 14
1742
1743+/*
1744+ * The number of the highest elfnote defined.
1745+ */
1746+#define XEN_ELFNOTE_MAX XEN_ELFNOTE_SUSPEND_CANCEL
1747+
1748+/*
1749+ * System information exported through crash notes.
1750+ *
1751+ * The kexec / kdump code will create one XEN_ELFNOTE_CRASH_INFO
1752+ * note in case of a system crash. This note will contain various
1753+ * information about the system, see xen/include/xen/elfcore.h.
1754+ */
1755+#define XEN_ELFNOTE_CRASH_INFO 0x1000001
1756+
1757+/*
1758+ * System registers exported through crash notes.
1759+ *
1760+ * The kexec / kdump code will create one XEN_ELFNOTE_CRASH_REGS
1761+ * note per cpu in case of a system crash. This note is architecture
1762+ * specific and will contain registers not saved in the "CORE" note.
1763+ * See xen/include/xen/elfcore.h for more information.
1764+ */
1765+#define XEN_ELFNOTE_CRASH_REGS 0x1000002
1766+
1767+
1768+/*
1769+ * xen dump-core none note.
1770+ * xm dump-core code will create one XEN_ELFNOTE_DUMPCORE_NONE
1771+ * in its dump file to indicate that the file is xen dump-core
1772+ * file. This note doesn't have any other information.
1773+ * See tools/libxc/xc_core.h for more information.
1774+ */
1775+#define XEN_ELFNOTE_DUMPCORE_NONE 0x2000000
1776+
1777+/*
1778+ * xen dump-core header note.
1779+ * xm dump-core code will create one XEN_ELFNOTE_DUMPCORE_HEADER
1780+ * in its dump file.
1781+ * See tools/libxc/xc_core.h for more information.
1782+ */
1783+#define XEN_ELFNOTE_DUMPCORE_HEADER 0x2000001
1784+
1785+/*
1786+ * xen dump-core xen version note.
1787+ * xm dump-core code will create one XEN_ELFNOTE_DUMPCORE_XEN_VERSION
1788+ * in its dump file. It contains the xen version obtained via the
1789+ * XENVER hypercall.
1790+ * See tools/libxc/xc_core.h for more information.
1791+ */
1792+#define XEN_ELFNOTE_DUMPCORE_XEN_VERSION 0x2000002
1793+
1794+/*
1795+ * xen dump-core format version note.
1796+ * xm dump-core code will create one XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION
1797+ * in its dump file. It contains a format version identifier.
1798+ * See tools/libxc/xc_core.h for more information.
1799+ */
1800+#define XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION 0x2000003
1801+
1802 #endif /* __XEN_PUBLIC_ELFNOTE_H__ */
1803
1804 /*
1805Index: head-2008-11-25/include/xen/interface/event_channel.h
1806===================================================================
1807--- head-2008-11-25.orig/include/xen/interface/event_channel.h 2008-11-25 12:33:06.000000000 +0100
1808+++ head-2008-11-25/include/xen/interface/event_channel.h 2008-11-25 12:35:56.000000000 +0100
1809@@ -3,14 +3,39 @@
1810 *
1811 * Event channels between domains.
1812 *
1813+ * Permission is hereby granted, free of charge, to any person obtaining a copy
1814+ * of this software and associated documentation files (the "Software"), to
1815+ * deal in the Software without restriction, including without limitation the
1816+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
1817+ * sell copies of the Software, and to permit persons to whom the Software is
1818+ * furnished to do so, subject to the following conditions:
1819+ *
1820+ * The above copyright notice and this permission notice shall be included in
1821+ * all copies or substantial portions of the Software.
1822+ *
1823+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1824+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1825+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1826+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1827+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
1828+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
1829+ * DEALINGS IN THE SOFTWARE.
1830+ *
1831 * Copyright (c) 2003-2004, K A Fraser.
1832 */
1833
1834 #ifndef __XEN_PUBLIC_EVENT_CHANNEL_H__
1835 #define __XEN_PUBLIC_EVENT_CHANNEL_H__
1836
1837+/*
1838+ * Prototype for this hypercall is:
1839+ * int event_channel_op(int cmd, void *args)
1840+ * @cmd == EVTCHNOP_??? (event-channel operation).
1841+ * @args == Operation-specific extra arguments (NULL if none).
1842+ */
1843+
1844 typedef uint32_t evtchn_port_t;
1845-DEFINE_GUEST_HANDLE(evtchn_port_t);
1846+DEFINE_XEN_GUEST_HANDLE(evtchn_port_t);
1847
1848 /*
1849 * EVTCHNOP_alloc_unbound: Allocate a port in domain <dom> and mark as
1850@@ -20,13 +45,14 @@ DEFINE_GUEST_HANDLE(evtchn_port_t);
1851 * 1. If the caller is unprivileged then <dom> must be DOMID_SELF.
1852 * 2. <rdom> may be DOMID_SELF, allowing loopback connections.
1853 */
1854-#define EVTCHNOP_alloc_unbound 6
1855+#define EVTCHNOP_alloc_unbound 6
1856 struct evtchn_alloc_unbound {
1857- /* IN parameters */
1858- domid_t dom, remote_dom;
1859- /* OUT parameters */
1860- evtchn_port_t port;
1861+ /* IN parameters */
1862+ domid_t dom, remote_dom;
1863+ /* OUT parameters */
1864+ evtchn_port_t port;
1865 };
1866+typedef struct evtchn_alloc_unbound evtchn_alloc_unbound_t;
1867
1868 /*
1869 * EVTCHNOP_bind_interdomain: Construct an interdomain event channel between
1870@@ -39,29 +65,35 @@ struct evtchn_alloc_unbound {
1871 */
1872 #define EVTCHNOP_bind_interdomain 0
1873 struct evtchn_bind_interdomain {
1874- /* IN parameters. */
1875- domid_t remote_dom;
1876- evtchn_port_t remote_port;
1877- /* OUT parameters. */
1878- evtchn_port_t local_port;
1879+ /* IN parameters. */
1880+ domid_t remote_dom;
1881+ evtchn_port_t remote_port;
1882+ /* OUT parameters. */
1883+ evtchn_port_t local_port;
1884 };
1885+typedef struct evtchn_bind_interdomain evtchn_bind_interdomain_t;
1886
1887 /*
1888 * EVTCHNOP_bind_virq: Bind a local event channel to VIRQ <irq> on specified
1889 * vcpu.
1890 * NOTES:
1891- * 1. A virtual IRQ may be bound to at most one event channel per vcpu.
1892- * 2. The allocated event channel is bound to the specified vcpu. The binding
1893- * may not be changed.
1894+ * 1. Virtual IRQs are classified as per-vcpu or global. See the VIRQ list
1895+ * in xen.h for the classification of each VIRQ.
1896+ * 2. Global VIRQs must be allocated on VCPU0 but can subsequently be
1897+ * re-bound via EVTCHNOP_bind_vcpu.
1898+ * 3. Per-vcpu VIRQs may be bound to at most one event channel per vcpu.
1899+ * The allocated event channel is bound to the specified vcpu and the
1900+ * binding cannot be changed.
1901 */
1902-#define EVTCHNOP_bind_virq 1
1903+#define EVTCHNOP_bind_virq 1
1904 struct evtchn_bind_virq {
1905- /* IN parameters. */
1906- uint32_t virq;
1907- uint32_t vcpu;
1908- /* OUT parameters. */
1909- evtchn_port_t port;
1910+ /* IN parameters. */
1911+ uint32_t virq;
1912+ uint32_t vcpu;
1913+ /* OUT parameters. */
1914+ evtchn_port_t port;
1915 };
1916+typedef struct evtchn_bind_virq evtchn_bind_virq_t;
1917
1918 /*
1919 * EVTCHNOP_bind_pirq: Bind a local event channel to PIRQ <irq>.
1920@@ -69,15 +101,16 @@ struct evtchn_bind_virq {
1921 * 1. A physical IRQ may be bound to at most one event channel per domain.
1922 * 2. Only a sufficiently-privileged domain may bind to a physical IRQ.
1923 */
1924-#define EVTCHNOP_bind_pirq 2
1925+#define EVTCHNOP_bind_pirq 2
1926 struct evtchn_bind_pirq {
1927- /* IN parameters. */
1928- uint32_t pirq;
1929+ /* IN parameters. */
1930+ uint32_t pirq;
1931 #define BIND_PIRQ__WILL_SHARE 1
1932- uint32_t flags; /* BIND_PIRQ__* */
1933- /* OUT parameters. */
1934- evtchn_port_t port;
1935+ uint32_t flags; /* BIND_PIRQ__* */
1936+ /* OUT parameters. */
1937+ evtchn_port_t port;
1938 };
1939+typedef struct evtchn_bind_pirq evtchn_bind_pirq_t;
1940
1941 /*
1942 * EVTCHNOP_bind_ipi: Bind a local event channel to receive events.
1943@@ -85,33 +118,36 @@ struct evtchn_bind_pirq {
1944 * 1. The allocated event channel is bound to the specified vcpu. The binding
1945 * may not be changed.
1946 */
1947-#define EVTCHNOP_bind_ipi 7
1948+#define EVTCHNOP_bind_ipi 7
1949 struct evtchn_bind_ipi {
1950- uint32_t vcpu;
1951- /* OUT parameters. */
1952- evtchn_port_t port;
1953+ uint32_t vcpu;
1954+ /* OUT parameters. */
1955+ evtchn_port_t port;
1956 };
1957+typedef struct evtchn_bind_ipi evtchn_bind_ipi_t;
1958
1959 /*
1960 * EVTCHNOP_close: Close a local event channel <port>. If the channel is
1961 * interdomain then the remote end is placed in the unbound state
1962 * (EVTCHNSTAT_unbound), awaiting a new connection.
1963 */
1964-#define EVTCHNOP_close 3
1965+#define EVTCHNOP_close 3
1966 struct evtchn_close {
1967- /* IN parameters. */
1968- evtchn_port_t port;
1969+ /* IN parameters. */
1970+ evtchn_port_t port;
1971 };
1972+typedef struct evtchn_close evtchn_close_t;
1973
1974 /*
1975 * EVTCHNOP_send: Send an event to the remote end of the channel whose local
1976 * endpoint is <port>.
1977 */
1978-#define EVTCHNOP_send 4
1979+#define EVTCHNOP_send 4
1980 struct evtchn_send {
1981- /* IN parameters. */
1982- evtchn_port_t port;
1983+ /* IN parameters. */
1984+ evtchn_port_t port;
1985 };
1986+typedef struct evtchn_send evtchn_send_t;
1987
1988 /*
1989 * EVTCHNOP_status: Get the current status of the communication channel which
1990@@ -121,75 +157,108 @@ struct evtchn_send {
1991 * 2. Only a sufficiently-privileged domain may obtain the status of an event
1992 * channel for which <dom> is not DOMID_SELF.
1993 */
1994-#define EVTCHNOP_status 5
1995+#define EVTCHNOP_status 5
1996 struct evtchn_status {
1997- /* IN parameters */
1998- domid_t dom;
1999- evtchn_port_t port;
2000- /* OUT parameters */
2001-#define EVTCHNSTAT_closed 0 /* Channel is not in use. */
2002-#define EVTCHNSTAT_unbound 1 /* Channel is waiting interdom connection.*/
2003-#define EVTCHNSTAT_interdomain 2 /* Channel is connected to remote domain. */
2004-#define EVTCHNSTAT_pirq 3 /* Channel is bound to a phys IRQ line. */
2005-#define EVTCHNSTAT_virq 4 /* Channel is bound to a virtual IRQ line */
2006-#define EVTCHNSTAT_ipi 5 /* Channel is bound to a virtual IPI line */
2007- uint32_t status;
2008- uint32_t vcpu; /* VCPU to which this channel is bound. */
2009- union {
2010- struct {
2011- domid_t dom;
2012- } unbound; /* EVTCHNSTAT_unbound */
2013- struct {
2014- domid_t dom;
2015- evtchn_port_t port;
2016- } interdomain; /* EVTCHNSTAT_interdomain */
2017- uint32_t pirq; /* EVTCHNSTAT_pirq */
2018- uint32_t virq; /* EVTCHNSTAT_virq */
2019- } u;
2020+ /* IN parameters */
2021+ domid_t dom;
2022+ evtchn_port_t port;
2023+ /* OUT parameters */
2024+#define EVTCHNSTAT_closed 0 /* Channel is not in use. */
2025+#define EVTCHNSTAT_unbound 1 /* Channel is waiting interdom connection.*/
2026+#define EVTCHNSTAT_interdomain 2 /* Channel is connected to remote domain. */
2027+#define EVTCHNSTAT_pirq 3 /* Channel is bound to a phys IRQ line. */
2028+#define EVTCHNSTAT_virq 4 /* Channel is bound to a virtual IRQ line */
2029+#define EVTCHNSTAT_ipi 5 /* Channel is bound to a virtual IPI line */
2030+ uint32_t status;
2031+ uint32_t vcpu; /* VCPU to which this channel is bound. */
2032+ union {
2033+ struct {
2034+ domid_t dom;
2035+ } unbound; /* EVTCHNSTAT_unbound */
2036+ struct {
2037+ domid_t dom;
2038+ evtchn_port_t port;
2039+ } interdomain; /* EVTCHNSTAT_interdomain */
2040+ uint32_t pirq; /* EVTCHNSTAT_pirq */
2041+ uint32_t virq; /* EVTCHNSTAT_virq */
2042+ } u;
2043 };
2044+typedef struct evtchn_status evtchn_status_t;
2045
2046 /*
2047 * EVTCHNOP_bind_vcpu: Specify which vcpu a channel should notify when an
2048 * event is pending.
2049 * NOTES:
2050- * 1. IPI- and VIRQ-bound channels always notify the vcpu that initialised
2051- * the binding. This binding cannot be changed.
2052- * 2. All other channels notify vcpu0 by default. This default is set when
2053+ * 1. IPI-bound channels always notify the vcpu specified at bind time.
2054+ * This binding cannot be changed.
2055+ * 2. Per-VCPU VIRQ channels always notify the vcpu specified at bind time.
2056+ * This binding cannot be changed.
2057+ * 3. All other channels notify vcpu0 by default. This default is set when
2058 * the channel is allocated (a port that is freed and subsequently reused
2059 * has its binding reset to vcpu0).
2060 */
2061-#define EVTCHNOP_bind_vcpu 8
2062+#define EVTCHNOP_bind_vcpu 8
2063 struct evtchn_bind_vcpu {
2064- /* IN parameters. */
2065- evtchn_port_t port;
2066- uint32_t vcpu;
2067+ /* IN parameters. */
2068+ evtchn_port_t port;
2069+ uint32_t vcpu;
2070 };
2071+typedef struct evtchn_bind_vcpu evtchn_bind_vcpu_t;
2072
2073 /*
2074 * EVTCHNOP_unmask: Unmask the specified local event-channel port and deliver
2075 * a notification to the appropriate VCPU if an event is pending.
2076 */
2077-#define EVTCHNOP_unmask 9
2078+#define EVTCHNOP_unmask 9
2079 struct evtchn_unmask {
2080- /* IN parameters. */
2081- evtchn_port_t port;
2082+ /* IN parameters. */
2083+ evtchn_port_t port;
2084+};
2085+typedef struct evtchn_unmask evtchn_unmask_t;
2086+
2087+/*
2088+ * EVTCHNOP_reset: Close all event channels associated with specified domain.
2089+ * NOTES:
2090+ * 1. <dom> may be specified as DOMID_SELF.
2091+ * 2. Only a sufficiently-privileged domain may specify other than DOMID_SELF.
2092+ */
2093+#define EVTCHNOP_reset 10
2094+struct evtchn_reset {
2095+ /* IN parameters. */
2096+ domid_t dom;
2097 };
2098+typedef struct evtchn_reset evtchn_reset_t;
2099
2100+/*
2101+ * Argument to event_channel_op_compat() hypercall. Superceded by new
2102+ * event_channel_op() hypercall since 0x00030202.
2103+ */
2104 struct evtchn_op {
2105- uint32_t cmd; /* EVTCHNOP_* */
2106- union {
2107- struct evtchn_alloc_unbound alloc_unbound;
2108- struct evtchn_bind_interdomain bind_interdomain;
2109- struct evtchn_bind_virq bind_virq;
2110- struct evtchn_bind_pirq bind_pirq;
2111- struct evtchn_bind_ipi bind_ipi;
2112- struct evtchn_close close;
2113- struct evtchn_send send;
2114- struct evtchn_status status;
2115- struct evtchn_bind_vcpu bind_vcpu;
2116- struct evtchn_unmask unmask;
2117- } u;
2118+ uint32_t cmd; /* EVTCHNOP_* */
2119+ union {
2120+ struct evtchn_alloc_unbound alloc_unbound;
2121+ struct evtchn_bind_interdomain bind_interdomain;
2122+ struct evtchn_bind_virq bind_virq;
2123+ struct evtchn_bind_pirq bind_pirq;
2124+ struct evtchn_bind_ipi bind_ipi;
2125+ struct evtchn_close close;
2126+ struct evtchn_send send;
2127+ struct evtchn_status status;
2128+ struct evtchn_bind_vcpu bind_vcpu;
2129+ struct evtchn_unmask unmask;
2130+ } u;
2131 };
2132-DEFINE_GUEST_HANDLE_STRUCT(evtchn_op);
2133+typedef struct evtchn_op evtchn_op_t;
2134+DEFINE_XEN_GUEST_HANDLE(evtchn_op_t);
2135
2136 #endif /* __XEN_PUBLIC_EVENT_CHANNEL_H__ */
2137+
2138+/*
2139+ * Local variables:
2140+ * mode: C
2141+ * c-set-style: "BSD"
2142+ * c-basic-offset: 4
2143+ * tab-width: 4
2144+ * indent-tabs-mode: nil
2145+ * End:
2146+ */
2147Index: head-2008-11-25/include/xen/interface/features.h
2148===================================================================
2149--- head-2008-11-25.orig/include/xen/interface/features.h 2008-11-25 12:33:06.000000000 +0100
2150+++ head-2008-11-25/include/xen/interface/features.h 2008-11-25 12:22:34.000000000 +0100
2151@@ -3,6 +3,24 @@
2152 *
2153 * Feature flags, reported by XENVER_get_features.
2154 *
2155+ * Permission is hereby granted, free of charge, to any person obtaining a copy
2156+ * of this software and associated documentation files (the "Software"), to
2157+ * deal in the Software without restriction, including without limitation the
2158+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
2159+ * sell copies of the Software, and to permit persons to whom the Software is
2160+ * furnished to do so, subject to the following conditions:
2161+ *
2162+ * The above copyright notice and this permission notice shall be included in
2163+ * all copies or substantial portions of the Software.
2164+ *
2165+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
2166+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
2167+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
2168+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2169+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
2170+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
2171+ * DEALINGS IN THE SOFTWARE.
2172+ *
2173 * Copyright (c) 2006, Keir Fraser <keir@xensource.com>
2174 */
2175
2176@@ -41,6 +59,25 @@
2177 /* x86: Does this Xen host support the MMU_PT_UPDATE_PRESERVE_AD hypercall? */
2178 #define XENFEAT_mmu_pt_update_preserve_ad 5
2179
2180+/* x86: Does this Xen host support the MMU_{CLEAR,COPY}_PAGE hypercall? */
2181+#define XENFEAT_highmem_assist 6
2182+
2183+/*
2184+ * If set, GNTTABOP_map_grant_ref honors flags to be placed into guest kernel
2185+ * available pte bits.
2186+ */
2187+#define XENFEAT_gnttab_map_avail_bits 7
2188+
2189 #define XENFEAT_NR_SUBMAPS 1
2190
2191 #endif /* __XEN_PUBLIC_FEATURES_H__ */
2192+
2193+/*
2194+ * Local variables:
2195+ * mode: C
2196+ * c-set-style: "BSD"
2197+ * c-basic-offset: 4
2198+ * tab-width: 4
2199+ * indent-tabs-mode: nil
2200+ * End:
2201+ */
2202Index: head-2008-11-25/include/xen/interface/grant_table.h
2203===================================================================
2204--- head-2008-11-25.orig/include/xen/interface/grant_table.h 2008-11-25 12:33:06.000000000 +0100
2205+++ head-2008-11-25/include/xen/interface/grant_table.h 2008-11-25 12:22:34.000000000 +0100
2206@@ -100,6 +100,7 @@ struct grant_entry {
2207 */
2208 uint32_t frame;
2209 };
2210+typedef struct grant_entry grant_entry_t;
2211
2212 /*
2213 * Type of grant entry.
2214@@ -118,6 +119,7 @@ struct grant_entry {
2215 * GTF_readonly: Restrict @domid to read-only mappings and accesses. [GST]
2216 * GTF_reading: Grant entry is currently mapped for reading by @domid. [XEN]
2217 * GTF_writing: Grant entry is currently mapped for writing by @domid. [XEN]
2218+ * GTF_PAT, GTF_PWT, GTF_PCD: (x86) cache attribute flags for the grant [GST]
2219 */
2220 #define _GTF_readonly (2)
2221 #define GTF_readonly (1U<<_GTF_readonly)
2222@@ -125,6 +127,12 @@ struct grant_entry {
2223 #define GTF_reading (1U<<_GTF_reading)
2224 #define _GTF_writing (4)
2225 #define GTF_writing (1U<<_GTF_writing)
2226+#define _GTF_PWT (5)
2227+#define GTF_PWT (1U<<_GTF_PWT)
2228+#define _GTF_PCD (6)
2229+#define GTF_PCD (1U<<_GTF_PCD)
2230+#define _GTF_PAT (7)
2231+#define GTF_PAT (1U<<_GTF_PAT)
2232
2233 /*
2234 * Subflags for GTF_accept_transfer:
2235@@ -185,7 +193,8 @@ struct gnttab_map_grant_ref {
2236 grant_handle_t handle;
2237 uint64_t dev_bus_addr;
2238 };
2239-DEFINE_GUEST_HANDLE_STRUCT(gnttab_map_grant_ref);
2240+typedef struct gnttab_map_grant_ref gnttab_map_grant_ref_t;
2241+DEFINE_XEN_GUEST_HANDLE(gnttab_map_grant_ref_t);
2242
2243 /*
2244 * GNTTABOP_unmap_grant_ref: Destroy one or more grant-reference mappings
2245@@ -207,7 +216,8 @@ struct gnttab_unmap_grant_ref {
2246 /* OUT parameters. */
2247 int16_t status; /* GNTST_* */
2248 };
2249-DEFINE_GUEST_HANDLE_STRUCT(gnttab_unmap_grant_ref);
2250+typedef struct gnttab_unmap_grant_ref gnttab_unmap_grant_ref_t;
2251+DEFINE_XEN_GUEST_HANDLE(gnttab_unmap_grant_ref_t);
2252
2253 /*
2254 * GNTTABOP_setup_table: Set up a grant table for <dom> comprising at least
2255@@ -225,9 +235,10 @@ struct gnttab_setup_table {
2256 uint32_t nr_frames;
2257 /* OUT parameters. */
2258 int16_t status; /* GNTST_* */
2259- GUEST_HANDLE(ulong) frame_list;
2260+ XEN_GUEST_HANDLE(ulong) frame_list;
2261 };
2262-DEFINE_GUEST_HANDLE_STRUCT(gnttab_setup_table);
2263+typedef struct gnttab_setup_table gnttab_setup_table_t;
2264+DEFINE_XEN_GUEST_HANDLE(gnttab_setup_table_t);
2265
2266 /*
2267 * GNTTABOP_dump_table: Dump the contents of the grant table to the
2268@@ -240,7 +251,8 @@ struct gnttab_dump_table {
2269 /* OUT parameters. */
2270 int16_t status; /* GNTST_* */
2271 };
2272-DEFINE_GUEST_HANDLE_STRUCT(gnttab_dump_table);
2273+typedef struct gnttab_dump_table gnttab_dump_table_t;
2274+DEFINE_XEN_GUEST_HANDLE(gnttab_dump_table_t);
2275
2276 /*
2277 * GNTTABOP_transfer_grant_ref: Transfer <frame> to a foreign domain. The
2278@@ -253,13 +265,15 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_dump_t
2279 #define GNTTABOP_transfer 4
2280 struct gnttab_transfer {
2281 /* IN parameters. */
2282- unsigned long mfn;
2283+ xen_pfn_t mfn;
2284 domid_t domid;
2285 grant_ref_t ref;
2286 /* OUT parameters. */
2287 int16_t status;
2288 };
2289-DEFINE_GUEST_HANDLE_STRUCT(gnttab_transfer);
2290+typedef struct gnttab_transfer gnttab_transfer_t;
2291+DEFINE_XEN_GUEST_HANDLE(gnttab_transfer_t);
2292+
2293
2294 /*
2295 * GNTTABOP_copy: Hypervisor based copy
2296@@ -285,22 +299,22 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_transf
2297 #define GNTCOPY_dest_gref (1<<_GNTCOPY_dest_gref)
2298
2299 #define GNTTABOP_copy 5
2300-struct gnttab_copy {
2301- /* IN parameters. */
2302- struct {
2303- union {
2304- grant_ref_t ref;
2305- unsigned long gmfn;
2306- } u;
2307- domid_t domid;
2308- uint16_t offset;
2309- } source, dest;
2310- uint16_t len;
2311- uint16_t flags; /* GNTCOPY_* */
2312- /* OUT parameters. */
2313- int16_t status;
2314-};
2315-DEFINE_GUEST_HANDLE_STRUCT(gnttab_copy);
2316+typedef struct gnttab_copy {
2317+ /* IN parameters. */
2318+ struct {
2319+ union {
2320+ grant_ref_t ref;
2321+ xen_pfn_t gmfn;
2322+ } u;
2323+ domid_t domid;
2324+ uint16_t offset;
2325+ } source, dest;
2326+ uint16_t len;
2327+ uint16_t flags; /* GNTCOPY_* */
2328+ /* OUT parameters. */
2329+ int16_t status;
2330+} gnttab_copy_t;
2331+DEFINE_XEN_GUEST_HANDLE(gnttab_copy_t);
2332
2333 /*
2334 * GNTTABOP_query_size: Query the current and maximum sizes of the shared
2335@@ -318,10 +332,35 @@ struct gnttab_query_size {
2336 uint32_t max_nr_frames;
2337 int16_t status; /* GNTST_* */
2338 };
2339-DEFINE_GUEST_HANDLE_STRUCT(gnttab_query_size);
2340+typedef struct gnttab_query_size gnttab_query_size_t;
2341+DEFINE_XEN_GUEST_HANDLE(gnttab_query_size_t);
2342
2343 /*
2344- * Bitfield values for update_pin_status.flags.
2345+ * GNTTABOP_unmap_and_replace: Destroy one or more grant-reference mappings
2346+ * tracked by <handle> but atomically replace the page table entry with one
2347+ * pointing to the machine address under <new_addr>. <new_addr> will be
2348+ * redirected to the null entry.
2349+ * NOTES:
2350+ * 1. The call may fail in an undefined manner if either mapping is not
2351+ * tracked by <handle>.
2352+ * 2. After executing a batch of unmaps, it is guaranteed that no stale
2353+ * mappings will remain in the device or host TLBs.
2354+ */
2355+#define GNTTABOP_unmap_and_replace 7
2356+struct gnttab_unmap_and_replace {
2357+ /* IN parameters. */
2358+ uint64_t host_addr;
2359+ uint64_t new_addr;
2360+ grant_handle_t handle;
2361+ /* OUT parameters. */
2362+ int16_t status; /* GNTST_* */
2363+};
2364+typedef struct gnttab_unmap_and_replace gnttab_unmap_and_replace_t;
2365+DEFINE_XEN_GUEST_HANDLE(gnttab_unmap_and_replace_t);
2366+
2367+
2368+/*
2369+ * Bitfield values for gnttab_map_grant_ref.flags.
2370 */
2371 /* Map the grant entry for access by I/O devices. */
2372 #define _GNTMAP_device_map (0)
2373@@ -349,6 +388,13 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_query_
2374 #define GNTMAP_contains_pte (1<<_GNTMAP_contains_pte)
2375
2376 /*
2377+ * Bits to be placed in guest kernel available PTE bits (architecture
2378+ * dependent; only supported when XENFEAT_gnttab_map_avail_bits is set).
2379+ */
2380+#define _GNTMAP_guest_avail0 (16)
2381+#define GNTMAP_guest_avail_mask ((uint32_t)~0 << _GNTMAP_guest_avail0)
2382+
2383+/*
2384 * Values for error status returns. All errors are -ve.
2385 */
2386 #define GNTST_okay (0) /* Normal return. */
2387@@ -361,7 +407,8 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_query_
2388 #define GNTST_no_device_space (-7) /* Out of space in I/O MMU. */
2389 #define GNTST_permission_denied (-8) /* Not enough privilege for operation. */
2390 #define GNTST_bad_page (-9) /* Specified page was invalid for op. */
2391-#define GNTST_bad_copy_arg (-10) /* copy arguments cross page boundary */
2392+#define GNTST_bad_copy_arg (-10) /* copy arguments cross page boundary. */
2393+#define GNTST_address_too_big (-11) /* transfer page address too large. */
2394
2395 #define GNTTABOP_error_msgs { \
2396 "okay", \
2397@@ -374,7 +421,18 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_query_
2398 "no spare translation slot in the I/O MMU", \
2399 "permission denied", \
2400 "bad page", \
2401- "copy arguments cross page boundary" \
2402+ "copy arguments cross page boundary", \
2403+ "page address size too large" \
2404 }
2405
2406 #endif /* __XEN_PUBLIC_GRANT_TABLE_H__ */
2407+
2408+/*
2409+ * Local variables:
2410+ * mode: C
2411+ * c-set-style: "BSD"
2412+ * c-basic-offset: 4
2413+ * tab-width: 4
2414+ * indent-tabs-mode: nil
2415+ * End:
2416+ */
2417Index: head-2008-11-25/include/xen/interface/io/blkif.h
2418===================================================================
2419--- head-2008-11-25.orig/include/xen/interface/io/blkif.h 2008-11-25 12:33:06.000000000 +0100
2420+++ head-2008-11-25/include/xen/interface/io/blkif.h 2008-11-25 12:35:56.000000000 +0100
2421@@ -3,6 +3,24 @@
2422 *
2423 * Unified block-device I/O interface for Xen guest OSes.
2424 *
2425+ * Permission is hereby granted, free of charge, to any person obtaining a copy
2426+ * of this software and associated documentation files (the "Software"), to
2427+ * deal in the Software without restriction, including without limitation the
2428+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
2429+ * sell copies of the Software, and to permit persons to whom the Software is
2430+ * furnished to do so, subject to the following conditions:
2431+ *
2432+ * The above copyright notice and this permission notice shall be included in
2433+ * all copies or substantial portions of the Software.
2434+ *
2435+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
2436+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
2437+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
2438+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2439+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
2440+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
2441+ * DEALINGS IN THE SOFTWARE.
2442+ *
2443 * Copyright (c) 2003-2004, Keir Fraser
2444 */
2445
2446@@ -24,8 +42,10 @@
2447 * rsp_event appropriately (e.g., using RING_FINAL_CHECK_FOR_RESPONSES()).
2448 */
2449
2450-typedef uint16_t blkif_vdev_t;
2451-typedef uint64_t blkif_sector_t;
2452+#ifndef blkif_vdev_t
2453+#define blkif_vdev_t uint16_t
2454+#endif
2455+#define blkif_sector_t uint64_t
2456
2457 /*
2458 * REQUEST CODES.
2459@@ -34,7 +54,7 @@ typedef uint64_t blkif_sector_t;
2460 #define BLKIF_OP_WRITE 1
2461 /*
2462 * Recognised only if "feature-barrier" is present in backend xenbus info.
2463- * The "feature_barrier" node contains a boolean indicating whether barrier
2464+ * The "feature-barrier" node contains a boolean indicating whether barrier
2465 * requests are likely to succeed or fail. Either way, a barrier request
2466 * may fail at any time with BLKIF_RSP_EOPNOTSUPP if it is unsupported by
2467 * the underlying block-device hardware. The boolean simply indicates whether
2468@@ -43,33 +63,50 @@ typedef uint64_t blkif_sector_t;
2469 * create the "feature-barrier" node!
2470 */
2471 #define BLKIF_OP_WRITE_BARRIER 2
2472+/*
2473+ * Recognised if "feature-flush-cache" is present in backend xenbus
2474+ * info. A flush will ask the underlying storage hardware to flush its
2475+ * non-volatile caches as appropriate. The "feature-flush-cache" node
2476+ * contains a boolean indicating whether flush requests are likely to
2477+ * succeed or fail. Either way, a flush request may fail at any time
2478+ * with BLKIF_RSP_EOPNOTSUPP if it is unsupported by the underlying
2479+ * block-device hardware. The boolean simply indicates whether or not it
2480+ * is worthwhile for the frontend to attempt flushes. If a backend does
2481+ * not recognise BLKIF_OP_WRITE_FLUSH_CACHE, it should *not* create the
2482+ * "feature-flush-cache" node!
2483+ */
2484+#define BLKIF_OP_FLUSH_DISKCACHE 3
2485
2486 /*
2487 * Maximum scatter/gather segments per request.
2488- * This is carefully chosen so that sizeof(struct blkif_ring) <= PAGE_SIZE.
2489+ * This is carefully chosen so that sizeof(blkif_ring_t) <= PAGE_SIZE.
2490 * NB. This could be 12 if the ring indexes weren't stored in the same page.
2491 */
2492 #define BLKIF_MAX_SEGMENTS_PER_REQUEST 11
2493
2494+struct blkif_request_segment {
2495+ grant_ref_t gref; /* reference to I/O buffer frame */
2496+ /* @first_sect: first sector in frame to transfer (inclusive). */
2497+ /* @last_sect: last sector in frame to transfer (inclusive). */
2498+ uint8_t first_sect, last_sect;
2499+};
2500+
2501 struct blkif_request {
2502- uint8_t operation; /* BLKIF_OP_??? */
2503- uint8_t nr_segments; /* number of segments */
2504- blkif_vdev_t handle; /* only for read/write requests */
2505- uint64_t id; /* private guest value, echoed in resp */
2506- blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
2507- struct blkif_request_segment {
2508- grant_ref_t gref; /* reference to I/O buffer frame */
2509- /* @first_sect: first sector in frame to transfer (inclusive). */
2510- /* @last_sect: last sector in frame to transfer (inclusive). */
2511- uint8_t first_sect, last_sect;
2512- } seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
2513+ uint8_t operation; /* BLKIF_OP_??? */
2514+ uint8_t nr_segments; /* number of segments */
2515+ blkif_vdev_t handle; /* only for read/write requests */
2516+ uint64_t id; /* private guest value, echoed in resp */
2517+ blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
2518+ struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
2519 };
2520+typedef struct blkif_request blkif_request_t;
2521
2522 struct blkif_response {
2523- uint64_t id; /* copied from request */
2524- uint8_t operation; /* copied from request */
2525- int16_t status; /* BLKIF_RSP_??? */
2526+ uint64_t id; /* copied from request */
2527+ uint8_t operation; /* copied from request */
2528+ int16_t status; /* BLKIF_RSP_??? */
2529 };
2530+typedef struct blkif_response blkif_response_t;
2531
2532 /*
2533 * STATUS RETURN CODES.
2534@@ -92,3 +129,13 @@ DEFINE_RING_TYPES(blkif, struct blkif_re
2535 #define VDISK_READONLY 0x4
2536
2537 #endif /* __XEN_PUBLIC_IO_BLKIF_H__ */
2538+
2539+/*
2540+ * Local variables:
2541+ * mode: C
2542+ * c-set-style: "BSD"
2543+ * c-basic-offset: 4
2544+ * tab-width: 4
2545+ * indent-tabs-mode: nil
2546+ * End:
2547+ */
2548Index: head-2008-11-25/include/xen/interface/io/console.h
2549===================================================================
2550--- head-2008-11-25.orig/include/xen/interface/io/console.h 2008-11-25 12:33:06.000000000 +0100
2551+++ head-2008-11-25/include/xen/interface/io/console.h 2008-11-25 12:35:56.000000000 +0100
2552@@ -3,6 +3,24 @@
2553 *
2554 * Console I/O interface for Xen guest OSes.
2555 *
2556+ * Permission is hereby granted, free of charge, to any person obtaining a copy
2557+ * of this software and associated documentation files (the "Software"), to
2558+ * deal in the Software without restriction, including without limitation the
2559+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
2560+ * sell copies of the Software, and to permit persons to whom the Software is
2561+ * furnished to do so, subject to the following conditions:
2562+ *
2563+ * The above copyright notice and this permission notice shall be included in
2564+ * all copies or substantial portions of the Software.
2565+ *
2566+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
2567+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
2568+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
2569+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2570+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
2571+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
2572+ * DEALINGS IN THE SOFTWARE.
2573+ *
2574 * Copyright (c) 2005, Keir Fraser
2575 */
2576
2577@@ -21,3 +39,13 @@ struct xencons_interface {
2578 };
2579
2580 #endif /* __XEN_PUBLIC_IO_CONSOLE_H__ */
2581+
2582+/*
2583+ * Local variables:
2584+ * mode: C
2585+ * c-set-style: "BSD"
2586+ * c-basic-offset: 4
2587+ * tab-width: 4
2588+ * indent-tabs-mode: nil
2589+ * End:
2590+ */
2591Index: head-2008-11-25/include/xen/interface/io/fbif.h
2592===================================================================
2593--- head-2008-11-25.orig/include/xen/interface/io/fbif.h 2008-11-25 12:33:06.000000000 +0100
2594+++ head-2008-11-25/include/xen/interface/io/fbif.h 2008-11-25 12:35:56.000000000 +0100
2595@@ -41,12 +41,13 @@
2596 */
2597 #define XENFB_TYPE_UPDATE 2
2598
2599-struct xenfb_update {
2600- uint8_t type; /* XENFB_TYPE_UPDATE */
2601- int32_t x; /* source x */
2602- int32_t y; /* source y */
2603- int32_t width; /* rect width */
2604- int32_t height; /* rect height */
2605+struct xenfb_update
2606+{
2607+ uint8_t type; /* XENFB_TYPE_UPDATE */
2608+ int32_t x; /* source x */
2609+ int32_t y; /* source y */
2610+ int32_t width; /* rect width */
2611+ int32_t height; /* rect height */
2612 };
2613
2614 /*
2615@@ -55,36 +56,58 @@ struct xenfb_update {
2616 */
2617 #define XENFB_TYPE_RESIZE 3
2618
2619-struct xenfb_resize {
2620- uint8_t type; /* XENFB_TYPE_RESIZE */
2621- int32_t width; /* width in pixels */
2622- int32_t height; /* height in pixels */
2623- int32_t stride; /* stride in bytes */
2624- int32_t depth; /* depth in bits */
2625- int32_t offset; /* start offset within framebuffer */
2626+struct xenfb_resize
2627+{
2628+ uint8_t type; /* XENFB_TYPE_RESIZE */
2629+ int32_t width; /* width in pixels */
2630+ int32_t height; /* height in pixels */
2631+ int32_t stride; /* stride in bytes */
2632+ int32_t depth; /* depth in bits */
2633+ int32_t offset; /* offset of the framebuffer in bytes */
2634 };
2635
2636 #define XENFB_OUT_EVENT_SIZE 40
2637
2638-union xenfb_out_event {
2639- uint8_t type;
2640- struct xenfb_update update;
2641- struct xenfb_resize resize;
2642- char pad[XENFB_OUT_EVENT_SIZE];
2643+union xenfb_out_event
2644+{
2645+ uint8_t type;
2646+ struct xenfb_update update;
2647+ struct xenfb_resize resize;
2648+ char pad[XENFB_OUT_EVENT_SIZE];
2649 };
2650
2651 /* In events (backend -> frontend) */
2652
2653 /*
2654 * Frontends should ignore unknown in events.
2655- * No in events currently defined.
2656 */
2657
2658+/*
2659+ * Framebuffer refresh period advice
2660+ * Backend sends it to advise the frontend their preferred period of
2661+ * refresh. Frontends that keep the framebuffer constantly up-to-date
2662+ * just ignore it. Frontends that use the advice should immediately
2663+ * refresh the framebuffer (and send an update notification event if
2664+ * those have been requested), then use the update frequency to guide
2665+ * their periodical refreshs.
2666+ */
2667+#define XENFB_TYPE_REFRESH_PERIOD 1
2668+#define XENFB_NO_REFRESH 0
2669+
2670+struct xenfb_refresh_period
2671+{
2672+ uint8_t type; /* XENFB_TYPE_UPDATE_PERIOD */
2673+ uint32_t period; /* period of refresh, in ms,
2674+ * XENFB_NO_REFRESH if no refresh is needed */
2675+};
2676+
2677 #define XENFB_IN_EVENT_SIZE 40
2678
2679-union xenfb_in_event {
2680- uint8_t type;
2681- char pad[XENFB_IN_EVENT_SIZE];
2682+union xenfb_in_event
2683+{
2684+ uint8_t type;
2685+ struct xenfb_refresh_period refresh_period;
2686+ char pad[XENFB_IN_EVENT_SIZE];
2687 };
2688
2689 /* shared page */
2690@@ -93,41 +116,41 @@ union xenfb_in_event {
2691 #define XENFB_IN_RING_LEN (XENFB_IN_RING_SIZE / XENFB_IN_EVENT_SIZE)
2692 #define XENFB_IN_RING_OFFS 1024
2693 #define XENFB_IN_RING(page) \
2694- ((union xenfb_in_event *)((char *)(page) + XENFB_IN_RING_OFFS))
2695+ ((union xenfb_in_event *)((char *)(page) + XENFB_IN_RING_OFFS))
2696 #define XENFB_IN_RING_REF(page, idx) \
2697- (XENFB_IN_RING((page))[(idx) % XENFB_IN_RING_LEN])
2698+ (XENFB_IN_RING((page))[(idx) % XENFB_IN_RING_LEN])
2699
2700 #define XENFB_OUT_RING_SIZE 2048
2701 #define XENFB_OUT_RING_LEN (XENFB_OUT_RING_SIZE / XENFB_OUT_EVENT_SIZE)
2702 #define XENFB_OUT_RING_OFFS (XENFB_IN_RING_OFFS + XENFB_IN_RING_SIZE)
2703 #define XENFB_OUT_RING(page) \
2704- ((union xenfb_out_event *)((char *)(page) + XENFB_OUT_RING_OFFS))
2705+ ((union xenfb_out_event *)((char *)(page) + XENFB_OUT_RING_OFFS))
2706 #define XENFB_OUT_RING_REF(page, idx) \
2707- (XENFB_OUT_RING((page))[(idx) % XENFB_OUT_RING_LEN])
2708+ (XENFB_OUT_RING((page))[(idx) % XENFB_OUT_RING_LEN])
2709
2710-struct xenfb_page {
2711- uint32_t in_cons, in_prod;
2712- uint32_t out_cons, out_prod;
2713-
2714- int32_t width; /* width of the framebuffer (in pixels) */
2715- int32_t height; /* height of the framebuffer (in pixels) */
2716- uint32_t line_length; /* length of a row of pixels (in bytes) */
2717- uint32_t mem_length; /* length of the framebuffer (in bytes) */
2718- uint8_t depth; /* depth of a pixel (in bits) */
2719-
2720- /*
2721- * Framebuffer page directory
2722- *
2723- * Each directory page holds PAGE_SIZE / sizeof(*pd)
2724- * framebuffer pages, and can thus map up to PAGE_SIZE *
2725- * PAGE_SIZE / sizeof(*pd) bytes. With PAGE_SIZE == 4096 and
2726- * sizeof(unsigned long) == 4/8, that's 4 Megs 32 bit and 2
2727- * Megs 64 bit. 256 directories give enough room for a 512
2728- * Meg framebuffer with a max resolution of 12,800x10,240.
2729- * Should be enough for a while with room leftover for
2730- * expansion.
2731- */
2732- unsigned long pd[256];
2733+struct xenfb_page
2734+{
2735+ uint32_t in_cons, in_prod;
2736+ uint32_t out_cons, out_prod;
2737+
2738+ int32_t width; /* the width of the framebuffer (in pixels) */
2739+ int32_t height; /* the height of the framebuffer (in pixels) */
2740+ uint32_t line_length; /* the length of a row of pixels (in bytes) */
2741+ uint32_t mem_length; /* the length of the framebuffer (in bytes) */
2742+ uint8_t depth; /* the depth of a pixel (in bits) */
2743+
2744+ /*
2745+ * Framebuffer page directory
2746+ *
2747+ * Each directory page holds PAGE_SIZE / sizeof(*pd)
2748+ * framebuffer pages, and can thus map up to PAGE_SIZE *
2749+ * PAGE_SIZE / sizeof(*pd) bytes. With PAGE_SIZE == 4096 and
2750+ * sizeof(unsigned long) == 4/8, that's 4 Megs 32 bit and 2 Megs
2751+ * 64 bit. 256 directories give enough room for a 512 Meg
2752+ * framebuffer with a max resolution of 12,800x10,240. Should
2753+ * be enough for a while with room leftover for expansion.
2754+ */
2755+ unsigned long pd[256];
2756 };
2757
2758 /*
2759@@ -141,3 +164,13 @@ struct xenfb_page {
2760 #endif
2761
2762 #endif
2763+
2764+/*
2765+ * Local variables:
2766+ * mode: C
2767+ * c-set-style: "BSD"
2768+ * c-basic-offset: 4
2769+ * tab-width: 4
2770+ * indent-tabs-mode: nil
2771+ * End:
2772+ */
2773Index: head-2008-11-25/include/xen/interface/io/kbdif.h
2774===================================================================
2775--- head-2008-11-25.orig/include/xen/interface/io/kbdif.h 2008-11-25 12:33:06.000000000 +0100
2776+++ head-2008-11-25/include/xen/interface/io/kbdif.h 2008-11-25 12:35:56.000000000 +0100
2777@@ -45,34 +45,38 @@
2778 */
2779 #define XENKBD_TYPE_POS 4
2780
2781-struct xenkbd_motion {
2782- uint8_t type; /* XENKBD_TYPE_MOTION */
2783- int32_t rel_x; /* relative X motion */
2784- int32_t rel_y; /* relative Y motion */
2785- int32_t rel_z; /* relative Z motion (wheel) */
2786-};
2787-
2788-struct xenkbd_key {
2789- uint8_t type; /* XENKBD_TYPE_KEY */
2790- uint8_t pressed; /* 1 if pressed; 0 otherwise */
2791- uint32_t keycode; /* KEY_* from linux/input.h */
2792-};
2793-
2794-struct xenkbd_position {
2795- uint8_t type; /* XENKBD_TYPE_POS */
2796- int32_t abs_x; /* absolute X position (in FB pixels) */
2797- int32_t abs_y; /* absolute Y position (in FB pixels) */
2798- int32_t rel_z; /* relative Z motion (wheel) */
2799+struct xenkbd_motion
2800+{
2801+ uint8_t type; /* XENKBD_TYPE_MOTION */
2802+ int32_t rel_x; /* relative X motion */
2803+ int32_t rel_y; /* relative Y motion */
2804+ int32_t rel_z; /* relative Z motion (wheel) */
2805+};
2806+
2807+struct xenkbd_key
2808+{
2809+ uint8_t type; /* XENKBD_TYPE_KEY */
2810+ uint8_t pressed; /* 1 if pressed; 0 otherwise */
2811+ uint32_t keycode; /* KEY_* from linux/input.h */
2812+};
2813+
2814+struct xenkbd_position
2815+{
2816+ uint8_t type; /* XENKBD_TYPE_POS */
2817+ int32_t abs_x; /* absolute X position (in FB pixels) */
2818+ int32_t abs_y; /* absolute Y position (in FB pixels) */
2819+ int32_t rel_z; /* relative Z motion (wheel) */
2820 };
2821
2822 #define XENKBD_IN_EVENT_SIZE 40
2823
2824-union xenkbd_in_event {
2825- uint8_t type;
2826- struct xenkbd_motion motion;
2827- struct xenkbd_key key;
2828- struct xenkbd_position pos;
2829- char pad[XENKBD_IN_EVENT_SIZE];
2830+union xenkbd_in_event
2831+{
2832+ uint8_t type;
2833+ struct xenkbd_motion motion;
2834+ struct xenkbd_key key;
2835+ struct xenkbd_position pos;
2836+ char pad[XENKBD_IN_EVENT_SIZE];
2837 };
2838
2839 /* Out events (frontend -> backend) */
2840@@ -85,9 +89,10 @@ union xenkbd_in_event {
2841
2842 #define XENKBD_OUT_EVENT_SIZE 40
2843
2844-union xenkbd_out_event {
2845- uint8_t type;
2846- char pad[XENKBD_OUT_EVENT_SIZE];
2847+union xenkbd_out_event
2848+{
2849+ uint8_t type;
2850+ char pad[XENKBD_OUT_EVENT_SIZE];
2851 };
2852
2853 /* shared page */
2854@@ -96,21 +101,32 @@ union xenkbd_out_event {
2855 #define XENKBD_IN_RING_LEN (XENKBD_IN_RING_SIZE / XENKBD_IN_EVENT_SIZE)
2856 #define XENKBD_IN_RING_OFFS 1024
2857 #define XENKBD_IN_RING(page) \
2858- ((union xenkbd_in_event *)((char *)(page) + XENKBD_IN_RING_OFFS))
2859+ ((union xenkbd_in_event *)((char *)(page) + XENKBD_IN_RING_OFFS))
2860 #define XENKBD_IN_RING_REF(page, idx) \
2861- (XENKBD_IN_RING((page))[(idx) % XENKBD_IN_RING_LEN])
2862+ (XENKBD_IN_RING((page))[(idx) % XENKBD_IN_RING_LEN])
2863
2864 #define XENKBD_OUT_RING_SIZE 1024
2865 #define XENKBD_OUT_RING_LEN (XENKBD_OUT_RING_SIZE / XENKBD_OUT_EVENT_SIZE)
2866 #define XENKBD_OUT_RING_OFFS (XENKBD_IN_RING_OFFS + XENKBD_IN_RING_SIZE)
2867 #define XENKBD_OUT_RING(page) \
2868- ((union xenkbd_out_event *)((char *)(page) + XENKBD_OUT_RING_OFFS))
2869+ ((union xenkbd_out_event *)((char *)(page) + XENKBD_OUT_RING_OFFS))
2870 #define XENKBD_OUT_RING_REF(page, idx) \
2871- (XENKBD_OUT_RING((page))[(idx) % XENKBD_OUT_RING_LEN])
2872+ (XENKBD_OUT_RING((page))[(idx) % XENKBD_OUT_RING_LEN])
2873
2874-struct xenkbd_page {
2875- uint32_t in_cons, in_prod;
2876- uint32_t out_cons, out_prod;
2877+struct xenkbd_page
2878+{
2879+ uint32_t in_cons, in_prod;
2880+ uint32_t out_cons, out_prod;
2881 };
2882
2883 #endif
2884+
2885+/*
2886+ * Local variables:
2887+ * mode: C
2888+ * c-set-style: "BSD"
2889+ * c-basic-offset: 4
2890+ * tab-width: 4
2891+ * indent-tabs-mode: nil
2892+ * End:
2893+ */
2894Index: head-2008-11-25/include/xen/interface/io/netif.h
2895===================================================================
2896--- head-2008-11-25.orig/include/xen/interface/io/netif.h 2008-11-25 12:33:06.000000000 +0100
2897+++ head-2008-11-25/include/xen/interface/io/netif.h 2008-11-25 12:35:56.000000000 +0100
2898@@ -3,6 +3,24 @@
2899 *
2900 * Unified network-device I/O interface for Xen guest OSes.
2901 *
2902+ * Permission is hereby granted, free of charge, to any person obtaining a copy
2903+ * of this software and associated documentation files (the "Software"), to
2904+ * deal in the Software without restriction, including without limitation the
2905+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
2906+ * sell copies of the Software, and to permit persons to whom the Software is
2907+ * furnished to do so, subject to the following conditions:
2908+ *
2909+ * The above copyright notice and this permission notice shall be included in
2910+ * all copies or substantial portions of the Software.
2911+ *
2912+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
2913+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
2914+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
2915+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2916+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
2917+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
2918+ * DEALINGS IN THE SOFTWARE.
2919+ *
2920 * Copyright (c) 2003-2004, Keir Fraser
2921 */
2922
2923@@ -47,18 +65,21 @@
2924 #define _NETTXF_extra_info (3)
2925 #define NETTXF_extra_info (1U<<_NETTXF_extra_info)
2926
2927-struct xen_netif_tx_request {
2928+struct netif_tx_request {
2929 grant_ref_t gref; /* Reference to buffer page */
2930 uint16_t offset; /* Offset within buffer page */
2931 uint16_t flags; /* NETTXF_* */
2932 uint16_t id; /* Echoed in response message. */
2933 uint16_t size; /* Packet size in bytes. */
2934 };
2935+typedef struct netif_tx_request netif_tx_request_t;
2936
2937 /* Types of netif_extra_info descriptors. */
2938-#define XEN_NETIF_EXTRA_TYPE_NONE (0) /* Never used - invalid */
2939-#define XEN_NETIF_EXTRA_TYPE_GSO (1) /* u.gso */
2940-#define XEN_NETIF_EXTRA_TYPE_MAX (2)
2941+#define XEN_NETIF_EXTRA_TYPE_NONE (0) /* Never used - invalid */
2942+#define XEN_NETIF_EXTRA_TYPE_GSO (1) /* u.gso */
2943+#define XEN_NETIF_EXTRA_TYPE_MCAST_ADD (2) /* u.mcast */
2944+#define XEN_NETIF_EXTRA_TYPE_MCAST_DEL (3) /* u.mcast */
2945+#define XEN_NETIF_EXTRA_TYPE_MAX (4)
2946
2947 /* netif_extra_info flags. */
2948 #define _XEN_NETIF_EXTRA_FLAG_MORE (0)
2949@@ -71,49 +92,68 @@ struct xen_netif_tx_request {
2950 * This structure needs to fit within both netif_tx_request and
2951 * netif_rx_response for compatibility.
2952 */
2953-struct xen_netif_extra_info {
2954- uint8_t type; /* XEN_NETIF_EXTRA_TYPE_* */
2955- uint8_t flags; /* XEN_NETIF_EXTRA_FLAG_* */
2956-
2957- union {
2958- struct {
2959- /*
2960- * Maximum payload size of each segment. For
2961- * example, for TCP this is just the path MSS.
2962- */
2963- uint16_t size;
2964-
2965- /*
2966- * GSO type. This determines the protocol of
2967- * the packet and any extra features required
2968- * to segment the packet properly.
2969- */
2970- uint8_t type; /* XEN_NETIF_GSO_TYPE_* */
2971-
2972- /* Future expansion. */
2973- uint8_t pad;
2974-
2975- /*
2976- * GSO features. This specifies any extra GSO
2977- * features required to process this packet,
2978- * such as ECN support for TCPv4.
2979- */
2980- uint16_t features; /* XEN_NETIF_GSO_FEAT_* */
2981- } gso;
2982+struct netif_extra_info {
2983+ uint8_t type; /* XEN_NETIF_EXTRA_TYPE_* */
2984+ uint8_t flags; /* XEN_NETIF_EXTRA_FLAG_* */
2985+
2986+ union {
2987+ /*
2988+ * XEN_NETIF_EXTRA_TYPE_GSO:
2989+ */
2990+ struct {
2991+ /*
2992+ * Maximum payload size of each segment. For example, for TCP this
2993+ * is just the path MSS.
2994+ */
2995+ uint16_t size;
2996+
2997+ /*
2998+ * GSO type. This determines the protocol of the packet and any
2999+ * extra features required to segment the packet properly.
3000+ */
3001+ uint8_t type; /* XEN_NETIF_GSO_TYPE_* */
3002+
3003+ /* Future expansion. */
3004+ uint8_t pad;
3005+
3006+ /*
3007+ * GSO features. This specifies any extra GSO features required
3008+ * to process this packet, such as ECN support for TCPv4.
3009+ */
3010+ uint16_t features; /* XEN_NETIF_GSO_FEAT_* */
3011+ } gso;
3012+
3013+ /*
3014+ * XEN_NETIF_EXTRA_TYPE_MCAST_{ADD,DEL}:
3015+ * Backend advertises availability via 'feature-multicast-control'
3016+ * xenbus node containing value '1'.
3017+ * Frontend requests this feature by advertising
3018+ * 'request-multicast-control' xenbus node containing value '1'.
3019+ * If multicast control is requested then multicast flooding is
3020+ * disabled and the frontend must explicitly register its interest
3021+ * in multicast groups using dummy transmit requests containing
3022+ * MCAST_{ADD,DEL} extra-info fragments.
3023+ */
3024+ struct {
3025+ uint8_t addr[6]; /* Address to add/remove. */
3026+ } mcast;
3027
3028- uint16_t pad[3];
3029- } u;
3030+ uint16_t pad[3];
3031+ } u;
3032 };
3033+typedef struct netif_extra_info netif_extra_info_t;
3034
3035-struct xen_netif_tx_response {
3036- uint16_t id;
3037- int16_t status; /* NETIF_RSP_* */
3038+struct netif_tx_response {
3039+ uint16_t id;
3040+ int16_t status; /* NETIF_RSP_* */
3041 };
3042+typedef struct netif_tx_response netif_tx_response_t;
3043
3044-struct xen_netif_rx_request {
3045- uint16_t id; /* Echoed in response message. */
3046- grant_ref_t gref; /* Reference to incoming granted frame */
3047+struct netif_rx_request {
3048+ uint16_t id; /* Echoed in response message. */
3049+ grant_ref_t gref; /* Reference to incoming granted frame */
3050 };
3051+typedef struct netif_rx_request netif_rx_request_t;
3052
3053 /* Packet data has been validated against protocol checksum. */
3054 #define _NETRXF_data_validated (0)
3055@@ -131,23 +171,20 @@ struct xen_netif_rx_request {
3056 #define _NETRXF_extra_info (3)
3057 #define NETRXF_extra_info (1U<<_NETRXF_extra_info)
3058
3059-struct xen_netif_rx_response {
3060+struct netif_rx_response {
3061 uint16_t id;
3062 uint16_t offset; /* Offset in page of start of received packet */
3063 uint16_t flags; /* NETRXF_* */
3064 int16_t status; /* -ve: BLKIF_RSP_* ; +ve: Rx'ed pkt size. */
3065 };
3066+typedef struct netif_rx_response netif_rx_response_t;
3067
3068 /*
3069 * Generate netif ring structures and types.
3070 */
3071
3072-DEFINE_RING_TYPES(xen_netif_tx,
3073- struct xen_netif_tx_request,
3074- struct xen_netif_tx_response);
3075-DEFINE_RING_TYPES(xen_netif_rx,
3076- struct xen_netif_rx_request,
3077- struct xen_netif_rx_response);
3078+DEFINE_RING_TYPES(netif_tx, struct netif_tx_request, struct netif_tx_response);
3079+DEFINE_RING_TYPES(netif_rx, struct netif_rx_request, struct netif_rx_response);
3080
3081 #define NETIF_RSP_DROPPED -2
3082 #define NETIF_RSP_ERROR -1
3083@@ -156,3 +193,13 @@ DEFINE_RING_TYPES(xen_netif_rx,
3084 #define NETIF_RSP_NULL 1
3085
3086 #endif
3087+
3088+/*
3089+ * Local variables:
3090+ * mode: C
3091+ * c-set-style: "BSD"
3092+ * c-basic-offset: 4
3093+ * tab-width: 4
3094+ * indent-tabs-mode: nil
3095+ * End:
3096+ */
3097Index: head-2008-11-25/include/xen/interface/io/protocols.h
3098===================================================================
3099--- head-2008-11-25.orig/include/xen/interface/io/protocols.h 2008-11-25 12:33:06.000000000 +0100
3100+++ head-2008-11-25/include/xen/interface/io/protocols.h 2008-11-25 12:35:56.000000000 +0100
3101@@ -1,10 +1,31 @@
3102+/******************************************************************************
3103+ * protocols.h
3104+ *
3105+ * Permission is hereby granted, free of charge, to any person obtaining a copy
3106+ * of this software and associated documentation files (the "Software"), to
3107+ * deal in the Software without restriction, including without limitation the
3108+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
3109+ * sell copies of the Software, and to permit persons to whom the Software is
3110+ * furnished to do so, subject to the following conditions:
3111+ *
3112+ * The above copyright notice and this permission notice shall be included in
3113+ * all copies or substantial portions of the Software.
3114+ *
3115+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3116+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3117+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3118+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3119+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
3120+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3121+ * DEALINGS IN THE SOFTWARE.
3122+ */
3123+
3124 #ifndef __XEN_PROTOCOLS_H__
3125 #define __XEN_PROTOCOLS_H__
3126
3127 #define XEN_IO_PROTO_ABI_X86_32 "x86_32-abi"
3128 #define XEN_IO_PROTO_ABI_X86_64 "x86_64-abi"
3129 #define XEN_IO_PROTO_ABI_IA64 "ia64-abi"
3130-#define XEN_IO_PROTO_ABI_POWERPC64 "powerpc64-abi"
3131
3132 #if defined(__i386__)
3133 # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_32
3134@@ -12,8 +33,6 @@
3135 # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_64
3136 #elif defined(__ia64__)
3137 # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_IA64
3138-#elif defined(__powerpc64__)
3139-# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_POWERPC64
3140 #else
3141 # error arch fixup needed here
3142 #endif
3143Index: head-2008-11-25/include/xen/interface/io/ring.h
3144===================================================================
3145--- head-2008-11-25.orig/include/xen/interface/io/ring.h 2008-11-25 12:33:06.000000000 +0100
3146+++ head-2008-11-25/include/xen/interface/io/ring.h 2008-11-25 12:35:56.000000000 +0100
3147@@ -3,16 +3,42 @@
3148 *
3149 * Shared producer-consumer ring macros.
3150 *
3151+ * Permission is hereby granted, free of charge, to any person obtaining a copy
3152+ * of this software and associated documentation files (the "Software"), to
3153+ * deal in the Software without restriction, including without limitation the
3154+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
3155+ * sell copies of the Software, and to permit persons to whom the Software is
3156+ * furnished to do so, subject to the following conditions:
3157+ *
3158+ * The above copyright notice and this permission notice shall be included in
3159+ * all copies or substantial portions of the Software.
3160+ *
3161+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3162+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3163+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3164+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3165+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
3166+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3167+ * DEALINGS IN THE SOFTWARE.
3168+ *
3169 * Tim Deegan and Andrew Warfield November 2004.
3170 */
3171
3172 #ifndef __XEN_PUBLIC_IO_RING_H__
3173 #define __XEN_PUBLIC_IO_RING_H__
3174
3175+#include "../xen-compat.h"
3176+
3177+#if __XEN_INTERFACE_VERSION__ < 0x00030208
3178+#define xen_mb() mb()
3179+#define xen_rmb() rmb()
3180+#define xen_wmb() wmb()
3181+#endif
3182+
3183 typedef unsigned int RING_IDX;
3184
3185 /* Round a 32-bit unsigned constant down to the nearest power of two. */
3186-#define __RD2(_x) (((_x) & 0x00000002) ? 0x2 : ((_x) & 0x1))
3187+#define __RD2(_x) (((_x) & 0x00000002) ? 0x2 : ((_x) & 0x1))
3188 #define __RD4(_x) (((_x) & 0x0000000c) ? __RD2((_x)>>2)<<2 : __RD2(_x))
3189 #define __RD8(_x) (((_x) & 0x000000f0) ? __RD4((_x)>>4)<<4 : __RD4(_x))
3190 #define __RD16(_x) (((_x) & 0x0000ff00) ? __RD8((_x)>>8)<<8 : __RD8(_x))
3191@@ -25,73 +51,76 @@ typedef unsigned int RING_IDX;
3192 * power of two (so we can mask with (size-1) to loop around).
3193 */
3194 #define __RING_SIZE(_s, _sz) \
3195- (__RD32(((_sz) - (long)&(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))
3196+ (__RD32(((_sz) - (long)(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))
3197
3198 /*
3199 * Macros to make the correct C datatypes for a new kind of ring.
3200 *
3201 * To make a new ring datatype, you need to have two message structures,
3202- * let's say struct request, and struct response already defined.
3203+ * let's say request_t, and response_t already defined.
3204 *
3205 * In a header where you want the ring datatype declared, you then do:
3206 *
3207- * DEFINE_RING_TYPES(mytag, struct request, struct response);
3208+ * DEFINE_RING_TYPES(mytag, request_t, response_t);
3209 *
3210 * These expand out to give you a set of types, as you can see below.
3211 * The most important of these are:
3212 *
3213- * struct mytag_sring - The shared ring.
3214- * struct mytag_front_ring - The 'front' half of the ring.
3215- * struct mytag_back_ring - The 'back' half of the ring.
3216+ * mytag_sring_t - The shared ring.
3217+ * mytag_front_ring_t - The 'front' half of the ring.
3218+ * mytag_back_ring_t - The 'back' half of the ring.
3219 *
3220 * To initialize a ring in your code you need to know the location and size
3221 * of the shared memory area (PAGE_SIZE, for instance). To initialise
3222 * the front half:
3223 *
3224- * struct mytag_front_ring front_ring;
3225- * SHARED_RING_INIT((struct mytag_sring *)shared_page);
3226- * FRONT_RING_INIT(&front_ring, (struct mytag_sring *)shared_page,
3227- * PAGE_SIZE);
3228+ * mytag_front_ring_t front_ring;
3229+ * SHARED_RING_INIT((mytag_sring_t *)shared_page);
3230+ * FRONT_RING_INIT(&front_ring, (mytag_sring_t *)shared_page, PAGE_SIZE);
3231 *
3232 * Initializing the back follows similarly (note that only the front
3233 * initializes the shared ring):
3234 *
3235- * struct mytag_back_ring back_ring;
3236- * BACK_RING_INIT(&back_ring, (struct mytag_sring *)shared_page,
3237- * PAGE_SIZE);
3238+ * mytag_back_ring_t back_ring;
3239+ * BACK_RING_INIT(&back_ring, (mytag_sring_t *)shared_page, PAGE_SIZE);
3240 */
3241
3242-#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t) \
3243- \
3244-/* Shared ring entry */ \
3245-union __name##_sring_entry { \
3246- __req_t req; \
3247- __rsp_t rsp; \
3248-}; \
3249- \
3250-/* Shared ring page */ \
3251-struct __name##_sring { \
3252- RING_IDX req_prod, req_event; \
3253- RING_IDX rsp_prod, rsp_event; \
3254- uint8_t pad[48]; \
3255- union __name##_sring_entry ring[1]; /* variable-length */ \
3256-}; \
3257- \
3258-/* "Front" end's private variables */ \
3259-struct __name##_front_ring { \
3260- RING_IDX req_prod_pvt; \
3261- RING_IDX rsp_cons; \
3262- unsigned int nr_ents; \
3263- struct __name##_sring *sring; \
3264-}; \
3265- \
3266-/* "Back" end's private variables */ \
3267-struct __name##_back_ring { \
3268- RING_IDX rsp_prod_pvt; \
3269- RING_IDX req_cons; \
3270- unsigned int nr_ents; \
3271- struct __name##_sring *sring; \
3272-};
3273+#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t) \
3274+ \
3275+/* Shared ring entry */ \
3276+union __name##_sring_entry { \
3277+ __req_t req; \
3278+ __rsp_t rsp; \
3279+}; \
3280+ \
3281+/* Shared ring page */ \
3282+struct __name##_sring { \
3283+ RING_IDX req_prod, req_event; \
3284+ RING_IDX rsp_prod, rsp_event; \
3285+ uint8_t pad[48]; \
3286+ union __name##_sring_entry ring[1]; /* variable-length */ \
3287+}; \
3288+ \
3289+/* "Front" end's private variables */ \
3290+struct __name##_front_ring { \
3291+ RING_IDX req_prod_pvt; \
3292+ RING_IDX rsp_cons; \
3293+ unsigned int nr_ents; \
3294+ struct __name##_sring *sring; \
3295+}; \
3296+ \
3297+/* "Back" end's private variables */ \
3298+struct __name##_back_ring { \
3299+ RING_IDX rsp_prod_pvt; \
3300+ RING_IDX req_cons; \
3301+ unsigned int nr_ents; \
3302+ struct __name##_sring *sring; \
3303+}; \
3304+ \
3305+/* Syntactic sugar */ \
3306+typedef struct __name##_sring __name##_sring_t; \
3307+typedef struct __name##_front_ring __name##_front_ring_t; \
3308+typedef struct __name##_back_ring __name##_back_ring_t
3309
3310 /*
3311 * Macros for manipulating rings.
3312@@ -109,86 +138,94 @@ struct __name##_back_ring { \
3313 */
3314
3315 /* Initialising empty rings */
3316-#define SHARED_RING_INIT(_s) do { \
3317- (_s)->req_prod = (_s)->rsp_prod = 0; \
3318- (_s)->req_event = (_s)->rsp_event = 1; \
3319- memset((_s)->pad, 0, sizeof((_s)->pad)); \
3320+#define SHARED_RING_INIT(_s) do { \
3321+ (_s)->req_prod = (_s)->rsp_prod = 0; \
3322+ (_s)->req_event = (_s)->rsp_event = 1; \
3323+ (void)memset((_s)->pad, 0, sizeof((_s)->pad)); \
3324 } while(0)
3325
3326-#define FRONT_RING_INIT(_r, _s, __size) do { \
3327- (_r)->req_prod_pvt = 0; \
3328- (_r)->rsp_cons = 0; \
3329- (_r)->nr_ents = __RING_SIZE(_s, __size); \
3330- (_r)->sring = (_s); \
3331+#define FRONT_RING_INIT(_r, _s, __size) do { \
3332+ (_r)->req_prod_pvt = 0; \
3333+ (_r)->rsp_cons = 0; \
3334+ (_r)->nr_ents = __RING_SIZE(_s, __size); \
3335+ (_r)->sring = (_s); \
3336 } while (0)
3337
3338-#define BACK_RING_INIT(_r, _s, __size) do { \
3339- (_r)->rsp_prod_pvt = 0; \
3340- (_r)->req_cons = 0; \
3341- (_r)->nr_ents = __RING_SIZE(_s, __size); \
3342- (_r)->sring = (_s); \
3343+#define BACK_RING_INIT(_r, _s, __size) do { \
3344+ (_r)->rsp_prod_pvt = 0; \
3345+ (_r)->req_cons = 0; \
3346+ (_r)->nr_ents = __RING_SIZE(_s, __size); \
3347+ (_r)->sring = (_s); \
3348 } while (0)
3349
3350 /* Initialize to existing shared indexes -- for recovery */
3351-#define FRONT_RING_ATTACH(_r, _s, __size) do { \
3352- (_r)->sring = (_s); \
3353- (_r)->req_prod_pvt = (_s)->req_prod; \
3354- (_r)->rsp_cons = (_s)->rsp_prod; \
3355- (_r)->nr_ents = __RING_SIZE(_s, __size); \
3356+#define FRONT_RING_ATTACH(_r, _s, __size) do { \
3357+ (_r)->sring = (_s); \
3358+ (_r)->req_prod_pvt = (_s)->req_prod; \
3359+ (_r)->rsp_cons = (_s)->rsp_prod; \
3360+ (_r)->nr_ents = __RING_SIZE(_s, __size); \
3361 } while (0)
3362
3363-#define BACK_RING_ATTACH(_r, _s, __size) do { \
3364- (_r)->sring = (_s); \
3365- (_r)->rsp_prod_pvt = (_s)->rsp_prod; \
3366- (_r)->req_cons = (_s)->req_prod; \
3367- (_r)->nr_ents = __RING_SIZE(_s, __size); \
3368+#define BACK_RING_ATTACH(_r, _s, __size) do { \
3369+ (_r)->sring = (_s); \
3370+ (_r)->rsp_prod_pvt = (_s)->rsp_prod; \
3371+ (_r)->req_cons = (_s)->req_prod; \
3372+ (_r)->nr_ents = __RING_SIZE(_s, __size); \
3373 } while (0)
3374
3375 /* How big is this ring? */
3376-#define RING_SIZE(_r) \
3377+#define RING_SIZE(_r) \
3378 ((_r)->nr_ents)
3379
3380 /* Number of free requests (for use on front side only). */
3381-#define RING_FREE_REQUESTS(_r) \
3382+#define RING_FREE_REQUESTS(_r) \
3383 (RING_SIZE(_r) - ((_r)->req_prod_pvt - (_r)->rsp_cons))
3384
3385 /* Test if there is an empty slot available on the front ring.
3386 * (This is only meaningful from the front. )
3387 */
3388-#define RING_FULL(_r) \
3389+#define RING_FULL(_r) \
3390 (RING_FREE_REQUESTS(_r) == 0)
3391
3392 /* Test if there are outstanding messages to be processed on a ring. */
3393-#define RING_HAS_UNCONSUMED_RESPONSES(_r) \
3394+#define RING_HAS_UNCONSUMED_RESPONSES(_r) \
3395 ((_r)->sring->rsp_prod - (_r)->rsp_cons)
3396
3397-#define RING_HAS_UNCONSUMED_REQUESTS(_r) \
3398- ({ \
3399- unsigned int req = (_r)->sring->req_prod - (_r)->req_cons; \
3400- unsigned int rsp = RING_SIZE(_r) - \
3401- ((_r)->req_cons - (_r)->rsp_prod_pvt); \
3402- req < rsp ? req : rsp; \
3403- })
3404+#ifdef __GNUC__
3405+#define RING_HAS_UNCONSUMED_REQUESTS(_r) ({ \
3406+ unsigned int req = (_r)->sring->req_prod - (_r)->req_cons; \
3407+ unsigned int rsp = RING_SIZE(_r) - \
3408+ ((_r)->req_cons - (_r)->rsp_prod_pvt); \
3409+ req < rsp ? req : rsp; \
3410+})
3411+#else
3412+/* Same as above, but without the nice GCC ({ ... }) syntax. */
3413+#define RING_HAS_UNCONSUMED_REQUESTS(_r) \
3414+ ((((_r)->sring->req_prod - (_r)->req_cons) < \
3415+ (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt))) ? \
3416+ ((_r)->sring->req_prod - (_r)->req_cons) : \
3417+ (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt)))
3418+#endif
3419
3420 /* Direct access to individual ring elements, by index. */
3421-#define RING_GET_REQUEST(_r, _idx) \
3422+#define RING_GET_REQUEST(_r, _idx) \
3423 (&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].req))
3424
3425-#define RING_GET_RESPONSE(_r, _idx) \
3426+#define RING_GET_RESPONSE(_r, _idx) \
3427 (&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].rsp))
3428
3429 /* Loop termination condition: Would the specified index overflow the ring? */
3430-#define RING_REQUEST_CONS_OVERFLOW(_r, _cons) \
3431+#define RING_REQUEST_CONS_OVERFLOW(_r, _cons) \
3432 (((_cons) - (_r)->rsp_prod_pvt) >= RING_SIZE(_r))
3433
3434-#define RING_PUSH_REQUESTS(_r) do { \
3435- wmb(); /* back sees requests /before/ updated producer index */ \
3436- (_r)->sring->req_prod = (_r)->req_prod_pvt; \
3437+#define RING_PUSH_REQUESTS(_r) do { \
3438+ xen_wmb(); /* back sees requests /before/ updated producer index */ \
3439+ (_r)->sring->req_prod = (_r)->req_prod_pvt; \
3440 } while (0)
3441
3442-#define RING_PUSH_RESPONSES(_r) do { \
3443- wmb(); /* front sees responses /before/ updated producer index */ \
3444- (_r)->sring->rsp_prod = (_r)->rsp_prod_pvt; \
3445+#define RING_PUSH_RESPONSES(_r) do { \
3446+ xen_wmb(); /* front sees resps /before/ updated producer index */ \
3447+ (_r)->sring->rsp_prod = (_r)->rsp_prod_pvt; \
3448 } while (0)
3449
3450 /*
3451@@ -221,40 +258,50 @@ struct __name##_back_ring { \
3452 * field appropriately.
3453 */
3454
3455-#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(_r, _notify) do { \
3456- RING_IDX __old = (_r)->sring->req_prod; \
3457- RING_IDX __new = (_r)->req_prod_pvt; \
3458- wmb(); /* back sees requests /before/ updated producer index */ \
3459- (_r)->sring->req_prod = __new; \
3460- mb(); /* back sees new requests /before/ we check req_event */ \
3461- (_notify) = ((RING_IDX)(__new - (_r)->sring->req_event) < \
3462- (RING_IDX)(__new - __old)); \
3463+#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(_r, _notify) do { \
3464+ RING_IDX __old = (_r)->sring->req_prod; \
3465+ RING_IDX __new = (_r)->req_prod_pvt; \
3466+ xen_wmb(); /* back sees requests /before/ updated producer index */ \
3467+ (_r)->sring->req_prod = __new; \
3468+ xen_mb(); /* back sees new requests /before/ we check req_event */ \
3469+ (_notify) = ((RING_IDX)(__new - (_r)->sring->req_event) < \
3470+ (RING_IDX)(__new - __old)); \
3471 } while (0)
3472
3473-#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify) do { \
3474- RING_IDX __old = (_r)->sring->rsp_prod; \
3475- RING_IDX __new = (_r)->rsp_prod_pvt; \
3476- wmb(); /* front sees responses /before/ updated producer index */ \
3477- (_r)->sring->rsp_prod = __new; \
3478- mb(); /* front sees new responses /before/ we check rsp_event */ \
3479- (_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
3480- (RING_IDX)(__new - __old)); \
3481+#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify) do { \
3482+ RING_IDX __old = (_r)->sring->rsp_prod; \
3483+ RING_IDX __new = (_r)->rsp_prod_pvt; \
3484+ xen_wmb(); /* front sees resps /before/ updated producer index */ \
3485+ (_r)->sring->rsp_prod = __new; \
3486+ xen_mb(); /* front sees new resps /before/ we check rsp_event */ \
3487+ (_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
3488+ (RING_IDX)(__new - __old)); \
3489 } while (0)
3490
3491-#define RING_FINAL_CHECK_FOR_REQUESTS(_r, _work_to_do) do { \
3492- (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
3493- if (_work_to_do) break; \
3494- (_r)->sring->req_event = (_r)->req_cons + 1; \
3495- mb(); \
3496- (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
3497+#define RING_FINAL_CHECK_FOR_REQUESTS(_r, _work_to_do) do { \
3498+ (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
3499+ if (_work_to_do) break; \
3500+ (_r)->sring->req_event = (_r)->req_cons + 1; \
3501+ xen_mb(); \
3502+ (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
3503 } while (0)
3504
3505-#define RING_FINAL_CHECK_FOR_RESPONSES(_r, _work_to_do) do { \
3506- (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
3507- if (_work_to_do) break; \
3508- (_r)->sring->rsp_event = (_r)->rsp_cons + 1; \
3509- mb(); \
3510- (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
3511+#define RING_FINAL_CHECK_FOR_RESPONSES(_r, _work_to_do) do { \
3512+ (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
3513+ if (_work_to_do) break; \
3514+ (_r)->sring->rsp_event = (_r)->rsp_cons + 1; \
3515+ xen_mb(); \
3516+ (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
3517 } while (0)
3518
3519 #endif /* __XEN_PUBLIC_IO_RING_H__ */
3520+
3521+/*
3522+ * Local variables:
3523+ * mode: C
3524+ * c-set-style: "BSD"
3525+ * c-basic-offset: 4
3526+ * tab-width: 4
3527+ * indent-tabs-mode: nil
3528+ * End:
3529+ */
3530Index: head-2008-11-25/include/xen/interface/io/xenbus.h
3531===================================================================
3532--- head-2008-11-25.orig/include/xen/interface/io/xenbus.h 2008-11-25 12:33:06.000000000 +0100
3533+++ head-2008-11-25/include/xen/interface/io/xenbus.h 2008-11-25 12:35:56.000000000 +0100
3534@@ -3,42 +3,78 @@
3535 *
3536 * Xenbus protocol details.
3537 *
3538+ * Permission is hereby granted, free of charge, to any person obtaining a copy
3539+ * of this software and associated documentation files (the "Software"), to
3540+ * deal in the Software without restriction, including without limitation the
3541+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
3542+ * sell copies of the Software, and to permit persons to whom the Software is
3543+ * furnished to do so, subject to the following conditions:
3544+ *
3545+ * The above copyright notice and this permission notice shall be included in
3546+ * all copies or substantial portions of the Software.
3547+ *
3548+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3549+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3550+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3551+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3552+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
3553+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3554+ * DEALINGS IN THE SOFTWARE.
3555+ *
3556 * Copyright (C) 2005 XenSource Ltd.
3557 */
3558
3559 #ifndef _XEN_PUBLIC_IO_XENBUS_H
3560 #define _XEN_PUBLIC_IO_XENBUS_H
3561
3562-/* The state of either end of the Xenbus, i.e. the current communication
3563- status of initialisation across the bus. States here imply nothing about
3564- the state of the connection between the driver and the kernel's device
3565- layers. */
3566-enum xenbus_state
3567-{
3568- XenbusStateUnknown = 0,
3569- XenbusStateInitialising = 1,
3570- XenbusStateInitWait = 2, /* Finished early
3571- initialisation, but waiting
3572- for information from the peer
3573- or hotplug scripts. */
3574- XenbusStateInitialised = 3, /* Initialised and waiting for a
3575- connection from the peer. */
3576- XenbusStateConnected = 4,
3577- XenbusStateClosing = 5, /* The device is being closed
3578- due to an error or an unplug
3579- event. */
3580- XenbusStateClosed = 6
3581+/*
3582+ * The state of either end of the Xenbus, i.e. the current communication
3583+ * status of initialisation across the bus. States here imply nothing about
3584+ * the state of the connection between the driver and the kernel's device
3585+ * layers.
3586+ */
3587+enum xenbus_state {
3588+ XenbusStateUnknown = 0,
3589+
3590+ XenbusStateInitialising = 1,
3591+
3592+ /*
3593+ * InitWait: Finished early initialisation but waiting for information
3594+ * from the peer or hotplug scripts.
3595+ */
3596+ XenbusStateInitWait = 2,
3597+
3598+ /*
3599+ * Initialised: Waiting for a connection from the peer.
3600+ */
3601+ XenbusStateInitialised = 3,
3602+
3603+ XenbusStateConnected = 4,
3604+
3605+ /*
3606+ * Closing: The device is being closed due to an error or an unplug event.
3607+ */
3608+ XenbusStateClosing = 5,
3609+
3610+ XenbusStateClosed = 6,
3611+
3612+ /*
3613+ * Reconfiguring: The device is being reconfigured.
3614+ */
3615+ XenbusStateReconfiguring = 7,
3616
3617+ XenbusStateReconfigured = 8
3618 };
3619+typedef enum xenbus_state XenbusState;
3620
3621 #endif /* _XEN_PUBLIC_IO_XENBUS_H */
3622
3623 /*
3624 * Local variables:
3625- * c-file-style: "linux"
3626- * indent-tabs-mode: t
3627- * c-indent-level: 8
3628- * c-basic-offset: 8
3629- * tab-width: 8
3630+ * mode: C
3631+ * c-set-style: "BSD"
3632+ * c-basic-offset: 4
3633+ * tab-width: 4
3634+ * indent-tabs-mode: nil
3635 * End:
3636 */
3637Index: head-2008-11-25/include/xen/interface/io/xs_wire.h
3638===================================================================
3639--- head-2008-11-25.orig/include/xen/interface/io/xs_wire.h 2008-11-25 12:33:06.000000000 +0100
3640+++ head-2008-11-25/include/xen/interface/io/xs_wire.h 2008-11-25 12:35:56.000000000 +0100
3641@@ -1,6 +1,25 @@
3642 /*
3643 * Details of the "wire" protocol between Xen Store Daemon and client
3644 * library or guest kernel.
3645+ *
3646+ * Permission is hereby granted, free of charge, to any person obtaining a copy
3647+ * of this software and associated documentation files (the "Software"), to
3648+ * deal in the Software without restriction, including without limitation the
3649+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
3650+ * sell copies of the Software, and to permit persons to whom the Software is
3651+ * furnished to do so, subject to the following conditions:
3652+ *
3653+ * The above copyright notice and this permission notice shall be included in
3654+ * all copies or substantial portions of the Software.
3655+ *
3656+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3657+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3658+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3659+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3660+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
3661+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3662+ * DEALINGS IN THE SOFTWARE.
3663+ *
3664 * Copyright (C) 2005 Rusty Russell IBM Corporation
3665 */
3666
3667@@ -26,7 +45,9 @@ enum xsd_sockmsg_type
3668 XS_SET_PERMS,
3669 XS_WATCH_EVENT,
3670 XS_ERROR,
3671- XS_IS_DOMAIN_INTRODUCED
3672+ XS_IS_DOMAIN_INTRODUCED,
3673+ XS_RESUME,
3674+ XS_SET_TARGET
3675 };
3676
3677 #define XS_WRITE_NONE "NONE"
3678@@ -40,7 +61,12 @@ struct xsd_errors
3679 const char *errstring;
3680 };
3681 #define XSD_ERROR(x) { x, #x }
3682-static struct xsd_errors xsd_errors[] __attribute__((unused)) = {
3683+/* LINTED: static unused */
3684+static struct xsd_errors xsd_errors[]
3685+#if defined(__GNUC__)
3686+__attribute__((unused))
3687+#endif
3688+ = {
3689 XSD_ERROR(EINVAL),
3690 XSD_ERROR(EACCES),
3691 XSD_ERROR(EEXIST),
3692@@ -84,4 +110,21 @@ struct xenstore_domain_interface {
3693 XENSTORE_RING_IDX rsp_cons, rsp_prod;
3694 };
3695
3696+/* Violating this is very bad. See docs/misc/xenstore.txt. */
3697+#define XENSTORE_PAYLOAD_MAX 4096
3698+
3699+/* Violating these just gets you an error back */
3700+#define XENSTORE_ABS_PATH_MAX 3072
3701+#define XENSTORE_REL_PATH_MAX 2048
3702+
3703 #endif /* _XS_WIRE_H */
3704+
3705+/*
3706+ * Local variables:
3707+ * mode: C
3708+ * c-set-style: "BSD"
3709+ * c-basic-offset: 4
3710+ * tab-width: 4
3711+ * indent-tabs-mode: nil
3712+ * End:
3713+ */
3714Index: head-2008-11-25/include/xen/interface/memory.h
3715===================================================================
3716--- head-2008-11-25.orig/include/xen/interface/memory.h 2008-11-25 12:33:06.000000000 +0100
3717+++ head-2008-11-25/include/xen/interface/memory.h 2008-11-25 12:35:56.000000000 +0100
3718@@ -3,6 +3,24 @@
3719 *
3720 * Memory reservation and information.
3721 *
3722+ * Permission is hereby granted, free of charge, to any person obtaining a copy
3723+ * of this software and associated documentation files (the "Software"), to
3724+ * deal in the Software without restriction, including without limitation the
3725+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
3726+ * sell copies of the Software, and to permit persons to whom the Software is
3727+ * furnished to do so, subject to the following conditions:
3728+ *
3729+ * The above copyright notice and this permission notice shall be included in
3730+ * all copies or substantial portions of the Software.
3731+ *
3732+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3733+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3734+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3735+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3736+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
3737+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3738+ * DEALINGS IN THE SOFTWARE.
3739+ *
3740 * Copyright (c) 2005, Keir Fraser <keir@xensource.com>
3741 */
3742
3743@@ -10,13 +28,28 @@
3744 #define __XEN_PUBLIC_MEMORY_H__
3745
3746 /*
3747- * Increase or decrease the specified domain's memory reservation. Returns a
3748- * -ve errcode on failure, or the # extents successfully allocated or freed.
3749+ * Increase or decrease the specified domain's memory reservation. Returns the
3750+ * number of extents successfully allocated or freed.
3751 * arg == addr of struct xen_memory_reservation.
3752 */
3753 #define XENMEM_increase_reservation 0
3754 #define XENMEM_decrease_reservation 1
3755 #define XENMEM_populate_physmap 6
3756+
3757+#if __XEN_INTERFACE_VERSION__ >= 0x00030209
3758+/*
3759+ * Maximum # bits addressable by the user of the allocated region (e.g., I/O
3760+ * devices often have a 32-bit limitation even in 64-bit systems). If zero
3761+ * then the user has no addressing restriction. This field is not used by
3762+ * XENMEM_decrease_reservation.
3763+ */
3764+#define XENMEMF_address_bits(x) (x)
3765+#define XENMEMF_get_address_bits(x) ((x) & 0xffu)
3766+/* NUMA node to allocate from. */
3767+#define XENMEMF_node(x) (((x) + 1) << 8)
3768+#define XENMEMF_get_node(x) ((((x) >> 8) - 1) & 0xffu)
3769+#endif
3770+
3771 struct xen_memory_reservation {
3772
3773 /*
3774@@ -29,19 +62,18 @@ struct xen_memory_reservation {
3775 * OUT: GMFN bases of extents that were allocated
3776 * (NB. This command also updates the mach_to_phys translation table)
3777 */
3778- GUEST_HANDLE(ulong) extent_start;
3779+ XEN_GUEST_HANDLE(ulong) extent_start;
3780
3781 /* Number of extents, and size/alignment of each (2^extent_order pages). */
3782- unsigned long nr_extents;
3783+ xen_ulong_t nr_extents;
3784 unsigned int extent_order;
3785
3786- /*
3787- * Maximum # bits addressable by the user of the allocated region (e.g.,
3788- * I/O devices often have a 32-bit limitation even in 64-bit systems). If
3789- * zero then the user has no addressing restriction.
3790- * This field is not used by XENMEM_decrease_reservation.
3791- */
3792+#if __XEN_INTERFACE_VERSION__ >= 0x00030209
3793+ /* XENMEMF flags. */
3794+ unsigned int mem_flags;
3795+#else
3796 unsigned int address_bits;
3797+#endif
3798
3799 /*
3800 * Domain whose reservation is being changed.
3801@@ -50,7 +82,51 @@ struct xen_memory_reservation {
3802 domid_t domid;
3803
3804 };
3805-DEFINE_GUEST_HANDLE_STRUCT(xen_memory_reservation);
3806+typedef struct xen_memory_reservation xen_memory_reservation_t;
3807+DEFINE_XEN_GUEST_HANDLE(xen_memory_reservation_t);
3808+
3809+/*
3810+ * An atomic exchange of memory pages. If return code is zero then
3811+ * @out.extent_list provides GMFNs of the newly-allocated memory.
3812+ * Returns zero on complete success, otherwise a negative error code.
3813+ * On complete success then always @nr_exchanged == @in.nr_extents.
3814+ * On partial success @nr_exchanged indicates how much work was done.
3815+ */
3816+#define XENMEM_exchange 11
3817+struct xen_memory_exchange {
3818+ /*
3819+ * [IN] Details of memory extents to be exchanged (GMFN bases).
3820+ * Note that @in.address_bits is ignored and unused.
3821+ */
3822+ struct xen_memory_reservation in;
3823+
3824+ /*
3825+ * [IN/OUT] Details of new memory extents.
3826+ * We require that:
3827+ * 1. @in.domid == @out.domid
3828+ * 2. @in.nr_extents << @in.extent_order ==
3829+ * @out.nr_extents << @out.extent_order
3830+ * 3. @in.extent_start and @out.extent_start lists must not overlap
3831+ * 4. @out.extent_start lists GPFN bases to be populated
3832+ * 5. @out.extent_start is overwritten with allocated GMFN bases
3833+ */
3834+ struct xen_memory_reservation out;
3835+
3836+ /*
3837+ * [OUT] Number of input extents that were successfully exchanged:
3838+ * 1. The first @nr_exchanged input extents were successfully
3839+ * deallocated.
3840+ * 2. The corresponding first entries in the output extent list correctly
3841+ * indicate the GMFNs that were successfully exchanged.
3842+ * 3. All other input and output extents are untouched.
3843+ * 4. If not all input exents are exchanged then the return code of this
3844+ * command will be non-zero.
3845+ * 5. THIS FIELD MUST BE INITIALISED TO ZERO BY THE CALLER!
3846+ */
3847+ xen_ulong_t nr_exchanged;
3848+};
3849+typedef struct xen_memory_exchange xen_memory_exchange_t;
3850+DEFINE_XEN_GUEST_HANDLE(xen_memory_exchange_t);
3851
3852 /*
3853 * Returns the maximum machine frame number of mapped RAM in this system.
3854@@ -68,6 +144,11 @@ DEFINE_GUEST_HANDLE_STRUCT(xen_memory_re
3855 #define XENMEM_maximum_reservation 4
3856
3857 /*
3858+ * Returns the maximum GPFN in use by the guest, or -ve errcode on failure.
3859+ */
3860+#define XENMEM_maximum_gpfn 14
3861+
3862+/*
3863 * Returns a list of MFN bases of 2MB extents comprising the machine_to_phys
3864 * mapping table. Architectures which do not have a m2p table do not implement
3865 * this command.
3866@@ -86,7 +167,7 @@ struct xen_machphys_mfn_list {
3867 * any large discontiguities in the machine address space, 2MB gaps in
3868 * the machphys table will be represented by an MFN base of zero.
3869 */
3870- GUEST_HANDLE(ulong) extent_start;
3871+ XEN_GUEST_HANDLE(xen_pfn_t) extent_start;
3872
3873 /*
3874 * Number of extents written to the above array. This will be smaller
3875@@ -94,7 +175,22 @@ struct xen_machphys_mfn_list {
3876 */
3877 unsigned int nr_extents;
3878 };
3879-DEFINE_GUEST_HANDLE_STRUCT(xen_machphys_mfn_list);
3880+typedef struct xen_machphys_mfn_list xen_machphys_mfn_list_t;
3881+DEFINE_XEN_GUEST_HANDLE(xen_machphys_mfn_list_t);
3882+
3883+/*
3884+ * Returns the location in virtual address space of the machine_to_phys
3885+ * mapping table. Architectures which do not have a m2p table, or which do not
3886+ * map it by default into guest address space, do not implement this command.
3887+ * arg == addr of xen_machphys_mapping_t.
3888+ */
3889+#define XENMEM_machphys_mapping 12
3890+struct xen_machphys_mapping {
3891+ xen_ulong_t v_start, v_end; /* Start and end virtual addresses. */
3892+ xen_ulong_t max_mfn; /* Maximum MFN that can be looked up. */
3893+};
3894+typedef struct xen_machphys_mapping xen_machphys_mapping_t;
3895+DEFINE_XEN_GUEST_HANDLE(xen_machphys_mapping_t);
3896
3897 /*
3898 * Sets the GPFN at which a particular page appears in the specified guest's
3899@@ -109,15 +205,33 @@ struct xen_add_to_physmap {
3900 /* Source mapping space. */
3901 #define XENMAPSPACE_shared_info 0 /* shared info page */
3902 #define XENMAPSPACE_grant_table 1 /* grant table page */
3903+#define XENMAPSPACE_mfn 2 /* usual MFN */
3904 unsigned int space;
3905
3906 /* Index into source mapping space. */
3907- unsigned long idx;
3908+ xen_ulong_t idx;
3909
3910 /* GPFN where the source mapping page should appear. */
3911- unsigned long gpfn;
3912+ xen_pfn_t gpfn;
3913 };
3914-DEFINE_GUEST_HANDLE_STRUCT(xen_add_to_physmap);
3915+typedef struct xen_add_to_physmap xen_add_to_physmap_t;
3916+DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_t);
3917+
3918+/*
3919+ * Unmaps the page appearing at a particular GPFN from the specified guest's
3920+ * pseudophysical address space.
3921+ * arg == addr of xen_remove_from_physmap_t.
3922+ */
3923+#define XENMEM_remove_from_physmap 15
3924+struct xen_remove_from_physmap {
3925+ /* Which domain to change the mapping for. */
3926+ domid_t domid;
3927+
3928+ /* GPFN of the current mapping of the page. */
3929+ xen_pfn_t gpfn;
3930+};
3931+typedef struct xen_remove_from_physmap xen_remove_from_physmap_t;
3932+DEFINE_XEN_GUEST_HANDLE(xen_remove_from_physmap_t);
3933
3934 /*
3935 * Translates a list of domain-specific GPFNs into MFNs. Returns a -ve error
3936@@ -129,17 +243,71 @@ struct xen_translate_gpfn_list {
3937 domid_t domid;
3938
3939 /* Length of list. */
3940- unsigned long nr_gpfns;
3941+ xen_ulong_t nr_gpfns;
3942
3943 /* List of GPFNs to translate. */
3944- GUEST_HANDLE(ulong) gpfn_list;
3945+ XEN_GUEST_HANDLE(xen_pfn_t) gpfn_list;
3946
3947 /*
3948 * Output list to contain MFN translations. May be the same as the input
3949 * list (in which case each input GPFN is overwritten with the output MFN).
3950 */
3951- GUEST_HANDLE(ulong) mfn_list;
3952+ XEN_GUEST_HANDLE(xen_pfn_t) mfn_list;
3953+};
3954+typedef struct xen_translate_gpfn_list xen_translate_gpfn_list_t;
3955+DEFINE_XEN_GUEST_HANDLE(xen_translate_gpfn_list_t);
3956+
3957+/*
3958+ * Returns the pseudo-physical memory map as it was when the domain
3959+ * was started (specified by XENMEM_set_memory_map).
3960+ * arg == addr of xen_memory_map_t.
3961+ */
3962+#define XENMEM_memory_map 9
3963+struct xen_memory_map {
3964+ /*
3965+ * On call the number of entries which can be stored in buffer. On
3966+ * return the number of entries which have been stored in
3967+ * buffer.
3968+ */
3969+ unsigned int nr_entries;
3970+
3971+ /*
3972+ * Entries in the buffer are in the same format as returned by the
3973+ * BIOS INT 0x15 EAX=0xE820 call.
3974+ */
3975+ XEN_GUEST_HANDLE(void) buffer;
3976+};
3977+typedef struct xen_memory_map xen_memory_map_t;
3978+DEFINE_XEN_GUEST_HANDLE(xen_memory_map_t);
3979+
3980+/*
3981+ * Returns the real physical memory map. Passes the same structure as
3982+ * XENMEM_memory_map.
3983+ * arg == addr of xen_memory_map_t.
3984+ */
3985+#define XENMEM_machine_memory_map 10
3986+
3987+/*
3988+ * Set the pseudo-physical memory map of a domain, as returned by
3989+ * XENMEM_memory_map.
3990+ * arg == addr of xen_foreign_memory_map_t.
3991+ */
3992+#define XENMEM_set_memory_map 13
3993+struct xen_foreign_memory_map {
3994+ domid_t domid;
3995+ struct xen_memory_map map;
3996 };
3997-DEFINE_GUEST_HANDLE_STRUCT(xen_translate_gpfn_list);
3998+typedef struct xen_foreign_memory_map xen_foreign_memory_map_t;
3999+DEFINE_XEN_GUEST_HANDLE(xen_foreign_memory_map_t);
4000
4001 #endif /* __XEN_PUBLIC_MEMORY_H__ */
4002+
4003+/*
4004+ * Local variables:
4005+ * mode: C
4006+ * c-set-style: "BSD"
4007+ * c-basic-offset: 4
4008+ * tab-width: 4
4009+ * indent-tabs-mode: nil
4010+ * End:
4011+ */
4012Index: head-2008-11-25/include/xen/interface/physdev.h
4013===================================================================
4014--- head-2008-11-25.orig/include/xen/interface/physdev.h 2008-11-25 12:33:06.000000000 +0100
4015+++ head-2008-11-25/include/xen/interface/physdev.h 2008-11-25 12:35:56.000000000 +0100
4016@@ -24,7 +24,7 @@
4017 /*
4018 * Prototype for this hypercall is:
4019 * int physdev_op(int cmd, void *args)
4020- * @cmd == PHYSDEVOP_??? (physdev operation).
4021+ * @cmd == PHYSDEVOP_??? (physdev operation).
4022 * @args == Operation-specific extra arguments (NULL if none).
4023 */
4024
4025@@ -32,114 +32,188 @@
4026 * Notify end-of-interrupt (EOI) for the specified IRQ.
4027 * @arg == pointer to physdev_eoi structure.
4028 */
4029-#define PHYSDEVOP_eoi 12
4030+#define PHYSDEVOP_eoi 12
4031 struct physdev_eoi {
4032- /* IN */
4033- uint32_t irq;
4034+ /* IN */
4035+ uint32_t irq;
4036 };
4037+typedef struct physdev_eoi physdev_eoi_t;
4038+DEFINE_XEN_GUEST_HANDLE(physdev_eoi_t);
4039
4040 /*
4041 * Query the status of an IRQ line.
4042 * @arg == pointer to physdev_irq_status_query structure.
4043 */
4044-#define PHYSDEVOP_irq_status_query 5
4045+#define PHYSDEVOP_irq_status_query 5
4046 struct physdev_irq_status_query {
4047- /* IN */
4048- uint32_t irq;
4049- /* OUT */
4050- uint32_t flags; /* XENIRQSTAT_* */
4051+ /* IN */
4052+ uint32_t irq;
4053+ /* OUT */
4054+ uint32_t flags; /* XENIRQSTAT_* */
4055 };
4056+typedef struct physdev_irq_status_query physdev_irq_status_query_t;
4057+DEFINE_XEN_GUEST_HANDLE(physdev_irq_status_query_t);
4058
4059 /* Need to call PHYSDEVOP_eoi when the IRQ has been serviced? */
4060-#define _XENIRQSTAT_needs_eoi (0)
4061-#define XENIRQSTAT_needs_eoi (1U<<_XENIRQSTAT_needs_eoi)
4062+#define _XENIRQSTAT_needs_eoi (0)
4063+#define XENIRQSTAT_needs_eoi (1U<<_XENIRQSTAT_needs_eoi)
4064
4065 /* IRQ shared by multiple guests? */
4066-#define _XENIRQSTAT_shared (1)
4067-#define XENIRQSTAT_shared (1U<<_XENIRQSTAT_shared)
4068+#define _XENIRQSTAT_shared (1)
4069+#define XENIRQSTAT_shared (1U<<_XENIRQSTAT_shared)
4070
4071 /*
4072 * Set the current VCPU's I/O privilege level.
4073 * @arg == pointer to physdev_set_iopl structure.
4074 */
4075-#define PHYSDEVOP_set_iopl 6
4076+#define PHYSDEVOP_set_iopl 6
4077 struct physdev_set_iopl {
4078- /* IN */
4079- uint32_t iopl;
4080+ /* IN */
4081+ uint32_t iopl;
4082 };
4083+typedef struct physdev_set_iopl physdev_set_iopl_t;
4084+DEFINE_XEN_GUEST_HANDLE(physdev_set_iopl_t);
4085
4086 /*
4087 * Set the current VCPU's I/O-port permissions bitmap.
4088 * @arg == pointer to physdev_set_iobitmap structure.
4089 */
4090-#define PHYSDEVOP_set_iobitmap 7
4091+#define PHYSDEVOP_set_iobitmap 7
4092 struct physdev_set_iobitmap {
4093- /* IN */
4094- uint8_t * bitmap;
4095- uint32_t nr_ports;
4096+ /* IN */
4097+#if __XEN_INTERFACE_VERSION__ >= 0x00030205
4098+ XEN_GUEST_HANDLE(uint8) bitmap;
4099+#else
4100+ uint8_t *bitmap;
4101+#endif
4102+ uint32_t nr_ports;
4103 };
4104+typedef struct physdev_set_iobitmap physdev_set_iobitmap_t;
4105+DEFINE_XEN_GUEST_HANDLE(physdev_set_iobitmap_t);
4106
4107 /*
4108 * Read or write an IO-APIC register.
4109 * @arg == pointer to physdev_apic structure.
4110 */
4111-#define PHYSDEVOP_apic_read 8
4112-#define PHYSDEVOP_apic_write 9
4113+#define PHYSDEVOP_apic_read 8
4114+#define PHYSDEVOP_apic_write 9
4115 struct physdev_apic {
4116- /* IN */
4117- unsigned long apic_physbase;
4118- uint32_t reg;
4119- /* IN or OUT */
4120- uint32_t value;
4121+ /* IN */
4122+ unsigned long apic_physbase;
4123+ uint32_t reg;
4124+ /* IN or OUT */
4125+ uint32_t value;
4126 };
4127+typedef struct physdev_apic physdev_apic_t;
4128+DEFINE_XEN_GUEST_HANDLE(physdev_apic_t);
4129
4130 /*
4131 * Allocate or free a physical upcall vector for the specified IRQ line.
4132 * @arg == pointer to physdev_irq structure.
4133 */
4134-#define PHYSDEVOP_alloc_irq_vector 10
4135-#define PHYSDEVOP_free_irq_vector 11
4136+#define PHYSDEVOP_alloc_irq_vector 10
4137+#define PHYSDEVOP_free_irq_vector 11
4138 struct physdev_irq {
4139- /* IN */
4140- uint32_t irq;
4141- /* IN or OUT */
4142- uint32_t vector;
4143+ /* IN */
4144+ uint32_t irq;
4145+ /* IN or OUT */
4146+ uint32_t vector;
4147+};
4148+typedef struct physdev_irq physdev_irq_t;
4149+DEFINE_XEN_GUEST_HANDLE(physdev_irq_t);
4150+
4151+#define MAP_PIRQ_TYPE_MSI 0x0
4152+#define MAP_PIRQ_TYPE_GSI 0x1
4153+#define MAP_PIRQ_TYPE_UNKNOWN 0x2
4154+
4155+#define PHYSDEVOP_map_pirq 13
4156+struct physdev_map_pirq {
4157+ domid_t domid;
4158+ /* IN */
4159+ int type;
4160+ /* IN */
4161+ int index;
4162+ /* IN or OUT */
4163+ int pirq;
4164+ /* IN */
4165+ int bus;
4166+ /* IN */
4167+ int devfn;
4168+ /* IN */
4169+ int entry_nr;
4170+ /* IN */
4171+ uint64_t table_base;
4172+};
4173+typedef struct physdev_map_pirq physdev_map_pirq_t;
4174+DEFINE_XEN_GUEST_HANDLE(physdev_map_pirq_t);
4175+
4176+#define PHYSDEVOP_unmap_pirq 14
4177+struct physdev_unmap_pirq {
4178+ domid_t domid;
4179+ /* IN */
4180+ int pirq;
4181+};
4182+
4183+typedef struct physdev_unmap_pirq physdev_unmap_pirq_t;
4184+DEFINE_XEN_GUEST_HANDLE(physdev_unmap_pirq_t);
4185+
4186+#define PHYSDEVOP_manage_pci_add 15
4187+#define PHYSDEVOP_manage_pci_remove 16
4188+struct physdev_manage_pci {
4189+ /* IN */
4190+ uint8_t bus;
4191+ uint8_t devfn;
4192 };
4193
4194+typedef struct physdev_manage_pci physdev_manage_pci_t;
4195+DEFINE_XEN_GUEST_HANDLE(physdev_manage_pci_t);
4196+
4197 /*
4198 * Argument to physdev_op_compat() hypercall. Superceded by new physdev_op()
4199 * hypercall since 0x00030202.
4200 */
4201 struct physdev_op {
4202- uint32_t cmd;
4203- union {
4204- struct physdev_irq_status_query irq_status_query;
4205- struct physdev_set_iopl set_iopl;
4206- struct physdev_set_iobitmap set_iobitmap;
4207- struct physdev_apic apic_op;
4208- struct physdev_irq irq_op;
4209- } u;
4210+ uint32_t cmd;
4211+ union {
4212+ struct physdev_irq_status_query irq_status_query;
4213+ struct physdev_set_iopl set_iopl;
4214+ struct physdev_set_iobitmap set_iobitmap;
4215+ struct physdev_apic apic_op;
4216+ struct physdev_irq irq_op;
4217+ } u;
4218 };
4219+typedef struct physdev_op physdev_op_t;
4220+DEFINE_XEN_GUEST_HANDLE(physdev_op_t);
4221
4222 /*
4223 * Notify that some PIRQ-bound event channels have been unmasked.
4224 * ** This command is obsolete since interface version 0x00030202 and is **
4225- * ** unsupported by newer versions of Xen. **
4226+ * ** unsupported by newer versions of Xen. **
4227 */
4228-#define PHYSDEVOP_IRQ_UNMASK_NOTIFY 4
4229+#define PHYSDEVOP_IRQ_UNMASK_NOTIFY 4
4230
4231 /*
4232 * These all-capitals physdev operation names are superceded by the new names
4233 * (defined above) since interface version 0x00030202.
4234 */
4235-#define PHYSDEVOP_IRQ_STATUS_QUERY PHYSDEVOP_irq_status_query
4236-#define PHYSDEVOP_SET_IOPL PHYSDEVOP_set_iopl
4237-#define PHYSDEVOP_SET_IOBITMAP PHYSDEVOP_set_iobitmap
4238-#define PHYSDEVOP_APIC_READ PHYSDEVOP_apic_read
4239-#define PHYSDEVOP_APIC_WRITE PHYSDEVOP_apic_write
4240-#define PHYSDEVOP_ASSIGN_VECTOR PHYSDEVOP_alloc_irq_vector
4241-#define PHYSDEVOP_FREE_VECTOR PHYSDEVOP_free_irq_vector
4242+#define PHYSDEVOP_IRQ_STATUS_QUERY PHYSDEVOP_irq_status_query
4243+#define PHYSDEVOP_SET_IOPL PHYSDEVOP_set_iopl
4244+#define PHYSDEVOP_SET_IOBITMAP PHYSDEVOP_set_iobitmap
4245+#define PHYSDEVOP_APIC_READ PHYSDEVOP_apic_read
4246+#define PHYSDEVOP_APIC_WRITE PHYSDEVOP_apic_write
4247+#define PHYSDEVOP_ASSIGN_VECTOR PHYSDEVOP_alloc_irq_vector
4248+#define PHYSDEVOP_FREE_VECTOR PHYSDEVOP_free_irq_vector
4249 #define PHYSDEVOP_IRQ_NEEDS_UNMASK_NOTIFY XENIRQSTAT_needs_eoi
4250-#define PHYSDEVOP_IRQ_SHARED XENIRQSTAT_shared
4251+#define PHYSDEVOP_IRQ_SHARED XENIRQSTAT_shared
4252
4253 #endif /* __XEN_PUBLIC_PHYSDEV_H__ */
4254+
4255+/*
4256+ * Local variables:
4257+ * mode: C
4258+ * c-set-style: "BSD"
4259+ * c-basic-offset: 4
4260+ * tab-width: 4
4261+ * indent-tabs-mode: nil
4262+ * End:
4263+ */
4264Index: head-2008-11-25/include/xen/interface/sched.h
4265===================================================================
4266--- head-2008-11-25.orig/include/xen/interface/sched.h 2008-11-25 12:33:06.000000000 +0100
4267+++ head-2008-11-25/include/xen/interface/sched.h 2008-11-25 12:35:56.000000000 +0100
4268@@ -3,6 +3,24 @@
4269 *
4270 * Scheduler state interactions
4271 *
4272+ * Permission is hereby granted, free of charge, to any person obtaining a copy
4273+ * of this software and associated documentation files (the "Software"), to
4274+ * deal in the Software without restriction, including without limitation the
4275+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
4276+ * sell copies of the Software, and to permit persons to whom the Software is
4277+ * furnished to do so, subject to the following conditions:
4278+ *
4279+ * The above copyright notice and this permission notice shall be included in
4280+ * all copies or substantial portions of the Software.
4281+ *
4282+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
4283+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
4284+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
4285+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
4286+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
4287+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
4288+ * DEALINGS IN THE SOFTWARE.
4289+ *
4290 * Copyright (c) 2005, Keir Fraser <keir@xensource.com>
4291 */
4292
4293@@ -13,17 +31,17 @@
4294
4295 /*
4296 * The prototype for this hypercall is:
4297- * long sched_op_new(int cmd, void *arg)
4298+ * long sched_op(int cmd, void *arg)
4299 * @cmd == SCHEDOP_??? (scheduler operation).
4300 * @arg == Operation-specific extra argument(s), as described below.
4301 *
4302- * **NOTE**:
4303- * Versions of Xen prior to 3.0.2 provide only the following legacy version
4304+ * Versions of Xen prior to 3.0.2 provided only the following legacy version
4305 * of this hypercall, supporting only the commands yield, block and shutdown:
4306 * long sched_op(int cmd, unsigned long arg)
4307 * @cmd == SCHEDOP_??? (scheduler operation).
4308 * @arg == 0 (SCHEDOP_yield and SCHEDOP_block)
4309 * == SHUTDOWN_* code (SCHEDOP_shutdown)
4310+ * This legacy version is available to new guests as sched_op_compat().
4311 */
4312
4313 /*
4314@@ -49,7 +67,8 @@
4315 struct sched_shutdown {
4316 unsigned int reason; /* SHUTDOWN_* */
4317 };
4318-DEFINE_GUEST_HANDLE_STRUCT(sched_shutdown);
4319+typedef struct sched_shutdown sched_shutdown_t;
4320+DEFINE_XEN_GUEST_HANDLE(sched_shutdown_t);
4321
4322 /*
4323 * Poll a set of event-channel ports. Return when one or more are pending. An
4324@@ -58,11 +77,26 @@ DEFINE_GUEST_HANDLE_STRUCT(sched_shutdow
4325 */
4326 #define SCHEDOP_poll 3
4327 struct sched_poll {
4328- GUEST_HANDLE(evtchn_port_t) ports;
4329+ XEN_GUEST_HANDLE(evtchn_port_t) ports;
4330 unsigned int nr_ports;
4331 uint64_t timeout;
4332 };
4333-DEFINE_GUEST_HANDLE_STRUCT(sched_poll);
4334+typedef struct sched_poll sched_poll_t;
4335+DEFINE_XEN_GUEST_HANDLE(sched_poll_t);
4336+
4337+/*
4338+ * Declare a shutdown for another domain. The main use of this function is
4339+ * in interpreting shutdown requests and reasons for fully-virtualized
4340+ * domains. A para-virtualized domain may use SCHEDOP_shutdown directly.
4341+ * @arg == pointer to sched_remote_shutdown structure.
4342+ */
4343+#define SCHEDOP_remote_shutdown 4
4344+struct sched_remote_shutdown {
4345+ domid_t domain_id; /* Remote domain ID */
4346+ unsigned int reason; /* SHUTDOWN_xxx reason */
4347+};
4348+typedef struct sched_remote_shutdown sched_remote_shutdown_t;
4349+DEFINE_XEN_GUEST_HANDLE(sched_remote_shutdown_t);
4350
4351 /*
4352 * Reason codes for SCHEDOP_shutdown. These may be interpreted by control
4353@@ -75,3 +109,13 @@ DEFINE_GUEST_HANDLE_STRUCT(sched_poll);
4354 #define SHUTDOWN_crash 3 /* Tell controller we've crashed. */
4355
4356 #endif /* __XEN_PUBLIC_SCHED_H__ */
4357+
4358+/*
4359+ * Local variables:
4360+ * mode: C
4361+ * c-set-style: "BSD"
4362+ * c-basic-offset: 4
4363+ * tab-width: 4
4364+ * indent-tabs-mode: nil
4365+ * End:
4366+ */
4367Index: head-2008-11-25/include/xen/interface/vcpu.h
4368===================================================================
4369--- head-2008-11-25.orig/include/xen/interface/vcpu.h 2008-11-25 12:33:06.000000000 +0100
4370+++ head-2008-11-25/include/xen/interface/vcpu.h 2008-11-25 12:35:56.000000000 +0100
4371@@ -29,9 +29,9 @@
4372
4373 /*
4374 * Prototype for this hypercall is:
4375- * int vcpu_op(int cmd, int vcpuid, void *extra_args)
4376- * @cmd == VCPUOP_??? (VCPU operation).
4377- * @vcpuid == VCPU to operate on.
4378+ * int vcpu_op(int cmd, int vcpuid, void *extra_args)
4379+ * @cmd == VCPUOP_??? (VCPU operation).
4380+ * @vcpuid == VCPU to operate on.
4381 * @extra_args == Operation-specific extra arguments (NULL if none).
4382 */
4383
4384@@ -40,52 +40,53 @@
4385 * newly-initialised VCPU will not run until it is brought up by VCPUOP_up.
4386 *
4387 * @extra_arg == pointer to vcpu_guest_context structure containing initial
4388- * state for the VCPU.
4389+ * state for the VCPU.
4390 */
4391-#define VCPUOP_initialise 0
4392+#define VCPUOP_initialise 0
4393
4394 /*
4395 * Bring up a VCPU. This makes the VCPU runnable. This operation will fail
4396 * if the VCPU has not been initialised (VCPUOP_initialise).
4397 */
4398-#define VCPUOP_up 1
4399+#define VCPUOP_up 1
4400
4401 /*
4402 * Bring down a VCPU (i.e., make it non-runnable).
4403 * There are a few caveats that callers should observe:
4404- * 1. This operation may return, and VCPU_is_up may return false, before the
4405- * VCPU stops running (i.e., the command is asynchronous). It is a good
4406- * idea to ensure that the VCPU has entered a non-critical loop before
4407- * bringing it down. Alternatively, this operation is guaranteed
4408- * synchronous if invoked by the VCPU itself.
4409- * 2. After a VCPU is initialised, there is currently no way to drop all its
4410- * references to domain memory. Even a VCPU that is down still holds
4411- * memory references via its pagetable base pointer and GDT. It is good
4412- * practise to move a VCPU onto an 'idle' or default page table, LDT and
4413- * GDT before bringing it down.
4414+ * 1. This operation may return, and VCPU_is_up may return false, before the
4415+ * VCPU stops running (i.e., the command is asynchronous). It is a good
4416+ * idea to ensure that the VCPU has entered a non-critical loop before
4417+ * bringing it down. Alternatively, this operation is guaranteed
4418+ * synchronous if invoked by the VCPU itself.
4419+ * 2. After a VCPU is initialised, there is currently no way to drop all its
4420+ * references to domain memory. Even a VCPU that is down still holds
4421+ * memory references via its pagetable base pointer and GDT. It is good
4422+ * practise to move a VCPU onto an 'idle' or default page table, LDT and
4423+ * GDT before bringing it down.
4424 */
4425-#define VCPUOP_down 2
4426+#define VCPUOP_down 2
4427
4428 /* Returns 1 if the given VCPU is up. */
4429-#define VCPUOP_is_up 3
4430+#define VCPUOP_is_up 3
4431
4432 /*
4433 * Return information about the state and running time of a VCPU.
4434 * @extra_arg == pointer to vcpu_runstate_info structure.
4435 */
4436-#define VCPUOP_get_runstate_info 4
4437+#define VCPUOP_get_runstate_info 4
4438 struct vcpu_runstate_info {
4439- /* VCPU's current state (RUNSTATE_*). */
4440- int state;
4441- /* When was current state entered (system time, ns)? */
4442- uint64_t state_entry_time;
4443- /*
4444- * Time spent in each RUNSTATE_* (ns). The sum of these times is
4445- * guaranteed not to drift from system time.
4446- */
4447- uint64_t time[4];
4448+ /* VCPU's current state (RUNSTATE_*). */
4449+ int state;
4450+ /* When was current state entered (system time, ns)? */
4451+ uint64_t state_entry_time;
4452+ /*
4453+ * Time spent in each RUNSTATE_* (ns). The sum of these times is
4454+ * guaranteed not to drift from system time.
4455+ */
4456+ uint64_t time[4];
4457 };
4458-DEFINE_GUEST_HANDLE_STRUCT(vcpu_runstate_info);
4459+typedef struct vcpu_runstate_info vcpu_runstate_info_t;
4460+DEFINE_XEN_GUEST_HANDLE(vcpu_runstate_info_t);
4461
4462 /* VCPU is currently running on a physical CPU. */
4463 #define RUNSTATE_running 0
4464@@ -108,47 +109,52 @@ DEFINE_GUEST_HANDLE_STRUCT(vcpu_runstate
4465 * Register a shared memory area from which the guest may obtain its own
4466 * runstate information without needing to execute a hypercall.
4467 * Notes:
4468- * 1. The registered address may be virtual or physical, depending on the
4469- * platform. The virtual address should be registered on x86 systems.
4470- * 2. Only one shared area may be registered per VCPU. The shared area is
4471- * updated by the hypervisor each time the VCPU is scheduled. Thus
4472- * runstate.state will always be RUNSTATE_running and
4473- * runstate.state_entry_time will indicate the system time at which the
4474- * VCPU was last scheduled to run.
4475+ * 1. The registered address may be virtual or physical or guest handle,
4476+ * depending on the platform. Virtual address or guest handle should be
4477+ * registered on x86 systems.
4478+ * 2. Only one shared area may be registered per VCPU. The shared area is
4479+ * updated by the hypervisor each time the VCPU is scheduled. Thus
4480+ * runstate.state will always be RUNSTATE_running and
4481+ * runstate.state_entry_time will indicate the system time at which the
4482+ * VCPU was last scheduled to run.
4483 * @extra_arg == pointer to vcpu_register_runstate_memory_area structure.
4484 */
4485 #define VCPUOP_register_runstate_memory_area 5
4486 struct vcpu_register_runstate_memory_area {
4487- union {
4488- GUEST_HANDLE(vcpu_runstate_info) h;
4489- struct vcpu_runstate_info *v;
4490- uint64_t p;
4491- } addr;
4492+ union {
4493+ XEN_GUEST_HANDLE(vcpu_runstate_info_t) h;
4494+ struct vcpu_runstate_info *v;
4495+ uint64_t p;
4496+ } addr;
4497 };
4498+typedef struct vcpu_register_runstate_memory_area vcpu_register_runstate_memory_area_t;
4499+DEFINE_XEN_GUEST_HANDLE(vcpu_register_runstate_memory_area_t);
4500
4501 /*
4502 * Set or stop a VCPU's periodic timer. Every VCPU has one periodic timer
4503 * which can be set via these commands. Periods smaller than one millisecond
4504 * may not be supported.
4505 */
4506-#define VCPUOP_set_periodic_timer 6 /* arg == vcpu_set_periodic_timer_t */
4507-#define VCPUOP_stop_periodic_timer 7 /* arg == NULL */
4508+#define VCPUOP_set_periodic_timer 6 /* arg == vcpu_set_periodic_timer_t */
4509+#define VCPUOP_stop_periodic_timer 7 /* arg == NULL */
4510 struct vcpu_set_periodic_timer {
4511- uint64_t period_ns;
4512+ uint64_t period_ns;
4513 };
4514-DEFINE_GUEST_HANDLE_STRUCT(vcpu_set_periodic_timer);
4515+typedef struct vcpu_set_periodic_timer vcpu_set_periodic_timer_t;
4516+DEFINE_XEN_GUEST_HANDLE(vcpu_set_periodic_timer_t);
4517
4518 /*
4519 * Set or stop a VCPU's single-shot timer. Every VCPU has one single-shot
4520 * timer which can be set via these commands.
4521 */
4522-#define VCPUOP_set_singleshot_timer 8 /* arg == vcpu_set_singleshot_timer_t */
4523+#define VCPUOP_set_singleshot_timer 8 /* arg == vcpu_set_singleshot_timer_t */
4524 #define VCPUOP_stop_singleshot_timer 9 /* arg == NULL */
4525 struct vcpu_set_singleshot_timer {
4526- uint64_t timeout_abs_ns;
4527- uint32_t flags; /* VCPU_SSHOTTMR_??? */
4528+ uint64_t timeout_abs_ns; /* Absolute system time value in nanoseconds. */
4529+ uint32_t flags; /* VCPU_SSHOTTMR_??? */
4530 };
4531-DEFINE_GUEST_HANDLE_STRUCT(vcpu_set_singleshot_timer);
4532+typedef struct vcpu_set_singleshot_timer vcpu_set_singleshot_timer_t;
4533+DEFINE_XEN_GUEST_HANDLE(vcpu_set_singleshot_timer_t);
4534
4535 /* Flags to VCPUOP_set_singleshot_timer. */
4536 /* Require the timeout to be in the future (return -ETIME if it's passed). */
4537@@ -161,13 +167,47 @@ DEFINE_GUEST_HANDLE_STRUCT(vcpu_set_sing
4538 * structure in a convenient place, such as in a per-cpu data area.
4539 * The pointer need not be page aligned, but the structure must not
4540 * cross a page boundary.
4541+ *
4542+ * This may be called only once per vcpu.
4543 */
4544-#define VCPUOP_register_vcpu_info 10 /* arg == struct vcpu_info */
4545+#define VCPUOP_register_vcpu_info 10 /* arg == vcpu_register_vcpu_info_t */
4546 struct vcpu_register_vcpu_info {
4547 uint64_t mfn; /* mfn of page to place vcpu_info */
4548 uint32_t offset; /* offset within page */
4549 uint32_t rsvd; /* unused */
4550 };
4551-DEFINE_GUEST_HANDLE_STRUCT(vcpu_register_vcpu_info);
4552+typedef struct vcpu_register_vcpu_info vcpu_register_vcpu_info_t;
4553+DEFINE_XEN_GUEST_HANDLE(vcpu_register_vcpu_info_t);
4554+
4555+/* Send an NMI to the specified VCPU. @extra_arg == NULL. */
4556+#define VCPUOP_send_nmi 11
4557+
4558+/*
4559+ * Get the physical ID information for a pinned vcpu's underlying physical
4560+ * processor. The physical ID informmation is architecture-specific.
4561+ * On x86: id[31:0]=apic_id, id[63:32]=acpi_id, and all values 0xff and
4562+ * greater are reserved.
4563+ * This command returns -EINVAL if it is not a valid operation for this VCPU.
4564+ */
4565+#define VCPUOP_get_physid 12 /* arg == vcpu_get_physid_t */
4566+struct vcpu_get_physid {
4567+ uint64_t phys_id;
4568+};
4569+typedef struct vcpu_get_physid vcpu_get_physid_t;
4570+DEFINE_XEN_GUEST_HANDLE(vcpu_get_physid_t);
4571+#define xen_vcpu_physid_to_x86_apicid(physid) \
4572+ ((((uint32_t)(physid)) >= 0xff) ? 0xff : ((uint8_t)(physid)))
4573+#define xen_vcpu_physid_to_x86_acpiid(physid) \
4574+ ((((uint32_t)((physid)>>32)) >= 0xff) ? 0xff : ((uint8_t)((physid)>>32)))
4575
4576 #endif /* __XEN_PUBLIC_VCPU_H__ */
4577+
4578+/*
4579+ * Local variables:
4580+ * mode: C
4581+ * c-set-style: "BSD"
4582+ * c-basic-offset: 4
4583+ * tab-width: 4
4584+ * indent-tabs-mode: nil
4585+ * End:
4586+ */
4587Index: head-2008-11-25/include/xen/interface/version.h
4588===================================================================
4589--- head-2008-11-25.orig/include/xen/interface/version.h 2008-11-25 12:33:06.000000000 +0100
4590+++ head-2008-11-25/include/xen/interface/version.h 2008-11-25 12:35:56.000000000 +0100
4591@@ -3,6 +3,24 @@
4592 *
4593 * Xen version, type, and compile information.
4594 *
4595+ * Permission is hereby granted, free of charge, to any person obtaining a copy
4596+ * of this software and associated documentation files (the "Software"), to
4597+ * deal in the Software without restriction, including without limitation the
4598+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
4599+ * sell copies of the Software, and to permit persons to whom the Software is
4600+ * furnished to do so, subject to the following conditions:
4601+ *
4602+ * The above copyright notice and this permission notice shall be included in
4603+ * all copies or substantial portions of the Software.
4604+ *
4605+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
4606+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
4607+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
4608+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
4609+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
4610+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
4611+ * DEALINGS IN THE SOFTWARE.
4612+ *
4613 * Copyright (c) 2005, Nguyen Anh Quynh <aquynh@gmail.com>
4614 * Copyright (c) 2005, Keir Fraser <keir@xensource.com>
4615 */
4616@@ -10,17 +28,15 @@
4617 #ifndef __XEN_PUBLIC_VERSION_H__
4618 #define __XEN_PUBLIC_VERSION_H__
4619
4620-/* NB. All ops return zero on success, except XENVER_version. */
4621+/* NB. All ops return zero on success, except XENVER_{version,pagesize} */
4622
4623 /* arg == NULL; returns major:minor (16:16). */
4624 #define XENVER_version 0
4625
4626 /* arg == xen_extraversion_t. */
4627 #define XENVER_extraversion 1
4628-struct xen_extraversion {
4629- char extraversion[16];
4630-};
4631-#define XEN_EXTRAVERSION_LEN (sizeof(struct xen_extraversion))
4632+typedef char xen_extraversion_t[16];
4633+#define XEN_EXTRAVERSION_LEN (sizeof(xen_extraversion_t))
4634
4635 /* arg == xen_compile_info_t. */
4636 #define XENVER_compile_info 2
4637@@ -30,31 +46,46 @@ struct xen_compile_info {
4638 char compile_domain[32];
4639 char compile_date[32];
4640 };
4641+typedef struct xen_compile_info xen_compile_info_t;
4642
4643 #define XENVER_capabilities 3
4644-struct xen_capabilities_info {
4645- char info[1024];
4646-};
4647-#define XEN_CAPABILITIES_INFO_LEN (sizeof(struct xen_capabilities_info))
4648+typedef char xen_capabilities_info_t[1024];
4649+#define XEN_CAPABILITIES_INFO_LEN (sizeof(xen_capabilities_info_t))
4650
4651 #define XENVER_changeset 4
4652-struct xen_changeset_info {
4653- char info[64];
4654-};
4655-#define XEN_CHANGESET_INFO_LEN (sizeof(struct xen_changeset_info))
4656+typedef char xen_changeset_info_t[64];
4657+#define XEN_CHANGESET_INFO_LEN (sizeof(xen_changeset_info_t))
4658
4659 #define XENVER_platform_parameters 5
4660 struct xen_platform_parameters {
4661 unsigned long virt_start;
4662 };
4663+typedef struct xen_platform_parameters xen_platform_parameters_t;
4664
4665 #define XENVER_get_features 6
4666 struct xen_feature_info {
4667 unsigned int submap_idx; /* IN: which 32-bit submap to return */
4668 uint32_t submap; /* OUT: 32-bit submap */
4669 };
4670+typedef struct xen_feature_info xen_feature_info_t;
4671
4672 /* Declares the features reported by XENVER_get_features. */
4673 #include "features.h"
4674
4675+/* arg == NULL; returns host memory page size. */
4676+#define XENVER_pagesize 7
4677+
4678+/* arg == xen_domain_handle_t. */
4679+#define XENVER_guest_handle 8
4680+
4681 #endif /* __XEN_PUBLIC_VERSION_H__ */
4682+
4683+/*
4684+ * Local variables:
4685+ * mode: C
4686+ * c-set-style: "BSD"
4687+ * c-basic-offset: 4
4688+ * tab-width: 4
4689+ * indent-tabs-mode: nil
4690+ * End:
4691+ */
4692Index: head-2008-11-25/include/xen/interface/xen.h
4693===================================================================
4694--- head-2008-11-25.orig/include/xen/interface/xen.h 2008-11-25 12:33:06.000000000 +0100
4695+++ head-2008-11-25/include/xen/interface/xen.h 2008-11-25 12:35:56.000000000 +0100
4696@@ -3,35 +3,68 @@
4697 *
4698 * Guest OS interface to Xen.
4699 *
4700+ * Permission is hereby granted, free of charge, to any person obtaining a copy
4701+ * of this software and associated documentation files (the "Software"), to
4702+ * deal in the Software without restriction, including without limitation the
4703+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
4704+ * sell copies of the Software, and to permit persons to whom the Software is
4705+ * furnished to do so, subject to the following conditions:
4706+ *
4707+ * The above copyright notice and this permission notice shall be included in
4708+ * all copies or substantial portions of the Software.
4709+ *
4710+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
4711+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
4712+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
4713+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
4714+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
4715+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
4716+ * DEALINGS IN THE SOFTWARE.
4717+ *
4718 * Copyright (c) 2004, K A Fraser
4719 */
4720
4721 #ifndef __XEN_PUBLIC_XEN_H__
4722 #define __XEN_PUBLIC_XEN_H__
4723
4724-#include <asm/xen/interface.h>
4725+#include "xen-compat.h"
4726+#ifdef CONFIG_PARAVIRT_XEN
4727 #include <asm/pvclock-abi.h>
4728+#endif
4729
4730-/*
4731- * XEN "SYSTEM CALLS" (a.k.a. HYPERCALLS).
4732- */
4733+#if defined(__i386__) || defined(__x86_64__)
4734+#include "arch-x86/xen.h"
4735+#elif defined(__ia64__)
4736+#include "arch-ia64.h"
4737+#else
4738+#error "Unsupported architecture"
4739+#endif
4740+
4741+#ifndef __ASSEMBLY__
4742+/* Guest handles for primitive C types. */
4743+DEFINE_XEN_GUEST_HANDLE(char);
4744+__DEFINE_XEN_GUEST_HANDLE(uchar, unsigned char);
4745+DEFINE_XEN_GUEST_HANDLE(int);
4746+__DEFINE_XEN_GUEST_HANDLE(uint, unsigned int);
4747+DEFINE_XEN_GUEST_HANDLE(long);
4748+__DEFINE_XEN_GUEST_HANDLE(ulong, unsigned long);
4749+DEFINE_XEN_GUEST_HANDLE(void);
4750+
4751+DEFINE_XEN_GUEST_HANDLE(xen_pfn_t);
4752+#endif
4753
4754 /*
4755- * x86_32: EAX = vector; EBX, ECX, EDX, ESI, EDI = args 1, 2, 3, 4, 5.
4756- * EAX = return value
4757- * (argument registers may be clobbered on return)
4758- * x86_64: RAX = vector; RDI, RSI, RDX, R10, R8, R9 = args 1, 2, 3, 4, 5, 6.
4759- * RAX = return value
4760- * (argument registers not clobbered on return; RCX, R11 are)
4761+ * HYPERCALLS
4762 */
4763+
4764 #define __HYPERVISOR_set_trap_table 0
4765 #define __HYPERVISOR_mmu_update 1
4766 #define __HYPERVISOR_set_gdt 2
4767 #define __HYPERVISOR_stack_switch 3
4768 #define __HYPERVISOR_set_callbacks 4
4769 #define __HYPERVISOR_fpu_taskswitch 5
4770-#define __HYPERVISOR_sched_op 6
4771-#define __HYPERVISOR_dom0_op 7
4772+#define __HYPERVISOR_sched_op_compat 6 /* compat since 0x00030101 */
4773+#define __HYPERVISOR_platform_op 7
4774 #define __HYPERVISOR_set_debugreg 8
4775 #define __HYPERVISOR_get_debugreg 9
4776 #define __HYPERVISOR_update_descriptor 10
4777@@ -39,10 +72,10 @@
4778 #define __HYPERVISOR_multicall 13
4779 #define __HYPERVISOR_update_va_mapping 14
4780 #define __HYPERVISOR_set_timer_op 15
4781-#define __HYPERVISOR_event_channel_op_compat 16
4782+#define __HYPERVISOR_event_channel_op_compat 16 /* compat since 0x00030202 */
4783 #define __HYPERVISOR_xen_version 17
4784 #define __HYPERVISOR_console_io 18
4785-#define __HYPERVISOR_physdev_op_compat 19
4786+#define __HYPERVISOR_physdev_op_compat 19 /* compat since 0x00030202 */
4787 #define __HYPERVISOR_grant_table_op 20
4788 #define __HYPERVISOR_vm_assist 21
4789 #define __HYPERVISOR_update_va_mapping_otherdomain 22
4790@@ -50,7 +83,7 @@
4791 #define __HYPERVISOR_vcpu_op 24
4792 #define __HYPERVISOR_set_segment_base 25 /* x86/64 only */
4793 #define __HYPERVISOR_mmuext_op 26
4794-#define __HYPERVISOR_acm_op 27
4795+#define __HYPERVISOR_xsm_op 27
4796 #define __HYPERVISOR_nmi_op 28
4797 #define __HYPERVISOR_sched_op_new 29
4798 #define __HYPERVISOR_callback_op 30
4799@@ -58,6 +91,9 @@
4800 #define __HYPERVISOR_event_channel_op 32
4801 #define __HYPERVISOR_physdev_op 33
4802 #define __HYPERVISOR_hvm_op 34
4803+#define __HYPERVISOR_sysctl 35
4804+#define __HYPERVISOR_domctl 36
4805+#define __HYPERVISOR_kexec_op 37
4806
4807 /* Architecture-specific hypercall definitions. */
4808 #define __HYPERVISOR_arch_0 48
4809@@ -70,15 +106,48 @@
4810 #define __HYPERVISOR_arch_7 55
4811
4812 /*
4813+ * HYPERCALL COMPATIBILITY.
4814+ */
4815+
4816+/* New sched_op hypercall introduced in 0x00030101. */
4817+#if __XEN_INTERFACE_VERSION__ < 0x00030101
4818+#undef __HYPERVISOR_sched_op
4819+#define __HYPERVISOR_sched_op __HYPERVISOR_sched_op_compat
4820+#else
4821+#define __HYPERVISOR_sched_op __HYPERVISOR_sched_op_new
4822+#endif
4823+
4824+/* New event-channel and physdev hypercalls introduced in 0x00030202. */
4825+#if __XEN_INTERFACE_VERSION__ < 0x00030202
4826+#undef __HYPERVISOR_event_channel_op
4827+#define __HYPERVISOR_event_channel_op __HYPERVISOR_event_channel_op_compat
4828+#undef __HYPERVISOR_physdev_op
4829+#define __HYPERVISOR_physdev_op __HYPERVISOR_physdev_op_compat
4830+#endif
4831+
4832+/* New platform_op hypercall introduced in 0x00030204. */
4833+#if __XEN_INTERFACE_VERSION__ < 0x00030204
4834+#define __HYPERVISOR_dom0_op __HYPERVISOR_platform_op
4835+#endif
4836+
4837+/*
4838 * VIRTUAL INTERRUPTS
4839 *
4840 * Virtual interrupts that a guest OS may receive from Xen.
4841- */
4842-#define VIRQ_TIMER 0 /* Timebase update, and/or requested timeout. */
4843-#define VIRQ_DEBUG 1 /* Request guest to dump debug info. */
4844-#define VIRQ_CONSOLE 2 /* (DOM0) Bytes received on emergency console. */
4845-#define VIRQ_DOM_EXC 3 /* (DOM0) Exceptional event for some domain. */
4846-#define VIRQ_DEBUGGER 6 /* (DOM0) A domain has paused for debugging. */
4847+ *
4848+ * In the side comments, 'V.' denotes a per-VCPU VIRQ while 'G.' denotes a
4849+ * global VIRQ. The former can be bound once per VCPU and cannot be re-bound.
4850+ * The latter can be allocated only once per guest: they must initially be
4851+ * allocated to VCPU0 but can subsequently be re-bound.
4852+ */
4853+#define VIRQ_TIMER 0 /* V. Timebase update, and/or requested timeout. */
4854+#define VIRQ_DEBUG 1 /* V. Request guest to dump debug info. */
4855+#define VIRQ_CONSOLE 2 /* G. (DOM0) Bytes received on emergency console. */
4856+#define VIRQ_DOM_EXC 3 /* G. (DOM0) Exceptional event for some domain. */
4857+#define VIRQ_TBUF 4 /* G. (DOM0) Trace buffer has records available. */
4858+#define VIRQ_DEBUGGER 6 /* G. (DOM0) A domain has paused for debugging. */
4859+#define VIRQ_XENOPROF 7 /* V. XenOprofile interrupt: new sample available */
4860+#define VIRQ_CON_RING 8 /* G. (DOM0) Bytes received on console */
4861
4862 /* Architecture-specific VIRQ definitions. */
4863 #define VIRQ_ARCH_0 16
4864@@ -91,6 +158,7 @@
4865 #define VIRQ_ARCH_7 23
4866
4867 #define NR_VIRQS 24
4868+
4869 /*
4870 * MMU-UPDATE REQUESTS
4871 *
4872@@ -166,6 +234,13 @@
4873 * cmd: MMUEXT_SET_LDT
4874 * linear_addr: Linear address of LDT base (NB. must be page-aligned).
4875 * nr_ents: Number of entries in LDT.
4876+ *
4877+ * cmd: MMUEXT_CLEAR_PAGE
4878+ * mfn: Machine frame number to be cleared.
4879+ *
4880+ * cmd: MMUEXT_COPY_PAGE
4881+ * mfn: Machine frame number of the destination page.
4882+ * src_mfn: Machine frame number of the source page.
4883 */
4884 #define MMUEXT_PIN_L1_TABLE 0
4885 #define MMUEXT_PIN_L2_TABLE 1
4886@@ -182,24 +257,34 @@
4887 #define MMUEXT_FLUSH_CACHE 12
4888 #define MMUEXT_SET_LDT 13
4889 #define MMUEXT_NEW_USER_BASEPTR 15
4890+#define MMUEXT_CLEAR_PAGE 16
4891+#define MMUEXT_COPY_PAGE 17
4892
4893 #ifndef __ASSEMBLY__
4894 struct mmuext_op {
4895- unsigned int cmd;
4896- union {
4897- /* [UN]PIN_TABLE, NEW_BASEPTR, NEW_USER_BASEPTR */
4898- unsigned long mfn;
4899- /* INVLPG_LOCAL, INVLPG_ALL, SET_LDT */
4900- unsigned long linear_addr;
4901- } arg1;
4902- union {
4903- /* SET_LDT */
4904- unsigned int nr_ents;
4905- /* TLB_FLUSH_MULTI, INVLPG_MULTI */
4906- void *vcpumask;
4907- } arg2;
4908+ unsigned int cmd;
4909+ union {
4910+ /* [UN]PIN_TABLE, NEW_BASEPTR, NEW_USER_BASEPTR
4911+ * CLEAR_PAGE, COPY_PAGE */
4912+ xen_pfn_t mfn;
4913+ /* INVLPG_LOCAL, INVLPG_ALL, SET_LDT */
4914+ unsigned long linear_addr;
4915+ } arg1;
4916+ union {
4917+ /* SET_LDT */
4918+ unsigned int nr_ents;
4919+ /* TLB_FLUSH_MULTI, INVLPG_MULTI */
4920+#if __XEN_INTERFACE_VERSION__ >= 0x00030205
4921+ XEN_GUEST_HANDLE(void) vcpumask;
4922+#else
4923+ void *vcpumask;
4924+#endif
4925+ /* COPY_PAGE */
4926+ xen_pfn_t src_mfn;
4927+ } arg2;
4928 };
4929-DEFINE_GUEST_HANDLE_STRUCT(mmuext_op);
4930+typedef struct mmuext_op mmuext_op_t;
4931+DEFINE_XEN_GUEST_HANDLE(mmuext_op_t);
4932 #endif
4933
4934 /* These are passed as 'flags' to update_va_mapping. They can be ORed. */
4935@@ -224,11 +309,24 @@ DEFINE_GUEST_HANDLE_STRUCT(mmuext_op);
4936 */
4937 #define VMASST_CMD_enable 0
4938 #define VMASST_CMD_disable 1
4939+
4940+/* x86/32 guests: simulate full 4GB segment limits. */
4941 #define VMASST_TYPE_4gb_segments 0
4942+
4943+/* x86/32 guests: trap (vector 15) whenever above vmassist is used. */
4944 #define VMASST_TYPE_4gb_segments_notify 1
4945+
4946+/*
4947+ * x86 guests: support writes to bottom-level PTEs.
4948+ * NB1. Page-directory entries cannot be written.
4949+ * NB2. Guest must continue to remove all writable mappings of PTEs.
4950+ */
4951 #define VMASST_TYPE_writable_pagetables 2
4952+
4953+/* x86/PAE guests: support PDPTs above 4GB. */
4954 #define VMASST_TYPE_pae_extended_cr3 3
4955-#define MAX_VMASST_TYPE 3
4956+
4957+#define MAX_VMASST_TYPE 3
4958
4959 #ifndef __ASSEMBLY__
4960
4961@@ -267,18 +365,19 @@ struct mmu_update {
4962 uint64_t ptr; /* Machine address of PTE. */
4963 uint64_t val; /* New contents of PTE. */
4964 };
4965-DEFINE_GUEST_HANDLE_STRUCT(mmu_update);
4966+typedef struct mmu_update mmu_update_t;
4967+DEFINE_XEN_GUEST_HANDLE(mmu_update_t);
4968
4969 /*
4970 * Send an array of these to HYPERVISOR_multicall().
4971 * NB. The fields are natural register size for this architecture.
4972 */
4973 struct multicall_entry {
4974- unsigned long op;
4975- long result;
4976+ unsigned long op, result;
4977 unsigned long args[6];
4978 };
4979-DEFINE_GUEST_HANDLE_STRUCT(multicall_entry);
4980+typedef struct multicall_entry multicall_entry_t;
4981+DEFINE_XEN_GUEST_HANDLE(multicall_entry_t);
4982
4983 /*
4984 * Event channel endpoints per domain:
4985@@ -287,173 +386,240 @@ DEFINE_GUEST_HANDLE_STRUCT(multicall_ent
4986 #define NR_EVENT_CHANNELS (sizeof(unsigned long) * sizeof(unsigned long) * 64)
4987
4988 struct vcpu_time_info {
4989- /*
4990- * Updates to the following values are preceded and followed
4991- * by an increment of 'version'. The guest can therefore
4992- * detect updates by looking for changes to 'version'. If the
4993- * least-significant bit of the version number is set then an
4994- * update is in progress and the guest must wait to read a
4995- * consistent set of values. The correct way to interact with
4996- * the version number is similar to Linux's seqlock: see the
4997- * implementations of read_seqbegin/read_seqretry.
4998- */
4999- uint32_t version;
5000- uint32_t pad0;
5001- uint64_t tsc_timestamp; /* TSC at last update of time vals. */
5002- uint64_t system_time; /* Time, in nanosecs, since boot. */
5003- /*
5004- * Current system time:
5005- * system_time + ((tsc - tsc_timestamp) << tsc_shift) * tsc_to_system_mul
5006- * CPU frequency (Hz):
5007- * ((10^9 << 32) / tsc_to_system_mul) >> tsc_shift
5008- */
5009- uint32_t tsc_to_system_mul;
5010- int8_t tsc_shift;
5011- int8_t pad1[3];
5012+ /*
5013+ * Updates to the following values are preceded and followed by an
5014+ * increment of 'version'. The guest can therefore detect updates by
5015+ * looking for changes to 'version'. If the least-significant bit of
5016+ * the version number is set then an update is in progress and the guest
5017+ * must wait to read a consistent set of values.
5018+ * The correct way to interact with the version number is similar to
5019+ * Linux's seqlock: see the implementations of read_seqbegin/read_seqretry.
5020+ */
5021+ uint32_t version;
5022+ uint32_t pad0;
5023+ uint64_t tsc_timestamp; /* TSC at last update of time vals. */
5024+ uint64_t system_time; /* Time, in nanosecs, since boot. */
5025+ /*
5026+ * Current system time:
5027+ * system_time +
5028+ * ((((tsc - tsc_timestamp) << tsc_shift) * tsc_to_system_mul) >> 32)
5029+ * CPU frequency (Hz):
5030+ * ((10^9 << 32) / tsc_to_system_mul) >> tsc_shift
5031+ */
5032+ uint32_t tsc_to_system_mul;
5033+ int8_t tsc_shift;
5034+ int8_t pad1[3];
5035 }; /* 32 bytes */
5036+typedef struct vcpu_time_info vcpu_time_info_t;
5037
5038 struct vcpu_info {
5039- /*
5040- * 'evtchn_upcall_pending' is written non-zero by Xen to indicate
5041- * a pending notification for a particular VCPU. It is then cleared
5042- * by the guest OS /before/ checking for pending work, thus avoiding
5043- * a set-and-check race. Note that the mask is only accessed by Xen
5044- * on the CPU that is currently hosting the VCPU. This means that the
5045- * pending and mask flags can be updated by the guest without special
5046- * synchronisation (i.e., no need for the x86 LOCK prefix).
5047- * This may seem suboptimal because if the pending flag is set by
5048- * a different CPU then an IPI may be scheduled even when the mask
5049- * is set. However, note:
5050- * 1. The task of 'interrupt holdoff' is covered by the per-event-
5051- * channel mask bits. A 'noisy' event that is continually being
5052- * triggered can be masked at source at this very precise
5053- * granularity.
5054- * 2. The main purpose of the per-VCPU mask is therefore to restrict
5055- * reentrant execution: whether for concurrency control, or to
5056- * prevent unbounded stack usage. Whatever the purpose, we expect
5057- * that the mask will be asserted only for short periods at a time,
5058- * and so the likelihood of a 'spurious' IPI is suitably small.
5059- * The mask is read before making an event upcall to the guest: a
5060- * non-zero mask therefore guarantees that the VCPU will not receive
5061- * an upcall activation. The mask is cleared when the VCPU requests
5062- * to block: this avoids wakeup-waiting races.
5063- */
5064- uint8_t evtchn_upcall_pending;
5065- uint8_t evtchn_upcall_mask;
5066- unsigned long evtchn_pending_sel;
5067- struct arch_vcpu_info arch;
5068- struct pvclock_vcpu_time_info time;
5069+ /*
5070+ * 'evtchn_upcall_pending' is written non-zero by Xen to indicate
5071+ * a pending notification for a particular VCPU. It is then cleared
5072+ * by the guest OS /before/ checking for pending work, thus avoiding
5073+ * a set-and-check race. Note that the mask is only accessed by Xen
5074+ * on the CPU that is currently hosting the VCPU. This means that the
5075+ * pending and mask flags can be updated by the guest without special
5076+ * synchronisation (i.e., no need for the x86 LOCK prefix).
5077+ * This may seem suboptimal because if the pending flag is set by
5078+ * a different CPU then an IPI may be scheduled even when the mask
5079+ * is set. However, note:
5080+ * 1. The task of 'interrupt holdoff' is covered by the per-event-
5081+ * channel mask bits. A 'noisy' event that is continually being
5082+ * triggered can be masked at source at this very precise
5083+ * granularity.
5084+ * 2. The main purpose of the per-VCPU mask is therefore to restrict
5085+ * reentrant execution: whether for concurrency control, or to
5086+ * prevent unbounded stack usage. Whatever the purpose, we expect
5087+ * that the mask will be asserted only for short periods at a time,
5088+ * and so the likelihood of a 'spurious' IPI is suitably small.
5089+ * The mask is read before making an event upcall to the guest: a
5090+ * non-zero mask therefore guarantees that the VCPU will not receive
5091+ * an upcall activation. The mask is cleared when the VCPU requests
5092+ * to block: this avoids wakeup-waiting races.
5093+ */
5094+ uint8_t evtchn_upcall_pending;
5095+ uint8_t evtchn_upcall_mask;
5096+ unsigned long evtchn_pending_sel;
5097+ struct arch_vcpu_info arch;
5098+#ifdef CONFIG_PARAVIRT_XEN
5099+ struct pvclock_vcpu_time_info time;
5100+#else
5101+ struct vcpu_time_info time;
5102+#endif
5103 }; /* 64 bytes (x86) */
5104+#ifndef __XEN__
5105+typedef struct vcpu_info vcpu_info_t;
5106+#endif
5107
5108 /*
5109 * Xen/kernel shared data -- pointer provided in start_info.
5110- * NB. We expect that this struct is smaller than a page.
5111+ *
5112+ * This structure is defined to be both smaller than a page, and the
5113+ * only data on the shared page, but may vary in actual size even within
5114+ * compatible Xen versions; guests should not rely on the size
5115+ * of this structure remaining constant.
5116 */
5117 struct shared_info {
5118- struct vcpu_info vcpu_info[MAX_VIRT_CPUS];
5119+ struct vcpu_info vcpu_info[MAX_VIRT_CPUS];
5120
5121- /*
5122- * A domain can create "event channels" on which it can send and receive
5123- * asynchronous event notifications. There are three classes of event that
5124- * are delivered by this mechanism:
5125- * 1. Bi-directional inter- and intra-domain connections. Domains must
5126- * arrange out-of-band to set up a connection (usually by allocating
5127- * an unbound 'listener' port and avertising that via a storage service
5128- * such as xenstore).
5129- * 2. Physical interrupts. A domain with suitable hardware-access
5130- * privileges can bind an event-channel port to a physical interrupt
5131- * source.
5132- * 3. Virtual interrupts ('events'). A domain can bind an event-channel
5133- * port to a virtual interrupt source, such as the virtual-timer
5134- * device or the emergency console.
5135- *
5136- * Event channels are addressed by a "port index". Each channel is
5137- * associated with two bits of information:
5138- * 1. PENDING -- notifies the domain that there is a pending notification
5139- * to be processed. This bit is cleared by the guest.
5140- * 2. MASK -- if this bit is clear then a 0->1 transition of PENDING
5141- * will cause an asynchronous upcall to be scheduled. This bit is only
5142- * updated by the guest. It is read-only within Xen. If a channel
5143- * becomes pending while the channel is masked then the 'edge' is lost
5144- * (i.e., when the channel is unmasked, the guest must manually handle
5145- * pending notifications as no upcall will be scheduled by Xen).
5146- *
5147- * To expedite scanning of pending notifications, any 0->1 pending
5148- * transition on an unmasked channel causes a corresponding bit in a
5149- * per-vcpu selector word to be set. Each bit in the selector covers a
5150- * 'C long' in the PENDING bitfield array.
5151- */
5152- unsigned long evtchn_pending[sizeof(unsigned long) * 8];
5153- unsigned long evtchn_mask[sizeof(unsigned long) * 8];
5154-
5155- /*
5156- * Wallclock time: updated only by control software. Guests should base
5157- * their gettimeofday() syscall on this wallclock-base value.
5158- */
5159- struct pvclock_wall_clock wc;
5160+ /*
5161+ * A domain can create "event channels" on which it can send and receive
5162+ * asynchronous event notifications. There are three classes of event that
5163+ * are delivered by this mechanism:
5164+ * 1. Bi-directional inter- and intra-domain connections. Domains must
5165+ * arrange out-of-band to set up a connection (usually by allocating
5166+ * an unbound 'listener' port and avertising that via a storage service
5167+ * such as xenstore).
5168+ * 2. Physical interrupts. A domain with suitable hardware-access
5169+ * privileges can bind an event-channel port to a physical interrupt
5170+ * source.
5171+ * 3. Virtual interrupts ('events'). A domain can bind an event-channel
5172+ * port to a virtual interrupt source, such as the virtual-timer
5173+ * device or the emergency console.
5174+ *
5175+ * Event channels are addressed by a "port index". Each channel is
5176+ * associated with two bits of information:
5177+ * 1. PENDING -- notifies the domain that there is a pending notification
5178+ * to be processed. This bit is cleared by the guest.
5179+ * 2. MASK -- if this bit is clear then a 0->1 transition of PENDING
5180+ * will cause an asynchronous upcall to be scheduled. This bit is only
5181+ * updated by the guest. It is read-only within Xen. If a channel
5182+ * becomes pending while the channel is masked then the 'edge' is lost
5183+ * (i.e., when the channel is unmasked, the guest must manually handle
5184+ * pending notifications as no upcall will be scheduled by Xen).
5185+ *
5186+ * To expedite scanning of pending notifications, any 0->1 pending
5187+ * transition on an unmasked channel causes a corresponding bit in a
5188+ * per-vcpu selector word to be set. Each bit in the selector covers a
5189+ * 'C long' in the PENDING bitfield array.
5190+ */
5191+ unsigned long evtchn_pending[sizeof(unsigned long) * 8];
5192+ unsigned long evtchn_mask[sizeof(unsigned long) * 8];
5193+
5194+ /*
5195+ * Wallclock time: updated only by control software. Guests should base
5196+ * their gettimeofday() syscall on this wallclock-base value.
5197+ */
5198+#ifdef CONFIG_PARAVIRT_XEN
5199+ struct pvclock_wall_clock wc;
5200+#else
5201+ uint32_t wc_version; /* Version counter: see vcpu_time_info_t. */
5202+ uint32_t wc_sec; /* Secs 00:00:00 UTC, Jan 1, 1970. */
5203+ uint32_t wc_nsec; /* Nsecs 00:00:00 UTC, Jan 1, 1970. */
5204+#endif
5205
5206- struct arch_shared_info arch;
5207+ struct arch_shared_info arch;
5208
5209 };
5210+#ifndef __XEN__
5211+typedef struct shared_info shared_info_t;
5212+#endif
5213
5214 /*
5215- * Start-of-day memory layout for the initial domain (DOM0):
5216+ * Start-of-day memory layout:
5217 * 1. The domain is started within contiguous virtual-memory region.
5218- * 2. The contiguous region begins and ends on an aligned 4MB boundary.
5219- * 3. The region start corresponds to the load address of the OS image.
5220- * If the load address is not 4MB aligned then the address is rounded down.
5221- * 4. This the order of bootstrap elements in the initial virtual region:
5222+ * 2. The contiguous region ends on an aligned 4MB boundary.
5223+ * 3. This the order of bootstrap elements in the initial virtual region:
5224 * a. relocated kernel image
5225 * b. initial ram disk [mod_start, mod_len]
5226 * c. list of allocated page frames [mfn_list, nr_pages]
5227 * d. start_info_t structure [register ESI (x86)]
5228 * e. bootstrap page tables [pt_base, CR3 (x86)]
5229 * f. bootstrap stack [register ESP (x86)]
5230- * 5. Bootstrap elements are packed together, but each is 4kB-aligned.
5231- * 6. The initial ram disk may be omitted.
5232- * 7. The list of page frames forms a contiguous 'pseudo-physical' memory
5233+ * 4. Bootstrap elements are packed together, but each is 4kB-aligned.
5234+ * 5. The initial ram disk may be omitted.
5235+ * 6. The list of page frames forms a contiguous 'pseudo-physical' memory
5236 * layout for the domain. In particular, the bootstrap virtual-memory
5237 * region is a 1:1 mapping to the first section of the pseudo-physical map.
5238- * 8. All bootstrap elements are mapped read-writable for the guest OS. The
5239+ * 7. All bootstrap elements are mapped read-writable for the guest OS. The
5240 * only exception is the bootstrap page table, which is mapped read-only.
5241- * 9. There is guaranteed to be at least 512kB padding after the final
5242+ * 8. There is guaranteed to be at least 512kB padding after the final
5243 * bootstrap element. If necessary, the bootstrap virtual region is
5244 * extended by an extra 4MB to ensure this.
5245 */
5246
5247 #define MAX_GUEST_CMDLINE 1024
5248 struct start_info {
5249- /* THE FOLLOWING ARE FILLED IN BOTH ON INITIAL BOOT AND ON RESUME. */
5250- char magic[32]; /* "xen-<version>-<platform>". */
5251- unsigned long nr_pages; /* Total pages allocated to this domain. */
5252- unsigned long shared_info; /* MACHINE address of shared info struct. */
5253- uint32_t flags; /* SIF_xxx flags. */
5254- unsigned long store_mfn; /* MACHINE page number of shared page. */
5255- uint32_t store_evtchn; /* Event channel for store communication. */
5256- union {
5257- struct {
5258- unsigned long mfn; /* MACHINE page number of console page. */
5259- uint32_t evtchn; /* Event channel for console page. */
5260- } domU;
5261- struct {
5262- uint32_t info_off; /* Offset of console_info struct. */
5263- uint32_t info_size; /* Size of console_info struct from start.*/
5264- } dom0;
5265- } console;
5266- /* THE FOLLOWING ARE ONLY FILLED IN ON INITIAL BOOT (NOT RESUME). */
5267- unsigned long pt_base; /* VIRTUAL address of page directory. */
5268- unsigned long nr_pt_frames; /* Number of bootstrap p.t. frames. */
5269- unsigned long mfn_list; /* VIRTUAL address of page-frame list. */
5270- unsigned long mod_start; /* VIRTUAL address of pre-loaded module. */
5271- unsigned long mod_len; /* Size (bytes) of pre-loaded module. */
5272- int8_t cmd_line[MAX_GUEST_CMDLINE];
5273+ /* THE FOLLOWING ARE FILLED IN BOTH ON INITIAL BOOT AND ON RESUME. */
5274+ char magic[32]; /* "xen-<version>-<platform>". */
5275+ unsigned long nr_pages; /* Total pages allocated to this domain. */
5276+ unsigned long shared_info; /* MACHINE address of shared info struct. */
5277+ uint32_t flags; /* SIF_xxx flags. */
5278+ xen_pfn_t store_mfn; /* MACHINE page number of shared page. */
5279+ uint32_t store_evtchn; /* Event channel for store communication. */
5280+ union {
5281+ struct {
5282+ xen_pfn_t mfn; /* MACHINE page number of console page. */
5283+ uint32_t evtchn; /* Event channel for console page. */
5284+ } domU;
5285+ struct {
5286+ uint32_t info_off; /* Offset of console_info struct. */
5287+ uint32_t info_size; /* Size of console_info struct from start.*/
5288+ } dom0;
5289+ } console;
5290+ /* THE FOLLOWING ARE ONLY FILLED IN ON INITIAL BOOT (NOT RESUME). */
5291+ unsigned long pt_base; /* VIRTUAL address of page directory. */
5292+ unsigned long nr_pt_frames; /* Number of bootstrap p.t. frames. */
5293+ unsigned long mfn_list; /* VIRTUAL address of page-frame list. */
5294+ unsigned long mod_start; /* VIRTUAL address of pre-loaded module. */
5295+ unsigned long mod_len; /* Size (bytes) of pre-loaded module. */
5296+ int8_t cmd_line[MAX_GUEST_CMDLINE];
5297 };
5298+typedef struct start_info start_info_t;
5299+
5300+/* New console union for dom0 introduced in 0x00030203. */
5301+#if __XEN_INTERFACE_VERSION__ < 0x00030203
5302+#define console_mfn console.domU.mfn
5303+#define console_evtchn console.domU.evtchn
5304+#endif
5305
5306 /* These flags are passed in the 'flags' field of start_info_t. */
5307 #define SIF_PRIVILEGED (1<<0) /* Is the domain privileged? */
5308 #define SIF_INITDOMAIN (1<<1) /* Is this the initial control domain? */
5309+#define SIF_PM_MASK (0xFF<<8) /* reserve 1 byte for xen-pm options */
5310
5311-typedef uint64_t cpumap_t;
5312+typedef struct dom0_vga_console_info {
5313+ uint8_t video_type; /* DOM0_VGA_CONSOLE_??? */
5314+#define XEN_VGATYPE_TEXT_MODE_3 0x03
5315+#define XEN_VGATYPE_VESA_LFB 0x23
5316+
5317+ union {
5318+ struct {
5319+ /* Font height, in pixels. */
5320+ uint16_t font_height;
5321+ /* Cursor location (column, row). */
5322+ uint16_t cursor_x, cursor_y;
5323+ /* Number of rows and columns (dimensions in characters). */
5324+ uint16_t rows, columns;
5325+ } text_mode_3;
5326+
5327+ struct {
5328+ /* Width and height, in pixels. */
5329+ uint16_t width, height;
5330+ /* Bytes per scan line. */
5331+ uint16_t bytes_per_line;
5332+ /* Bits per pixel. */
5333+ uint16_t bits_per_pixel;
5334+ /* LFB physical address, and size (in units of 64kB). */
5335+ uint32_t lfb_base;
5336+ uint32_t lfb_size;
5337+ /* RGB mask offsets and sizes, as defined by VBE 1.2+ */
5338+ uint8_t red_pos, red_size;
5339+ uint8_t green_pos, green_size;
5340+ uint8_t blue_pos, blue_size;
5341+ uint8_t rsvd_pos, rsvd_size;
5342+#if __XEN_INTERFACE_VERSION__ >= 0x00030206
5343+ /* VESA capabilities (offset 0xa, VESA command 0x4f00). */
5344+ uint32_t gbl_caps;
5345+ /* Mode attributes (offset 0x0, VESA command 0x4f01). */
5346+ uint16_t mode_attrs;
5347+#endif
5348+ } vesa_lfb;
5349+ } u;
5350+} dom0_vga_console_info_t;
5351+#define xen_vga_console_info dom0_vga_console_info
5352+#define xen_vga_console_info_t dom0_vga_console_info_t
5353
5354 typedef uint8_t xen_domain_handle_t[16];
5355
5356@@ -461,6 +627,11 @@ typedef uint8_t xen_domain_handle_t[16];
5357 #define __mk_unsigned_long(x) x ## UL
5358 #define mk_unsigned_long(x) __mk_unsigned_long(x)
5359
5360+__DEFINE_XEN_GUEST_HANDLE(uint8, uint8_t);
5361+__DEFINE_XEN_GUEST_HANDLE(uint16, uint16_t);
5362+__DEFINE_XEN_GUEST_HANDLE(uint32, uint32_t);
5363+__DEFINE_XEN_GUEST_HANDLE(uint64, uint64_t);
5364+
5365 #else /* __ASSEMBLY__ */
5366
5367 /* In assembly code we cannot use C numeric constant suffixes. */
5368@@ -468,4 +639,24 @@ typedef uint8_t xen_domain_handle_t[16];
5369
5370 #endif /* !__ASSEMBLY__ */
5371
5372+/* Default definitions for macros used by domctl/sysctl. */
5373+#if defined(__XEN__) || defined(__XEN_TOOLS__)
5374+#ifndef uint64_aligned_t
5375+#define uint64_aligned_t uint64_t
5376+#endif
5377+#ifndef XEN_GUEST_HANDLE_64
5378+#define XEN_GUEST_HANDLE_64(name) XEN_GUEST_HANDLE(name)
5379+#endif
5380+#endif
5381+
5382 #endif /* __XEN_PUBLIC_XEN_H__ */
5383+
5384+/*
5385+ * Local variables:
5386+ * mode: C
5387+ * c-set-style: "BSD"
5388+ * c-basic-offset: 4
5389+ * tab-width: 4
5390+ * indent-tabs-mode: nil
5391+ * End:
5392+ */
5393Index: head-2008-11-25/include/xen/xenbus.h
5394===================================================================
5395--- head-2008-11-25.orig/include/xen/xenbus.h 2008-11-25 12:33:06.000000000 +0100
5396+++ head-2008-11-25/include/xen/xenbus.h 2008-11-25 12:35:56.000000000 +0100
5397@@ -39,6 +39,7 @@
5398 #include <linux/mutex.h>
5399 #include <linux/completion.h>
5400 #include <linux/init.h>
5401+#include <linux/err.h>
5402 #include <xen/interface/xen.h>
5403 #include <xen/interface/grant_table.h>
5404 #include <xen/interface/io/xenbus.h>
5405@@ -55,8 +56,17 @@ struct xenbus_watch
5406 /* Callback (executed in a process context with no locks held). */
5407 void (*callback)(struct xenbus_watch *,
5408 const char **vec, unsigned int len);
5409+
5410+ /* See XBWF_ definitions below. */
5411+ unsigned long flags;
5412 };
5413
5414+/*
5415+ * Execute callback in its own kthread. Useful if the callback is long
5416+ * running or heavily serialised, to avoid taking out the main xenwatch thread
5417+ * for a long period of time (or even unwittingly causing a deadlock).
5418+ */
5419+#define XBWF_new_thread 1
5420
5421 /* A xenbus device. */
5422 struct xenbus_device {
5423@@ -105,27 +115,8 @@ static inline struct xenbus_driver *to_x
5424 return container_of(drv, struct xenbus_driver, driver);
5425 }
5426
5427-int __must_check __xenbus_register_frontend(struct xenbus_driver *drv,
5428- struct module *owner,
5429- const char *mod_name);
5430-
5431-static inline int __must_check
5432-xenbus_register_frontend(struct xenbus_driver *drv)
5433-{
5434- WARN_ON(drv->owner != THIS_MODULE);
5435- return __xenbus_register_frontend(drv, THIS_MODULE, KBUILD_MODNAME);
5436-}
5437-
5438-int __must_check __xenbus_register_backend(struct xenbus_driver *drv,
5439- struct module *owner,
5440- const char *mod_name);
5441-static inline int __must_check
5442-xenbus_register_backend(struct xenbus_driver *drv)
5443-{
5444- WARN_ON(drv->owner != THIS_MODULE);
5445- return __xenbus_register_backend(drv, THIS_MODULE, KBUILD_MODNAME);
5446-}
5447-
5448+int xenbus_register_frontend(struct xenbus_driver *drv);
5449+int xenbus_register_backend(struct xenbus_driver *drv);
5450 void xenbus_unregister_driver(struct xenbus_driver *drv);
5451
5452 struct xenbus_transaction
5453@@ -136,8 +127,6 @@ struct xenbus_transaction
5454 /* Nil transaction ID. */
5455 #define XBT_NIL ((struct xenbus_transaction) { 0 })
5456
5457-int __init xenbus_dev_init(void);
5458-
5459 char **xenbus_directory(struct xenbus_transaction t,
5460 const char *dir, const char *node, unsigned int *num);
5461 void *xenbus_read(struct xenbus_transaction t,
5462@@ -167,7 +156,6 @@ int xenbus_printf(struct xenbus_transact
5463 int xenbus_gather(struct xenbus_transaction t, const char *dir, ...);
5464
5465 /* notifer routines for when the xenstore comes up */
5466-extern int xenstored_ready;
5467 int register_xenstore_notifier(struct notifier_block *nb);
5468 void unregister_xenstore_notifier(struct notifier_block *nb);
5469
5470@@ -180,12 +168,9 @@ void xs_suspend_cancel(void);
5471 /* Used by xenbus_dev to borrow kernel's store connection. */
5472 void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg);
5473
5474-struct work_struct;
5475-
5476 /* Prepare for domain suspend: then resume or cancel the suspend. */
5477 void xenbus_suspend(void);
5478 void xenbus_resume(void);
5479-void xenbus_probe(struct work_struct *);
5480 void xenbus_suspend_cancel(void);
5481
5482 #define XENBUS_IS_ERR_READ(str) ({ \
5483@@ -198,38 +183,125 @@ void xenbus_suspend_cancel(void);
5484
5485 #define XENBUS_EXIST_ERR(err) ((err) == -ENOENT || (err) == -ERANGE)
5486
5487+
5488+/**
5489+ * Register a watch on the given path, using the given xenbus_watch structure
5490+ * for storage, and the given callback function as the callback. Return 0 on
5491+ * success, or -errno on error. On success, the given path will be saved as
5492+ * watch->node, and remains the caller's to free. On error, watch->node will
5493+ * be NULL, the device will switch to XenbusStateClosing, and the error will
5494+ * be saved in the store.
5495+ */
5496 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
5497 struct xenbus_watch *watch,
5498 void (*callback)(struct xenbus_watch *,
5499 const char **, unsigned int));
5500-int xenbus_watch_pathfmt(struct xenbus_device *dev, struct xenbus_watch *watch,
5501- void (*callback)(struct xenbus_watch *,
5502- const char **, unsigned int),
5503- const char *pathfmt, ...)
5504- __attribute__ ((format (printf, 4, 5)));
5505
5506+
5507+/**
5508+ * Register a watch on the given path/path2, using the given xenbus_watch
5509+ * structure for storage, and the given callback function as the callback.
5510+ * Return 0 on success, or -errno on error. On success, the watched path
5511+ * (path/path2) will be saved as watch->node, and becomes the caller's to
5512+ * kfree(). On error, watch->node will be NULL, so the caller has nothing to
5513+ * free, the device will switch to XenbusStateClosing, and the error will be
5514+ * saved in the store.
5515+ */
5516+int xenbus_watch_path2(struct xenbus_device *dev, const char *path,
5517+ const char *path2, struct xenbus_watch *watch,
5518+ void (*callback)(struct xenbus_watch *,
5519+ const char **, unsigned int));
5520+
5521+
5522+/**
5523+ * Advertise in the store a change of the given driver to the given new_state.
5524+ * Return 0 on success, or -errno on error. On error, the device will switch
5525+ * to XenbusStateClosing, and the error will be saved in the store.
5526+ */
5527 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state new_state);
5528+
5529+
5530+/**
5531+ * Grant access to the given ring_mfn to the peer of the given device. Return
5532+ * 0 on success, or -errno on error. On error, the device will switch to
5533+ * XenbusStateClosing, and the error will be saved in the store.
5534+ */
5535 int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn);
5536-int xenbus_map_ring_valloc(struct xenbus_device *dev,
5537- int gnt_ref, void **vaddr);
5538+
5539+
5540+/**
5541+ * Map a page of memory into this domain from another domain's grant table.
5542+ * xenbus_map_ring_valloc allocates a page of virtual address space, maps the
5543+ * page to that address, and sets *vaddr to that address.
5544+ * xenbus_map_ring does not allocate the virtual address space (you must do
5545+ * this yourself!). It only maps in the page to the specified address.
5546+ * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
5547+ * or -ENOMEM on error. If an error is returned, device will switch to
5548+ * XenbusStateClosing and the error message will be saved in XenStore.
5549+ */
5550+struct vm_struct *xenbus_map_ring_valloc(struct xenbus_device *dev,
5551+ int gnt_ref);
5552 int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
5553 grant_handle_t *handle, void *vaddr);
5554
5555-int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr);
5556+
5557+/**
5558+ * Unmap a page of memory in this domain that was imported from another domain.
5559+ * Use xenbus_unmap_ring_vfree if you mapped in your memory with
5560+ * xenbus_map_ring_valloc (it will free the virtual address space).
5561+ * Returns 0 on success and returns GNTST_* on error
5562+ * (see xen/include/interface/grant_table.h).
5563+ */
5564+int xenbus_unmap_ring_vfree(struct xenbus_device *dev, struct vm_struct *);
5565 int xenbus_unmap_ring(struct xenbus_device *dev,
5566 grant_handle_t handle, void *vaddr);
5567
5568+
5569+/**
5570+ * Allocate an event channel for the given xenbus_device, assigning the newly
5571+ * created local port to *port. Return 0 on success, or -errno on error. On
5572+ * error, the device will switch to XenbusStateClosing, and the error will be
5573+ * saved in the store.
5574+ */
5575 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port);
5576-int xenbus_bind_evtchn(struct xenbus_device *dev, int remote_port, int *port);
5577+
5578+
5579+/**
5580+ * Free an existing event channel. Returns 0 on success or -errno on error.
5581+ */
5582 int xenbus_free_evtchn(struct xenbus_device *dev, int port);
5583
5584+
5585+/**
5586+ * Return the state of the driver rooted at the given store path, or
5587+ * XenbusStateUnknown if no state can be read.
5588+ */
5589 enum xenbus_state xenbus_read_driver_state(const char *path);
5590
5591-void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...);
5592-void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...);
5593+
5594+/***
5595+ * Report the given negative errno into the store, along with the given
5596+ * formatted message.
5597+ */
5598+void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,
5599+ ...);
5600+
5601+
5602+/***
5603+ * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
5604+ * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
5605+ * closedown of this driver and its peer.
5606+ */
5607+void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt,
5608+ ...);
5609+
5610+int xenbus_dev_init(void);
5611
5612 const char *xenbus_strstate(enum xenbus_state state);
5613 int xenbus_dev_is_online(struct xenbus_device *dev);
5614 int xenbus_frontend_closed(struct xenbus_device *dev);
5615
5616+int xenbus_for_each_backend(void *arg, int (*fn)(struct device *, void *));
5617+int xenbus_for_each_frontend(void *arg, int (*fn)(struct device *, void *));
5618+
5619 #endif /* _XEN_XENBUS_H */
Peter's tree of IPFire 2.x