5 files changed, 776 insertions, 10 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 503d82569449..6d9d7fab77f5 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -15,6 +15,8 @@ obj-$(CONFIG_ACPI)		+= acpi/
 obj-$(CONFIG_PNP)               += pnp/
 obj-$(CONFIG_ARM_AMBA)          += amba/
 
+obj-$(CONFIG_XEN)               += xen/
+
 # char/ comes before serial/ etc so that the VT console is the boot-time
 # default.
 obj-y                           += char/
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
new file mode 100644
index 000000000000..eb42b521eef9
--- /dev/null
+++ b/drivers/xen/Makefile
@@ -0,0 +1 @@
+obj-y   += grant-table.o
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
new file mode 100644
index 000000000000..ea94dbabf9a9
--- /dev/null
+++ b/drivers/xen/grant-table.c
@@ -0,0 +1,582 @@
+/******************************************************************************
+ * grant_table.c
+ *
+ * Granting foreign access to our memory reservation.
+ *
+ * Copyright (c) 2005-2006, Christopher Clark
+ * Copyright (c) 2004-2005, K A Fraser
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
+#include <linux/uaccess.h>
+
+#include <xen/interface/xen.h>
+#include <xen/page.h>
+#include <xen/grant_table.h>
+
+#include <asm/pgtable.h>
+#include <asm/sync_bitops.h>
+
+
+/* External tools reserve first few grant table entries. */
+#define NR_RESERVED_ENTRIES 8
+#define GNTTAB_LIST_END 0xffffffff
+#define GREFS_PER_GRANT_FRAME (PAGE_SIZE / sizeof(struct grant_entry))
+
+static grant_ref_t **gnttab_list;
+static unsigned int nr_grant_frames;
+static unsigned int boot_max_nr_grant_frames;
+static int gnttab_free_count;
+static grant_ref_t gnttab_free_head;
+static DEFINE_SPINLOCK(gnttab_list_lock);
+
+static struct grant_entry *shared;
+
+static struct gnttab_free_callback *gnttab_free_callback_list;
+
+static int gnttab_expand(unsigned int req_entries);
+
+#define RPP (PAGE_SIZE / sizeof(grant_ref_t))
+
+static inline grant_ref_t *__gnttab_entry(grant_ref_t entry)
+{
+        return &gnttab_list[(entry) / RPP][(entry) % RPP];
+}
+/* This can be used as an l-value */
+#define gnttab_entry(entry) (*__gnttab_entry(entry))
+
+static int get_free_entries(unsigned count)
+{
+        unsigned long flags;
+        int ref, rc;
+        grant_ref_t head;
+
+        spin_lock_irqsave(&gnttab_list_lock, flags);
+
+        if ((gnttab_free_count < count) &&
+            ((rc = gnttab_expand(count - gnttab_free_count)) < 0)) {
+                spin_unlock_irqrestore(&gnttab_list_lock, flags);
+                return rc;
+        }
+
+        ref = head = gnttab_free_head;
+        gnttab_free_count -= count;
+        while (count-- > 1)
+                head = gnttab_entry(head);
+        gnttab_free_head = gnttab_entry(head);
+        gnttab_entry(head) = GNTTAB_LIST_END;
+
+        spin_unlock_irqrestore(&gnttab_list_lock, flags);
+
+        return ref;
+}
+
+static void do_free_callbacks(void)
+{
+        struct gnttab_free_callback *callback, *next;
+
+        callback = gnttab_free_callback_list;
+        gnttab_free_callback_list = NULL;
+
+        while (callback != NULL) {
+                next = callback->next;
+                if (gnttab_free_count >= callback->count) {
+                        callback->next = NULL;
+                        callback->fn(callback->arg);
+                } else {
+                        callback->next = gnttab_free_callback_list;
+                        gnttab_free_callback_list = callback;
+                }
+                callback = next;
+        }
+}
+
+static inline void check_free_callbacks(void)
+{
+        if (unlikely(gnttab_free_callback_list))
+                do_free_callbacks();
+}
+
+static void put_free_entry(grant_ref_t ref)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&gnttab_list_lock, flags);
+        gnttab_entry(ref) = gnttab_free_head;
+        gnttab_free_head = ref;
+        gnttab_free_count++;
+        check_free_callbacks();
+        spin_unlock_irqrestore(&gnttab_list_lock, flags);
+}
+
+static void update_grant_entry(grant_ref_t ref, domid_t domid,
+                               unsigned long frame, unsigned flags)
+{
+        /*
+         * Introducing a valid entry into the grant table:
+         *  1. Write ent->domid.
+         *  2. Write ent->frame:
+         *      GTF_permit_access:   Frame to which access is permitted.
+         *      GTF_accept_transfer: Pseudo-phys frame slot being filled by new
+         *                           frame, or zero if none.
+         *  3. Write memory barrier (WMB).
+         *  4. Write ent->flags, inc. valid type.
+         */
+        shared[ref].frame = frame;
+        shared[ref].domid = domid;
+        wmb();
+        shared[ref].flags = flags;
+}
+
+/*
+ * Public grant-issuing interface functions
+ */
+void gnttab_grant_foreign_access_ref(grant_ref_t ref, domid_t domid,
+                                     unsigned long frame, int readonly)
+{
+        update_grant_entry(ref, domid, frame,
+                           GTF_permit_access | (readonly ? GTF_readonly : 0));
+}
+EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_ref);
+
+int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
+                                int readonly)
+{
+        int ref;
+
+        ref = get_free_entries(1);
+        if (unlikely(ref < 0))
+                return -ENOSPC;
+
+        gnttab_grant_foreign_access_ref(ref, domid, frame, readonly);
+
+        return ref;
+}
+EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access);
+
+int gnttab_query_foreign_access(grant_ref_t ref)
+{
+        u16 nflags;
+
+        nflags = shared[ref].flags;
+
+        return (nflags & (GTF_reading|GTF_writing));
+}
+EXPORT_SYMBOL_GPL(gnttab_query_foreign_access);
+
+int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
+{
+        u16 flags, nflags;
+
+        nflags = shared[ref].flags;
+        do {
+                flags = nflags;
+                if (flags & (GTF_reading|GTF_writing)) {
+                        printk(KERN_ALERT "WARNING: g.e. still in use!\n");
+                        return 0;
+                }
+        } while ((nflags = sync_cmpxchg(&shared[ref].flags, flags, 0)) != flags);
+
+        return 1;
+}
+EXPORT_SYMBOL_GPL(gnttab_end_foreign_access_ref);
+
+void gnttab_end_foreign_access(grant_ref_t ref, int readonly,
+                               unsigned long page)
+{
+        if (gnttab_end_foreign_access_ref(ref, readonly)) {
+                put_free_entry(ref);
+                if (page != 0)
+                        free_page(page);
+        } else {
+                /* XXX This needs to be fixed so that the ref and page are
+                   placed on a list to be freed up later. */
+                printk(KERN_WARNING
+                       "WARNING: leaking g.e. and page still in use!\n");
+        }
+}
+EXPORT_SYMBOL_GPL(gnttab_end_foreign_access);
+
+int gnttab_grant_foreign_transfer(domid_t domid, unsigned long pfn)
+{
+        int ref;
+
+        ref = get_free_entries(1);
+        if (unlikely(ref < 0))
+                return -ENOSPC;
+        gnttab_grant_foreign_transfer_ref(ref, domid, pfn);
+
+        return ref;
+}
+EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer);
+
+void gnttab_grant_foreign_transfer_ref(grant_ref_t ref, domid_t domid,
+                                       unsigned long pfn)
+{
+        update_grant_entry(ref, domid, pfn, GTF_accept_transfer);
+}
+EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer_ref);
+
+unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref)
+{
+        unsigned long frame;
+        u16           flags;
+
+        /*
+         * If a transfer is not even yet started, try to reclaim the grant
+         * reference and return failure (== 0).
+         */
+        while (!((flags = shared[ref].flags) & GTF_transfer_committed)) {
+                if (sync_cmpxchg(&shared[ref].flags, flags, 0) == flags)
+                        return 0;
+                cpu_relax();
+        }
+
+        /* If a transfer is in progress then wait until it is completed. */
+        while (!(flags & GTF_transfer_completed)) {
+                flags = shared[ref].flags;
+                cpu_relax();
+        }
+
+        rmb();  /* Read the frame number /after/ reading completion status. */
+        frame = shared[ref].frame;
+        BUG_ON(frame == 0);
+
+        return frame;
+}
+EXPORT_SYMBOL_GPL(gnttab_end_foreign_transfer_ref);
+
+unsigned long gnttab_end_foreign_transfer(grant_ref_t ref)
+{
+        unsigned long frame = gnttab_end_foreign_transfer_ref(ref);
+        put_free_entry(ref);
+        return frame;
+}
+EXPORT_SYMBOL_GPL(gnttab_end_foreign_transfer);
+
+void gnttab_free_grant_reference(grant_ref_t ref)
+{
+        put_free_entry(ref);
+}
+EXPORT_SYMBOL_GPL(gnttab_free_grant_reference);
+
+void gnttab_free_grant_references(grant_ref_t head)
+{
+        grant_ref_t ref;
+        unsigned long flags;
+        int count = 1;
+        if (head == GNTTAB_LIST_END)
+                return;
+        spin_lock_irqsave(&gnttab_list_lock, flags);
+        ref = head;
+        while (gnttab_entry(ref) != GNTTAB_LIST_END) {
+                ref = gnttab_entry(ref);
+                count++;
+        }
+        gnttab_entry(ref) = gnttab_free_head;
+        gnttab_free_head = head;
+        gnttab_free_count += count;
+        check_free_callbacks();
+        spin_unlock_irqrestore(&gnttab_list_lock, flags);
+}
+EXPORT_SYMBOL_GPL(gnttab_free_grant_references);
+
+int gnttab_alloc_grant_references(u16 count, grant_ref_t *head)
+{
+        int h = get_free_entries(count);
+
+        if (h < 0)
+                return -ENOSPC;
+
+        *head = h;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(gnttab_alloc_grant_references);
+
+int gnttab_empty_grant_references(const grant_ref_t *private_head)
+{
+        return (*private_head == GNTTAB_LIST_END);
+}
+EXPORT_SYMBOL_GPL(gnttab_empty_grant_references);
+
+int gnttab_claim_grant_reference(grant_ref_t *private_head)
+{
+        grant_ref_t g = *private_head;
+        if (unlikely(g == GNTTAB_LIST_END))
+                return -ENOSPC;
+        *private_head = gnttab_entry(g);
+        return g;
+}
+EXPORT_SYMBOL_GPL(gnttab_claim_grant_reference);
+
+void gnttab_release_grant_reference(grant_ref_t *private_head,
+                                    grant_ref_t release)
+{
+        gnttab_entry(release) = *private_head;
+        *private_head = release;
+}
+EXPORT_SYMBOL_GPL(gnttab_release_grant_reference);
+
+void gnttab_request_free_callback(struct gnttab_free_callback *callback,
+                                  void (*fn)(void *), void *arg, u16 count)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&gnttab_list_lock, flags);
+        if (callback->next)
+                goto out;
+        callback->fn = fn;
+        callback->arg = arg;
+        callback->count = count;
+        callback->next = gnttab_free_callback_list;
+        gnttab_free_callback_list = callback;
+        check_free_callbacks();
+out:
+        spin_unlock_irqrestore(&gnttab_list_lock, flags);
+}
+EXPORT_SYMBOL_GPL(gnttab_request_free_callback);
+
+void gnttab_cancel_free_callback(struct gnttab_free_callback *callback)
+{
+        struct gnttab_free_callback **pcb;
+        unsigned long flags;
+
+        spin_lock_irqsave(&gnttab_list_lock, flags);
+        for (pcb = &gnttab_free_callback_list; *pcb; pcb = &(*pcb)->next) {
+                if (*pcb == callback) {
+                        *pcb = callback->next;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&gnttab_list_lock, flags);
+}
+EXPORT_SYMBOL_GPL(gnttab_cancel_free_callback);
+
+static int grow_gnttab_list(unsigned int more_frames)
+{
+        unsigned int new_nr_grant_frames, extra_entries, i;
+
+        new_nr_grant_frames = nr_grant_frames + more_frames;
+        extra_entries       = more_frames * GREFS_PER_GRANT_FRAME;
+
+        for (i = nr_grant_frames; i < new_nr_grant_frames; i++) {
+                gnttab_list[i] = (grant_ref_t *)__get_free_page(GFP_ATOMIC);
+                if (!gnttab_list[i])
+                        goto grow_nomem;
+        }
+
+
+        for (i = GREFS_PER_GRANT_FRAME * nr_grant_frames;
+             i < GREFS_PER_GRANT_FRAME * new_nr_grant_frames - 1; i++)
+                gnttab_entry(i) = i + 1;
+
+        gnttab_entry(i) = gnttab_free_head;
+        gnttab_free_head = GREFS_PER_GRANT_FRAME * nr_grant_frames;
+        gnttab_free_count += extra_entries;
+
+        nr_grant_frames = new_nr_grant_frames;
+
+        check_free_callbacks();
+
+        return 0;
+
+grow_nomem:
+        for ( ; i >= nr_grant_frames; i--)
+                free_page((unsigned long) gnttab_list[i]);
+        return -ENOMEM;
+}
+
+static unsigned int __max_nr_grant_frames(void)
+{
+        struct gnttab_query_size query;
+        int rc;
+
+        query.dom = DOMID_SELF;
+
+        rc = HYPERVISOR_grant_table_op(GNTTABOP_query_size, &query, 1);
+        if ((rc < 0) || (query.status != GNTST_okay))
+                return 4; /* Legacy max supported number of frames */
+
+        return query.max_nr_frames;
+}
+
+static inline unsigned int max_nr_grant_frames(void)
+{
+        unsigned int xen_max = __max_nr_grant_frames();
+
+        if (xen_max > boot_max_nr_grant_frames)
+                return boot_max_nr_grant_frames;
+        return xen_max;
+}
+
+static int map_pte_fn(pte_t *pte, struct page *pmd_page,
+                      unsigned long addr, void *data)
+{
+        unsigned long **frames = (unsigned long **)data;
+
+        set_pte_at(&init_mm, addr, pte, mfn_pte((*frames)[0], PAGE_KERNEL));
+        (*frames)++;
+        return 0;
+}
+
+static int unmap_pte_fn(pte_t *pte, struct page *pmd_page,
+                        unsigned long addr, void *data)
+{
+
+        set_pte_at(&init_mm, addr, pte, __pte(0));
+        return 0;
+}
+
+static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
+{
+        struct gnttab_setup_table setup;
+        unsigned long *frames;
+        unsigned int nr_gframes = end_idx + 1;
+        int rc;
+
+        frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC);
+        if (!frames)
+                return -ENOMEM;
+
+        setup.dom        = DOMID_SELF;
+        setup.nr_frames  = nr_gframes;
+        setup.frame_list = frames;
+
+        rc = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);
+        if (rc == -ENOSYS) {
+                kfree(frames);
+                return -ENOSYS;
+        }
+
+        BUG_ON(rc || setup.status);
+
+        if (shared == NULL) {
+                struct vm_struct *area;
+                area = alloc_vm_area(PAGE_SIZE * max_nr_grant_frames());
+                BUG_ON(area == NULL);
+                shared = area->addr;
+        }
+        rc = apply_to_page_range(&init_mm, (unsigned long)shared,
+                                 PAGE_SIZE * nr_gframes,
+                                 map_pte_fn, &frames);
+        BUG_ON(rc);
+        frames -= nr_gframes; /* adjust after map_pte_fn() */
+
+        kfree(frames);
+
+        return 0;
+}
+
+static int gnttab_resume(void)
+{
+        if (max_nr_grant_frames() < nr_grant_frames)
+                return -ENOSYS;
+        return gnttab_map(0, nr_grant_frames - 1);
+}
+
+static int gnttab_suspend(void)
+{
+        apply_to_page_range(&init_mm, (unsigned long)shared,
+                            PAGE_SIZE * nr_grant_frames,
+                            unmap_pte_fn, NULL);
+
+        return 0;
+}
+
+static int gnttab_expand(unsigned int req_entries)
+{
+        int rc;
+        unsigned int cur, extra;
+
+        cur = nr_grant_frames;
+        extra = ((req_entries + (GREFS_PER_GRANT_FRAME-1)) /
+                 GREFS_PER_GRANT_FRAME);
+        if (cur + extra > max_nr_grant_frames())
+                return -ENOSPC;
+
+        rc = gnttab_map(cur, cur + extra - 1);
+        if (rc == 0)
+                rc = grow_gnttab_list(extra);
+
+        return rc;
+}
+
+static int __devinit gnttab_init(void)
+{
+        int i;
+        unsigned int max_nr_glist_frames;
+        unsigned int nr_init_grefs;
+
+        if (!is_running_on_xen())
+                return -ENODEV;
+
+        nr_grant_frames = 1;
+        boot_max_nr_grant_frames = __max_nr_grant_frames();
+
+        /* Determine the maximum number of frames required for the
+         * grant reference free list on the current hypervisor.
+         */
+        max_nr_glist_frames = (boot_max_nr_grant_frames *
+                               GREFS_PER_GRANT_FRAME /
+                               (PAGE_SIZE / sizeof(grant_ref_t)));
+
+        gnttab_list = kmalloc(max_nr_glist_frames * sizeof(grant_ref_t *),
+                              GFP_KERNEL);
+        if (gnttab_list == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < nr_grant_frames; i++) {
+                gnttab_list[i] = (grant_ref_t *)__get_free_page(GFP_KERNEL);
+                if (gnttab_list[i] == NULL)
+                        goto ini_nomem;
+        }
+
+        if (gnttab_resume() < 0)
+                return -ENODEV;
+
+        nr_init_grefs = nr_grant_frames * GREFS_PER_GRANT_FRAME;
+
+        for (i = NR_RESERVED_ENTRIES; i < nr_init_grefs - 1; i++)
+                gnttab_entry(i) = i + 1;
+
+        gnttab_entry(nr_init_grefs - 1) = GNTTAB_LIST_END;
+        gnttab_free_count = nr_init_grefs - NR_RESERVED_ENTRIES;
+        gnttab_free_head  = NR_RESERVED_ENTRIES;
+
+        printk("Grant table initialized\n");
+        return 0;
+
+ ini_nomem:
+        for (i--; i >= 0; i--)
+                free_page((unsigned long)gnttab_list[i]);
+        kfree(gnttab_list);
+        return -ENOMEM;
+}
+
+core_initcall(gnttab_init);
diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h
new file mode 100644
index 000000000000..761c83498e03
--- /dev/null
+++ b/include/xen/grant_table.h
@@ -0,0 +1,107 @@
+/******************************************************************************
+ * grant_table.h
+ *
+ * Two sets of functionality:
+ * 1. Granting foreign access to our memory reservation.
+ * 2. Accessing others' memory reservations via grant references.
+ * (i.e., mechanisms for both sender and recipient of grant references)
+ *
+ * Copyright (c) 2004-2005, K A Fraser
+ * Copyright (c) 2005, Christopher Clark
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef __ASM_GNTTAB_H__
+#define __ASM_GNTTAB_H__
+
+#include <asm/xen/hypervisor.h>
+#include <xen/interface/grant_table.h>
+
+/* NR_GRANT_FRAMES must be less than or equal to that configured in Xen */
+#define NR_GRANT_FRAMES 4
+
+struct gnttab_free_callback {
+        struct gnttab_free_callback *next;
+        void (*fn)(void *);
+        void *arg;
+        u16 count;
+};
+
+int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
+                                int readonly);
+
+/*
+ * End access through the given grant reference, iff the grant entry is no
+ * longer in use.  Return 1 if the grant entry was freed, 0 if it is still in
+ * use.
+ */
+int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly);
+
+/*
+ * Eventually end access through the given grant reference, and once that
+ * access has been ended, free the given page too.  Access will be ended
+ * immediately iff the grant entry is not in use, otherwise it will happen
+ * some time later.  page may be 0, in which case no freeing will occur.
+ */
+void gnttab_end_foreign_access(grant_ref_t ref, int readonly,
+                               unsigned long page);
+
+int gnttab_grant_foreign_transfer(domid_t domid, unsigned long pfn);
+
+unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref);
+unsigned long gnttab_end_foreign_transfer(grant_ref_t ref);
+
+int gnttab_query_foreign_access(grant_ref_t ref);
+
+/*
+ * operations on reserved batches of grant references
+ */
+int gnttab_alloc_grant_references(u16 count, grant_ref_t *pprivate_head);
+
+void gnttab_free_grant_reference(grant_ref_t ref);
+
+void gnttab_free_grant_references(grant_ref_t head);
+
+int gnttab_empty_grant_references(const grant_ref_t *pprivate_head);
+
+int gnttab_claim_grant_reference(grant_ref_t *pprivate_head);
+
+void gnttab_release_grant_reference(grant_ref_t *private_head,
+                                    grant_ref_t release);
+
+void gnttab_request_free_callback(struct gnttab_free_callback *callback,
+                                  void (*fn)(void *), void *arg, u16 count);
+void gnttab_cancel_free_callback(struct gnttab_free_callback *callback);
+
+void gnttab_grant_foreign_access_ref(grant_ref_t ref, domid_t domid,
+                                     unsigned long frame, int readonly);
+
+void gnttab_grant_foreign_transfer_ref(grant_ref_t, domid_t domid,
+                                       unsigned long pfn);
+
+#define gnttab_map_vaddr(map) ((void *)(map.host_virt_addr))
+
+#endif /* __ASM_GNTTAB_H__ */
diff --git a/include/xen/interface/grant_table.h b/include/xen/interface/grant_table.h
index e9e06695ed52..219049802cf2 100644
--- a/include/xen/interface/grant_table.h
+++ b/include/xen/interface/grant_table.h
@@ -4,6 +4,24 @@
  * Interface for granting foreign access to page frames, and receiving
  * page-ownership transfers.
  *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
  * Copyright (c) 2004, K A Fraser
  */
 
