/*
* Copyright (C) 2012 Cray, Inc.
*
- * Copyright (c) 2013, 2014, Intel Corporation.
+ * Copyright (c) 2013, 2015, Intel Corporation.
*
* Author: Nic Henke <nic@cray.com>
* Author: James Shimek <jshimek@cray.com>
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,
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);
}
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,
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);
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;
}
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));
/* 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 {
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 */
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);
/* 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,
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);
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);
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);
}
}
- 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;
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;
GOTO(failed, rc = -EINVAL);
}
+ rrc = kgnilnd_register_smdd_buf(dev);
+ if (rrc != GNI_RC_SUCCESS) {
+ GOTO(failed, rc = -EINVAL);
+ }
+
RETURN(0);
failed:
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 &&
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,
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();
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;
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);
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);
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;
}
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);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff