xen/xenbus: some cleanups
Juergen Gross
maintainercover xen/xenbus: some cleanups
Avoid allocating large amount of data on the stack in xenbus_map_ring_valloc() and some related return value cleanups.
Juergen Gross (2):
xen/xenbus: avoid large structs and arrays on the stack xen/xenbus: let xenbus_map_ring_valloc() return errno values only
drivers/xen/xenbus/xenbus_client.c | 133 ++++++++++++++--------------- 1 file changed, 64 insertions(+), 69 deletions(-)
Signature · 1 line
2.26.1
Juergen Gross
maintainerPATCH 1/2 xen/xenbus: avoid large structs and arrays on the stack
xenbus_map_ring_valloc() and its sub-functions are putting quite large structs and arrays on the stack. This is problematic at runtime, but might also result in build failures (e.g. with clang due to the option -Werror,-Wframe-larger-than=... used).
Fix that by moving most of the data from the stack into a dynamically allocated struct. Performance is no issue here, as xenbus_map_ring_valloc() is used only when adding a new PV device to a backend driver.
While at it move some duplicated code from pv/hvm specific mapping functions to the single caller.
--- drivers/xen/xenbus/xenbus_client.c | 127 +++++++++++++++-------------- 1 file changed, 66 insertions(+), 61 deletions(-)
drivers/xen/xenbus/xenbus_client.c +66 -61
@@ -69,11 +69,27 @@ struct xenbus_map_node {unsigned int nr_handles; }; +struct map_ring_valloc { +struct xenbus_map_node *node; + +/* Why do we need two arrays? See comment of __xenbus_map_ring */ +union { +unsigned long addrs[XENBUS_MAX_RING_GRANTS ]; +pte_t *ptes[XENBUS_MAX_RING_GRANTS ]; + }; +phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS ]; + +struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS ]; +struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS ]; + +unsigned int idx;/* HVM only. */ +}; +static DEFINE_SPINLOCK (xenbus_valloc_lock);static LIST_HEAD (xenbus_valloc_pages);struct xenbus_ring_ops { -int (*map)(struct xenbus_device *dev, +int (*map)(struct xenbus_device *dev,struct map_ring_valloc *info,grant_ref_t *gnt_refs,unsigned int nr_grefs,void **vaddr);int (*unmap)(struct xenbus_device *dev,void *vaddr);
@@ -449,12 +465,32 @@ int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs, unsigned int nr_grefs, void **vaddr) { int err; +struct map_ring_valloc *info; + + *vaddr =NULL ; + +if (nr_grefs >XENBUS_MAX_RING_GRANTS ) +return -EINVAL ; + + info =kzalloc (sizeof (*info),GFP_KERNEL ); +if (!info) +return -ENOMEM ; + + info->node =kzalloc (sizeof (*info->node),GFP_KERNEL ); +if (!info->node) { + err = -ENOMEM ; + goto out; + } + + err = ring_ops->map (dev, info, gnt_refs, nr_grefs, vaddr); - err = ring_ops->map (dev, gnt_refs, nr_grefs, vaddr);/* Some hypervisors are buggy and can return 1. */ if (err >0 ) err = GNTST_general_error; + out: +kfree (info->node); +kfree (info);return err; }EXPORT_SYMBOL_GPL (xenbus_map_ring_valloc);
@@ -466,12 +502,10 @@ static int __xenbus_map_ring(struct xenbus_device *dev,grant_ref_t *gnt_refs, unsigned int nr_grefs, grant_handle_t *handles, - phys_addr_t *addrs, + struct map_ring_valloc *info, unsigned int flags, bool *leaked) { - struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS]; -struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS ]; int i, j;int err = GNTST_okay;
@@ -479,23 +513,22 @@ static int __xenbus_map_ring(struct xenbus_device *dev,return -EINVAL ;for (i =0 ; i < nr_grefs; i++) { -memset (&map[i],0 ,sizeof (map[i])); -gnttab_set_map_op (&map[i], addrs[i], flags, gnt_refs[i], - dev->otherend_id); +gnttab_set_map_op (&info->map[i], info->phys_addrs[i], flags, + gnt_refs[i], dev->otherend_id); handles[i] =INVALID_GRANT_HANDLE ; } -gnttab_batch_map (map, i); +gnttab_batch_map (info->map, i);for (i =0 ; i < nr_grefs; i++) { -if (map[i].status != GNTST_okay) { - err = map[i].status; -xenbus_dev_fatal (dev, map[i].status, +if (info->map[i].status != GNTST_okay) { + err = info->map[i].status; +xenbus_dev_fatal (dev, info->map[i].status,"mapping in shared page %d from domain %d" , gnt_refs[i], dev->otherend_id); goto fail; }else - handles[i] = map[i].handle; + handles[i] = info->map[i].handle; }return GNTST_okay;
@@ -503,19 +536,19 @@ static int __xenbus_map_ring(struct xenbus_device *dev, fail:for (i = j =0 ; i < nr_grefs; i++) {if (handles[i] !=INVALID_GRANT_HANDLE ) { -memset (&unmap[j],0 ,sizeof (unmap[j])); -gnttab_set_unmap_op (&unmap[j], (phys_addr_t )addrs[i], +gnttab_set_unmap_op (&info->unmap[j], + info->phys_addrs[i], GNTMAP_host_map, handles[i]); j++; } } -if (HYPERVISOR_grant_table_op (GNTTABOP_unmap_grant_ref, unmap, j)) +if (HYPERVISOR_grant_table_op (GNTTABOP_unmap_grant_ref, info->unmap, j))BUG (); *leaked = false;for (i =0 ; i < j; i++) { -if (unmap[i].status != GNTST_okay) { +if (info->unmap[i].status != GNTST_okay) { *leaked = true;break ; }
@@ -566,21 +599,12 @@ static int xenbus_unmap_ring(struct xenbus_device *dev, grant_handle_t *handles,return err; } -struct map_ring_valloc_hvm -{ -unsigned int idx; - -/* Why do we need two arrays? See comment of __xenbus_map_ring */ -phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS ]; -unsigned long addrs[XENBUS_MAX_RING_GRANTS ]; -}; -static void xenbus_map_ring_setup_grant_hvm (unsigned long gfn,unsigned int goffset,unsigned int len,void *data) { -struct map_ring_valloc_hvm *info = data; +struct map_ring_valloc *info = data;unsigned long vaddr = (unsigned long )gfn_to_virt (gfn); info->phys_addrs[info->idx] = vaddr;
@@ -590,38 +614,27 @@ static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn, }static int xenbus_map_ring_valloc_hvm (struct xenbus_device *dev, +struct map_ring_valloc *info,grant_ref_t *gnt_ref,unsigned int nr_grefs,void **vaddr) { -struct xenbus_map_node *node; +struct xenbus_map_node *node = info->node;int err;void *addr;bool leaked = false; -struct map_ring_valloc_hvm info = { - .idx =0 , - };unsigned int nr_pages =XENBUS_PAGES (nr_grefs); -if (nr_grefs >XENBUS_MAX_RING_GRANTS ) -return -EINVAL ; - - *vaddr =NULL ; - - node =kzalloc (sizeof (*node),GFP_KERNEL ); -if (!node) -return -ENOMEM ; - err =alloc_xenballooned_pages (nr_pages, node->hvm.pages);if (err) goto out_err;gnttab_foreach_grant (node->hvm.pages, nr_grefs, xenbus_map_ring_setup_grant_hvm, - &info); + info); err =__xenbus_map_ring (dev, gnt_ref, nr_grefs, node->handles, - info.phys_addrs, GNTMAP_host_map, &leaked); + info, GNTMAP_host_map, &leaked); node->nr_handles = nr_grefs;if (err)
@@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,spin_unlock (&xenbus_valloc_lock); *vaddr = addr; + info->node =NULL ; +return 0 ; out_xenbus_unmap_ring:if (!leaked) -xenbus_unmap_ring (dev, node->handles, nr_grefs, info.addrs); +xenbus_unmap_ring (dev, node->handles, nr_grefs, info->addrs);else pr_alert ("leaking %p size %u page(s)" , addr, nr_pages);
@@ -653,7 +668,6 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,if (!leaked)free_xenballooned_pages (nr_pages, node->hvm.pages); out_err: -kfree (node);return err; }
@@ -677,39 +691,29 @@ EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);#ifdef CONFIG_XEN_PV static int xenbus_map_ring_valloc_pv (struct xenbus_device *dev, +struct map_ring_valloc *info,grant_ref_t *gnt_refs,unsigned int nr_grefs,void **vaddr) { -struct xenbus_map_node *node; +struct xenbus_map_node *node = info->node;struct vm_struct *area; -pte_t *ptes[XENBUS_MAX_RING_GRANTS ]; -phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS ];int err = GNTST_okay;int i;bool leaked; - *vaddr =NULL ; - -if (nr_grefs >XENBUS_MAX_RING_GRANTS ) -return -EINVAL ; - - node =kzalloc (sizeof (*node),GFP_KERNEL ); -if (!node) -return -ENOMEM ; - - area =alloc_vm_area (XEN_PAGE_SIZE * nr_grefs, ptes); + area =alloc_vm_area (XEN_PAGE_SIZE * nr_grefs, info->ptes);if (!area) {kfree (node);return -ENOMEM ; }for (i =0 ; i < nr_grefs; i++) - phys_addrs[i] =arbitrary_virt_to_machine (ptes[i]).maddr; + info->phys_addrs[i] = +arbitrary_virt_to_machine (info->ptes[i]).maddr; err =__xenbus_map_ring (dev, gnt_refs, nr_grefs, node->handles, - phys_addrs, - GNTMAP_host_map | GNTMAP_contains_pte, + info, GNTMAP_host_map | GNTMAP_contains_pte, &leaked);if (err) goto failed;
@@ -722,6 +726,8 @@ static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,spin_unlock (&xenbus_valloc_lock); *vaddr = area->addr; + info->node =NULL ; +return 0 ; failed:
@@ -730,7 +736,6 @@ static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,else pr_alert ("leaking VM area %p size %u page(s)" , area, nr_grefs); -kfree (node);return err; }
Signature · 1 line
2.26.1
Re: [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack
Quoted 2 lines · Juergen Gross
static int xenbus_map_ring_valloc_hvm(struct
xenbus_device*dev,
I wonder whether we can drop valloc/vfree from xenbus_ring_ops' names.
Quoted 40 lines
drivers/xen/xenbus/xenbus_client.c +4
-15+struct map_ring_valloc *info, grant_ref_t *gnt_ref, unsigned int nr_grefs, void **vaddr) { - struct xenbus_map_node *node; + struct xenbus_map_node *node = info->node;int err;void *addr;bool leaked = false; -struct map_ring_valloc_hvm info = { - .idx =0 , - };unsigned int nr_pages =XENBUS_PAGES (nr_grefs); -if (nr_grefs >XENBUS_MAX_RING_GRANTS ) -return -EINVAL ; - - *vaddr =NULL ; - - node =kzalloc (sizeof (*node),GFP_KERNEL ); -if (!node) -return -ENOMEM ; - err =alloc_xenballooned_pages (nr_pages, node->hvm.pages);if (err) goto out_err;gnttab_foreach_grant (node->hvm.pages, nr_grefs, xenbus_map_ring_setup_grant_hvm, - &info); + info); err =__xenbus_map_ring (dev, gnt_ref, nr_grefs, node->handles, - info.phys_addrs, GNTMAP_host_map, &leaked); + info, GNTMAP_host_map, &leaked); node->nr_handles = nr_grefs;if (err)
drivers/xen/xenbus/xenbus_client.c static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev, · line 657
Quoted 4 lines
drivers/xen/xenbus/xenbus_client.c +1
-0@@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,spin_unlock (&xenbus_valloc_lock); *vaddr = addr; + info->node =NULL ;
Is this so that xenbus_map_ring_valloc() doesn't free it accidentally?
-boris
Quoted 4 lines
drivers/xen/xenbus/xenbus_client.c +1
-0+return 0 ;
Jürgen Groß
maintainerRe: [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack
Quoted 6 lines · Boris Ostrovsky
Quoted 2 lines · Juergen Gross
static int xenbus_map_ring_valloc_hvm(struct
xenbus_device*dev,I wonder whether we can drop valloc/vfree from
xenbus_ring_ops' names.
I can do that.
Quoted 44 lines
Quoted 44 lines
drivers/xen/xenbus/xenbus_client.c +4
-15+struct map_ring_valloc *info, grant_ref_t *gnt_ref, unsigned int nr_grefs, void **vaddr) { - struct xenbus_map_node *node; + struct xenbus_map_node *node = info->node;int err;void *addr;bool leaked = false; -struct map_ring_valloc_hvm info = { - .idx =0 , - };unsigned int nr_pages =XENBUS_PAGES (nr_grefs); -if (nr_grefs >XENBUS_MAX_RING_GRANTS ) -return -EINVAL ; - - *vaddr =NULL ; - - node =kzalloc (sizeof (*node),GFP_KERNEL ); -if (!node) -return -ENOMEM ; - err =alloc_xenballooned_pages (nr_pages, node->hvm.pages);if (err) goto out_err;gnttab_foreach_grant (node->hvm.pages, nr_grefs, xenbus_map_ring_setup_grant_hvm, - &info); + info); err =__xenbus_map_ring (dev, gnt_ref, nr_grefs, node->handles, - info.phys_addrs, GNTMAP_host_map, &leaked); + info, GNTMAP_host_map, &leaked); node->nr_handles = nr_grefs;if (err)@@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,spin_unlock (&xenbus_valloc_lock);
Quoted 5 lines
drivers/xen/xenbus/xenbus_client.c static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev, · line 657
Quoted 2 lines
drivers/xen/xenbus/xenbus_client.c +1
-0*vaddr = addr; + info->node =NULL ;Is this so that
xenbus_map_ring_valloc()doesn't free it accidentally?
Yes.
Juergen
Juergen Gross
maintainerPATCH 2/2 xen/xenbus: let xenbus_map_ring_valloc() return errno values only
In reply to Juergen GrossToday xenbus_map_ring_valloc() can return either a negative errno value (-ENOMEM or -EINVAL) or a grant status value. This is a mess as e.g -ENOMEM and GNTST_eagain have the same numeric value.
Fix that by turning all grant mapping errors into -ENOENT. This is no problem as all callers of xenbus_map_ring_valloc() only use the return value to print an error message, and in case of mapping errors the grant status value has already been printed by __xenbus_map_ring() before.
--- drivers/xen/xenbus/xenbus_client.c | 22 ++++++---------------- 1 file changed, 6 insertions(+), 16 deletions(-)
drivers/xen/xenbus/xenbus_client.c +6 -16
@@ -456,8 +456,7 @@ EXPORT_SYMBOL_GPL(xenbus_free_evtchn);* Map @nr_grefs pages of memory into this domain from another * domain's grant table. xenbus_map_ring_valloc allocates @nr_grefs * pages of virtual address space, maps the pages to that address, and -* sets *vaddr to that address. Returns 0 on success, and GNTST_* -* (see xen/include/interface/grant_table.h) or -ENOMEM / -EINVAL on +* sets *vaddr to that address. Returns 0 on success, and -errno on * error. If an error is returned, device will switch to * XenbusStateClosing and the error message will be saved in XenStore. */
@@ -477,18 +476,11 @@ int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,return -ENOMEM ; info->node =kzalloc (sizeof (*info->node),GFP_KERNEL ); -if (!info->node) { +if (!info->node) err = -ENOMEM ; - goto out; - } - - err = ring_ops->map (dev, info, gnt_refs, nr_grefs, vaddr); - -/* Some hypervisors are buggy and can return 1. */ -if (err >0 ) - err = GNTST_general_error; +else + err = ring_ops->map (dev, info, gnt_refs, nr_grefs, vaddr); - out:kfree (info->node);kfree (info);return err;
@@ -507,7 +499,6 @@ static int __xenbus_map_ring(struct xenbus_device *dev, bool *leaked) {int i, j; -int err = GNTST_okay;if (nr_grefs >XENBUS_MAX_RING_GRANTS )return -EINVAL ;
@@ -522,7 +513,6 @@ static int __xenbus_map_ring(struct xenbus_device *dev,for (i =0 ; i < nr_grefs; i++) {if (info->map[i].status != GNTST_okay) { - err = info->map[i].status;xenbus_dev_fatal (dev, info->map[i].status,"mapping in shared page %d from domain %d" , gnt_refs[i], dev->otherend_id);
@@ -531,7 +521,7 @@ static int __xenbus_map_ring(struct xenbus_device *dev, handles[i] = info->map[i].handle; } -return GNTST_okay; +return 0 ; fail:for (i = j =0 ; i < nr_grefs; i++) {
@@ -554,7 +544,7 @@ static int __xenbus_map_ring(struct xenbus_device *dev, } } -return err; +return -ENOENT ; }/**
Signature · 1 line
2.26.1
Re: [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only
Quoted 11 lines · Juergen Gross
Today
xenbus_map_ring_valloc()can return either a negative errno value (-ENOMEMor-EINVAL) or a grant status value. This is a mess as e.g-ENOMEMandGNTST_eagainhave the same numeric value.Fix that by turning all grant mapping errors into
-ENOENT. This is no problem as all callers ofxenbus_map_ring_valloc()only use the return value to print an error message, and in case of mapping errors the grant status value has already been printed by__xenbus_map_ring()before.Signed-off-by Juergen Gross <[email protected]>