@@ -17,7 +35,7 @@
 
 /* Some rough guidelines on accessing and updating grant-table entries
  * in a concurrency-safe manner. For more information, Linux contains a
- * reference implementation for guest OSes (arch/i386/mach-xen/grant_table.c).
+ * reference implementation for guest OSes (arch/xen/kernel/grant_table.c).
  *
  * NB. WMB is a no-op on current-generation x86 processors. However, a
  *     compiler barrier will still be required.
@@ -144,9 +162,9 @@ typedef uint32_t grant_handle_t;
  * that must be presented later to destroy the mapping(s). On error, <handle>
  * is a negative status code.
  * NOTES:
- *  1. If GNTPIN_map_for_dev is specified then <dev_bus_addr> is the address
+ *  1. If GNTMAP_device_map is specified then <dev_bus_addr> is the address
  *     via which I/O devices may access the granted frame.
- *  2. If GNTPIN_map_for_host is specified then a mapping will be added at
+ *  2. If GNTMAP_host_map is specified then a mapping will be added at
  *     either a host virtual address in the current address space, or at
  *     a PTE at the specified machine address.  The type of mapping to
  *     perform is selected through the GNTMAP_contains_pte flag, and the
@@ -167,7 +185,6 @@ struct gnttab_map_grant_ref {
     grant_handle_t handle;
     uint64_t dev_bus_addr;
 };
-DEFINE_GUEST_HANDLE_STRUCT(gnttab_map_grant_ref);
 
 /*
  * GNTTABOP_unmap_grant_ref: Destroy one or more grant-reference mappings
@@ -189,7 +206,6 @@ struct gnttab_unmap_grant_ref {
     /* OUT parameters. */
     int16_t  status;              /* GNTST_* */
 };
