1 | // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB |
2 | /* |
3 | * Copyright (c) 2017, Mellanox Technologies inc. All rights reserved. |
4 | */ |
5 | #include <rdma/uverbs_ioctl.h> |
6 | #include <rdma/rdma_user_ioctl.h> |
7 | #include <linux/bitops.h> |
8 | #include "rdma_core.h" |
9 | #include "uverbs.h" |
10 | |
11 | static int ib_uverbs_notsupp(struct uverbs_attr_bundle *attrs) |
12 | { |
13 | return -EOPNOTSUPP; |
14 | } |
15 | |
16 | static void *uapi_add_elm(struct uverbs_api *uapi, u32 key, size_t alloc_size) |
17 | { |
18 | void *elm; |
19 | int rc; |
20 | |
21 | if (key == UVERBS_API_KEY_ERR) |
22 | return ERR_PTR(error: -EOVERFLOW); |
23 | |
24 | elm = kzalloc(size: alloc_size, GFP_KERNEL); |
25 | if (!elm) |
26 | return ERR_PTR(error: -ENOMEM); |
27 | rc = radix_tree_insert(&uapi->radix, index: key, elm); |
28 | if (rc) { |
29 | kfree(objp: elm); |
30 | return ERR_PTR(error: rc); |
31 | } |
32 | |
33 | return elm; |
34 | } |
35 | |
36 | static void *uapi_add_get_elm(struct uverbs_api *uapi, u32 key, |
37 | size_t alloc_size, bool *exists) |
38 | { |
39 | void *elm; |
40 | |
41 | elm = uapi_add_elm(uapi, key, alloc_size); |
42 | if (!IS_ERR(ptr: elm)) { |
43 | *exists = false; |
44 | return elm; |
45 | } |
46 | |
47 | if (elm != ERR_PTR(error: -EEXIST)) |
48 | return elm; |
49 | |
50 | elm = radix_tree_lookup(&uapi->radix, key); |
51 | if (WARN_ON(!elm)) |
52 | return ERR_PTR(error: -EINVAL); |
53 | *exists = true; |
54 | return elm; |
55 | } |
56 | |
57 | static int uapi_create_write(struct uverbs_api *uapi, |
58 | struct ib_device *ibdev, |
59 | const struct uapi_definition *def, |
60 | u32 obj_key, |
61 | u32 *cur_method_key) |
62 | { |
63 | struct uverbs_api_write_method *method_elm; |
64 | u32 method_key = obj_key; |
65 | bool exists; |
66 | |
67 | if (def->write.is_ex) |
68 | method_key |= uapi_key_write_ex_method(id: def->write.command_num); |
69 | else |
70 | method_key |= uapi_key_write_method(id: def->write.command_num); |
71 | |
72 | method_elm = uapi_add_get_elm(uapi, key: method_key, alloc_size: sizeof(*method_elm), |
73 | exists: &exists); |
74 | if (IS_ERR(ptr: method_elm)) |
75 | return PTR_ERR(ptr: method_elm); |
76 | |
77 | if (WARN_ON(exists && (def->write.is_ex != method_elm->is_ex))) |
78 | return -EINVAL; |
79 | |
80 | method_elm->is_ex = def->write.is_ex; |
81 | method_elm->handler = def->func_write; |
82 | if (!def->write.is_ex) |
83 | method_elm->disabled = !(ibdev->uverbs_cmd_mask & |
84 | BIT_ULL(def->write.command_num)); |
85 | |
86 | if (!def->write.is_ex && def->func_write) { |
87 | method_elm->has_udata = def->write.has_udata; |
88 | method_elm->has_resp = def->write.has_resp; |
89 | method_elm->req_size = def->write.req_size; |
90 | method_elm->resp_size = def->write.resp_size; |
91 | } |
92 | |
93 | *cur_method_key = method_key; |
94 | return 0; |
95 | } |
96 | |
97 | static int uapi_merge_method(struct uverbs_api *uapi, |
98 | struct uverbs_api_object *obj_elm, u32 obj_key, |
99 | const struct uverbs_method_def *method, |
100 | bool is_driver) |
101 | { |
102 | u32 method_key = obj_key | uapi_key_ioctl_method(id: method->id); |
103 | struct uverbs_api_ioctl_method *method_elm; |
104 | unsigned int i; |
105 | bool exists; |
106 | |
107 | if (!method->attrs) |
108 | return 0; |
109 | |
110 | method_elm = uapi_add_get_elm(uapi, key: method_key, alloc_size: sizeof(*method_elm), |
111 | exists: &exists); |
112 | if (IS_ERR(ptr: method_elm)) |
113 | return PTR_ERR(ptr: method_elm); |
114 | if (exists) { |
115 | /* |
116 | * This occurs when a driver uses ADD_UVERBS_ATTRIBUTES_SIMPLE |
117 | */ |
118 | if (WARN_ON(method->handler)) |
119 | return -EINVAL; |
120 | } else { |
121 | WARN_ON(!method->handler); |
122 | rcu_assign_pointer(method_elm->handler, method->handler); |
123 | if (method->handler != uverbs_destroy_def_handler) |
124 | method_elm->driver_method = is_driver; |
125 | } |
126 | |
127 | for (i = 0; i != method->num_attrs; i++) { |
128 | const struct uverbs_attr_def *attr = (*method->attrs)[i]; |
129 | struct uverbs_api_attr *attr_slot; |
130 | |
131 | if (!attr) |
132 | continue; |
133 | |
134 | /* |
135 | * ENUM_IN contains the 'ids' pointer to the driver's .rodata, |
136 | * so if it is specified by a driver then it always makes this |
137 | * into a driver method. |
138 | */ |
139 | if (attr->attr.type == UVERBS_ATTR_TYPE_ENUM_IN) |
140 | method_elm->driver_method |= is_driver; |
141 | |
142 | /* |
143 | * Like other uobject based things we only support a single |
144 | * uobject being NEW'd or DESTROY'd |
145 | */ |
146 | if (attr->attr.type == UVERBS_ATTR_TYPE_IDRS_ARRAY) { |
147 | u8 access = attr->attr.u2.objs_arr.access; |
148 | |
149 | if (WARN_ON(access == UVERBS_ACCESS_NEW || |
150 | access == UVERBS_ACCESS_DESTROY)) |
151 | return -EINVAL; |
152 | } |
153 | |
154 | attr_slot = |
155 | uapi_add_elm(uapi, key: method_key | uapi_key_attr(id: attr->id), |
156 | alloc_size: sizeof(*attr_slot)); |
157 | /* Attributes are not allowed to be modified by drivers */ |
158 | if (IS_ERR(ptr: attr_slot)) |
159 | return PTR_ERR(ptr: attr_slot); |
160 | |
161 | attr_slot->spec = attr->attr; |
162 | } |
163 | |
164 | return 0; |
165 | } |
166 | |
167 | static int uapi_merge_obj_tree(struct uverbs_api *uapi, |
168 | const struct uverbs_object_def *obj, |
169 | bool is_driver) |
170 | { |
171 | struct uverbs_api_object *obj_elm; |
172 | unsigned int i; |
173 | u32 obj_key; |
174 | bool exists; |
175 | int rc; |
176 | |
177 | obj_key = uapi_key_obj(id: obj->id); |
178 | obj_elm = uapi_add_get_elm(uapi, key: obj_key, alloc_size: sizeof(*obj_elm), exists: &exists); |
179 | if (IS_ERR(ptr: obj_elm)) |
180 | return PTR_ERR(ptr: obj_elm); |
181 | |
182 | if (obj->type_attrs) { |
183 | if (WARN_ON(obj_elm->type_attrs)) |
184 | return -EINVAL; |
185 | |
186 | obj_elm->id = obj->id; |
187 | obj_elm->type_attrs = obj->type_attrs; |
188 | obj_elm->type_class = obj->type_attrs->type_class; |
189 | /* |
190 | * Today drivers are only permitted to use idr_class and |
191 | * fd_class types. We can revoke the IDR types during |
192 | * disassociation, and the FD types require the driver to use |
193 | * struct file_operations.owner to prevent the driver module |
194 | * code from unloading while the file is open. This provides |
195 | * enough safety that uverbs_uobject_fd_release() will |
196 | * continue to work. Drivers using FD are responsible to |
197 | * handle disassociation of the device on their own. |
198 | */ |
199 | if (WARN_ON(is_driver && |
200 | obj->type_attrs->type_class != &uverbs_idr_class && |
201 | obj->type_attrs->type_class != &uverbs_fd_class)) |
202 | return -EINVAL; |
203 | } |
204 | |
205 | if (!obj->methods) |
206 | return 0; |
207 | |
208 | for (i = 0; i != obj->num_methods; i++) { |
209 | const struct uverbs_method_def *method = (*obj->methods)[i]; |
210 | |
211 | if (!method) |
212 | continue; |
213 | |
214 | rc = uapi_merge_method(uapi, obj_elm, obj_key, method, |
215 | is_driver); |
216 | if (rc) |
217 | return rc; |
218 | } |
219 | |
220 | return 0; |
221 | } |
222 | |
223 | static int uapi_disable_elm(struct uverbs_api *uapi, |
224 | const struct uapi_definition *def, |
225 | u32 obj_key, |
226 | u32 method_key) |
227 | { |
228 | bool exists; |
229 | |
230 | if (def->scope == UAPI_SCOPE_OBJECT) { |
231 | struct uverbs_api_object *obj_elm; |
232 | |
233 | obj_elm = uapi_add_get_elm( |
234 | uapi, key: obj_key, alloc_size: sizeof(*obj_elm), exists: &exists); |
235 | if (IS_ERR(ptr: obj_elm)) |
236 | return PTR_ERR(ptr: obj_elm); |
237 | obj_elm->disabled = 1; |
238 | return 0; |
239 | } |
240 | |
241 | if (def->scope == UAPI_SCOPE_METHOD && |
242 | uapi_key_is_ioctl_method(key: method_key)) { |
243 | struct uverbs_api_ioctl_method *method_elm; |
244 | |
245 | method_elm = uapi_add_get_elm(uapi, key: method_key, |
246 | alloc_size: sizeof(*method_elm), exists: &exists); |
247 | if (IS_ERR(ptr: method_elm)) |
248 | return PTR_ERR(ptr: method_elm); |
249 | method_elm->disabled = 1; |
250 | return 0; |
251 | } |
252 | |
253 | if (def->scope == UAPI_SCOPE_METHOD && |
254 | (uapi_key_is_write_method(key: method_key) || |
255 | uapi_key_is_write_ex_method(key: method_key))) { |
256 | struct uverbs_api_write_method *write_elm; |
257 | |
258 | write_elm = uapi_add_get_elm(uapi, key: method_key, |
259 | alloc_size: sizeof(*write_elm), exists: &exists); |
260 | if (IS_ERR(ptr: write_elm)) |
261 | return PTR_ERR(ptr: write_elm); |
262 | write_elm->disabled = 1; |
263 | return 0; |
264 | } |
265 | |
266 | WARN_ON(true); |
267 | return -EINVAL; |
268 | } |
269 | |
270 | static int uapi_merge_def(struct uverbs_api *uapi, struct ib_device *ibdev, |
271 | const struct uapi_definition *def_list, |
272 | bool is_driver) |
273 | { |
274 | const struct uapi_definition *def = def_list; |
275 | u32 cur_obj_key = UVERBS_API_KEY_ERR; |
276 | u32 cur_method_key = UVERBS_API_KEY_ERR; |
277 | bool exists; |
278 | int rc; |
279 | |
280 | if (!def_list) |
281 | return 0; |
282 | |
283 | for (;; def++) { |
284 | switch ((enum uapi_definition_kind)def->kind) { |
285 | case UAPI_DEF_CHAIN: |
286 | rc = uapi_merge_def(uapi, ibdev, def_list: def->chain, is_driver); |
287 | if (rc) |
288 | return rc; |
289 | continue; |
290 | |
291 | case UAPI_DEF_CHAIN_OBJ_TREE: |
292 | if (WARN_ON(def->object_start.object_id != |
293 | def->chain_obj_tree->id)) |
294 | return -EINVAL; |
295 | |
296 | cur_obj_key = uapi_key_obj(id: def->object_start.object_id); |
297 | rc = uapi_merge_obj_tree(uapi, obj: def->chain_obj_tree, |
298 | is_driver); |
299 | if (rc) |
300 | return rc; |
301 | continue; |
302 | |
303 | case UAPI_DEF_END: |
304 | return 0; |
305 | |
306 | case UAPI_DEF_IS_SUPPORTED_DEV_FN: { |
307 | void **ibdev_fn = |
308 | (void *)(&ibdev->ops) + def->needs_fn_offset; |
309 | |
310 | if (*ibdev_fn) |
311 | continue; |
312 | rc = uapi_disable_elm( |
313 | uapi, def, obj_key: cur_obj_key, method_key: cur_method_key); |
314 | if (rc) |
315 | return rc; |
316 | continue; |
317 | } |
318 | |
319 | case UAPI_DEF_IS_SUPPORTED_FUNC: |
320 | if (def->func_is_supported(ibdev)) |
321 | continue; |
322 | rc = uapi_disable_elm( |
323 | uapi, def, obj_key: cur_obj_key, method_key: cur_method_key); |
324 | if (rc) |
325 | return rc; |
326 | continue; |
327 | |
328 | case UAPI_DEF_OBJECT_START: { |
329 | struct uverbs_api_object *obj_elm; |
330 | |
331 | cur_obj_key = uapi_key_obj(id: def->object_start.object_id); |
332 | obj_elm = uapi_add_get_elm(uapi, key: cur_obj_key, |
333 | alloc_size: sizeof(*obj_elm), exists: &exists); |
334 | if (IS_ERR(ptr: obj_elm)) |
335 | return PTR_ERR(ptr: obj_elm); |
336 | continue; |
337 | } |
338 | |
339 | case UAPI_DEF_WRITE: |
340 | rc = uapi_create_write( |
341 | uapi, ibdev, def, obj_key: cur_obj_key, cur_method_key: &cur_method_key); |
342 | if (rc) |
343 | return rc; |
344 | continue; |
345 | } |
346 | WARN_ON(true); |
347 | return -EINVAL; |
348 | } |
349 | } |
350 | |
351 | static int |
352 | uapi_finalize_ioctl_method(struct uverbs_api *uapi, |
353 | struct uverbs_api_ioctl_method *method_elm, |
354 | u32 method_key) |
355 | { |
356 | struct radix_tree_iter iter; |
357 | unsigned int num_attrs = 0; |
358 | unsigned int max_bkey = 0; |
359 | bool single_uobj = false; |
360 | void __rcu **slot; |
361 | |
362 | method_elm->destroy_bkey = UVERBS_API_ATTR_BKEY_LEN; |
363 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, |
364 | uapi_key_attrs_start(method_key)) { |
365 | struct uverbs_api_attr *elm = |
366 | rcu_dereference_protected(*slot, true); |
367 | u32 attr_key = iter.index & UVERBS_API_ATTR_KEY_MASK; |
368 | u32 attr_bkey = uapi_bkey_attr(attr_key); |
369 | u8 type = elm->spec.type; |
370 | |
371 | if (uapi_key_attr_to_ioctl_method(attr_key: iter.index) != |
372 | uapi_key_attr_to_ioctl_method(attr_key: method_key)) |
373 | break; |
374 | |
375 | if (elm->spec.mandatory) |
376 | __set_bit(attr_bkey, method_elm->attr_mandatory); |
377 | |
378 | if (elm->spec.is_udata) |
379 | method_elm->has_udata = true; |
380 | |
381 | if (type == UVERBS_ATTR_TYPE_IDR || |
382 | type == UVERBS_ATTR_TYPE_FD) { |
383 | u8 access = elm->spec.u.obj.access; |
384 | |
385 | /* |
386 | * Verbs specs may only have one NEW/DESTROY, we don't |
387 | * have the infrastructure to abort multiple NEW's or |
388 | * cope with multiple DESTROY failure. |
389 | */ |
390 | if (access == UVERBS_ACCESS_NEW || |
391 | access == UVERBS_ACCESS_DESTROY) { |
392 | if (WARN_ON(single_uobj)) |
393 | return -EINVAL; |
394 | |
395 | single_uobj = true; |
396 | if (WARN_ON(!elm->spec.mandatory)) |
397 | return -EINVAL; |
398 | } |
399 | |
400 | if (access == UVERBS_ACCESS_DESTROY) |
401 | method_elm->destroy_bkey = attr_bkey; |
402 | } |
403 | |
404 | max_bkey = max(max_bkey, attr_bkey); |
405 | num_attrs++; |
406 | } |
407 | |
408 | method_elm->key_bitmap_len = max_bkey + 1; |
409 | WARN_ON(method_elm->key_bitmap_len > UVERBS_API_ATTR_BKEY_LEN); |
410 | |
411 | uapi_compute_bundle_size(method_elm, num_attrs); |
412 | return 0; |
413 | } |
414 | |
415 | static int uapi_finalize(struct uverbs_api *uapi) |
416 | { |
417 | const struct uverbs_api_write_method **data; |
418 | unsigned long max_write_ex = 0; |
419 | unsigned long max_write = 0; |
420 | struct radix_tree_iter iter; |
421 | void __rcu **slot; |
422 | int rc; |
423 | int i; |
424 | |
425 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { |
426 | struct uverbs_api_ioctl_method *method_elm = |
427 | rcu_dereference_protected(*slot, true); |
428 | |
429 | if (uapi_key_is_ioctl_method(key: iter.index)) { |
430 | rc = uapi_finalize_ioctl_method(uapi, method_elm, |
431 | method_key: iter.index); |
432 | if (rc) |
433 | return rc; |
434 | } |
435 | |
436 | if (uapi_key_is_write_method(key: iter.index)) |
437 | max_write = max(max_write, |
438 | iter.index & UVERBS_API_ATTR_KEY_MASK); |
439 | if (uapi_key_is_write_ex_method(key: iter.index)) |
440 | max_write_ex = |
441 | max(max_write_ex, |
442 | iter.index & UVERBS_API_ATTR_KEY_MASK); |
443 | } |
444 | |
445 | uapi->notsupp_method.handler = ib_uverbs_notsupp; |
446 | uapi->num_write = max_write + 1; |
447 | uapi->num_write_ex = max_write_ex + 1; |
448 | data = kmalloc_array(n: uapi->num_write + uapi->num_write_ex, |
449 | size: sizeof(*uapi->write_methods), GFP_KERNEL); |
450 | if (!data) |
451 | return -ENOMEM; |
452 | |
453 | for (i = 0; i != uapi->num_write + uapi->num_write_ex; i++) |
454 | data[i] = &uapi->notsupp_method; |
455 | uapi->write_methods = data; |
456 | uapi->write_ex_methods = data + uapi->num_write; |
457 | |
458 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { |
459 | if (uapi_key_is_write_method(key: iter.index)) |
460 | uapi->write_methods[iter.index & |
461 | UVERBS_API_ATTR_KEY_MASK] = |
462 | rcu_dereference_protected(*slot, true); |
463 | if (uapi_key_is_write_ex_method(key: iter.index)) |
464 | uapi->write_ex_methods[iter.index & |
465 | UVERBS_API_ATTR_KEY_MASK] = |
466 | rcu_dereference_protected(*slot, true); |
467 | } |
468 | |
469 | return 0; |
470 | } |
471 | |
472 | static void uapi_remove_range(struct uverbs_api *uapi, u32 start, u32 last) |
473 | { |
474 | struct radix_tree_iter iter; |
475 | void __rcu **slot; |
476 | |
477 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, start) { |
478 | if (iter.index > last) |
479 | return; |
480 | kfree(rcu_dereference_protected(*slot, true)); |
481 | radix_tree_iter_delete(&uapi->radix, iter: &iter, slot); |
482 | } |
483 | } |
484 | |
485 | static void uapi_remove_object(struct uverbs_api *uapi, u32 obj_key) |
486 | { |
487 | uapi_remove_range(uapi, start: obj_key, |
488 | last: obj_key | UVERBS_API_METHOD_KEY_MASK | |
489 | UVERBS_API_ATTR_KEY_MASK); |
490 | } |
491 | |
492 | static void uapi_remove_method(struct uverbs_api *uapi, u32 method_key) |
493 | { |
494 | uapi_remove_range(uapi, start: method_key, |
495 | last: method_key | UVERBS_API_ATTR_KEY_MASK); |
496 | } |
497 | |
498 | |
499 | static u32 uapi_get_obj_id(struct uverbs_attr_spec *spec) |
500 | { |
501 | if (spec->type == UVERBS_ATTR_TYPE_IDR || |
502 | spec->type == UVERBS_ATTR_TYPE_FD) |
503 | return spec->u.obj.obj_type; |
504 | if (spec->type == UVERBS_ATTR_TYPE_IDRS_ARRAY) |
505 | return spec->u2.objs_arr.obj_type; |
506 | return UVERBS_API_KEY_ERR; |
507 | } |
508 | |
509 | static void uapi_key_okay(u32 key) |
510 | { |
511 | unsigned int count = 0; |
512 | |
513 | if (uapi_key_is_object(key)) |
514 | count++; |
515 | if (uapi_key_is_ioctl_method(key)) |
516 | count++; |
517 | if (uapi_key_is_write_method(key)) |
518 | count++; |
519 | if (uapi_key_is_write_ex_method(key)) |
520 | count++; |
521 | if (uapi_key_is_attr(key)) |
522 | count++; |
523 | WARN(count != 1, "Bad count %u key=%x" , count, key); |
524 | } |
525 | |
526 | static void uapi_finalize_disable(struct uverbs_api *uapi) |
527 | { |
528 | struct radix_tree_iter iter; |
529 | u32 starting_key = 0; |
530 | bool scan_again = false; |
531 | void __rcu **slot; |
532 | |
533 | again: |
534 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, starting_key) { |
535 | uapi_key_okay(key: iter.index); |
536 | |
537 | if (uapi_key_is_object(key: iter.index)) { |
538 | struct uverbs_api_object *obj_elm = |
539 | rcu_dereference_protected(*slot, true); |
540 | |
541 | if (obj_elm->disabled) { |
542 | /* Have to check all the attrs again */ |
543 | scan_again = true; |
544 | starting_key = iter.index; |
545 | uapi_remove_object(uapi, obj_key: iter.index); |
546 | goto again; |
547 | } |
548 | continue; |
549 | } |
550 | |
551 | if (uapi_key_is_ioctl_method(key: iter.index)) { |
552 | struct uverbs_api_ioctl_method *method_elm = |
553 | rcu_dereference_protected(*slot, true); |
554 | |
555 | if (method_elm->disabled) { |
556 | starting_key = iter.index; |
557 | uapi_remove_method(uapi, method_key: iter.index); |
558 | goto again; |
559 | } |
560 | continue; |
561 | } |
562 | |
563 | if (uapi_key_is_write_method(key: iter.index) || |
564 | uapi_key_is_write_ex_method(key: iter.index)) { |
565 | struct uverbs_api_write_method *method_elm = |
566 | rcu_dereference_protected(*slot, true); |
567 | |
568 | if (method_elm->disabled) { |
569 | kfree(objp: method_elm); |
570 | radix_tree_iter_delete(&uapi->radix, iter: &iter, slot); |
571 | } |
572 | continue; |
573 | } |
574 | |
575 | if (uapi_key_is_attr(key: iter.index)) { |
576 | struct uverbs_api_attr *attr_elm = |
577 | rcu_dereference_protected(*slot, true); |
578 | const struct uverbs_api_object *tmp_obj; |
579 | u32 obj_key; |
580 | |
581 | /* |
582 | * If the method has a mandatory object handle |
583 | * attribute which relies on an object which is not |
584 | * present then the entire method is uncallable. |
585 | */ |
586 | if (!attr_elm->spec.mandatory) |
587 | continue; |
588 | obj_key = uapi_get_obj_id(spec: &attr_elm->spec); |
589 | if (obj_key == UVERBS_API_KEY_ERR) |
590 | continue; |
591 | tmp_obj = uapi_get_object(uapi, object_id: obj_key); |
592 | if (IS_ERR(ptr: tmp_obj)) { |
593 | if (PTR_ERR(ptr: tmp_obj) == -ENOMSG) |
594 | continue; |
595 | } else { |
596 | if (!tmp_obj->disabled) |
597 | continue; |
598 | } |
599 | |
600 | starting_key = iter.index; |
601 | uapi_remove_method( |
602 | uapi, |
603 | method_key: iter.index & (UVERBS_API_OBJ_KEY_MASK | |
604 | UVERBS_API_METHOD_KEY_MASK)); |
605 | goto again; |
606 | } |
607 | |
608 | WARN_ON(false); |
609 | } |
610 | |
611 | if (!scan_again) |
612 | return; |
613 | scan_again = false; |
614 | starting_key = 0; |
615 | goto again; |
616 | } |
617 | |
618 | void uverbs_destroy_api(struct uverbs_api *uapi) |
619 | { |
620 | if (!uapi) |
621 | return; |
622 | |
623 | uapi_remove_range(uapi, start: 0, U32_MAX); |
624 | kfree(objp: uapi->write_methods); |
625 | kfree(objp: uapi); |
626 | } |
627 | |
628 | static const struct uapi_definition uverbs_core_api[] = { |
629 | UAPI_DEF_CHAIN(uverbs_def_obj_async_fd), |
630 | UAPI_DEF_CHAIN(uverbs_def_obj_counters), |
631 | UAPI_DEF_CHAIN(uverbs_def_obj_cq), |
632 | UAPI_DEF_CHAIN(uverbs_def_obj_device), |
633 | UAPI_DEF_CHAIN(uverbs_def_obj_dm), |
634 | UAPI_DEF_CHAIN(uverbs_def_obj_flow_action), |
635 | UAPI_DEF_CHAIN(uverbs_def_obj_intf), |
636 | UAPI_DEF_CHAIN(uverbs_def_obj_mr), |
637 | UAPI_DEF_CHAIN(uverbs_def_obj_qp), |
638 | UAPI_DEF_CHAIN(uverbs_def_obj_srq), |
639 | UAPI_DEF_CHAIN(uverbs_def_obj_wq), |
640 | UAPI_DEF_CHAIN(uverbs_def_write_intf), |
641 | {}, |
642 | }; |
643 | |
644 | struct uverbs_api *uverbs_alloc_api(struct ib_device *ibdev) |
645 | { |
646 | struct uverbs_api *uapi; |
647 | int rc; |
648 | |
649 | uapi = kzalloc(size: sizeof(*uapi), GFP_KERNEL); |
650 | if (!uapi) |
651 | return ERR_PTR(error: -ENOMEM); |
652 | |
653 | INIT_RADIX_TREE(&uapi->radix, GFP_KERNEL); |
654 | uapi->driver_id = ibdev->ops.driver_id; |
655 | |
656 | rc = uapi_merge_def(uapi, ibdev, def_list: uverbs_core_api, is_driver: false); |
657 | if (rc) |
658 | goto err; |
659 | rc = uapi_merge_def(uapi, ibdev, def_list: ibdev->driver_def, is_driver: true); |
660 | if (rc) |
661 | goto err; |
662 | |
663 | uapi_finalize_disable(uapi); |
664 | rc = uapi_finalize(uapi); |
665 | if (rc) |
666 | goto err; |
667 | |
668 | return uapi; |
669 | err: |
670 | if (rc != -ENOMEM) |
671 | dev_err(&ibdev->dev, |
672 | "Setup of uverbs_api failed, kernel parsing tree description is not valid (%d)??\n" , |
673 | rc); |
674 | |
675 | uverbs_destroy_api(uapi); |
676 | return ERR_PTR(error: rc); |
677 | } |
678 | |
679 | /* |
680 | * The pre version is done before destroying the HW objects, it only blocks |
681 | * off method access. All methods that require the ib_dev or the module data |
682 | * must test one of these assignments prior to continuing. |
683 | */ |
684 | void uverbs_disassociate_api_pre(struct ib_uverbs_device *uverbs_dev) |
685 | { |
686 | struct uverbs_api *uapi = uverbs_dev->uapi; |
687 | struct radix_tree_iter iter; |
688 | void __rcu **slot; |
689 | |
690 | rcu_assign_pointer(uverbs_dev->ib_dev, NULL); |
691 | |
692 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { |
693 | if (uapi_key_is_ioctl_method(key: iter.index)) { |
694 | struct uverbs_api_ioctl_method *method_elm = |
695 | rcu_dereference_protected(*slot, true); |
696 | |
697 | if (method_elm->driver_method) |
698 | rcu_assign_pointer(method_elm->handler, NULL); |
699 | } |
700 | } |
701 | |
702 | synchronize_srcu(ssp: &uverbs_dev->disassociate_srcu); |
703 | } |
704 | |
705 | /* |
706 | * Called when a driver disassociates from the ib_uverbs_device. The |
707 | * assumption is that the driver module will unload after. Replace everything |
708 | * related to the driver with NULL as a safety measure. |
709 | */ |
710 | void uverbs_disassociate_api(struct uverbs_api *uapi) |
711 | { |
712 | struct radix_tree_iter iter; |
713 | void __rcu **slot; |
714 | |
715 | radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) { |
716 | if (uapi_key_is_object(key: iter.index)) { |
717 | struct uverbs_api_object *object_elm = |
718 | rcu_dereference_protected(*slot, true); |
719 | |
720 | /* |
721 | * Some type_attrs are in the driver module. We don't |
722 | * bother to keep track of which since there should be |
723 | * no use of this after disassociate. |
724 | */ |
725 | object_elm->type_attrs = NULL; |
726 | } else if (uapi_key_is_attr(key: iter.index)) { |
727 | struct uverbs_api_attr *elm = |
728 | rcu_dereference_protected(*slot, true); |
729 | |
730 | if (elm->spec.type == UVERBS_ATTR_TYPE_ENUM_IN) |
731 | elm->spec.u2.enum_def.ids = NULL; |
732 | } |
733 | } |
734 | } |
735 | |