]> Git Repo - linux.git/blob - drivers/infiniband/core/device.c
dma-mapping: don't return errors from dma_set_max_seg_size
[linux.git] / drivers / infiniband / core / device.c
1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/module.h>
35 #include <linux/string.h>
36 #include <linux/errno.h>
37 #include <linux/kernel.h>
38 #include <linux/slab.h>
39 #include <linux/init.h>
40 #include <linux/netdevice.h>
41 #include <net/net_namespace.h>
42 #include <linux/security.h>
43 #include <linux/notifier.h>
44 #include <linux/hashtable.h>
45 #include <rdma/rdma_netlink.h>
46 #include <rdma/ib_addr.h>
47 #include <rdma/ib_cache.h>
48 #include <rdma/rdma_counter.h>
49
50 #include "core_priv.h"
51 #include "restrack.h"
52
53 MODULE_AUTHOR("Roland Dreier");
54 MODULE_DESCRIPTION("core kernel InfiniBand API");
55 MODULE_LICENSE("Dual BSD/GPL");
56
57 struct workqueue_struct *ib_comp_wq;
58 struct workqueue_struct *ib_comp_unbound_wq;
59 struct workqueue_struct *ib_wq;
60 EXPORT_SYMBOL_GPL(ib_wq);
61 static struct workqueue_struct *ib_unreg_wq;
62
63 /*
64  * Each of the three rwsem locks (devices, clients, client_data) protects the
65  * xarray of the same name. Specifically it allows the caller to assert that
66  * the MARK will/will not be changing under the lock, and for devices and
67  * clients, that the value in the xarray is still a valid pointer. Change of
68  * the MARK is linked to the object state, so holding the lock and testing the
69  * MARK also asserts that the contained object is in a certain state.
70  *
71  * This is used to build a two stage register/unregister flow where objects
72  * can continue to be in the xarray even though they are still in progress to
73  * register/unregister.
74  *
75  * The xarray itself provides additional locking, and restartable iteration,
76  * which is also relied on.
77  *
78  * Locks should not be nested, with the exception of client_data, which is
79  * allowed to nest under the read side of the other two locks.
80  *
81  * The devices_rwsem also protects the device name list, any change or
82  * assignment of device name must also hold the write side to guarantee unique
83  * names.
84  */
85
86 /*
87  * devices contains devices that have had their names assigned. The
88  * devices may not be registered. Users that care about the registration
89  * status need to call ib_device_try_get() on the device to ensure it is
90  * registered, and keep it registered, for the required duration.
91  *
92  */
93 static DEFINE_XARRAY_FLAGS(devices, XA_FLAGS_ALLOC);
94 static DECLARE_RWSEM(devices_rwsem);
95 #define DEVICE_REGISTERED XA_MARK_1
96
97 static u32 highest_client_id;
98 #define CLIENT_REGISTERED XA_MARK_1
99 static DEFINE_XARRAY_FLAGS(clients, XA_FLAGS_ALLOC);
100 static DECLARE_RWSEM(clients_rwsem);
101
102 static void ib_client_put(struct ib_client *client)
103 {
104         if (refcount_dec_and_test(&client->uses))
105                 complete(&client->uses_zero);
106 }
107
108 /*
109  * If client_data is registered then the corresponding client must also still
110  * be registered.
111  */
112 #define CLIENT_DATA_REGISTERED XA_MARK_1
113
114 unsigned int rdma_dev_net_id;
115
116 /*
117  * A list of net namespaces is maintained in an xarray. This is necessary
118  * because we can't get the locking right using the existing net ns list. We
119  * would require a init_net callback after the list is updated.
120  */
121 static DEFINE_XARRAY_FLAGS(rdma_nets, XA_FLAGS_ALLOC);
122 /*
123  * rwsem to protect accessing the rdma_nets xarray entries.
124  */
125 static DECLARE_RWSEM(rdma_nets_rwsem);
126
127 bool ib_devices_shared_netns = true;
128 module_param_named(netns_mode, ib_devices_shared_netns, bool, 0444);
129 MODULE_PARM_DESC(netns_mode,
130                  "Share device among net namespaces; default=1 (shared)");
131 /**
132  * rdma_dev_access_netns() - Return whether an rdma device can be accessed
133  *                           from a specified net namespace or not.
134  * @dev:        Pointer to rdma device which needs to be checked
135  * @net:        Pointer to net namesapce for which access to be checked
136  *
137  * When the rdma device is in shared mode, it ignores the net namespace.
138  * When the rdma device is exclusive to a net namespace, rdma device net
139  * namespace is checked against the specified one.
140  */
141 bool rdma_dev_access_netns(const struct ib_device *dev, const struct net *net)
142 {
143         return (ib_devices_shared_netns ||
144                 net_eq(read_pnet(&dev->coredev.rdma_net), net));
145 }
146 EXPORT_SYMBOL(rdma_dev_access_netns);
147
148 /*
149  * xarray has this behavior where it won't iterate over NULL values stored in
150  * allocated arrays.  So we need our own iterator to see all values stored in
151  * the array. This does the same thing as xa_for_each except that it also
152  * returns NULL valued entries if the array is allocating. Simplified to only
153  * work on simple xarrays.
154  */
155 static void *xan_find_marked(struct xarray *xa, unsigned long *indexp,
156                              xa_mark_t filter)
157 {
158         XA_STATE(xas, xa, *indexp);
159         void *entry;
160
161         rcu_read_lock();
162         do {
163                 entry = xas_find_marked(&xas, ULONG_MAX, filter);
164                 if (xa_is_zero(entry))
165                         break;
166         } while (xas_retry(&xas, entry));
167         rcu_read_unlock();
168
169         if (entry) {
170                 *indexp = xas.xa_index;
171                 if (xa_is_zero(entry))
172                         return NULL;
173                 return entry;
174         }
175         return XA_ERROR(-ENOENT);
176 }
177 #define xan_for_each_marked(xa, index, entry, filter)                          \
178         for (index = 0, entry = xan_find_marked(xa, &(index), filter);         \
179              !xa_is_err(entry);                                                \
180              (index)++, entry = xan_find_marked(xa, &(index), filter))
181
182 /* RCU hash table mapping netdevice pointers to struct ib_port_data */
183 static DEFINE_SPINLOCK(ndev_hash_lock);
184 static DECLARE_HASHTABLE(ndev_hash, 5);
185
186 static void free_netdevs(struct ib_device *ib_dev);
187 static void ib_unregister_work(struct work_struct *work);
188 static void __ib_unregister_device(struct ib_device *device);
189 static int ib_security_change(struct notifier_block *nb, unsigned long event,
190                               void *lsm_data);
191 static void ib_policy_change_task(struct work_struct *work);
192 static DECLARE_WORK(ib_policy_change_work, ib_policy_change_task);
193
194 static void __ibdev_printk(const char *level, const struct ib_device *ibdev,
195                            struct va_format *vaf)
196 {
197         if (ibdev && ibdev->dev.parent)
198                 dev_printk_emit(level[1] - '0',
199                                 ibdev->dev.parent,
200                                 "%s %s %s: %pV",
201                                 dev_driver_string(ibdev->dev.parent),
202                                 dev_name(ibdev->dev.parent),
203                                 dev_name(&ibdev->dev),
204                                 vaf);
205         else if (ibdev)
206                 printk("%s%s: %pV",
207                        level, dev_name(&ibdev->dev), vaf);
208         else
209                 printk("%s(NULL ib_device): %pV", level, vaf);
210 }
211
212 void ibdev_printk(const char *level, const struct ib_device *ibdev,
213                   const char *format, ...)
214 {
215         struct va_format vaf;
216         va_list args;
217
218         va_start(args, format);
219
220         vaf.fmt = format;
221         vaf.va = &args;
222
223         __ibdev_printk(level, ibdev, &vaf);
224
225         va_end(args);
226 }
227 EXPORT_SYMBOL(ibdev_printk);
228
229 #define define_ibdev_printk_level(func, level)                  \
230 void func(const struct ib_device *ibdev, const char *fmt, ...)  \
231 {                                                               \
232         struct va_format vaf;                                   \
233         va_list args;                                           \
234                                                                 \
235         va_start(args, fmt);                                    \
236                                                                 \
237         vaf.fmt = fmt;                                          \
238         vaf.va = &args;                                         \
239                                                                 \
240         __ibdev_printk(level, ibdev, &vaf);                     \
241                                                                 \
242         va_end(args);                                           \
243 }                                                               \
244 EXPORT_SYMBOL(func);
245
246 define_ibdev_printk_level(ibdev_emerg, KERN_EMERG);
247 define_ibdev_printk_level(ibdev_alert, KERN_ALERT);
248 define_ibdev_printk_level(ibdev_crit, KERN_CRIT);
249 define_ibdev_printk_level(ibdev_err, KERN_ERR);
250 define_ibdev_printk_level(ibdev_warn, KERN_WARNING);
251 define_ibdev_printk_level(ibdev_notice, KERN_NOTICE);
252 define_ibdev_printk_level(ibdev_info, KERN_INFO);
253
254 static struct notifier_block ibdev_lsm_nb = {
255         .notifier_call = ib_security_change,
256 };
257
258 static int rdma_dev_change_netns(struct ib_device *device, struct net *cur_net,
259                                  struct net *net);
260
261 /* Pointer to the RCU head at the start of the ib_port_data array */
262 struct ib_port_data_rcu {
263         struct rcu_head rcu_head;
264         struct ib_port_data pdata[];
265 };
266
267 static void ib_device_check_mandatory(struct ib_device *device)
268 {
269 #define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device_ops, x), #x }
270         static const struct {
271                 size_t offset;
272                 char  *name;
273         } mandatory_table[] = {
274                 IB_MANDATORY_FUNC(query_device),
275                 IB_MANDATORY_FUNC(query_port),
276                 IB_MANDATORY_FUNC(alloc_pd),
277                 IB_MANDATORY_FUNC(dealloc_pd),
278                 IB_MANDATORY_FUNC(create_qp),
279                 IB_MANDATORY_FUNC(modify_qp),
280                 IB_MANDATORY_FUNC(destroy_qp),
281                 IB_MANDATORY_FUNC(post_send),
282                 IB_MANDATORY_FUNC(post_recv),
283                 IB_MANDATORY_FUNC(create_cq),
284                 IB_MANDATORY_FUNC(destroy_cq),
285                 IB_MANDATORY_FUNC(poll_cq),
286                 IB_MANDATORY_FUNC(req_notify_cq),
287                 IB_MANDATORY_FUNC(get_dma_mr),
288                 IB_MANDATORY_FUNC(reg_user_mr),
289                 IB_MANDATORY_FUNC(dereg_mr),
290                 IB_MANDATORY_FUNC(get_port_immutable)
291         };
292         int i;
293
294         device->kverbs_provider = true;
295         for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
296                 if (!*(void **) ((void *) &device->ops +
297                                  mandatory_table[i].offset)) {
298                         device->kverbs_provider = false;
299                         break;
300                 }
301         }
302 }
303
304 /*
305  * Caller must perform ib_device_put() to return the device reference count
306  * when ib_device_get_by_index() returns valid device pointer.
307  */
308 struct ib_device *ib_device_get_by_index(const struct net *net, u32 index)
309 {
310         struct ib_device *device;
311
312         down_read(&devices_rwsem);
313         device = xa_load(&devices, index);
314         if (device) {
315                 if (!rdma_dev_access_netns(device, net)) {
316                         device = NULL;
317                         goto out;
318                 }
319
320                 if (!ib_device_try_get(device))
321                         device = NULL;
322         }
323 out:
324         up_read(&devices_rwsem);
325         return device;
326 }
327
328 /**
329  * ib_device_put - Release IB device reference
330  * @device: device whose reference to be released
331  *
332  * ib_device_put() releases reference to the IB device to allow it to be
333  * unregistered and eventually free.
334  */
335 void ib_device_put(struct ib_device *device)
336 {
337         if (refcount_dec_and_test(&device->refcount))
338                 complete(&device->unreg_completion);
339 }
340 EXPORT_SYMBOL(ib_device_put);
341
342 static struct ib_device *__ib_device_get_by_name(const char *name)
343 {
344         struct ib_device *device;
345         unsigned long index;
346
347         xa_for_each (&devices, index, device)
348                 if (!strcmp(name, dev_name(&device->dev)))
349                         return device;
350
351         return NULL;
352 }
353
354 /**
355  * ib_device_get_by_name - Find an IB device by name
356  * @name: The name to look for
357  * @driver_id: The driver ID that must match (RDMA_DRIVER_UNKNOWN matches all)
358  *
359  * Find and hold an ib_device by its name. The caller must call
360  * ib_device_put() on the returned pointer.
361  */
362 struct ib_device *ib_device_get_by_name(const char *name,
363                                         enum rdma_driver_id driver_id)
364 {
365         struct ib_device *device;
366
367         down_read(&devices_rwsem);
368         device = __ib_device_get_by_name(name);
369         if (device && driver_id != RDMA_DRIVER_UNKNOWN &&
370             device->ops.driver_id != driver_id)
371                 device = NULL;
372
373         if (device) {
374                 if (!ib_device_try_get(device))
375                         device = NULL;
376         }
377         up_read(&devices_rwsem);
378         return device;
379 }
380 EXPORT_SYMBOL(ib_device_get_by_name);
381
382 static int rename_compat_devs(struct ib_device *device)
383 {
384         struct ib_core_device *cdev;
385         unsigned long index;
386         int ret = 0;
387
388         mutex_lock(&device->compat_devs_mutex);
389         xa_for_each (&device->compat_devs, index, cdev) {
390                 ret = device_rename(&cdev->dev, dev_name(&device->dev));
391                 if (ret) {
392                         dev_warn(&cdev->dev,
393                                  "Fail to rename compatdev to new name %s\n",
394                                  dev_name(&device->dev));
395                         break;
396                 }
397         }
398         mutex_unlock(&device->compat_devs_mutex);
399         return ret;
400 }
401
402 int ib_device_rename(struct ib_device *ibdev, const char *name)
403 {
404         unsigned long index;
405         void *client_data;
406         int ret;
407
408         down_write(&devices_rwsem);
409         if (!strcmp(name, dev_name(&ibdev->dev))) {
410                 up_write(&devices_rwsem);
411                 return 0;
412         }
413
414         if (__ib_device_get_by_name(name)) {
415                 up_write(&devices_rwsem);
416                 return -EEXIST;
417         }
418
419         ret = device_rename(&ibdev->dev, name);
420         if (ret) {
421                 up_write(&devices_rwsem);
422                 return ret;
423         }
424
425         strscpy(ibdev->name, name, IB_DEVICE_NAME_MAX);
426         ret = rename_compat_devs(ibdev);
427
428         downgrade_write(&devices_rwsem);
429         down_read(&ibdev->client_data_rwsem);
430         xan_for_each_marked(&ibdev->client_data, index, client_data,
431                             CLIENT_DATA_REGISTERED) {
432                 struct ib_client *client = xa_load(&clients, index);
433
434                 if (!client || !client->rename)
435                         continue;
436
437                 client->rename(ibdev, client_data);
438         }
439         up_read(&ibdev->client_data_rwsem);
440         up_read(&devices_rwsem);
441         return 0;
442 }
443
444 int ib_device_set_dim(struct ib_device *ibdev, u8 use_dim)
445 {
446         if (use_dim > 1)
447                 return -EINVAL;
448         ibdev->use_cq_dim = use_dim;
449
450         return 0;
451 }
452
453 static int alloc_name(struct ib_device *ibdev, const char *name)
454 {
455         struct ib_device *device;
456         unsigned long index;
457         struct ida inuse;
458         int rc;
459         int i;
460
461         lockdep_assert_held_write(&devices_rwsem);
462         ida_init(&inuse);
463         xa_for_each (&devices, index, device) {
464                 char buf[IB_DEVICE_NAME_MAX];
465
466                 if (sscanf(dev_name(&device->dev), name, &i) != 1)
467                         continue;
468                 if (i < 0 || i >= INT_MAX)
469                         continue;
470                 snprintf(buf, sizeof buf, name, i);
471                 if (strcmp(buf, dev_name(&device->dev)) != 0)
472                         continue;
473
474                 rc = ida_alloc_range(&inuse, i, i, GFP_KERNEL);
475                 if (rc < 0)
476                         goto out;
477         }
478
479         rc = ida_alloc(&inuse, GFP_KERNEL);
480         if (rc < 0)
481                 goto out;
482
483         rc = dev_set_name(&ibdev->dev, name, rc);
484 out:
485         ida_destroy(&inuse);
486         return rc;
487 }
488
489 static void ib_device_release(struct device *device)
490 {
491         struct ib_device *dev = container_of(device, struct ib_device, dev);
492
493         free_netdevs(dev);
494         WARN_ON(refcount_read(&dev->refcount));
495         if (dev->hw_stats_data)
496                 ib_device_release_hw_stats(dev->hw_stats_data);
497         if (dev->port_data) {
498                 ib_cache_release_one(dev);
499                 ib_security_release_port_pkey_list(dev);
500                 rdma_counter_release(dev);
501                 kfree_rcu(container_of(dev->port_data, struct ib_port_data_rcu,
502                                        pdata[0]),
503                           rcu_head);
504         }
505
506         mutex_destroy(&dev->subdev_lock);
507         mutex_destroy(&dev->unregistration_lock);
508         mutex_destroy(&dev->compat_devs_mutex);
509
510         xa_destroy(&dev->compat_devs);
511         xa_destroy(&dev->client_data);
512         kfree_rcu(dev, rcu_head);
513 }
514
515 static int ib_device_uevent(const struct device *device,
516                             struct kobj_uevent_env *env)
517 {
518         if (add_uevent_var(env, "NAME=%s", dev_name(device)))
519                 return -ENOMEM;
520
521         /*
522          * It would be nice to pass the node GUID with the event...
523          */
524
525         return 0;
526 }
527
528 static const void *net_namespace(const struct device *d)
529 {
530         const struct ib_core_device *coredev =
531                         container_of(d, struct ib_core_device, dev);
532
533         return read_pnet(&coredev->rdma_net);
534 }
535
536 static struct class ib_class = {
537         .name    = "infiniband",
538         .dev_release = ib_device_release,
539         .dev_uevent = ib_device_uevent,
540         .ns_type = &net_ns_type_operations,
541         .namespace = net_namespace,
542 };
543
544 static void rdma_init_coredev(struct ib_core_device *coredev,
545                               struct ib_device *dev, struct net *net)
546 {
547         /* This BUILD_BUG_ON is intended to catch layout change
548          * of union of ib_core_device and device.
549          * dev must be the first element as ib_core and providers
550          * driver uses it. Adding anything in ib_core_device before
551          * device will break this assumption.
552          */
553         BUILD_BUG_ON(offsetof(struct ib_device, coredev.dev) !=
554                      offsetof(struct ib_device, dev));
555
556         coredev->dev.class = &ib_class;
557         coredev->dev.groups = dev->groups;
558         device_initialize(&coredev->dev);
559         coredev->owner = dev;
560         INIT_LIST_HEAD(&coredev->port_list);
561         write_pnet(&coredev->rdma_net, net);
562 }
563
564 /**
565  * _ib_alloc_device - allocate an IB device struct
566  * @size:size of structure to allocate
567  *
568  * Low-level drivers should use ib_alloc_device() to allocate &struct
569  * ib_device.  @size is the size of the structure to be allocated,
570  * including any private data used by the low-level driver.
571  * ib_dealloc_device() must be used to free structures allocated with
572  * ib_alloc_device().
573  */
574 struct ib_device *_ib_alloc_device(size_t size)
575 {
576         struct ib_device *device;
577         unsigned int i;
578
579         if (WARN_ON(size < sizeof(struct ib_device)))
580                 return NULL;
581
582         device = kzalloc(size, GFP_KERNEL);
583         if (!device)
584                 return NULL;
585
586         if (rdma_restrack_init(device)) {
587                 kfree(device);
588                 return NULL;
589         }
590
591         rdma_init_coredev(&device->coredev, device, &init_net);
592
593         INIT_LIST_HEAD(&device->event_handler_list);
594         spin_lock_init(&device->qp_open_list_lock);
595         init_rwsem(&device->event_handler_rwsem);
596         mutex_init(&device->unregistration_lock);
597         /*
598          * client_data needs to be alloc because we don't want our mark to be
599          * destroyed if the user stores NULL in the client data.
600          */
601         xa_init_flags(&device->client_data, XA_FLAGS_ALLOC);
602         init_rwsem(&device->client_data_rwsem);
603         xa_init_flags(&device->compat_devs, XA_FLAGS_ALLOC);
604         mutex_init(&device->compat_devs_mutex);
605         init_completion(&device->unreg_completion);
606         INIT_WORK(&device->unregistration_work, ib_unregister_work);
607
608         spin_lock_init(&device->cq_pools_lock);
609         for (i = 0; i < ARRAY_SIZE(device->cq_pools); i++)
610                 INIT_LIST_HEAD(&device->cq_pools[i]);
611
612         rwlock_init(&device->cache_lock);
613
614         device->uverbs_cmd_mask =
615                 BIT_ULL(IB_USER_VERBS_CMD_ALLOC_MW) |
616                 BIT_ULL(IB_USER_VERBS_CMD_ALLOC_PD) |
617                 BIT_ULL(IB_USER_VERBS_CMD_ATTACH_MCAST) |
618                 BIT_ULL(IB_USER_VERBS_CMD_CLOSE_XRCD) |
619                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_AH) |
620                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
621                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_CQ) |
622                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_QP) |
623                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_SRQ) |
624                 BIT_ULL(IB_USER_VERBS_CMD_CREATE_XSRQ) |
625                 BIT_ULL(IB_USER_VERBS_CMD_DEALLOC_MW) |
626                 BIT_ULL(IB_USER_VERBS_CMD_DEALLOC_PD) |
627                 BIT_ULL(IB_USER_VERBS_CMD_DEREG_MR) |
628                 BIT_ULL(IB_USER_VERBS_CMD_DESTROY_AH) |
629                 BIT_ULL(IB_USER_VERBS_CMD_DESTROY_CQ) |
630                 BIT_ULL(IB_USER_VERBS_CMD_DESTROY_QP) |
631                 BIT_ULL(IB_USER_VERBS_CMD_DESTROY_SRQ) |
632                 BIT_ULL(IB_USER_VERBS_CMD_DETACH_MCAST) |
633                 BIT_ULL(IB_USER_VERBS_CMD_GET_CONTEXT) |
634                 BIT_ULL(IB_USER_VERBS_CMD_MODIFY_QP) |
635                 BIT_ULL(IB_USER_VERBS_CMD_MODIFY_SRQ) |
636                 BIT_ULL(IB_USER_VERBS_CMD_OPEN_QP) |
637                 BIT_ULL(IB_USER_VERBS_CMD_OPEN_XRCD) |
638                 BIT_ULL(IB_USER_VERBS_CMD_QUERY_DEVICE) |
639                 BIT_ULL(IB_USER_VERBS_CMD_QUERY_PORT) |
640                 BIT_ULL(IB_USER_VERBS_CMD_QUERY_QP) |
641                 BIT_ULL(IB_USER_VERBS_CMD_QUERY_SRQ) |
642                 BIT_ULL(IB_USER_VERBS_CMD_REG_MR) |
643                 BIT_ULL(IB_USER_VERBS_CMD_REREG_MR) |
644                 BIT_ULL(IB_USER_VERBS_CMD_RESIZE_CQ);
645
646         mutex_init(&device->subdev_lock);
647         INIT_LIST_HEAD(&device->subdev_list_head);
648         INIT_LIST_HEAD(&device->subdev_list);
649
650         return device;
651 }
652 EXPORT_SYMBOL(_ib_alloc_device);
653
654 /**
655  * ib_dealloc_device - free an IB device struct
656  * @device:structure to free
657  *
658  * Free a structure allocated with ib_alloc_device().
659  */
660 void ib_dealloc_device(struct ib_device *device)
661 {
662         if (device->ops.dealloc_driver)
663                 device->ops.dealloc_driver(device);
664
665         /*
666          * ib_unregister_driver() requires all devices to remain in the xarray
667          * while their ops are callable. The last op we call is dealloc_driver
668          * above.  This is needed to create a fence on op callbacks prior to
669          * allowing the driver module to unload.
670          */
671         down_write(&devices_rwsem);
672         if (xa_load(&devices, device->index) == device)
673                 xa_erase(&devices, device->index);
674         up_write(&devices_rwsem);
675
676         /* Expedite releasing netdev references */
677         free_netdevs(device);
678
679         WARN_ON(!xa_empty(&device->compat_devs));
680         WARN_ON(!xa_empty(&device->client_data));
681         WARN_ON(refcount_read(&device->refcount));
682         rdma_restrack_clean(device);
683         /* Balances with device_initialize */
684         put_device(&device->dev);
685 }
686 EXPORT_SYMBOL(ib_dealloc_device);
687
688 /*
689  * add_client_context() and remove_client_context() must be safe against
690  * parallel calls on the same device - registration/unregistration of both the
691  * device and client can be occurring in parallel.
692  *
693  * The routines need to be a fence, any caller must not return until the add
694  * or remove is fully completed.
695  */
696 static int add_client_context(struct ib_device *device,
697                               struct ib_client *client)
698 {
699         int ret = 0;
700
701         if (!device->kverbs_provider && !client->no_kverbs_req)
702                 return 0;
703
704         down_write(&device->client_data_rwsem);
705         /*
706          * So long as the client is registered hold both the client and device
707          * unregistration locks.
708          */
709         if (!refcount_inc_not_zero(&client->uses))
710                 goto out_unlock;
711         refcount_inc(&device->refcount);
712
713         /*
714          * Another caller to add_client_context got here first and has already
715          * completely initialized context.
716          */
717         if (xa_get_mark(&device->client_data, client->client_id,
718                     CLIENT_DATA_REGISTERED))
719                 goto out;
720
721         ret = xa_err(xa_store(&device->client_data, client->client_id, NULL,
722                               GFP_KERNEL));
723         if (ret)
724                 goto out;
725         downgrade_write(&device->client_data_rwsem);
726         if (client->add) {
727                 if (client->add(device)) {
728                         /*
729                          * If a client fails to add then the error code is
730                          * ignored, but we won't call any more ops on this
731                          * client.
732                          */
733                         xa_erase(&device->client_data, client->client_id);
734                         up_read(&device->client_data_rwsem);
735                         ib_device_put(device);
736                         ib_client_put(client);
737                         return 0;
738                 }
739         }
740
741         /* Readers shall not see a client until add has been completed */
742         xa_set_mark(&device->client_data, client->client_id,
743                     CLIENT_DATA_REGISTERED);
744         up_read(&device->client_data_rwsem);
745         return 0;
746
747 out:
748         ib_device_put(device);
749         ib_client_put(client);
750 out_unlock:
751         up_write(&device->client_data_rwsem);
752         return ret;
753 }
754
755 static void remove_client_context(struct ib_device *device,
756                                   unsigned int client_id)
757 {
758         struct ib_client *client;
759         void *client_data;
760
761         down_write(&device->client_data_rwsem);
762         if (!xa_get_mark(&device->client_data, client_id,
763                          CLIENT_DATA_REGISTERED)) {
764                 up_write(&device->client_data_rwsem);
765                 return;
766         }
767         client_data = xa_load(&device->client_data, client_id);
768         xa_clear_mark(&device->client_data, client_id, CLIENT_DATA_REGISTERED);
769         client = xa_load(&clients, client_id);
770         up_write(&device->client_data_rwsem);
771
772         /*
773          * Notice we cannot be holding any exclusive locks when calling the
774          * remove callback as the remove callback can recurse back into any
775          * public functions in this module and thus try for any locks those
776          * functions take.
777          *
778          * For this reason clients and drivers should not call the
779          * unregistration functions will holdling any locks.
780          */
781         if (client->remove)
782                 client->remove(device, client_data);
783
784         xa_erase(&device->client_data, client_id);
785         ib_device_put(device);
786         ib_client_put(client);
787 }
788
789 static int alloc_port_data(struct ib_device *device)
790 {
791         struct ib_port_data_rcu *pdata_rcu;
792         u32 port;
793
794         if (device->port_data)
795                 return 0;
796
797         /* This can only be called once the physical port range is defined */
798         if (WARN_ON(!device->phys_port_cnt))
799                 return -EINVAL;
800
801         /* Reserve U32_MAX so the logic to go over all the ports is sane */
802         if (WARN_ON(device->phys_port_cnt == U32_MAX))
803                 return -EINVAL;
804
805         /*
806          * device->port_data is indexed directly by the port number to make
807          * access to this data as efficient as possible.
808          *
809          * Therefore port_data is declared as a 1 based array with potential
810          * empty slots at the beginning.
811          */
812         pdata_rcu = kzalloc(struct_size(pdata_rcu, pdata,
813                                         size_add(rdma_end_port(device), 1)),
814                             GFP_KERNEL);
815         if (!pdata_rcu)
816                 return -ENOMEM;
817         /*
818          * The rcu_head is put in front of the port data array and the stored
819          * pointer is adjusted since we never need to see that member until
820          * kfree_rcu.
821          */
822         device->port_data = pdata_rcu->pdata;
823
824         rdma_for_each_port (device, port) {
825                 struct ib_port_data *pdata = &device->port_data[port];
826
827                 pdata->ib_dev = device;
828                 spin_lock_init(&pdata->pkey_list_lock);
829                 INIT_LIST_HEAD(&pdata->pkey_list);
830                 spin_lock_init(&pdata->netdev_lock);
831                 INIT_HLIST_NODE(&pdata->ndev_hash_link);
832         }
833         return 0;
834 }
835
836 static int verify_immutable(const struct ib_device *dev, u32 port)
837 {
838         return WARN_ON(!rdma_cap_ib_mad(dev, port) &&
839                             rdma_max_mad_size(dev, port) != 0);
840 }
841
842 static int setup_port_data(struct ib_device *device)
843 {
844         u32 port;
845         int ret;
846
847         ret = alloc_port_data(device);
848         if (ret)
849                 return ret;
850
851         rdma_for_each_port (device, port) {
852                 struct ib_port_data *pdata = &device->port_data[port];
853
854                 ret = device->ops.get_port_immutable(device, port,
855                                                      &pdata->immutable);
856                 if (ret)
857                         return ret;
858
859                 if (verify_immutable(device, port))
860                         return -EINVAL;
861         }
862         return 0;
863 }
864
865 /**
866  * ib_port_immutable_read() - Read rdma port's immutable data
867  * @dev: IB device
868  * @port: port number whose immutable data to read. It starts with index 1 and
869  *        valid upto including rdma_end_port().
870  */
871 const struct ib_port_immutable*
872 ib_port_immutable_read(struct ib_device *dev, unsigned int port)
873 {
874         WARN_ON(!rdma_is_port_valid(dev, port));
875         return &dev->port_data[port].immutable;
876 }
877 EXPORT_SYMBOL(ib_port_immutable_read);
878
879 void ib_get_device_fw_str(struct ib_device *dev, char *str)
880 {
881         if (dev->ops.get_dev_fw_str)
882                 dev->ops.get_dev_fw_str(dev, str);
883         else
884                 str[0] = '\0';
885 }
886 EXPORT_SYMBOL(ib_get_device_fw_str);
887
888 static void ib_policy_change_task(struct work_struct *work)
889 {
890         struct ib_device *dev;
891         unsigned long index;
892
893         down_read(&devices_rwsem);
894         xa_for_each_marked (&devices, index, dev, DEVICE_REGISTERED) {
895                 unsigned int i;
896
897                 rdma_for_each_port (dev, i) {
898                         u64 sp;
899                         ib_get_cached_subnet_prefix(dev, i, &sp);
900                         ib_security_cache_change(dev, i, sp);
901                 }
902         }
903         up_read(&devices_rwsem);
904 }
905
906 static int ib_security_change(struct notifier_block *nb, unsigned long event,
907                               void *lsm_data)
908 {
909         if (event != LSM_POLICY_CHANGE)
910                 return NOTIFY_DONE;
911
912         schedule_work(&ib_policy_change_work);
913         ib_mad_agent_security_change();
914
915         return NOTIFY_OK;
916 }
917
918 static void compatdev_release(struct device *dev)
919 {
920         struct ib_core_device *cdev =
921                 container_of(dev, struct ib_core_device, dev);
922
923         kfree(cdev);
924 }
925
926 static int add_one_compat_dev(struct ib_device *device,
927                               struct rdma_dev_net *rnet)
928 {
929         struct ib_core_device *cdev;
930         int ret;
931
932         lockdep_assert_held(&rdma_nets_rwsem);
933         if (!ib_devices_shared_netns)
934                 return 0;
935
936         /*
937          * Create and add compat device in all namespaces other than where it
938          * is currently bound to.
939          */
940         if (net_eq(read_pnet(&rnet->net),
941                    read_pnet(&device->coredev.rdma_net)))
942                 return 0;
943
944         /*
945          * The first of init_net() or ib_register_device() to take the
946          * compat_devs_mutex wins and gets to add the device. Others will wait
947          * for completion here.
948          */
949         mutex_lock(&device->compat_devs_mutex);
950         cdev = xa_load(&device->compat_devs, rnet->id);
951         if (cdev) {
952                 ret = 0;
953                 goto done;
954         }
955         ret = xa_reserve(&device->compat_devs, rnet->id, GFP_KERNEL);
956         if (ret)
957                 goto done;
958
959         cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
960         if (!cdev) {
961                 ret = -ENOMEM;
962                 goto cdev_err;
963         }
964
965         cdev->dev.parent = device->dev.parent;
966         rdma_init_coredev(cdev, device, read_pnet(&rnet->net));
967         cdev->dev.release = compatdev_release;
968         ret = dev_set_name(&cdev->dev, "%s", dev_name(&device->dev));
969         if (ret)
970                 goto add_err;
971
972         ret = device_add(&cdev->dev);
973         if (ret)
974                 goto add_err;
975         ret = ib_setup_port_attrs(cdev);
976         if (ret)
977                 goto port_err;
978
979         ret = xa_err(xa_store(&device->compat_devs, rnet->id,
980                               cdev, GFP_KERNEL));
981         if (ret)
982                 goto insert_err;
983
984         mutex_unlock(&device->compat_devs_mutex);
985         return 0;
986
987 insert_err:
988         ib_free_port_attrs(cdev);
989 port_err:
990         device_del(&cdev->dev);
991 add_err:
992         put_device(&cdev->dev);
993 cdev_err:
994         xa_release(&device->compat_devs, rnet->id);
995 done:
996         mutex_unlock(&device->compat_devs_mutex);
997         return ret;
998 }
999
1000 static void remove_one_compat_dev(struct ib_device *device, u32 id)
1001 {
1002         struct ib_core_device *cdev;
1003
1004         mutex_lock(&device->compat_devs_mutex);
1005         cdev = xa_erase(&device->compat_devs, id);
1006         mutex_unlock(&device->compat_devs_mutex);
1007         if (cdev) {
1008                 ib_free_port_attrs(cdev);
1009                 device_del(&cdev->dev);
1010                 put_device(&cdev->dev);
1011         }
1012 }
1013
1014 static void remove_compat_devs(struct ib_device *device)
1015 {
1016         struct ib_core_device *cdev;
1017         unsigned long index;
1018
1019         xa_for_each (&device->compat_devs, index, cdev)
1020                 remove_one_compat_dev(device, index);
1021 }
1022
1023 static int add_compat_devs(struct ib_device *device)
1024 {
1025         struct rdma_dev_net *rnet;
1026         unsigned long index;
1027         int ret = 0;
1028
1029         lockdep_assert_held(&devices_rwsem);
1030
1031         down_read(&rdma_nets_rwsem);
1032         xa_for_each (&rdma_nets, index, rnet) {
1033                 ret = add_one_compat_dev(device, rnet);
1034                 if (ret)
1035                         break;
1036         }
1037         up_read(&rdma_nets_rwsem);
1038         return ret;
1039 }
1040
1041 static void remove_all_compat_devs(void)
1042 {
1043         struct ib_compat_device *cdev;
1044         struct ib_device *dev;
1045         unsigned long index;
1046
1047         down_read(&devices_rwsem);
1048         xa_for_each (&devices, index, dev) {
1049                 unsigned long c_index = 0;
1050
1051                 /* Hold nets_rwsem so that any other thread modifying this
1052                  * system param can sync with this thread.
1053                  */
1054                 down_read(&rdma_nets_rwsem);
1055                 xa_for_each (&dev->compat_devs, c_index, cdev)
1056                         remove_one_compat_dev(dev, c_index);
1057                 up_read(&rdma_nets_rwsem);
1058         }
1059         up_read(&devices_rwsem);
1060 }
1061
1062 static int add_all_compat_devs(void)
1063 {
1064         struct rdma_dev_net *rnet;
1065         struct ib_device *dev;
1066         unsigned long index;
1067         int ret = 0;
1068
1069         down_read(&devices_rwsem);
1070         xa_for_each_marked (&devices, index, dev, DEVICE_REGISTERED) {
1071                 unsigned long net_index = 0;
1072
1073                 /* Hold nets_rwsem so that any other thread modifying this
1074                  * system param can sync with this thread.
1075                  */
1076                 down_read(&rdma_nets_rwsem);
1077                 xa_for_each (&rdma_nets, net_index, rnet) {
1078                         ret = add_one_compat_dev(dev, rnet);
1079                         if (ret)
1080                                 break;
1081                 }
1082                 up_read(&rdma_nets_rwsem);
1083         }
1084         up_read(&devices_rwsem);
1085         if (ret)
1086                 remove_all_compat_devs();
1087         return ret;
1088 }
1089
1090 int rdma_compatdev_set(u8 enable)
1091 {
1092         struct rdma_dev_net *rnet;
1093         unsigned long index;
1094         int ret = 0;
1095
1096         down_write(&rdma_nets_rwsem);
1097         if (ib_devices_shared_netns == enable) {
1098                 up_write(&rdma_nets_rwsem);
1099                 return 0;
1100         }
1101
1102         /* enable/disable of compat devices is not supported
1103          * when more than default init_net exists.
1104          */
1105         xa_for_each (&rdma_nets, index, rnet) {
1106                 ret++;
1107                 break;
1108         }
1109         if (!ret)
1110                 ib_devices_shared_netns = enable;
1111         up_write(&rdma_nets_rwsem);
1112         if (ret)
1113                 return -EBUSY;
1114
1115         if (enable)
1116                 ret = add_all_compat_devs();
1117         else
1118                 remove_all_compat_devs();
1119         return ret;
1120 }
1121
1122 static void rdma_dev_exit_net(struct net *net)
1123 {
1124         struct rdma_dev_net *rnet = rdma_net_to_dev_net(net);
1125         struct ib_device *dev;
1126         unsigned long index;
1127         int ret;
1128
1129         down_write(&rdma_nets_rwsem);
1130         /*
1131          * Prevent the ID from being re-used and hide the id from xa_for_each.
1132          */
1133         ret = xa_err(xa_store(&rdma_nets, rnet->id, NULL, GFP_KERNEL));
1134         WARN_ON(ret);
1135         up_write(&rdma_nets_rwsem);
1136
1137         down_read(&devices_rwsem);
1138         xa_for_each (&devices, index, dev) {
1139                 get_device(&dev->dev);
1140                 /*
1141                  * Release the devices_rwsem so that pontentially blocking
1142                  * device_del, doesn't hold the devices_rwsem for too long.
1143                  */
1144                 up_read(&devices_rwsem);
1145
1146                 remove_one_compat_dev(dev, rnet->id);
1147
1148                 /*
1149                  * If the real device is in the NS then move it back to init.
1150                  */
1151                 rdma_dev_change_netns(dev, net, &init_net);
1152
1153                 put_device(&dev->dev);
1154                 down_read(&devices_rwsem);
1155         }
1156         up_read(&devices_rwsem);
1157
1158         rdma_nl_net_exit(rnet);
1159         xa_erase(&rdma_nets, rnet->id);
1160 }
1161
1162 static __net_init int rdma_dev_init_net(struct net *net)
1163 {
1164         struct rdma_dev_net *rnet = rdma_net_to_dev_net(net);
1165         unsigned long index;
1166         struct ib_device *dev;
1167         int ret;
1168
1169         write_pnet(&rnet->net, net);
1170
1171         ret = rdma_nl_net_init(rnet);
1172         if (ret)
1173                 return ret;
1174
1175         /* No need to create any compat devices in default init_net. */
1176         if (net_eq(net, &init_net))
1177                 return 0;
1178
1179         ret = xa_alloc(&rdma_nets, &rnet->id, rnet, xa_limit_32b, GFP_KERNEL);
1180         if (ret) {
1181                 rdma_nl_net_exit(rnet);
1182                 return ret;
1183         }
1184
1185         down_read(&devices_rwsem);
1186         xa_for_each_marked (&devices, index, dev, DEVICE_REGISTERED) {
1187                 /* Hold nets_rwsem so that netlink command cannot change
1188                  * system configuration for device sharing mode.
1189                  */
1190                 down_read(&rdma_nets_rwsem);
1191                 ret = add_one_compat_dev(dev, rnet);
1192                 up_read(&rdma_nets_rwsem);
1193                 if (ret)
1194                         break;
1195         }
1196         up_read(&devices_rwsem);
1197
1198         if (ret)
1199                 rdma_dev_exit_net(net);
1200
1201         return ret;
1202 }
1203
1204 /*
1205  * Assign the unique string device name and the unique device index. This is
1206  * undone by ib_dealloc_device.
1207  */
1208 static int assign_name(struct ib_device *device, const char *name)
1209 {
1210         static u32 last_id;
1211         int ret;
1212
1213         down_write(&devices_rwsem);
1214         /* Assign a unique name to the device */
1215         if (strchr(name, '%'))
1216                 ret = alloc_name(device, name);
1217         else
1218                 ret = dev_set_name(&device->dev, name);
1219         if (ret)
1220                 goto out;
1221
1222         if (__ib_device_get_by_name(dev_name(&device->dev))) {
1223                 ret = -ENFILE;
1224                 goto out;
1225         }
1226         strscpy(device->name, dev_name(&device->dev), IB_DEVICE_NAME_MAX);
1227
1228         ret = xa_alloc_cyclic(&devices, &device->index, device, xa_limit_31b,
1229                         &last_id, GFP_KERNEL);
1230         if (ret > 0)
1231                 ret = 0;
1232
1233 out:
1234         up_write(&devices_rwsem);
1235         return ret;
1236 }
1237
1238 /*
1239  * setup_device() allocates memory and sets up data that requires calling the
1240  * device ops, this is the only reason these actions are not done during
1241  * ib_alloc_device. It is undone by ib_dealloc_device().
1242  */
1243 static int setup_device(struct ib_device *device)
1244 {
1245         struct ib_udata uhw = {.outlen = 0, .inlen = 0};
1246         int ret;
1247
1248         ib_device_check_mandatory(device);
1249
1250         ret = setup_port_data(device);
1251         if (ret) {
1252                 dev_warn(&device->dev, "Couldn't create per-port data\n");
1253                 return ret;
1254         }
1255
1256         memset(&device->attrs, 0, sizeof(device->attrs));
1257         ret = device->ops.query_device(device, &device->attrs, &uhw);
1258         if (ret) {
1259                 dev_warn(&device->dev,
1260                          "Couldn't query the device attributes\n");
1261                 return ret;
1262         }
1263
1264         return 0;
1265 }
1266
1267 static void disable_device(struct ib_device *device)
1268 {
1269         u32 cid;
1270
1271         WARN_ON(!refcount_read(&device->refcount));
1272
1273         down_write(&devices_rwsem);
1274         xa_clear_mark(&devices, device->index, DEVICE_REGISTERED);
1275         up_write(&devices_rwsem);
1276
1277         /*
1278          * Remove clients in LIFO order, see assign_client_id. This could be
1279          * more efficient if xarray learns to reverse iterate. Since no new
1280          * clients can be added to this ib_device past this point we only need
1281          * the maximum possible client_id value here.
1282          */
1283         down_read(&clients_rwsem);
1284         cid = highest_client_id;
1285         up_read(&clients_rwsem);
1286         while (cid) {
1287                 cid--;
1288                 remove_client_context(device, cid);
1289         }
1290
1291         ib_cq_pool_cleanup(device);
1292
1293         /* Pairs with refcount_set in enable_device */
1294         ib_device_put(device);
1295         wait_for_completion(&device->unreg_completion);
1296
1297         /*
1298          * compat devices must be removed after device refcount drops to zero.
1299          * Otherwise init_net() may add more compatdevs after removing compat
1300          * devices and before device is disabled.
1301          */
1302         remove_compat_devs(device);
1303 }
1304
1305 /*
1306  * An enabled device is visible to all clients and to all the public facing
1307  * APIs that return a device pointer. This always returns with a new get, even
1308  * if it fails.
1309  */
1310 static int enable_device_and_get(struct ib_device *device)
1311 {
1312         struct ib_client *client;
1313         unsigned long index;
1314         int ret = 0;
1315
1316         /*
1317          * One ref belongs to the xa and the other belongs to this
1318          * thread. This is needed to guard against parallel unregistration.
1319          */
1320         refcount_set(&device->refcount, 2);
1321         down_write(&devices_rwsem);
1322         xa_set_mark(&devices, device->index, DEVICE_REGISTERED);
1323
1324         /*
1325          * By using downgrade_write() we ensure that no other thread can clear
1326          * DEVICE_REGISTERED while we are completing the client setup.
1327          */
1328         downgrade_write(&devices_rwsem);
1329
1330         if (device->ops.enable_driver) {
1331                 ret = device->ops.enable_driver(device);
1332                 if (ret)
1333                         goto out;
1334         }
1335
1336         down_read(&clients_rwsem);
1337         xa_for_each_marked (&clients, index, client, CLIENT_REGISTERED) {
1338                 ret = add_client_context(device, client);
1339                 if (ret)
1340                         break;
1341         }
1342         up_read(&clients_rwsem);
1343         if (!ret)
1344                 ret = add_compat_devs(device);
1345 out:
1346         up_read(&devices_rwsem);
1347         return ret;
1348 }
1349
1350 static void prevent_dealloc_device(struct ib_device *ib_dev)
1351 {
1352 }
1353
1354 /**
1355  * ib_register_device - Register an IB device with IB core
1356  * @device: Device to register
1357  * @name: unique string device name. This may include a '%' which will
1358  *        cause a unique index to be added to the passed device name.
1359  * @dma_device: pointer to a DMA-capable device. If %NULL, then the IB
1360  *              device will be used. In this case the caller should fully
1361  *              setup the ibdev for DMA. This usually means using dma_virt_ops.
1362  *
1363  * Low-level drivers use ib_register_device() to register their
1364  * devices with the IB core.  All registered clients will receive a
1365  * callback for each device that is added. @device must be allocated
1366  * with ib_alloc_device().
1367  *
1368  * If the driver uses ops.dealloc_driver and calls any ib_unregister_device()
1369  * asynchronously then the device pointer may become freed as soon as this
1370  * function returns.
1371  */
1372 int ib_register_device(struct ib_device *device, const char *name,
1373                        struct device *dma_device)
1374 {
1375         int ret;
1376
1377         ret = assign_name(device, name);
1378         if (ret)
1379                 return ret;
1380
1381         /*
1382          * If the caller does not provide a DMA capable device then the IB core
1383          * will set up ib_sge and scatterlist structures that stash the kernel
1384          * virtual address into the address field.
1385          */
1386         WARN_ON(dma_device && !dma_device->dma_parms);
1387         device->dma_device = dma_device;
1388
1389         ret = setup_device(device);
1390         if (ret)
1391                 return ret;
1392
1393         ret = ib_cache_setup_one(device);
1394         if (ret) {
1395                 dev_warn(&device->dev,
1396                          "Couldn't set up InfiniBand P_Key/GID cache\n");
1397                 return ret;
1398         }
1399
1400         device->groups[0] = &ib_dev_attr_group;
1401         device->groups[1] = device->ops.device_group;
1402         ret = ib_setup_device_attrs(device);
1403         if (ret)
1404                 goto cache_cleanup;
1405
1406         ib_device_register_rdmacg(device);
1407
1408         rdma_counter_init(device);
1409
1410         /*
1411          * Ensure that ADD uevent is not fired because it
1412          * is too early amd device is not initialized yet.
1413          */
1414         dev_set_uevent_suppress(&device->dev, true);
1415         ret = device_add(&device->dev);
1416         if (ret)
1417                 goto cg_cleanup;
1418
1419         ret = ib_setup_port_attrs(&device->coredev);
1420         if (ret) {
1421                 dev_warn(&device->dev,
1422                          "Couldn't register device with driver model\n");
1423                 goto dev_cleanup;
1424         }
1425
1426         ret = enable_device_and_get(device);
1427         if (ret) {
1428                 void (*dealloc_fn)(struct ib_device *);
1429
1430                 /*
1431                  * If we hit this error flow then we don't want to
1432                  * automatically dealloc the device since the caller is
1433                  * expected to call ib_dealloc_device() after
1434                  * ib_register_device() fails. This is tricky due to the
1435                  * possibility for a parallel unregistration along with this
1436                  * error flow. Since we have a refcount here we know any
1437                  * parallel flow is stopped in disable_device and will see the
1438                  * special dealloc_driver pointer, causing the responsibility to
1439                  * ib_dealloc_device() to revert back to this thread.
1440                  */
1441                 dealloc_fn = device->ops.dealloc_driver;
1442                 device->ops.dealloc_driver = prevent_dealloc_device;
1443                 ib_device_put(device);
1444                 __ib_unregister_device(device);
1445                 device->ops.dealloc_driver = dealloc_fn;
1446                 dev_set_uevent_suppress(&device->dev, false);
1447                 return ret;
1448         }
1449         dev_set_uevent_suppress(&device->dev, false);
1450         /* Mark for userspace that device is ready */
1451         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
1452         ib_device_put(device);
1453
1454         return 0;
1455
1456 dev_cleanup:
1457         device_del(&device->dev);
1458 cg_cleanup:
1459         dev_set_uevent_suppress(&device->dev, false);
1460         ib_device_unregister_rdmacg(device);
1461 cache_cleanup:
1462         ib_cache_cleanup_one(device);
1463         return ret;
1464 }
1465 EXPORT_SYMBOL(ib_register_device);
1466
1467 /* Callers must hold a get on the device. */
1468 static void __ib_unregister_device(struct ib_device *ib_dev)
1469 {
1470         struct ib_device *sub, *tmp;
1471
1472         mutex_lock(&ib_dev->subdev_lock);
1473         list_for_each_entry_safe_reverse(sub, tmp,
1474                                          &ib_dev->subdev_list_head,
1475                                          subdev_list) {
1476                 list_del(&sub->subdev_list);
1477                 ib_dev->ops.del_sub_dev(sub);
1478                 ib_device_put(ib_dev);
1479         }
1480         mutex_unlock(&ib_dev->subdev_lock);
1481
1482         /*
1483          * We have a registration lock so that all the calls to unregister are
1484          * fully fenced, once any unregister returns the device is truely
1485          * unregistered even if multiple callers are unregistering it at the
1486          * same time. This also interacts with the registration flow and
1487          * provides sane semantics if register and unregister are racing.
1488          */
1489         mutex_lock(&ib_dev->unregistration_lock);
1490         if (!refcount_read(&ib_dev->refcount))
1491                 goto out;
1492
1493         disable_device(ib_dev);
1494
1495         /* Expedite removing unregistered pointers from the hash table */
1496         free_netdevs(ib_dev);
1497
1498         ib_free_port_attrs(&ib_dev->coredev);
1499         device_del(&ib_dev->dev);
1500         ib_device_unregister_rdmacg(ib_dev);
1501         ib_cache_cleanup_one(ib_dev);
1502
1503         /*
1504          * Drivers using the new flow may not call ib_dealloc_device except
1505          * in error unwind prior to registration success.
1506          */
1507         if (ib_dev->ops.dealloc_driver &&
1508             ib_dev->ops.dealloc_driver != prevent_dealloc_device) {
1509                 WARN_ON(kref_read(&ib_dev->dev.kobj.kref) <= 1);
1510                 ib_dealloc_device(ib_dev);
1511         }
1512 out:
1513         mutex_unlock(&ib_dev->unregistration_lock);
1514 }
1515
1516 /**
1517  * ib_unregister_device - Unregister an IB device
1518  * @ib_dev: The device to unregister
1519  *
1520  * Unregister an IB device.  All clients will receive a remove callback.
1521  *
1522  * Callers should call this routine only once, and protect against races with
1523  * registration. Typically it should only be called as part of a remove
1524  * callback in an implementation of driver core's struct device_driver and
1525  * related.
1526  *
1527  * If ops.dealloc_driver is used then ib_dev will be freed upon return from
1528  * this function.
1529  */
1530 void ib_unregister_device(struct ib_device *ib_dev)
1531 {
1532         get_device(&ib_dev->dev);
1533         __ib_unregister_device(ib_dev);
1534         put_device(&ib_dev->dev);
1535 }
1536 EXPORT_SYMBOL(ib_unregister_device);
1537
1538 /**
1539  * ib_unregister_device_and_put - Unregister a device while holding a 'get'
1540  * @ib_dev: The device to unregister
1541  *
1542  * This is the same as ib_unregister_device(), except it includes an internal
1543  * ib_device_put() that should match a 'get' obtained by the caller.
1544  *
1545  * It is safe to call this routine concurrently from multiple threads while
1546  * holding the 'get'. When the function returns the device is fully
1547  * unregistered.
1548  *
1549  * Drivers using this flow MUST use the driver_unregister callback to clean up
1550  * their resources associated with the device and dealloc it.
1551  */
1552 void ib_unregister_device_and_put(struct ib_device *ib_dev)
1553 {
1554         WARN_ON(!ib_dev->ops.dealloc_driver);
1555         get_device(&ib_dev->dev);
1556         ib_device_put(ib_dev);
1557         __ib_unregister_device(ib_dev);
1558         put_device(&ib_dev->dev);
1559 }
1560 EXPORT_SYMBOL(ib_unregister_device_and_put);
1561
1562 /**
1563  * ib_unregister_driver - Unregister all IB devices for a driver
1564  * @driver_id: The driver to unregister
1565  *
1566  * This implements a fence for device unregistration. It only returns once all
1567  * devices associated with the driver_id have fully completed their
1568  * unregistration and returned from ib_unregister_device*().
1569  *
1570  * If device's are not yet unregistered it goes ahead and starts unregistering
1571  * them.
1572  *
1573  * This does not block creation of new devices with the given driver_id, that
1574  * is the responsibility of the caller.
1575  */
1576 void ib_unregister_driver(enum rdma_driver_id driver_id)
1577 {
1578         struct ib_device *ib_dev;
1579         unsigned long index;
1580
1581         down_read(&devices_rwsem);
1582         xa_for_each (&devices, index, ib_dev) {
1583                 if (ib_dev->ops.driver_id != driver_id)
1584                         continue;
1585
1586                 get_device(&ib_dev->dev);
1587                 up_read(&devices_rwsem);
1588
1589                 WARN_ON(!ib_dev->ops.dealloc_driver);
1590                 __ib_unregister_device(ib_dev);
1591
1592                 put_device(&ib_dev->dev);
1593                 down_read(&devices_rwsem);
1594         }
1595         up_read(&devices_rwsem);
1596 }
1597 EXPORT_SYMBOL(ib_unregister_driver);
1598
1599 static void ib_unregister_work(struct work_struct *work)
1600 {
1601         struct ib_device *ib_dev =
1602                 container_of(work, struct ib_device, unregistration_work);
1603
1604         __ib_unregister_device(ib_dev);
1605         put_device(&ib_dev->dev);
1606 }
1607
1608 /**
1609  * ib_unregister_device_queued - Unregister a device using a work queue
1610  * @ib_dev: The device to unregister
1611  *
1612  * This schedules an asynchronous unregistration using a WQ for the device. A
1613  * driver should use this to avoid holding locks while doing unregistration,
1614  * such as holding the RTNL lock.
1615  *
1616  * Drivers using this API must use ib_unregister_driver before module unload
1617  * to ensure that all scheduled unregistrations have completed.
1618  */
1619 void ib_unregister_device_queued(struct ib_device *ib_dev)
1620 {
1621         WARN_ON(!refcount_read(&ib_dev->refcount));
1622         WARN_ON(!ib_dev->ops.dealloc_driver);
1623         get_device(&ib_dev->dev);
1624         if (!queue_work(ib_unreg_wq, &ib_dev->unregistration_work))
1625                 put_device(&ib_dev->dev);
1626 }
1627 EXPORT_SYMBOL(ib_unregister_device_queued);
1628
1629 /*
1630  * The caller must pass in a device that has the kref held and the refcount
1631  * released. If the device is in cur_net and still registered then it is moved
1632  * into net.
1633  */
1634 static int rdma_dev_change_netns(struct ib_device *device, struct net *cur_net,
1635                                  struct net *net)
1636 {
1637         int ret2 = -EINVAL;
1638         int ret;
1639
1640         mutex_lock(&device->unregistration_lock);
1641
1642         /*
1643          * If a device not under ib_device_get() or if the unregistration_lock
1644          * is not held, the namespace can be changed, or it can be unregistered.
1645          * Check again under the lock.
1646          */
1647         if (refcount_read(&device->refcount) == 0 ||
1648             !net_eq(cur_net, read_pnet(&device->coredev.rdma_net))) {
1649                 ret = -ENODEV;
1650                 goto out;
1651         }
1652
1653         kobject_uevent(&device->dev.kobj, KOBJ_REMOVE);
1654         disable_device(device);
1655
1656         /*
1657          * At this point no one can be using the device, so it is safe to
1658          * change the namespace.
1659          */
1660         write_pnet(&device->coredev.rdma_net, net);
1661
1662         down_read(&devices_rwsem);
1663         /*
1664          * Currently rdma devices are system wide unique. So the device name
1665          * is guaranteed free in the new namespace. Publish the new namespace
1666          * at the sysfs level.
1667          */
1668         ret = device_rename(&device->dev, dev_name(&device->dev));
1669         up_read(&devices_rwsem);
1670         if (ret) {
1671                 dev_warn(&device->dev,
1672                          "%s: Couldn't rename device after namespace change\n",
1673                          __func__);
1674                 /* Try and put things back and re-enable the device */
1675                 write_pnet(&device->coredev.rdma_net, cur_net);
1676         }
1677
1678         ret2 = enable_device_and_get(device);
1679         if (ret2) {
1680                 /*
1681                  * This shouldn't really happen, but if it does, let the user
1682                  * retry at later point. So don't disable the device.
1683                  */
1684                 dev_warn(&device->dev,
1685                          "%s: Couldn't re-enable device after namespace change\n",
1686                          __func__);
1687         }
1688         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
1689
1690         ib_device_put(device);
1691 out:
1692         mutex_unlock(&device->unregistration_lock);
1693         if (ret)
1694                 return ret;
1695         return ret2;
1696 }
1697
1698 int ib_device_set_netns_put(struct sk_buff *skb,
1699                             struct ib_device *dev, u32 ns_fd)
1700 {
1701         struct net *net;
1702         int ret;
1703
1704         net = get_net_ns_by_fd(ns_fd);
1705         if (IS_ERR(net)) {
1706                 ret = PTR_ERR(net);
1707                 goto net_err;
1708         }
1709
1710         if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
1711                 ret = -EPERM;
1712                 goto ns_err;
1713         }
1714
1715         /*
1716          * All the ib_clients, including uverbs, are reset when the namespace is
1717          * changed and this cannot be blocked waiting for userspace to do
1718          * something, so disassociation is mandatory.
1719          */
1720         if (!dev->ops.disassociate_ucontext || ib_devices_shared_netns) {
1721                 ret = -EOPNOTSUPP;
1722                 goto ns_err;
1723         }
1724
1725         get_device(&dev->dev);
1726         ib_device_put(dev);
1727         ret = rdma_dev_change_netns(dev, current->nsproxy->net_ns, net);
1728         put_device(&dev->dev);
1729
1730         put_net(net);
1731         return ret;
1732
1733 ns_err:
1734         put_net(net);
1735 net_err:
1736         ib_device_put(dev);
1737         return ret;
1738 }
1739
1740 static struct pernet_operations rdma_dev_net_ops = {
1741         .init = rdma_dev_init_net,
1742         .exit = rdma_dev_exit_net,
1743         .id = &rdma_dev_net_id,
1744         .size = sizeof(struct rdma_dev_net),
1745 };
1746
1747 static int assign_client_id(struct ib_client *client)
1748 {
1749         int ret;
1750
1751         lockdep_assert_held(&clients_rwsem);
1752         /*
1753          * The add/remove callbacks must be called in FIFO/LIFO order. To
1754          * achieve this we assign client_ids so they are sorted in
1755          * registration order.
1756          */
1757         client->client_id = highest_client_id;
1758         ret = xa_insert(&clients, client->client_id, client, GFP_KERNEL);
1759         if (ret)
1760                 return ret;
1761
1762         highest_client_id++;
1763         xa_set_mark(&clients, client->client_id, CLIENT_REGISTERED);
1764         return 0;
1765 }
1766
1767 static void remove_client_id(struct ib_client *client)
1768 {
1769         down_write(&clients_rwsem);
1770         xa_erase(&clients, client->client_id);
1771         for (; highest_client_id; highest_client_id--)
1772                 if (xa_load(&clients, highest_client_id - 1))
1773                         break;
1774         up_write(&clients_rwsem);
1775 }
1776
1777 /**
1778  * ib_register_client - Register an IB client
1779  * @client:Client to register
1780  *
1781  * Upper level users of the IB drivers can use ib_register_client() to
1782  * register callbacks for IB device addition and removal.  When an IB
1783  * device is added, each registered client's add method will be called
1784  * (in the order the clients were registered), and when a device is
1785  * removed, each client's remove method will be called (in the reverse
1786  * order that clients were registered).  In addition, when
1787  * ib_register_client() is called, the client will receive an add
1788  * callback for all devices already registered.
1789  */
1790 int ib_register_client(struct ib_client *client)
1791 {
1792         struct ib_device *device;
1793         unsigned long index;
1794         bool need_unreg = false;
1795         int ret;
1796
1797         refcount_set(&client->uses, 1);
1798         init_completion(&client->uses_zero);
1799
1800         /*
1801          * The devices_rwsem is held in write mode to ensure that a racing
1802          * ib_register_device() sees a consisent view of clients and devices.
1803          */
1804         down_write(&devices_rwsem);
1805         down_write(&clients_rwsem);
1806         ret = assign_client_id(client);
1807         if (ret)
1808                 goto out;
1809
1810         need_unreg = true;
1811         xa_for_each_marked (&devices, index, device, DEVICE_REGISTERED) {
1812                 ret = add_client_context(device, client);
1813                 if (ret)
1814                         goto out;
1815         }
1816         ret = 0;
1817 out:
1818         up_write(&clients_rwsem);
1819         up_write(&devices_rwsem);
1820         if (need_unreg && ret)
1821                 ib_unregister_client(client);
1822         return ret;
1823 }
1824 EXPORT_SYMBOL(ib_register_client);
1825
1826 /**
1827  * ib_unregister_client - Unregister an IB client
1828  * @client:Client to unregister
1829  *
1830  * Upper level users use ib_unregister_client() to remove their client
1831  * registration.  When ib_unregister_client() is called, the client
1832  * will receive a remove callback for each IB device still registered.
1833  *
1834  * This is a full fence, once it returns no client callbacks will be called,
1835  * or are running in another thread.
1836  */
1837 void ib_unregister_client(struct ib_client *client)
1838 {
1839         struct ib_device *device;
1840         unsigned long index;
1841
1842         down_write(&clients_rwsem);
1843         ib_client_put(client);
1844         xa_clear_mark(&clients, client->client_id, CLIENT_REGISTERED);
1845         up_write(&clients_rwsem);
1846
1847         /* We do not want to have locks while calling client->remove() */
1848         rcu_read_lock();
1849         xa_for_each (&devices, index, device) {
1850                 if (!ib_device_try_get(device))
1851                         continue;
1852                 rcu_read_unlock();
1853
1854                 remove_client_context(device, client->client_id);
1855
1856                 ib_device_put(device);
1857                 rcu_read_lock();
1858         }
1859         rcu_read_unlock();
1860
1861         /*
1862          * remove_client_context() is not a fence, it can return even though a
1863          * removal is ongoing. Wait until all removals are completed.
1864          */
1865         wait_for_completion(&client->uses_zero);
1866         remove_client_id(client);
1867 }
1868 EXPORT_SYMBOL(ib_unregister_client);
1869
1870 static int __ib_get_global_client_nl_info(const char *client_name,
1871                                           struct ib_client_nl_info *res)
1872 {
1873         struct ib_client *client;
1874         unsigned long index;
1875         int ret = -ENOENT;
1876
1877         down_read(&clients_rwsem);
1878         xa_for_each_marked (&clients, index, client, CLIENT_REGISTERED) {
1879                 if (strcmp(client->name, client_name) != 0)
1880                         continue;
1881                 if (!client->get_global_nl_info) {
1882                         ret = -EOPNOTSUPP;
1883                         break;
1884                 }
1885                 ret = client->get_global_nl_info(res);
1886                 if (WARN_ON(ret == -ENOENT))
1887                         ret = -EINVAL;
1888                 if (!ret && res->cdev)
1889                         get_device(res->cdev);
1890                 break;
1891         }
1892         up_read(&clients_rwsem);
1893         return ret;
1894 }
1895
1896 static int __ib_get_client_nl_info(struct ib_device *ibdev,
1897                                    const char *client_name,
1898                                    struct ib_client_nl_info *res)
1899 {
1900         unsigned long index;
1901         void *client_data;
1902         int ret = -ENOENT;
1903
1904         down_read(&ibdev->client_data_rwsem);
1905         xan_for_each_marked (&ibdev->client_data, index, client_data,
1906                              CLIENT_DATA_REGISTERED) {
1907                 struct ib_client *client = xa_load(&clients, index);
1908
1909                 if (!client || strcmp(client->name, client_name) != 0)
1910                         continue;
1911                 if (!client->get_nl_info) {
1912                         ret = -EOPNOTSUPP;
1913                         break;
1914                 }
1915                 ret = client->get_nl_info(ibdev, client_data, res);
1916                 if (WARN_ON(ret == -ENOENT))
1917                         ret = -EINVAL;
1918
1919                 /*
1920                  * The cdev is guaranteed valid as long as we are inside the
1921                  * client_data_rwsem as remove_one can't be called. Keep it
1922                  * valid for the caller.
1923                  */
1924                 if (!ret && res->cdev)
1925                         get_device(res->cdev);
1926                 break;
1927         }
1928         up_read(&ibdev->client_data_rwsem);
1929
1930         return ret;
1931 }
1932
1933 /**
1934  * ib_get_client_nl_info - Fetch the nl_info from a client
1935  * @ibdev: IB device
1936  * @client_name: Name of the client
1937  * @res: Result of the query
1938  */
1939 int ib_get_client_nl_info(struct ib_device *ibdev, const char *client_name,
1940                           struct ib_client_nl_info *res)
1941 {
1942         int ret;
1943
1944         if (ibdev)
1945                 ret = __ib_get_client_nl_info(ibdev, client_name, res);
1946         else
1947                 ret = __ib_get_global_client_nl_info(client_name, res);
1948 #ifdef CONFIG_MODULES
1949         if (ret == -ENOENT) {
1950                 request_module("rdma-client-%s", client_name);
1951                 if (ibdev)
1952                         ret = __ib_get_client_nl_info(ibdev, client_name, res);
1953                 else
1954                         ret = __ib_get_global_client_nl_info(client_name, res);
1955         }
1956 #endif
1957         if (ret) {
1958                 if (ret == -ENOENT)
1959                         return -EOPNOTSUPP;
1960                 return ret;
1961         }
1962
1963         if (WARN_ON(!res->cdev))
1964                 return -EINVAL;
1965         return 0;
1966 }
1967
1968 /**
1969  * ib_set_client_data - Set IB client context
1970  * @device:Device to set context for
1971  * @client:Client to set context for
1972  * @data:Context to set
1973  *
1974  * ib_set_client_data() sets client context data that can be retrieved with
1975  * ib_get_client_data(). This can only be called while the client is
1976  * registered to the device, once the ib_client remove() callback returns this
1977  * cannot be called.
1978  */
1979 void ib_set_client_data(struct ib_device *device, struct ib_client *client,
1980                         void *data)
1981 {
1982         void *rc;
1983
1984         if (WARN_ON(IS_ERR(data)))
1985                 data = NULL;
1986
1987         rc = xa_store(&device->client_data, client->client_id, data,
1988                       GFP_KERNEL);
1989         WARN_ON(xa_is_err(rc));
1990 }
1991 EXPORT_SYMBOL(ib_set_client_data);
1992
1993 /**
1994  * ib_register_event_handler - Register an IB event handler
1995  * @event_handler:Handler to register
1996  *
1997  * ib_register_event_handler() registers an event handler that will be
1998  * called back when asynchronous IB events occur (as defined in
1999  * chapter 11 of the InfiniBand Architecture Specification). This
2000  * callback occurs in workqueue context.
2001  */
2002 void ib_register_event_handler(struct ib_event_handler *event_handler)
2003 {
2004         down_write(&event_handler->device->event_handler_rwsem);
2005         list_add_tail(&event_handler->list,
2006                       &event_handler->device->event_handler_list);
2007         up_write(&event_handler->device->event_handler_rwsem);
2008 }
2009 EXPORT_SYMBOL(ib_register_event_handler);
2010
2011 /**
2012  * ib_unregister_event_handler - Unregister an event handler
2013  * @event_handler:Handler to unregister
2014  *
2015  * Unregister an event handler registered with
2016  * ib_register_event_handler().
2017  */
2018 void ib_unregister_event_handler(struct ib_event_handler *event_handler)
2019 {
2020         down_write(&event_handler->device->event_handler_rwsem);
2021         list_del(&event_handler->list);
2022         up_write(&event_handler->device->event_handler_rwsem);
2023 }
2024 EXPORT_SYMBOL(ib_unregister_event_handler);
2025
2026 void ib_dispatch_event_clients(struct ib_event *event)
2027 {
2028         struct ib_event_handler *handler;
2029
2030         down_read(&event->device->event_handler_rwsem);
2031
2032         list_for_each_entry(handler, &event->device->event_handler_list, list)
2033                 handler->handler(handler, event);
2034
2035         up_read(&event->device->event_handler_rwsem);
2036 }
2037
2038 static int iw_query_port(struct ib_device *device,
2039                            u32 port_num,
2040                            struct ib_port_attr *port_attr)
2041 {
2042         struct in_device *inetdev;
2043         struct net_device *netdev;
2044
2045         memset(port_attr, 0, sizeof(*port_attr));
2046
2047         netdev = ib_device_get_netdev(device, port_num);
2048         if (!netdev)
2049                 return -ENODEV;
2050
2051         port_attr->max_mtu = IB_MTU_4096;
2052         port_attr->active_mtu = ib_mtu_int_to_enum(netdev->mtu);
2053
2054         if (!netif_carrier_ok(netdev)) {
2055                 port_attr->state = IB_PORT_DOWN;
2056                 port_attr->phys_state = IB_PORT_PHYS_STATE_DISABLED;
2057         } else {
2058                 rcu_read_lock();
2059                 inetdev = __in_dev_get_rcu(netdev);
2060
2061                 if (inetdev && inetdev->ifa_list) {
2062                         port_attr->state = IB_PORT_ACTIVE;
2063                         port_attr->phys_state = IB_PORT_PHYS_STATE_LINK_UP;
2064                 } else {
2065                         port_attr->state = IB_PORT_INIT;
2066                         port_attr->phys_state =
2067                                 IB_PORT_PHYS_STATE_PORT_CONFIGURATION_TRAINING;
2068                 }
2069
2070                 rcu_read_unlock();
2071         }
2072
2073         dev_put(netdev);
2074         return device->ops.query_port(device, port_num, port_attr);
2075 }
2076
2077 static int __ib_query_port(struct ib_device *device,
2078                            u32 port_num,
2079                            struct ib_port_attr *port_attr)
2080 {
2081         int err;
2082
2083         memset(port_attr, 0, sizeof(*port_attr));
2084
2085         err = device->ops.query_port(device, port_num, port_attr);
2086         if (err || port_attr->subnet_prefix)
2087                 return err;
2088
2089         if (rdma_port_get_link_layer(device, port_num) !=
2090             IB_LINK_LAYER_INFINIBAND)
2091                 return 0;
2092
2093         ib_get_cached_subnet_prefix(device, port_num,
2094                                     &port_attr->subnet_prefix);
2095         return 0;
2096 }
2097
2098 /**
2099  * ib_query_port - Query IB port attributes
2100  * @device:Device to query
2101  * @port_num:Port number to query
2102  * @port_attr:Port attributes
2103  *
2104  * ib_query_port() returns the attributes of a port through the
2105  * @port_attr pointer.
2106  */
2107 int ib_query_port(struct ib_device *device,
2108                   u32 port_num,
2109                   struct ib_port_attr *port_attr)
2110 {
2111         if (!rdma_is_port_valid(device, port_num))
2112                 return -EINVAL;
2113
2114         if (rdma_protocol_iwarp(device, port_num))
2115                 return iw_query_port(device, port_num, port_attr);
2116         else
2117                 return __ib_query_port(device, port_num, port_attr);
2118 }
2119 EXPORT_SYMBOL(ib_query_port);
2120
2121 static void add_ndev_hash(struct ib_port_data *pdata)
2122 {
2123         unsigned long flags;
2124
2125         might_sleep();
2126
2127         spin_lock_irqsave(&ndev_hash_lock, flags);
2128         if (hash_hashed(&pdata->ndev_hash_link)) {
2129                 hash_del_rcu(&pdata->ndev_hash_link);
2130                 spin_unlock_irqrestore(&ndev_hash_lock, flags);
2131                 /*
2132                  * We cannot do hash_add_rcu after a hash_del_rcu until the
2133                  * grace period
2134                  */
2135                 synchronize_rcu();
2136                 spin_lock_irqsave(&ndev_hash_lock, flags);
2137         }
2138         if (pdata->netdev)
2139                 hash_add_rcu(ndev_hash, &pdata->ndev_hash_link,
2140                              (uintptr_t)pdata->netdev);
2141         spin_unlock_irqrestore(&ndev_hash_lock, flags);
2142 }
2143
2144 /**
2145  * ib_device_set_netdev - Associate the ib_dev with an underlying net_device
2146  * @ib_dev: Device to modify
2147  * @ndev: net_device to affiliate, may be NULL
2148  * @port: IB port the net_device is connected to
2149  *
2150  * Drivers should use this to link the ib_device to a netdev so the netdev
2151  * shows up in interfaces like ib_enum_roce_netdev. Only one netdev may be
2152  * affiliated with any port.
2153  *
2154  * The caller must ensure that the given ndev is not unregistered or
2155  * unregistering, and that either the ib_device is unregistered or
2156  * ib_device_set_netdev() is called with NULL when the ndev sends a
2157  * NETDEV_UNREGISTER event.
2158  */
2159 int ib_device_set_netdev(struct ib_device *ib_dev, struct net_device *ndev,
2160                          u32 port)
2161 {
2162         struct net_device *old_ndev;
2163         struct ib_port_data *pdata;
2164         unsigned long flags;
2165         int ret;
2166
2167         if (!rdma_is_port_valid(ib_dev, port))
2168                 return -EINVAL;
2169
2170         /*
2171          * Drivers wish to call this before ib_register_driver, so we have to
2172          * setup the port data early.
2173          */
2174         ret = alloc_port_data(ib_dev);
2175         if (ret)
2176                 return ret;
2177
2178         pdata = &ib_dev->port_data[port];
2179         spin_lock_irqsave(&pdata->netdev_lock, flags);
2180         old_ndev = rcu_dereference_protected(
2181                 pdata->netdev, lockdep_is_held(&pdata->netdev_lock));
2182         if (old_ndev == ndev) {
2183                 spin_unlock_irqrestore(&pdata->netdev_lock, flags);
2184                 return 0;
2185         }
2186
2187         rcu_assign_pointer(pdata->netdev, ndev);
2188         netdev_put(old_ndev, &pdata->netdev_tracker);
2189         netdev_hold(ndev, &pdata->netdev_tracker, GFP_ATOMIC);
2190         spin_unlock_irqrestore(&pdata->netdev_lock, flags);
2191
2192         add_ndev_hash(pdata);
2193         return 0;
2194 }
2195 EXPORT_SYMBOL(ib_device_set_netdev);
2196
2197 static void free_netdevs(struct ib_device *ib_dev)
2198 {
2199         unsigned long flags;
2200         u32 port;
2201
2202         if (!ib_dev->port_data)
2203                 return;
2204
2205         rdma_for_each_port (ib_dev, port) {
2206                 struct ib_port_data *pdata = &ib_dev->port_data[port];
2207                 struct net_device *ndev;
2208
2209                 spin_lock_irqsave(&pdata->netdev_lock, flags);
2210                 ndev = rcu_dereference_protected(
2211                         pdata->netdev, lockdep_is_held(&pdata->netdev_lock));
2212                 if (ndev) {
2213                         spin_lock(&ndev_hash_lock);
2214                         hash_del_rcu(&pdata->ndev_hash_link);
2215                         spin_unlock(&ndev_hash_lock);
2216
2217                         /*
2218                          * If this is the last dev_put there is still a
2219                          * synchronize_rcu before the netdev is kfreed, so we
2220                          * can continue to rely on unlocked pointer
2221                          * comparisons after the put
2222                          */
2223                         rcu_assign_pointer(pdata->netdev, NULL);
2224                         netdev_put(ndev, &pdata->netdev_tracker);
2225                 }
2226                 spin_unlock_irqrestore(&pdata->netdev_lock, flags);
2227         }
2228 }
2229
2230 struct net_device *ib_device_get_netdev(struct ib_device *ib_dev,
2231                                         u32 port)
2232 {
2233         struct ib_port_data *pdata;
2234         struct net_device *res;
2235
2236         if (!rdma_is_port_valid(ib_dev, port))
2237                 return NULL;
2238
2239         pdata = &ib_dev->port_data[port];
2240
2241         /*
2242          * New drivers should use ib_device_set_netdev() not the legacy
2243          * get_netdev().
2244          */
2245         if (ib_dev->ops.get_netdev)
2246                 res = ib_dev->ops.get_netdev(ib_dev, port);
2247         else {
2248                 spin_lock(&pdata->netdev_lock);
2249                 res = rcu_dereference_protected(
2250                         pdata->netdev, lockdep_is_held(&pdata->netdev_lock));
2251                 dev_hold(res);
2252                 spin_unlock(&pdata->netdev_lock);
2253         }
2254
2255         /*
2256          * If we are starting to unregister expedite things by preventing
2257          * propagation of an unregistering netdev.
2258          */
2259         if (res && res->reg_state != NETREG_REGISTERED) {
2260                 dev_put(res);
2261                 return NULL;
2262         }
2263
2264         return res;
2265 }
2266
2267 /**
2268  * ib_device_get_by_netdev - Find an IB device associated with a netdev
2269  * @ndev: netdev to locate
2270  * @driver_id: The driver ID that must match (RDMA_DRIVER_UNKNOWN matches all)
2271  *
2272  * Find and hold an ib_device that is associated with a netdev via
2273  * ib_device_set_netdev(). The caller must call ib_device_put() on the
2274  * returned pointer.
2275  */
2276 struct ib_device *ib_device_get_by_netdev(struct net_device *ndev,
2277                                           enum rdma_driver_id driver_id)
2278 {
2279         struct ib_device *res = NULL;
2280         struct ib_port_data *cur;
2281
2282         rcu_read_lock();
2283         hash_for_each_possible_rcu (ndev_hash, cur, ndev_hash_link,
2284                                     (uintptr_t)ndev) {
2285                 if (rcu_access_pointer(cur->netdev) == ndev &&
2286                     (driver_id == RDMA_DRIVER_UNKNOWN ||
2287                      cur->ib_dev->ops.driver_id == driver_id) &&
2288                     ib_device_try_get(cur->ib_dev)) {
2289                         res = cur->ib_dev;
2290                         break;
2291                 }
2292         }
2293         rcu_read_unlock();
2294
2295         return res;
2296 }
2297 EXPORT_SYMBOL(ib_device_get_by_netdev);
2298
2299 /**
2300  * ib_enum_roce_netdev - enumerate all RoCE ports
2301  * @ib_dev : IB device we want to query
2302  * @filter: Should we call the callback?
2303  * @filter_cookie: Cookie passed to filter
2304  * @cb: Callback to call for each found RoCE ports
2305  * @cookie: Cookie passed back to the callback
2306  *
2307  * Enumerates all of the physical RoCE ports of ib_dev
2308  * which are related to netdevice and calls callback() on each
2309  * device for which filter() function returns non zero.
2310  */
2311 void ib_enum_roce_netdev(struct ib_device *ib_dev,
2312                          roce_netdev_filter filter,
2313                          void *filter_cookie,
2314                          roce_netdev_callback cb,
2315                          void *cookie)
2316 {
2317         u32 port;
2318
2319         rdma_for_each_port (ib_dev, port)
2320                 if (rdma_protocol_roce(ib_dev, port)) {
2321                         struct net_device *idev =
2322                                 ib_device_get_netdev(ib_dev, port);
2323
2324                         if (filter(ib_dev, port, idev, filter_cookie))
2325                                 cb(ib_dev, port, idev, cookie);
2326                         dev_put(idev);
2327                 }
2328 }
2329
2330 /**
2331  * ib_enum_all_roce_netdevs - enumerate all RoCE devices
2332  * @filter: Should we call the callback?
2333  * @filter_cookie: Cookie passed to filter
2334  * @cb: Callback to call for each found RoCE ports
2335  * @cookie: Cookie passed back to the callback
2336  *
2337  * Enumerates all RoCE devices' physical ports which are related
2338  * to netdevices and calls callback() on each device for which
2339  * filter() function returns non zero.
2340  */
2341 void ib_enum_all_roce_netdevs(roce_netdev_filter filter,
2342                               void *filter_cookie,
2343                               roce_netdev_callback cb,
2344                               void *cookie)
2345 {
2346         struct ib_device *dev;
2347         unsigned long index;
2348
2349         down_read(&devices_rwsem);
2350         xa_for_each_marked (&devices, index, dev, DEVICE_REGISTERED)
2351                 ib_enum_roce_netdev(dev, filter, filter_cookie, cb, cookie);
2352         up_read(&devices_rwsem);
2353 }
2354
2355 /*
2356  * ib_enum_all_devs - enumerate all ib_devices
2357  * @cb: Callback to call for each found ib_device
2358  *
2359  * Enumerates all ib_devices and calls callback() on each device.
2360  */
2361 int ib_enum_all_devs(nldev_callback nldev_cb, struct sk_buff *skb,
2362                      struct netlink_callback *cb)
2363 {
2364         unsigned long index;
2365         struct ib_device *dev;
2366         unsigned int idx = 0;
2367         int ret = 0;
2368
2369         down_read(&devices_rwsem);
2370         xa_for_each_marked (&devices, index, dev, DEVICE_REGISTERED) {
2371                 if (!rdma_dev_access_netns(dev, sock_net(skb->sk)))
2372                         continue;
2373
2374                 ret = nldev_cb(dev, skb, cb, idx);
2375                 if (ret)
2376                         break;
2377                 idx++;
2378         }
2379         up_read(&devices_rwsem);
2380         return ret;
2381 }
2382
2383 /**
2384  * ib_query_pkey - Get P_Key table entry
2385  * @device:Device to query
2386  * @port_num:Port number to query
2387  * @index:P_Key table index to query
2388  * @pkey:Returned P_Key
2389  *
2390  * ib_query_pkey() fetches the specified P_Key table entry.
2391  */
2392 int ib_query_pkey(struct ib_device *device,
2393                   u32 port_num, u16 index, u16 *pkey)
2394 {
2395         if (!rdma_is_port_valid(device, port_num))
2396                 return -EINVAL;
2397
2398         if (!device->ops.query_pkey)
2399                 return -EOPNOTSUPP;
2400
2401         return device->ops.query_pkey(device, port_num, index, pkey);
2402 }
2403 EXPORT_SYMBOL(ib_query_pkey);
2404
2405 /**
2406  * ib_modify_device - Change IB device attributes
2407  * @device:Device to modify
2408  * @device_modify_mask:Mask of attributes to change
2409  * @device_modify:New attribute values
2410  *
2411  * ib_modify_device() changes a device's attributes as specified by
2412  * the @device_modify_mask and @device_modify structure.
2413  */
2414 int ib_modify_device(struct ib_device *device,
2415                      int device_modify_mask,
2416                      struct ib_device_modify *device_modify)
2417 {
2418         if (!device->ops.modify_device)
2419                 return -EOPNOTSUPP;
2420
2421         return device->ops.modify_device(device, device_modify_mask,
2422                                          device_modify);
2423 }
2424 EXPORT_SYMBOL(ib_modify_device);
2425
2426 /**
2427  * ib_modify_port - Modifies the attributes for the specified port.
2428  * @device: The device to modify.
2429  * @port_num: The number of the port to modify.
2430  * @port_modify_mask: Mask used to specify which attributes of the port
2431  *   to change.
2432  * @port_modify: New attribute values for the port.
2433  *
2434  * ib_modify_port() changes a port's attributes as specified by the
2435  * @port_modify_mask and @port_modify structure.
2436  */
2437 int ib_modify_port(struct ib_device *device,
2438                    u32 port_num, int port_modify_mask,
2439                    struct ib_port_modify *port_modify)
2440 {
2441         int rc;
2442
2443         if (!rdma_is_port_valid(device, port_num))
2444                 return -EINVAL;
2445
2446         if (device->ops.modify_port)
2447                 rc = device->ops.modify_port(device, port_num,
2448                                              port_modify_mask,
2449                                              port_modify);
2450         else if (rdma_protocol_roce(device, port_num) &&
2451                  ((port_modify->set_port_cap_mask & ~IB_PORT_CM_SUP) == 0 ||
2452                   (port_modify->clr_port_cap_mask & ~IB_PORT_CM_SUP) == 0))
2453                 rc = 0;
2454         else
2455                 rc = -EOPNOTSUPP;
2456         return rc;
2457 }
2458 EXPORT_SYMBOL(ib_modify_port);
2459
2460 /**
2461  * ib_find_gid - Returns the port number and GID table index where
2462  *   a specified GID value occurs. Its searches only for IB link layer.
2463  * @device: The device to query.
2464  * @gid: The GID value to search for.
2465  * @port_num: The port number of the device where the GID value was found.
2466  * @index: The index into the GID table where the GID was found.  This
2467  *   parameter may be NULL.
2468  */
2469 int ib_find_gid(struct ib_device *device, union ib_gid *gid,
2470                 u32 *port_num, u16 *index)
2471 {
2472         union ib_gid tmp_gid;
2473         u32 port;
2474         int ret, i;
2475
2476         rdma_for_each_port (device, port) {
2477                 if (!rdma_protocol_ib(device, port))
2478                         continue;
2479
2480                 for (i = 0; i < device->port_data[port].immutable.gid_tbl_len;
2481                      ++i) {
2482                         ret = rdma_query_gid(device, port, i, &tmp_gid);
2483                         if (ret)
2484                                 continue;
2485
2486                         if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
2487                                 *port_num = port;
2488                                 if (index)
2489                                         *index = i;
2490                                 return 0;
2491                         }
2492                 }
2493         }
2494
2495         return -ENOENT;
2496 }
2497 EXPORT_SYMBOL(ib_find_gid);
2498
2499 /**
2500  * ib_find_pkey - Returns the PKey table index where a specified
2501  *   PKey value occurs.
2502  * @device: The device to query.
2503  * @port_num: The port number of the device to search for the PKey.
2504  * @pkey: The PKey value to search for.
2505  * @index: The index into the PKey table where the PKey was found.
2506  */
2507 int ib_find_pkey(struct ib_device *device,
2508                  u32 port_num, u16 pkey, u16 *index)
2509 {
2510         int ret, i;
2511         u16 tmp_pkey;
2512         int partial_ix = -1;
2513
2514         for (i = 0; i < device->port_data[port_num].immutable.pkey_tbl_len;
2515              ++i) {
2516                 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
2517                 if (ret)
2518                         return ret;
2519                 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
2520                         /* if there is full-member pkey take it.*/
2521                         if (tmp_pkey & 0x8000) {
2522                                 *index = i;
2523                                 return 0;
2524                         }
2525                         if (partial_ix < 0)
2526                                 partial_ix = i;
2527                 }
2528         }
2529
2530         /*no full-member, if exists take the limited*/
2531         if (partial_ix >= 0) {
2532                 *index = partial_ix;
2533                 return 0;
2534         }
2535         return -ENOENT;
2536 }
2537 EXPORT_SYMBOL(ib_find_pkey);
2538
2539 /**
2540  * ib_get_net_dev_by_params() - Return the appropriate net_dev
2541  * for a received CM request
2542  * @dev:        An RDMA device on which the request has been received.
2543  * @port:       Port number on the RDMA device.
2544  * @pkey:       The Pkey the request came on.
2545  * @gid:        A GID that the net_dev uses to communicate.
2546  * @addr:       Contains the IP address that the request specified as its
2547  *              destination.
2548  *
2549  */
2550 struct net_device *ib_get_net_dev_by_params(struct ib_device *dev,
2551                                             u32 port,
2552                                             u16 pkey,
2553                                             const union ib_gid *gid,
2554                                             const struct sockaddr *addr)
2555 {
2556         struct net_device *net_dev = NULL;
2557         unsigned long index;
2558         void *client_data;
2559
2560         if (!rdma_protocol_ib(dev, port))
2561                 return NULL;
2562
2563         /*
2564          * Holding the read side guarantees that the client will not become
2565          * unregistered while we are calling get_net_dev_by_params()
2566          */
2567         down_read(&dev->client_data_rwsem);
2568         xan_for_each_marked (&dev->client_data, index, client_data,
2569                              CLIENT_DATA_REGISTERED) {
2570                 struct ib_client *client = xa_load(&clients, index);
2571
2572                 if (!client || !client->get_net_dev_by_params)
2573                         continue;
2574
2575                 net_dev = client->get_net_dev_by_params(dev, port, pkey, gid,
2576                                                         addr, client_data);
2577                 if (net_dev)
2578                         break;
2579         }
2580         up_read(&dev->client_data_rwsem);
2581
2582         return net_dev;
2583 }
2584 EXPORT_SYMBOL(ib_get_net_dev_by_params);
2585
2586 void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops)
2587 {
2588         struct ib_device_ops *dev_ops = &dev->ops;
2589 #define SET_DEVICE_OP(ptr, name)                                               \
2590         do {                                                                   \
2591                 if (ops->name)                                                 \
2592                         if (!((ptr)->name))                                    \
2593                                 (ptr)->name = ops->name;                       \
2594         } while (0)
2595
2596 #define SET_OBJ_SIZE(ptr, name) SET_DEVICE_OP(ptr, size_##name)
2597
2598         if (ops->driver_id != RDMA_DRIVER_UNKNOWN) {
2599                 WARN_ON(dev_ops->driver_id != RDMA_DRIVER_UNKNOWN &&
2600                         dev_ops->driver_id != ops->driver_id);
2601                 dev_ops->driver_id = ops->driver_id;
2602         }
2603         if (ops->owner) {
2604                 WARN_ON(dev_ops->owner && dev_ops->owner != ops->owner);
2605                 dev_ops->owner = ops->owner;
2606         }
2607         if (ops->uverbs_abi_ver)
2608                 dev_ops->uverbs_abi_ver = ops->uverbs_abi_ver;
2609
2610         dev_ops->uverbs_no_driver_id_binding |=
2611                 ops->uverbs_no_driver_id_binding;
2612
2613         SET_DEVICE_OP(dev_ops, add_gid);
2614         SET_DEVICE_OP(dev_ops, add_sub_dev);
2615         SET_DEVICE_OP(dev_ops, advise_mr);
2616         SET_DEVICE_OP(dev_ops, alloc_dm);
2617         SET_DEVICE_OP(dev_ops, alloc_hw_device_stats);
2618         SET_DEVICE_OP(dev_ops, alloc_hw_port_stats);
2619         SET_DEVICE_OP(dev_ops, alloc_mr);
2620         SET_DEVICE_OP(dev_ops, alloc_mr_integrity);
2621         SET_DEVICE_OP(dev_ops, alloc_mw);
2622         SET_DEVICE_OP(dev_ops, alloc_pd);
2623         SET_DEVICE_OP(dev_ops, alloc_rdma_netdev);
2624         SET_DEVICE_OP(dev_ops, alloc_ucontext);
2625         SET_DEVICE_OP(dev_ops, alloc_xrcd);
2626         SET_DEVICE_OP(dev_ops, attach_mcast);
2627         SET_DEVICE_OP(dev_ops, check_mr_status);
2628         SET_DEVICE_OP(dev_ops, counter_alloc_stats);
2629         SET_DEVICE_OP(dev_ops, counter_bind_qp);
2630         SET_DEVICE_OP(dev_ops, counter_dealloc);
2631         SET_DEVICE_OP(dev_ops, counter_unbind_qp);
2632         SET_DEVICE_OP(dev_ops, counter_update_stats);
2633         SET_DEVICE_OP(dev_ops, create_ah);
2634         SET_DEVICE_OP(dev_ops, create_counters);
2635         SET_DEVICE_OP(dev_ops, create_cq);
2636         SET_DEVICE_OP(dev_ops, create_flow);
2637         SET_DEVICE_OP(dev_ops, create_qp);
2638         SET_DEVICE_OP(dev_ops, create_rwq_ind_table);
2639         SET_DEVICE_OP(dev_ops, create_srq);
2640         SET_DEVICE_OP(dev_ops, create_user_ah);
2641         SET_DEVICE_OP(dev_ops, create_wq);
2642         SET_DEVICE_OP(dev_ops, dealloc_dm);
2643         SET_DEVICE_OP(dev_ops, dealloc_driver);
2644         SET_DEVICE_OP(dev_ops, dealloc_mw);
2645         SET_DEVICE_OP(dev_ops, dealloc_pd);
2646         SET_DEVICE_OP(dev_ops, dealloc_ucontext);
2647         SET_DEVICE_OP(dev_ops, dealloc_xrcd);
2648         SET_DEVICE_OP(dev_ops, del_gid);
2649         SET_DEVICE_OP(dev_ops, del_sub_dev);
2650         SET_DEVICE_OP(dev_ops, dereg_mr);
2651         SET_DEVICE_OP(dev_ops, destroy_ah);
2652         SET_DEVICE_OP(dev_ops, destroy_counters);
2653         SET_DEVICE_OP(dev_ops, destroy_cq);
2654         SET_DEVICE_OP(dev_ops, destroy_flow);
2655         SET_DEVICE_OP(dev_ops, destroy_flow_action);
2656         SET_DEVICE_OP(dev_ops, destroy_qp);
2657         SET_DEVICE_OP(dev_ops, destroy_rwq_ind_table);
2658         SET_DEVICE_OP(dev_ops, destroy_srq);
2659         SET_DEVICE_OP(dev_ops, destroy_wq);
2660         SET_DEVICE_OP(dev_ops, device_group);
2661         SET_DEVICE_OP(dev_ops, detach_mcast);
2662         SET_DEVICE_OP(dev_ops, disassociate_ucontext);
2663         SET_DEVICE_OP(dev_ops, drain_rq);
2664         SET_DEVICE_OP(dev_ops, drain_sq);
2665         SET_DEVICE_OP(dev_ops, enable_driver);
2666         SET_DEVICE_OP(dev_ops, fill_res_cm_id_entry);
2667         SET_DEVICE_OP(dev_ops, fill_res_cq_entry);
2668         SET_DEVICE_OP(dev_ops, fill_res_cq_entry_raw);
2669         SET_DEVICE_OP(dev_ops, fill_res_mr_entry);
2670         SET_DEVICE_OP(dev_ops, fill_res_mr_entry_raw);
2671         SET_DEVICE_OP(dev_ops, fill_res_qp_entry);
2672         SET_DEVICE_OP(dev_ops, fill_res_qp_entry_raw);
2673         SET_DEVICE_OP(dev_ops, fill_res_srq_entry);
2674         SET_DEVICE_OP(dev_ops, fill_res_srq_entry_raw);
2675         SET_DEVICE_OP(dev_ops, fill_stat_mr_entry);
2676         SET_DEVICE_OP(dev_ops, get_dev_fw_str);
2677         SET_DEVICE_OP(dev_ops, get_dma_mr);
2678         SET_DEVICE_OP(dev_ops, get_hw_stats);
2679         SET_DEVICE_OP(dev_ops, get_link_layer);
2680         SET_DEVICE_OP(dev_ops, get_netdev);
2681         SET_DEVICE_OP(dev_ops, get_numa_node);
2682         SET_DEVICE_OP(dev_ops, get_port_immutable);
2683         SET_DEVICE_OP(dev_ops, get_vector_affinity);
2684         SET_DEVICE_OP(dev_ops, get_vf_config);
2685         SET_DEVICE_OP(dev_ops, get_vf_guid);
2686         SET_DEVICE_OP(dev_ops, get_vf_stats);
2687         SET_DEVICE_OP(dev_ops, iw_accept);
2688         SET_DEVICE_OP(dev_ops, iw_add_ref);
2689         SET_DEVICE_OP(dev_ops, iw_connect);
2690         SET_DEVICE_OP(dev_ops, iw_create_listen);
2691         SET_DEVICE_OP(dev_ops, iw_destroy_listen);
2692         SET_DEVICE_OP(dev_ops, iw_get_qp);
2693         SET_DEVICE_OP(dev_ops, iw_reject);
2694         SET_DEVICE_OP(dev_ops, iw_rem_ref);
2695         SET_DEVICE_OP(dev_ops, map_mr_sg);
2696         SET_DEVICE_OP(dev_ops, map_mr_sg_pi);
2697         SET_DEVICE_OP(dev_ops, mmap);
2698         SET_DEVICE_OP(dev_ops, mmap_free);
2699         SET_DEVICE_OP(dev_ops, modify_ah);
2700         SET_DEVICE_OP(dev_ops, modify_cq);
2701         SET_DEVICE_OP(dev_ops, modify_device);
2702         SET_DEVICE_OP(dev_ops, modify_hw_stat);
2703         SET_DEVICE_OP(dev_ops, modify_port);
2704         SET_DEVICE_OP(dev_ops, modify_qp);
2705         SET_DEVICE_OP(dev_ops, modify_srq);
2706         SET_DEVICE_OP(dev_ops, modify_wq);
2707         SET_DEVICE_OP(dev_ops, peek_cq);
2708         SET_DEVICE_OP(dev_ops, poll_cq);
2709         SET_DEVICE_OP(dev_ops, port_groups);
2710         SET_DEVICE_OP(dev_ops, post_recv);
2711         SET_DEVICE_OP(dev_ops, post_send);
2712         SET_DEVICE_OP(dev_ops, post_srq_recv);
2713         SET_DEVICE_OP(dev_ops, process_mad);
2714         SET_DEVICE_OP(dev_ops, query_ah);
2715         SET_DEVICE_OP(dev_ops, query_device);
2716         SET_DEVICE_OP(dev_ops, query_gid);
2717         SET_DEVICE_OP(dev_ops, query_pkey);
2718         SET_DEVICE_OP(dev_ops, query_port);
2719         SET_DEVICE_OP(dev_ops, query_qp);
2720         SET_DEVICE_OP(dev_ops, query_srq);
2721         SET_DEVICE_OP(dev_ops, query_ucontext);
2722         SET_DEVICE_OP(dev_ops, rdma_netdev_get_params);
2723         SET_DEVICE_OP(dev_ops, read_counters);
2724         SET_DEVICE_OP(dev_ops, reg_dm_mr);
2725         SET_DEVICE_OP(dev_ops, reg_user_mr);
2726         SET_DEVICE_OP(dev_ops, reg_user_mr_dmabuf);
2727         SET_DEVICE_OP(dev_ops, req_notify_cq);
2728         SET_DEVICE_OP(dev_ops, rereg_user_mr);
2729         SET_DEVICE_OP(dev_ops, resize_cq);
2730         SET_DEVICE_OP(dev_ops, set_vf_guid);
2731         SET_DEVICE_OP(dev_ops, set_vf_link_state);
2732
2733         SET_OBJ_SIZE(dev_ops, ib_ah);
2734         SET_OBJ_SIZE(dev_ops, ib_counters);
2735         SET_OBJ_SIZE(dev_ops, ib_cq);
2736         SET_OBJ_SIZE(dev_ops, ib_mw);
2737         SET_OBJ_SIZE(dev_ops, ib_pd);
2738         SET_OBJ_SIZE(dev_ops, ib_qp);
2739         SET_OBJ_SIZE(dev_ops, ib_rwq_ind_table);
2740         SET_OBJ_SIZE(dev_ops, ib_srq);
2741         SET_OBJ_SIZE(dev_ops, ib_ucontext);
2742         SET_OBJ_SIZE(dev_ops, ib_xrcd);
2743 }
2744 EXPORT_SYMBOL(ib_set_device_ops);
2745
2746 int ib_add_sub_device(struct ib_device *parent,
2747                       enum rdma_nl_dev_type type,
2748                       const char *name)
2749 {
2750         struct ib_device *sub;
2751         int ret = 0;
2752
2753         if (!parent->ops.add_sub_dev || !parent->ops.del_sub_dev)
2754                 return -EOPNOTSUPP;
2755
2756         if (!ib_device_try_get(parent))
2757                 return -EINVAL;
2758
2759         sub = parent->ops.add_sub_dev(parent, type, name);
2760         if (IS_ERR(sub)) {
2761                 ib_device_put(parent);
2762                 return PTR_ERR(sub);
2763         }
2764
2765         sub->type = type;
2766         sub->parent = parent;
2767
2768         mutex_lock(&parent->subdev_lock);
2769         list_add_tail(&parent->subdev_list_head, &sub->subdev_list);
2770         mutex_unlock(&parent->subdev_lock);
2771
2772         return ret;
2773 }
2774 EXPORT_SYMBOL(ib_add_sub_device);
2775
2776 int ib_del_sub_device_and_put(struct ib_device *sub)
2777 {
2778         struct ib_device *parent = sub->parent;
2779
2780         if (!parent)
2781                 return -EOPNOTSUPP;
2782
2783         mutex_lock(&parent->subdev_lock);
2784         list_del(&sub->subdev_list);
2785         mutex_unlock(&parent->subdev_lock);
2786
2787         ib_device_put(sub);
2788         parent->ops.del_sub_dev(sub);
2789         ib_device_put(parent);
2790
2791         return 0;
2792 }
2793 EXPORT_SYMBOL(ib_del_sub_device_and_put);
2794
2795 #ifdef CONFIG_INFINIBAND_VIRT_DMA
2796 int ib_dma_virt_map_sg(struct ib_device *dev, struct scatterlist *sg, int nents)
2797 {
2798         struct scatterlist *s;
2799         int i;
2800
2801         for_each_sg(sg, s, nents, i) {
2802                 sg_dma_address(s) = (uintptr_t)sg_virt(s);
2803                 sg_dma_len(s) = s->length;
2804         }
2805         return nents;
2806 }
2807 EXPORT_SYMBOL(ib_dma_virt_map_sg);
2808 #endif /* CONFIG_INFINIBAND_VIRT_DMA */
2809
2810 static const struct rdma_nl_cbs ibnl_ls_cb_table[RDMA_NL_LS_NUM_OPS] = {
2811         [RDMA_NL_LS_OP_RESOLVE] = {
2812                 .doit = ib_nl_handle_resolve_resp,
2813                 .flags = RDMA_NL_ADMIN_PERM,
2814         },
2815         [RDMA_NL_LS_OP_SET_TIMEOUT] = {
2816                 .doit = ib_nl_handle_set_timeout,
2817                 .flags = RDMA_NL_ADMIN_PERM,
2818         },
2819         [RDMA_NL_LS_OP_IP_RESOLVE] = {
2820                 .doit = ib_nl_handle_ip_res_resp,
2821                 .flags = RDMA_NL_ADMIN_PERM,
2822         },
2823 };
2824
2825 static int __init ib_core_init(void)
2826 {
2827         int ret = -ENOMEM;
2828
2829         ib_wq = alloc_workqueue("infiniband", 0, 0);
2830         if (!ib_wq)
2831                 return -ENOMEM;
2832
2833         ib_unreg_wq = alloc_workqueue("ib-unreg-wq", WQ_UNBOUND,
2834                                       WQ_UNBOUND_MAX_ACTIVE);
2835         if (!ib_unreg_wq)
2836                 goto err;
2837
2838         ib_comp_wq = alloc_workqueue("ib-comp-wq",
2839                         WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_SYSFS, 0);
2840         if (!ib_comp_wq)
2841                 goto err_unbound;
2842
2843         ib_comp_unbound_wq =
2844                 alloc_workqueue("ib-comp-unb-wq",
2845                                 WQ_UNBOUND | WQ_HIGHPRI | WQ_MEM_RECLAIM |
2846                                 WQ_SYSFS, WQ_UNBOUND_MAX_ACTIVE);
2847         if (!ib_comp_unbound_wq)
2848                 goto err_comp;
2849
2850         ret = class_register(&ib_class);
2851         if (ret) {
2852                 pr_warn("Couldn't create InfiniBand device class\n");
2853                 goto err_comp_unbound;
2854         }
2855
2856         rdma_nl_init();
2857
2858         ret = addr_init();
2859         if (ret) {
2860                 pr_warn("Couldn't init IB address resolution\n");
2861                 goto err_ibnl;
2862         }
2863
2864         ret = ib_mad_init();
2865         if (ret) {
2866                 pr_warn("Couldn't init IB MAD\n");
2867                 goto err_addr;
2868         }
2869
2870         ret = ib_sa_init();
2871         if (ret) {
2872                 pr_warn("Couldn't init SA\n");
2873                 goto err_mad;
2874         }
2875
2876         ret = register_blocking_lsm_notifier(&ibdev_lsm_nb);
2877         if (ret) {
2878                 pr_warn("Couldn't register LSM notifier. ret %d\n", ret);
2879                 goto err_sa;
2880         }
2881
2882         ret = register_pernet_device(&rdma_dev_net_ops);
2883         if (ret) {
2884                 pr_warn("Couldn't init compat dev. ret %d\n", ret);
2885                 goto err_compat;
2886         }
2887
2888         nldev_init();
2889         rdma_nl_register(RDMA_NL_LS, ibnl_ls_cb_table);
2890         ret = roce_gid_mgmt_init();
2891         if (ret) {
2892                 pr_warn("Couldn't init RoCE GID management\n");
2893                 goto err_parent;
2894         }
2895
2896         return 0;
2897
2898 err_parent:
2899         rdma_nl_unregister(RDMA_NL_LS);
2900         nldev_exit();
2901         unregister_pernet_device(&rdma_dev_net_ops);
2902 err_compat:
2903         unregister_blocking_lsm_notifier(&ibdev_lsm_nb);
2904 err_sa:
2905         ib_sa_cleanup();
2906 err_mad:
2907         ib_mad_cleanup();
2908 err_addr:
2909         addr_cleanup();
2910 err_ibnl:
2911         class_unregister(&ib_class);
2912 err_comp_unbound:
2913         destroy_workqueue(ib_comp_unbound_wq);
2914 err_comp:
2915         destroy_workqueue(ib_comp_wq);
2916 err_unbound:
2917         destroy_workqueue(ib_unreg_wq);
2918 err:
2919         destroy_workqueue(ib_wq);
2920         return ret;
2921 }
2922
2923 static void __exit ib_core_cleanup(void)
2924 {
2925         roce_gid_mgmt_cleanup();
2926         rdma_nl_unregister(RDMA_NL_LS);
2927         nldev_exit();
2928         unregister_pernet_device(&rdma_dev_net_ops);
2929         unregister_blocking_lsm_notifier(&ibdev_lsm_nb);
2930         ib_sa_cleanup();
2931         ib_mad_cleanup();
2932         addr_cleanup();
2933         rdma_nl_exit();
2934         class_unregister(&ib_class);
2935         destroy_workqueue(ib_comp_unbound_wq);
2936         destroy_workqueue(ib_comp_wq);
2937         /* Make sure that any pending umem accounting work is done. */
2938         destroy_workqueue(ib_wq);
2939         destroy_workqueue(ib_unreg_wq);
2940         WARN_ON(!xa_empty(&clients));
2941         WARN_ON(!xa_empty(&devices));
2942 }
2943
2944 MODULE_ALIAS_RDMA_NETLINK(RDMA_NL_LS, 4);
2945
2946 /* ib core relies on netdev stack to first register net_ns_type_operations
2947  * ns kobject type before ib_core initialization.
2948  */
2949 fs_initcall(ib_core_init);
2950 module_exit(ib_core_cleanup);
This page took 0.199078 seconds and 4 git commands to generate.