leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

IB/uverbs: Provide implementation private memory for the uverbs_attr_bundle

Browse Source 
This already existed as the anonymous 'ctx' structure, but this was not
really a useful form. Hoist this struct into bundle_priv and rework the
internal things to use it instead.

Move a bunch of the processing internal state into the priv and reduce the
excessive use of function arguments.

Signed-off-by: Jason Gunthorpe <jgg@mellanox.com>
Reviewed-by: Leon Romanovsky <leonro@mellanox.com>
This commit is contained in:
Jason Gunthorpe 2018-08-09 20:14:38 -06:00
parent 6b0d08f4a2
commit 4b3dd2bbf0
2 changed files with 58 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
drivers/infiniband/core/uverbs_ioctl.c
View File

@ -35,6 +35,18 @@
#include "rdma_core.h" #include "rdma_core.h"
#include "uverbs.h" #include "uverbs.h"
struct bundle_priv {
struct ib_uverbs_attr __user *user_attrs;
struct ib_uverbs_attr *uattrs;
struct uverbs_obj_attr *destroy_attr;
/*
* Must be last. bundle ends in a flex array which overlaps
* internal_buffer.
*/
struct uverbs_attr_bundle bundle;
};
static bool uverbs_is_attr_cleared(const struct ib_uverbs_attr *uattr, static bool uverbs_is_attr_cleared(const struct ib_uverbs_attr *uattr,
u16 len) u16 len)
{ {
@ -46,12 +58,11 @@ static bool uverbs_is_attr_cleared(const struct ib_uverbs_attr *uattr,
0, uattr->len - len); 0, uattr->len - len);
} }
static int uverbs_process_attr(struct ib_uverbs_file *ufile, static int uverbs_process_attr(struct bundle_priv *pbundle,
const struct ib_uverbs_attr *uattr, const struct ib_uverbs_attr *uattr,
u16 attr_id, u16 attr_id,
const struct uverbs_attr_spec_hash *attr_spec_bucket, const struct uverbs_attr_spec_hash *attr_spec_bucket,
struct uverbs_attr_bundle_hash *attr_bundle_h, struct uverbs_attr_bundle_hash *attr_bundle_h,
struct uverbs_obj_attr **destroy_attr,
struct ib_uverbs_attr __user *uattr_ptr) struct ib_uverbs_attr __user *uattr_ptr)
{ {
const struct uverbs_attr_spec *spec; const struct uverbs_attr_spec *spec;
@ -147,9 +158,9 @@ static int uverbs_process_attr(struct ib_uverbs_file *ufile,
/* specs are allowed to have only one destroy attribute */ /* specs are allowed to have only one destroy attribute */
WARN_ON(spec->u.obj.access == UVERBS_ACCESS_DESTROY && WARN_ON(spec->u.obj.access == UVERBS_ACCESS_DESTROY &&
*destroy_attr); pbundle->destroy_attr);
if (spec->u.obj.access == UVERBS_ACCESS_DESTROY) if (spec->u.obj.access == UVERBS_ACCESS_DESTROY)
*destroy_attr = o_attr; pbundle->destroy_attr = o_attr;
/* /*
* The type of uattr->data is u64 for UVERBS_ATTR_TYPE_IDR and * The type of uattr->data is u64 for UVERBS_ATTR_TYPE_IDR and
@ -159,7 +170,7 @@ static int uverbs_process_attr(struct ib_uverbs_file *ufile,
*/ */
o_attr->uobject = uverbs_get_uobject_from_file( o_attr->uobject = uverbs_get_uobject_from_file(
spec->u.obj.obj_type, spec->u.obj.obj_type,
ufile, pbundle->bundle.ufile,
spec->u.obj.access, spec->u.obj.access,
uattr->data_s64); uattr->data_s64);
@ -187,10 +198,11 @@ static int uverbs_process_attr(struct ib_uverbs_file *ufile,
return 0; return 0;
} }
static int uverbs_finalize_attrs(struct uverbs_attr_bundle *attrs_bundle, static int uverbs_finalize_attrs(struct bundle_priv *pbundle,
struct uverbs_attr_spec_hash *const *spec_hash, struct uverbs_attr_spec_hash *const *spec_hash,
size_t num, bool commit) size_t num, bool commit)
{ {
struct uverbs_attr_bundle *attrs_bundle = &pbundle->bundle;
unsigned int i; unsigned int i;
int ret = 0; int ret = 0;
@ -233,27 +245,25 @@ static int uverbs_finalize_attrs(struct uverbs_attr_bundle *attrs_bundle,
return ret; return ret;
} }
static int uverbs_uattrs_process(struct ib_uverbs_file *ufile, static int uverbs_uattrs_process(size_t num_uattrs,
const struct ib_uverbs_attr *uattrs,
size_t num_uattrs,
const struct uverbs_method_spec *method, const struct uverbs_method_spec *method,
struct uverbs_attr_bundle *attr_bundle, struct bundle_priv *pbundle)
struct uverbs_obj_attr **destroy_attr,
struct ib_uverbs_attr __user *uattr_ptr)
{ {
struct uverbs_attr_bundle *attr_bundle = &pbundle->bundle;
struct ib_uverbs_attr __user *uattr_ptr = pbundle->user_attrs;
size_t i; size_t i;
int ret = 0; int ret = 0;
int num_given_buckets = 0; int num_given_buckets = 0;
for (i = 0; i < num_uattrs; i++) { for (i = 0; i < num_uattrs; i++) {
const struct ib_uverbs_attr *uattr = &uattrs[i]; const struct ib_uverbs_attr *uattr = &pbundle->uattrs[i];
u16 attr_id = uattr->attr_id; u16 attr_id = uattr->attr_id;
struct uverbs_attr_spec_hash *attr_spec_bucket; struct uverbs_attr_spec_hash *attr_spec_bucket;
ret = uverbs_ns_idx(&attr_id, method->num_buckets); ret = uverbs_ns_idx(&attr_id, method->num_buckets);
if (ret < 0 || !method->attr_buckets[ret]) { if (ret < 0 || !method->attr_buckets[ret]) {
if (uattr->flags & UVERBS_ATTR_F_MANDATORY) { if (uattr->flags & UVERBS_ATTR_F_MANDATORY) {
uverbs_finalize_attrs(attr_bundle, uverbs_finalize_attrs(pbundle,
method->attr_buckets, method->attr_buckets,
num_given_buckets, num_given_buckets,
false); false);
@ -270,12 +280,13 @@ static int uverbs_uattrs_process(struct ib_uverbs_file *ufile,
num_given_buckets = ret + 1; num_given_buckets = ret + 1;
attr_spec_bucket = method->attr_buckets[ret]; attr_spec_bucket = method->attr_buckets[ret];
ret = uverbs_process_attr(ufile, uattr, attr_id, ret = uverbs_process_attr(pbundle,
uattr, attr_id,
attr_spec_bucket, attr_spec_bucket,
&attr_bundle->hash[ret], destroy_attr, &attr_bundle->hash[ret],
uattr_ptr++); uattr_ptr++);
if (ret) { if (ret) {
uverbs_finalize_attrs(attr_bundle, uverbs_finalize_attrs(pbundle,
method->attr_buckets, method->attr_buckets,
num_given_buckets, num_given_buckets,
false); false);
@ -287,8 +298,9 @@ static int uverbs_uattrs_process(struct ib_uverbs_file *ufile,
} }
static int uverbs_validate_kernel_mandatory(const struct uverbs_method_spec *method_spec, static int uverbs_validate_kernel_mandatory(const struct uverbs_method_spec *method_spec,
struct uverbs_attr_bundle *attr_bundle) struct bundle_priv *pbundle)
{ {
struct uverbs_attr_bundle *attr_bundle = &pbundle->bundle;
unsigned int i; unsigned int i;
for (i = 0; i < attr_bundle->num_buckets; i++) { for (i = 0; i < attr_bundle->num_buckets; i++) {
@ -316,27 +328,22 @@ static int uverbs_validate_kernel_mandatory(const struct uverbs_method_spec *met
return 0; return 0;
} }
static int uverbs_handle_method(struct ib_uverbs_attr __user *uattr_ptr, static int uverbs_handle_method(size_t num_uattrs,
const struct ib_uverbs_attr *uattrs,
size_t num_uattrs,
struct ib_device *ibdev,
struct ib_uverbs_file *ufile,
const struct uverbs_method_spec *method_spec, const struct uverbs_method_spec *method_spec,
struct uverbs_attr_bundle *attr_bundle) struct bundle_priv *pbundle)
{ {
struct uverbs_attr_bundle *attr_bundle = &pbundle->bundle;
int ret; int ret;
int finalize_ret; int finalize_ret;
int num_given_buckets; int num_given_buckets;
struct uverbs_obj_attr *destroy_attr = NULL;
num_given_buckets = num_given_buckets =
uverbs_uattrs_process(ufile, uattrs, num_uattrs, method_spec, uverbs_uattrs_process(num_uattrs, method_spec, pbundle);
attr_bundle, &destroy_attr, uattr_ptr);
if (num_given_buckets <= 0) if (num_given_buckets <= 0)
return -EINVAL; return -EINVAL;
attr_bundle->num_buckets = num_given_buckets; attr_bundle->num_buckets = num_given_buckets;
ret = uverbs_validate_kernel_mandatory(method_spec, attr_bundle); ret = uverbs_validate_kernel_mandatory(method_spec, pbundle);
if (ret) if (ret)
goto cleanup; goto cleanup;
@ -344,21 +351,21 @@ static int uverbs_handle_method(struct ib_uverbs_attr __user *uattr_ptr,
* We destroy the HW object before invoking the handler, handlers do * We destroy the HW object before invoking the handler, handlers do
* not get to manipulate the HW objects. * not get to manipulate the HW objects.
*/ */
if (destroy_attr) { if (pbundle->destroy_attr) {
ret = uobj_destroy(destroy_attr->uobject); ret = uobj_destroy(pbundle->destroy_attr->uobject);
if (ret) if (ret)
goto cleanup; goto cleanup;
} }
ret = method_spec->handler(ufile, attr_bundle); ret = method_spec->handler(pbundle->bundle.ufile, attr_bundle);
if (destroy_attr) { if (pbundle->destroy_attr) {
uobj_put_destroy(destroy_attr->uobject); uobj_put_destroy(pbundle->destroy_attr->uobject);
destroy_attr->uobject = NULL; pbundle->destroy_attr->uobject = NULL;
} }
cleanup: cleanup:
finalize_ret = uverbs_finalize_attrs(attr_bundle, finalize_ret = uverbs_finalize_attrs(pbundle,
method_spec->attr_buckets, method_spec->attr_buckets,
attr_bundle->num_buckets, attr_bundle->num_buckets,
!ret); !ret);
@ -370,16 +377,13 @@ cleanup:
static long ib_uverbs_cmd_verbs(struct ib_device *ib_dev, static long ib_uverbs_cmd_verbs(struct ib_device *ib_dev,
struct ib_uverbs_file *file, struct ib_uverbs_file *file,
struct ib_uverbs_ioctl_hdr *hdr, struct ib_uverbs_ioctl_hdr *hdr,
void __user *buf) struct ib_uverbs_attr __user *user_attrs)
{ {
const struct uverbs_object_spec *object_spec; const struct uverbs_object_spec *object_spec;
const struct uverbs_method_spec *method_spec; const struct uverbs_method_spec *method_spec;
long err = 0; long err = 0;
unsigned int i; unsigned int i;
struct { struct bundle_priv *ctx;
struct ib_uverbs_attr *uattrs;
struct uverbs_attr_bundle *uverbs_attr_bundle;
} *ctx = NULL;
struct uverbs_attr *curr_attr; struct uverbs_attr *curr_attr;
unsigned long *curr_bitmap; unsigned long *curr_bitmap;
size_t ctx_size; size_t ctx_size;
@ -397,12 +401,11 @@ static long ib_uverbs_cmd_verbs(struct ib_device *ib_dev,
return -EPROTONOSUPPORT; return -EPROTONOSUPPORT;
ctx_size = sizeof(*ctx) + ctx_size = sizeof(*ctx) +
sizeof(struct uverbs_attr_bundle) +
sizeof(struct uverbs_attr_bundle_hash) * method_spec->num_buckets + sizeof(struct uverbs_attr_bundle_hash) * method_spec->num_buckets +
sizeof(*ctx->uattrs) * hdr->num_attrs + sizeof(*ctx->uattrs) * hdr->num_attrs +
sizeof(*ctx->uverbs_attr_bundle->hash[0].attrs) * sizeof(*ctx->bundle.hash[0].attrs) *
method_spec->num_child_attrs + method_spec->num_child_attrs +
sizeof(*ctx->uverbs_attr_bundle->hash[0].valid_bitmap) * sizeof(*ctx->bundle.hash[0].valid_bitmap) *
(method_spec->num_child_attrs / BITS_PER_LONG + (method_spec->num_child_attrs / BITS_PER_LONG +
method_spec->num_buckets); method_spec->num_buckets);
@ -413,10 +416,8 @@ static long ib_uverbs_cmd_verbs(struct ib_device *ib_dev,
if (!ctx) if (!ctx)
return -ENOMEM; return -ENOMEM;
ctx->uverbs_attr_bundle = (void *)ctx + sizeof(*ctx); ctx->uattrs = (void *)(ctx + 1) +
ctx->uattrs = (void *)(ctx->uverbs_attr_bundle + 1) + (sizeof(ctx->bundle.hash[0]) * method_spec->num_buckets);
(sizeof(ctx->uverbs_attr_bundle->hash[0]) *
method_spec->num_buckets);
curr_attr = (void *)(ctx->uattrs + hdr->num_attrs); curr_attr = (void *)(ctx->uattrs + hdr->num_attrs);
curr_bitmap = (void *)(curr_attr + method_spec->num_child_attrs); curr_bitmap = (void *)(curr_attr + method_spec->num_child_attrs);
@ -432,23 +433,25 @@ static long ib_uverbs_cmd_verbs(struct ib_device *ib_dev,
curr_num_attrs = method_spec->attr_buckets[i]->num_attrs; curr_num_attrs = method_spec->attr_buckets[i]->num_attrs;
ctx->uverbs_attr_bundle->hash[i].attrs = curr_attr; ctx->bundle.hash[i].attrs = curr_attr;
curr_attr += curr_num_attrs; curr_attr += curr_num_attrs;
ctx->uverbs_attr_bundle->hash[i].num_attrs = curr_num_attrs; ctx->bundle.hash[i].num_attrs = curr_num_attrs;
ctx->uverbs_attr_bundle->hash[i].valid_bitmap = curr_bitmap; ctx->bundle.hash[i].valid_bitmap = curr_bitmap;
bitmap_zero(curr_bitmap, curr_num_attrs); bitmap_zero(curr_bitmap, curr_num_attrs);
curr_bitmap += BITS_TO_LONGS(curr_num_attrs); curr_bitmap += BITS_TO_LONGS(curr_num_attrs);
} }
err = copy_from_user(ctx->uattrs, buf, err = copy_from_user(ctx->uattrs, user_attrs,
sizeof(*ctx->uattrs) * hdr->num_attrs); sizeof(*ctx->uattrs) * hdr->num_attrs);
if (err) { if (err) {
err = -EFAULT; err = -EFAULT;
goto out; goto out;
} }
err = uverbs_handle_method(buf, ctx->uattrs, hdr->num_attrs, ib_dev, ctx->destroy_attr = NULL;
file, method_spec, ctx->uverbs_attr_bundle); ctx->bundle.ufile = file;
ctx->user_attrs = user_attrs;
err = uverbs_handle_method(hdr->num_attrs, method_spec, ctx);
/* /*
* EPROTONOSUPPORT is ONLY to be returned if the ioctl framework can * EPROTONOSUPPORT is ONLY to be returned if the ioctl framework can
@ -499,8 +502,7 @@ long ib_uverbs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
goto out; goto out;
} }
err = ib_uverbs_cmd_verbs(ib_dev, file, &hdr, err = ib_uverbs_cmd_verbs(ib_dev, file, &hdr, user_hdr->attrs);
(__user void *)arg + sizeof(hdr));
} else { } else {
err = -ENOIOCTLCMD; err = -ENOIOCTLCMD;
} }

1
include/rdma/uverbs_ioctl.h
View File

@ -494,6 +494,7 @@ struct uverbs_attr_bundle_hash {
}; };
struct uverbs_attr_bundle { struct uverbs_attr_bundle {
struct ib_uverbs_file *ufile;
size_t num_buckets; size_t num_buckets;
struct uverbs_attr_bundle_hash hash[]; struct uverbs_attr_bundle_hash hash[];
}; };