X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Fklnds%2Fgnilnd%2Fgnilnd.c;h=1fa2bbc22bf6f7f1293eff36706856b995db6cbe;hb=9766f8e746731c74096c86fcc9514c3e3219e674;hp=0ed87780bb98cfd70a8254d8f703b8655f623750;hpb=2b294992edce5af7b79d4300ed3aa1ea6a8db850;p=fs%2Flustre-release.git diff --git a/lnet/klnds/gnilnd/gnilnd.c b/lnet/klnds/gnilnd/gnilnd.c index 0ed8778..1fa2bbc 100644 --- a/lnet/klnds/gnilnd/gnilnd.c +++ b/lnet/klnds/gnilnd/gnilnd.c @@ -42,6 +42,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) @@ -202,12 +248,15 @@ 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); } + mutex_init(&conn->gnc_smsg_mutex); + mutex_init(&conn->gnc_rdma_mutex); atomic_set(&conn->gnc_refcount, 1); atomic_set(&conn->gnc_reaper_noop, 0); atomic_set(&conn->gnc_sched_noop, 0); @@ -460,7 +509,7 @@ kgnilnd_peer_alive(kgn_peer_t *peer) } void -kgnilnd_peer_notify(kgn_peer_t *peer, int error) +kgnilnd_peer_notify(kgn_peer_t *peer, int error, int alive) { int tell_lnet = 0; int nnets = 0; @@ -489,10 +538,10 @@ kgnilnd_peer_notify(kgn_peer_t *peer, int error) peer, libcfs_nid2str(peer->gnp_nid), peer->gnp_connecting, conn, kgnilnd_data.kgn_in_reset, error); - if ((peer->gnp_connecting == GNILND_PEER_IDLE) && + if (((peer->gnp_connecting == GNILND_PEER_IDLE) && (conn == NULL) && (!kgnilnd_data.kgn_in_reset) && - (!kgnilnd_conn_clean_errno(error))) { + (!kgnilnd_conn_clean_errno(error))) || alive) { tell_lnet = 1; } @@ -556,8 +605,8 @@ kgnilnd_peer_notify(kgn_peer_t *peer, int error) peer, libcfs_nid2str(peer_nid), peer->gnp_last_alive, cfs_duration_sec(jiffies - peer->gnp_last_alive)); - lnet_notify(net->gnn_ni, peer_nid, 0, peer->gnp_last_alive); - + lnet_notify(net->gnn_ni, peer_nid, alive, + peer->gnp_last_alive); kgnilnd_net_decref(net); } @@ -622,6 +671,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 */ @@ -806,8 +859,8 @@ kgnilnd_complete_closed_conn(kgn_conn_t *conn) /* I'm telling Mommy! - use peer_error if they initiated close */ kgnilnd_peer_notify(conn->gnc_peer, - conn->gnc_error == -ECONNRESET ? conn->gnc_peer_error - : conn->gnc_error); + conn->gnc_error == -ECONNRESET ? + conn->gnc_peer_error : conn->gnc_error, 0); EXIT; } @@ -1166,7 +1219,7 @@ kgnilnd_release_purgatory_list(struct list_head *conn_list) * make sure we tell LNet - if this is from other context, * the checks in the function will prevent an errant * notification */ - kgnilnd_peer_notify(conn->gnc_peer, conn->gnc_error); + kgnilnd_peer_notify(conn->gnc_peer, conn->gnc_error, 0); list_for_each_entry_safe(gmp, gmpN, &conn->gnc_mdd_list, gmp_list) { @@ -1544,7 +1597,8 @@ kgnilnd_del_conn_or_peer(kgn_net_t *net, lnet_nid_t nid, int command, atomic_read(&kgnilnd_data.kgn_npending_detach) || atomic_read(&kgnilnd_data.kgn_npending_unlink)) { - cfs_pause(cfs_time_seconds(1)); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); i++; CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, "Waiting on %d peers %d closes %d detaches\n", @@ -1614,8 +1668,8 @@ kgnilnd_get_conn_info(kgn_peer_t *peer, *device_id = conn->gnc_device->gnd_host_id; *peerstamp = conn->gnc_peerstamp; - *tx_seq = conn->gnc_tx_seq; - *rx_seq = conn->gnc_rx_seq; + *tx_seq = atomic_read(&conn->gnc_tx_seq); + *rx_seq = atomic_read(&conn->gnc_rx_seq); *fmaq_len = kgnilnd_count_list(&conn->gnc_fmaq); *nfma = atomic_read(&conn->gnc_nlive_fma); *nrdma = atomic_read(&conn->gnc_nlive_rdma); @@ -1739,13 +1793,11 @@ kgnilnd_report_node_state(lnet_nid_t nid, int down) * kgnilnd_tx_done */ kgnilnd_txlist_done(&zombies, -ENETRESET); - - if (*kgnilnd_tunables.kgn_peer_health) { - kgnilnd_peer_notify(peer, -ECONNRESET); - } + kgnilnd_peer_notify(peer, -ECONNRESET, 0); + LCONSOLE_INFO("Received down event for nid %d\n", + LNET_NIDADDR(nid)); } - CDEBUG(D_INFO, "marking nid %lld %s\n", nid, down ? "down" : "up"); return 0; } @@ -1955,7 +2007,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); @@ -2017,7 +2069,7 @@ kgnilnd_dev_init(kgn_device_t *dev) } CDEBUG(D_NET, "NIC %x -> NID %d\n", dev->gnd_host_id, dev->gnd_nid); - rrc = kgnilnd_cq_create(dev->gnd_handle, cq_size, + rrc = kgnilnd_cq_create(dev->gnd_handle, *kgnilnd_tunables.kgn_credits, 0, kgnilnd_device_callback, dev->gnd_id, &dev->gnd_snd_rdma_cqh); if (rrc != GNI_RC_SUCCESS) { @@ -2047,6 +2099,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: @@ -2097,6 +2154,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,12 +2196,12 @@ kgnilnd_dev_fini(kgn_device_t *dev) dev->gnd_domain = NULL; } - sock_release(kgnilnd_data.kgn_sock); + if (kgnilnd_data.kgn_sock) + sock_release(kgnilnd_data.kgn_sock); EXIT; } - int kgnilnd_base_startup(void) { struct timeval tv; @@ -2146,6 +2210,15 @@ int kgnilnd_base_startup(void) int i; kgn_device_t *dev; struct task_struct *thrd; + +#if defined(CONFIG_CRAY_XT) && !defined(CONFIG_CRAY_COMPUTE) + /* limit how much memory can be allocated for fma blocks in + * instances where many nodes need to reconnects at the same time */ + struct sysinfo si; + si_meminfo(&si); + kgnilnd_data.free_pages_limit = si.totalram/4; +#endif + ENTRY; LASSERTF(kgnilnd_data.kgn_init == GNILND_INIT_NOTHING, @@ -2153,6 +2226,7 @@ int kgnilnd_base_startup(void) /* zero pointers, flags etc */ memset(&kgnilnd_data, 0, sizeof(kgnilnd_data)); + kgnilnd_check_kgni_version(); /* CAVEAT EMPTOR: Every 'Fma' message includes the sender's NID and * a unique (for all time) connstamp so we can uniquely identify @@ -2374,13 +2448,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); + } } } @@ -2411,8 +2492,6 @@ int kgnilnd_base_startup(void) } } - - /* flag everything initialised */ kgnilnd_data.kgn_init = GNILND_INIT_ALL; /*****************************************************/ @@ -2460,7 +2539,8 @@ kgnilnd_base_shutdown(void) CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, "Waiting for conns to be cleaned up %d\n",atomic_read(&kgnilnd_data.kgn_nconns)); - cfs_pause(cfs_time_seconds(1)); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); } /* Peer state all cleaned up BEFORE setting shutdown, so threads don't * have to worry about shutdown races. NB connections may be created @@ -2479,7 +2559,8 @@ kgnilnd_base_shutdown(void) i++; CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, "Waiting for ruhroh thread to terminate\n"); - cfs_pause(cfs_time_seconds(1)); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); } /* Flag threads to terminate */ @@ -2501,7 +2582,8 @@ kgnilnd_base_shutdown(void) wake_up_all(&kgnilnd_data.kgn_reaper_waitq); spin_unlock(&kgnilnd_data.kgn_reaper_lock); - kgnilnd_wakeup_rca_thread(); + if (atomic_read(&kgnilnd_data.kgn_nthreads)) + kgnilnd_wakeup_rca_thread(); /* Wait for threads to exit */ i = 2; @@ -2510,7 +2592,8 @@ kgnilnd_base_shutdown(void) CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, /* power of 2? */ "Waiting for %d threads to terminate\n", atomic_read(&kgnilnd_data.kgn_nthreads)); - cfs_pause(cfs_time_seconds(1)); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); } LASSERTF(atomic_read(&kgnilnd_data.kgn_npeers) == 0, @@ -2756,7 +2839,8 @@ kgnilnd_shutdown(lnet_ni_t *ni) "Waiting for %d references to clear on net %d\n", atomic_read(&net->gnn_refcount), net->gnn_netnum); - cfs_pause(cfs_time_seconds(1)); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1)); } /* release ref from kgnilnd_startup */ @@ -2794,17 +2878,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; @@ -2823,8 +2904,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(KGNILND_BUILD_REV); MODULE_LICENSE("GPL"); -module_init(kgnilnd_module_init); -module_exit(kgnilnd_module_fini); +module_init(kgnilnd_init); +module_exit(kgnilnd_exit);