Changeset View
Changeset View
Standalone View
Standalone View
sys/ofed/drivers/infiniband/core/ib_uverbs_uapi.c
- This file was added.
// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB | |||||
/* | |||||
* Copyright (c) 2017, Mellanox Technologies inc. All rights reserved. | |||||
*/ | |||||
#include <rdma/uverbs_ioctl.h> | |||||
#include <rdma/rdma_user_ioctl.h> | |||||
#include <linux/bitops.h> | |||||
#include "rdma_core.h" | |||||
#include "uverbs.h" | |||||
static int ib_uverbs_notsupp(struct uverbs_attr_bundle *attrs) | |||||
{ | |||||
return -EOPNOTSUPP; | |||||
} | |||||
static void *uapi_add_elm(struct uverbs_api *uapi, u32 key, size_t alloc_size) | |||||
{ | |||||
void *elm; | |||||
int rc; | |||||
if (key == UVERBS_API_KEY_ERR) | |||||
return ERR_PTR(-EOVERFLOW); | |||||
elm = kzalloc(alloc_size, GFP_KERNEL); | |||||
if (!elm) | |||||
return ERR_PTR(-ENOMEM); | |||||
rc = radix_tree_insert(&uapi->radix, key, elm); | |||||
if (rc) { | |||||
kfree(elm); | |||||
return ERR_PTR(rc); | |||||
} | |||||
return elm; | |||||
} | |||||
static void *uapi_add_get_elm(struct uverbs_api *uapi, u32 key, | |||||
size_t alloc_size, bool *exists) | |||||
{ | |||||
void *elm; | |||||
elm = uapi_add_elm(uapi, key, alloc_size); | |||||
if (!IS_ERR(elm)) { | |||||
*exists = false; | |||||
return elm; | |||||
} | |||||
if (elm != ERR_PTR(-EEXIST)) | |||||
return elm; | |||||
elm = radix_tree_lookup(&uapi->radix, key); | |||||
if (WARN_ON(!elm)) | |||||
return ERR_PTR(-EINVAL); | |||||
*exists = true; | |||||
return elm; | |||||
} | |||||
static int uapi_create_write(struct uverbs_api *uapi, | |||||
struct ib_device *ibdev, | |||||
const struct uapi_definition *def, | |||||
u32 obj_key, | |||||
u32 *cur_method_key) | |||||
{ | |||||
struct uverbs_api_write_method *method_elm; | |||||
u32 method_key = obj_key; | |||||
bool exists; | |||||
if (def->write.is_ex) | |||||
method_key |= uapi_key_write_ex_method(def->write.command_num); | |||||
else | |||||
method_key |= uapi_key_write_method(def->write.command_num); | |||||
method_elm = uapi_add_get_elm(uapi, method_key, sizeof(*method_elm), | |||||
&exists); | |||||
if (IS_ERR(method_elm)) | |||||
return PTR_ERR(method_elm); | |||||
if (WARN_ON(exists && (def->write.is_ex != method_elm->is_ex))) | |||||
return -EINVAL; | |||||
method_elm->is_ex = def->write.is_ex; | |||||
method_elm->handler = def->func_write; | |||||
if (def->write.is_ex) | |||||
method_elm->disabled = !(ibdev->uverbs_ex_cmd_mask & | |||||
BIT_ULL(def->write.command_num)); | |||||
else | |||||
method_elm->disabled = !(ibdev->uverbs_cmd_mask & | |||||
BIT_ULL(def->write.command_num)); | |||||
if (!def->write.is_ex && def->func_write) { | |||||
method_elm->has_udata = def->write.has_udata; | |||||
method_elm->has_resp = def->write.has_resp; | |||||
method_elm->req_size = def->write.req_size; | |||||
method_elm->resp_size = def->write.resp_size; | |||||
} | |||||
*cur_method_key = method_key; | |||||
return 0; | |||||
} | |||||
static int uapi_merge_method(struct uverbs_api *uapi, | |||||
struct uverbs_api_object *obj_elm, u32 obj_key, | |||||
const struct uverbs_method_def *method, | |||||
bool is_driver) | |||||
{ | |||||
u32 method_key = obj_key | uapi_key_ioctl_method(method->id); | |||||
struct uverbs_api_ioctl_method *method_elm; | |||||
unsigned int i; | |||||
bool exists; | |||||
if (!method->attrs) | |||||
return 0; | |||||
method_elm = uapi_add_get_elm(uapi, method_key, sizeof(*method_elm), | |||||
&exists); | |||||
if (IS_ERR(method_elm)) | |||||
return PTR_ERR(method_elm); | |||||
if (exists) { | |||||
/* | |||||
* This occurs when a driver uses ADD_UVERBS_ATTRIBUTES_SIMPLE | |||||
*/ | |||||
if (WARN_ON(method->handler)) | |||||
return -EINVAL; | |||||
} else { | |||||
WARN_ON(!method->handler); | |||||
rcu_assign_pointer(method_elm->handler, method->handler); | |||||
if (method->handler != uverbs_destroy_def_handler) | |||||
method_elm->driver_method = is_driver; | |||||
} | |||||
for (i = 0; i != method->num_attrs; i++) { | |||||
const struct uverbs_attr_def *attr = (*method->attrs)[i]; | |||||
struct uverbs_api_attr *attr_slot; | |||||
if (!attr) | |||||
continue; | |||||
/* | |||||
* ENUM_IN contains the 'ids' pointer to the driver's .rodata, | |||||
* so if it is specified by a driver then it always makes this | |||||
* into a driver method. | |||||
*/ | |||||
if (attr->attr.type == UVERBS_ATTR_TYPE_ENUM_IN) | |||||
method_elm->driver_method |= is_driver; | |||||
/* | |||||
* Like other uobject based things we only support a single | |||||
* uobject being NEW'd or DESTROY'd | |||||
*/ | |||||
if (attr->attr.type == UVERBS_ATTR_TYPE_IDRS_ARRAY) { | |||||
u8 access = attr->attr.u2.objs_arr.access; | |||||
if (WARN_ON(access == UVERBS_ACCESS_NEW || | |||||
access == UVERBS_ACCESS_DESTROY)) | |||||
return -EINVAL; | |||||
} | |||||
attr_slot = | |||||
uapi_add_elm(uapi, method_key | uapi_key_attr(attr->id), | |||||
sizeof(*attr_slot)); | |||||
/* Attributes are not allowed to be modified by drivers */ | |||||
if (IS_ERR(attr_slot)) | |||||
return PTR_ERR(attr_slot); | |||||
attr_slot->spec = attr->attr; | |||||
} | |||||
return 0; | |||||
} | |||||
static int uapi_merge_obj_tree(struct uverbs_api *uapi, | |||||
const struct uverbs_object_def *obj, | |||||
bool is_driver) | |||||
{ | |||||
struct uverbs_api_object *obj_elm; | |||||
unsigned int i; | |||||
u32 obj_key; | |||||
bool exists; | |||||
int rc; | |||||
obj_key = uapi_key_obj(obj->id); | |||||
obj_elm = uapi_add_get_elm(uapi, obj_key, sizeof(*obj_elm), &exists); | |||||
if (IS_ERR(obj_elm)) | |||||
return PTR_ERR(obj_elm); | |||||
if (obj->type_attrs) { | |||||
if (WARN_ON(obj_elm->type_attrs)) | |||||
return -EINVAL; | |||||
obj_elm->id = obj->id; | |||||
obj_elm->type_attrs = obj->type_attrs; | |||||
obj_elm->type_class = obj->type_attrs->type_class; | |||||
/* | |||||
* Today drivers are only permitted to use idr_class and | |||||
* fd_class types. We can revoke the IDR types during | |||||
* disassociation, and the FD types require the driver to use | |||||
* struct file_operations.owner to prevent the driver module | |||||
* code from unloading while the file is open. This provides | |||||
* enough safety that uverbs_uobject_fd_release() will | |||||
* continue to work. Drivers using FD are responsible to | |||||
* handle disassociation of the device on their own. | |||||
*/ | |||||
if (WARN_ON(is_driver && | |||||
obj->type_attrs->type_class != &uverbs_idr_class && | |||||
obj->type_attrs->type_class != &uverbs_fd_class)) | |||||
return -EINVAL; | |||||
} | |||||
if (!obj->methods) | |||||
return 0; | |||||
for (i = 0; i != obj->num_methods; i++) { | |||||
const struct uverbs_method_def *method = (*obj->methods)[i]; | |||||
if (!method) | |||||
continue; | |||||
rc = uapi_merge_method(uapi, obj_elm, obj_key, method, | |||||
is_driver); | |||||
if (rc) | |||||
return rc; | |||||
} | |||||
return 0; | |||||
} | |||||
static int uapi_disable_elm(struct uverbs_api *uapi, | |||||
const struct uapi_definition *def, | |||||
u32 obj_key, | |||||
u32 method_key) | |||||
{ | |||||
bool exists; | |||||
if (def->scope == UAPI_SCOPE_OBJECT) { | |||||
struct uverbs_api_object *obj_elm; | |||||
obj_elm = uapi_add_get_elm( | |||||
uapi, obj_key, sizeof(*obj_elm), &exists); | |||||
if (IS_ERR(obj_elm)) | |||||
return PTR_ERR(obj_elm); | |||||
obj_elm->disabled = 1; | |||||
return 0; | |||||
} | |||||
if (def->scope == UAPI_SCOPE_METHOD && | |||||
uapi_key_is_ioctl_method(method_key)) { | |||||
struct uverbs_api_ioctl_method *method_elm; | |||||
method_elm = uapi_add_get_elm(uapi, method_key, | |||||
sizeof(*method_elm), &exists); | |||||
if (IS_ERR(method_elm)) | |||||
return PTR_ERR(method_elm); | |||||
method_elm->disabled = 1; | |||||
return 0; | |||||
} | |||||
if (def->scope == UAPI_SCOPE_METHOD && | |||||
(uapi_key_is_write_method(method_key) || | |||||
uapi_key_is_write_ex_method(method_key))) { | |||||
struct uverbs_api_write_method *write_elm; | |||||
write_elm = uapi_add_get_elm(uapi, method_key, | |||||
sizeof(*write_elm), &exists); | |||||
if (IS_ERR(write_elm)) | |||||
return PTR_ERR(write_elm); | |||||
write_elm->disabled = 1; | |||||
return 0; | |||||
} | |||||
WARN_ON(true); | |||||
return -EINVAL; | |||||
} | |||||
static int uapi_merge_def(struct uverbs_api *uapi, struct ib_device *ibdev, | |||||
const struct uapi_definition *def_list, | |||||
bool is_driver) | |||||
{ | |||||
const struct uapi_definition *def = def_list; | |||||
u32 cur_obj_key = UVERBS_API_KEY_ERR; | |||||
u32 cur_method_key = UVERBS_API_KEY_ERR; | |||||
bool exists; | |||||
int rc; | |||||
if (!def_list) | |||||
return 0; | |||||
for (;; def++) { | |||||
switch ((enum uapi_definition_kind)def->kind) { | |||||
case UAPI_DEF_CHAIN: | |||||
rc = uapi_merge_def(uapi, ibdev, def->chain, is_driver); | |||||
if (rc) | |||||
return rc; | |||||
continue; | |||||
case UAPI_DEF_CHAIN_OBJ_TREE: | |||||
if (WARN_ON(def->object_start.object_id != | |||||
def->chain_obj_tree->id)) | |||||
return -EINVAL; | |||||
cur_obj_key = uapi_key_obj(def->object_start.object_id); | |||||
rc = uapi_merge_obj_tree(uapi, def->chain_obj_tree, | |||||
is_driver); | |||||
if (rc) | |||||
return rc; | |||||
continue; | |||||
case UAPI_DEF_END: | |||||
return 0; | |||||
case UAPI_DEF_IS_SUPPORTED_DEV_FN: { | |||||
void **ibdev_fn = | |||||
(void *)((u8 *)ibdev + def->needs_fn_offset); | |||||
if (*ibdev_fn) | |||||
continue; | |||||
rc = uapi_disable_elm( | |||||
uapi, def, cur_obj_key, cur_method_key); | |||||
if (rc) | |||||
return rc; | |||||
continue; | |||||
} | |||||
case UAPI_DEF_IS_SUPPORTED_FUNC: | |||||
if (def->func_is_supported(ibdev)) | |||||
continue; | |||||
rc = uapi_disable_elm( | |||||
uapi, def, cur_obj_key, cur_method_key); | |||||
if (rc) | |||||
return rc; | |||||
continue; | |||||
case UAPI_DEF_OBJECT_START: { | |||||
struct uverbs_api_object *obj_elm; | |||||
cur_obj_key = uapi_key_obj(def->object_start.object_id); | |||||
obj_elm = uapi_add_get_elm(uapi, cur_obj_key, | |||||
sizeof(*obj_elm), &exists); | |||||
if (IS_ERR(obj_elm)) | |||||
return PTR_ERR(obj_elm); | |||||
continue; | |||||
} | |||||
case UAPI_DEF_WRITE: | |||||
rc = uapi_create_write( | |||||
uapi, ibdev, def, cur_obj_key, &cur_method_key); | |||||
if (rc) | |||||
return rc; | |||||
continue; | |||||
} | |||||
WARN_ON(true); | |||||
return -EINVAL; | |||||
} | |||||
} | |||||
static int | |||||
uapi_finalize_ioctl_method(struct uverbs_api *uapi, | |||||
struct uverbs_api_ioctl_method *method_elm, | |||||
u32 method_key) | |||||
{ | |||||
struct radix_tree_iter iter; | |||||
unsigned int num_attrs = 0; | |||||
unsigned int max_bkey = 0; | |||||
bool single_uobj = false; | |||||
void __rcu **slot; | |||||
method_elm->destroy_bkey = UVERBS_API_ATTR_BKEY_LEN; | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, | |||||
uapi_key_attrs_start(method_key)) { | |||||
struct uverbs_api_attr *elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
u32 attr_key = iter.index & UVERBS_API_ATTR_KEY_MASK; | |||||
u32 attr_bkey = uapi_bkey_attr(attr_key); | |||||
u8 type = elm->spec.type; | |||||
if (uapi_key_attr_to_ioctl_method(iter.index) != | |||||
uapi_key_attr_to_ioctl_method(method_key)) | |||||
break; | |||||
if (elm->spec.mandatory) | |||||
__set_bit(attr_bkey, method_elm->attr_mandatory); | |||||
if (elm->spec.is_udata) | |||||
method_elm->has_udata = true; | |||||
if (type == UVERBS_ATTR_TYPE_IDR || | |||||
type == UVERBS_ATTR_TYPE_FD) { | |||||
u8 access = elm->spec.u.obj.access; | |||||
/* | |||||
* Verbs specs may only have one NEW/DESTROY, we don't | |||||
* have the infrastructure to abort multiple NEW's or | |||||
* cope with multiple DESTROY failure. | |||||
*/ | |||||
if (access == UVERBS_ACCESS_NEW || | |||||
access == UVERBS_ACCESS_DESTROY) { | |||||
if (WARN_ON(single_uobj)) | |||||
return -EINVAL; | |||||
single_uobj = true; | |||||
if (WARN_ON(!elm->spec.mandatory)) | |||||
return -EINVAL; | |||||
} | |||||
if (access == UVERBS_ACCESS_DESTROY) | |||||
method_elm->destroy_bkey = attr_bkey; | |||||
} | |||||
max_bkey = max(max_bkey, attr_bkey); | |||||
num_attrs++; | |||||
} | |||||
method_elm->key_bitmap_len = max_bkey + 1; | |||||
WARN_ON(method_elm->key_bitmap_len > UVERBS_API_ATTR_BKEY_LEN); | |||||
uapi_compute_bundle_size(method_elm, num_attrs); | |||||
return 0; | |||||
} | |||||
static int uapi_finalize(struct uverbs_api *uapi) | |||||
{ | |||||
const struct uverbs_api_write_method **data; | |||||
unsigned long max_write_ex = 0; | |||||
unsigned long max_write = 0; | |||||
struct radix_tree_iter iter; | |||||
void __rcu **slot; | |||||
int rc; | |||||
int i; | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { | |||||
struct uverbs_api_ioctl_method *method_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (uapi_key_is_ioctl_method(iter.index)) { | |||||
rc = uapi_finalize_ioctl_method(uapi, method_elm, | |||||
iter.index); | |||||
if (rc) | |||||
return rc; | |||||
} | |||||
if (uapi_key_is_write_method(iter.index)) | |||||
max_write = max(max_write, | |||||
iter.index & UVERBS_API_ATTR_KEY_MASK); | |||||
if (uapi_key_is_write_ex_method(iter.index)) | |||||
max_write_ex = | |||||
max(max_write_ex, | |||||
iter.index & UVERBS_API_ATTR_KEY_MASK); | |||||
} | |||||
uapi->notsupp_method.handler = ib_uverbs_notsupp; | |||||
uapi->num_write = max_write + 1; | |||||
uapi->num_write_ex = max_write_ex + 1; | |||||
data = kmalloc_array(uapi->num_write + uapi->num_write_ex, | |||||
sizeof(*uapi->write_methods), GFP_KERNEL); | |||||
for (i = 0; i != uapi->num_write + uapi->num_write_ex; i++) | |||||
data[i] = &uapi->notsupp_method; | |||||
uapi->write_methods = data; | |||||
uapi->write_ex_methods = data + uapi->num_write; | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { | |||||
if (uapi_key_is_write_method(iter.index)) | |||||
uapi->write_methods[iter.index & | |||||
UVERBS_API_ATTR_KEY_MASK] = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (uapi_key_is_write_ex_method(iter.index)) | |||||
uapi->write_ex_methods[iter.index & | |||||
UVERBS_API_ATTR_KEY_MASK] = | |||||
rcu_dereference_protected(*slot, true); | |||||
} | |||||
return 0; | |||||
} | |||||
static void uapi_remove_range(struct uverbs_api *uapi, u32 start, u32 last) | |||||
{ | |||||
struct radix_tree_iter iter; | |||||
void __rcu **slot; | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, start) { | |||||
if (iter.index > last) | |||||
return; | |||||
kfree(rcu_dereference_protected(*slot, true)); | |||||
radix_tree_iter_delete(&uapi->radix, &iter, slot); | |||||
} | |||||
} | |||||
static void uapi_remove_object(struct uverbs_api *uapi, u32 obj_key) | |||||
{ | |||||
uapi_remove_range(uapi, obj_key, | |||||
obj_key | UVERBS_API_METHOD_KEY_MASK | | |||||
UVERBS_API_ATTR_KEY_MASK); | |||||
} | |||||
static void uapi_remove_method(struct uverbs_api *uapi, u32 method_key) | |||||
{ | |||||
uapi_remove_range(uapi, method_key, | |||||
method_key | UVERBS_API_ATTR_KEY_MASK); | |||||
} | |||||
static u32 uapi_get_obj_id(struct uverbs_attr_spec *spec) | |||||
{ | |||||
if (spec->type == UVERBS_ATTR_TYPE_IDR || | |||||
spec->type == UVERBS_ATTR_TYPE_FD) | |||||
return spec->u.obj.obj_type; | |||||
if (spec->type == UVERBS_ATTR_TYPE_IDRS_ARRAY) | |||||
return spec->u2.objs_arr.obj_type; | |||||
return UVERBS_API_KEY_ERR; | |||||
} | |||||
static void uapi_key_okay(u32 key) | |||||
{ | |||||
unsigned int count = 0; | |||||
if (uapi_key_is_object(key)) | |||||
count++; | |||||
if (uapi_key_is_ioctl_method(key)) | |||||
count++; | |||||
if (uapi_key_is_write_method(key)) | |||||
count++; | |||||
if (uapi_key_is_write_ex_method(key)) | |||||
count++; | |||||
if (uapi_key_is_attr(key)) | |||||
count++; | |||||
WARN(count != 1, "Bad count %d key=%x", count, key); | |||||
} | |||||
static void uapi_finalize_disable(struct uverbs_api *uapi) | |||||
{ | |||||
struct radix_tree_iter iter; | |||||
u32 starting_key = 0; | |||||
bool scan_again = false; | |||||
void __rcu **slot; | |||||
again: | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, starting_key) { | |||||
uapi_key_okay(iter.index); | |||||
if (uapi_key_is_object(iter.index)) { | |||||
struct uverbs_api_object *obj_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (obj_elm->disabled) { | |||||
/* Have to check all the attrs again */ | |||||
scan_again = true; | |||||
starting_key = iter.index; | |||||
uapi_remove_object(uapi, iter.index); | |||||
goto again; | |||||
} | |||||
continue; | |||||
} | |||||
if (uapi_key_is_ioctl_method(iter.index)) { | |||||
struct uverbs_api_ioctl_method *method_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (method_elm->disabled) { | |||||
starting_key = iter.index; | |||||
uapi_remove_method(uapi, iter.index); | |||||
goto again; | |||||
} | |||||
continue; | |||||
} | |||||
if (uapi_key_is_write_method(iter.index) || | |||||
uapi_key_is_write_ex_method(iter.index)) { | |||||
struct uverbs_api_write_method *method_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (method_elm->disabled) { | |||||
kfree(method_elm); | |||||
radix_tree_iter_delete(&uapi->radix, &iter, slot); | |||||
} | |||||
continue; | |||||
} | |||||
if (uapi_key_is_attr(iter.index)) { | |||||
struct uverbs_api_attr *attr_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
const struct uverbs_api_object *tmp_obj; | |||||
u32 obj_key; | |||||
/* | |||||
* If the method has a mandatory object handle | |||||
* attribute which relies on an object which is not | |||||
* present then the entire method is uncallable. | |||||
*/ | |||||
if (!attr_elm->spec.mandatory) | |||||
continue; | |||||
obj_key = uapi_get_obj_id(&attr_elm->spec); | |||||
if (obj_key == UVERBS_API_KEY_ERR) | |||||
continue; | |||||
tmp_obj = uapi_get_object(uapi, obj_key); | |||||
if (IS_ERR(tmp_obj)) { | |||||
if (PTR_ERR(tmp_obj) == -ENOMSG) | |||||
continue; | |||||
} else { | |||||
if (!tmp_obj->disabled) | |||||
continue; | |||||
} | |||||
starting_key = iter.index; | |||||
uapi_remove_method( | |||||
uapi, | |||||
iter.index & (UVERBS_API_OBJ_KEY_MASK | | |||||
UVERBS_API_METHOD_KEY_MASK)); | |||||
goto again; | |||||
} | |||||
WARN_ON(false); | |||||
} | |||||
if (!scan_again) | |||||
return; | |||||
scan_again = false; | |||||
starting_key = 0; | |||||
goto again; | |||||
} | |||||
void uverbs_destroy_api(struct uverbs_api *uapi) | |||||
{ | |||||
if (!uapi) | |||||
return; | |||||
uapi_remove_range(uapi, 0, U32_MAX); | |||||
kfree(uapi->write_methods); | |||||
kfree(uapi); | |||||
} | |||||
static const struct uapi_definition uverbs_core_api[] = { | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_async_fd), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_counters), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_cq), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_device), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_dm), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_flow_action), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_intf), | |||||
UAPI_DEF_CHAIN(uverbs_def_obj_mr), | |||||
UAPI_DEF_CHAIN(uverbs_def_write_intf), | |||||
{}, | |||||
}; | |||||
struct uverbs_api *uverbs_alloc_api(struct ib_device *ibdev) | |||||
{ | |||||
struct uverbs_api *uapi; | |||||
int rc; | |||||
uapi = kzalloc(sizeof(*uapi), GFP_KERNEL); | |||||
if (!uapi) | |||||
return ERR_PTR(-ENOMEM); | |||||
INIT_RADIX_TREE(&uapi->radix, GFP_KERNEL); | |||||
uapi->driver_id = ibdev->ops.driver_id; | |||||
rc = uapi_merge_def(uapi, ibdev, uverbs_core_api, false); | |||||
if (rc) | |||||
goto err; | |||||
rc = uapi_merge_def(uapi, ibdev, ibdev->driver_def, true); | |||||
if (rc) | |||||
goto err; | |||||
uapi_finalize_disable(uapi); | |||||
rc = uapi_finalize(uapi); | |||||
if (rc) | |||||
goto err; | |||||
return uapi; | |||||
err: | |||||
if (rc != -ENOMEM) | |||||
dev_err(&ibdev->dev, | |||||
"Setup of uverbs_api failed, kernel parsing tree description is not valid (%d)??\n", | |||||
rc); | |||||
uverbs_destroy_api(uapi); | |||||
return ERR_PTR(rc); | |||||
} | |||||
/* | |||||
* The pre version is done before destroying the HW objects, it only blocks | |||||
* off method access. All methods that require the ib_dev or the module data | |||||
* must test one of these assignments prior to continuing. | |||||
*/ | |||||
void uverbs_disassociate_api_pre(struct ib_uverbs_device *uverbs_dev) | |||||
{ | |||||
struct uverbs_api *uapi = uverbs_dev->uapi; | |||||
struct radix_tree_iter iter; | |||||
void __rcu **slot; | |||||
rcu_assign_pointer(uverbs_dev->ib_dev, NULL); | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { | |||||
if (uapi_key_is_ioctl_method(iter.index)) { | |||||
struct uverbs_api_ioctl_method *method_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (method_elm->driver_method) | |||||
rcu_assign_pointer(method_elm->handler, NULL); | |||||
} | |||||
} | |||||
synchronize_srcu(&uverbs_dev->disassociate_srcu); | |||||
} | |||||
/* | |||||
* Called when a driver disassociates from the ib_uverbs_device. The | |||||
* assumption is that the driver module will unload after. Replace everything | |||||
* related to the driver with NULL as a safety measure. | |||||
*/ | |||||
void uverbs_disassociate_api(struct uverbs_api *uapi) | |||||
{ | |||||
struct radix_tree_iter iter; | |||||
void __rcu **slot; | |||||
radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { | |||||
if (uapi_key_is_object(iter.index)) { | |||||
struct uverbs_api_object *object_elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
/* | |||||
* Some type_attrs are in the driver module. We don't | |||||
* bother to keep track of which since there should be | |||||
* no use of this after disassociate. | |||||
*/ | |||||
object_elm->type_attrs = NULL; | |||||
} else if (uapi_key_is_attr(iter.index)) { | |||||
struct uverbs_api_attr *elm = | |||||
rcu_dereference_protected(*slot, true); | |||||
if (elm->spec.type == UVERBS_ATTR_TYPE_ENUM_IN) | |||||
elm->spec.u2.enum_def.ids = NULL; | |||||
} | |||||
} | |||||
} |