* its ref on 'cmid'). */
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;
struct kib_sched_info *sched;
kib_conn_t *conn;
LASSERT(net != NULL);
LASSERT(!cfs_in_interrupt());
+ dev = net->ibn_dev;
+
cpt = lnet_cpt_of_nid(peer->ibp_nid);
sched = kiblnd_data.kib_scheds[cpt];
goto failed_2;
}
- if (dev->ibd_hdev->ibh_ibdev != cmid->device) {
- /* wakeup failover thread and teardown connection */
- if (kiblnd_dev_can_failover(dev)) {
- cfs_list_add_tail(&dev->ibd_fail_list,
- &kiblnd_data.kib_failed_devs);
- cfs_waitq_signal(&kiblnd_data.kib_failover_waitq);
- }
+ if (dev->ibd_hdev->ibh_ibdev != cmid->device) {
+ /* wakeup failover thread and teardown connection */
+ if (kiblnd_dev_can_failover(dev)) {
+ cfs_list_add_tail(&dev->ibd_fail_list,
+ &kiblnd_data.kib_failed_devs);
+ wake_up(&kiblnd_data.kib_failover_waitq);
+ }
write_unlock_irqrestore(glock, flags);
- CERROR("cmid HCA(%s), kib_dev(%s) need failover\n",
- cmid->device->name, dev->ibd_ifname);
- goto failed_2;
- }
+ CERROR("cmid HCA(%s), kib_dev(%s) need failover\n",
+ cmid->device->name, dev->ibd_ifname);
+ goto failed_2;
+ }
kiblnd_hdev_addref_locked(dev->ibd_hdev);
conn->ibc_hdev = dev->ibd_hdev;
for (i = 0; i < npages; i++) {
if (p->ibp_pages[i] != NULL)
- cfs_free_page(p->ibp_pages[i]);
+ __free_page(p->ibp_pages[i]);
}
LIBCFS_FREE(p, offsetof(kib_pages_t, ibp_pages[npages]));
for (i = 0; i < npages; i++) {
p->ibp_pages[i] = cfs_page_cpt_alloc(lnet_cpt_table(), cpt,
- CFS_ALLOC_IO);
+ __GFP_IO);
if (p->ibp_pages[i] == NULL) {
CERROR("Can't allocate page %d of %d\n", i, npages);
kiblnd_free_pages(p);
if (i++ % 50 == 0)
CDEBUG(D_NET, "%s: Wait for failover\n",
dev->ibd_ifname);
- cfs_schedule_timeout(cfs_time_seconds(1) / 100);
+ schedule_timeout(cfs_time_seconds(1) / 100);
read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
}
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);
spin_unlock(&fps->fps_lock);
CDEBUG(D_NET, "Another thread is allocating new "
"FMR pool, waiting for her to complete\n");
- cfs_schedule();
+ schedule();
goto again;
}
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);
+ 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);
CDEBUG(D_NET, "Another thread is allocating new "
"%s pool, waiting for her to complete\n",
ps->ps_name);
- cfs_schedule();
+ schedule();
goto again;
}
LASSERT (cfs_list_empty(&kiblnd_data.kib_connd_zombies));
LASSERT (cfs_list_empty(&kiblnd_data.kib_connd_conns));
- /* flag threads to terminate; wake and wait for them to die */
- kiblnd_data.kib_shutdown = 1;
+ /* flag threads to terminate; wake and wait for them to die */
+ kiblnd_data.kib_shutdown = 1;
/* 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);
+ wake_up_all(&sched->ibs_waitq);
- cfs_waitq_broadcast(&kiblnd_data.kib_connd_waitq);
- cfs_waitq_broadcast(&kiblnd_data.kib_failover_waitq);
+ wake_up_all(&kiblnd_data.kib_connd_waitq);
+ wake_up_all(&kiblnd_data.kib_failover_waitq);
- i = 2;
- while (cfs_atomic_read(&kiblnd_data.kib_nthreads) != 0) {
+ i = 2;
+ while (cfs_atomic_read(&kiblnd_data.kib_nthreads) != 0) {
i++;
CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, /* power of 2? */
"Waiting for %d threads to terminate\n",
CDEBUG(D_MALLOC, "after LND base cleanup: kmem %d\n",
cfs_atomic_read(&libcfs_kmemory));
- kiblnd_data.kib_init = IBLND_INIT_NOTHING;
- PORTAL_MODULE_UNUSE;
+ kiblnd_data.kib_init = IBLND_INIT_NOTHING;
+ module_put(THIS_MODULE);
}
void
LASSERT (kiblnd_data.kib_init == IBLND_INIT_NOTHING);
- PORTAL_MODULE_USE;
- memset(&kiblnd_data, 0, sizeof(kiblnd_data)); /* zero pointers, flags etc */
+ try_module_get(THIS_MODULE);
+ memset(&kiblnd_data, 0, sizeof(kiblnd_data)); /* zero pointers, flags etc */
rwlock_init(&kiblnd_data.kib_global_lock);
CFS_INIT_LIST_HEAD(&kiblnd_data.kib_peers[i]);
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);
+ CFS_INIT_LIST_HEAD(&kiblnd_data.kib_connd_conns);
+ CFS_INIT_LIST_HEAD(&kiblnd_data.kib_connd_zombies);
+ init_waitqueue_head(&kiblnd_data.kib_connd_waitq);
+ init_waitqueue_head(&kiblnd_data.kib_failover_waitq);
kiblnd_data.kib_scheds = cfs_percpt_alloc(lnet_cpt_table(),
sizeof(*sched));
spin_lock_init(&sched->ibs_lock);
CFS_INIT_LIST_HEAD(&sched->ibs_conns);
- cfs_waitq_init(&sched->ibs_waitq);
+ init_waitqueue_head(&sched->ibs_waitq);
nthrs = cfs_cpt_weight(lnet_cpt_table(), i);
if (*kiblnd_tunables.kib_nscheds > 0) {
kiblnd_data.kib_init = IBLND_INIT_DATA;
/*****************************************************/
- 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);
for (i = 0; i < nthrs; i++) {
long id;
-
+ char name[20];
id = KIB_THREAD_ID(sched->ibs_cpt, sched->ibs_nthreads + i);
- rc = kiblnd_thread_start(kiblnd_scheduler, (void *)id);
+ 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;
if (net == NULL)
goto failed;
- memset(net, 0, sizeof(*net));
+ memset(net, 0, sizeof(*net));
- cfs_gettimeofday(&tv);
- net->ibn_incarnation = (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec;
+ do_gettimeofday(&tv);
+ net->ibn_incarnation = (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec;
ni->ni_peertimeout = *kiblnd_tunables.kib_peertimeout;
ni->ni_maxtxcredits = *kiblnd_tunables.kib_credits;
return 0;
failed:
- if (net->ibn_dev == NULL && ibdev != NULL)
+ if (net != NULL && net->ibn_dev == NULL && ibdev != NULL)
kiblnd_destroy_dev(ibdev);
kiblnd_shutdown(ni);