WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

[Xen-devel] [PATCH 2/6] xen-gntdev: Remove unneeded structures from gran

To: xen-devel@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-devel] [PATCH 2/6] xen-gntdev: Remove unneeded structures from grant_map tracking data
From: Daniel De Graaf <dgdegra@xxxxxxxxxxxxx>
Date: Fri, 14 Jan 2011 10:46:12 -0500
Cc: Daniel De Graaf <dgdegra@xxxxxxxxxxxxx>, jeremy@xxxxxxxx, Ian.Campbell@xxxxxxxxxx, konrad.wilk@xxxxxxxxxx
Delivery-date: Fri, 14 Jan 2011 07:51:32 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
In-reply-to: <1295019976-605-1-git-send-email-dgdegra@xxxxxxxxxxxxx>
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
References: <1295019976-605-1-git-send-email-dgdegra@xxxxxxxxxxxxx>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
The entire hypercall argument list isn't required; only selected
fields from the hypercall need to be tracked between the ioctl, map,
and unmap operations.

Signed-off-by: Daniel De Graaf <dgdegra@xxxxxxxxxxxxx>
---
 drivers/xen/gntdev.c |  225 ++++++++++++++++++++++++++++++--------------------
 1 files changed, 136 insertions(+), 89 deletions(-)

diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c
index 59e6a51..d0802b5 100644
--- a/drivers/xen/gntdev.c
+++ b/drivers/xen/gntdev.c
@@ -60,18 +60,24 @@ struct gntdev_priv {
        struct mmu_notifier mn;
 };
 
+struct granted_page {
+       u64 pte_maddr;
+       union {
+               struct ioctl_gntdev_grant_ref target;
+               grant_handle_t handle;
+       };
+};
+
 struct grant_map {
        struct list_head next;
        struct gntdev_priv *priv;
        struct vm_area_struct *vma;
        int index;
        int count;
-       int flags;
-       int is_mapped;
-       struct ioctl_gntdev_grant_ref *grants;
-       struct gnttab_map_grant_ref   *map_ops;
-       struct gnttab_unmap_grant_ref *unmap_ops;
+       int is_mapped:1;
+       int is_ro:1;
        struct page **pages;
+       struct granted_page pginfo[0];
 };
 
 /* ------------------------------------------------------------------ */
@@ -91,24 +97,19 @@ static void gntdev_print_maps(struct gntdev_priv *priv,
 #endif
 }
 