-DEFINE_GUEST_HANDLE_STRUCT(gnttab_unmap_grant_ref);
 
 /*
  * GNTTABOP_setup_table: Set up a grant table for <dom> comprising at least
@@ -207,9 +223,8 @@ struct gnttab_setup_table {
     uint32_t nr_frames;
     /* OUT parameters. */
     int16_t  status;              /* GNTST_* */
-    GUEST_HANDLE(ulong) frame_list;
+    ulong *frame_list;
 };
-DEFINE_GUEST_HANDLE_STRUCT(gnttab_setup_table);
 
 /*
  * GNTTABOP_dump_table: Dump the contents of the grant table to the
@@ -222,7 +237,6 @@ struct gnttab_dump_table {
     /* OUT parameters. */
     int16_t status;               /* GNTST_* */
 };
-DEFINE_GUEST_HANDLE_STRUCT(gnttab_dump_table);
 
 /*
  * GNTTABOP_transfer_grant_ref: Transfer <frame> to a foreign domain. The
@@ -241,7 +255,65 @@ struct gnttab_transfer {
     /* OUT parameters. */
     int16_t       status;
 };
-DEFINE_GUEST_HANDLE_STRUCT(gnttab_transfer);
+
+
+/*
+ * GNTTABOP_copy: Hypervisor based copy
+ * source and destinations can be eithers MFNs or, for foreign domains,
+ * grant references. the foreign domain has to grant read/write access
+ * in its grant table.
+ *
+ * The flags specify what type source and destinations are (either MFN
+ * or grant reference).
+ *
+ * Note that this can also be used to copy data between two domains
+ * via a third party if the source and destination domains had previously
+ * grant appropriate access to their pages to the third party.
+ *
+ * source_offset specifies an offset in the source frame, dest_offset
+ * the offset in the target frame and  len specifies the number of
+ * bytes to be copied.
+ */
+
+#define _GNTCOPY_source_gref      (0)
+#define GNTCOPY_source_gref       (1<<_GNTCOPY_source_gref)
+#define _GNTCOPY_dest_gref        (1)
+#define GNTCOPY_dest_gref         (1<<_GNTCOPY_dest_gref)
+
+#define GNTTABOP_copy                 5
+struct gnttab_copy {
+        /* IN parameters. */
+        struct {
+                union {
+                        grant_ref_t ref;
+                        unsigned long   gmfn;
+                } u;
+                domid_t  domid;
+                uint16_t offset;
+        } source, dest;
+        uint16_t      len;
+        uint16_t      flags;          /* GNTCOPY_* */
+        /* OUT parameters. */
+        int16_t       status;
+};
+
+/*
+ * GNTTABOP_query_size: Query the current and maximum sizes of the shared
+ * grant table.
+ * NOTES:
+ *  1. <dom> may be specified as DOMID_SELF.
+ *  2. Only a sufficiently-privileged domain may specify <dom> != DOMID_SELF.
+ */
+#define GNTTABOP_query_size           6
+struct gnttab_query_size {
+    /* IN parameters. */
+    domid_t  dom;
+    /* OUT parameters. */
+    uint32_t nr_frames;
+    uint32_t max_nr_frames;
+    int16_t  status;              /* GNTST_* */
+};
+
 
 /*
  * Bitfield values for update_pin_status.flags.
@@ -284,6 +356,7 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_transfer);
 #define GNTST_no_device_space  (-7) /* Out of space in I/O MMU.              */
 #define GNTST_permission_denied (-8) /* Not enough privilege for operation.  */
 #define GNTST_bad_page         (-9) /* Specified page was invalid for op.    */
+#define GNTST_bad_copy_arg    (-10) /* copy arguments cross page boundary */
 
 #define GNTTABOP_error_msgs {                   \
     "okay",                                     \
@@ -295,7 +368,8 @@ DEFINE_GUEST_HANDLE_STRUCT(gnttab_transfer);
     "invalid device address",                   \
     "no spare translation slot in the I/O MMU", \
     "permission denied",                        \
-    "bad page"                                  \
+    "bad page",                                 \
+    "copy arguments cross page boundary"        \
 }
 
 #endif /* __XEN_PUBLIC_GRANT_TABLE_H__ */