LU-6245 libcfs: remove sysctl module handling

[fs/lustre-release.git] / lnet / klnds / gnilnd / gnilnd.c

diff --git a/lnet/klnds/gnilnd/gnilnd.c b/lnet/klnds/gnilnd/gnilnd.c
index 8970f4b..1fa2bbc 100644 (file)
--- 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);
@@ -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 */
@@ -1615,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);
@@ -1741,7 +1794,8 @@ kgnilnd_report_node_state(lnet_nid_t nid, int down)
                 */
                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;
@@ -1953,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);
@@ -2045,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:
@@ -2095,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,
@@ -2136,7 +2202,6 @@ kgnilnd_dev_fini(kgn_device_t *dev)
        EXIT;
 }
 
-
 int kgnilnd_base_startup(void)
 {
        struct timeval       tv;
@@ -2161,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
@@ -2382,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);
+                       }
                }
        }
 
@@ -2419,8 +2492,6 @@ int kgnilnd_base_startup(void)
                }
        }
 
-
-
        /* flag everything initialised */
        kgnilnd_data.kgn_init = GNILND_INIT_ALL;
        /*****************************************************/
@@ -2807,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;
 
@@ -2836,8 +2904,9 @@ kgnilnd_module_init(void)
 }
 
 MODULE_AUTHOR("Cray, Inc. <nic@cray.com>");
-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);