/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2004 Cluster File Systems, Inc.
- * Author: Eric Barton <eric@bartonsoftware.com>
- * Author: Frank Zago <fzago@systemfabricworks.com>
+ * GPL HEADER START
*
- * This file is part of Lustre, http://www.lustre.org.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
- * Lustre is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
*
- * Lustre is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
*
- * You should have received a copy of the GNU General Public License
- * along with Lustre; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see
+ * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
*
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * GPL HEADER END
+ */
+/*
+ * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Use is subject to license terms.
+ */
+/*
+ * This file is part of Lustre, http://www.lustre.org/
+ * Lustre is a trademark of Sun Microsystems, Inc.
+ *
+ * lnet/klnds/viblnd/viblnd.c
+ *
+ * Author: Eric Barton <eric@bartonsoftware.com>
+ * Author: Frank Zago <fzago@systemfabricworks.com>
*/
#include "viblnd.h"
}
void
-kibnal_pack_msg(kib_msg_t *msg, __u32 version, int credits,
+kibnal_pack_msg(kib_msg_t *msg, __u32 version, int credits,
lnet_nid_t dstnid, __u64 dststamp, __u64 seq)
{
/* CAVEAT EMPTOR! all message fields not set here should have been
msg->ibm_credits = credits;
/* ibm_nob */
msg->ibm_cksum = 0;
- msg->ibm_srcnid = lnet_ptlcompat_srcnid(kibnal_data.kib_ni->ni_nid,
- dstnid);
+ msg->ibm_srcnid = kibnal_data.kib_ni->ni_nid;
msg->ibm_srcstamp = kibnal_data.kib_incarnation;
msg->ibm_dstnid = dstnid;
msg->ibm_dststamp = dststamp;
msg_version != IBNAL_MSG_VERSION)
return -EPROTO;
} else if (msg_version != expected_version) {
- CERROR("Bad version: %x(%x expected)\n",
+ CERROR("Bad version: %x(%x expected)\n",
msg_version, expected_version);
return -EPROTO;
}
return -EPROTO;
}
msg->ibm_cksum = msg_cksum;
-
+
if (flip) {
/* leave magic unflipped as a clue to peer endianness */
msg->ibm_version = msg_version;
__swab64s(&msg->ibm_dststamp);
__swab64s(&msg->ibm_seq);
}
-
+
if (msg->ibm_srcnid == LNET_NID_ANY) {
CERROR("Bad src nid: %s\n", libcfs_nid2str(msg->ibm_srcnid));
return -EPROTO;
default:
CERROR("Unknown message type %x\n", msg->ibm_type);
return -EPROTO;
-
+
case IBNAL_MSG_NOOP:
break;
__swab32s(&msg->ibm_u.putack.ibpam_rd.rd_key);
__swab32s(&msg->ibm_u.putack.ibpam_rd.rd_nfrag);
}
-
+
n = msg->ibm_u.putack.ibpam_rd.rd_nfrag;
if (n <= 0 || n > IBNAL_MAX_RDMA_FRAGS) {
- CERROR("Bad PUT_ACK nfrags: %d, should be 0 < n <= %d\n",
+ CERROR("Bad PUT_ACK nfrags: %d, should be 0 < n <= %d\n",
n, IBNAL_MAX_RDMA_FRAGS);
return -EPROTO;
}
-
+
if (msg_nob < offsetof(kib_msg_t, ibm_u.putack.ibpam_rd.rd_frags[n])) {
CERROR("Short PUT_ACK: %d(%d)\n", msg_nob,
(int)offsetof(kib_msg_t, ibm_u.putack.ibpam_rd.rd_frags[n]));
__swab32s(&msg->ibm_u.get.ibgm_rd.rd_nob);
__swab32s(&msg->ibm_u.get.ibgm_rd.rd_key);
}
-#else
+#else
if (flip) {
__swab32s(&msg->ibm_u.get.ibgm_rd.rd_key);
__swab32s(&msg->ibm_u.get.ibgm_rd.rd_nfrag);
n = msg->ibm_u.get.ibgm_rd.rd_nfrag;
if (n <= 0 || n > IBNAL_MAX_RDMA_FRAGS) {
- CERROR("Bad GET_REQ nfrags: %d, should be 0 < n <= %d\n",
+ CERROR("Bad GET_REQ nfrags: %d, should be 0 < n <= %d\n",
n, IBNAL_MAX_RDMA_FRAGS);
return -EPROTO;
}
-
+
if (msg_nob < offsetof(kib_msg_t, ibm_u.get.ibgm_rd.rd_frags[n])) {
CERROR("Short GET_REQ: %d(%d)\n", msg_nob,
(int)offsetof(kib_msg_t, ibm_u.get.ibgm_rd.rd_frags[n]));
return -EPROTO;
}
-
+
if (flip)
for (i = 0; i < msg->ibm_u.get.ibgm_rd.rd_nfrag; i++) {
__swab32s(&msg->ibm_u.get.ibgm_rd.rd_frags[i].rf_nob);
LASSERT (kibnal_data.kib_listen_handle == NULL);
- kibnal_data.kib_listen_handle =
+ kibnal_data.kib_listen_handle =
cm_create_cep(cm_cep_transp_rc);
if (kibnal_data.kib_listen_handle == NULL) {
CERROR ("Can't create listen CEP\n");
return -ENOMEM;
}
- CDEBUG(D_NET, "Created CEP %p for listening\n",
+ CDEBUG(D_NET, "Created CEP %p for listening\n",
kibnal_data.kib_listen_handle);
memset(&info, 0, sizeof(info));
- info.listen_addr.end_pt.sid =
+ info.listen_addr.end_pt.sid =
(__u64)(*kibnal_tunables.kib_service_number);
cmrc = cm_listen(kibnal_data.kib_listen_handle, &info,
kibnal_listen_callback, NULL);
if (cmrc == cm_stat_success)
return 0;
-
+
CERROR ("cm_listen error: %d\n", cmrc);
cmrc = cm_destroy_cep(kibnal_data.kib_listen_handle);
cm_return_t cmrc;
LASSERT (kibnal_data.kib_listen_handle != NULL);
-
+
cmrc = cm_cancel(kibnal_data.kib_listen_handle);
if (cmrc != cm_stat_success)
CERROR ("Error %d stopping listener\n", cmrc);
cfs_pause(cfs_time_seconds(1)/10); /* ensure no more callbacks */
-
+
cmrc = cm_destroy_cep(kibnal_data.kib_listen_handle);
if (cmrc != vv_return_ok)
CERROR ("Error %d destroying CEP\n", cmrc);
/* npeers only grows with the global lock held */
atomic_inc(&kibnal_data.kib_npeers);
}
-
+
write_unlock_irqrestore(&kibnal_data.kib_global_lock, flags);
if (rc != 0) {
CERROR("Can't create peer: %s\n",
- (rc == -ESHUTDOWN) ? "shutting down" :
+ (rc == -ESHUTDOWN) ? "shutting down" :
"too many peers");
LIBCFS_FREE(peer, sizeof(*peer));
} else {
*peerp = peer;
}
-
+
return rc;
}
LASSERT (peer->ibp_accepting == 0);
LASSERT (list_empty (&peer->ibp_conns));
LASSERT (list_empty (&peer->ibp_tx_queue));
-
+
LIBCFS_FREE (peer, sizeof (*peer));
/* NB a peer's connections keep a reference on their peer until
CDEBUG(D_NET, "%s at %u.%u.%u.%u\n",
libcfs_nid2str(nid), HIPQUAD(ip));
-
+
if (nid == LNET_NID_ANY)
return (-EINVAL);
write_lock_irqsave(&kibnal_data.kib_global_lock, flags);
+ /* I'm always called with a reference on kibnal_data.kib_ni
+ * so shutdown can't have started */
+ LASSERT (kibnal_data.kib_listen_handle != NULL);
+
peer2 = kibnal_find_peer_locked (nid);
if (peer2 != NULL) {
kibnal_peer_decref (peer);
peer->ibp_ip = ip;
peer->ibp_persistence++;
-
+
write_unlock_irqrestore(&kibnal_data.kib_global_lock, flags);
return (0);
}
{
struct list_head *tmp;
int i;
-
+
spin_lock(&conn->ibc_lock);
-
- CDEBUG(D_CONSOLE, "conn[%d] %p -> %s: \n",
- atomic_read(&conn->ibc_refcount), conn,
+
+ CDEBUG(D_CONSOLE, "conn[%d] %p -> %s: \n",
+ atomic_read(&conn->ibc_refcount), conn,
libcfs_nid2str(conn->ibc_peer->ibp_nid));
CDEBUG(D_CONSOLE, " txseq "LPD64" rxseq "LPD64" state %d \n",
conn->ibc_txseq, conn->ibc_rxseq, conn->ibc_state);
CDEBUG(D_CONSOLE, " nposted %d cred %d o_cred %d r_cred %d\n",
- conn->ibc_nsends_posted, conn->ibc_credits,
+ conn->ibc_nsends_posted, conn->ibc_credits,
conn->ibc_outstanding_credits, conn->ibc_reserved_credits);
CDEBUG(D_CONSOLE, " disc %d comms_err %d\n",
conn->ibc_disconnect, conn->ibc_comms_error);
CDEBUG(D_CONSOLE, " early_rxs:\n");
list_for_each(tmp, &conn->ibc_early_rxs)
kibnal_debug_rx(list_entry(tmp, kib_rx_t, rx_list));
-
+
CDEBUG(D_CONSOLE, " tx_queue_nocred:\n");
list_for_each(tmp, &conn->ibc_tx_queue_nocred)
kibnal_debug_tx(list_entry(tmp, kib_tx_t, tx_list));
CDEBUG(D_CONSOLE, " tx_queue:\n");
list_for_each(tmp, &conn->ibc_tx_queue)
kibnal_debug_tx(list_entry(tmp, kib_tx_t, tx_list));
-
+
CDEBUG(D_CONSOLE, " active_txs:\n");
list_for_each(tmp, &conn->ibc_active_txs)
kibnal_debug_tx(list_entry(tmp, kib_tx_t, tx_list));
-
+
CDEBUG(D_CONSOLE, " rxs:\n");
for (i = 0; i < IBNAL_RX_MSGS; i++)
kibnal_debug_rx(&conn->ibc_rxs[i]);
kibnal_set_qp_state (kib_conn_t *conn, vv_qp_state_t new_state)
{
static vv_qp_attr_t attr;
-
+
kib_connvars_t *cv = conn->ibc_connvars;
vv_return_t vvrc;
-
+
/* Only called by connd => static OK */
LASSERT (!in_interrupt());
LASSERT (current == kibnal_data.kib_connd);
memset(&attr, 0, sizeof(attr));
-
+
switch (new_state) {
default:
LBUG();
-
+
case vv_qp_state_init: {
struct vv_qp_modify_init_st *init = &attr.modify.params.init;
init->access_control = vv_acc_r_mem_read |
vv_acc_r_mem_write; /* XXX vv_acc_l_mem_write ? */
- attr.modify.vv_qp_attr_mask = VV_QP_AT_P_KEY_IX |
+ attr.modify.vv_qp_attr_mask = VV_QP_AT_P_KEY_IX |
VV_QP_AT_PHY_PORT_NUM |
VV_QP_AT_ACCESS_CON_F;
break;
// XXX sdp sets VV_QP_AT_OP_F but no actual optional options
- attr.modify.vv_qp_attr_mask = VV_QP_AT_ADD_VEC |
+ attr.modify.vv_qp_attr_mask = VV_QP_AT_ADD_VEC |
VV_QP_AT_DEST_QP |
- VV_QP_AT_R_PSN |
+ VV_QP_AT_R_PSN |
VV_QP_AT_MIN_RNR_NAK_T |
VV_QP_AT_RESP_RDMA_ATOM_OUT_NUM |
VV_QP_AT_OP_F;
rts->retry_num = *kibnal_tunables.kib_retry_cnt;
rts->rnr_num = *kibnal_tunables.kib_rnr_cnt;
rts->dest_out_rdma_r_atom_num = IBNAL_OUS_DST_RD;
-
+
attr.modify.vv_qp_attr_mask = VV_QP_AT_S_PSN |
VV_QP_AT_L_ACK_T |
VV_QP_AT_RETRY_NUM |
attr.modify.vv_qp_attr_mask = 0;
break;
}
-
+
attr.modify.qp_modify_into_state = new_state;
attr.modify.vv_qp_attr_mask |= VV_QP_AT_STATE;
-
+
vvrc = vv_qp_modify(kibnal_data.kib_hca, conn->ibc_qp, &attr, NULL);
if (vvrc != vv_return_ok) {
- CERROR("Can't modify qp -> %s state to %d: %d\n",
+ CERROR("Can't modify qp -> %s state to %d: %d\n",
libcfs_nid2str(conn->ibc_peer->ibp_nid),
new_state, vvrc);
return -EIO;
}
-
+
return 0;
}
/* Only the connd creates conns => single threaded */
LASSERT(!in_interrupt());
LASSERT(current == kibnal_data.kib_connd);
-
+
LIBCFS_ALLOC(conn, sizeof (*conn));
if (conn == NULL) {
CERROR ("Can't allocate connection\n");
INIT_LIST_HEAD (&conn->ibc_tx_queue_rsrvd);
INIT_LIST_HEAD (&conn->ibc_active_txs);
spin_lock_init (&conn->ibc_lock);
-
+
atomic_inc (&kibnal_data.kib_nconns);
/* well not really, but I call destroy() on failure, which decrements */
vv_r_key_t r_key;
rx->rx_conn = conn;
- rx->rx_msg = (kib_msg_t *)(((char *)page_address(page)) +
+ rx->rx_msg = (kib_msg_t *)(((char *)page_address(page)) +
page_offset);
vvrc = vv_get_gen_mr_attrib(kibnal_data.kib_hca,
reqattr.create.qp_type = vv_qp_type_r_conn;
reqattr.create.cq_send_h = kibnal_data.kib_cq;
reqattr.create.cq_receive_h = kibnal_data.kib_cq;
- reqattr.create.send_max_outstand_wr = (1 + IBNAL_MAX_RDMA_FRAGS) *
+ reqattr.create.send_max_outstand_wr = (1 + IBNAL_MAX_RDMA_FRAGS) *
(*kibnal_tunables.kib_concurrent_sends);
reqattr.create.receive_max_outstand_wr = IBNAL_RX_MSGS;
reqattr.create.max_scatgat_per_send_wr = 1;
conn->ibc_state = IBNAL_CONN_INIT_QP;
conn->ibc_connvars->cv_local_qpn = rspattr.create_return.qp_num;
- if (rspattr.create_return.receive_max_outstand_wr <
+ if (rspattr.create_return.receive_max_outstand_wr <
IBNAL_RX_MSGS ||
- rspattr.create_return.send_max_outstand_wr <
+ rspattr.create_return.send_max_outstand_wr <
(1 + IBNAL_MAX_RDMA_FRAGS) * (*kibnal_tunables.kib_concurrent_sends)) {
CERROR("Insufficient rx/tx work items: wanted %d/%d got %d/%d\n",
- IBNAL_RX_MSGS,
- (1 + IBNAL_MAX_RDMA_FRAGS) *
+ IBNAL_RX_MSGS,
+ (1 + IBNAL_MAX_RDMA_FRAGS) *
(*kibnal_tunables.kib_concurrent_sends),
rspattr.create_return.receive_max_outstand_wr,
rspattr.create_return.send_max_outstand_wr);
/* 1 ref for caller */
atomic_set (&conn->ibc_refcount, 1);
return (conn);
-
+
failed:
kibnal_destroy_conn (conn);
return (NULL);
/* Only the connd does this (i.e. single threaded) */
LASSERT (!in_interrupt());
LASSERT (current == kibnal_data.kib_connd);
-
+
CDEBUG (D_NET, "connection %p\n", conn);
LASSERT (atomic_read (&conn->ibc_refcount) == 0);
if (vvrc != vv_return_ok)
CERROR("Can't destroy QP: %d\n", vvrc);
/* fall through */
-
+
case IBNAL_CONN_INIT_NOTHING:
break;
}
- if (conn->ibc_rx_pages != NULL)
+ if (conn->ibc_rx_pages != NULL)
kibnal_free_pages(conn->ibc_rx_pages);
if (conn->ibc_rxs != NULL)
- LIBCFS_FREE(conn->ibc_rxs,
+ LIBCFS_FREE(conn->ibc_rxs,
IBNAL_RX_MSGS * sizeof(kib_rx_t));
if (conn->ibc_connvars != NULL)
CDEBUG(D_NET, "Closing stale conn -> %s incarnation:"LPX64"("LPX64")\n",
libcfs_nid2str(peer->ibp_nid),
conn->ibc_incarnation, incarnation);
-
+
count++;
kibnal_close_conn_locked (conn, -ESTALE);
}
/* wildcards always succeed */
if (nid == LNET_NID_ANY)
return (0);
-
+
return (count == 0 ? -ENOENT : 0);
}
{
int npages = p->ibp_npages;
int i;
-
+
for (i = 0; i < npages; i++)
if (p->ibp_pages[i] != NULL)
__free_page(p->ibp_pages[i]);
-
+
LIBCFS_FREE (p, offsetof(kib_pages_t, ibp_pages[npages]));
}
memset (p, 0, offsetof(kib_pages_t, ibp_pages[npages]));
p->ibp_npages = npages;
-
+
for (i = 0; i < npages; i++) {
p->ibp_pages[i] = alloc_page (GFP_KERNEL);
if (p->ibp_pages[i] == NULL) {
}
int
-kibnal_alloc_tx_descs (void)
+kibnal_alloc_tx_descs (void)
{
int i;
-
+
LIBCFS_ALLOC (kibnal_data.kib_tx_descs,
IBNAL_TX_MSGS() * sizeof(kib_tx_t));
if (kibnal_data.kib_tx_descs == NULL)
return -ENOMEM;
-
+
memset(kibnal_data.kib_tx_descs, 0,
IBNAL_TX_MSGS() * sizeof(kib_tx_t));
if (tx->tx_pages == NULL)
return -ENOMEM;
#else
- LIBCFS_ALLOC(tx->tx_wrq,
- (1 + IBNAL_MAX_RDMA_FRAGS) *
+ LIBCFS_ALLOC(tx->tx_wrq,
+ (1 + IBNAL_MAX_RDMA_FRAGS) *
sizeof(*tx->tx_wrq));
if (tx->tx_wrq == NULL)
return -ENOMEM;
-
- LIBCFS_ALLOC(tx->tx_gl,
- (1 + IBNAL_MAX_RDMA_FRAGS) *
+
+ LIBCFS_ALLOC(tx->tx_gl,
+ (1 + IBNAL_MAX_RDMA_FRAGS) *
sizeof(*tx->tx_gl));
if (tx->tx_gl == NULL)
return -ENOMEM;
-
- LIBCFS_ALLOC(tx->tx_rd,
- offsetof(kib_rdma_desc_t,
+
+ LIBCFS_ALLOC(tx->tx_rd,
+ offsetof(kib_rdma_desc_t,
rd_frags[IBNAL_MAX_RDMA_FRAGS]));
if (tx->tx_rd == NULL)
return -ENOMEM;
}
void
-kibnal_free_tx_descs (void)
+kibnal_free_tx_descs (void)
{
int i;
sizeof(*tx->tx_pages));
#else
if (tx->tx_wrq != NULL)
- LIBCFS_FREE(tx->tx_wrq,
- (1 + IBNAL_MAX_RDMA_FRAGS) *
+ LIBCFS_FREE(tx->tx_wrq,
+ (1 + IBNAL_MAX_RDMA_FRAGS) *
sizeof(*tx->tx_wrq));
if (tx->tx_gl != NULL)
- LIBCFS_FREE(tx->tx_gl,
- (1 + IBNAL_MAX_RDMA_FRAGS) *
+ LIBCFS_FREE(tx->tx_gl,
+ (1 + IBNAL_MAX_RDMA_FRAGS) *
sizeof(*tx->tx_gl));
if (tx->tx_rd != NULL)
- LIBCFS_FREE(tx->tx_rd,
- offsetof(kib_rdma_desc_t,
+ LIBCFS_FREE(tx->tx_rd,
+ offsetof(kib_rdma_desc_t,
rd_frags[IBNAL_MAX_RDMA_FRAGS]));
#endif
}
#if IBNAL_USE_FMR
void
-kibnal_free_fmrs (int n)
+kibnal_free_fmrs (int n)
{
int i;
vv_return_t vvrc;
/* No fancy arithmetic when we do the buffer calculations */
CLASSERT (PAGE_SIZE % IBNAL_MSG_SIZE == 0);
- rc = kibnal_alloc_pages(&kibnal_data.kib_tx_pages,
+ rc = kibnal_alloc_pages(&kibnal_data.kib_tx_pages,
IBNAL_TX_MSG_PAGES(), 0);
if (rc != 0)
return (rc);
fmr_props.max_pages = LNET_MAX_IOV;
fmr_props.log2_page_sz = PAGE_SHIFT;
fmr_props.max_outstanding_maps = *kibnal_tunables.kib_fmr_remaps;
-
+
vvrc = vv_alloc_fmr(kibnal_data.kib_hca,
&fmr_props,
&tx->tx_md.md_fmrhandle);
if (vvrc != vv_return_ok) {
CERROR("Can't allocate fmr %d: %d\n", i, vvrc);
-
kibnal_free_fmrs(i);
kibnal_free_pages (kibnal_data.kib_tx_pages);
return -ENOMEM;
tx->tx_md.md_fmrcount = *kibnal_tunables.kib_fmr_remaps;
tx->tx_md.md_active = 0;
#endif
- tx->tx_msg = (kib_msg_t *)(((char *)page_address(page)) +
+ tx->tx_msg = (kib_msg_t *)(((char *)page_address(page)) +
page_offset);
vvrc = vv_get_gen_mr_attrib(kibnal_data.kib_hca,
&rkey);
LASSERT (vvrc == vv_return_ok);
- CDEBUG(D_NET, "Tx[%d] %p->%p[%x]\n", i, tx,
+ CDEBUG(D_NET, "Tx[%d] %p->%p[%x]\n", i, tx,
tx->tx_msg, tx->tx_lkey);
list_add (&tx->tx_list, &kibnal_data.kib_idle_txs);
LASSERT (ipage <= IBNAL_TX_MSG_PAGES());
}
}
-
+
return (0);
}
LASSERT (ni == kibnal_data.kib_ni);
LASSERT (ni->ni_data == &kibnal_data);
-
+
CDEBUG(D_MALLOC, "before NAL cleanup: kmem %d\n",
atomic_read (&libcfs_kmemory));
kibnal_async_callback);
if (vvrc != vv_return_ok)
CERROR("vv_dell_async_event_cb error: %d\n", vvrc);
-
+
/* fall through */
case IBNAL_INIT_HCA:
cfs_pause(cfs_time_seconds(1));
}
/* fall through */
-
+
case IBNAL_INIT_NOTHING:
break;
}
if (kibnal_data.kib_peers != NULL)
LIBCFS_FREE (kibnal_data.kib_peers,
- sizeof (struct list_head) *
+ sizeof (struct list_head) *
kibnal_data.kib_peer_hash_size);
CDEBUG(D_MALLOC, "after NAL cleanup: kmem %d\n",
ni->ni_peertxcredits = *kibnal_tunables.kib_peercredits;
CLASSERT (LNET_MAX_INTERFACES > 1);
-
+
if (ni->ni_interfaces[0] != NULL) {
/* Use the HCA specified in 'networks=' */
/* Parse <hca base name><number> */
hca_name = ni->ni_interfaces[0];
nob = strlen(*kibnal_tunables.kib_hca_basename);
-
+
if (strncmp(hca_name, *kibnal_tunables.kib_hca_basename, nob) ||
sscanf(hca_name + nob, "%d%n", &devno, &nob) < 1) {
CERROR("Unrecognised HCA %s\n", hca_name);
CERROR("IPoIB interface name %s truncated\n", ipif_name);
return -EINVAL;
}
-
+
rc = libcfs_ipif_query(ipif_name, &up, &ip, &netmask);
if (rc != 0) {
CERROR("Can't query IPoIB interface %s: %d\n", ipif_name, rc);
return -ENETDOWN;
}
-
+
if (!up) {
CERROR("Can't query IPoIB interface %s: it's down\n", ipif_name);
return -ENETDOWN;
}
-
+
ni->ni_nid = LNET_MKNID(LNET_NIDNET(ni->ni_nid), ip);
-
+
PORTAL_MODULE_USE;
memset (&kibnal_data, 0, sizeof (kibnal_data)); /* zero pointers, flags etc */
kibnal_data.kib_ni = ni;
ni->ni_data = &kibnal_data;
-
+
do_gettimeofday(&tv);
kibnal_data.kib_incarnation = (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec;
CERROR("Can't allocate tx descs\n");
goto failed;
}
-
+
/* lists/ptrs/locks initialised */
kibnal_data.kib_init = IBNAL_INIT_DATA;
/*****************************************************/
/* Found a suitable port. Get its GUID and PKEY. */
tbl_count = 1;
- vvrc = vv_get_port_gid_tbl(kibnal_data.kib_hca,
+ vvrc = vv_get_port_gid_tbl(kibnal_data.kib_hca,
port_num, &tbl_count,
&kibnal_data.kib_port_gid);
if (vvrc != vv_return_ok) {
CERROR("vv_get_port_gid_tbl failed "
- "for %s port %d: %d\n",
+ "for %s port %d: %d\n",
hca_name, port_num, vvrc);
continue;
}
tbl_count = 1;
- vvrc = vv_get_port_partition_tbl(kibnal_data.kib_hca,
+ vvrc = vv_get_port_partition_tbl(kibnal_data.kib_hca,
port_num, &tbl_count,
&kibnal_data.kib_port_pkey);
if (vvrc != vv_return_ok) {
}
CDEBUG(D_NET, "Using %s port %d - GID="LPX64":"LPX64"\n",
- hca_name, kibnal_data.kib_port,
- kibnal_data.kib_port_gid.scope.g.subnet,
+ hca_name, kibnal_data.kib_port,
+ kibnal_data.kib_port_gid.scope.g.subnet,
kibnal_data.kib_port_gid.scope.g.eui64);
-
+
/*****************************************************/
#if 1
CERROR ("Can't init PD: %d\n", vvrc);
goto failed;
}
-
+
/* flag PD initialised */
kibnal_data.kib_init = IBNAL_INIT_PD;
/*****************************************************/
CERROR ("Can't register tx descs: %d\n", rc);
goto failed;
}
-
+
/* flag TX descs initialised */
kibnal_data.kib_init = IBNAL_INIT_TXD;
/*****************************************************/
{
- uint32_t nentries;
+ __u32 nentries;
vvrc = vv_cq_create(kibnal_data.kib_hca, IBNAL_CQ_ENTRIES(),
- kibnal_cq_callback,
+ kibnal_cq_callback,
NULL, /* context */
&kibnal_data.kib_cq, &nentries);
if (vvrc != 0) {
kibnal_data.kib_init = IBNAL_INIT_CQ;
if (nentries < IBNAL_CQ_ENTRIES()) {
- CERROR ("CQ only has %d entries, need %d\n",
+ CERROR ("CQ only has %d entries, need %d\n",
nentries, IBNAL_CQ_ENTRIES());
goto failed;
}
- vvrc = vv_request_completion_notification(kibnal_data.kib_hca,
- kibnal_data.kib_cq,
+ vvrc = vv_request_completion_notification(kibnal_data.kib_hca,
+ kibnal_data.kib_cq,
vv_next_solicit_unsolicit_event);
if (vvrc != 0) {
CERROR ("Failed to re-arm completion queue: %d\n", rc);
CERROR("Can't start listener: %d\n", rc);
goto failed;
}
-
+
/* flag everything initialised */
kibnal_data.kib_init = IBNAL_INIT_ALL;
/*****************************************************/
failed:
CDEBUG(D_NET, "kibnal_startup failed\n");
- kibnal_shutdown (ni);
+ kibnal_shutdown (ni);
return (-ENETDOWN);
}
vibnal_assert_wire_constants();
- CLASSERT (offsetof(kib_msg_t, ibm_u) + sizeof(kib_connparams_t)
+ CLASSERT (offsetof(kib_msg_t, ibm_u) + sizeof(kib_connparams_t)
<= cm_REQ_priv_data_len);
- CLASSERT (offsetof(kib_msg_t, ibm_u) + sizeof(kib_connparams_t)
+ CLASSERT (offsetof(kib_msg_t, ibm_u) + sizeof(kib_connparams_t)
<= cm_REP_priv_data_len);
CLASSERT (sizeof(kib_msg_t) <= IBNAL_MSG_SIZE);
#if !IBNAL_USE_FMR
return 0;
}
-MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
+MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
MODULE_DESCRIPTION("Kernel Voltaire IB LND v1.00");
MODULE_LICENSE("GPL");
module_init(kibnal_module_init);
module_exit(kibnal_module_fini);
-