1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (C) 2004 Cluster File Systems, Inc.
5 * Author: Eric Barton <eric@bartonsoftware.com>
6 * Author: Frank Zago <fzago@systemfabricworks.com>
8 * This file is part of Lustre, http://www.lustre.org.
10 * Lustre is free software; you can redistribute it and/or
11 * modify it under the terms of version 2 of the GNU General Public
12 * License as published by the Free Software Foundation.
14 * Lustre is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with Lustre; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 ptl_handle_ni_t kibnal_ni;
29 kib_tunables_t kibnal_tunables;
31 kib_data_t kibnal_data = {
32 .kib_service_id = IBNAL_SERVICE_NUMBER,
36 #define IBNAL_SYSCTL 202
38 #define IBNAL_SYSCTL_TIMEOUT 1
40 static ctl_table kibnal_ctl_table[] = {
41 {IBNAL_SYSCTL_TIMEOUT, "timeout",
42 &kibnal_tunables.kib_io_timeout, sizeof (int),
43 0644, NULL, &proc_dointvec},
47 static ctl_table kibnal_top_ctl_table[] = {
48 {IBNAL_SYSCTL, "vibnal", NULL, 0, 0555, kibnal_ctl_table},
55 print_service(IB_SERVICE_RECORD *service, char *tag, int rc)
62 "status : %d (NULL)\n", tag, rc);
65 strncpy (name, service->ServiceName, sizeof(name)-1);
66 name[sizeof(name)-1] = 0;
70 "service id: "LPX64"\n"
72 "NID : "LPX64"\n", tag, rc,
73 service->RID.ServiceID, name,
74 *kibnal_service_nid_field(service));
79 * method is SUBN_ADM_SET, SUBN_ADM_GET, SUBN_ADM_DELETE. Tables not supported.
80 * nid is the nid to advertize/query/unadvertize
82 static void fill_sa_request(struct sa_request *request, int method, ptl_nid_t nid)
84 gsi_dtgrm_t *dtgrm = request->dtgrm_req;
85 sa_mad_v2_t *mad = (sa_mad_v2_t *) dtgrm->mad;
86 ib_service_record_v2_t *sr = (ib_service_record_v2_t *) mad->payload;
88 memset(mad, 0, MAD_BLOCK_SIZE);
92 dtgrm->rlid = kibnal_data.kib_port_attr.port_sma_address_info.sm_lid;
93 dtgrm->sl = kibnal_data.kib_port_attr.port_sma_address_info.service_level;
95 mad->hdr.base_ver = MAD_IB_BASE_VERSION;
96 mad->hdr.class = MAD_CLASS_SUBN_ADM;
97 mad->hdr.class_ver = 2;
98 mad->hdr.m.ms.method = method;
99 mad->hdr.attrib_id = SA_SERVICE_RECORD; /* something(?) will swap that field */
101 /* Note: the transaction ID is set by the Voltaire stack if it is 0. */
103 /* TODO: change the 40 to sizeof(something) */
104 mad->payload_len = cpu_to_be32(0x40 /*header size */ +
105 sizeof (ib_service_record_v2_t));
108 mad->component_mask = cpu_to_be64(
109 (1ull << 0) | /* service_id */
110 (1ull << 2) | /* service_pkey */
111 (1ull << 6) | /* service_name */
112 (1ull << 7) | /* service_data8[0] */
113 (1ull << 8) | /* service_data8[1] */
114 (1ull << 9) | /* service_data8[2] */
115 (1ull << 10) | /* service_data8[3] */
116 (1ull << 11) | /* service_data8[4] */
117 (1ull << 12) | /* service_data8[5] */
118 (1ull << 13) | /* service_data8[6] */
119 (1ull << 14) /* service_data8[7] */
122 sr->service_id = cpu_to_be64(kibnal_data.kib_service_id);
123 sr->service_pkey = cpu_to_be16(kibnal_data.kib_port_pkey);
125 /* Set the service name and the data (bytes 0 to 7) in data8 */
126 kibnal_set_service_keys(sr, nid);
128 if (method == SUBN_ADM_SET) {
129 mad->component_mask |= cpu_to_be64(
130 (1ull << 1) | /* service_gid */
131 (1ull << 4) /* service_lease */
134 sr->service_gid = kibnal_data.kib_port_gid;
135 gid_swap(&sr->service_gid);
136 sr->service_lease = cpu_to_be32(0xffffffff);
139 CDEBUG(D_NET, "SA request %02x for service id "LPX64" %s:"LPX64"\n",
140 mad->hdr.m.ms.method,
143 *kibnal_service_nid_field(sr));
146 /* Do an advertizement operation:
147 * SUBN_ADM_GET = 0x01 (i.e. query),
148 * SUBN_ADM_SET = 0x02 (i.e. advertize),
149 * SUBN_ADM_DELETE = 0x15 (i.e. un-advertize).
150 * If callback is NULL, the function is synchronous (and context is ignored).
152 int kibnal_advertize_op(ptl_nid_t nid, int op, sa_request_cb_t callback, void *context)
154 struct sa_request *request;
157 LASSERT (kibnal_data.kib_nid != PTL_NID_ANY);
159 CDEBUG(D_NET, "kibnal_advertize_op: nid="LPX64", op=%d\n", nid, op);
161 request = alloc_sa_request();
162 if (request == NULL) {
163 CERROR("Cannot allocate a SA request");
167 fill_sa_request(request, op, nid);
170 request->callback = callback;
171 request->context = context;
173 init_completion(&request->signal);
176 ret = vibnal_start_sa_request(request);
178 CERROR("vibnal_send_sa failed: %d\n", ret);
179 free_sa_request(request);
182 /* Return. The callback will have to free the SA request. */
185 wait_for_completion(&request->signal);
187 ret = request->status;
190 CERROR ("Error %d in advertising operation %d for NID "LPX64"\n",
191 ret, op, kibnal_data.kib_nid);
194 free_sa_request(request);
202 kibnal_set_mynid(ptl_nid_t nid)
205 lib_ni_t *ni = &kibnal_lib.libnal_ni;
209 CDEBUG(D_IOCTL, "setting mynid to "LPX64" (old nid="LPX64")\n",
210 nid, ni->ni_pid.nid);
212 do_gettimeofday(&tv);
214 down (&kibnal_data.kib_nid_mutex);
216 if (nid == kibnal_data.kib_nid) {
217 /* no change of NID */
218 up (&kibnal_data.kib_nid_mutex);
222 CDEBUG(D_NET, "NID "LPX64"("LPX64")\n",
223 kibnal_data.kib_nid, nid);
225 /* Unsubscribes the current NID */
226 if (kibnal_data.kib_nid != PTL_NID_ANY) {
228 rc = kibnal_advertize_op(kibnal_data.kib_nid, SUBN_ADM_DELETE, NULL, NULL);
231 CERROR("Error %d unadvertising NID "LPX64"\n",
232 rc, kibnal_data.kib_nid);
236 kibnal_data.kib_nid = ni->ni_pid.nid = nid;
237 kibnal_data.kib_incarnation = (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec;
239 /* Destroys the current endpoint, if any. */
240 if (kibnal_data.kib_cep) {
241 retval = cm_cancel(kibnal_data.kib_cep);
243 CERROR ("Error %d stopping listener\n", retval);
245 retval = cm_destroy_cep(kibnal_data.kib_cep);
247 CERROR ("Error %d destroying CEP\n", retval);
249 kibnal_data.kib_cep = NULL;
252 /* Delete all existing peers and their connections after new
253 * NID/incarnation set to ensure no old connections in our brave
255 kibnal_del_peer (PTL_NID_ANY, 0);
257 if (kibnal_data.kib_nid == PTL_NID_ANY) {
258 /* No new NID to install. The driver is shuting down. */
259 up (&kibnal_data.kib_nid_mutex);
263 /* remove any previous advert (crashed node etc) */
264 kibnal_advertize_op(kibnal_data.kib_nid, SUBN_ADM_DELETE, NULL, NULL);
266 kibnal_data.kib_cep = cm_create_cep(cm_cep_transp_rc);
267 if (kibnal_data.kib_cep == NULL) {
268 CERROR ("Can't create CEP\n");
272 cm_listen_data_t info;
274 CDEBUG(D_NET, "Created CEP %p for listening\n", kibnal_data.kib_cep);
276 memset(&info, 0, sizeof(info));
277 info.listen_addr.end_pt.sid = kibnal_data.kib_service_id;
279 cmret = cm_listen(kibnal_data.kib_cep, &info,
280 kibnal_listen_callback, NULL);
282 CERROR ("cm_listen error: %d\n", cmret);
290 rc = kibnal_advertize_op(kibnal_data.kib_nid, SUBN_ADM_SET, NULL, NULL);
292 #ifdef IBNAL_CHECK_ADVERT
293 kibnal_advertize_op(kibnal_data.kib_nid, SUBN_ADM_GET, NULL, NULL);
295 up (&kibnal_data.kib_nid_mutex);
299 retval = cm_cancel (kibnal_data.kib_cep);
301 CERROR("cm_cancel failed: %d\n", retval);
303 retval = cm_destroy_cep (kibnal_data.kib_cep);
305 CERROR("cm_destroy_cep failed: %d\n", retval);
307 /* remove any peers that sprung up while I failed to
308 * advertise myself */
309 kibnal_del_peer (PTL_NID_ANY, 0);
312 kibnal_data.kib_nid = PTL_NID_ANY;
313 up (&kibnal_data.kib_nid_mutex);
318 kibnal_create_peer (ptl_nid_t nid)
322 LASSERT (nid != PTL_NID_ANY);
324 PORTAL_ALLOC(peer, sizeof (*peer));
326 CERROR("Canot allocate perr\n");
330 memset(peer, 0, sizeof(*peer)); /* zero flags etc */
333 atomic_set (&peer->ibp_refcount, 1); /* 1 ref for caller */
335 INIT_LIST_HEAD (&peer->ibp_list); /* not in the peer table yet */
336 INIT_LIST_HEAD (&peer->ibp_conns);
337 INIT_LIST_HEAD (&peer->ibp_tx_queue);
339 peer->ibp_reconnect_time = jiffies;
340 peer->ibp_reconnect_interval = IBNAL_MIN_RECONNECT_INTERVAL;
342 atomic_inc (&kibnal_data.kib_npeers);
347 kibnal_destroy_peer (kib_peer_t *peer)
350 LASSERT (atomic_read (&peer->ibp_refcount) == 0);
351 LASSERT (peer->ibp_persistence == 0);
352 LASSERT (!kibnal_peer_active(peer));
353 LASSERT (peer->ibp_connecting == 0);
354 LASSERT (list_empty (&peer->ibp_conns));
355 LASSERT (list_empty (&peer->ibp_tx_queue));
357 PORTAL_FREE (peer, sizeof (*peer));
359 /* NB a peer's connections keep a reference on their peer until
360 * they are destroyed, so we can be assured that _all_ state to do
361 * with this peer has been cleaned up when its refcount drops to
363 atomic_dec (&kibnal_data.kib_npeers);
366 /* the caller is responsible for accounting for the additional reference
367 * that this creates */
369 kibnal_find_peer_locked (ptl_nid_t nid)
371 struct list_head *peer_list = kibnal_nid2peerlist (nid);
372 struct list_head *tmp;
375 list_for_each (tmp, peer_list) {
377 peer = list_entry (tmp, kib_peer_t, ibp_list);
379 LASSERT (peer->ibp_persistence != 0 || /* persistent peer */
380 peer->ibp_connecting != 0 || /* creating conns */
381 !list_empty (&peer->ibp_conns)); /* active conn */
383 if (peer->ibp_nid != nid)
386 CDEBUG(D_NET, "got peer [%p] -> "LPX64" (%d)\n",
387 peer, nid, atomic_read (&peer->ibp_refcount));
394 kibnal_get_peer (ptl_nid_t nid)
398 read_lock (&kibnal_data.kib_global_lock);
399 peer = kibnal_find_peer_locked (nid);
400 if (peer != NULL) /* +1 ref for caller? */
401 kib_peer_addref(peer);
402 read_unlock (&kibnal_data.kib_global_lock);
408 kibnal_unlink_peer_locked (kib_peer_t *peer)
410 LASSERT (peer->ibp_persistence == 0);
411 LASSERT (list_empty(&peer->ibp_conns));
413 LASSERT (kibnal_peer_active(peer));
414 list_del_init (&peer->ibp_list);
415 /* lose peerlist's ref */
416 kib_peer_decref(peer);
420 kibnal_get_peer_info (int index, ptl_nid_t *nidp, int *persistencep)
423 struct list_head *ptmp;
426 read_lock (&kibnal_data.kib_global_lock);
428 for (i = 0; i < kibnal_data.kib_peer_hash_size; i++) {
430 list_for_each (ptmp, &kibnal_data.kib_peers[i]) {
432 peer = list_entry (ptmp, kib_peer_t, ibp_list);
433 LASSERT (peer->ibp_persistence != 0 ||
434 peer->ibp_connecting != 0 ||
435 !list_empty (&peer->ibp_conns));
440 *nidp = peer->ibp_nid;
441 *persistencep = peer->ibp_persistence;
443 read_unlock (&kibnal_data.kib_global_lock);
448 read_unlock (&kibnal_data.kib_global_lock);
453 kibnal_add_persistent_peer (ptl_nid_t nid)
459 if (nid == PTL_NID_ANY)
462 peer = kibnal_create_peer (nid);
466 write_lock_irqsave (&kibnal_data.kib_global_lock, flags);
468 peer2 = kibnal_find_peer_locked (nid);
470 kib_peer_decref (peer);
473 /* peer table takes existing ref on peer */
474 list_add_tail (&peer->ibp_list,
475 kibnal_nid2peerlist (nid));
478 peer->ibp_persistence++;
480 write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
485 kibnal_del_peer_locked (kib_peer_t *peer, int single_share)
487 struct list_head *ctmp;
488 struct list_head *cnxt;
492 peer->ibp_persistence = 0;
493 else if (peer->ibp_persistence > 0)
494 peer->ibp_persistence--;
496 if (peer->ibp_persistence != 0)
499 if (list_empty(&peer->ibp_conns)) {
500 kibnal_unlink_peer_locked(peer);
502 list_for_each_safe (ctmp, cnxt, &peer->ibp_conns) {
503 conn = list_entry(ctmp, kib_conn_t, ibc_list);
505 kibnal_close_conn_locked (conn, 0);
507 /* NB peer is no longer persistent; closing its last conn
510 /* NB peer now unlinked; might even be freed if the peer table had the
515 kibnal_del_peer (ptl_nid_t nid, int single_share)
518 struct list_head *ptmp;
519 struct list_head *pnxt;
526 write_lock_irqsave (&kibnal_data.kib_global_lock, flags);
528 if (nid != PTL_NID_ANY)
529 lo = hi = kibnal_nid2peerlist(nid) - kibnal_data.kib_peers;
532 hi = kibnal_data.kib_peer_hash_size - 1;
535 for (i = lo; i <= hi; i++) {
536 list_for_each_safe (ptmp, pnxt, &kibnal_data.kib_peers[i]) {
537 peer = list_entry (ptmp, kib_peer_t, ibp_list);
538 LASSERT (peer->ibp_persistence != 0 ||
539 peer->ibp_connecting != 0 ||
540 !list_empty (&peer->ibp_conns));
542 if (!(nid == PTL_NID_ANY || peer->ibp_nid == nid))
545 kibnal_del_peer_locked (peer, single_share);
546 rc = 0; /* matched something */
553 write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
559 kibnal_get_conn_by_idx (int index)
562 struct list_head *ptmp;
564 struct list_head *ctmp;
567 read_lock (&kibnal_data.kib_global_lock);
569 for (i = 0; i < kibnal_data.kib_peer_hash_size; i++) {
570 list_for_each (ptmp, &kibnal_data.kib_peers[i]) {
572 peer = list_entry (ptmp, kib_peer_t, ibp_list);
573 LASSERT (peer->ibp_persistence > 0 ||
574 peer->ibp_connecting != 0 ||
575 !list_empty (&peer->ibp_conns));
577 list_for_each (ctmp, &peer->ibp_conns) {
581 conn = list_entry (ctmp, kib_conn_t, ibc_list);
582 CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
583 conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
584 atomic_read (&conn->ibc_refcount));
585 atomic_inc (&conn->ibc_refcount);
586 read_unlock (&kibnal_data.kib_global_lock);
592 read_unlock (&kibnal_data.kib_global_lock);
597 kibnal_create_conn (void)
605 vv_qp_attr_t qp_attr;
610 PORTAL_ALLOC(conn, sizeof (*conn));
612 CERROR ("Can't allocate connection\n");
616 /* zero flags, NULL pointers etc... */
617 memset (conn, 0, sizeof (*conn));
619 INIT_LIST_HEAD (&conn->ibc_tx_queue);
620 INIT_LIST_HEAD (&conn->ibc_active_txs);
621 spin_lock_init (&conn->ibc_lock);
623 atomic_inc (&kibnal_data.kib_nconns);
624 /* well not really, but I call destroy() on failure, which decrements */
626 PORTAL_ALLOC(conn->ibc_rxs, IBNAL_RX_MSGS * sizeof (kib_rx_t));
627 if (conn->ibc_rxs == NULL) {
628 CERROR("Cannot allocate RX buffers\n");
631 memset (conn->ibc_rxs, 0, IBNAL_RX_MSGS * sizeof(kib_rx_t));
633 rc = kibnal_alloc_pages(&conn->ibc_rx_pages, IBNAL_RX_MSG_PAGES, 1);
637 vaddr_base = vaddr = conn->ibc_rx_pages->ibp_vaddr;
639 for (i = ipage = page_offset = 0; i < IBNAL_RX_MSGS; i++) {
640 struct page *page = conn->ibc_rx_pages->ibp_pages[ipage];
641 kib_rx_t *rx = &conn->ibc_rxs[i];
644 rx->rx_msg = (kib_msg_t *)(((char *)page_address(page)) +
647 if (kibnal_whole_mem()) {
649 vv_mem_reg_h_t mem_h;
652 /* Voltaire stack already registers the whole
653 * memory, so use that API. */
654 retval = vv_get_gen_mr_attrib(kibnal_data.kib_hca,
661 CERROR("vv_get_gen_mr_attrib failed: %d", retval);
662 /* TODO: free pages? */
667 vaddr += IBNAL_MSG_SIZE;
668 LASSERT (vaddr <= vaddr_base + IBNAL_RX_MSG_BYTES);
670 page_offset += IBNAL_MSG_SIZE;
671 LASSERT (page_offset <= PAGE_SIZE);
673 if (page_offset == PAGE_SIZE) {
676 LASSERT (ipage <= IBNAL_RX_MSG_PAGES);
680 qp_attr = (vv_qp_attr_t) {
681 .create.qp_type = vv_qp_type_r_conn,
682 .create.cq_send_h = kibnal_data.kib_cq,
683 .create.cq_receive_h = kibnal_data.kib_cq,
684 .create.send_max_outstand_wr = IBNAL_TX_MAX_SG *
685 IBNAL_MSG_QUEUE_SIZE,
686 .create.receive_max_outstand_wr = IBNAL_MSG_QUEUE_SIZE,
687 .create.max_scatgat_per_send_wr = 1,
688 .create.max_scatgat_per_receive_wr = 1,
689 .create.signaling_type = vv_selectable_signaling, /* TODO: correct? */
690 .create.pd_h = kibnal_data.kib_pd,
691 .create.recv_solicited_events = vv_signal_all,
693 retval = vv_qp_create(kibnal_data.kib_hca, &qp_attr, NULL,
694 &conn->ibc_qp, &conn->ibc_qp_attrs);
696 CERROR ("Failed to create queue pair: %d\n", retval);
700 /* Mark QP created */
701 conn->ibc_state = IBNAL_CONN_INIT_QP;
703 qp_attr = (vv_qp_attr_t) {
704 .modify.qp_modify_into_state = vv_qp_state_init,
705 .modify.vv_qp_attr_mask = VV_QP_AT_STATE | VV_QP_AT_PHY_PORT_NUM | VV_QP_AT_P_KEY_IX | VV_QP_AT_ACCESS_CON_F,
706 .modify.qp_type = vv_qp_type_r_conn,
708 .modify.params.init.p_key_indx = 0,
709 .modify.params.init.phy_port_num = kibnal_data.kib_port,
710 .modify.params.init.access_control = vv_acc_r_mem_write | vv_acc_r_mem_read,
712 retval = vv_qp_modify(kibnal_data.kib_hca, conn->ibc_qp, &qp_attr, &conn->ibc_qp_attrs);
714 CERROR ("Failed to modify queue pair: %d\n", retval);
718 retval = vv_qp_query(kibnal_data.kib_hca, conn->ibc_qp, &qp_context, &conn->ibc_qp_attrs);
720 CERROR ("Failed to query queue pair: %d\n", retval);
724 /* 1 ref for caller */
725 atomic_set (&conn->ibc_refcount, 1);
729 kibnal_destroy_conn (conn);
734 kibnal_destroy_conn (kib_conn_t *conn)
738 CDEBUG (D_NET, "connection %p\n", conn);
740 LASSERT (atomic_read (&conn->ibc_refcount) == 0);
741 LASSERT (list_empty(&conn->ibc_tx_queue));
742 LASSERT (list_empty(&conn->ibc_active_txs));
743 LASSERT (conn->ibc_nsends_posted == 0);
744 LASSERT (conn->ibc_connreq == NULL);
746 switch (conn->ibc_state) {
747 case IBNAL_CONN_DISCONNECTED:
748 /* called after connection sequence initiated */
751 case IBNAL_CONN_INIT_QP:
752 /* _destroy includes an implicit Reset of the QP which
753 * discards posted work */
754 retval = vv_qp_destroy(kibnal_data.kib_hca, conn->ibc_qp);
756 CERROR("Can't destroy QP: %d\n", retval);
759 case IBNAL_CONN_INIT_NOTHING:
766 if (conn->ibc_cep != NULL) {
767 retval = cm_destroy_cep(conn->ibc_cep);
769 CERROR("Can't destroy CEP %p: %d\n", conn->ibc_cep,
773 if (conn->ibc_rx_pages != NULL)
774 kibnal_free_pages(conn->ibc_rx_pages);
776 if (conn->ibc_rxs != NULL)
777 PORTAL_FREE(conn->ibc_rxs,
778 IBNAL_RX_MSGS * sizeof(kib_rx_t));
780 if (conn->ibc_peer != NULL)
781 kib_peer_decref(conn->ibc_peer);
783 PORTAL_FREE(conn, sizeof (*conn));
785 atomic_dec(&kibnal_data.kib_nconns);
787 if (atomic_read (&kibnal_data.kib_nconns) == 0 &&
788 kibnal_data.kib_shutdown) {
789 /* I just nuked the last connection on shutdown; wake up
790 * everyone so they can exit. */
791 wake_up_all(&kibnal_data.kib_sched_waitq);
792 wake_up_all(&kibnal_data.kib_connd_waitq);
797 kibnal_put_conn (kib_conn_t *conn)
801 CDEBUG (D_NET, "putting conn[%p] state %d -> "LPX64" (%d)\n",
802 conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
803 atomic_read (&conn->ibc_refcount));
805 LASSERT (atomic_read (&conn->ibc_refcount) > 0);
806 if (!atomic_dec_and_test (&conn->ibc_refcount))
809 /* must disconnect before dropping the final ref */
810 LASSERT (conn->ibc_state == IBNAL_CONN_DISCONNECTED);
812 spin_lock_irqsave (&kibnal_data.kib_connd_lock, flags);
814 list_add (&conn->ibc_list, &kibnal_data.kib_connd_conns);
815 wake_up (&kibnal_data.kib_connd_waitq);
817 spin_unlock_irqrestore (&kibnal_data.kib_connd_lock, flags);
821 kibnal_close_peer_conns_locked (kib_peer_t *peer, int why)
824 struct list_head *ctmp;
825 struct list_head *cnxt;
828 list_for_each_safe (ctmp, cnxt, &peer->ibp_conns) {
829 conn = list_entry (ctmp, kib_conn_t, ibc_list);
832 kibnal_close_conn_locked (conn, why);
839 kibnal_close_stale_conns_locked (kib_peer_t *peer, __u64 incarnation)
842 struct list_head *ctmp;
843 struct list_head *cnxt;
846 list_for_each_safe (ctmp, cnxt, &peer->ibp_conns) {
847 conn = list_entry (ctmp, kib_conn_t, ibc_list);
849 if (conn->ibc_incarnation == incarnation)
852 CDEBUG(D_NET, "Closing stale conn nid:"LPX64" incarnation:"LPX64"("LPX64")\n",
853 peer->ibp_nid, conn->ibc_incarnation, incarnation);
856 kibnal_close_conn_locked (conn, -ESTALE);
863 kibnal_close_matching_conns (ptl_nid_t nid)
867 struct list_head *ptmp;
868 struct list_head *pnxt;
874 write_lock_irqsave (&kibnal_data.kib_global_lock, flags);
876 if (nid != PTL_NID_ANY)
877 lo = hi = kibnal_nid2peerlist(nid) - kibnal_data.kib_peers;
880 hi = kibnal_data.kib_peer_hash_size - 1;
883 for (i = lo; i <= hi; i++) {
884 list_for_each_safe (ptmp, pnxt, &kibnal_data.kib_peers[i]) {
886 peer = list_entry (ptmp, kib_peer_t, ibp_list);
887 LASSERT (peer->ibp_persistence != 0 ||
888 peer->ibp_connecting != 0 ||
889 !list_empty (&peer->ibp_conns));
891 if (!(nid == PTL_NID_ANY || nid == peer->ibp_nid))
894 count += kibnal_close_peer_conns_locked (peer, 0);
898 write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
900 /* wildcards always succeed */
901 if (nid == PTL_NID_ANY)
904 return (count == 0 ? -ENOENT : 0);
908 kibnal_cmd(struct portals_cfg *pcfg, void * private)
913 LASSERT (pcfg != NULL);
915 switch(pcfg->pcfg_command) {
916 case NAL_CMD_GET_PEER: {
920 rc = kibnal_get_peer_info(pcfg->pcfg_count,
922 pcfg->pcfg_nid = nid;
926 pcfg->pcfg_count = 0;
927 pcfg->pcfg_wait = share_count;
930 case NAL_CMD_ADD_PEER: {
931 rc = kibnal_add_persistent_peer (pcfg->pcfg_nid);
934 case NAL_CMD_DEL_PEER: {
935 rc = kibnal_del_peer (pcfg->pcfg_nid,
936 /* flags == single_share */
937 pcfg->pcfg_flags != 0);
940 case NAL_CMD_GET_CONN: {
941 kib_conn_t *conn = kibnal_get_conn_by_idx (pcfg->pcfg_count);
947 pcfg->pcfg_nid = conn->ibc_peer->ibp_nid;
950 pcfg->pcfg_flags = 0;
951 kibnal_put_conn (conn);
955 case NAL_CMD_CLOSE_CONNECTION: {
956 rc = kibnal_close_matching_conns (pcfg->pcfg_nid);
959 case NAL_CMD_REGISTER_MYNID: {
960 if (pcfg->pcfg_nid == PTL_NID_ANY)
963 rc = kibnal_set_mynid (pcfg->pcfg_nid);
972 kibnal_free_pages (kib_pages_t *p)
974 int npages = p->ibp_npages;
979 retval = vv_mem_region_destroy(kibnal_data.kib_hca, p->ibp_handle);
981 CERROR ("Deregister error: %d\n", retval);
984 for (i = 0; i < npages; i++)
985 if (p->ibp_pages[i] != NULL)
986 __free_page(p->ibp_pages[i]);
988 PORTAL_FREE (p, offsetof(kib_pages_t, ibp_pages[npages]));
992 kibnal_alloc_pages (kib_pages_t **pp, int npages, int allow_write)
995 vv_phy_list_t phys_pages;
996 vv_phy_buf_t *phys_buf;
1000 PORTAL_ALLOC(p, offsetof(kib_pages_t, ibp_pages[npages]));
1002 CERROR ("Can't allocate buffer %d\n", npages);
1006 memset (p, 0, offsetof(kib_pages_t, ibp_pages[npages]));
1007 p->ibp_npages = npages;
1009 for (i = 0; i < npages; i++) {
1010 p->ibp_pages[i] = alloc_page (GFP_KERNEL);
1011 if (p->ibp_pages[i] == NULL) {
1012 CERROR ("Can't allocate page %d of %d\n", i, npages);
1013 kibnal_free_pages(p);
1018 if (kibnal_whole_mem())
1021 PORTAL_ALLOC(phys_buf, npages * sizeof(vv_phy_buf_t));
1022 if (phys_buf == NULL) {
1023 CERROR ("Can't allocate phys_buf for %d pages\n", npages);
1024 /* XXX free ibp_pages? */
1025 kibnal_free_pages(p);
1029 phys_pages.number_of_buff = npages;
1030 phys_pages.phy_list = phys_buf;
1032 /* if we were using the _contig_ registration variant we would have
1033 * an array of PhysAddr/Length pairs, but the discontiguous variant
1034 * just takes the PhysAddr */
1035 for (i = 0; i < npages; i++) {
1036 phys_buf[i].start = kibnal_page2phys(p->ibp_pages[i]);
1037 phys_buf[i].size = PAGE_SIZE;
1040 retval = vv_phy_mem_region_register(kibnal_data.kib_hca,
1042 0, /* requested vaddr */
1046 vv_acc_l_mem_write | vv_acc_r_mem_write | vv_acc_r_mem_read | vv_acc_mem_bind, /* TODO: translated as-is, but seems incorrect or too much */
1047 &p->ibp_handle, &p->ibp_vaddr,
1048 &p->ibp_lkey, &p->ibp_rkey);
1050 PORTAL_FREE(phys_buf, npages * sizeof(vv_phy_buf_t));
1053 CERROR ("Error %d mapping %d pages\n", retval, npages);
1054 kibnal_free_pages(p);
1058 CDEBUG(D_NET, "registered %d pages; handle: %x vaddr "LPX64" "
1059 "lkey %x rkey %x\n", npages, p->ibp_handle,
1060 p->ibp_vaddr, p->ibp_lkey, p->ibp_rkey);
1069 kibnal_setup_tx_descs (void)
1072 int page_offset = 0;
1080 /* pre-mapped messages are not bigger than 1 page */
1081 LASSERT (IBNAL_MSG_SIZE <= PAGE_SIZE);
1083 /* No fancy arithmetic when we do the buffer calculations */
1084 LASSERT (PAGE_SIZE % IBNAL_MSG_SIZE == 0);
1086 rc = kibnal_alloc_pages(&kibnal_data.kib_tx_pages, IBNAL_TX_MSG_PAGES,
1091 /* ignored for the whole_mem case */
1092 vaddr = vaddr_base = kibnal_data.kib_tx_pages->ibp_vaddr;
1094 for (i = 0; i < IBNAL_TX_MSGS; i++) {
1095 page = kibnal_data.kib_tx_pages->ibp_pages[ipage];
1096 tx = &kibnal_data.kib_tx_descs[i];
1098 memset (tx, 0, sizeof(*tx)); /* zero flags etc */
1100 tx->tx_msg = (kib_msg_t *)(((char *)page_address(page)) +
1103 if (kibnal_whole_mem()) {
1105 vv_mem_reg_h_t mem_h;
1108 /* Voltaire stack already registers the whole
1109 * memory, so use that API. */
1110 retval = vv_get_gen_mr_attrib(kibnal_data.kib_hca,
1117 CERROR("vv_get_gen_mr_attrib failed: %d", retval);
1118 /* TODO: free pages? */
1123 tx->tx_isnblk = (i >= IBNAL_NTX);
1124 tx->tx_mapped = KIB_TX_UNMAPPED;
1126 CDEBUG(D_NET, "Tx[%d] %p->%p\n", i, tx, tx->tx_msg);
1129 list_add (&tx->tx_list,
1130 &kibnal_data.kib_idle_nblk_txs);
1132 list_add (&tx->tx_list,
1133 &kibnal_data.kib_idle_txs);
1135 vaddr += IBNAL_MSG_SIZE;
1136 LASSERT (vaddr <= vaddr_base + IBNAL_TX_MSG_BYTES);
1138 page_offset += IBNAL_MSG_SIZE;
1139 LASSERT (page_offset <= PAGE_SIZE);
1141 if (page_offset == PAGE_SIZE) {
1144 LASSERT (ipage <= IBNAL_TX_MSG_PAGES);
1152 kibnal_api_shutdown (nal_t *nal)
1158 if (nal->nal_refct != 0) {
1159 /* This module got the first ref */
1160 PORTAL_MODULE_UNUSE;
1164 CDEBUG(D_MALLOC, "before NAL cleanup: kmem %d\n",
1165 atomic_read (&portal_kmemory));
1167 LASSERT(nal == &kibnal_api);
1169 switch (kibnal_data.kib_init) {
1171 case IBNAL_INIT_ALL:
1172 /* stop calls to nal_cmd */
1173 libcfs_nal_cmd_unregister(VIBNAL);
1176 /* resetting my NID to unadvertises me, removes my
1177 * listener and nukes all current peers */
1178 kibnal_set_mynid (PTL_NID_ANY);
1180 /* Wait for all peer state to clean up (crazy) */
1182 while (atomic_read (&kibnal_data.kib_npeers) != 0) {
1184 CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, /* power of 2? */
1185 "waiting for %d peers to disconnect (can take a few seconds)\n",
1186 atomic_read (&kibnal_data.kib_npeers));
1187 set_current_state (TASK_UNINTERRUPTIBLE);
1188 schedule_timeout (HZ);
1193 retval = vv_cq_destroy(kibnal_data.kib_hca, kibnal_data.kib_cq);
1195 CERROR ("Destroy CQ error: %d\n", retval);
1198 case IBNAL_INIT_TXD:
1199 kibnal_free_pages (kibnal_data.kib_tx_pages);
1203 case IBNAL_INIT_FMR:
1204 rc = ib_fmr_pool_destroy (kibnal_data.kib_fmr_pool);
1206 CERROR ("Destroy FMR pool error: %d\n", rc);
1210 #if IBNAL_WHOLE_MEM==0
1211 retval = vv_pd_deallocate(kibnal_data.kib_hca, kibnal_data.kib_pd);
1213 CERROR ("Destroy PD error: %d\n", retval);
1217 case IBNAL_INIT_GSI:
1218 retval = gsi_deregister_class(kibnal_data.gsi_handle);
1220 CERROR ("GSI deregister failed: %d\n", retval);
1223 case IBNAL_INIT_GSI_POOL:
1224 gsi_dtgrm_pool_destroy(kibnal_data.gsi_pool_handle);
1227 case IBNAL_INIT_PORT:
1231 case IBNAL_INIT_ASYNC:
1232 retval = vv_dell_async_event_cb (kibnal_data.kib_hca,
1233 kibnal_ca_async_callback);
1235 CERROR("deregister asynchronous call back error: %d\n", retval);
1239 case IBNAL_INIT_HCA:
1240 retval = vv_hca_close(kibnal_data.kib_hca);
1242 CERROR ("Close HCA error: %d\n", retval);
1245 case IBNAL_INIT_LIB:
1246 lib_fini(&kibnal_lib);
1249 case IBNAL_INIT_DATA:
1250 /* Module refcount only gets to zero when all peers
1251 * have been closed so all lists must be empty */
1252 LASSERT (atomic_read (&kibnal_data.kib_npeers) == 0);
1253 LASSERT (kibnal_data.kib_peers != NULL);
1254 for (i = 0; i < kibnal_data.kib_peer_hash_size; i++) {
1255 LASSERT (list_empty (&kibnal_data.kib_peers[i]));
1257 LASSERT (atomic_read (&kibnal_data.kib_nconns) == 0);
1258 LASSERT (list_empty (&kibnal_data.kib_sched_rxq));
1259 LASSERT (list_empty (&kibnal_data.kib_sched_txq));
1260 LASSERT (list_empty (&kibnal_data.kib_connd_conns));
1261 LASSERT (list_empty (&kibnal_data.kib_connd_peers));
1263 /* flag threads to terminate; wake and wait for them to die */
1264 kibnal_data.kib_shutdown = 1;
1265 wake_up_all (&kibnal_data.kib_sched_waitq);
1266 wake_up_all (&kibnal_data.kib_connd_waitq);
1269 while (atomic_read (&kibnal_data.kib_nthreads) != 0) {
1271 CDEBUG(((i & (-i)) == i) ? D_WARNING : D_NET, /* power of 2? */
1272 "Waiting for %d threads to terminate\n",
1273 atomic_read (&kibnal_data.kib_nthreads));
1274 set_current_state (TASK_INTERRUPTIBLE);
1275 schedule_timeout (HZ);
1279 case IBNAL_INIT_NOTHING:
1283 if (kibnal_data.kib_tx_descs != NULL)
1284 PORTAL_FREE (kibnal_data.kib_tx_descs,
1285 IBNAL_TX_MSGS * sizeof(kib_tx_t));
1287 if (kibnal_data.kib_peers != NULL)
1288 PORTAL_FREE (kibnal_data.kib_peers,
1289 sizeof (struct list_head) *
1290 kibnal_data.kib_peer_hash_size);
1292 CDEBUG(D_MALLOC, "after NAL cleanup: kmem %d\n",
1293 atomic_read (&portal_kmemory));
1294 printk(KERN_INFO "Lustre: Voltaire IB NAL unloaded (final mem %d)\n",
1295 atomic_read(&portal_kmemory));
1297 kibnal_data.kib_init = IBNAL_INIT_NOTHING;
1300 #define roundup_power(val, power) \
1301 ( (val + (__u64)(power - 1)) & ~((__u64)(power - 1)) )
1303 /* this isn't very portable or sturdy in the face of funny mem/bus configs */
1304 static __u64 max_phys_mem(void)
1310 ret = (__u64)max(si.totalram, max_mapnr) * si.mem_unit;
1311 return roundup_power(ret, 128 * 1024 * 1024);
1313 #undef roundup_power
1316 kibnal_api_startup (nal_t *nal, ptl_pid_t requested_pid,
1317 ptl_ni_limits_t *requested_limits,
1318 ptl_ni_limits_t *actual_limits)
1320 ptl_process_id_t process_id;
1321 int pkmem = atomic_read(&portal_kmemory);
1324 vv_request_event_record_t req_er;
1327 LASSERT (nal == &kibnal_api);
1329 if (nal->nal_refct != 0) {
1330 if (actual_limits != NULL)
1331 *actual_limits = kibnal_lib.libnal_ni.ni_actual_limits;
1332 /* This module got the first ref */
1337 LASSERT (kibnal_data.kib_init == IBNAL_INIT_NOTHING);
1339 init_MUTEX (&kibnal_data.kib_nid_mutex);
1340 kibnal_data.kib_nid = PTL_NID_ANY;
1342 rwlock_init(&kibnal_data.kib_global_lock);
1344 kibnal_data.kib_peer_hash_size = IBNAL_PEER_HASH_SIZE;
1345 PORTAL_ALLOC (kibnal_data.kib_peers,
1346 sizeof (struct list_head) * kibnal_data.kib_peer_hash_size);
1347 if (kibnal_data.kib_peers == NULL) {
1350 for (i = 0; i < kibnal_data.kib_peer_hash_size; i++)
1351 INIT_LIST_HEAD(&kibnal_data.kib_peers[i]);
1353 spin_lock_init (&kibnal_data.kib_connd_lock);
1354 INIT_LIST_HEAD (&kibnal_data.kib_connd_peers);
1355 INIT_LIST_HEAD (&kibnal_data.kib_connd_conns);
1356 init_waitqueue_head (&kibnal_data.kib_connd_waitq);
1358 spin_lock_init (&kibnal_data.kib_sched_lock);
1359 INIT_LIST_HEAD (&kibnal_data.kib_sched_txq);
1360 INIT_LIST_HEAD (&kibnal_data.kib_sched_rxq);
1361 init_waitqueue_head (&kibnal_data.kib_sched_waitq);
1363 spin_lock_init (&kibnal_data.kib_tx_lock);
1364 INIT_LIST_HEAD (&kibnal_data.kib_idle_txs);
1365 INIT_LIST_HEAD (&kibnal_data.kib_idle_nblk_txs);
1366 init_waitqueue_head(&kibnal_data.kib_idle_tx_waitq);
1368 INIT_LIST_HEAD (&kibnal_data.gsi_pending);
1369 init_MUTEX (&kibnal_data.gsi_mutex);
1371 PORTAL_ALLOC (kibnal_data.kib_tx_descs,
1372 IBNAL_TX_MSGS * sizeof(kib_tx_t));
1373 if (kibnal_data.kib_tx_descs == NULL) {
1374 CERROR ("Can't allocate tx descs\n");
1378 /* lists/ptrs/locks initialised */
1379 kibnal_data.kib_init = IBNAL_INIT_DATA;
1380 /*****************************************************/
1382 process_id.pid = requested_pid;
1383 process_id.nid = kibnal_data.kib_nid;
1385 rc = lib_init(&kibnal_lib, nal, process_id,
1386 requested_limits, actual_limits);
1388 CERROR("lib_init failed: error %d\n", rc);
1392 /* lib interface initialised */
1393 kibnal_data.kib_init = IBNAL_INIT_LIB;
1394 /*****************************************************/
1396 for (i = 0; i < IBNAL_N_SCHED; i++) {
1397 rc = kibnal_thread_start (kibnal_scheduler, (void *)i);
1399 CERROR("Can't spawn vibnal scheduler[%d]: %d\n",
1405 rc = kibnal_thread_start (kibnal_connd, NULL);
1407 CERROR ("Can't spawn vibnal connd: %d\n", rc);
1411 /* TODO: apparently only one adapter is supported */
1412 retval = vv_hca_open("ANY_HCA", NULL, &kibnal_data.kib_hca);
1414 CERROR ("Can't open CA: %d\n", retval);
1418 /* Channel Adapter opened */
1419 kibnal_data.kib_init = IBNAL_INIT_HCA;
1421 /* register to get HCA's asynchronous events. */
1422 req_er.req_event_type = VV_ASYNC_EVENT_ALL_MASK;
1423 retval = vv_set_async_event_cb (kibnal_data.kib_hca,
1425 kibnal_ca_async_callback);
1428 CERROR ("Can't open CA: %d\n", retval);
1432 kibnal_data.kib_init = IBNAL_INIT_ASYNC;
1434 /*****************************************************/
1436 retval = vv_hca_query(kibnal_data.kib_hca,
1437 &kibnal_data.kib_hca_attrs);
1439 CERROR ("Can't size port attrs: %d\n", retval);
1443 kibnal_data.kib_port = -1;
1445 for (i = 0; i<kibnal_data.kib_hca_attrs.port_num; i++) {
1448 u_int32_t tbl_count;
1449 vv_port_attrib_t *pattr = &kibnal_data.kib_port_attr;
1451 retval = vv_port_query(kibnal_data.kib_hca, port_num, pattr);
1453 CERROR("vv_port_query failed for port %d: %d\n", port_num, retval);
1457 switch (pattr->port_state) {
1458 case vv_state_linkDoun:
1459 CDEBUG(D_NET, "port[%d] Down\n", port_num);
1461 case vv_state_linkInit:
1462 CDEBUG(D_NET, "port[%d] Init\n", port_num);
1464 case vv_state_linkArm:
1465 CDEBUG(D_NET, "port[%d] Armed\n", port_num);
1467 case vv_state_linkActive:
1468 CDEBUG(D_NET, "port[%d] Active\n", port_num);
1470 /* Found a suitable port. Get its GUID and PKEY. */
1471 kibnal_data.kib_port = port_num;
1474 retval = vv_get_port_gid_tbl(kibnal_data.kib_hca, port_num, &tbl_count, &kibnal_data.kib_port_gid);
1476 CERROR("vv_get_port_gid_tbl failed for port %d: %d\n", port_num, retval);
1481 retval = vv_get_port_partition_tbl (kibnal_data.kib_hca, port_num, &tbl_count, &kibnal_data.kib_port_pkey);
1483 CERROR("vv_get_port_partition_tbl failed for port %d: %d\n", port_num, retval);
1488 case vv_state_linkActDefer: /* TODO: correct? */
1489 case vv_state_linkNoChange:
1490 CERROR("Unexpected port[%d] state %d\n",
1491 i, pattr->port_state);
1497 if (kibnal_data.kib_port == -1) {
1498 CERROR ("Can't find an active port\n");
1502 CDEBUG(D_NET, "Using port %d - GID="LPX64":"LPX64"\n",
1503 kibnal_data.kib_port, kibnal_data.kib_port_gid.scope.g.subnet, kibnal_data.kib_port_gid.scope.g.eui64);
1504 CDEBUG(D_NET, "got guid "LPX64"\n", cpu_to_le64(kibnal_data.kib_port_gid.scope.g.eui64));
1506 /* Active port found */
1507 kibnal_data.kib_init = IBNAL_INIT_PORT;
1508 /*****************************************************/
1510 /* Prepare things to be able to send/receive MADS */
1511 retval = gsi_dtgrm_pool_create(IBNAL_CONCURRENT_PEERS, &kibnal_data.gsi_pool_handle);
1513 CERROR("Could not create GSI pool: %d\n", retval);
1516 kibnal_data.kib_init = IBNAL_INIT_GSI_POOL;
1518 retval = gsi_register_class(MAD_CLASS_SUBN_ADM, /* TODO: correct? */
1521 #ifdef GSI_PASS_PORT_NUM
1522 kibnal_data.kib_port,
1525 vibnal_mad_sent_cb, vibnal_mad_received_cb,
1526 NULL, &kibnal_data.gsi_handle);
1528 CERROR("Cannot register GSI class: %d\n", retval);
1532 kibnal_data.kib_init = IBNAL_INIT_GSI;
1533 /*****************************************************/
1535 #if IBNAL_WHOLE_MEM==0
1536 retval = vv_pd_allocate(kibnal_data.kib_hca, &kibnal_data.kib_pd);
1538 retval = vv_get_gen_pd_h(kibnal_data.kib_hca, &kibnal_data.kib_pd);
1541 CERROR ("Can't create PD: %d\n", retval);
1545 /* flag PD initialised */
1546 kibnal_data.kib_init = IBNAL_INIT_PD;
1547 /*****************************************************/
1551 const int pool_size = IBNAL_NTX + IBNAL_NTX_NBLK;
1552 struct ib_fmr_pool_param params = {
1553 .max_pages_per_fmr = PTL_MTU/PAGE_SIZE,
1554 .access = (IB_ACCESS_LOCAL_WRITE |
1555 IB_ACCESS_REMOTE_WRITE |
1556 IB_ACCESS_REMOTE_READ),
1557 .pool_size = pool_size,
1558 .dirty_watermark = (pool_size * 3)/4,
1559 .flush_function = NULL,
1563 rc = ib_fmr_pool_create(kibnal_data.kib_pd, ¶ms,
1564 &kibnal_data.kib_fmr_pool);
1566 CERROR ("Can't create FMR pool size %d: %d\n",
1572 /* flag FMR pool initialised */
1573 kibnal_data.kib_init = IBNAL_INIT_FMR;
1576 /*****************************************************/
1578 rc = kibnal_setup_tx_descs();
1580 CERROR ("Can't register tx descs: %d\n", rc);
1584 /* flag TX descs initialised */
1585 kibnal_data.kib_init = IBNAL_INIT_TXD;
1586 /*****************************************************/
1590 retval = vv_cq_create(kibnal_data.kib_hca, IBNAL_CQ_ENTRIES,
1593 &kibnal_data.kib_cq, &nentries);
1595 CERROR ("Can't create RX CQ: %d\n", retval);
1599 /* flag CQ initialised */
1600 kibnal_data.kib_init = IBNAL_INIT_CQ;
1602 if (nentries < IBNAL_CQ_ENTRIES) {
1603 CERROR ("CQ only has %d entries, need %d\n",
1604 nentries, IBNAL_CQ_ENTRIES);
1608 retval = vv_request_completion_notification(kibnal_data.kib_hca, kibnal_data.kib_cq, vv_next_solicit_unsolicit_event);
1610 CERROR ("Failed to re-arm completion queue: %d\n", rc);
1615 /*****************************************************/
1617 rc = libcfs_nal_cmd_register(VIBNAL, &kibnal_cmd, NULL);
1619 CERROR ("Can't initialise command interface (rc = %d)\n", rc);
1623 /* flag everything initialised */
1624 kibnal_data.kib_init = IBNAL_INIT_ALL;
1625 /*****************************************************/
1627 printk(KERN_INFO "Lustre: Voltaire IB NAL loaded "
1628 "(initial mem %d)\n", pkmem);
1633 CDEBUG(D_NET, "kibnal_api_startup failed\n");
1634 kibnal_api_shutdown (&kibnal_api);
1639 kibnal_module_fini (void)
1641 #ifdef CONFIG_SYSCTL
1642 if (kibnal_tunables.kib_sysctl != NULL)
1643 unregister_sysctl_table (kibnal_tunables.kib_sysctl);
1645 PtlNIFini(kibnal_ni);
1647 ptl_unregister_nal(VIBNAL);
1651 kibnal_module_init (void)
1655 if (sizeof(kib_wire_connreq_t) > cm_REQ_priv_data_len) {
1656 CERROR("sizeof(kib_wire_connreq_t) > cm_REQ_priv_data_len\n");
1660 /* the following must be sizeof(int) for proc_dointvec() */
1661 if (sizeof (kibnal_tunables.kib_io_timeout) != sizeof (int)) {
1662 CERROR("sizeof (kibnal_tunables.kib_io_timeout) != sizeof (int)\n");
1666 kibnal_api.nal_ni_init = kibnal_api_startup;
1667 kibnal_api.nal_ni_fini = kibnal_api_shutdown;
1669 /* Initialise dynamic tunables to defaults once only */
1670 kibnal_tunables.kib_io_timeout = IBNAL_IO_TIMEOUT;
1672 rc = ptl_register_nal(VIBNAL, &kibnal_api);
1674 CERROR("Can't register IBNAL: %d\n", rc);
1675 return (-ENOMEM); /* or something... */
1678 /* Pure gateways want the NAL started up at module load time... */
1679 rc = PtlNIInit(VIBNAL, LUSTRE_SRV_PTL_PID, NULL, NULL, &kibnal_ni);
1680 if (rc != PTL_OK && rc != PTL_IFACE_DUP) {
1681 ptl_unregister_nal(VIBNAL);
1685 #ifdef CONFIG_SYSCTL
1686 /* Press on regardless even if registering sysctl doesn't work */
1687 kibnal_tunables.kib_sysctl =
1688 register_sysctl_table (kibnal_top_ctl_table, 0);
1693 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
1694 MODULE_DESCRIPTION("Kernel Voltaire IB NAL v0.01");
1695 MODULE_LICENSE("GPL");
1697 module_init(kibnal_module_init);
1698 module_exit(kibnal_module_fini);