X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Fklnds%2Fgnilnd%2Fgnilnd.c;h=d1a73a7fc62f1c8e3cbb3703f98d8e94cbe272f6;hb=refs%2Fchanges%2F25%2F36725%2F3;hp=4961d44c33a4998a68412c3b56638f45425bed2f;hpb=31be9f94d72287d7077ffc00d392a71056f61f4d;p=fs%2Flustre-release.git diff --git a/lnet/klnds/gnilnd/gnilnd.c b/lnet/klnds/gnilnd/gnilnd.c index 4961d44..d1a73a7 100644 --- a/lnet/klnds/gnilnd/gnilnd.c +++ b/lnet/klnds/gnilnd/gnilnd.c @@ -1,7 +1,7 @@ /* * Copyright (C) 2012 Cray, Inc. * - * Copyright (c) 2013, 2014, Intel Corporation. + * Copyright (c) 2013, 2017, Intel Corporation. * * Author: Nic Henke * Author: James Shimek @@ -25,12 +25,8 @@ #include "gnilnd.h" /* Primary entry points from LNET. There are no guarantees against reentrance. */ -lnd_t the_kgnilnd = { -#ifdef CONFIG_CRAY_XT +struct lnet_lnd the_kgnilnd = { .lnd_type = GNILND, -#else - .lnd_type = GNIIPLND, -#endif .lnd_startup = kgnilnd_startup, .lnd_shutdown = kgnilnd_shutdown, .lnd_ctl = kgnilnd_ctl, @@ -42,6 +38,52 @@ lnd_t the_kgnilnd = { kgn_data_t kgnilnd_data; +int +kgnilnd_thread_start(int(*fn)(void *arg), void *arg, char *name, int id) +{ + struct task_struct *thrd; + + thrd = kthread_run(fn, arg, "%s_%02d", name, id); + if (IS_ERR(thrd)) + return PTR_ERR(thrd); + + atomic_inc(&kgnilnd_data.kgn_nthreads); + return 0; +} + +/* bind scheduler threads to cpus */ +int +kgnilnd_start_sd_threads(void) +{ + int cpu; + int i = 0; + struct task_struct *task; + + for_each_online_cpu(cpu) { + /* don't bind to cpu 0 - all interrupts are processed here */ + if (cpu == 0) + continue; + + task = kthread_create(kgnilnd_scheduler, (void *)((long)i), + "%s_%02d", "kgnilnd_sd", i); + if (!IS_ERR(task)) { + kthread_bind(task, cpu); + wake_up_process(task); + } else { + CERROR("Can't spawn gnilnd scheduler[%d] %ld\n", i, + PTR_ERR(task)); + return PTR_ERR(task); + } + atomic_inc(&kgnilnd_data.kgn_nthreads); + + if (++i >= *kgnilnd_tunables.kgn_sched_threads) { + break; + } + } + + return 0; +} + /* needs write_lock on kgn_peer_conn_lock */ int kgnilnd_close_stale_conns_locked(kgn_peer_t *peer, kgn_conn_t *newconn) @@ -71,8 +113,8 @@ kgnilnd_close_stale_conns_locked(kgn_peer_t *peer, kgn_conn_t *newconn) newconn->gnc_peer_connstamp == conn->gnc_my_connstamp) { CDEBUG(D_NET, "skipping prune of %p, " "loopback and matching stamps" - " connstamp "LPU64"("LPU64")" - " peerstamp "LPU64"("LPU64")\n", + " connstamp %llu(%llu)" + " peerstamp %llu(%llu)\n", conn, newconn->gnc_my_connstamp, conn->gnc_peer_connstamp, newconn->gnc_peer_connstamp, @@ -82,25 +124,25 @@ kgnilnd_close_stale_conns_locked(kgn_peer_t *peer, kgn_conn_t *newconn) if (conn->gnc_peerstamp != newconn->gnc_peerstamp) { LASSERTF(conn->gnc_peerstamp < newconn->gnc_peerstamp, - "conn 0x%p peerstamp "LPU64" >= " - "newconn 0x%p peerstamp "LPU64"\n", + "conn 0x%p peerstamp %llu >= " + "newconn 0x%p peerstamp %llu\n", conn, conn->gnc_peerstamp, newconn, newconn->gnc_peerstamp); CDEBUG(D_NET, "Closing stale conn nid: %s " - " peerstamp:"LPX64"("LPX64")\n", + " peerstamp:%#llx(%#llx)\n", libcfs_nid2str(peer->gnp_nid), conn->gnc_peerstamp, newconn->gnc_peerstamp); } else { LASSERTF(conn->gnc_peer_connstamp < newconn->gnc_peer_connstamp, - "conn 0x%p peer_connstamp "LPU64" >= " - "newconn 0x%p peer_connstamp "LPU64"\n", + "conn 0x%p peer_connstamp %llu >= " + "newconn 0x%p peer_connstamp %llu\n", conn, conn->gnc_peer_connstamp, newconn, newconn->gnc_peer_connstamp); CDEBUG(D_NET, "Closing stale conn nid: %s" - " connstamp:"LPU64"("LPU64")\n", + " connstamp:%llu(%llu)\n", libcfs_nid2str(peer->gnp_nid), conn->gnc_peer_connstamp, newconn->gnc_peer_connstamp); } @@ -129,8 +171,8 @@ kgnilnd_conn_isdup_locked(kgn_peer_t *peer, kgn_conn_t *newconn) list_for_each(tmp, &peer->gnp_conns) { conn = list_entry(tmp, kgn_conn_t, gnc_list); CDEBUG(D_NET, "checking conn 0x%p for peer %s" - " lo %d new "LPU64" existing "LPU64 - " new peer "LPU64" existing peer "LPU64 + " lo %d new %llu existing %llu" + " new peer %llu existing peer %llu" " new dev %p existing dev %p\n", conn, libcfs_nid2str(peer->gnp_nid), loopback, @@ -202,7 +244,8 @@ kgnilnd_create_conn(kgn_conn_t **connp, kgn_device_t *dev) return -ENOMEM; } - LIBCFS_ALLOC(conn->gnc_tx_ref_table, GNILND_MAX_MSG_ID * sizeof(void *)); + conn->gnc_tx_ref_table = + kgnilnd_vzalloc(GNILND_MAX_MSG_ID * sizeof(void *)); if (conn->gnc_tx_ref_table == NULL) { CERROR("Can't allocate conn tx_ref_table\n"); GOTO(failed, rc = -ENOMEM); @@ -219,6 +262,7 @@ kgnilnd_create_conn(kgn_conn_t **connp, kgn_device_t *dev) INIT_LIST_HEAD(&conn->gnc_schedlist); INIT_LIST_HEAD(&conn->gnc_fmaq); INIT_LIST_HEAD(&conn->gnc_mdd_list); + INIT_LIST_HEAD(&conn->gnc_delaylist); spin_lock_init(&conn->gnc_list_lock); spin_lock_init(&conn->gnc_tx_lock); conn->gnc_magic = GNILND_CONN_MAGIC; @@ -228,7 +272,7 @@ kgnilnd_create_conn(kgn_conn_t **connp, kgn_device_t *dev) conn->gnc_next_tx = (int) GNILND_MAX_MSG_ID - 10; /* if this fails, we have conflicts and MAX_TX is too large */ - CLASSERT(GNILND_MAX_MSG_ID < GNILND_MSGID_CLOSE); + BUILD_BUG_ON(GNILND_MAX_MSG_ID >= GNILND_MSGID_CLOSE); /* get a new unique CQ id for this conn */ write_lock(&kgnilnd_data.kgn_peer_conn_lock); @@ -272,7 +316,8 @@ kgnilnd_create_conn(kgn_conn_t **connp, kgn_device_t *dev) failed: atomic_dec(&kgnilnd_data.kgn_nconns); - LIBCFS_FREE(conn->gnc_tx_ref_table, GNILND_MAX_MSG_ID * sizeof(void *)); + kgnilnd_vfree(conn->gnc_tx_ref_table, + GNILND_MAX_MSG_ID * sizeof(void *)); LIBCFS_FREE(conn, sizeof(*conn)); return rc; } @@ -403,8 +448,9 @@ kgnilnd_destroy_conn(kgn_conn_t *conn) list_empty(&conn->gnc_hashlist) && list_empty(&conn->gnc_schedlist) && list_empty(&conn->gnc_mdd_list) && + list_empty(&conn->gnc_delaylist) && conn->gnc_magic == GNILND_CONN_MAGIC, - "conn 0x%p->%s IRQ %d sched %d purg %d ep 0x%p Mg %d lists %d/%d/%d/%d\n", + "conn 0x%p->%s IRQ %d sched %d purg %d ep 0x%p Mg %d lists %d/%d/%d/%d/%d\n", conn, conn->gnc_peer ? libcfs_nid2str(conn->gnc_peer->gnp_nid) : "", !!in_interrupt(), conn->gnc_scheduled, @@ -414,7 +460,8 @@ kgnilnd_destroy_conn(kgn_conn_t *conn) list_empty(&conn->gnc_list), list_empty(&conn->gnc_hashlist), list_empty(&conn->gnc_schedlist), - list_empty(&conn->gnc_mdd_list)); + list_empty(&conn->gnc_mdd_list), + list_empty(&conn->gnc_delaylist)); /* Tripping these is especially bad, as it means we have items on the * lists that didn't keep their refcount on the connection - or @@ -446,8 +493,8 @@ kgnilnd_destroy_conn(kgn_conn_t *conn) kgnilnd_peer_decref(conn->gnc_peer); if (conn->gnc_tx_ref_table != NULL) { - LIBCFS_FREE(conn->gnc_tx_ref_table, - GNILND_MAX_MSG_ID * sizeof(void *)); + kgnilnd_vfree(conn->gnc_tx_ref_table, + GNILND_MAX_MSG_ID * sizeof(void *)); } LIBCFS_FREE(conn, sizeof(*conn)); @@ -458,7 +505,9 @@ kgnilnd_destroy_conn(kgn_conn_t *conn) void kgnilnd_peer_alive(kgn_peer_t *peer) { - set_mb(peer->gnp_last_alive, jiffies); + time64_t now = ktime_get_seconds(); + + set_mb(peer->gnp_last_alive, now); } void @@ -554,11 +603,12 @@ kgnilnd_peer_notify(kgn_peer_t *peer, int error, int alive) peer_nid = kgnilnd_lnd2lnetnid(net->gnn_ni->ni_nid, peer->gnp_nid); - CDEBUG(D_NET, "peer 0x%p->%s last_alive %lu (%lus ago)\n", + CDEBUG(D_NET, "peer 0x%p->%s last_alive %lld (%llds ago)\n", peer, libcfs_nid2str(peer_nid), peer->gnp_last_alive, - cfs_duration_sec(jiffies - peer->gnp_last_alive)); + ktime_get_seconds() - peer->gnp_last_alive); lnet_notify(net->gnn_ni, peer_nid, alive, + (alive) ? true : false, peer->gnp_last_alive); kgnilnd_net_decref(net); @@ -588,7 +638,7 @@ kgnilnd_close_conn_locked(kgn_conn_t *conn, int error) /* if we NETERROR, make sure it is rate limited */ if (!kgnilnd_conn_clean_errno(error) && - peer->gnp_down == GNILND_RCA_NODE_UP) { + peer->gnp_state != GNILND_PEER_DOWN) { CNETERR("closing conn to %s: error %d\n", libcfs_nid2str(peer->gnp_nid), error); } else { @@ -624,6 +674,10 @@ kgnilnd_close_conn_locked(kgn_conn_t *conn, int error) conn->gnc_state = GNILND_CONN_CLOSING; } + if (CFS_FAIL_CHECK(CFS_FAIL_GNI_RDMA_CQ_ERROR)) { + msleep_interruptible(MSEC_PER_SEC); + } + /* leave on peer->gnp_conns to make sure we don't let the reaper * or others try to unlink this peer until the conn is fully * processed for closing */ @@ -686,6 +740,11 @@ kgnilnd_complete_closed_conn(kgn_conn_t *conn) kgnilnd_conn_state2str(conn)); LASSERT(list_empty(&conn->gnc_hashlist)); + /* We shouldnt be on the delay list, the conn can + * get added to this list during a retransmit, and retransmits + * only occur within scheduler threads. + */ + LASSERT(list_empty(&conn->gnc_delaylist)); /* we've sent the close, start nuking */ if (CFS_FAIL_CHECK(CFS_FAIL_GNI_SCHEDULE_COMPLETE)) @@ -757,19 +816,13 @@ kgnilnd_complete_closed_conn(kgn_conn_t *conn) logmsg = (nlive + nrdma + nq_rdma); if (logmsg) { - if (conn->gnc_peer->gnp_down == GNILND_RCA_NODE_UP) { - CNETERR("Closed conn 0x%p->%s (errno %d, peer errno %d): " - "canceled %d TX, %d/%d RDMA\n", - conn, libcfs_nid2str(conn->gnc_peer->gnp_nid), - conn->gnc_error, conn->gnc_peer_error, - nlive, nq_rdma, nrdma); - } else { - CDEBUG(D_NET, "Closed conn 0x%p->%s (errno %d," - " peer errno %d): canceled %d TX, %d/%d RDMA\n", - conn, libcfs_nid2str(conn->gnc_peer->gnp_nid), - conn->gnc_error, conn->gnc_peer_error, - nlive, nq_rdma, nrdma); - } + int level = conn->gnc_peer->gnp_state == GNILND_PEER_UP ? + D_NETERROR : D_NET; + CDEBUG(level, "Closed conn 0x%p->%s (errno %d," + " peer errno %d): canceled %d TX, %d/%d RDMA\n", + conn, libcfs_nid2str(conn->gnc_peer->gnp_nid), + conn->gnc_error, conn->gnc_peer_error, + nlive, nq_rdma, nrdma); } kgnilnd_destroy_conn_ep(conn); @@ -873,8 +926,8 @@ kgnilnd_set_conn_params(kgn_dgram_t *dgram) /* log this for help in debuggin SMSG buffer re-use */ CDEBUG(D_NET, "conn %p src %s dst %s smsg %p acquired" - " local cqid %u SMSG %p->%u hndl "LPX64"."LPX64 - " remote cqid %u SMSG %p->%u hndl "LPX64"."LPX64"\n", + " local cqid %u SMSG %p->%u hndl %#llx.%#llx" + " remote cqid %u SMSG %p->%u hndl %#llx.%#llx\n", conn, libcfs_nid2str(connreq->gncr_srcnid), libcfs_nid2str(connreq->gncr_dstnid), &conn->gnpr_smsg_attr, @@ -953,7 +1006,7 @@ kgnilnd_create_peer_safe(kgn_peer_t **peerp, return -ENOMEM; } peer->gnp_nid = nid; - peer->gnp_down = node_state; + peer->gnp_state = node_state; /* translate from nid to nic addr & store */ rc = kgnilnd_nid_to_nicaddrs(LNET_NIDADDR(nid), 1, &peer->gnp_host_id); @@ -1173,7 +1226,7 @@ kgnilnd_release_purgatory_list(struct list_head *conn_list) list_for_each_entry_safe(gmp, gmpN, &conn->gnc_mdd_list, gmp_list) { CDEBUG(D_NET, - "dev %p releasing held mdd "LPX64"."LPX64"\n", + "dev %p releasing held mdd %#llx.%#llx\n", conn->gnc_device, gmp->gmp_map_key.qword1, gmp->gmp_map_key.qword2); @@ -1673,9 +1726,8 @@ kgnilnd_report_node_state(lnet_nid_t nid, int down) write_unlock(&kgnilnd_data.kgn_peer_conn_lock); /* Don't add a peer for node up events */ - if (down == GNILND_RCA_NODE_UP) { + if (down == GNILND_PEER_UP) return 0; - } /* find any valid net - we don't care which one... */ down_read(&kgnilnd_data.kgn_net_rw_sem); @@ -1719,9 +1771,9 @@ kgnilnd_report_node_state(lnet_nid_t nid, int down) } } - peer->gnp_down = down; + peer->gnp_state = down; - if (down == GNILND_RCA_NODE_DOWN) { + if (down == GNILND_PEER_DOWN) { kgn_conn_t *conn; peer->gnp_down_event_time = jiffies; @@ -1737,20 +1789,21 @@ kgnilnd_report_node_state(lnet_nid_t nid, int down) write_unlock(&kgnilnd_data.kgn_peer_conn_lock); - if (down == GNILND_RCA_NODE_DOWN) { + if (down == GNILND_PEER_DOWN) { /* using ENETRESET so we don't get messages from * kgnilnd_tx_done */ kgnilnd_txlist_done(&zombies, -ENETRESET); kgnilnd_peer_notify(peer, -ECONNRESET, 0); - LCONSOLE_INFO("Recieved down event for nid %lld\n", nid); + LCONSOLE_INFO("Received down event for nid %d\n", + LNET_NIDADDR(nid)); } return 0; } int -kgnilnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg) +kgnilnd_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg) { struct libcfs_ioctl_data *data = arg; kgn_net_t *net = ni->ni_data; @@ -1870,13 +1923,13 @@ kgnilnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg) } void -kgnilnd_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) +kgnilnd_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) { kgn_net_t *net = ni->ni_data; kgn_tx_t *tx; kgn_peer_t *peer = NULL; kgn_conn_t *conn = NULL; - lnet_process_id_t id = { + struct lnet_process_id id = { .nid = nid, .pid = LNET_PID_LUSTRE, }; @@ -1889,7 +1942,7 @@ kgnilnd_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) /* LIE if in a quiesce - we will update the timeouts after, * but we don't want sends failing during it */ if (kgnilnd_data.kgn_quiesce_trigger) { - *when = jiffies; + *when = ktime_get_seconds(); read_unlock(&kgnilnd_data.kgn_peer_conn_lock); GOTO(out, 0); } @@ -1905,7 +1958,7 @@ kgnilnd_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) * - if it was, we lie to LNet because we believe a TX would complete * on reconnect */ if (kgnilnd_conn_clean_errno(peer->gnp_last_errno)) { - *when = jiffies; + *when = ktime_get_seconds(); } /* we still want to fire a TX and new conn in this case */ } else { @@ -1935,7 +1988,7 @@ kgnilnd_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) kgnilnd_launch_tx(tx, net, &id); } out: - CDEBUG(D_NETTRACE, "peer 0x%p->%s when %lu\n", peer, + CDEBUG(D_NETTRACE, "peer 0x%p->%s when %lld\n", peer, libcfs_nid2str(nid), *when); EXIT; } @@ -1955,7 +2008,7 @@ kgnilnd_dev_init(kgn_device_t *dev) cq_size = *kgnilnd_tunables.kgn_credits * 2 * 3; rrc = kgnilnd_cdm_create(dev->gnd_id, *kgnilnd_tunables.kgn_ptag, - GNILND_COOKIE, 0, + *kgnilnd_tunables.kgn_pkey, 0, &dev->gnd_domain); if (rrc != GNI_RC_SUCCESS) { CERROR("Can't create CDM %d (%d)\n", dev->gnd_id, rrc); @@ -2000,12 +2053,6 @@ kgnilnd_dev_init(kgn_device_t *dev) } } - rrc = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_IP, &kgnilnd_data.kgn_sock); - if (rrc < 0) { - CERROR("sock_create returned %d\n", rrc); - GOTO(failed, rrc); - } - rc = kgnilnd_nicaddr_to_nid(dev->gnd_host_id, &dev->gnd_nid); if (rc < 0) { /* log messages during startup */ @@ -2047,6 +2094,11 @@ kgnilnd_dev_init(kgn_device_t *dev) GOTO(failed, rc = -EINVAL); } + rrc = kgnilnd_register_smdd_buf(dev); + if (rrc != GNI_RC_SUCCESS) { + GOTO(failed, rc = -EINVAL); + } + RETURN(0); failed: @@ -2063,9 +2115,12 @@ kgnilnd_dev_fini(kgn_device_t *dev) /* At quiesce or rest time, need to loop through and clear gnd_ready_conns ?*/ LASSERTF(list_empty(&dev->gnd_ready_conns) && list_empty(&dev->gnd_map_tx) && - list_empty(&dev->gnd_rdmaq), - "dev 0x%p ready_conns %d@0x%p map_tx %d@0x%p rdmaq %d@0x%p\n", + list_empty(&dev->gnd_rdmaq) && + list_empty(&dev->gnd_delay_conns), + "dev 0x%p ready_conns %d@0x%p delay_conns %d@0x%p" + "map_tx %d@0x%p rdmaq %d@0x%p\n", dev, kgnilnd_count_list(&dev->gnd_ready_conns), &dev->gnd_ready_conns, + kgnilnd_count_list(&dev->gnd_delay_conns), &dev->gnd_delay_conns, kgnilnd_count_list(&dev->gnd_map_tx), &dev->gnd_map_tx, kgnilnd_count_list(&dev->gnd_rdmaq), &dev->gnd_rdmaq); @@ -2075,7 +2130,7 @@ kgnilnd_dev_fini(kgn_device_t *dev) dev->gnd_map_nphys, dev->gnd_map_physnop); LASSERTF(dev->gnd_map_nvirt == 0 && dev->gnd_map_virtnob == 0, - "%d virtual mappings of "LPU64" bytes still mapped\n", + "%d virtual mappings of %llu bytes still mapped\n", dev->gnd_map_nvirt, dev->gnd_map_virtnob); LASSERTF(atomic_read(&dev->gnd_n_mdd) == 0 && @@ -2097,6 +2152,13 @@ kgnilnd_dev_fini(kgn_device_t *dev) atomic_read(&kgnilnd_data.kgn_nthreads) == 0, "tried to shutdown with threads active\n"); + if (dev->gnd_smdd_hold_buf) { + rrc = kgnilnd_deregister_smdd_buf(dev); + LASSERTF(rrc == GNI_RC_SUCCESS, + "bad rc from deregistion of sMDD buffer: %d\n", rrc); + dev->gnd_smdd_hold_buf = NULL; + } + if (dev->gnd_rcv_fma_cqh) { rrc = kgnilnd_cq_destroy(dev->gnd_rcv_fma_cqh); LASSERTF(rrc == GNI_RC_SUCCESS, @@ -2132,9 +2194,6 @@ kgnilnd_dev_fini(kgn_device_t *dev) dev->gnd_domain = NULL; } - if (kgnilnd_data.kgn_sock) - sock_release(kgnilnd_data.kgn_sock); - EXIT; } @@ -2182,6 +2241,7 @@ int kgnilnd_base_startup(void) dev->gnd_id = i; INIT_LIST_HEAD(&dev->gnd_ready_conns); + INIT_LIST_HEAD(&dev->gnd_delay_conns); INIT_LIST_HEAD(&dev->gnd_map_tx); INIT_LIST_HEAD(&dev->gnd_fma_buffs); mutex_init(&dev->gnd_cq_mutex); @@ -2279,7 +2339,7 @@ int kgnilnd_base_startup(void) } kgnilnd_data.kgn_mbox_cache = - kmem_cache_create("kgn_mbox_block", KMALLOC_MAX_SIZE, 0, + kmem_cache_create("kgn_mbox_block", GNILND_MBOX_SIZE, 0, SLAB_HWCACHE_ALIGN, NULL); if (kgnilnd_data.kgn_mbox_cache == NULL) { CERROR("Can't create slab for physical mbox blocks\n"); @@ -2384,13 +2444,20 @@ int kgnilnd_base_startup(void) } /* threads will load balance across devs as they are available */ - for (i = 0; i < *kgnilnd_tunables.kgn_sched_threads; i++) { - rc = kgnilnd_thread_start(kgnilnd_scheduler, (void *)((long)i), - "kgnilnd_sd", i); - if (rc != 0) { - CERROR("Can't spawn gnilnd scheduler[%d]: %d\n", - i, rc); + if (*kgnilnd_tunables.kgn_thread_affinity) { + rc = kgnilnd_start_sd_threads(); + if (rc != 0) GOTO(failed, rc); + } else { + for (i = 0; i < *kgnilnd_tunables.kgn_sched_threads; i++) { + rc = kgnilnd_thread_start(kgnilnd_scheduler, + (void *)((long)i), + "kgnilnd_sd", i); + if (rc != 0) { + CERROR("Can't spawn gnilnd scheduler[%d]: %d\n", + i, rc); + GOTO(failed, rc); + } } } @@ -2421,8 +2488,6 @@ int kgnilnd_base_startup(void) } } - - /* flag everything initialised */ kgnilnd_data.kgn_init = GNILND_INIT_ALL; /*****************************************************/ @@ -2615,15 +2680,15 @@ kgnilnd_base_shutdown(void) } int -kgnilnd_startup(lnet_ni_t *ni) +kgnilnd_startup(struct lnet_ni *ni) { int rc, devno; kgn_net_t *net; ENTRY; - LASSERTF(ni->ni_lnd == &the_kgnilnd, + LASSERTF(ni->ni_net->net_lnd == &the_kgnilnd, "bad LND 0x%p != the_kgnilnd @ 0x%p\n", - ni->ni_lnd, &the_kgnilnd); + ni->ni_net->net_lnd, &the_kgnilnd); if (kgnilnd_data.kgn_init == GNILND_INIT_NOTHING) { rc = kgnilnd_base_startup(); @@ -2643,8 +2708,12 @@ kgnilnd_startup(lnet_ni_t *ni) INIT_LIST_HEAD(&net->gnn_list); ni->ni_data = net; net->gnn_ni = ni; - ni->ni_maxtxcredits = *kgnilnd_tunables.kgn_credits; - ni->ni_peertxcredits = *kgnilnd_tunables.kgn_peer_credits; + if (!ni->ni_net->net_tunables_set) { + ni->ni_net->net_tunables.lct_max_tx_credits = + *kgnilnd_tunables.kgn_credits; + ni->ni_net->net_tunables.lct_peer_tx_credits = + *kgnilnd_tunables.kgn_peer_credits; + } if (*kgnilnd_tunables.kgn_peer_health) { int fudge; @@ -2654,9 +2723,10 @@ kgnilnd_startup(lnet_ni_t *ni) fudge = (GNILND_TO2KA(*kgnilnd_tunables.kgn_timeout) / GNILND_REAPER_NCHECKS); timeout = *kgnilnd_tunables.kgn_timeout + fudge; - if (*kgnilnd_tunables.kgn_peer_timeout >= timeout) - ni->ni_peertimeout = *kgnilnd_tunables.kgn_peer_timeout; - else if (*kgnilnd_tunables.kgn_peer_timeout > -1) { + if (*kgnilnd_tunables.kgn_peer_timeout >= timeout) { + ni->ni_net->net_tunables.lct_peer_timeout = + *kgnilnd_tunables.kgn_peer_timeout; + } else if (*kgnilnd_tunables.kgn_peer_timeout > -1) { LCONSOLE_ERROR("Peer_timeout is set to %d but needs to be >= %d\n", *kgnilnd_tunables.kgn_peer_timeout, timeout); @@ -2664,10 +2734,10 @@ kgnilnd_startup(lnet_ni_t *ni) LIBCFS_FREE(net, sizeof(*net)); GOTO(failed, rc = -EINVAL); } else - ni->ni_peertimeout = timeout; + ni->ni_net->net_tunables.lct_peer_timeout = timeout; LCONSOLE_INFO("Enabling LNet peer health for gnilnd, timeout %ds\n", - ni->ni_peertimeout); + ni->ni_net->net_tunables.lct_peer_timeout); } atomic_set(&net->gnn_refcount, 1); @@ -2708,7 +2778,7 @@ kgnilnd_startup(lnet_ni_t *ni) } void -kgnilnd_shutdown(lnet_ni_t *ni) +kgnilnd_shutdown(struct lnet_ni *ni) { kgn_net_t *net = ni->ni_data; int i; @@ -2809,17 +2879,14 @@ out: EXIT; } -void __exit -kgnilnd_module_fini(void) +static void __exit kgnilnd_exit(void) { lnet_unregister_lnd(&the_kgnilnd); kgnilnd_proc_fini(); kgnilnd_remove_sysctl(); - kgnilnd_tunables_fini(); } -int __init -kgnilnd_module_init(void) +static int __init kgnilnd_init(void) { int rc; @@ -2827,7 +2894,7 @@ kgnilnd_module_init(void) if (rc != 0) return rc; - printk(KERN_INFO "Lustre: kgnilnd build version: "KGNILND_BUILD_REV"\n"); + LCONSOLE_INFO("Lustre: kgnilnd build version: "LUSTRE_VERSION_STRING"\n"); kgnilnd_insert_sysctl(); kgnilnd_proc_init(); @@ -2838,8 +2905,9 @@ kgnilnd_module_init(void) } MODULE_AUTHOR("Cray, Inc. "); -MODULE_DESCRIPTION("Kernel Gemini LND v"KGNILND_BUILD_REV); +MODULE_DESCRIPTION("Gemini LNet Network Driver"); +MODULE_VERSION(LUSTRE_VERSION_STRING); MODULE_LICENSE("GPL"); -module_init(kgnilnd_module_init); -module_exit(kgnilnd_module_fini); +module_init(kgnilnd_init); +module_exit(kgnilnd_exit);