-static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count)
+static struct grant_map *gntdev_alloc_map(int count,
+               struct ioctl_gntdev_grant_ref* grants)
 {
        struct grant_map *add;
        int i;
 
-       add = kzalloc(sizeof(struct grant_map), GFP_KERNEL);
-       if (NULL == add)
+       add = kzalloc(sizeof(*add) + sizeof(add->pginfo[0])*count, GFP_KERNEL);
+       if (!add)
                return NULL;
 
-       add->grants    = kzalloc(sizeof(add->grants[0])    * count, GFP_KERNEL);
-       add->map_ops   = kzalloc(sizeof(add->map_ops[0])   * count, GFP_KERNEL);
-       add->unmap_ops = kzalloc(sizeof(add->unmap_ops[0]) * count, GFP_KERNEL);
-       add->pages     = kzalloc(sizeof(add->pages[0])     * count, GFP_KERNEL);
-       if (NULL == add->grants    ||
-           NULL == add->map_ops   ||
-           NULL == add->unmap_ops ||
-           NULL == add->pages)
-               goto err;
+       add->pages = kzalloc(sizeof(add->pages[0])*count, GFP_KERNEL);
+       if (!add->pages)
+               goto err_nopages;
 
        for (i = 0; i < count; i++) {
                add->pages[i] = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
@@ -118,20 +119,18 @@ static struct grant_map *gntdev_alloc_map(struct 
gntdev_priv *priv, int count)
 
        add->index = 0;
        add->count = count;
-       add->priv  = priv;
+       for(i = 0; i < count; i++)
+               add->pginfo[i].target = grants[i];
 
        return add;
 
 err:
-       if (add->pages)
-               for (i = 0; i < count; i++) {
-                       if (add->pages[i])
-                               __free_page(add->pages[i]);
-               }
+       for (i = 0; i < count; i++) {
+               if (add->pages[i])
+                       __free_page(add->pages[i]);
+       }
        kfree(add->pages);
-       kfree(add->grants);
-       kfree(add->map_ops);
-       kfree(add->unmap_ops);
+err_nopages:
        kfree(add);
        return NULL;
 }
@@ -140,6 +139,7 @@ static void gntdev_add_map(struct gntdev_priv *priv, struct 
grant_map *add)
 {
        struct grant_map *map;
 
+       spin_lock(&priv->lock);
        list_for_each_entry(map, &priv->maps, next) {
                if (add->index + add->count < map->index) {
                        list_add_tail(&add->next, &map->next);
@@ -150,7 +150,9 @@ static void gntdev_add_map(struct gntdev_priv *priv, struct 
grant_map *add)
        list_add_tail(&add->next, &priv->maps);
 
 done:
+       add->priv = priv;
        gntdev_print_maps(priv, "[new]", add->index);
+       spin_unlock(&priv->lock);
 }
 
 static struct grant_map *gntdev_find_map_index(struct gntdev_priv *priv,
@@ -191,9 +193,10 @@ static int gntdev_del_map(struct grant_map *map)
 
        if (map->vma)
                return -EBUSY;
-       for (i = 0; i < map->count; i++)
-               if (map->unmap_ops[i].handle)
-                       return -EBUSY;
+       if (map->is_mapped)
+               for (i = 0; i < map->count; i++)
+                       if (map->pginfo[i].handle)
+                               return -EBUSY;
 
        atomic_sub(map->count, &pages_mapped);
        list_del(&map->next);
@@ -207,15 +210,11 @@ static void gntdev_free_map(struct grant_map *map)
        if (!map)
                return;
 
-       if (map->pages)
-               for (i = 0; i < map->count; i++) {
-                       if (map->pages[i])
-                               __free_page(map->pages[i]);
-               }
+       for (i = 0; i < map->count; i++) {
+               if (map->pages[i])
+                       __free_page(map->pages[i]);
+       }
        kfree(map->pages);
-       kfree(map->grants);
-       kfree(map->map_ops);
-       kfree(map->unmap_ops);
        kfree(map);
 }
 
@@ -229,50 +228,96 @@ static int find_grant_ptes(pte_t *pte, pgtable_t token,
        u64 pte_maddr;
 
        BUG_ON(pgnr >= map->count);
+
        pte_maddr = arbitrary_virt_to_machine(pte).maddr;
+       map->pginfo[pgnr].pte_maddr = pte_maddr;
 
-       gnttab_set_map_op(&map->map_ops[pgnr], pte_maddr,
-                         GNTMAP_contains_pte | map->flags,
-                         map->grants[pgnr].ref,
-                         map->grants[pgnr].domid);
-       gnttab_set_unmap_op(&map->unmap_ops[pgnr], pte_maddr,
-                           GNTMAP_contains_pte | map->flags,
-                           0 /* handle */);
        return 0;
 }
 
 static int map_grant_pages(struct grant_map *map)
 {
-       int i, err = 0;
+       int i, flags, err = 0;
+       struct gnttab_map_grant_ref* map_ops = NULL;
 
-       pr_debug("map %d+%d\n", map->index, map->count);
-       err = gnttab_map_refs(map->map_ops, map->pages, map->count);
-       if (err)
-               return err;
+       flags = GNTMAP_host_map | GNTMAP_application_map | GNTMAP_contains_pte;
+       if (map->is_ro)
+               flags |= GNTMAP_readonly;
+
+       err = -ENOMEM;
+       map_ops = kzalloc(sizeof(map_ops[0]) * map->count, GFP_TEMPORARY);
+       if (!map_ops)
+               goto out;
+
+       for(i=0; i < map->count; i++) {
+               gnttab_set_map_op(&map_ops[i], map->pginfo[i].pte_maddr, flags,
+                                 map->pginfo[i].target.ref,
+                                 map->pginfo[i].target.domid);
+       }
+       pr_debug("%s: map %d+%d\n", __FUNCTION__, map->index, map->count);
+
+       err = gnttab_map_refs(map_ops, map->pages, map->count);
+
+       if (WARN_ON(err))
+               goto out;
 
        for (i = 0; i < map->count; i++) {
-               if (map->map_ops[i].status)
+               if (map_ops[i].status) {
+                       __free_page(map->pages[i]);
+                       map->pages[i] = NULL;
                        err = -EINVAL;
-               map->unmap_ops[i].handle = map->map_ops[i].handle;
+               } else {
+                       map->pginfo[i].handle = map_ops[i].handle;
+               }
        }
+
+out:
+       kfree(map_ops);
        return err;
 }
 
-static int unmap_grant_pages(struct grant_map *map, int offset, int pages)
+static void unmap_grant_pages(struct grant_map *map, int offset, int pages)
 {
-       int i, err = 0;
+       int i, flags, err = 0;
+       struct gnttab_unmap_grant_ref *unmap_ops;
+       struct gnttab_unmap_grant_ref unmap_single;
+
+       if (pages > 1) {
+               unmap_ops = kzalloc(sizeof(unmap_ops[0]) * pages,
+                                   GFP_TEMPORARY);
+               if (unlikely(!unmap_ops)) {
+                       for(i=0; i < pages; i++)
+                               unmap_grant_pages(map, offset + i, 1);
+                       return;
+               }
+       } else {
+               unmap_ops = &unmap_single;
+       }
+
+       flags = GNTMAP_host_map | GNTMAP_application_map | GNTMAP_contains_pte;
+       if (map->is_ro)
+               flags |= GNTMAP_readonly;
 
+       for(i=0; i < pages; i++)
+               gnttab_set_unmap_op(&unmap_ops[i],
+                                   map->pginfo[offset+i].pte_maddr, flags,
+                                   map->pginfo[offset+i].handle);
        pr_debug("map %d+%d [%d+%d]\n", map->index, map->count, offset, pages);
-       err = gnttab_unmap_refs(map->unmap_ops + offset, map->pages, pages);
+
+       err = gnttab_unmap_refs(unmap_ops, map->pages + offset, pages);
+
        if (err)
-               return err;
+               goto out;
 
        for (i = 0; i < pages; i++) {
-               if (map->unmap_ops[offset+i].status)
-                       err = -EINVAL;
-               map->unmap_ops[offset+i].handle = 0;
+               WARN_ON(unmap_ops[i].status);
+               __free_page(map->pages[offset+i]);
+               map->pages[offset+i] = NULL;
+               map->pginfo[offset+i].handle = 0;
        }
-       return err;
+out:
+       if (unmap_ops != &unmap_single)
+               kfree(unmap_ops);
 }
 
 /* ------------------------------------------------------------------ */
@@ -309,7 +354,6 @@ static void mn_invl_range_start(struct mmu_notifier *mn,
        struct gntdev_priv *priv = container_of(mn, struct gntdev_priv, mn);
        struct grant_map *map;
        unsigned long mstart, mend;
-       int err;
 
        spin_lock(&priv->lock);
        list_for_each_entry(map, &priv->maps, next) {
@@ -327,10 +371,9 @@ static void mn_invl_range_start(struct mmu_notifier *mn,
                                map->index, map->count,
                                map->vma->vm_start, map->vma->vm_end,
                                start, end, mstart, mend);
-               err = unmap_grant_pages(map,
-                                       (mstart - map->vma->vm_start) >> 
PAGE_SHIFT,
-                                       (mend - mstart) >> PAGE_SHIFT);
-               WARN_ON(err);
+               unmap_grant_pages(map,
+                                 (mstart - map->vma->vm_start) >> PAGE_SHIFT,
+                                 (mend - mstart) >> PAGE_SHIFT);
        }
        spin_unlock(&priv->lock);
 }
@@ -347,7 +390,6 @@ static void mn_release(struct mmu_notifier *mn,
 {
        struct gntdev_priv *priv = container_of(mn, struct gntdev_priv, mn);
        struct grant_map *map;
-       int err;
 
        spin_lock(&priv->lock);
        list_for_each_entry(map, &priv->maps, next) {
@@ -356,8 +398,7 @@ static void mn_release(struct mmu_notifier *mn,
                pr_debug("map %d+%d (%lx %lx)\n",
                                map->index, map->count,
                                map->vma->vm_start, map->vma->vm_end);
-               err = unmap_grant_pages(map, /* offset */ 0, map->count);
-               WARN_ON(err);
+               unmap_grant_pages(map, /* offset */ 0, map->count);
        }
        spin_unlock(&priv->lock);
 }
@@ -430,6 +471,7 @@ static long gntdev_ioctl_map_grant_ref(struct gntdev_priv 
*priv,
 {
        struct ioctl_gntdev_map_grant_ref op;
        struct grant_map *map;
+       struct ioctl_gntdev_grant_ref* grants;
        int err;
 
        if (copy_from_user(&op, u, sizeof(op)) != 0)
@@ -438,37 +480,44 @@ static long gntdev_ioctl_map_grant_ref(struct gntdev_priv 
*priv,
        if (unlikely(op.count <= 0))
                return -EINVAL;
 
-       err = -ENOMEM;
-       map = gntdev_alloc_map(priv, op.count);
-       if (!map)
-               return err;
+       grants = kmalloc(sizeof(grants[0]) * op.count, GFP_TEMPORARY);
+       if (!grants)
+               return -ENOMEM;
 
-       if (copy_from_user(map->grants, &u->refs,
-                          sizeof(map->grants[0]) * op.count) != 0) {
-               gntdev_free_map(map);
-               return err;
+       if (copy_from_user(grants, u->refs, sizeof(grants[0]) * op.count)) {
+               err = -EFAULT;
+               goto out_free;
        }
 
+       err = -ENOMEM;
+       map = gntdev_alloc_map(op.count, grants);
+       if (!map)
+               goto out_free;
+
        if (unlikely(atomic_add_return(op.count, &pages_mapped) > limit))
        {
                pr_debug("%s: can't map: over limit\n", __FUNCTION__);
-               gntdev_free_map(map);
-               return err;
+               goto out_free_map;
        }
 
-       spin_lock(&priv->lock);
        gntdev_add_map(priv, map);
        op.index = map->index << PAGE_SHIFT;
-       spin_unlock(&priv->lock);
 
-       if (copy_to_user(u, &op, sizeof(op)) != 0) {
-               spin_lock(&priv->lock);
-               gntdev_del_map(map);
-               spin_unlock(&priv->lock);
-               gntdev_free_map(map);
-               return err;
+       if (copy_to_user(u, &op, sizeof(op))) {
+               err = -EFAULT;
+               goto out_remove;
        }
-       return 0;
+       err = 0;
+out_free:
+       kfree(grants);
+       return err;
+out_remove:
+       spin_lock(&priv->lock);
+       gntdev_del_map(map);
+       spin_unlock(&priv->lock);
+out_free_map:
+       gntdev_free_map(map);
+       goto out_free;
 }
 
 static long gntdev_ioctl_unmap_grant_ref(struct gntdev_priv *priv,
@@ -574,9 +623,7 @@ static int gntdev_mmap(struct file *flip, struct 
vm_area_struct *vma)
        vma->vm_private_data = map;
        map->vma = vma;
 
-       map->flags = GNTMAP_host_map | GNTMAP_application_map;
-       if (!(vma->vm_flags & VM_WRITE))
-               map->flags |= GNTMAP_readonly;
+       map->is_ro = !(vma->vm_flags & VM_WRITE);
 
        spin_unlock(&priv->lock);
 
-- 
1.7.3.4


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel

<Prev in Thread] Current Thread [Next in Thread>