2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2004 Topspin Communications. All rights reserved.
|
2005-08-11 14:03:10 +08:00
|
|
|
* Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* This software is available to you under a choice of one of two
|
|
|
|
* licenses. You may choose to be licensed under the terms of the GNU
|
|
|
|
* General Public License (GPL) Version 2, available from the file
|
|
|
|
* COPYING in the main directory of this source tree, or the
|
|
|
|
* OpenIB.org BSD license below:
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or
|
|
|
|
* without modification, are permitted provided that the following
|
|
|
|
* conditions are met:
|
|
|
|
*
|
|
|
|
* - Redistributions of source code must retain the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer.
|
|
|
|
*
|
|
|
|
* - Redistributions in binary form must reproduce the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer in the documentation and/or other materials
|
|
|
|
* provided with the distribution.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
2007-02-07 00:07:25 +08:00
|
|
|
#include <linux/kernel.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
2006-01-14 06:51:39 +08:00
|
|
|
#include <linux/mutex.h>
|
2015-07-30 22:50:15 +08:00
|
|
|
#include <linux/netdevice.h>
|
2011-05-21 02:46:11 +08:00
|
|
|
#include <rdma/rdma_netlink.h>
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
#include <rdma/ib_addr.h>
|
|
|
|
#include <rdma/ib_cache.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include "core_priv.h"
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Roland Dreier");
|
|
|
|
MODULE_DESCRIPTION("core kernel InfiniBand API");
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
|
|
|
|
struct ib_client_data {
|
|
|
|
struct list_head list;
|
|
|
|
struct ib_client *client;
|
|
|
|
void * data;
|
2015-07-30 22:50:14 +08:00
|
|
|
/* The device or client is going down. Do not call client or device
|
|
|
|
* callbacks other than remove(). */
|
|
|
|
bool going_down;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2015-12-12 03:53:03 +08:00
|
|
|
struct workqueue_struct *ib_comp_wq;
|
2010-10-19 23:24:36 +08:00
|
|
|
struct workqueue_struct *ib_wq;
|
|
|
|
EXPORT_SYMBOL_GPL(ib_wq);
|
|
|
|
|
2015-07-30 22:50:13 +08:00
|
|
|
/* The device_list and client_list contain devices and clients after their
|
|
|
|
* registration has completed, and the devices and clients are removed
|
|
|
|
* during unregistration. */
|
2005-04-17 06:20:36 +08:00
|
|
|
static LIST_HEAD(device_list);
|
|
|
|
static LIST_HEAD(client_list);
|
|
|
|
|
|
|
|
/*
|
2015-07-30 22:50:13 +08:00
|
|
|
* device_mutex and lists_rwsem protect access to both device_list and
|
|
|
|
* client_list. device_mutex protects writer access by device and client
|
|
|
|
* registration / de-registration. lists_rwsem protects reader access to
|
|
|
|
* these lists. Iterators of these lists must lock it for read, while updates
|
|
|
|
* to the lists must be done with a write lock. A special case is when the
|
|
|
|
* device_mutex is locked. In this case locking the lists for read access is
|
|
|
|
* not necessary as the device_mutex implies it.
|
2015-07-30 22:50:14 +08:00
|
|
|
*
|
|
|
|
* lists_rwsem also protects access to the client data list.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2006-01-14 06:51:39 +08:00
|
|
|
static DEFINE_MUTEX(device_mutex);
|
2015-07-30 22:50:13 +08:00
|
|
|
static DECLARE_RWSEM(lists_rwsem);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static int ib_device_check_mandatory(struct ib_device *device)
|
|
|
|
{
|
|
|
|
#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x }
|
|
|
|
static const struct {
|
|
|
|
size_t offset;
|
|
|
|
char *name;
|
|
|
|
} mandatory_table[] = {
|
|
|
|
IB_MANDATORY_FUNC(query_device),
|
|
|
|
IB_MANDATORY_FUNC(query_port),
|
|
|
|
IB_MANDATORY_FUNC(query_pkey),
|
|
|
|
IB_MANDATORY_FUNC(query_gid),
|
|
|
|
IB_MANDATORY_FUNC(alloc_pd),
|
|
|
|
IB_MANDATORY_FUNC(dealloc_pd),
|
|
|
|
IB_MANDATORY_FUNC(create_ah),
|
|
|
|
IB_MANDATORY_FUNC(destroy_ah),
|
|
|
|
IB_MANDATORY_FUNC(create_qp),
|
|
|
|
IB_MANDATORY_FUNC(modify_qp),
|
|
|
|
IB_MANDATORY_FUNC(destroy_qp),
|
|
|
|
IB_MANDATORY_FUNC(post_send),
|
|
|
|
IB_MANDATORY_FUNC(post_recv),
|
|
|
|
IB_MANDATORY_FUNC(create_cq),
|
|
|
|
IB_MANDATORY_FUNC(destroy_cq),
|
|
|
|
IB_MANDATORY_FUNC(poll_cq),
|
|
|
|
IB_MANDATORY_FUNC(req_notify_cq),
|
|
|
|
IB_MANDATORY_FUNC(get_dma_mr),
|
2015-05-14 08:02:58 +08:00
|
|
|
IB_MANDATORY_FUNC(dereg_mr),
|
|
|
|
IB_MANDATORY_FUNC(get_port_immutable)
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
2007-02-07 00:07:25 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!*(void **) ((void *) device + mandatory_table[i].offset)) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Device %s is missing mandatory function %s\n",
|
|
|
|
device->name, mandatory_table[i].name);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ib_device *__ib_device_get_by_name(const char *name)
|
|
|
|
{
|
|
|
|
struct ib_device *device;
|
|
|
|
|
|
|
|
list_for_each_entry(device, &device_list, core_list)
|
|
|
|
if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX))
|
|
|
|
return device;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int alloc_name(char *name)
|
|
|
|
{
|
2007-10-10 10:59:04 +08:00
|
|
|
unsigned long *inuse;
|
2005-04-17 06:20:36 +08:00
|
|
|
char buf[IB_DEVICE_NAME_MAX];
|
|
|
|
struct ib_device *device;
|
|
|
|
int i;
|
|
|
|
|
2007-10-10 10:59:04 +08:00
|
|
|
inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!inuse)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
list_for_each_entry(device, &device_list, core_list) {
|
|
|
|
if (!sscanf(device->name, name, &i))
|
|
|
|
continue;
|
|
|
|
if (i < 0 || i >= PAGE_SIZE * 8)
|
|
|
|
continue;
|
|
|
|
snprintf(buf, sizeof buf, name, i);
|
|
|
|
if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX))
|
|
|
|
set_bit(i, inuse);
|
|
|
|
}
|
|
|
|
|
|
|
|
i = find_first_zero_bit(inuse, PAGE_SIZE * 8);
|
|
|
|
free_page((unsigned long) inuse);
|
|
|
|
snprintf(buf, sizeof buf, name, i);
|
|
|
|
|
|
|
|
if (__ib_device_get_by_name(buf))
|
|
|
|
return -ENFILE;
|
|
|
|
|
|
|
|
strlcpy(name, buf, IB_DEVICE_NAME_MAX);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
static void ib_device_release(struct device *device)
|
|
|
|
{
|
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
|
|
|
|
2017-03-19 16:55:55 +08:00
|
|
|
WARN_ON(dev->reg_state == IB_DEV_REGISTERED);
|
|
|
|
if (dev->reg_state == IB_DEV_UNREGISTERED) {
|
|
|
|
/*
|
|
|
|
* In IB_DEV_UNINITIALIZED state, cache or port table
|
|
|
|
* is not even created. Free cache and port table only when
|
|
|
|
* device reaches UNREGISTERED state.
|
|
|
|
*/
|
|
|
|
ib_cache_release_one(dev);
|
|
|
|
kfree(dev->port_immutable);
|
|
|
|
}
|
2015-08-05 05:23:34 +08:00
|
|
|
kfree(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ib_device_uevent(struct device *device,
|
|
|
|
struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
|
|
|
|
|
|
|
if (add_uevent_var(env, "NAME=%s", dev->name))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It would be nice to pass the node GUID with the event...
|
|
|
|
*/
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct class ib_class = {
|
|
|
|
.name = "infiniband",
|
|
|
|
.dev_release = ib_device_release,
|
|
|
|
.dev_uevent = ib_device_uevent,
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* ib_alloc_device - allocate an IB device struct
|
|
|
|
* @size:size of structure to allocate
|
|
|
|
*
|
|
|
|
* Low-level drivers should use ib_alloc_device() to allocate &struct
|
|
|
|
* ib_device. @size is the size of the structure to be allocated,
|
|
|
|
* including any private data used by the low-level driver.
|
|
|
|
* ib_dealloc_device() must be used to free structures allocated with
|
|
|
|
* ib_alloc_device().
|
|
|
|
*/
|
|
|
|
struct ib_device *ib_alloc_device(size_t size)
|
|
|
|
{
|
2015-08-05 05:23:34 +08:00
|
|
|
struct ib_device *device;
|
|
|
|
|
|
|
|
if (WARN_ON(size < sizeof(struct ib_device)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
device = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (!device)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
device->dev.class = &ib_class;
|
|
|
|
device_initialize(&device->dev);
|
|
|
|
|
|
|
|
dev_set_drvdata(&device->dev, device);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&device->event_handler_list);
|
|
|
|
spin_lock_init(&device->event_handler_lock);
|
|
|
|
spin_lock_init(&device->client_data_lock);
|
|
|
|
INIT_LIST_HEAD(&device->client_data_list);
|
|
|
|
INIT_LIST_HEAD(&device->port_list);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
return device;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_alloc_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_dealloc_device - free an IB device struct
|
|
|
|
* @device:structure to free
|
|
|
|
*
|
|
|
|
* Free a structure allocated with ib_alloc_device().
|
|
|
|
*/
|
|
|
|
void ib_dealloc_device(struct ib_device *device)
|
|
|
|
{
|
2015-08-05 05:23:34 +08:00
|
|
|
WARN_ON(device->reg_state != IB_DEV_UNREGISTERED &&
|
|
|
|
device->reg_state != IB_DEV_UNINITIALIZED);
|
2009-02-26 05:27:46 +08:00
|
|
|
kobject_put(&device->dev.kobj);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_dealloc_device);
|
|
|
|
|
|
|
|
static int add_client_context(struct ib_device *device, struct ib_client *client)
|
|
|
|
{
|
|
|
|
struct ib_client_data *context;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
context = kmalloc(sizeof *context, GFP_KERNEL);
|
2016-11-03 22:44:10 +08:00
|
|
|
if (!context)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
context->client = client;
|
|
|
|
context->data = NULL;
|
2015-07-30 22:50:14 +08:00
|
|
|
context->going_down = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 22:50:14 +08:00
|
|
|
down_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_add(&context->list, &device->client_data_list);
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
2015-07-30 22:50:14 +08:00
|
|
|
up_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-07 02:38:29 +08:00
|
|
|
static int verify_immutable(const struct ib_device *dev, u8 port)
|
|
|
|
{
|
|
|
|
return WARN_ON(!rdma_cap_ib_mad(dev, port) &&
|
|
|
|
rdma_max_mad_size(dev, port) != 0);
|
|
|
|
}
|
|
|
|
|
2015-05-14 08:02:58 +08:00
|
|
|
static int read_port_immutable(struct ib_device *device)
|
2007-05-14 12:26:51 +08:00
|
|
|
{
|
2015-08-05 05:23:34 +08:00
|
|
|
int ret;
|
2015-05-14 08:02:58 +08:00
|
|
|
u8 start_port = rdma_start_port(device);
|
|
|
|
u8 end_port = rdma_end_port(device);
|
|
|
|
u8 port;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device->port_immutable is indexed directly by the port number to make
|
|
|
|
* access to this data as efficient as possible.
|
|
|
|
*
|
|
|
|
* Therefore port_immutable is declared as a 1 based array with
|
|
|
|
* potential empty slots at the beginning.
|
|
|
|
*/
|
|
|
|
device->port_immutable = kzalloc(sizeof(*device->port_immutable)
|
|
|
|
* (end_port + 1),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!device->port_immutable)
|
2015-08-05 05:23:34 +08:00
|
|
|
return -ENOMEM;
|
2007-05-14 12:26:51 +08:00
|
|
|
|
2015-05-14 08:02:58 +08:00
|
|
|
for (port = start_port; port <= end_port; ++port) {
|
|
|
|
ret = device->get_port_immutable(device, port,
|
|
|
|
&device->port_immutable[port]);
|
2007-05-14 12:26:51 +08:00
|
|
|
if (ret)
|
2015-08-05 05:23:34 +08:00
|
|
|
return ret;
|
2015-06-07 02:38:29 +08:00
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
if (verify_immutable(device, port))
|
|
|
|
return -EINVAL;
|
2007-05-14 12:26:51 +08:00
|
|
|
}
|
2015-08-05 05:23:34 +08:00
|
|
|
return 0;
|
2007-05-14 12:26:51 +08:00
|
|
|
}
|
|
|
|
|
2016-06-15 14:21:56 +08:00
|
|
|
void ib_get_device_fw_str(struct ib_device *dev, char *str, size_t str_len)
|
|
|
|
{
|
|
|
|
if (dev->get_dev_fw_str)
|
|
|
|
dev->get_dev_fw_str(dev, str, str_len);
|
|
|
|
else
|
|
|
|
str[0] = '\0';
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_get_device_fw_str);
|
|
|
|
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 20:48:52 +08:00
|
|
|
static int setup_port_pkey_list(struct ib_device *device)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device->port_pkey_list is indexed directly by the port number,
|
|
|
|
* Therefore it is declared as a 1 based array with potential empty
|
|
|
|
* slots at the beginning.
|
|
|
|
*/
|
|
|
|
device->port_pkey_list = kcalloc(rdma_end_port(device) + 1,
|
|
|
|
sizeof(*device->port_pkey_list),
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!device->port_pkey_list)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (i = 0; i < (rdma_end_port(device) + 1); i++) {
|
|
|
|
spin_lock_init(&device->port_pkey_list[i].list_lock);
|
|
|
|
INIT_LIST_HEAD(&device->port_pkey_list[i].pkey_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* ib_register_device - Register an IB device with IB core
|
|
|
|
* @device:Device to register
|
|
|
|
*
|
|
|
|
* Low-level drivers use ib_register_device() to register their
|
|
|
|
* devices with the IB core. All registered clients will receive a
|
|
|
|
* callback for each device that is added. @device must be allocated
|
|
|
|
* with ib_alloc_device().
|
|
|
|
*/
|
2010-05-07 08:03:25 +08:00
|
|
|
int ib_register_device(struct ib_device *device,
|
|
|
|
int (*port_callback)(struct ib_device *,
|
|
|
|
u8, struct kobject *))
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2015-08-15 22:16:14 +08:00
|
|
|
struct ib_client *client;
|
2015-12-18 16:59:44 +08:00
|
|
|
struct ib_udata uhw = {.outlen = 0, .inlen = 0};
|
2017-01-21 05:04:36 +08:00
|
|
|
struct device *parent = device->dev.parent;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!parent);
|
2017-03-08 06:56:53 +08:00
|
|
|
WARN_ON_ONCE(device->dma_device);
|
|
|
|
if (device->dev.dma_ops) {
|
|
|
|
/*
|
|
|
|
* The caller provided custom DMA operations. Copy the
|
|
|
|
* DMA-related fields that are used by e.g. dma_alloc_coherent()
|
|
|
|
* into device->dev.
|
|
|
|
*/
|
|
|
|
device->dma_device = &device->dev;
|
|
|
|
if (!device->dev.dma_mask)
|
|
|
|
device->dev.dma_mask = parent->dma_mask;
|
|
|
|
if (!device->dev.coherent_dma_mask)
|
|
|
|
device->dev.coherent_dma_mask =
|
|
|
|
parent->coherent_dma_mask;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The caller did not provide custom DMA operations. Use the
|
|
|
|
* DMA mapping operations of the parent device.
|
|
|
|
*/
|
|
|
|
device->dma_device = parent;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_lock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (strchr(device->name, '%')) {
|
|
|
|
ret = alloc_name(device->name);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ib_device_check_mandatory(device)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-05-14 08:02:58 +08:00
|
|
|
ret = read_port_immutable(device);
|
2007-05-14 12:26:51 +08:00
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't create per port immutable data %s\n",
|
|
|
|
device->name);
|
2007-05-14 12:26:51 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 20:48:52 +08:00
|
|
|
ret = setup_port_pkey_list(device);
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("Couldn't create per port_pkey_list\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
ret = ib_cache_setup_one(device);
|
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't set up InfiniBand P_Key/GID cache\n");
|
2017-03-19 16:55:55 +08:00
|
|
|
goto port_cleanup;
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
}
|
|
|
|
|
2017-01-10 08:02:14 +08:00
|
|
|
ret = ib_device_register_rdmacg(device);
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("Couldn't register device with rdma cgroup\n");
|
2017-03-19 16:55:55 +08:00
|
|
|
goto cache_cleanup;
|
2017-01-10 08:02:14 +08:00
|
|
|
}
|
|
|
|
|
2015-12-18 16:59:44 +08:00
|
|
|
memset(&device->attrs, 0, sizeof(device->attrs));
|
|
|
|
ret = device->query_device(device, &device->attrs, &uhw);
|
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't query the device attributes\n");
|
2017-03-19 16:55:55 +08:00
|
|
|
goto cache_cleanup;
|
2015-12-18 16:59:44 +08:00
|
|
|
}
|
|
|
|
|
2010-05-07 08:03:25 +08:00
|
|
|
ret = ib_device_register_sysfs(device, port_callback);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't register device %s with driver model\n",
|
|
|
|
device->name);
|
2017-03-19 16:55:55 +08:00
|
|
|
goto cache_cleanup;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
device->reg_state = IB_DEV_REGISTERED;
|
|
|
|
|
2015-08-15 22:16:14 +08:00
|
|
|
list_for_each_entry(client, &client_list, list)
|
|
|
|
if (client->add && !add_client_context(device, client))
|
|
|
|
client->add(device);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 22:50:13 +08:00
|
|
|
down_write(&lists_rwsem);
|
|
|
|
list_add_tail(&device->core_list, &device_list);
|
|
|
|
up_write(&lists_rwsem);
|
2017-03-19 16:55:55 +08:00
|
|
|
mutex_unlock(&device_mutex);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cache_cleanup:
|
|
|
|
ib_cache_cleanup_one(device);
|
|
|
|
ib_cache_release_one(device);
|
|
|
|
port_cleanup:
|
|
|
|
kfree(device->port_immutable);
|
2015-07-30 22:50:13 +08:00
|
|
|
out:
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_unlock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_register_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_unregister_device - Unregister an IB device
|
|
|
|
* @device:Device to unregister
|
|
|
|
*
|
|
|
|
* Unregister an IB device. All clients will receive a remove callback.
|
|
|
|
*/
|
|
|
|
void ib_unregister_device(struct ib_device *device)
|
|
|
|
{
|
|
|
|
struct ib_client_data *context, *tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_lock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 22:50:13 +08:00
|
|
|
down_write(&lists_rwsem);
|
|
|
|
list_del(&device->core_list);
|
2015-07-30 22:50:14 +08:00
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
|
|
|
|
context->going_down = true;
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
|
|
|
downgrade_write(&lists_rwsem);
|
2015-07-30 22:50:13 +08:00
|
|
|
|
2015-07-30 22:50:14 +08:00
|
|
|
list_for_each_entry_safe(context, tmp, &device->client_data_list,
|
|
|
|
list) {
|
|
|
|
if (context->client->remove)
|
|
|
|
context->client->remove(device, context->data);
|
|
|
|
}
|
|
|
|
up_read(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_unlock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-01-10 08:02:14 +08:00
|
|
|
ib_device_unregister_rdmacg(device);
|
2009-02-26 05:27:46 +08:00
|
|
|
ib_device_unregister_sysfs(device);
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
ib_cache_cleanup_one(device);
|
2009-02-26 05:27:46 +08:00
|
|
|
|
IB/core: Enforce PKey security on QPs
Add new LSM hooks to allocate and free security contexts and check for
permission to access a PKey.
Allocate and free a security context when creating and destroying a QP.
This context is used for controlling access to PKeys.
When a request is made to modify a QP that changes the port, PKey index,
or alternate path, check that the QP has permission for the PKey in the
PKey table index on the subnet prefix of the port. If the QP is shared
make sure all handles to the QP also have access.
Store which port and PKey index a QP is using. After the reset to init
transition the user can modify the port, PKey index and alternate path
independently. So port and PKey settings changes can be a merge of the
previous settings and the new ones.
In order to maintain access control if there are PKey table or subnet
prefix change keep a list of all QPs are using each PKey index on
each port. If a change occurs all QPs using that device and port must
have access enforced for the new cache settings.
These changes add a transaction to the QP modify process. Association
with the old port and PKey index must be maintained if the modify fails,
and must be removed if it succeeds. Association with the new port and
PKey index must be established prior to the modify and removed if the
modify fails.
1. When a QP is modified to a particular Port, PKey index or alternate
path insert that QP into the appropriate lists.
2. Check permission to access the new settings.
3. If step 2 grants access attempt to modify the QP.
4a. If steps 2 and 3 succeed remove any prior associations.
4b. If ether fails remove the new setting associations.
If a PKey table or subnet prefix changes walk the list of QPs and
check that they have permission. If not send the QP to the error state
and raise a fatal error event. If it's a shared QP make sure all the
QPs that share the real_qp have permission as well. If the QP that
owns a security structure is denied access the security structure is
marked as such and the QP is added to an error_list. Once the moving
the QP to error is complete the security structure mark is cleared.
Maintaining the lists correctly turns QP destroy into a transaction.
The hardware driver for the device frees the ib_qp structure, so while
the destroy is in progress the ib_qp pointer in the ib_qp_security
struct is undefined. When the destroy process begins the ib_qp_security
structure is marked as destroying. This prevents any action from being
taken on the QP pointer. After the QP is destroyed successfully it
could still listed on an error_list wait for it to be processed by that
flow before cleaning up the structure.
If the destroy fails the QPs port and PKey settings are reinserted into
the appropriate lists, the destroying flag is cleared, and access control
is enforced, in case there were any cache changes during the destroy
flow.
To keep the security changes isolated a new file is used to hold security
related functionality.
Signed-off-by: Daniel Jurgens <danielj@mellanox.com>
Acked-by: Doug Ledford <dledford@redhat.com>
[PM: merge fixup in ib_verbs.h and uverbs_cmd.c]
Signed-off-by: Paul Moore <paul@paul-moore.com>
2017-05-19 20:48:52 +08:00
|
|
|
ib_security_destroy_port_pkey_list(device);
|
|
|
|
kfree(device->port_pkey_list);
|
|
|
|
|
2015-07-30 22:50:14 +08:00
|
|
|
down_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
|
|
|
|
kfree(context);
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
2015-07-30 22:50:14 +08:00
|
|
|
up_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
device->reg_state = IB_DEV_UNREGISTERED;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_unregister_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_register_client - Register an IB client
|
|
|
|
* @client:Client to register
|
|
|
|
*
|
|
|
|
* Upper level users of the IB drivers can use ib_register_client() to
|
|
|
|
* register callbacks for IB device addition and removal. When an IB
|
|
|
|
* device is added, each registered client's add method will be called
|
|
|
|
* (in the order the clients were registered), and when a device is
|
|
|
|
* removed, each client's remove method will be called (in the reverse
|
|
|
|
* order that clients were registered). In addition, when
|
|
|
|
* ib_register_client() is called, the client will receive an add
|
|
|
|
* callback for all devices already registered.
|
|
|
|
*/
|
|
|
|
int ib_register_client(struct ib_client *client)
|
|
|
|
{
|
|
|
|
struct ib_device *device;
|
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_lock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
list_for_each_entry(device, &device_list, core_list)
|
|
|
|
if (client->add && !add_client_context(device, client))
|
|
|
|
client->add(device);
|
|
|
|
|
2015-07-30 22:50:13 +08:00
|
|
|
down_write(&lists_rwsem);
|
|
|
|
list_add_tail(&client->list, &client_list);
|
|
|
|
up_write(&lists_rwsem);
|
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_unlock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_register_client);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_unregister_client - Unregister an IB client
|
|
|
|
* @client:Client to unregister
|
|
|
|
*
|
|
|
|
* Upper level users use ib_unregister_client() to remove their client
|
|
|
|
* registration. When ib_unregister_client() is called, the client
|
|
|
|
* will receive a remove callback for each IB device still registered.
|
|
|
|
*/
|
|
|
|
void ib_unregister_client(struct ib_client *client)
|
|
|
|
{
|
|
|
|
struct ib_client_data *context, *tmp;
|
|
|
|
struct ib_device *device;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_lock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 22:50:13 +08:00
|
|
|
down_write(&lists_rwsem);
|
|
|
|
list_del(&client->list);
|
|
|
|
up_write(&lists_rwsem);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
list_for_each_entry(device, &device_list, core_list) {
|
2015-07-30 22:50:14 +08:00
|
|
|
struct ib_client_data *found_context = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 22:50:14 +08:00
|
|
|
down_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
|
|
|
|
if (context->client == client) {
|
2015-07-30 22:50:14 +08:00
|
|
|
context->going_down = true;
|
|
|
|
found_context = context;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
2015-07-30 22:50:14 +08:00
|
|
|
up_write(&lists_rwsem);
|
|
|
|
|
|
|
|
if (client->remove)
|
|
|
|
client->remove(device, found_context ?
|
|
|
|
found_context->data : NULL);
|
|
|
|
|
|
|
|
if (!found_context) {
|
|
|
|
pr_warn("No client context found for %s/%s\n",
|
|
|
|
device->name, client->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
down_write(&lists_rwsem);
|
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_del(&found_context->list);
|
|
|
|
kfree(found_context);
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
|
|
|
up_write(&lists_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-01-14 06:51:39 +08:00
|
|
|
mutex_unlock(&device_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_unregister_client);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_get_client_data - Get IB client context
|
|
|
|
* @device:Device to get context for
|
|
|
|
* @client:Client to get context for
|
|
|
|
*
|
|
|
|
* ib_get_client_data() returns client context set with
|
|
|
|
* ib_set_client_data().
|
|
|
|
*/
|
|
|
|
void *ib_get_client_data(struct ib_device *device, struct ib_client *client)
|
|
|
|
{
|
|
|
|
struct ib_client_data *context;
|
|
|
|
void *ret = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_for_each_entry(context, &device->client_data_list, list)
|
|
|
|
if (context->client == client) {
|
|
|
|
ret = context->data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_get_client_data);
|
|
|
|
|
|
|
|
/**
|
2006-09-23 06:22:58 +08:00
|
|
|
* ib_set_client_data - Set IB client context
|
2005-04-17 06:20:36 +08:00
|
|
|
* @device:Device to set context for
|
|
|
|
* @client:Client to set context for
|
|
|
|
* @data:Context to set
|
|
|
|
*
|
|
|
|
* ib_set_client_data() sets client context that can be retrieved with
|
|
|
|
* ib_get_client_data().
|
|
|
|
*/
|
|
|
|
void ib_set_client_data(struct ib_device *device, struct ib_client *client,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ib_client_data *context;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&device->client_data_lock, flags);
|
|
|
|
list_for_each_entry(context, &device->client_data_list, list)
|
|
|
|
if (context->client == client) {
|
|
|
|
context->data = data;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("No client context found for %s/%s\n",
|
|
|
|
device->name, client->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&device->client_data_lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_set_client_data);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_register_event_handler - Register an IB event handler
|
|
|
|
* @event_handler:Handler to register
|
|
|
|
*
|
|
|
|
* ib_register_event_handler() registers an event handler that will be
|
|
|
|
* called back when asynchronous IB events occur (as defined in
|
|
|
|
* chapter 11 of the InfiniBand Architecture Specification). This
|
|
|
|
* callback may occur in interrupt context.
|
|
|
|
*/
|
|
|
|
int ib_register_event_handler (struct ib_event_handler *event_handler)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
|
|
|
|
list_add_tail(&event_handler->list,
|
|
|
|
&event_handler->device->event_handler_list);
|
|
|
|
spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_register_event_handler);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_unregister_event_handler - Unregister an event handler
|
|
|
|
* @event_handler:Handler to unregister
|
|
|
|
*
|
|
|
|
* Unregister an event handler registered with
|
|
|
|
* ib_register_event_handler().
|
|
|
|
*/
|
|
|
|
int ib_unregister_event_handler(struct ib_event_handler *event_handler)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
|
|
|
|
list_del(&event_handler->list);
|
|
|
|
spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_unregister_event_handler);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_dispatch_event - Dispatch an asynchronous event
|
|
|
|
* @event:Event to dispatch
|
|
|
|
*
|
|
|
|
* Low-level drivers must call ib_dispatch_event() to dispatch the
|
|
|
|
* event to all registered event handlers when an asynchronous event
|
|
|
|
* occurs.
|
|
|
|
*/
|
|
|
|
void ib_dispatch_event(struct ib_event *event)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct ib_event_handler *handler;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&event->device->event_handler_lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry(handler, &event->device->event_handler_list, list)
|
|
|
|
handler->handler(handler, event);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&event->device->event_handler_lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_dispatch_event);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_query_port - Query IB port attributes
|
|
|
|
* @device:Device to query
|
|
|
|
* @port_num:Port number to query
|
|
|
|
* @port_attr:Port attributes
|
|
|
|
*
|
|
|
|
* ib_query_port() returns the attributes of a port through the
|
|
|
|
* @port_attr pointer.
|
|
|
|
*/
|
|
|
|
int ib_query_port(struct ib_device *device,
|
|
|
|
u8 port_num,
|
|
|
|
struct ib_port_attr *port_attr)
|
|
|
|
{
|
2016-03-12 04:58:36 +08:00
|
|
|
union ib_gid gid;
|
|
|
|
int err;
|
|
|
|
|
2017-01-26 00:41:37 +08:00
|
|
|
if (!rdma_is_port_valid(device, port_num))
|
2005-10-04 00:32:33 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-03-12 04:58:36 +08:00
|
|
|
memset(port_attr, 0, sizeof(*port_attr));
|
|
|
|
err = device->query_port(device, port_num, port_attr);
|
|
|
|
if (err || port_attr->subnet_prefix)
|
|
|
|
return err;
|
|
|
|
|
2016-06-04 20:15:18 +08:00
|
|
|
if (rdma_port_get_link_layer(device, port_num) != IB_LINK_LAYER_INFINIBAND)
|
|
|
|
return 0;
|
|
|
|
|
2016-03-12 04:58:36 +08:00
|
|
|
err = ib_query_gid(device, port_num, 0, &gid, NULL);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
port_attr->subnet_prefix = be64_to_cpu(gid.global.subnet_prefix);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_query_port);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_query_gid - Get GID table entry
|
|
|
|
* @device:Device to query
|
|
|
|
* @port_num:Port number to query
|
|
|
|
* @index:GID table index to query
|
|
|
|
* @gid:Returned GID
|
2015-10-15 23:38:45 +08:00
|
|
|
* @attr: Returned GID attributes related to this GID index (only in RoCE).
|
|
|
|
* NULL means ignore.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* ib_query_gid() fetches the specified GID table entry.
|
|
|
|
*/
|
|
|
|
int ib_query_gid(struct ib_device *device,
|
2015-10-15 23:38:45 +08:00
|
|
|
u8 port_num, int index, union ib_gid *gid,
|
|
|
|
struct ib_gid_attr *attr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
if (rdma_cap_roce_gid_table(device, port_num))
|
2015-10-15 23:38:45 +08:00
|
|
|
return ib_get_cached_gid(device, port_num, index, gid, attr);
|
|
|
|
|
|
|
|
if (attr)
|
|
|
|
return -EINVAL;
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return device->query_gid(device, port_num, index, gid);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_query_gid);
|
|
|
|
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
/**
|
|
|
|
* ib_enum_roce_netdev - enumerate all RoCE ports
|
|
|
|
* @ib_dev : IB device we want to query
|
|
|
|
* @filter: Should we call the callback?
|
|
|
|
* @filter_cookie: Cookie passed to filter
|
|
|
|
* @cb: Callback to call for each found RoCE ports
|
|
|
|
* @cookie: Cookie passed back to the callback
|
|
|
|
*
|
|
|
|
* Enumerates all of the physical RoCE ports of ib_dev
|
|
|
|
* which are related to netdevice and calls callback() on each
|
|
|
|
* device for which filter() function returns non zero.
|
|
|
|
*/
|
|
|
|
void ib_enum_roce_netdev(struct ib_device *ib_dev,
|
|
|
|
roce_netdev_filter filter,
|
|
|
|
void *filter_cookie,
|
|
|
|
roce_netdev_callback cb,
|
|
|
|
void *cookie)
|
|
|
|
{
|
|
|
|
u8 port;
|
|
|
|
|
|
|
|
for (port = rdma_start_port(ib_dev); port <= rdma_end_port(ib_dev);
|
|
|
|
port++)
|
|
|
|
if (rdma_protocol_roce(ib_dev, port)) {
|
|
|
|
struct net_device *idev = NULL;
|
|
|
|
|
|
|
|
if (ib_dev->get_netdev)
|
|
|
|
idev = ib_dev->get_netdev(ib_dev, port);
|
|
|
|
|
|
|
|
if (idev &&
|
|
|
|
idev->reg_state >= NETREG_UNREGISTERED) {
|
|
|
|
dev_put(idev);
|
|
|
|
idev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filter(ib_dev, port, idev, filter_cookie))
|
|
|
|
cb(ib_dev, port, idev, cookie);
|
|
|
|
|
|
|
|
if (idev)
|
|
|
|
dev_put(idev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_enum_all_roce_netdevs - enumerate all RoCE devices
|
|
|
|
* @filter: Should we call the callback?
|
|
|
|
* @filter_cookie: Cookie passed to filter
|
|
|
|
* @cb: Callback to call for each found RoCE ports
|
|
|
|
* @cookie: Cookie passed back to the callback
|
|
|
|
*
|
|
|
|
* Enumerates all RoCE devices' physical ports which are related
|
|
|
|
* to netdevices and calls callback() on each device for which
|
|
|
|
* filter() function returns non zero.
|
|
|
|
*/
|
|
|
|
void ib_enum_all_roce_netdevs(roce_netdev_filter filter,
|
|
|
|
void *filter_cookie,
|
|
|
|
roce_netdev_callback cb,
|
|
|
|
void *cookie)
|
|
|
|
{
|
|
|
|
struct ib_device *dev;
|
|
|
|
|
|
|
|
down_read(&lists_rwsem);
|
|
|
|
list_for_each_entry(dev, &device_list, core_list)
|
|
|
|
ib_enum_roce_netdev(dev, filter, filter_cookie, cb, cookie);
|
|
|
|
up_read(&lists_rwsem);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* ib_query_pkey - Get P_Key table entry
|
|
|
|
* @device:Device to query
|
|
|
|
* @port_num:Port number to query
|
|
|
|
* @index:P_Key table index to query
|
|
|
|
* @pkey:Returned P_Key
|
|
|
|
*
|
|
|
|
* ib_query_pkey() fetches the specified P_Key table entry.
|
|
|
|
*/
|
|
|
|
int ib_query_pkey(struct ib_device *device,
|
|
|
|
u8 port_num, u16 index, u16 *pkey)
|
|
|
|
{
|
|
|
|
return device->query_pkey(device, port_num, index, pkey);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_query_pkey);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_modify_device - Change IB device attributes
|
|
|
|
* @device:Device to modify
|
|
|
|
* @device_modify_mask:Mask of attributes to change
|
|
|
|
* @device_modify:New attribute values
|
|
|
|
*
|
|
|
|
* ib_modify_device() changes a device's attributes as specified by
|
|
|
|
* the @device_modify_mask and @device_modify structure.
|
|
|
|
*/
|
|
|
|
int ib_modify_device(struct ib_device *device,
|
|
|
|
int device_modify_mask,
|
|
|
|
struct ib_device_modify *device_modify)
|
|
|
|
{
|
2011-06-19 00:35:42 +08:00
|
|
|
if (!device->modify_device)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return device->modify_device(device, device_modify_mask,
|
|
|
|
device_modify);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_modify_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_modify_port - Modifies the attributes for the specified port.
|
|
|
|
* @device: The device to modify.
|
|
|
|
* @port_num: The number of the port to modify.
|
|
|
|
* @port_modify_mask: Mask used to specify which attributes of the port
|
|
|
|
* to change.
|
|
|
|
* @port_modify: New attribute values for the port.
|
|
|
|
*
|
|
|
|
* ib_modify_port() changes a port's attributes as specified by the
|
|
|
|
* @port_modify_mask and @port_modify structure.
|
|
|
|
*/
|
|
|
|
int ib_modify_port(struct ib_device *device,
|
|
|
|
u8 port_num, int port_modify_mask,
|
|
|
|
struct ib_port_modify *port_modify)
|
|
|
|
{
|
2011-06-19 00:35:42 +08:00
|
|
|
if (!device->modify_port)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
2017-01-26 00:41:37 +08:00
|
|
|
if (!rdma_is_port_valid(device, port_num))
|
2005-10-04 00:32:33 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return device->modify_port(device, port_num, port_modify_mask,
|
|
|
|
port_modify);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_modify_port);
|
|
|
|
|
2007-05-14 12:26:51 +08:00
|
|
|
/**
|
|
|
|
* ib_find_gid - Returns the port number and GID table index where
|
|
|
|
* a specified GID value occurs.
|
|
|
|
* @device: The device to query.
|
|
|
|
* @gid: The GID value to search for.
|
2015-12-23 20:56:47 +08:00
|
|
|
* @gid_type: Type of GID.
|
2015-10-15 23:38:45 +08:00
|
|
|
* @ndev: The ndev related to the GID to search for.
|
2007-05-14 12:26:51 +08:00
|
|
|
* @port_num: The port number of the device where the GID value was found.
|
|
|
|
* @index: The index into the GID table where the GID was found. This
|
|
|
|
* parameter may be NULL.
|
|
|
|
*/
|
|
|
|
int ib_find_gid(struct ib_device *device, union ib_gid *gid,
|
2015-12-23 20:56:47 +08:00
|
|
|
enum ib_gid_type gid_type, struct net_device *ndev,
|
|
|
|
u8 *port_num, u16 *index)
|
2007-05-14 12:26:51 +08:00
|
|
|
{
|
|
|
|
union ib_gid tmp_gid;
|
|
|
|
int ret, port, i;
|
|
|
|
|
2015-05-14 08:02:55 +08:00
|
|
|
for (port = rdma_start_port(device); port <= rdma_end_port(device); ++port) {
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
if (rdma_cap_roce_gid_table(device, port)) {
|
2015-12-23 20:56:47 +08:00
|
|
|
if (!ib_find_cached_gid_by_port(device, gid, gid_type, port,
|
2015-10-15 23:38:46 +08:00
|
|
|
ndev, index)) {
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
*port_num = port;
|
|
|
|
return 0;
|
2015-08-18 17:22:10 +08:00
|
|
|
}
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
}
|
|
|
|
|
2015-12-23 20:56:47 +08:00
|
|
|
if (gid_type != IB_GID_TYPE_IB)
|
|
|
|
continue;
|
|
|
|
|
2015-05-14 08:02:58 +08:00
|
|
|
for (i = 0; i < device->port_immutable[port].gid_tbl_len; ++i) {
|
2015-10-15 23:38:45 +08:00
|
|
|
ret = ib_query_gid(device, port, i, &tmp_gid, NULL);
|
2007-05-14 12:26:51 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
|
|
|
|
*port_num = port;
|
|
|
|
if (index)
|
|
|
|
*index = i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_find_gid);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ib_find_pkey - Returns the PKey table index where a specified
|
|
|
|
* PKey value occurs.
|
|
|
|
* @device: The device to query.
|
|
|
|
* @port_num: The port number of the device to search for the PKey.
|
|
|
|
* @pkey: The PKey value to search for.
|
|
|
|
* @index: The index into the PKey table where the PKey was found.
|
|
|
|
*/
|
|
|
|
int ib_find_pkey(struct ib_device *device,
|
|
|
|
u8 port_num, u16 pkey, u16 *index)
|
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
u16 tmp_pkey;
|
2012-08-03 16:40:38 +08:00
|
|
|
int partial_ix = -1;
|
2007-05-14 12:26:51 +08:00
|
|
|
|
2015-05-14 08:02:58 +08:00
|
|
|
for (i = 0; i < device->port_immutable[port_num].pkey_tbl_len; ++i) {
|
2007-05-14 12:26:51 +08:00
|
|
|
ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-07-23 15:07:42 +08:00
|
|
|
if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
|
2012-08-03 16:40:38 +08:00
|
|
|
/* if there is full-member pkey take it.*/
|
|
|
|
if (tmp_pkey & 0x8000) {
|
|
|
|
*index = i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (partial_ix < 0)
|
|
|
|
partial_ix = i;
|
2007-05-14 12:26:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-03 16:40:38 +08:00
|
|
|
/*no full-member, if exists take the limited*/
|
|
|
|
if (partial_ix >= 0) {
|
|
|
|
*index = partial_ix;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-05-14 12:26:51 +08:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_find_pkey);
|
|
|
|
|
2015-07-30 22:50:15 +08:00
|
|
|
/**
|
|
|
|
* ib_get_net_dev_by_params() - Return the appropriate net_dev
|
|
|
|
* for a received CM request
|
|
|
|
* @dev: An RDMA device on which the request has been received.
|
|
|
|
* @port: Port number on the RDMA device.
|
|
|
|
* @pkey: The Pkey the request came on.
|
|
|
|
* @gid: A GID that the net_dev uses to communicate.
|
|
|
|
* @addr: Contains the IP address that the request specified as its
|
|
|
|
* destination.
|
|
|
|
*/
|
|
|
|
struct net_device *ib_get_net_dev_by_params(struct ib_device *dev,
|
|
|
|
u8 port,
|
|
|
|
u16 pkey,
|
|
|
|
const union ib_gid *gid,
|
|
|
|
const struct sockaddr *addr)
|
|
|
|
{
|
|
|
|
struct net_device *net_dev = NULL;
|
|
|
|
struct ib_client_data *context;
|
|
|
|
|
|
|
|
if (!rdma_protocol_ib(dev, port))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
down_read(&lists_rwsem);
|
|
|
|
|
|
|
|
list_for_each_entry(context, &dev->client_data_list, list) {
|
|
|
|
struct ib_client *client = context->client;
|
|
|
|
|
|
|
|
if (context->going_down)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (client->get_net_dev_by_params) {
|
|
|
|
net_dev = client->get_net_dev_by_params(dev, port, pkey,
|
|
|
|
gid, addr,
|
|
|
|
context->data);
|
|
|
|
if (net_dev)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
up_read(&lists_rwsem);
|
|
|
|
|
|
|
|
return net_dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ib_get_net_dev_by_params);
|
|
|
|
|
2016-05-19 22:12:35 +08:00
|
|
|
static struct ibnl_client_cbs ibnl_ls_cb_table[] = {
|
|
|
|
[RDMA_NL_LS_OP_RESOLVE] = {
|
|
|
|
.dump = ib_nl_handle_resolve_resp,
|
|
|
|
.module = THIS_MODULE },
|
|
|
|
[RDMA_NL_LS_OP_SET_TIMEOUT] = {
|
|
|
|
.dump = ib_nl_handle_set_timeout,
|
|
|
|
.module = THIS_MODULE },
|
2016-05-19 22:12:36 +08:00
|
|
|
[RDMA_NL_LS_OP_IP_RESOLVE] = {
|
|
|
|
.dump = ib_nl_handle_ip_res_resp,
|
|
|
|
.module = THIS_MODULE },
|
2016-05-19 22:12:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int ib_add_ibnl_clients(void)
|
|
|
|
{
|
|
|
|
return ibnl_add_client(RDMA_NL_LS, ARRAY_SIZE(ibnl_ls_cb_table),
|
|
|
|
ibnl_ls_cb_table);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ib_remove_ibnl_clients(void)
|
|
|
|
{
|
|
|
|
ibnl_remove_client(RDMA_NL_LS);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int __init ib_core_init(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-10-19 23:24:36 +08:00
|
|
|
ib_wq = alloc_workqueue("infiniband", 0, 0);
|
|
|
|
if (!ib_wq)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-12-12 03:53:03 +08:00
|
|
|
ib_comp_wq = alloc_workqueue("ib-comp-wq",
|
2017-03-09 04:03:17 +08:00
|
|
|
WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_SYSFS, 0);
|
2015-12-12 03:53:03 +08:00
|
|
|
if (!ib_comp_wq) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
ret = class_register(&ib_class);
|
2011-05-21 02:46:10 +08:00
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't create InfiniBand device class\n");
|
2015-12-12 03:53:03 +08:00
|
|
|
goto err_comp;
|
2011-05-21 02:46:10 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-05-21 02:46:11 +08:00
|
|
|
ret = ibnl_init();
|
|
|
|
if (ret) {
|
2016-03-02 03:20:29 +08:00
|
|
|
pr_warn("Couldn't init IB netlink interface\n");
|
2011-05-21 02:46:11 +08:00
|
|
|
goto err_sysfs;
|
|
|
|
}
|
|
|
|
|
2016-05-19 22:12:31 +08:00
|
|
|
ret = addr_init();
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("Could't init IB address resolution\n");
|
|
|
|
goto err_ibnl;
|
|
|
|
}
|
|
|
|
|
2016-05-19 22:12:32 +08:00
|
|
|
ret = ib_mad_init();
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("Couldn't init IB MAD\n");
|
|
|
|
goto err_addr;
|
|
|
|
}
|
|
|
|
|
2016-05-19 22:12:33 +08:00
|
|
|
ret = ib_sa_init();
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("Couldn't init SA\n");
|
|
|
|
goto err_mad;
|
|
|
|
}
|
|
|
|
|
2016-06-01 00:05:56 +08:00
|
|
|
ret = ib_add_ibnl_clients();
|
|
|
|
if (ret) {
|
2016-05-19 22:12:35 +08:00
|
|
|
pr_warn("Couldn't register ibnl clients\n");
|
|
|
|
goto err_sa;
|
|
|
|
}
|
|
|
|
|
IB/core: Add RoCE GID table management
RoCE GIDs are based on IP addresses configured on Ethernet net-devices
which relate to the RDMA (RoCE) device port.
Currently, each of the low-level drivers that support RoCE (ocrdma,
mlx4) manages its own RoCE port GID table. As there's nothing which is
essentially vendor specific, we generalize that, and enhance the RDMA
core GID cache to do this job.
In order to populate the GID table, we listen for events:
(a) netdev up/down/change_addr events - if a netdev is built onto
our RoCE device, we need to add/delete its IPs. This involves
adding all GIDs related to this ndev, add default GIDs, etc.
(b) inet events - add new GIDs (according to the IP addresses)
to the table.
For programming the port RoCE GID table, providers must implement
the add_gid and del_gid callbacks.
RoCE GID management requires us to state the associated net_device
alongside the GID. This information is necessary in order to manage
the GID table. For example, when a net_device is removed, its
associated GIDs need to be removed as well.
RoCE mandates generating a default GID for each port, based on the
related net-device's IPv6 link local. In contrast to the GID based on
the regular IPv6 link-local (as we generate GID per IP address),
the default GID is also available when the net device is down (in
order to support loopback).
Locking is done as follows:
The patch modify the GID table code both for new RoCE drivers
implementing the add_gid/del_gid callbacks and for current RoCE and
IB drivers that do not. The flows for updating the table are
different, so the locking requirements are too.
While updating RoCE GID table, protection against multiple writers is
achieved via mutex_lock(&table->lock). Since writing to a table
requires us to find an entry (possible a free entry) in the table and
then modify it, this mutex protects both the find_gid and write_gid
ensuring the atomicity of the action.
Each entry in the GID cache is protected by rwlock. In RoCE, writing
(usually results from netdev notifier) involves invoking the vendor's
add_gid and del_gid callbacks, which could sleep.
Therefore, an invalid flag is added for each entry. Updates for RoCE are
done via a workqueue, thus sleeping is permitted.
In IB, updates are done in write_lock_irq(&device->cache.lock), thus
write_gid isn't allowed to sleep and add_gid/del_gid are not called.
When passing net-device into/out-of the GID cache, the device
is always passed held (dev_hold).
The code uses a single work item for updating all RDMA devices,
following a netdev or inet notifier.
The patch moves the cache from being a client (which was incorrect,
as the cache is part of the IB infrastructure) to being explicitly
initialized/freed when a device is registered/removed.
Signed-off-by: Matan Barak <matanb@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2015-07-30 23:33:26 +08:00
|
|
|
ib_cache_setup();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-05-21 02:46:10 +08:00
|
|
|
return 0;
|
|
|
|
|
2016-05-19 22:12:35 +08:00
|
|
|
err_sa:
|
|
|
|
ib_sa_cleanup();
|
2016-05-19 22:12:33 +08:00
|
|
|
err_mad:
|
|
|
|
ib_mad_cleanup();
|
2016-05-19 22:12:32 +08:00
|
|
|
err_addr:
|
|
|
|
addr_cleanup();
|
2016-05-19 22:12:31 +08:00
|
|
|
err_ibnl:
|
|
|
|
ibnl_cleanup();
|
2011-05-21 02:46:10 +08:00
|
|
|
err_sysfs:
|
2015-08-05 05:23:34 +08:00
|
|
|
class_unregister(&ib_class);
|
2015-12-12 03:53:03 +08:00
|
|
|
err_comp:
|
|
|
|
destroy_workqueue(ib_comp_wq);
|
2011-05-21 02:46:10 +08:00
|
|
|
err:
|
|
|
|
destroy_workqueue(ib_wq);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit ib_core_cleanup(void)
|
|
|
|
{
|
|
|
|
ib_cache_cleanup();
|
2016-05-19 22:12:35 +08:00
|
|
|
ib_remove_ibnl_clients();
|
2016-05-19 22:12:33 +08:00
|
|
|
ib_sa_cleanup();
|
2016-05-19 22:12:32 +08:00
|
|
|
ib_mad_cleanup();
|
2016-05-19 22:12:31 +08:00
|
|
|
addr_cleanup();
|
2011-05-21 02:46:11 +08:00
|
|
|
ibnl_cleanup();
|
2015-08-05 05:23:34 +08:00
|
|
|
class_unregister(&ib_class);
|
2015-12-12 03:53:03 +08:00
|
|
|
destroy_workqueue(ib_comp_wq);
|
2007-03-05 08:15:11 +08:00
|
|
|
/* Make sure that any pending umem accounting work is done. */
|
2010-10-19 23:24:36 +08:00
|
|
|
destroy_workqueue(ib_wq);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(ib_core_init);
|
|
|
|
module_exit(ib_core_cleanup);
|