-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
}
int
-kiblnd_create_peer (lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid)
+kiblnd_create_peer(lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid)
{
- kib_peer_t *peer;
- kib_net_t *net = ni->ni_data;
- unsigned long flags;
+ kib_peer_t *peer;
+ kib_net_t *net = ni->ni_data;
+ int cpt = lnet_cpt_of_nid(nid);
+ unsigned long flags;
- LASSERT (net != NULL);
- LASSERT (nid != LNET_NID_ANY);
+ LASSERT(net != NULL);
+ LASSERT(nid != LNET_NID_ANY);
- LIBCFS_ALLOC(peer, sizeof(*peer));
+ LIBCFS_CPT_ALLOC(peer, lnet_cpt_table(), cpt, sizeof(*peer));
if (peer == NULL) {
CERROR("Cannot allocate peer\n");
return -ENOMEM;
CFS_INIT_LIST_HEAD(&peer->ibp_conns);
CFS_INIT_LIST_HEAD(&peer->ibp_tx_queue);
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
/* always called with a ref on ni, which prevents ni being shutdown */
LASSERT (net->ibn_shutdown == 0);
/* npeers only grows with the global lock held */
cfs_atomic_inc(&net->ibn_npeers);
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
*peerp = peer;
return 0;
int i;
unsigned long flags;
- cfs_read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
*nidp = peer->ibp_nid;
*count = cfs_atomic_read(&peer->ibp_refcount);
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock,
- flags);
- return 0;
- }
- }
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock,
+ flags);
+ return 0;
+ }
+ }
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
return -ENOENT;
}
unsigned long flags;
int rc = -ENOENT;
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
if (nid != LNET_NID_ANY) {
lo = hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
}
}
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
kiblnd_txlist_done(ni, &zombies, -EIO);
int i;
unsigned long flags;
- cfs_read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
cfs_list_for_each (ptmp, &kiblnd_data.kib_peers[i]) {
conn = cfs_list_entry(ctmp, kib_conn_t,
ibc_list);
kiblnd_conn_addref(conn);
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock,
- flags);
- return conn;
- }
- }
- }
-
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock,
+ flags);
+ return conn;
+ }
+ }
+ }
+
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
return NULL;
}
void
kiblnd_debug_conn (kib_conn_t *conn)
{
- cfs_list_t *tmp;
- int i;
+ cfs_list_t *tmp;
+ int i;
- cfs_spin_lock(&conn->ibc_lock);
+ spin_lock(&conn->ibc_lock);
CDEBUG(D_CONSOLE, "conn[%d] %p [version %x] -> %s: \n",
cfs_atomic_read(&conn->ibc_refcount), conn,
for (i = 0; i < IBLND_RX_MSGS(conn->ibc_version); i++)
kiblnd_debug_rx(&conn->ibc_rxs[i]);
- cfs_spin_unlock(&conn->ibc_lock);
+ spin_unlock(&conn->ibc_lock);
}
int
cmid->route.path_rec->mtu = mtu;
}
+#ifdef HAVE_OFED_IB_COMP_VECTOR
+static int
+kiblnd_get_completion_vector(kib_conn_t *conn, int cpt)
+{
+ cpumask_t *mask;
+ int vectors;
+ int off;
+ int i;
+
+ vectors = conn->ibc_cmid->device->num_comp_vectors;
+ if (vectors <= 1)
+ return 0;
+
+ mask = cfs_cpt_cpumask(lnet_cpt_table(), cpt);
+
+ /* hash NID to CPU id in this partition... */
+ off = conn->ibc_peer->ibp_nid % cpus_weight(*mask);
+ for_each_cpu_mask(i, *mask) {
+ if (off-- == 0)
+ return i % vectors;
+ }
+
+ LBUG();
+ return 1;
+}
+#endif
+
kib_conn_t *
kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
int state, int version)
* she must dispose of 'cmid'. (Actually I'd block forever if I tried
* to destroy 'cmid' here since I'm called from the CM which still has
* its ref on 'cmid'). */
- cfs_rwlock_t *glock = &kiblnd_data.kib_global_lock;
+ rwlock_t *glock = &kiblnd_data.kib_global_lock;
kib_net_t *net = peer->ibp_ni->ni_data;
- kib_dev_t *dev = net->ibn_dev;
+ kib_dev_t *dev;
struct ib_qp_init_attr *init_qp_attr;
- kib_conn_t *conn;
- struct ib_cq *cq;
- unsigned long flags;
- int rc;
- int i;
+ struct kib_sched_info *sched;
+ kib_conn_t *conn;
+ struct ib_cq *cq;
+ unsigned long flags;
+ int cpt;
+ int rc;
+ int i;
- LASSERT (net != NULL);
- LASSERT (!cfs_in_interrupt());
+ LASSERT(net != NULL);
+ LASSERT(!cfs_in_interrupt());
- LIBCFS_ALLOC(init_qp_attr, sizeof(*init_qp_attr));
- if (init_qp_attr == NULL) {
- CERROR("Can't allocate qp_attr for %s\n",
- libcfs_nid2str(peer->ibp_nid));
- goto failed_0;
- }
+ dev = net->ibn_dev;
+
+ cpt = lnet_cpt_of_nid(peer->ibp_nid);
+ sched = kiblnd_data.kib_scheds[cpt];
+
+ LASSERT(sched->ibs_nthreads > 0);
- LIBCFS_ALLOC(conn, sizeof(*conn));
+ LIBCFS_CPT_ALLOC(init_qp_attr, lnet_cpt_table(), cpt,
+ sizeof(*init_qp_attr));
+ if (init_qp_attr == NULL) {
+ CERROR("Can't allocate qp_attr for %s\n",
+ libcfs_nid2str(peer->ibp_nid));
+ goto failed_0;
+ }
+
+ LIBCFS_CPT_ALLOC(conn, lnet_cpt_table(), cpt, sizeof(*conn));
if (conn == NULL) {
CERROR("Can't allocate connection for %s\n",
libcfs_nid2str(peer->ibp_nid));
goto failed_1;
}
- memset(conn, 0, sizeof(*conn)); /* zero flags, NULL pointers etc... */
-
conn->ibc_state = IBLND_CONN_INIT;
conn->ibc_version = version;
conn->ibc_peer = peer; /* I take the caller's ref */
CFS_INIT_LIST_HEAD(&conn->ibc_tx_queue_rsrvd);
CFS_INIT_LIST_HEAD(&conn->ibc_tx_queue_nocred);
CFS_INIT_LIST_HEAD(&conn->ibc_active_txs);
- cfs_spin_lock_init(&conn->ibc_lock);
-
- LIBCFS_ALLOC(conn->ibc_connvars, sizeof(*conn->ibc_connvars));
- if (conn->ibc_connvars == NULL) {
- CERROR("Can't allocate in-progress connection state\n");
- goto failed_2;
- }
- memset(conn->ibc_connvars, 0, sizeof(*conn->ibc_connvars));
-
- cfs_write_lock_irqsave(glock, flags);
- if (dev->ibd_failover) {
- cfs_write_unlock_irqrestore(glock, flags);
- CERROR("%s: failover in progress\n", dev->ibd_ifname);
- goto failed_2;
- }
+ spin_lock_init(&conn->ibc_lock);
+
+ LIBCFS_CPT_ALLOC(conn->ibc_connvars, lnet_cpt_table(), cpt,
+ sizeof(*conn->ibc_connvars));
+ if (conn->ibc_connvars == NULL) {
+ CERROR("Can't allocate in-progress connection state\n");
+ goto failed_2;
+ }
+
+ write_lock_irqsave(glock, flags);
+ if (dev->ibd_failover) {
+ write_unlock_irqrestore(glock, flags);
+ CERROR("%s: failover in progress\n", dev->ibd_ifname);
+ goto failed_2;
+ }
if (dev->ibd_hdev->ibh_ibdev != cmid->device) {
/* wakeup failover thread and teardown connection */
cfs_waitq_signal(&kiblnd_data.kib_failover_waitq);
}
- cfs_write_unlock_irqrestore(glock, flags);
+ write_unlock_irqrestore(glock, flags);
CERROR("cmid HCA(%s), kib_dev(%s) need failover\n",
cmid->device->name, dev->ibd_ifname);
goto failed_2;
kiblnd_setup_mtu_locked(cmid);
- cfs_write_unlock_irqrestore(glock, flags);
+ write_unlock_irqrestore(glock, flags);
- LIBCFS_ALLOC(conn->ibc_rxs, IBLND_RX_MSGS(version) * sizeof(kib_rx_t));
- if (conn->ibc_rxs == NULL) {
- CERROR("Cannot allocate RX buffers\n");
- goto failed_2;
- }
- memset(conn->ibc_rxs, 0, IBLND_RX_MSGS(version) * sizeof(kib_rx_t));
+ LIBCFS_CPT_ALLOC(conn->ibc_rxs, lnet_cpt_table(), cpt,
+ IBLND_RX_MSGS(version) * sizeof(kib_rx_t));
+ if (conn->ibc_rxs == NULL) {
+ CERROR("Cannot allocate RX buffers\n");
+ goto failed_2;
+ }
- rc = kiblnd_alloc_pages(&conn->ibc_rx_pages,
- IBLND_RX_MSG_PAGES(version));
- if (rc != 0)
- goto failed_2;
+ rc = kiblnd_alloc_pages(&conn->ibc_rx_pages, cpt,
+ IBLND_RX_MSG_PAGES(version));
+ if (rc != 0)
+ goto failed_2;
- kiblnd_map_rx_descs(conn);
+ kiblnd_map_rx_descs(conn);
#ifdef HAVE_OFED_IB_COMP_VECTOR
- cq = ib_create_cq(cmid->device,
- kiblnd_cq_completion, kiblnd_cq_event, conn,
- IBLND_CQ_ENTRIES(version), 0);
+ cq = ib_create_cq(cmid->device,
+ kiblnd_cq_completion, kiblnd_cq_event, conn,
+ IBLND_CQ_ENTRIES(version),
+ kiblnd_get_completion_vector(conn, cpt));
#else
cq = ib_create_cq(cmid->device,
kiblnd_cq_completion, kiblnd_cq_event, conn,
goto failed_2;
}
- memset(init_qp_attr, 0, sizeof(*init_qp_attr));
init_qp_attr->event_handler = kiblnd_qp_event;
init_qp_attr->qp_context = conn;
init_qp_attr->cap.max_send_wr = IBLND_SEND_WRS(version);
init_qp_attr->send_cq = cq;
init_qp_attr->recv_cq = cq;
+ conn->ibc_sched = sched;
+
rc = rdma_create_qp(cmid, conn->ibc_hdev->ibh_pd, init_qp_attr);
if (rc != 0) {
CERROR("Can't create QP: %d, send_wr: %d, recv_wr: %d\n",
/* correct # of posted buffers
* NB locking needed now I'm racing with completion */
- cfs_spin_lock_irqsave(&kiblnd_data.kib_sched_lock,
- flags);
- conn->ibc_nrx -= IBLND_RX_MSGS(version) - i;
- cfs_spin_unlock_irqrestore(&kiblnd_data.kib_sched_lock,
- flags);
+ spin_lock_irqsave(&sched->ibs_lock, flags);
+ conn->ibc_nrx -= IBLND_RX_MSGS(version) - i;
+ spin_unlock_irqrestore(&sched->ibs_lock, flags);
/* cmid will be destroyed by CM(ofed) after cm_callback
* returned, so we can't refer it anymore
unsigned long flags;
int count = 0;
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
if (nid != LNET_NID_ANY)
lo = hi = kiblnd_nid2peerlist(nid) - kiblnd_data.kib_peers;
}
}
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
/* wildcards always succeed */
if (nid == LNET_NID_ANY)
void
kiblnd_query (lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when)
{
- cfs_time_t last_alive = 0;
- cfs_time_t now = cfs_time_current();
- cfs_rwlock_t *glock = &kiblnd_data.kib_global_lock;
- kib_peer_t *peer;
- unsigned long flags;
+ cfs_time_t last_alive = 0;
+ cfs_time_t now = cfs_time_current();
+ rwlock_t *glock = &kiblnd_data.kib_global_lock;
+ kib_peer_t *peer;
+ unsigned long flags;
- cfs_read_lock_irqsave(glock, flags);
+ read_lock_irqsave(glock, flags);
peer = kiblnd_find_peer_locked(nid);
if (peer != NULL) {
last_alive = peer->ibp_last_alive;
}
- cfs_read_unlock_irqrestore(glock, flags);
+ read_unlock_irqrestore(glock, flags);
if (last_alive != 0)
*when = last_alive;
}
void
-kiblnd_free_pages (kib_pages_t *p)
+kiblnd_free_pages(kib_pages_t *p)
{
- int npages = p->ibp_npages;
- int i;
+ int npages = p->ibp_npages;
+ int i;
- for (i = 0; i < npages; i++)
- if (p->ibp_pages[i] != NULL)
- __free_page(p->ibp_pages[i]);
+ for (i = 0; i < npages; i++) {
+ if (p->ibp_pages[i] != NULL)
+ cfs_free_page(p->ibp_pages[i]);
+ }
- LIBCFS_FREE (p, offsetof(kib_pages_t, ibp_pages[npages]));
+ LIBCFS_FREE(p, offsetof(kib_pages_t, ibp_pages[npages]));
}
int
-kiblnd_alloc_pages (kib_pages_t **pp, int npages)
+kiblnd_alloc_pages(kib_pages_t **pp, int cpt, int npages)
{
- kib_pages_t *p;
- int i;
+ kib_pages_t *p;
+ int i;
- LIBCFS_ALLOC(p, offsetof(kib_pages_t, ibp_pages[npages]));
+ LIBCFS_CPT_ALLOC(p, lnet_cpt_table(), cpt,
+ offsetof(kib_pages_t, ibp_pages[npages]));
if (p == NULL) {
CERROR("Can't allocate descriptor for %d pages\n", npages);
return -ENOMEM;
p->ibp_npages = npages;
for (i = 0; i < npages; i++) {
- p->ibp_pages[i] = alloc_page(GFP_KERNEL);
+ p->ibp_pages[i] = cfs_page_cpt_alloc(lnet_cpt_table(), cpt,
+ CFS_ALLOC_IO);
if (p->ibp_pages[i] == NULL) {
CERROR("Can't allocate page %d of %d\n", i, npages);
kiblnd_free_pages(p);
unsigned long flags;
int i = 0;
- cfs_read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
- while (dev->ibd_failover) {
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
- if (i++ % 50 == 0)
- CDEBUG(D_NET, "Wait for dev(%s) failover\n", dev->ibd_ifname);
- cfs_schedule_timeout(cfs_time_seconds(1) / 100);
+ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ while (dev->ibd_failover) {
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ if (i++ % 50 == 0)
+ CDEBUG(D_NET, "%s: Wait for failover\n",
+ dev->ibd_ifname);
+ cfs_schedule_timeout(cfs_time_seconds(1) / 100);
- cfs_read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
- }
+ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ }
- kiblnd_hdev_addref_locked(dev->ibd_hdev);
- hdev = dev->ibd_hdev;
+ kiblnd_hdev_addref_locked(dev->ibd_hdev);
+ hdev = dev->ibd_hdev;
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
- return hdev;
+ return hdev;
}
static void
kib_pages_t *txpgs = tpo->tpo_tx_pages;
kib_pool_t *pool = &tpo->tpo_pool;
kib_net_t *net = pool->po_owner->ps_net;
- kib_dev_t *dev = net->ibn_dev;
+ kib_dev_t *dev;
struct page *page;
kib_tx_t *tx;
int page_offset;
LASSERT (net != NULL);
+ dev = net->ibn_dev;
+
/* pre-mapped messages are not bigger than 1 page */
CLASSERT (IBLND_MSG_SIZE <= PAGE_SIZE);
}
}
+static int kiblnd_fmr_pool_size(int ncpts)
+{
+ int size = *kiblnd_tunables.kib_fmr_pool_size / ncpts;
+
+ return max(IBLND_FMR_POOL, size);
+}
+
+static int kiblnd_fmr_flush_trigger(int ncpts)
+{
+ int size = *kiblnd_tunables.kib_fmr_flush_trigger / ncpts;
+
+ return max(IBLND_FMR_POOL_FLUSH, size);
+}
+
int
kiblnd_create_fmr_pool(kib_fmr_poolset_t *fps, kib_fmr_pool_t **pp_fpo)
{
.page_shift = PAGE_SHIFT,
.access = (IB_ACCESS_LOCAL_WRITE |
IB_ACCESS_REMOTE_WRITE),
- .pool_size = *kiblnd_tunables.kib_fmr_pool_size,
- .dirty_watermark = *kiblnd_tunables.kib_fmr_flush_trigger,
- .flush_function = NULL,
- .flush_arg = NULL,
- .cache = !!*kiblnd_tunables.kib_fmr_cache};
- int rc;
-
- LIBCFS_ALLOC(fpo, sizeof(kib_fmr_pool_t));
- if (fpo == NULL)
- return -ENOMEM;
+ .pool_size = fps->fps_pool_size,
+ .dirty_watermark = fps->fps_flush_trigger,
+ .flush_function = NULL,
+ .flush_arg = NULL,
+ .cache = !!*kiblnd_tunables.kib_fmr_cache};
+ int rc;
+
+ LIBCFS_CPT_ALLOC(fpo, lnet_cpt_table(), fps->fps_cpt, sizeof(*fpo));
+ if (fpo == NULL)
+ return -ENOMEM;
+
+ fpo->fpo_hdev = kiblnd_current_hdev(dev);
+
+ fpo->fpo_fmr_pool = ib_create_fmr_pool(fpo->fpo_hdev->ibh_pd, ¶m);
+ if (IS_ERR(fpo->fpo_fmr_pool)) {
+ rc = PTR_ERR(fpo->fpo_fmr_pool);
+ CERROR("Failed to create FMR pool: %d\n", rc);
- memset(fpo, 0, sizeof(kib_fmr_pool_t));
- fpo->fpo_hdev = kiblnd_current_hdev(dev);
- fpo->fpo_fmr_pool = ib_create_fmr_pool(fpo->fpo_hdev->ibh_pd, ¶m);
- if (IS_ERR(fpo->fpo_fmr_pool)) {
- CERROR("Failed to create FMR pool: %ld\n",
- PTR_ERR(fpo->fpo_fmr_pool));
- rc = PTR_ERR(fpo->fpo_fmr_pool);
kiblnd_hdev_decref(fpo->fpo_hdev);
LIBCFS_FREE(fpo, sizeof(kib_fmr_pool_t));
return rc;
}
static void
-kiblnd_fail_fmr_pool_set(kib_fmr_poolset_t *fps, cfs_list_t *zombies)
+kiblnd_fail_fmr_poolset(kib_fmr_poolset_t *fps, cfs_list_t *zombies)
{
- cfs_spin_lock(&fps->fps_lock);
+ if (fps->fps_net == NULL) /* intialized? */
+ return;
+
+ spin_lock(&fps->fps_lock);
while (!cfs_list_empty(&fps->fps_pool_list)) {
kib_fmr_pool_t *fpo = cfs_list_entry(fps->fps_pool_list.next,
cfs_list_add(&fpo->fpo_list, &fps->fps_failed_pool_list);
}
- cfs_spin_unlock(&fps->fps_lock);
+ spin_unlock(&fps->fps_lock);
}
static void
-kiblnd_fini_fmr_pool_set(kib_fmr_poolset_t *fps)
+kiblnd_fini_fmr_poolset(kib_fmr_poolset_t *fps)
{
- kiblnd_destroy_fmr_pool_list(&fps->fps_failed_pool_list);
- kiblnd_destroy_fmr_pool_list(&fps->fps_pool_list);
+ if (fps->fps_net != NULL) { /* initialized? */
+ kiblnd_destroy_fmr_pool_list(&fps->fps_failed_pool_list);
+ kiblnd_destroy_fmr_pool_list(&fps->fps_pool_list);
+ }
}
static int
-kiblnd_init_fmr_pool_set(kib_fmr_poolset_t *fps, kib_net_t *net)
+kiblnd_init_fmr_poolset(kib_fmr_poolset_t *fps, int cpt, kib_net_t *net,
+ int pool_size, int flush_trigger)
{
kib_fmr_pool_t *fpo;
int rc;
memset(fps, 0, sizeof(kib_fmr_poolset_t));
fps->fps_net = net;
- cfs_spin_lock_init(&fps->fps_lock);
- CFS_INIT_LIST_HEAD(&fps->fps_pool_list);
- CFS_INIT_LIST_HEAD(&fps->fps_failed_pool_list);
+ fps->fps_cpt = cpt;
+ fps->fps_pool_size = pool_size;
+ fps->fps_flush_trigger = flush_trigger;
+ spin_lock_init(&fps->fps_lock);
+ CFS_INIT_LIST_HEAD(&fps->fps_pool_list);
+ CFS_INIT_LIST_HEAD(&fps->fps_failed_pool_list);
+
rc = kiblnd_create_fmr_pool(fps, &fpo);
if (rc == 0)
cfs_list_add_tail(&fpo->fpo_list, &fps->fps_pool_list);
fmr->fmr_pool = NULL;
fmr->fmr_pfmr = NULL;
- cfs_spin_lock(&fps->fps_lock);
+ spin_lock(&fps->fps_lock);
fpo->fpo_map_count --; /* decref the pool */
cfs_list_for_each_entry_safe(fpo, tmp, &fps->fps_pool_list, fpo_list) {
fps->fps_version ++;
}
}
- cfs_spin_unlock(&fps->fps_lock);
+ spin_unlock(&fps->fps_lock);
if (!cfs_list_empty(&zombies))
kiblnd_destroy_fmr_pool_list(&zombies);
__u64 version;
int rc;
- LASSERT (fps->fps_net->ibn_with_fmr);
again:
- cfs_spin_lock(&fps->fps_lock);
- version = fps->fps_version;
- cfs_list_for_each_entry(fpo, &fps->fps_pool_list, fpo_list) {
- fpo->fpo_deadline = cfs_time_shift(IBLND_POOL_DEADLINE);
- fpo->fpo_map_count ++;
- cfs_spin_unlock(&fps->fps_lock);
+ spin_lock(&fps->fps_lock);
+ version = fps->fps_version;
+ cfs_list_for_each_entry(fpo, &fps->fps_pool_list, fpo_list) {
+ fpo->fpo_deadline = cfs_time_shift(IBLND_POOL_DEADLINE);
+ fpo->fpo_map_count++;
+ spin_unlock(&fps->fps_lock);
pfmr = ib_fmr_pool_map_phys(fpo->fpo_fmr_pool,
pages, npages, iov);
return 0;
}
- cfs_spin_lock(&fps->fps_lock);
- fpo->fpo_map_count --;
- if (PTR_ERR(pfmr) != -EAGAIN) {
- cfs_spin_unlock(&fps->fps_lock);
- return PTR_ERR(pfmr);
- }
-
- /* EAGAIN and ... */
- if (version != fps->fps_version) {
- cfs_spin_unlock(&fps->fps_lock);
- goto again;
- }
- }
-
- if (fps->fps_increasing) {
- cfs_spin_unlock(&fps->fps_lock);
- CDEBUG(D_NET, "Another thread is allocating new "
- "FMR pool, waiting for her to complete\n");
- cfs_schedule();
- goto again;
-
- }
-
- if (cfs_time_before(cfs_time_current(), fps->fps_next_retry)) {
- /* someone failed recently */
- cfs_spin_unlock(&fps->fps_lock);
- return -EAGAIN;
- }
-
- fps->fps_increasing = 1;
- cfs_spin_unlock(&fps->fps_lock);
-
- CDEBUG(D_NET, "Allocate new FMR pool\n");
- rc = kiblnd_create_fmr_pool(fps, &fpo);
- cfs_spin_lock(&fps->fps_lock);
- fps->fps_increasing = 0;
- if (rc == 0) {
- fps->fps_version ++;
- cfs_list_add_tail(&fpo->fpo_list, &fps->fps_pool_list);
- } else {
- fps->fps_next_retry = cfs_time_shift(10);
- }
- cfs_spin_unlock(&fps->fps_lock);
-
- goto again;
+ spin_lock(&fps->fps_lock);
+ fpo->fpo_map_count--;
+ if (PTR_ERR(pfmr) != -EAGAIN) {
+ spin_unlock(&fps->fps_lock);
+ return PTR_ERR(pfmr);
+ }
+
+ /* EAGAIN and ... */
+ if (version != fps->fps_version) {
+ spin_unlock(&fps->fps_lock);
+ goto again;
+ }
+ }
+
+ if (fps->fps_increasing) {
+ spin_unlock(&fps->fps_lock);
+ CDEBUG(D_NET, "Another thread is allocating new "
+ "FMR pool, waiting for her to complete\n");
+ cfs_schedule();
+ goto again;
+
+ }
+
+ if (cfs_time_before(cfs_time_current(), fps->fps_next_retry)) {
+ /* someone failed recently */
+ spin_unlock(&fps->fps_lock);
+ return -EAGAIN;
+ }
+
+ fps->fps_increasing = 1;
+ spin_unlock(&fps->fps_lock);
+
+ CDEBUG(D_NET, "Allocate new FMR pool\n");
+ rc = kiblnd_create_fmr_pool(fps, &fpo);
+ spin_lock(&fps->fps_lock);
+ fps->fps_increasing = 0;
+ if (rc == 0) {
+ fps->fps_version++;
+ cfs_list_add_tail(&fpo->fpo_list, &fps->fps_pool_list);
+ } else {
+ fps->fps_next_retry = cfs_time_shift(IBLND_POOL_RETRY);
+ }
+ spin_unlock(&fps->fps_lock);
+
+ goto again;
}
static void
}
static void
-kiblnd_fail_pool_set(kib_poolset_t *ps, cfs_list_t *zombies)
+kiblnd_fail_poolset(kib_poolset_t *ps, cfs_list_t *zombies)
{
- cfs_spin_lock(&ps->ps_lock);
+ if (ps->ps_net == NULL) /* intialized? */
+ return;
+
+ spin_lock(&ps->ps_lock);
while (!cfs_list_empty(&ps->ps_pool_list)) {
kib_pool_t *po = cfs_list_entry(ps->ps_pool_list.next,
kib_pool_t, po_list);
else
cfs_list_add(&po->po_list, &ps->ps_failed_pool_list);
}
- cfs_spin_unlock(&ps->ps_lock);
+ spin_unlock(&ps->ps_lock);
}
static void
-kiblnd_fini_pool_set(kib_poolset_t *ps)
+kiblnd_fini_poolset(kib_poolset_t *ps)
{
- kiblnd_destroy_pool_list(&ps->ps_failed_pool_list);
- kiblnd_destroy_pool_list(&ps->ps_pool_list);
+ if (ps->ps_net != NULL) { /* initialized? */
+ kiblnd_destroy_pool_list(&ps->ps_failed_pool_list);
+ kiblnd_destroy_pool_list(&ps->ps_pool_list);
+ }
}
static int
-kiblnd_init_pool_set(kib_poolset_t *ps, kib_net_t *net,
- char *name, int size,
- kib_ps_pool_create_t po_create,
- kib_ps_pool_destroy_t po_destroy,
- kib_ps_node_init_t nd_init,
- kib_ps_node_fini_t nd_fini)
+kiblnd_init_poolset(kib_poolset_t *ps, int cpt,
+ kib_net_t *net, char *name, int size,
+ kib_ps_pool_create_t po_create,
+ kib_ps_pool_destroy_t po_destroy,
+ kib_ps_node_init_t nd_init,
+ kib_ps_node_fini_t nd_fini)
{
- kib_pool_t *pool;
- int rc;
+ kib_pool_t *pool;
+ int rc;
- memset(ps, 0, sizeof(kib_poolset_t));
+ memset(ps, 0, sizeof(kib_poolset_t));
+ ps->ps_cpt = cpt;
ps->ps_net = net;
ps->ps_pool_create = po_create;
ps->ps_pool_destroy = po_destroy;
ps->ps_node_init = nd_init;
ps->ps_node_fini = nd_fini;
ps->ps_pool_size = size;
- strncpy(ps->ps_name, name, IBLND_POOL_NAME_LEN);
- cfs_spin_lock_init(&ps->ps_lock);
+ if (strlcpy(ps->ps_name, name, sizeof(ps->ps_name))
+ >= sizeof(ps->ps_name))
+ return -E2BIG;
+ spin_lock_init(&ps->ps_lock);
CFS_INIT_LIST_HEAD(&ps->ps_pool_list);
CFS_INIT_LIST_HEAD(&ps->ps_failed_pool_list);
kib_pool_t *tmp;
cfs_time_t now = cfs_time_current();
- cfs_spin_lock(&ps->ps_lock);
+ spin_lock(&ps->ps_lock);
if (ps->ps_node_fini != NULL)
ps->ps_node_fini(pool, node);
if (kiblnd_pool_is_idle(pool, now))
cfs_list_move(&pool->po_list, &zombies);
}
- cfs_spin_unlock(&ps->ps_lock);
+ spin_unlock(&ps->ps_lock);
- if (!cfs_list_empty(&zombies))
- kiblnd_destroy_pool_list(&zombies);
+ if (!cfs_list_empty(&zombies))
+ kiblnd_destroy_pool_list(&zombies);
}
cfs_list_t *
int rc;
again:
- cfs_spin_lock(&ps->ps_lock);
+ spin_lock(&ps->ps_lock);
cfs_list_for_each_entry(pool, &ps->ps_pool_list, po_list) {
if (cfs_list_empty(&pool->po_free_list))
continue;
/* still hold the lock */
ps->ps_node_init(pool, node);
}
- cfs_spin_unlock(&ps->ps_lock);
- return node;
- }
-
- /* no available tx pool and ... */
- if (ps->ps_increasing) {
- /* another thread is allocating a new pool */
- cfs_spin_unlock(&ps->ps_lock);
+ spin_unlock(&ps->ps_lock);
+ return node;
+ }
+
+ /* no available tx pool and ... */
+ if (ps->ps_increasing) {
+ /* another thread is allocating a new pool */
+ spin_unlock(&ps->ps_lock);
CDEBUG(D_NET, "Another thread is allocating new "
"%s pool, waiting for her to complete\n",
ps->ps_name);
goto again;
}
- if (cfs_time_before(cfs_time_current(), ps->ps_next_retry)) {
- /* someone failed recently */
- cfs_spin_unlock(&ps->ps_lock);
- return NULL;
- }
+ if (cfs_time_before(cfs_time_current(), ps->ps_next_retry)) {
+ /* someone failed recently */
+ spin_unlock(&ps->ps_lock);
+ return NULL;
+ }
- ps->ps_increasing = 1;
- cfs_spin_unlock(&ps->ps_lock);
+ ps->ps_increasing = 1;
+ spin_unlock(&ps->ps_lock);
- CDEBUG(D_NET, "%s pool exhausted, allocate new pool\n", ps->ps_name);
+ CDEBUG(D_NET, "%s pool exhausted, allocate new pool\n", ps->ps_name);
- rc = ps->ps_pool_create(ps, ps->ps_pool_size, &pool);
+ rc = ps->ps_pool_create(ps, ps->ps_pool_size, &pool);
- cfs_spin_lock(&ps->ps_lock);
+ spin_lock(&ps->ps_lock);
ps->ps_increasing = 0;
if (rc == 0) {
cfs_list_add_tail(&pool->po_list, &ps->ps_pool_list);
} else {
- /* retry 10 seconds later */
- ps->ps_next_retry = cfs_time_shift(10);
+ ps->ps_next_retry = cfs_time_shift(IBLND_POOL_RETRY);
CERROR("Can't allocate new %s pool because out of memory\n",
ps->ps_name);
}
- cfs_spin_unlock(&ps->ps_lock);
+ spin_unlock(&ps->ps_lock);
- goto again;
+ goto again;
}
void
LIBCFS_FREE(ppo, sizeof(kib_pmr_pool_t));
}
+static inline int kiblnd_pmr_pool_size(int ncpts)
+{
+ int size = *kiblnd_tunables.kib_pmr_pool_size / ncpts;
+
+ return max(IBLND_PMR_POOL, size);
+}
+
static int
kiblnd_create_pmr_pool(kib_poolset_t *ps, int size, kib_pool_t **pp_po)
{
- kib_pmr_pool_t *ppo;
- kib_pool_t *pool;
- kib_phys_mr_t *pmr;
- int i;
+ struct kib_pmr_pool *ppo;
+ struct kib_pool *pool;
+ kib_phys_mr_t *pmr;
+ int i;
- LIBCFS_ALLOC(ppo, sizeof(kib_pmr_pool_t));
+ LIBCFS_CPT_ALLOC(ppo, lnet_cpt_table(),
+ ps->ps_cpt, sizeof(kib_pmr_pool_t));
if (ppo == NULL) {
CERROR("Failed to allocate PMR pool\n");
return -ENOMEM;
kiblnd_init_pool(ps, pool, size);
for (i = 0; i < size; i++) {
- LIBCFS_ALLOC(pmr, sizeof(kib_phys_mr_t));
- if (pmr == NULL)
- break;
-
- memset(pmr, 0, sizeof(kib_phys_mr_t));
- pmr->pmr_pool = ppo;
- LIBCFS_ALLOC(pmr->pmr_ipb,
- IBLND_MAX_RDMA_FRAGS *
- sizeof(struct ib_phys_buf));
+ LIBCFS_CPT_ALLOC(pmr, lnet_cpt_table(),
+ ps->ps_cpt, sizeof(kib_phys_mr_t));
+ if (pmr == NULL)
+ break;
+
+ pmr->pmr_pool = ppo;
+ LIBCFS_CPT_ALLOC(pmr->pmr_ipb, lnet_cpt_table(), ps->ps_cpt,
+ IBLND_MAX_RDMA_FRAGS * sizeof(*pmr->pmr_ipb));
if (pmr->pmr_ipb == NULL)
break;
LIBCFS_FREE(tpo, sizeof(kib_tx_pool_t));
}
+static int kiblnd_tx_pool_size(int ncpts)
+{
+ int ntx = *kiblnd_tunables.kib_ntx / ncpts;
+
+ return max(IBLND_TX_POOL, ntx);
+}
+
static int
kiblnd_create_tx_pool(kib_poolset_t *ps, int size, kib_pool_t **pp_po)
{
kib_pool_t *pool;
kib_tx_pool_t *tpo;
- LIBCFS_ALLOC(tpo, sizeof(kib_tx_pool_t));
+ LIBCFS_CPT_ALLOC(tpo, lnet_cpt_table(), ps->ps_cpt, sizeof(*tpo));
if (tpo == NULL) {
CERROR("Failed to allocate TX pool\n");
return -ENOMEM;
tpo->tpo_tx_pages = NULL;
npg = (size * IBLND_MSG_SIZE + PAGE_SIZE - 1) / PAGE_SIZE;
- if (kiblnd_alloc_pages(&tpo->tpo_tx_pages, npg) != 0) {
- CERROR("Can't allocate tx pages: %d\n", npg);
- LIBCFS_FREE(tpo, sizeof(kib_tx_pool_t));
- return -ENOMEM;
- }
-
- LIBCFS_ALLOC (tpo->tpo_tx_descs, size * sizeof(kib_tx_t));
+ if (kiblnd_alloc_pages(&tpo->tpo_tx_pages, ps->ps_cpt, npg) != 0) {
+ CERROR("Can't allocate tx pages: %d\n", npg);
+ LIBCFS_FREE(tpo, sizeof(kib_tx_pool_t));
+ return -ENOMEM;
+ }
+
+ LIBCFS_CPT_ALLOC(tpo->tpo_tx_descs, lnet_cpt_table(), ps->ps_cpt,
+ size * sizeof(kib_tx_t));
if (tpo->tpo_tx_descs == NULL) {
CERROR("Can't allocate %d tx descriptors\n", size);
ps->ps_pool_destroy(pool);
kib_tx_t *tx = &tpo->tpo_tx_descs[i];
tx->tx_pool = tpo;
- if (ps->ps_net->ibn_with_fmr){
- LIBCFS_ALLOC(tx->tx_pages, LNET_MAX_IOV *
- sizeof(*tx->tx_pages));
- if (tx->tx_pages == NULL)
- break;
- }
-
- LIBCFS_ALLOC(tx->tx_frags,
- IBLND_MAX_RDMA_FRAGS *
- sizeof(*tx->tx_frags));
- if (tx->tx_frags == NULL)
- break;
-
- LIBCFS_ALLOC(tx->tx_wrq,
- (1 + IBLND_MAX_RDMA_FRAGS) *
- sizeof(*tx->tx_wrq));
- if (tx->tx_wrq == NULL)
- break;
-
- LIBCFS_ALLOC(tx->tx_sge,
- (1 + IBLND_MAX_RDMA_FRAGS) *
- sizeof(*tx->tx_sge));
- if (tx->tx_sge == NULL)
- break;
-
- LIBCFS_ALLOC(tx->tx_rd,
- offsetof(kib_rdma_desc_t,
- rd_frags[IBLND_MAX_RDMA_FRAGS]));
- if (tx->tx_rd == NULL)
- break;
+ if (ps->ps_net->ibn_fmr_ps != NULL) {
+ LIBCFS_CPT_ALLOC(tx->tx_pages,
+ lnet_cpt_table(), ps->ps_cpt,
+ LNET_MAX_IOV * sizeof(*tx->tx_pages));
+ if (tx->tx_pages == NULL)
+ break;
+ }
+
+ LIBCFS_CPT_ALLOC(tx->tx_frags, lnet_cpt_table(), ps->ps_cpt,
+ IBLND_MAX_RDMA_FRAGS * sizeof(*tx->tx_frags));
+ if (tx->tx_frags == NULL)
+ break;
+
+ sg_init_table(tx->tx_frags, IBLND_MAX_RDMA_FRAGS);
+
+ LIBCFS_CPT_ALLOC(tx->tx_wrq, lnet_cpt_table(), ps->ps_cpt,
+ (1 + IBLND_MAX_RDMA_FRAGS) *
+ sizeof(*tx->tx_wrq));
+ if (tx->tx_wrq == NULL)
+ break;
+
+ LIBCFS_CPT_ALLOC(tx->tx_sge, lnet_cpt_table(), ps->ps_cpt,
+ (1 + IBLND_MAX_RDMA_FRAGS) *
+ sizeof(*tx->tx_sge));
+ if (tx->tx_sge == NULL)
+ break;
+
+ LIBCFS_CPT_ALLOC(tx->tx_rd, lnet_cpt_table(), ps->ps_cpt,
+ offsetof(kib_rdma_desc_t,
+ rd_frags[IBLND_MAX_RDMA_FRAGS]));
+ if (tx->tx_rd == NULL)
+ break;
}
if (i == size) {
}
void
-kiblnd_ni_fini_pools(kib_net_t *net)
+kiblnd_net_fini_pools(kib_net_t *net)
{
- kiblnd_fini_pool_set(&net->ibn_tx_ps.tps_poolset);
- if (net->ibn_with_fmr)
- kiblnd_fini_fmr_pool_set(&net->ibn_fmr_ps);
- else if (net->ibn_with_pmr)
- kiblnd_fini_pool_set(&net->ibn_pmr_ps.pps_poolset);
-}
+ int i;
-int
-kiblnd_net_init_pools(kib_net_t *net)
-{
- kib_fmr_poolset_t *fps = &net->ibn_fmr_ps;
- kib_pmr_poolset_t *pps = &net->ibn_pmr_ps;
- kib_tx_poolset_t *tps = &net->ibn_tx_ps;
- unsigned long flags;
- int rc;
+ cfs_cpt_for_each(i, lnet_cpt_table()) {
+ kib_tx_poolset_t *tps;
+ kib_fmr_poolset_t *fps;
+ kib_pmr_poolset_t *pps;
- if (*kiblnd_tunables.kib_fmr_pool_size <
- *kiblnd_tunables.kib_ntx / 4) {
- CERROR("Can't set fmr pool size (%d) < ntx / 4(%d)\n",
- *kiblnd_tunables.kib_fmr_pool_size,
- *kiblnd_tunables.kib_ntx / 4);
- return -EINVAL;
- }
+ if (net->ibn_tx_ps != NULL) {
+ tps = net->ibn_tx_ps[i];
+ kiblnd_fini_poolset(&tps->tps_poolset);
+ }
- if (*kiblnd_tunables.kib_pmr_pool_size <
- *kiblnd_tunables.kib_ntx / 4) {
- CERROR("Can't set pmr pool size (%d) < ntx / 4(%d)\n",
- *kiblnd_tunables.kib_pmr_pool_size,
- *kiblnd_tunables.kib_ntx / 4);
- return -EINVAL;
- }
+ if (net->ibn_fmr_ps != NULL) {
+ fps = net->ibn_fmr_ps[i];
+ kiblnd_fini_fmr_poolset(fps);
+ }
- cfs_read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
- if (*kiblnd_tunables.kib_map_on_demand > 0 ||
- net->ibn_dev->ibd_hdev->ibh_nmrs > 1) {
- /* premapping can fail if ibd_nmr > 1, so we always create
- * FMR/PMR pool and map-on-demand if premapping failed */
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
- rc = kiblnd_init_fmr_pool_set(fps, net);
- if (rc == 0) {
- net->ibn_with_fmr = 1;
- } else if (rc == -ENOSYS) {
- rc = kiblnd_init_pool_set(&pps->pps_poolset, net, "PMR",
- *kiblnd_tunables.kib_pmr_pool_size,
- kiblnd_create_pmr_pool,
- kiblnd_destroy_pmr_pool,
- NULL, NULL);
- if (rc == 0)
- net->ibn_with_pmr = 1;
- }
- if (rc != 0)
- return rc;
- } else {
- cfs_read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
- }
+ if (net->ibn_pmr_ps != NULL) {
+ pps = net->ibn_pmr_ps[i];
+ kiblnd_fini_poolset(&pps->pps_poolset);
+ }
+ }
- rc = kiblnd_init_pool_set(&tps->tps_poolset, net, "TX", IBLND_TX_MSGS(),
- kiblnd_create_tx_pool, kiblnd_destroy_tx_pool,
- kiblnd_tx_init, NULL);
- if (rc == 0)
- return 0;
+ if (net->ibn_tx_ps != NULL) {
+ cfs_percpt_free(net->ibn_tx_ps);
+ net->ibn_tx_ps = NULL;
+ }
- if (net->ibn_with_fmr)
- kiblnd_fini_fmr_pool_set(fps);
- else if (net->ibn_with_pmr)
- kiblnd_fini_pool_set(&pps->pps_poolset);
+ if (net->ibn_fmr_ps != NULL) {
+ cfs_percpt_free(net->ibn_fmr_ps);
+ net->ibn_fmr_ps = NULL;
+ }
- return rc;
+ if (net->ibn_pmr_ps != NULL) {
+ cfs_percpt_free(net->ibn_pmr_ps);
+ net->ibn_pmr_ps = NULL;
+ }
+}
+
+int
+kiblnd_net_init_pools(kib_net_t *net, __u32 *cpts, int ncpts)
+{
+ unsigned long flags;
+ int cpt;
+ int rc;
+ int i;
+
+ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ if (*kiblnd_tunables.kib_map_on_demand == 0 &&
+ net->ibn_dev->ibd_hdev->ibh_nmrs == 1) {
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock,
+ flags);
+ goto create_tx_pool;
+ }
+
+ read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+
+ if (*kiblnd_tunables.kib_fmr_pool_size <
+ *kiblnd_tunables.kib_ntx / 4) {
+ CERROR("Can't set fmr pool size (%d) < ntx / 4(%d)\n",
+ *kiblnd_tunables.kib_fmr_pool_size,
+ *kiblnd_tunables.kib_ntx / 4);
+ rc = -EINVAL;
+ goto failed;
+ }
+
+ /* TX pool must be created later than FMR/PMR, see LU-2268
+ * for details */
+ LASSERT(net->ibn_tx_ps == NULL);
+
+ /* premapping can fail if ibd_nmr > 1, so we always create
+ * FMR/PMR pool and map-on-demand if premapping failed */
+
+ net->ibn_fmr_ps = cfs_percpt_alloc(lnet_cpt_table(),
+ sizeof(kib_fmr_poolset_t));
+ if (net->ibn_fmr_ps == NULL) {
+ CERROR("Failed to allocate FMR pool array\n");
+ rc = -ENOMEM;
+ goto failed;
+ }
+
+ for (i = 0; i < ncpts; i++) {
+ cpt = (cpts == NULL) ? i : cpts[i];
+ rc = kiblnd_init_fmr_poolset(net->ibn_fmr_ps[cpt], cpt, net,
+ kiblnd_fmr_pool_size(ncpts),
+ kiblnd_fmr_flush_trigger(ncpts));
+ if (rc == -ENOSYS && i == 0) /* no FMR */
+ break; /* create PMR pool */
+
+ if (rc != 0) { /* a real error */
+ CERROR("Can't initialize FMR pool for CPT %d: %d\n",
+ cpt, rc);
+ goto failed;
+ }
+ }
+
+ if (i > 0) {
+ LASSERT(i == ncpts);
+ goto create_tx_pool;
+ }
+
+ cfs_percpt_free(net->ibn_fmr_ps);
+ net->ibn_fmr_ps = NULL;
+
+ CWARN("Device does not support FMR, failing back to PMR\n");
+
+ if (*kiblnd_tunables.kib_pmr_pool_size <
+ *kiblnd_tunables.kib_ntx / 4) {
+ CERROR("Can't set pmr pool size (%d) < ntx / 4(%d)\n",
+ *kiblnd_tunables.kib_pmr_pool_size,
+ *kiblnd_tunables.kib_ntx / 4);
+ rc = -EINVAL;
+ goto failed;
+ }
+
+ net->ibn_pmr_ps = cfs_percpt_alloc(lnet_cpt_table(),
+ sizeof(kib_pmr_poolset_t));
+ if (net->ibn_pmr_ps == NULL) {
+ CERROR("Failed to allocate PMR pool array\n");
+ rc = -ENOMEM;
+ goto failed;
+ }
+
+ for (i = 0; i < ncpts; i++) {
+ cpt = (cpts == NULL) ? i : cpts[i];
+ rc = kiblnd_init_poolset(&net->ibn_pmr_ps[cpt]->pps_poolset,
+ cpt, net, "PMR",
+ kiblnd_pmr_pool_size(ncpts),
+ kiblnd_create_pmr_pool,
+ kiblnd_destroy_pmr_pool, NULL, NULL);
+ if (rc != 0) {
+ CERROR("Can't initialize PMR pool for CPT %d: %d\n",
+ cpt, rc);
+ goto failed;
+ }
+ }
+
+ create_tx_pool:
+ net->ibn_tx_ps = cfs_percpt_alloc(lnet_cpt_table(),
+ sizeof(kib_tx_poolset_t));
+ if (net->ibn_tx_ps == NULL) {
+ CERROR("Failed to allocate tx pool array\n");
+ rc = -ENOMEM;
+ goto failed;
+ }
+
+ for (i = 0; i < ncpts; i++) {
+ cpt = (cpts == NULL) ? i : cpts[i];
+ rc = kiblnd_init_poolset(&net->ibn_tx_ps[cpt]->tps_poolset,
+ cpt, net, "TX",
+ kiblnd_tx_pool_size(ncpts),
+ kiblnd_create_tx_pool,
+ kiblnd_destroy_tx_pool,
+ kiblnd_tx_init, NULL);
+ if (rc != 0) {
+ CERROR("Can't initialize TX pool for CPT %d: %d\n",
+ cpt, rc);
+ goto failed;
+ }
+ }
+
+ return 0;
+ failed:
+ kiblnd_net_fini_pools(net);
+ LASSERT(rc != 0);
+ return rc;
}
static int
return rc;
}
-#ifdef HAVE_OFED_TRANSPORT_IWARP
- /* XXX We can't trust this value returned by Chelsio driver, it's wrong
- * and we have reported the bug, remove these in the future when Chelsio
- * bug got fixed. */
- if (rdma_node_get_transport(hdev->ibh_ibdev->node_type) ==
- RDMA_TRANSPORT_IWARP)
- hdev->ibh_mr_size = (1ULL << 32) - 1;
-#endif
-
if (hdev->ibh_mr_size == ~0ULL) {
hdev->ibh_mr_shift = 64;
return 0;
dstaddr.sin_family = AF_INET;
rc = rdma_resolve_addr(cmid, (struct sockaddr *)&srcaddr,
(struct sockaddr *)&dstaddr, 1);
- if (rc != 0) {
- CERROR("Failed to bind %s to device: %d\n",
- dev->ibd_ifname, rc);
+ if (rc != 0 || cmid->device == NULL) {
+ CERROR("Failed to bind %s:%u.%u.%u.%u to device(%p): %d\n",
+ dev->ibd_ifname, HIPQUAD(dev->ibd_ifip),
+ cmid->device, rc);
rdma_destroy_id(cmid);
return rc;
}
- LASSERT (cmid->device != NULL);
if (dev->ibd_hdev->ibh_ibdev == cmid->device) {
/* don't need device failover */
rdma_destroy_id(cmid);
struct sockaddr_in addr;
unsigned long flags;
int rc = 0;
+ int i;
LASSERT (*kiblnd_tunables.kib_dev_failover > 1 ||
dev->ibd_can_failover ||
* because we can fail to create new listener.
* But we have to close it now, otherwise rdma_bind_addr
* will return EADDRINUSE... How crap! */
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
- cmid = dev->ibd_hdev->ibh_cmid;
- /* make next schedule of kiblnd_dev_need_failover
- * will return 1 for me */
- dev->ibd_hdev->ibh_cmid = NULL;
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ cmid = dev->ibd_hdev->ibh_cmid;
+ /* make next schedule of kiblnd_dev_need_failover()
+ * return 1 for me */
+ dev->ibd_hdev->ibh_cmid = NULL;
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
rdma_destroy_id(cmid);
}
/* Bind to failover device or port */
rc = rdma_bind_addr(cmid, (struct sockaddr *)&addr);
- if (rc != 0) {
- CERROR("Failed to bind %s to device: %d\n",
- dev->ibd_ifname, rc);
+ if (rc != 0 || cmid->device == NULL) {
+ CERROR("Failed to bind %s:%u.%u.%u.%u to device(%p): %d\n",
+ dev->ibd_ifname, HIPQUAD(dev->ibd_ifip),
+ cmid->device, rc);
rdma_destroy_id(cmid);
goto out;
}
- LIBCFS_ALLOC(hdev, sizeof(*hdev));
+ LIBCFS_ALLOC(hdev, sizeof(*hdev));
if (hdev == NULL) {
CERROR("Failed to allocate kib_hca_dev\n");
rdma_destroy_id(cmid);
rc = -ENOMEM;
goto out;
}
- memset(hdev, 0, sizeof(*hdev));
+
atomic_set(&hdev->ibh_ref, 1);
hdev->ibh_dev = dev;
hdev->ibh_cmid = cmid;
goto out;
}
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
old = dev->ibd_hdev;
dev->ibd_hdev = hdev; /* take over the refcount */
hdev = old;
cfs_list_for_each_entry(net, &dev->ibd_nets, ibn_list) {
- kiblnd_fail_pool_set(&net->ibn_tx_ps.tps_poolset, &zombie_tpo);
- if (net->ibn_with_pmr)
- kiblnd_fail_pool_set(&net->ibn_pmr_ps.pps_poolset, &zombie_ppo);
- if (net->ibn_with_fmr)
- kiblnd_fail_fmr_pool_set(&net->ibn_fmr_ps, &zombie_fpo);
- }
-
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ cfs_cpt_for_each(i, lnet_cpt_table()) {
+ kiblnd_fail_poolset(&net->ibn_tx_ps[i]->tps_poolset,
+ &zombie_tpo);
+
+ if (net->ibn_fmr_ps != NULL) {
+ kiblnd_fail_fmr_poolset(net->ibn_fmr_ps[i],
+ &zombie_fpo);
+
+ } else if (net->ibn_pmr_ps != NULL) {
+ kiblnd_fail_poolset(&net->ibn_pmr_ps[i]->
+ pps_poolset, &zombie_ppo);
+ }
+ }
+ }
+
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
out:
if (!cfs_list_empty(&zombie_tpo))
kiblnd_destroy_pool_list(&zombie_tpo);
memset(dev, 0, sizeof(*dev));
#ifdef HAVE_DEV_GET_BY_NAME_2ARG
- if ((netdev = dev_get_by_name(&init_net, ifname)) == NULL) {
+ netdev = dev_get_by_name(&init_net, ifname);
#else
- if ((netdev = dev_get_by_name(ifname)) == NULL) {
+ netdev = dev_get_by_name(ifname);
#endif
- CERROR("Can't find netdev of IF: %s\n", ifname);
- LIBCFS_FREE(dev, sizeof(*dev));
- return NULL;
+ if (netdev == NULL) {
+ dev->ibd_can_failover = 0;
+ } else {
+ dev->ibd_can_failover = !!(netdev->flags & IFF_MASTER);
+ dev_put(netdev);
}
- dev->ibd_can_failover = !!(netdev->flags & IFF_MASTER);
- dev_put(netdev);
-
CFS_INIT_LIST_HEAD(&dev->ibd_nets);
CFS_INIT_LIST_HEAD(&dev->ibd_list); /* not yet in kib_devs */
CFS_INIT_LIST_HEAD(&dev->ibd_fail_list);
}
void
-kiblnd_base_shutdown (void)
+kiblnd_base_shutdown(void)
{
- int i;
+ struct kib_sched_info *sched;
+ int i;
LASSERT (cfs_list_empty(&kiblnd_data.kib_devs));
/* flag threads to terminate; wake and wait for them to die */
kiblnd_data.kib_shutdown = 1;
- cfs_waitq_broadcast(&kiblnd_data.kib_sched_waitq);
+
+ /* NB: we really want to stop scheduler threads net by net
+ * instead of the whole module, this should be improved
+ * with dynamic configuration LNet */
+ cfs_percpt_for_each(sched, i, kiblnd_data.kib_scheds)
+ cfs_waitq_broadcast(&sched->ibs_waitq);
+
cfs_waitq_broadcast(&kiblnd_data.kib_connd_waitq);
cfs_waitq_broadcast(&kiblnd_data.kib_failover_waitq);
break;
}
- if (kiblnd_data.kib_peers != NULL)
- LIBCFS_FREE(kiblnd_data.kib_peers,
- sizeof(cfs_list_t) *
- kiblnd_data.kib_peer_hash_size);
+ if (kiblnd_data.kib_peers != NULL) {
+ LIBCFS_FREE(kiblnd_data.kib_peers,
+ sizeof(cfs_list_t) *
+ kiblnd_data.kib_peer_hash_size);
+ }
+
+ if (kiblnd_data.kib_scheds != NULL)
+ cfs_percpt_free(kiblnd_data.kib_scheds);
CDEBUG(D_MALLOC, "after LND base cleanup: kmem %d\n",
cfs_atomic_read(&libcfs_kmemory));
kiblnd_shutdown (lnet_ni_t *ni)
{
kib_net_t *net = ni->ni_data;
- cfs_rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
+ rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
int i;
unsigned long flags;
CDEBUG(D_MALLOC, "before LND net cleanup: kmem %d\n",
cfs_atomic_read(&libcfs_kmemory));
- cfs_write_lock_irqsave(g_lock, flags);
- net->ibn_shutdown = 1;
- cfs_write_unlock_irqrestore(g_lock, flags);
+ write_lock_irqsave(g_lock, flags);
+ net->ibn_shutdown = 1;
+ write_unlock_irqrestore(g_lock, flags);
switch (net->ibn_init) {
default:
cfs_pause(cfs_time_seconds(1));
}
- kiblnd_ni_fini_pools(net);
+ kiblnd_net_fini_pools(net);
- cfs_write_lock_irqsave(g_lock, flags);
- LASSERT (net->ibn_dev->ibd_nnets > 0);
- net->ibn_dev->ibd_nnets--;
- cfs_list_del(&net->ibn_list);
- cfs_write_unlock_irqrestore(g_lock, flags);
+ write_lock_irqsave(g_lock, flags);
+ LASSERT(net->ibn_dev->ibd_nnets > 0);
+ net->ibn_dev->ibd_nnets--;
+ cfs_list_del(&net->ibn_list);
+ write_unlock_irqrestore(g_lock, flags);
/* fall through */
}
int
-kiblnd_base_startup (void)
+kiblnd_base_startup(void)
{
- int i;
- int rc;
+ struct kib_sched_info *sched;
+ int rc;
+ int i;
LASSERT (kiblnd_data.kib_init == IBLND_INIT_NOTHING);
PORTAL_MODULE_USE;
memset(&kiblnd_data, 0, sizeof(kiblnd_data)); /* zero pointers, flags etc */
- cfs_rwlock_init(&kiblnd_data.kib_global_lock);
+ rwlock_init(&kiblnd_data.kib_global_lock);
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_devs);
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_failed_devs);
for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++)
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_peers[i]);
- cfs_spin_lock_init(&kiblnd_data.kib_connd_lock);
+ spin_lock_init(&kiblnd_data.kib_connd_lock);
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_connd_conns);
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_connd_zombies);
cfs_waitq_init(&kiblnd_data.kib_connd_waitq);
+ cfs_waitq_init(&kiblnd_data.kib_failover_waitq);
+
+ kiblnd_data.kib_scheds = cfs_percpt_alloc(lnet_cpt_table(),
+ sizeof(*sched));
+ if (kiblnd_data.kib_scheds == NULL)
+ goto failed;
- cfs_spin_lock_init(&kiblnd_data.kib_sched_lock);
- CFS_INIT_LIST_HEAD(&kiblnd_data.kib_sched_conns);
- cfs_waitq_init(&kiblnd_data.kib_sched_waitq);
- cfs_waitq_init(&kiblnd_data.kib_failover_waitq);
+ cfs_percpt_for_each(sched, i, kiblnd_data.kib_scheds) {
+ int nthrs;
+
+ spin_lock_init(&sched->ibs_lock);
+ CFS_INIT_LIST_HEAD(&sched->ibs_conns);
+ cfs_waitq_init(&sched->ibs_waitq);
+
+ nthrs = cfs_cpt_weight(lnet_cpt_table(), i);
+ if (*kiblnd_tunables.kib_nscheds > 0) {
+ nthrs = min(nthrs, *kiblnd_tunables.kib_nscheds);
+ } else {
+ /* max to half of CPUs, another half is reserved for
+ * upper layer modules */
+ nthrs = min(max(IBLND_N_SCHED, nthrs >> 1), nthrs);
+ }
+
+ sched->ibs_nthreads_max = nthrs;
+ sched->ibs_cpt = i;
+ }
kiblnd_data.kib_error_qpa.qp_state = IB_QPS_ERR;
kiblnd_data.kib_init = IBLND_INIT_DATA;
/*****************************************************/
- for (i = 0; i < IBLND_N_SCHED; i++) {
- rc = kiblnd_thread_start(kiblnd_scheduler, (void *)((long)i));
- if (rc != 0) {
- CERROR("Can't spawn o2iblnd scheduler[%d]: %d\n",
- i, rc);
- goto failed;
- }
- }
-
- rc = kiblnd_thread_start(kiblnd_connd, NULL);
+ rc = kiblnd_thread_start(kiblnd_connd, NULL, "kiblnd_connd");
if (rc != 0) {
CERROR("Can't spawn o2iblnd connd: %d\n", rc);
goto failed;
}
- if (*kiblnd_tunables.kib_dev_failover != 0)
- rc = kiblnd_thread_start(kiblnd_failover_thread, NULL);
+ if (*kiblnd_tunables.kib_dev_failover != 0)
+ rc = kiblnd_thread_start(kiblnd_failover_thread, NULL,
+ "kiblnd_failover");
if (rc != 0) {
CERROR("Can't spawn o2iblnd failover thread: %d\n", rc);
}
int
+kiblnd_start_schedulers(struct kib_sched_info *sched)
+{
+ int rc = 0;
+ int nthrs;
+ int i;
+
+ if (sched->ibs_nthreads == 0) {
+ if (*kiblnd_tunables.kib_nscheds > 0) {
+ nthrs = sched->ibs_nthreads_max;
+ } else {
+ nthrs = cfs_cpt_weight(lnet_cpt_table(),
+ sched->ibs_cpt);
+ nthrs = min(max(IBLND_N_SCHED, nthrs >> 1), nthrs);
+ nthrs = min(IBLND_N_SCHED_HIGH, nthrs);
+ }
+ } else {
+ LASSERT(sched->ibs_nthreads <= sched->ibs_nthreads_max);
+ /* increase one thread if there is new interface */
+ nthrs = (sched->ibs_nthreads < sched->ibs_nthreads_max);
+ }
+
+ for (i = 0; i < nthrs; i++) {
+ long id;
+ char name[20];
+ id = KIB_THREAD_ID(sched->ibs_cpt, sched->ibs_nthreads + i);
+ snprintf(name, sizeof(name), "kiblnd_sd_%02ld_%02ld",
+ KIB_THREAD_CPT(id), KIB_THREAD_TID(id));
+ rc = kiblnd_thread_start(kiblnd_scheduler, (void *)id, name);
+ if (rc == 0)
+ continue;
+
+ CERROR("Can't spawn thread %d for scheduler[%d]: %d\n",
+ sched->ibs_cpt, sched->ibs_nthreads + i, rc);
+ break;
+ }
+
+ sched->ibs_nthreads += i;
+ return rc;
+}
+
+int
+kiblnd_dev_start_threads(kib_dev_t *dev, int newdev, __u32 *cpts, int ncpts)
+{
+ int cpt;
+ int rc;
+ int i;
+
+ for (i = 0; i < ncpts; i++) {
+ struct kib_sched_info *sched;
+
+ cpt = (cpts == NULL) ? i : cpts[i];
+ sched = kiblnd_data.kib_scheds[cpt];
+
+ if (!newdev && sched->ibs_nthreads > 0)
+ continue;
+
+ rc = kiblnd_start_schedulers(kiblnd_data.kib_scheds[cpt]);
+ if (rc != 0) {
+ CERROR("Failed to start scheduler threads for %s\n",
+ dev->ibd_ifname);
+ return rc;
+ }
+ }
+ return 0;
+}
+
+kib_dev_t *
+kiblnd_dev_search(char *ifname)
+{
+ kib_dev_t *alias = NULL;
+ kib_dev_t *dev;
+ char *colon;
+ char *colon2;
+
+ colon = strchr(ifname, ':');
+ cfs_list_for_each_entry(dev, &kiblnd_data.kib_devs, ibd_list) {
+ if (strcmp(&dev->ibd_ifname[0], ifname) == 0)
+ return dev;
+
+ if (alias != NULL)
+ continue;
+
+ colon2 = strchr(dev->ibd_ifname, ':');
+ if (colon != NULL)
+ *colon = 0;
+ if (colon2 != NULL)
+ *colon2 = 0;
+
+ if (strcmp(&dev->ibd_ifname[0], ifname) == 0)
+ alias = dev;
+
+ if (colon != NULL)
+ *colon = ':';
+ if (colon2 != NULL)
+ *colon2 = ':';
+ }
+ return alias;
+}
+
+int
kiblnd_startup (lnet_ni_t *ni)
{
char *ifname;
kib_dev_t *ibdev = NULL;
kib_net_t *net;
- cfs_list_t *tmp;
struct timeval tv;
unsigned long flags;
int rc;
+ int newdev;
LASSERT (ni->ni_lnd == &the_o2iblnd);
goto failed;
}
- cfs_list_for_each (tmp, &kiblnd_data.kib_devs) {
- ibdev = cfs_list_entry(tmp, kib_dev_t, ibd_list);
+ ibdev = kiblnd_dev_search(ifname);
- if (!strcmp(&ibdev->ibd_ifname[0], ifname))
- break;
-
- ibdev = NULL;
- }
-
- if (ibdev == NULL)
+ newdev = ibdev == NULL;
+ /* hmm...create kib_dev even for alias */
+ if (ibdev == NULL || strcmp(&ibdev->ibd_ifname[0], ifname) != 0)
ibdev = kiblnd_create_dev(ifname);
if (ibdev == NULL)
net->ibn_dev = ibdev;
ni->ni_nid = LNET_MKNID(LNET_NIDNET(ni->ni_nid), ibdev->ibd_ifip);
- rc = kiblnd_net_init_pools(net);
+ rc = kiblnd_dev_start_threads(ibdev, newdev,
+ ni->ni_cpts, ni->ni_ncpts);
+ if (rc != 0)
+ goto failed;
+
+ rc = kiblnd_net_init_pools(net, ni->ni_cpts, ni->ni_ncpts);
if (rc != 0) {
CERROR("Failed to initialize NI pools: %d\n", rc);
goto failed;
}
- cfs_write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
- ibdev->ibd_nnets++;
- cfs_list_add_tail(&net->ibn_list, &ibdev->ibd_nets);
- cfs_write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
+ write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
+ ibdev->ibd_nnets++;
+ cfs_list_add_tail(&net->ibn_list, &ibdev->ibd_nets);
+ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
net->ibn_init = IBLND_INIT_ALL;