![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to infiniband.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to infiniband.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 ! root 1: /* ! 2: * Copyright (C) 2007 Michael Brown <[email protected]>. ! 3: * ! 4: * This program is free software; you can redistribute it and/or ! 5: * modify it under the terms of the GNU General Public License as ! 6: * published by the Free Software Foundation; either version 2 of the ! 7: * License, or any later version. ! 8: * ! 9: * This program is distributed in the hope that it will be useful, but ! 10: * WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 12: * General Public License for more details. ! 13: * ! 14: * You should have received a copy of the GNU General Public License ! 15: * along with this program; if not, write to the Free Software ! 16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 17: */ ! 18: ! 19: FILE_LICENCE ( GPL2_OR_LATER ); ! 20: ! 21: #include <stdint.h> ! 22: #include <stdlib.h> ! 23: #include <stdio.h> ! 24: #include <string.h> ! 25: #include <unistd.h> ! 26: #include <byteswap.h> ! 27: #include <errno.h> ! 28: #include <assert.h> ! 29: #include <ipxe/list.h> ! 30: #include <ipxe/errortab.h> ! 31: #include <ipxe/if_arp.h> ! 32: #include <ipxe/netdevice.h> ! 33: #include <ipxe/iobuf.h> ! 34: #include <ipxe/process.h> ! 35: #include <ipxe/infiniband.h> ! 36: #include <ipxe/ib_mi.h> ! 37: #include <ipxe/ib_sma.h> ! 38: ! 39: /** @file ! 40: * ! 41: * Infiniband protocol ! 42: * ! 43: */ ! 44: ! 45: /** List of Infiniband devices */ ! 46: struct list_head ib_devices = LIST_HEAD_INIT ( ib_devices ); ! 47: ! 48: /** List of open Infiniband devices, in reverse order of opening */ ! 49: static struct list_head open_ib_devices = LIST_HEAD_INIT ( open_ib_devices ); ! 50: ! 51: /* Disambiguate the various possible EINPROGRESSes */ ! 52: #define EINPROGRESS_INIT __einfo_error ( EINFO_EINPROGRESS_INIT ) ! 53: #define EINFO_EINPROGRESS_INIT __einfo_uniqify \ ! 54: ( EINFO_EINPROGRESS, 0x01, "Initialising" ) ! 55: #define EINPROGRESS_ARMED __einfo_error ( EINFO_EINPROGRESS_ARMED ) ! 56: #define EINFO_EINPROGRESS_ARMED __einfo_uniqify \ ! 57: ( EINFO_EINPROGRESS, 0x02, "Armed" ) ! 58: ! 59: /** Human-readable message for the link statuses */ ! 60: struct errortab infiniband_errors[] __errortab = { ! 61: __einfo_errortab ( EINFO_EINPROGRESS_INIT ), ! 62: __einfo_errortab ( EINFO_EINPROGRESS_ARMED ), ! 63: }; ! 64: ! 65: /*************************************************************************** ! 66: * ! 67: * Completion queues ! 68: * ! 69: *************************************************************************** ! 70: */ ! 71: ! 72: /** ! 73: * Create completion queue ! 74: * ! 75: * @v ibdev Infiniband device ! 76: * @v num_cqes Number of completion queue entries ! 77: * @v op Completion queue operations ! 78: * @ret cq New completion queue ! 79: */ ! 80: struct ib_completion_queue * ! 81: ib_create_cq ( struct ib_device *ibdev, unsigned int num_cqes, ! 82: struct ib_completion_queue_operations *op ) { ! 83: struct ib_completion_queue *cq; ! 84: int rc; ! 85: ! 86: DBGC ( ibdev, "IBDEV %p creating completion queue\n", ibdev ); ! 87: ! 88: /* Allocate and initialise data structure */ ! 89: cq = zalloc ( sizeof ( *cq ) ); ! 90: if ( ! cq ) ! 91: goto err_alloc_cq; ! 92: cq->ibdev = ibdev; ! 93: list_add ( &cq->list, &ibdev->cqs ); ! 94: cq->num_cqes = num_cqes; ! 95: INIT_LIST_HEAD ( &cq->work_queues ); ! 96: cq->op = op; ! 97: ! 98: /* Perform device-specific initialisation and get CQN */ ! 99: if ( ( rc = ibdev->op->create_cq ( ibdev, cq ) ) != 0 ) { ! 100: DBGC ( ibdev, "IBDEV %p could not initialise completion " ! 101: "queue: %s\n", ibdev, strerror ( rc ) ); ! 102: goto err_dev_create_cq; ! 103: } ! 104: ! 105: DBGC ( ibdev, "IBDEV %p created %d-entry completion queue %p (%p) " ! 106: "with CQN %#lx\n", ibdev, num_cqes, cq, ! 107: ib_cq_get_drvdata ( cq ), cq->cqn ); ! 108: return cq; ! 109: ! 110: ibdev->op->destroy_cq ( ibdev, cq ); ! 111: err_dev_create_cq: ! 112: list_del ( &cq->list ); ! 113: free ( cq ); ! 114: err_alloc_cq: ! 115: return NULL; ! 116: } ! 117: ! 118: /** ! 119: * Destroy completion queue ! 120: * ! 121: * @v ibdev Infiniband device ! 122: * @v cq Completion queue ! 123: */ ! 124: void ib_destroy_cq ( struct ib_device *ibdev, ! 125: struct ib_completion_queue *cq ) { ! 126: DBGC ( ibdev, "IBDEV %p destroying completion queue %#lx\n", ! 127: ibdev, cq->cqn ); ! 128: assert ( list_empty ( &cq->work_queues ) ); ! 129: ibdev->op->destroy_cq ( ibdev, cq ); ! 130: list_del ( &cq->list ); ! 131: free ( cq ); ! 132: } ! 133: ! 134: /** ! 135: * Poll completion queue ! 136: * ! 137: * @v ibdev Infiniband device ! 138: * @v cq Completion queue ! 139: */ ! 140: void ib_poll_cq ( struct ib_device *ibdev, ! 141: struct ib_completion_queue *cq ) { ! 142: struct ib_work_queue *wq; ! 143: ! 144: /* Poll completion queue */ ! 145: ibdev->op->poll_cq ( ibdev, cq ); ! 146: ! 147: /* Refill receive work queues */ ! 148: list_for_each_entry ( wq, &cq->work_queues, list ) { ! 149: if ( ! wq->is_send ) ! 150: ib_refill_recv ( ibdev, wq->qp ); ! 151: } ! 152: } ! 153: ! 154: /*************************************************************************** ! 155: * ! 156: * Work queues ! 157: * ! 158: *************************************************************************** ! 159: */ ! 160: ! 161: /** ! 162: * Create queue pair ! 163: * ! 164: * @v ibdev Infiniband device ! 165: * @v type Queue pair type ! 166: * @v num_send_wqes Number of send work queue entries ! 167: * @v send_cq Send completion queue ! 168: * @v num_recv_wqes Number of receive work queue entries ! 169: * @v recv_cq Receive completion queue ! 170: * @ret qp Queue pair ! 171: * ! 172: * The queue pair will be left in the INIT state; you must call ! 173: * ib_modify_qp() before it is ready to use for sending and receiving. ! 174: */ ! 175: struct ib_queue_pair * ib_create_qp ( struct ib_device *ibdev, ! 176: enum ib_queue_pair_type type, ! 177: unsigned int num_send_wqes, ! 178: struct ib_completion_queue *send_cq, ! 179: unsigned int num_recv_wqes, ! 180: struct ib_completion_queue *recv_cq ) { ! 181: struct ib_queue_pair *qp; ! 182: size_t total_size; ! 183: int rc; ! 184: ! 185: DBGC ( ibdev, "IBDEV %p creating queue pair\n", ibdev ); ! 186: ! 187: /* Allocate and initialise data structure */ ! 188: total_size = ( sizeof ( *qp ) + ! 189: ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) ) + ! 190: ( num_recv_wqes * sizeof ( qp->recv.iobufs[0] ) ) ); ! 191: qp = zalloc ( total_size ); ! 192: if ( ! qp ) ! 193: goto err_alloc_qp; ! 194: qp->ibdev = ibdev; ! 195: list_add ( &qp->list, &ibdev->qps ); ! 196: qp->type = type; ! 197: qp->send.qp = qp; ! 198: qp->send.is_send = 1; ! 199: qp->send.cq = send_cq; ! 200: list_add ( &qp->send.list, &send_cq->work_queues ); ! 201: qp->send.psn = ( random() & 0xffffffUL ); ! 202: qp->send.num_wqes = num_send_wqes; ! 203: qp->send.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) ); ! 204: qp->recv.qp = qp; ! 205: qp->recv.cq = recv_cq; ! 206: list_add ( &qp->recv.list, &recv_cq->work_queues ); ! 207: qp->recv.psn = ( random() & 0xffffffUL ); ! 208: qp->recv.num_wqes = num_recv_wqes; ! 209: qp->recv.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) + ! 210: ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) )); ! 211: INIT_LIST_HEAD ( &qp->mgids ); ! 212: ! 213: /* Perform device-specific initialisation and get QPN */ ! 214: if ( ( rc = ibdev->op->create_qp ( ibdev, qp ) ) != 0 ) { ! 215: DBGC ( ibdev, "IBDEV %p could not initialise queue pair: " ! 216: "%s\n", ibdev, strerror ( rc ) ); ! 217: goto err_dev_create_qp; ! 218: } ! 219: DBGC ( ibdev, "IBDEV %p created queue pair %p (%p) with QPN %#lx\n", ! 220: ibdev, qp, ib_qp_get_drvdata ( qp ), qp->qpn ); ! 221: DBGC ( ibdev, "IBDEV %p QPN %#lx has %d send entries at [%p,%p)\n", ! 222: ibdev, qp->qpn, num_send_wqes, qp->send.iobufs, ! 223: qp->recv.iobufs ); ! 224: DBGC ( ibdev, "IBDEV %p QPN %#lx has %d receive entries at [%p,%p)\n", ! 225: ibdev, qp->qpn, num_recv_wqes, qp->recv.iobufs, ! 226: ( ( ( void * ) qp ) + total_size ) ); ! 227: ! 228: /* Calculate externally-visible QPN */ ! 229: switch ( type ) { ! 230: case IB_QPT_SMI: ! 231: qp->ext_qpn = IB_QPN_SMI; ! 232: break; ! 233: case IB_QPT_GSI: ! 234: qp->ext_qpn = IB_QPN_GSI; ! 235: break; ! 236: default: ! 237: qp->ext_qpn = qp->qpn; ! 238: break; ! 239: } ! 240: if ( qp->ext_qpn != qp->qpn ) { ! 241: DBGC ( ibdev, "IBDEV %p QPN %#lx has external QPN %#lx\n", ! 242: ibdev, qp->qpn, qp->ext_qpn ); ! 243: } ! 244: ! 245: return qp; ! 246: ! 247: ibdev->op->destroy_qp ( ibdev, qp ); ! 248: err_dev_create_qp: ! 249: list_del ( &qp->send.list ); ! 250: list_del ( &qp->recv.list ); ! 251: list_del ( &qp->list ); ! 252: free ( qp ); ! 253: err_alloc_qp: ! 254: return NULL; ! 255: } ! 256: ! 257: /** ! 258: * Modify queue pair ! 259: * ! 260: * @v ibdev Infiniband device ! 261: * @v qp Queue pair ! 262: * @v av New address vector, if applicable ! 263: * @ret rc Return status code ! 264: */ ! 265: int ib_modify_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ) { ! 266: int rc; ! 267: ! 268: DBGC ( ibdev, "IBDEV %p modifying QPN %#lx\n", ibdev, qp->qpn ); ! 269: ! 270: if ( ( rc = ibdev->op->modify_qp ( ibdev, qp ) ) != 0 ) { ! 271: DBGC ( ibdev, "IBDEV %p could not modify QPN %#lx: %s\n", ! 272: ibdev, qp->qpn, strerror ( rc ) ); ! 273: return rc; ! 274: } ! 275: ! 276: return 0; ! 277: } ! 278: ! 279: /** ! 280: * Destroy queue pair ! 281: * ! 282: * @v ibdev Infiniband device ! 283: * @v qp Queue pair ! 284: */ ! 285: void ib_destroy_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ) { ! 286: struct io_buffer *iobuf; ! 287: unsigned int i; ! 288: ! 289: DBGC ( ibdev, "IBDEV %p destroying QPN %#lx\n", ! 290: ibdev, qp->qpn ); ! 291: ! 292: assert ( list_empty ( &qp->mgids ) ); ! 293: ! 294: /* Perform device-specific destruction */ ! 295: ibdev->op->destroy_qp ( ibdev, qp ); ! 296: ! 297: /* Complete any remaining I/O buffers with errors */ ! 298: for ( i = 0 ; i < qp->send.num_wqes ; i++ ) { ! 299: if ( ( iobuf = qp->send.iobufs[i] ) != NULL ) ! 300: ib_complete_send ( ibdev, qp, iobuf, -ECANCELED ); ! 301: } ! 302: for ( i = 0 ; i < qp->recv.num_wqes ; i++ ) { ! 303: if ( ( iobuf = qp->recv.iobufs[i] ) != NULL ) { ! 304: ib_complete_recv ( ibdev, qp, NULL, iobuf, ! 305: -ECANCELED ); ! 306: } ! 307: } ! 308: ! 309: /* Remove work queues from completion queue */ ! 310: list_del ( &qp->send.list ); ! 311: list_del ( &qp->recv.list ); ! 312: ! 313: /* Free QP */ ! 314: list_del ( &qp->list ); ! 315: free ( qp ); ! 316: } ! 317: ! 318: /** ! 319: * Find queue pair by QPN ! 320: * ! 321: * @v ibdev Infiniband device ! 322: * @v qpn Queue pair number ! 323: * @ret qp Queue pair, or NULL ! 324: */ ! 325: struct ib_queue_pair * ib_find_qp_qpn ( struct ib_device *ibdev, ! 326: unsigned long qpn ) { ! 327: struct ib_queue_pair *qp; ! 328: ! 329: list_for_each_entry ( qp, &ibdev->qps, list ) { ! 330: if ( ( qpn == qp->qpn ) || ( qpn == qp->ext_qpn ) ) ! 331: return qp; ! 332: } ! 333: return NULL; ! 334: } ! 335: ! 336: /** ! 337: * Find queue pair by multicast GID ! 338: * ! 339: * @v ibdev Infiniband device ! 340: * @v gid Multicast GID ! 341: * @ret qp Queue pair, or NULL ! 342: */ ! 343: struct ib_queue_pair * ib_find_qp_mgid ( struct ib_device *ibdev, ! 344: union ib_gid *gid ) { ! 345: struct ib_queue_pair *qp; ! 346: struct ib_multicast_gid *mgid; ! 347: ! 348: list_for_each_entry ( qp, &ibdev->qps, list ) { ! 349: list_for_each_entry ( mgid, &qp->mgids, list ) { ! 350: if ( memcmp ( &mgid->gid, gid, ! 351: sizeof ( mgid->gid ) ) == 0 ) { ! 352: return qp; ! 353: } ! 354: } ! 355: } ! 356: return NULL; ! 357: } ! 358: ! 359: /** ! 360: * Find work queue belonging to completion queue ! 361: * ! 362: * @v cq Completion queue ! 363: * @v qpn Queue pair number ! 364: * @v is_send Find send work queue (rather than receive) ! 365: * @ret wq Work queue, or NULL if not found ! 366: */ ! 367: struct ib_work_queue * ib_find_wq ( struct ib_completion_queue *cq, ! 368: unsigned long qpn, int is_send ) { ! 369: struct ib_work_queue *wq; ! 370: ! 371: list_for_each_entry ( wq, &cq->work_queues, list ) { ! 372: if ( ( wq->qp->qpn == qpn ) && ( wq->is_send == is_send ) ) ! 373: return wq; ! 374: } ! 375: return NULL; ! 376: } ! 377: ! 378: /** ! 379: * Post send work queue entry ! 380: * ! 381: * @v ibdev Infiniband device ! 382: * @v qp Queue pair ! 383: * @v av Address vector ! 384: * @v iobuf I/O buffer ! 385: * @ret rc Return status code ! 386: */ ! 387: int ib_post_send ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 388: struct ib_address_vector *av, ! 389: struct io_buffer *iobuf ) { ! 390: struct ib_address_vector av_copy; ! 391: int rc; ! 392: ! 393: /* Check queue fill level */ ! 394: if ( qp->send.fill >= qp->send.num_wqes ) { ! 395: DBGC ( ibdev, "IBDEV %p QPN %#lx send queue full\n", ! 396: ibdev, qp->qpn ); ! 397: return -ENOBUFS; ! 398: } ! 399: ! 400: /* Use default address vector if none specified */ ! 401: if ( ! av ) ! 402: av = &qp->av; ! 403: ! 404: /* Make modifiable copy of address vector */ ! 405: memcpy ( &av_copy, av, sizeof ( av_copy ) ); ! 406: av = &av_copy; ! 407: ! 408: /* Fill in optional parameters in address vector */ ! 409: if ( ! av->qkey ) ! 410: av->qkey = qp->qkey; ! 411: if ( ! av->rate ) ! 412: av->rate = IB_RATE_2_5; ! 413: ! 414: /* Post to hardware */ ! 415: if ( ( rc = ibdev->op->post_send ( ibdev, qp, av, iobuf ) ) != 0 ) { ! 416: DBGC ( ibdev, "IBDEV %p QPN %#lx could not post send WQE: " ! 417: "%s\n", ibdev, qp->qpn, strerror ( rc ) ); ! 418: return rc; ! 419: } ! 420: ! 421: qp->send.fill++; ! 422: return 0; ! 423: } ! 424: ! 425: /** ! 426: * Post receive work queue entry ! 427: * ! 428: * @v ibdev Infiniband device ! 429: * @v qp Queue pair ! 430: * @v iobuf I/O buffer ! 431: * @ret rc Return status code ! 432: */ ! 433: int ib_post_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 434: struct io_buffer *iobuf ) { ! 435: int rc; ! 436: ! 437: /* Check packet length */ ! 438: if ( iob_tailroom ( iobuf ) < IB_MAX_PAYLOAD_SIZE ) { ! 439: DBGC ( ibdev, "IBDEV %p QPN %#lx wrong RX buffer size (%zd)\n", ! 440: ibdev, qp->qpn, iob_tailroom ( iobuf ) ); ! 441: return -EINVAL; ! 442: } ! 443: ! 444: /* Check queue fill level */ ! 445: if ( qp->recv.fill >= qp->recv.num_wqes ) { ! 446: DBGC ( ibdev, "IBDEV %p QPN %#lx receive queue full\n", ! 447: ibdev, qp->qpn ); ! 448: return -ENOBUFS; ! 449: } ! 450: ! 451: /* Post to hardware */ ! 452: if ( ( rc = ibdev->op->post_recv ( ibdev, qp, iobuf ) ) != 0 ) { ! 453: DBGC ( ibdev, "IBDEV %p QPN %#lx could not post receive WQE: " ! 454: "%s\n", ibdev, qp->qpn, strerror ( rc ) ); ! 455: return rc; ! 456: } ! 457: ! 458: qp->recv.fill++; ! 459: return 0; ! 460: } ! 461: ! 462: /** ! 463: * Complete send work queue entry ! 464: * ! 465: * @v ibdev Infiniband device ! 466: * @v qp Queue pair ! 467: * @v iobuf I/O buffer ! 468: * @v rc Completion status code ! 469: */ ! 470: void ib_complete_send ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 471: struct io_buffer *iobuf, int rc ) { ! 472: ! 473: if ( qp->send.cq->op->complete_send ) { ! 474: qp->send.cq->op->complete_send ( ibdev, qp, iobuf, rc ); ! 475: } else { ! 476: free_iob ( iobuf ); ! 477: } ! 478: qp->send.fill--; ! 479: } ! 480: ! 481: /** ! 482: * Complete receive work queue entry ! 483: * ! 484: * @v ibdev Infiniband device ! 485: * @v qp Queue pair ! 486: * @v av Address vector, or NULL ! 487: * @v iobuf I/O buffer ! 488: * @v rc Completion status code ! 489: */ ! 490: void ib_complete_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 491: struct ib_address_vector *av, ! 492: struct io_buffer *iobuf, int rc ) { ! 493: ! 494: if ( qp->recv.cq->op->complete_recv ) { ! 495: qp->recv.cq->op->complete_recv ( ibdev, qp, av, iobuf, rc ); ! 496: } else { ! 497: free_iob ( iobuf ); ! 498: } ! 499: qp->recv.fill--; ! 500: } ! 501: ! 502: /** ! 503: * Refill receive work queue ! 504: * ! 505: * @v ibdev Infiniband device ! 506: * @v qp Queue pair ! 507: */ ! 508: void ib_refill_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp ) { ! 509: struct io_buffer *iobuf; ! 510: int rc; ! 511: ! 512: /* Keep filling while unfilled entries remain */ ! 513: while ( qp->recv.fill < qp->recv.num_wqes ) { ! 514: ! 515: /* Allocate I/O buffer */ ! 516: iobuf = alloc_iob ( IB_MAX_PAYLOAD_SIZE ); ! 517: if ( ! iobuf ) { ! 518: /* Non-fatal; we will refill on next attempt */ ! 519: return; ! 520: } ! 521: ! 522: /* Post I/O buffer */ ! 523: if ( ( rc = ib_post_recv ( ibdev, qp, iobuf ) ) != 0 ) { ! 524: DBGC ( ibdev, "IBDEV %p could not refill: %s\n", ! 525: ibdev, strerror ( rc ) ); ! 526: free_iob ( iobuf ); ! 527: /* Give up */ ! 528: return; ! 529: } ! 530: } ! 531: } ! 532: ! 533: /*************************************************************************** ! 534: * ! 535: * Link control ! 536: * ! 537: *************************************************************************** ! 538: */ ! 539: ! 540: /** ! 541: * Get link state ! 542: * ! 543: * @v ibdev Infiniband device ! 544: * @ret rc Link status code ! 545: */ ! 546: int ib_link_rc ( struct ib_device *ibdev ) { ! 547: switch ( ibdev->port_state ) { ! 548: case IB_PORT_STATE_DOWN: return -ENOTCONN; ! 549: case IB_PORT_STATE_INIT: return -EINPROGRESS_INIT; ! 550: case IB_PORT_STATE_ARMED: return -EINPROGRESS_ARMED; ! 551: case IB_PORT_STATE_ACTIVE: return 0; ! 552: default: return -EINVAL; ! 553: } ! 554: } ! 555: ! 556: /** ! 557: * Textual representation of Infiniband link state ! 558: * ! 559: * @v ibdev Infiniband device ! 560: * @ret link_text Link state text ! 561: */ ! 562: static const char * ib_link_state_text ( struct ib_device *ibdev ) { ! 563: switch ( ibdev->port_state ) { ! 564: case IB_PORT_STATE_DOWN: return "DOWN"; ! 565: case IB_PORT_STATE_INIT: return "INIT"; ! 566: case IB_PORT_STATE_ARMED: return "ARMED"; ! 567: case IB_PORT_STATE_ACTIVE: return "ACTIVE"; ! 568: default: return "UNKNOWN"; ! 569: } ! 570: } ! 571: ! 572: /** ! 573: * Notify drivers of Infiniband device or link state change ! 574: * ! 575: * @v ibdev Infiniband device ! 576: */ ! 577: static void ib_notify ( struct ib_device *ibdev ) { ! 578: struct ib_driver *driver; ! 579: ! 580: for_each_table_entry ( driver, IB_DRIVERS ) ! 581: driver->notify ( ibdev ); ! 582: } ! 583: ! 584: /** ! 585: * Notify of Infiniband link state change ! 586: * ! 587: * @v ibdev Infiniband device ! 588: */ ! 589: void ib_link_state_changed ( struct ib_device *ibdev ) { ! 590: ! 591: DBGC ( ibdev, "IBDEV %p link state is %s\n", ! 592: ibdev, ib_link_state_text ( ibdev ) ); ! 593: ! 594: /* Notify drivers of link state change */ ! 595: ib_notify ( ibdev ); ! 596: } ! 597: ! 598: /** ! 599: * Open port ! 600: * ! 601: * @v ibdev Infiniband device ! 602: * @ret rc Return status code ! 603: */ ! 604: int ib_open ( struct ib_device *ibdev ) { ! 605: int rc; ! 606: ! 607: /* Increment device open request counter */ ! 608: if ( ibdev->open_count++ > 0 ) { ! 609: /* Device was already open; do nothing */ ! 610: return 0; ! 611: } ! 612: ! 613: /* Create subnet management interface */ ! 614: ibdev->smi = ib_create_mi ( ibdev, IB_QPT_SMI ); ! 615: if ( ! ibdev->smi ) { ! 616: DBGC ( ibdev, "IBDEV %p could not create SMI\n", ibdev ); ! 617: rc = -ENOMEM; ! 618: goto err_create_smi; ! 619: } ! 620: ! 621: /* Create subnet management agent */ ! 622: if ( ( rc = ib_create_sma ( ibdev, ibdev->smi ) ) != 0 ) { ! 623: DBGC ( ibdev, "IBDEV %p could not create SMA: %s\n", ! 624: ibdev, strerror ( rc ) ); ! 625: goto err_create_sma; ! 626: } ! 627: ! 628: /* Create general services interface */ ! 629: ibdev->gsi = ib_create_mi ( ibdev, IB_QPT_GSI ); ! 630: if ( ! ibdev->gsi ) { ! 631: DBGC ( ibdev, "IBDEV %p could not create GSI\n", ibdev ); ! 632: rc = -ENOMEM; ! 633: goto err_create_gsi; ! 634: } ! 635: ! 636: /* Open device */ ! 637: if ( ( rc = ibdev->op->open ( ibdev ) ) != 0 ) { ! 638: DBGC ( ibdev, "IBDEV %p could not open: %s\n", ! 639: ibdev, strerror ( rc ) ); ! 640: goto err_open; ! 641: } ! 642: ! 643: /* Add to head of open devices list */ ! 644: list_add ( &ibdev->open_list, &open_ib_devices ); ! 645: ! 646: /* Notify drivers of device state change */ ! 647: ib_notify ( ibdev ); ! 648: ! 649: assert ( ibdev->open_count == 1 ); ! 650: return 0; ! 651: ! 652: ibdev->op->close ( ibdev ); ! 653: err_open: ! 654: ib_destroy_mi ( ibdev, ibdev->gsi ); ! 655: err_create_gsi: ! 656: ib_destroy_sma ( ibdev, ibdev->smi ); ! 657: err_create_sma: ! 658: ib_destroy_mi ( ibdev, ibdev->smi ); ! 659: err_create_smi: ! 660: assert ( ibdev->open_count == 1 ); ! 661: ibdev->open_count = 0; ! 662: return rc; ! 663: } ! 664: ! 665: /** ! 666: * Close port ! 667: * ! 668: * @v ibdev Infiniband device ! 669: */ ! 670: void ib_close ( struct ib_device *ibdev ) { ! 671: ! 672: /* Decrement device open request counter */ ! 673: ibdev->open_count--; ! 674: ! 675: /* Close device if this was the last remaining requested opening */ ! 676: if ( ibdev->open_count == 0 ) { ! 677: ib_notify ( ibdev ); ! 678: list_del ( &ibdev->open_list ); ! 679: ib_destroy_mi ( ibdev, ibdev->gsi ); ! 680: ib_destroy_sma ( ibdev, ibdev->smi ); ! 681: ib_destroy_mi ( ibdev, ibdev->smi ); ! 682: ibdev->op->close ( ibdev ); ! 683: } ! 684: } ! 685: ! 686: /*************************************************************************** ! 687: * ! 688: * Multicast ! 689: * ! 690: *************************************************************************** ! 691: */ ! 692: ! 693: /** ! 694: * Attach to multicast group ! 695: * ! 696: * @v ibdev Infiniband device ! 697: * @v qp Queue pair ! 698: * @v gid Multicast GID ! 699: * @ret rc Return status code ! 700: * ! 701: * Note that this function handles only the local device's attachment ! 702: * to the multicast GID; it does not issue the relevant MADs to join ! 703: * the multicast group on the subnet. ! 704: */ ! 705: int ib_mcast_attach ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 706: union ib_gid *gid ) { ! 707: struct ib_multicast_gid *mgid; ! 708: int rc; ! 709: ! 710: /* Add to software multicast GID list */ ! 711: mgid = zalloc ( sizeof ( *mgid ) ); ! 712: if ( ! mgid ) { ! 713: rc = -ENOMEM; ! 714: goto err_alloc_mgid; ! 715: } ! 716: memcpy ( &mgid->gid, gid, sizeof ( mgid->gid ) ); ! 717: list_add ( &mgid->list, &qp->mgids ); ! 718: ! 719: /* Add to hardware multicast GID list */ ! 720: if ( ( rc = ibdev->op->mcast_attach ( ibdev, qp, gid ) ) != 0 ) ! 721: goto err_dev_mcast_attach; ! 722: ! 723: return 0; ! 724: ! 725: err_dev_mcast_attach: ! 726: list_del ( &mgid->list ); ! 727: free ( mgid ); ! 728: err_alloc_mgid: ! 729: return rc; ! 730: } ! 731: ! 732: /** ! 733: * Detach from multicast group ! 734: * ! 735: * @v ibdev Infiniband device ! 736: * @v qp Queue pair ! 737: * @v gid Multicast GID ! 738: */ ! 739: void ib_mcast_detach ( struct ib_device *ibdev, struct ib_queue_pair *qp, ! 740: union ib_gid *gid ) { ! 741: struct ib_multicast_gid *mgid; ! 742: ! 743: /* Remove from hardware multicast GID list */ ! 744: ibdev->op->mcast_detach ( ibdev, qp, gid ); ! 745: ! 746: /* Remove from software multicast GID list */ ! 747: list_for_each_entry ( mgid, &qp->mgids, list ) { ! 748: if ( memcmp ( &mgid->gid, gid, sizeof ( mgid->gid ) ) == 0 ) { ! 749: list_del ( &mgid->list ); ! 750: free ( mgid ); ! 751: break; ! 752: } ! 753: } ! 754: } ! 755: ! 756: /*************************************************************************** ! 757: * ! 758: * Miscellaneous ! 759: * ! 760: *************************************************************************** ! 761: */ ! 762: ! 763: /** ! 764: * Count Infiniband HCA ports ! 765: * ! 766: * @v ibdev Infiniband device ! 767: * @ret num_ports Number of ports ! 768: */ ! 769: int ib_count_ports ( struct ib_device *ibdev ) { ! 770: struct ib_device *tmp; ! 771: int num_ports = 0; ! 772: ! 773: /* Search for IB devices with the same physical device to ! 774: * identify port count. ! 775: */ ! 776: for_each_ibdev ( tmp ) { ! 777: if ( tmp->dev == ibdev->dev ) ! 778: num_ports++; ! 779: } ! 780: return num_ports; ! 781: } ! 782: ! 783: /** ! 784: * Set port information ! 785: * ! 786: * @v ibdev Infiniband device ! 787: * @v mad Set port information MAD ! 788: */ ! 789: int ib_set_port_info ( struct ib_device *ibdev, union ib_mad *mad ) { ! 790: int rc; ! 791: ! 792: /* Adapters with embedded SMAs do not need to support this method */ ! 793: if ( ! ibdev->op->set_port_info ) { ! 794: DBGC ( ibdev, "IBDEV %p does not support setting port " ! 795: "information\n", ibdev ); ! 796: return -ENOTSUP; ! 797: } ! 798: ! 799: if ( ( rc = ibdev->op->set_port_info ( ibdev, mad ) ) != 0 ) { ! 800: DBGC ( ibdev, "IBDEV %p could not set port information: %s\n", ! 801: ibdev, strerror ( rc ) ); ! 802: return rc; ! 803: } ! 804: ! 805: return 0; ! 806: }; ! 807: ! 808: /** ! 809: * Set partition key table ! 810: * ! 811: * @v ibdev Infiniband device ! 812: * @v mad Set partition key table MAD ! 813: */ ! 814: int ib_set_pkey_table ( struct ib_device *ibdev, union ib_mad *mad ) { ! 815: int rc; ! 816: ! 817: /* Adapters with embedded SMAs do not need to support this method */ ! 818: if ( ! ibdev->op->set_pkey_table ) { ! 819: DBGC ( ibdev, "IBDEV %p does not support setting partition " ! 820: "key table\n", ibdev ); ! 821: return -ENOTSUP; ! 822: } ! 823: ! 824: if ( ( rc = ibdev->op->set_pkey_table ( ibdev, mad ) ) != 0 ) { ! 825: DBGC ( ibdev, "IBDEV %p could not set partition key table: " ! 826: "%s\n", ibdev, strerror ( rc ) ); ! 827: return rc; ! 828: } ! 829: ! 830: return 0; ! 831: }; ! 832: ! 833: /*************************************************************************** ! 834: * ! 835: * Event queues ! 836: * ! 837: *************************************************************************** ! 838: */ ! 839: ! 840: /** ! 841: * Poll event queue ! 842: * ! 843: * @v ibdev Infiniband device ! 844: */ ! 845: void ib_poll_eq ( struct ib_device *ibdev ) { ! 846: struct ib_completion_queue *cq; ! 847: ! 848: /* Poll device's event queue */ ! 849: ibdev->op->poll_eq ( ibdev ); ! 850: ! 851: /* Poll all completion queues */ ! 852: list_for_each_entry ( cq, &ibdev->cqs, list ) ! 853: ib_poll_cq ( ibdev, cq ); ! 854: } ! 855: ! 856: /** ! 857: * Single-step the Infiniband event queue ! 858: * ! 859: * @v process Infiniband event queue process ! 860: */ ! 861: static void ib_step ( struct process *process __unused ) { ! 862: struct ib_device *ibdev; ! 863: ! 864: for_each_ibdev ( ibdev ) ! 865: ib_poll_eq ( ibdev ); ! 866: } ! 867: ! 868: /** Infiniband event queue process */ ! 869: struct process ib_process __permanent_process = { ! 870: .list = LIST_HEAD_INIT ( ib_process.list ), ! 871: .step = ib_step, ! 872: }; ! 873: ! 874: /*************************************************************************** ! 875: * ! 876: * Infiniband device creation/destruction ! 877: * ! 878: *************************************************************************** ! 879: */ ! 880: ! 881: /** ! 882: * Allocate Infiniband device ! 883: * ! 884: * @v priv_size Size of driver private data area ! 885: * @ret ibdev Infiniband device, or NULL ! 886: */ ! 887: struct ib_device * alloc_ibdev ( size_t priv_size ) { ! 888: struct ib_device *ibdev; ! 889: void *drv_priv; ! 890: size_t total_len; ! 891: ! 892: total_len = ( sizeof ( *ibdev ) + priv_size ); ! 893: ibdev = zalloc ( total_len ); ! 894: if ( ibdev ) { ! 895: drv_priv = ( ( ( void * ) ibdev ) + sizeof ( *ibdev ) ); ! 896: ib_set_drvdata ( ibdev, drv_priv ); ! 897: INIT_LIST_HEAD ( &ibdev->list ); ! 898: INIT_LIST_HEAD ( &ibdev->open_list ); ! 899: INIT_LIST_HEAD ( &ibdev->cqs ); ! 900: INIT_LIST_HEAD ( &ibdev->qps ); ! 901: ibdev->port_state = IB_PORT_STATE_DOWN; ! 902: ibdev->lid = IB_LID_NONE; ! 903: ibdev->pkey = IB_PKEY_DEFAULT; ! 904: } ! 905: return ibdev; ! 906: } ! 907: ! 908: /** ! 909: * Register Infiniband device ! 910: * ! 911: * @v ibdev Infiniband device ! 912: * @ret rc Return status code ! 913: */ ! 914: int register_ibdev ( struct ib_device *ibdev ) { ! 915: struct ib_driver *driver; ! 916: int rc; ! 917: ! 918: /* Add to device list */ ! 919: ibdev_get ( ibdev ); ! 920: list_add_tail ( &ibdev->list, &ib_devices ); ! 921: DBGC ( ibdev, "IBDEV %p registered (phys %s)\n", ibdev, ! 922: ibdev->dev->name ); ! 923: ! 924: /* Probe device */ ! 925: for_each_table_entry ( driver, IB_DRIVERS ) { ! 926: if ( ( rc = driver->probe ( ibdev ) ) != 0 ) { ! 927: DBGC ( ibdev, "IBDEV %p could not add %s device: %s\n", ! 928: ibdev, driver->name, strerror ( rc ) ); ! 929: goto err_probe; ! 930: } ! 931: } ! 932: ! 933: return 0; ! 934: ! 935: err_probe: ! 936: for_each_table_entry_continue_reverse ( driver, IB_DRIVERS ) ! 937: driver->remove ( ibdev ); ! 938: list_del ( &ibdev->list ); ! 939: ibdev_put ( ibdev ); ! 940: return rc; ! 941: } ! 942: ! 943: /** ! 944: * Unregister Infiniband device ! 945: * ! 946: * @v ibdev Infiniband device ! 947: */ ! 948: void unregister_ibdev ( struct ib_device *ibdev ) { ! 949: struct ib_driver *driver; ! 950: ! 951: /* Remove device */ ! 952: for_each_table_entry_reverse ( driver, IB_DRIVERS ) ! 953: driver->remove ( ibdev ); ! 954: ! 955: /* Remove from device list */ ! 956: list_del ( &ibdev->list ); ! 957: ibdev_put ( ibdev ); ! 958: DBGC ( ibdev, "IBDEV %p unregistered\n", ibdev ); ! 959: } ! 960: ! 961: /** ! 962: * Find Infiniband device by GID ! 963: * ! 964: * @v gid GID ! 965: * @ret ibdev Infiniband device, or NULL ! 966: */ ! 967: struct ib_device * find_ibdev ( union ib_gid *gid ) { ! 968: struct ib_device *ibdev; ! 969: ! 970: for_each_ibdev ( ibdev ) { ! 971: if ( memcmp ( gid, &ibdev->gid, sizeof ( *gid ) ) == 0 ) ! 972: return ibdev; ! 973: } ! 974: return NULL; ! 975: } ! 976: ! 977: /** ! 978: * Get most recently opened Infiniband device ! 979: * ! 980: * @ret ibdev Most recently opened Infiniband device, or NULL ! 981: */ ! 982: struct ib_device * last_opened_ibdev ( void ) { ! 983: struct ib_device *ibdev; ! 984: ! 985: ibdev = list_first_entry ( &open_ib_devices, struct ib_device, ! 986: open_list ); ! 987: if ( ! ibdev ) ! 988: return NULL; ! 989: ! 990: assert ( ibdev->open_count != 0 ); ! 991: return ibdev; ! 992: } ! 993: ! 994: /* Drag in IPoIB */ ! 995: REQUIRE_OBJECT ( ipoib );
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.