Cleaned up some debug messages.
[people/xl0/gpxe.git] / src / drivers / net / ipoib.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
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 #include <stdint.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <byteswap.h>
23 #include <errno.h>
24 #include <gpxe/if_arp.h>
25 #include <gpxe/iobuf.h>
26 #include <gpxe/netdevice.h>
27 #include <gpxe/infiniband.h>
28 #include <gpxe/ipoib.h>
29
30 /** @file
31  *
32  * IP over Infiniband
33  */
34
35
36
37
38
39 extern unsigned long hack_ipoib_qkey;
40 extern struct ib_address_vector hack_ipoib_bcast_av;
41
42
43
44 /** IPoIB MTU */
45 #define IPOIB_MTU 2048
46
47 /** Number of IPoIB data send work queue entries */
48 #define IPOIB_DATA_NUM_SEND_WQES 4
49
50 /** Number of IPoIB data receive work queue entries */
51 #define IPOIB_DATA_NUM_RECV_WQES 4
52
53 /** Number of IPoIB data completion entries */
54 #define IPOIB_DATA_NUM_CQES 8
55
56 /** Number of IPoIB metadata send work queue entries */
57 #define IPOIB_META_NUM_SEND_WQES 4
58
59 /** Number of IPoIB metadata receive work queue entries */
60 #define IPOIB_META_NUM_RECV_WQES 4
61
62 /** Number of IPoIB metadata completion entries */
63 #define IPOIB_META_NUM_CQES 8
64
65 /** An IPoIB queue set */
66 struct ipoib_queue_set {
67         /** Completion queue */
68         struct ib_completion_queue *cq;
69         /** Queue pair */
70         struct ib_queue_pair *qp;
71         /** Receive work queue fill level */
72         unsigned int recv_fill;
73         /** Receive work queue maximum fill level */
74         unsigned int recv_max_fill;
75 };
76
77 /** An IPoIB device */
78 struct ipoib_device {
79         /** Network device */
80         struct net_device *netdev;
81         /** Underlying Infiniband device */
82         struct ib_device *ibdev;
83         /** Data queue set */
84         struct ipoib_queue_set data;
85         /** Data queue set */
86         struct ipoib_queue_set meta;
87 };
88
89 /**
90  * IPoIB path cache entry
91  *
92  * This serves a similar role to the ARP cache for Ethernet.  (ARP
93  * *is* used on IPoIB; we have two caches to maintain.)
94  */
95 struct ipoib_cached_path {
96         /** Destination GID */
97         struct ib_gid gid;
98         /** Destination LID */
99         unsigned int dlid;
100         /** Service level */
101         unsigned int sl;
102         /** Rate */
103         unsigned int rate;
104 };
105
106 /** Number of IPoIB path cache entries */
107 #define IPOIB_NUM_CACHED_PATHS 2
108
109 /** IPoIB path cache */
110 static struct ipoib_cached_path ipoib_path_cache[IPOIB_NUM_CACHED_PATHS];
111
112 /** Oldest IPoIB path cache entry index */
113 static unsigned int ipoib_path_cache_idx = 0;
114
115 /****************************************************************************
116  *
117  * IPoIB link layer
118  *
119  ****************************************************************************
120  */
121
122 /** Broadcast QPN used in IPoIB MAC addresses
123  *
124  * This is a guaranteed invalid real QPN
125  */
126 #define IPOIB_BROADCAST_QPN 0xffffffffUL
127
128 /** Broadcast IPoIB address */
129 static struct ipoib_mac ipoib_broadcast = {
130         .qpn = ntohl ( IPOIB_BROADCAST_QPN ),
131 };
132
133 /**
134  * Transmit IPoIB packet
135  *
136  * @v iobuf             I/O buffer
137  * @v netdev            Network device
138  * @v net_protocol      Network-layer protocol
139  * @v ll_dest           Link-layer destination address
140  *
141  * Prepends the IPoIB link-layer header and transmits the packet.
142  */
143 static int ipoib_tx ( struct io_buffer *iobuf, struct net_device *netdev,
144                       struct net_protocol *net_protocol,
145                       const void *ll_dest ) {
146         struct ipoib_hdr *ipoib_hdr =
147                 iob_push ( iobuf, sizeof ( *ipoib_hdr ) );
148
149         /* Build IPoIB header */
150         memcpy ( &ipoib_hdr->pseudo.peer, ll_dest,
151                  sizeof ( ipoib_hdr->pseudo.peer ) );
152         ipoib_hdr->real.proto = net_protocol->net_proto;
153         ipoib_hdr->real.reserved = 0;
154
155         /* Hand off to network device */
156         return netdev_tx ( netdev, iobuf );
157 }
158
159 /**
160  * Process received IPoIB packet
161  *
162  * @v iobuf     I/O buffer
163  * @v netdev    Network device
164  *
165  * Strips off the IPoIB link-layer header and passes up to the
166  * network-layer protocol.
167  */
168 static int ipoib_rx ( struct io_buffer *iobuf, struct net_device *netdev ) {
169         struct ipoib_hdr *ipoib_hdr = iobuf->data;
170
171         /* Sanity check */
172         if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
173                 DBG ( "IPoIB packet too short (%d bytes)\n",
174                       iob_len ( iobuf ) );
175                 free_iob ( iobuf );
176                 return -EINVAL;
177         }
178
179         /* Strip off IPoIB header */
180         iob_pull ( iobuf, sizeof ( *ipoib_hdr ) );
181
182         /* Hand off to network-layer protocol */
183         return net_rx ( iobuf, netdev, ipoib_hdr->real.proto,
184                         &ipoib_hdr->pseudo.peer );
185 }
186
187 /**
188  * Transcribe IPoIB address
189  *
190  * @v ll_addr   Link-layer address
191  * @ret string  Link-layer address in human-readable format
192  */
193 const char * ipoib_ntoa ( const void *ll_addr ) {
194         static char buf[45];
195         const struct ipoib_mac *mac = ll_addr;
196
197         snprintf ( buf, sizeof ( buf ), "%08lx:%08lx:%08lx:%08lx:%08lx",
198                    htonl ( mac->qpn ), htonl ( mac->gid.u.dwords[0] ),
199                    htonl ( mac->gid.u.dwords[1] ),
200                    htonl ( mac->gid.u.dwords[2] ),
201                    htonl ( mac->gid.u.dwords[3] ) );
202         return buf;
203 }
204
205 /** IPoIB protocol */
206 struct ll_protocol ipoib_protocol __ll_protocol = {
207         .name           = "IPoIB",
208         .ll_proto       = htons ( ARPHRD_INFINIBAND ),
209         .ll_addr_len    = IPOIB_ALEN,
210         .ll_header_len  = IPOIB_HLEN,
211         .ll_broadcast   = ( uint8_t * ) &ipoib_broadcast,
212         .tx             = ipoib_tx,
213         .rx             = ipoib_rx,
214         .ntoa           = ipoib_ntoa,
215 };
216
217 /****************************************************************************
218  *
219  * IPoIB network device
220  *
221  ****************************************************************************
222  */
223
224 /**
225  * Destroy queue set
226  *
227  * @v ipoib             IPoIB device
228  * @v qset              Queue set
229  */
230 static void ipoib_destroy_qset ( struct ipoib_device *ipoib,
231                                  struct ipoib_queue_set *qset ) {
232         struct ib_device *ibdev = ipoib->ibdev;
233
234         if ( qset->qp )
235                 ib_destroy_qp ( ibdev, qset->qp );
236         if ( qset->cq )
237                 ib_destroy_cq ( ibdev, qset->cq );
238         memset ( qset, 0, sizeof ( *qset ) );
239 }
240
241 /**
242  * Create queue set
243  *
244  * @v ipoib             IPoIB device
245  * @v qset              Queue set
246  * @ret rc              Return status code
247  */
248 static int ipoib_create_qset ( struct ipoib_device *ipoib,
249                                struct ipoib_queue_set *qset,
250                                unsigned int num_cqes,
251                                unsigned int num_send_wqes,
252                                unsigned int num_recv_wqes,
253                                unsigned long qkey ) {
254         struct ib_device *ibdev = ipoib->ibdev;
255         int rc;
256
257         /* Store queue parameters */
258         qset->recv_max_fill = num_recv_wqes;
259
260         /* Allocate completion queue */
261         qset->cq = ib_create_cq ( ibdev, num_cqes );
262         if ( ! qset->cq ) {
263                 DBGC ( ipoib, "IPoIB %p could not allocate completion queue\n",
264                        ipoib );
265                 rc = -ENOMEM;
266                 goto err;
267         }
268
269         /* Allocate queue pair */
270         qset->qp = ib_create_qp ( ibdev, num_send_wqes, qset->cq,
271                                   num_recv_wqes, qset->cq, qkey );
272         if ( ! qset->qp ) {
273                 DBGC ( ipoib, "IPoIB %p could not allocate queue pair\n",
274                        ipoib );
275                 rc = -ENOMEM;
276                 goto err;
277         }
278         qset->qp->owner_priv = ipoib->netdev;
279
280         return 0;
281
282  err:
283         ipoib_destroy_qset ( ipoib, qset );
284         return rc;
285 }
286
287 /**
288  * Find path cache entry by GID
289  *
290  * @v gid               GID
291  * @ret entry           Path cache entry, or NULL
292  */
293 static struct ipoib_cached_path *
294 ipoib_find_cached_path ( struct ib_gid *gid ) {
295         struct ipoib_cached_path *path;
296         unsigned int i;
297
298         for ( i = 0 ; i < IPOIB_NUM_CACHED_PATHS ; i++ ) {
299                 path = &ipoib_path_cache[i];
300                 if ( memcmp ( &path->gid, gid, sizeof ( *gid ) ) == 0 )
301                         return path;
302         }
303         DBG ( "IPoIB %08lx:%08lx:%08lx:%08lx cache miss\n",
304               htonl ( gid->u.dwords[0] ), htonl ( gid->u.dwords[1] ),
305               htonl ( gid->u.dwords[2] ), htonl ( gid->u.dwords[3] ) );
306         return NULL;
307 }
308
309 /**
310  * Transmit path record request
311  *
312  * @v ipoib             IPoIB device
313  * @v gid               Destination GID
314  * @ret rc              Return status code
315  */
316 static int ipoib_get_path_record ( struct ipoib_device *ipoib,
317                                    struct ib_gid *gid ) {
318         struct ib_device *ibdev = ipoib->ibdev;
319         struct io_buffer *iobuf;
320         struct ib_mad_path_record *path_record;
321         struct ib_address_vector av;
322         static uint32_t tid = 0;
323         int rc;
324
325         /* Allocate I/O buffer */
326         iobuf = alloc_iob ( sizeof ( *path_record ) );
327         if ( ! iobuf )
328                 return -ENOMEM;
329         iob_put ( iobuf, sizeof ( *path_record ) );
330         path_record = iobuf->data;
331         memset ( path_record, 0, sizeof ( *path_record ) );
332
333         /* Construct path record request */
334         path_record->mad_hdr.base_version = IB_MGMT_BASE_VERSION;
335         path_record->mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
336         path_record->mad_hdr.class_version = 2;
337         path_record->mad_hdr.method = IB_MGMT_METHOD_GET;
338         path_record->mad_hdr.attr_id = htons ( IB_SA_ATTR_PATH_REC );
339         path_record->mad_hdr.tid = tid++;
340         path_record->sa_hdr.comp_mask[1] =
341                 htonl ( IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID );
342         memcpy ( &path_record->dgid, gid, sizeof ( path_record->dgid ) );
343         memcpy ( &path_record->sgid, &ibdev->port_gid,
344                  sizeof ( path_record->sgid ) );
345
346         /* Construct address vector */
347         memset ( &av, 0, sizeof ( av ) );
348         av.dlid = ibdev->sm_lid;
349         av.dest_qp = IB_SA_QPN;
350         av.qkey = IB_GLOBAL_QKEY;
351
352         /* Post send request */
353         if ( ( rc = ib_post_send ( ibdev, ipoib->meta.qp, &av,
354                                    iobuf ) ) != 0 ) {
355                 DBGC ( ipoib, "IPoIB %p could not send get path record: %s\n",
356                        ipoib, strerror ( rc ) );
357                 free_iob ( iobuf );
358                 return rc;
359         }
360
361         return 0;
362 }
363
364 /**
365  * Transmit packet via IPoIB network device
366  *
367  * @v netdev            Network device
368  * @v iobuf             I/O buffer
369  * @ret rc              Return status code
370  */
371 static int ipoib_transmit ( struct net_device *netdev,
372                             struct io_buffer *iobuf ) {
373         struct ipoib_device *ipoib = netdev->priv;
374         struct ib_device *ibdev = ipoib->ibdev;
375         struct ipoib_pseudo_hdr *ipoib_pshdr = iobuf->data;
376         struct ib_address_vector av;
377         struct ipoib_cached_path *path;
378         int rc;
379
380         if ( iob_len ( iobuf ) < sizeof ( *ipoib_pshdr ) ) {
381                 DBGC ( ipoib, "IPoIB %p buffer too short\n", ipoib );
382                 return -EINVAL;
383         }
384
385         /* Construct address vector */
386         memset ( &av, 0, sizeof ( av ) );
387         if ( ipoib_pshdr->peer.qpn == htonl ( IPOIB_BROADCAST_QPN ) ) {
388                 /* Broadcast address */
389                 memcpy ( &av, &hack_ipoib_bcast_av, sizeof ( av ) );
390         } else {
391                 /* Unicast - look in path cache */
392                 path = ipoib_find_cached_path ( &ipoib_pshdr->peer.gid );
393                 if ( ! path ) {
394                         /* No path entry - get path record */
395                         rc = ipoib_get_path_record ( ipoib,
396                                                      &ipoib_pshdr->peer.gid );
397                         free_iob ( iobuf );
398                         return rc;
399                 }
400                 av.dest_qp = ntohl ( ipoib_pshdr->peer.qpn );
401                 av.qkey = IB_GLOBAL_QKEY;
402                 av.dlid = path->dlid;
403                 av.rate = path->rate;
404                 av.sl = path->sl;
405                 av.gid_present = 1;
406                 memcpy ( &av.gid, &ipoib_pshdr->peer.gid, sizeof ( av.gid ) );
407         }
408
409         iob_pull ( iobuf, ( sizeof ( *ipoib_pshdr ) ) );
410         return ib_post_send ( ibdev, ipoib->data.qp, &av, iobuf );
411 }
412
413 /**
414  * Handle IPoIB data send completion
415  *
416  * @v ibdev             Infiniband device
417  * @v qp                Queue pair
418  * @v completion        Completion
419  * @v iobuf             I/O buffer
420  */
421 static void ipoib_data_complete_send ( struct ib_device *ibdev __unused,
422                                        struct ib_queue_pair *qp,
423                                        struct ib_completion *completion,
424                                        struct io_buffer *iobuf ) {
425         struct net_device *netdev = qp->owner_priv;
426
427         netdev_tx_complete_err ( netdev, iobuf,
428                                  ( completion->syndrome ? -EIO : 0 ) );
429 }
430
431 /**
432  * Handle IPoIB data receive completion
433  *
434  * @v ibdev             Infiniband device
435  * @v qp                Queue pair
436  * @v completion        Completion
437  * @v iobuf             I/O buffer
438  */
439 static void ipoib_data_complete_recv ( struct ib_device *ibdev __unused,
440                                        struct ib_queue_pair *qp,
441                                        struct ib_completion *completion,
442                                        struct io_buffer *iobuf ) {
443         struct net_device *netdev = qp->owner_priv;
444         struct ipoib_device *ipoib = netdev->priv;
445         struct ipoib_pseudo_hdr *ipoib_pshdr;
446
447         if ( completion->syndrome ) {
448                 netdev_rx_err ( netdev, iobuf, -EIO );
449         } else {
450                 iob_put ( iobuf, completion->len );
451                 iob_pull ( iobuf, ( sizeof ( struct ib_global_route_header ) -
452                                     sizeof ( *ipoib_pshdr ) ) );
453                 /* FIXME: fill in a MAC address for the sake of AoE! */
454                 netdev_rx ( netdev, iobuf );
455         }
456
457         ipoib->data.recv_fill--;
458 }
459
460 /**
461  * Handle IPoIB metadata send completion
462  *
463  * @v ibdev             Infiniband device
464  * @v qp                Queue pair
465  * @v completion        Completion
466  * @v iobuf             I/O buffer
467  */
468 static void ipoib_meta_complete_send ( struct ib_device *ibdev __unused,
469                                        struct ib_queue_pair *qp,
470                                        struct ib_completion *completion,
471                                        struct io_buffer *iobuf ) {
472         struct net_device *netdev = qp->owner_priv;
473         struct ipoib_device *ipoib = netdev->priv;
474
475         if ( completion->syndrome ) {
476                 DBGC ( ipoib, "IPoIB %p metadata TX completion error %x\n",
477                        ipoib, completion->syndrome );
478         }
479         free_iob ( iobuf );
480 }
481
482 /**
483  * Handle IPoIB metadata receive completion
484  *
485  * @v ibdev             Infiniband device
486  * @v qp                Queue pair
487  * @v completion        Completion
488  * @v iobuf             I/O buffer
489  */
490 static void ipoib_meta_complete_recv ( struct ib_device *ibdev __unused,
491                                        struct ib_queue_pair *qp,
492                                        struct ib_completion *completion,
493                                        struct io_buffer *iobuf ) {
494         struct net_device *netdev = qp->owner_priv;
495         struct ipoib_device *ipoib = netdev->priv;
496         struct ib_mad_path_record *path_record;
497         struct ipoib_cached_path *path;
498
499         if ( completion->syndrome ) {
500                 DBGC ( ipoib, "IPoIB %p metadata RX completion error %x\n",
501                        ipoib, completion->syndrome );
502         } else {
503                 /* Update path cache */
504                 iob_put ( iobuf, completion->len );
505                 iob_pull ( iobuf, sizeof ( struct ib_global_route_header ) );
506                 path_record = iobuf->data;
507                 path = &ipoib_path_cache[ipoib_path_cache_idx];
508                 memcpy ( &path->gid, &path_record->dgid,
509                          sizeof ( path->gid ) );
510                 path->dlid = ntohs ( path_record->dlid );
511                 path->sl = ( path_record->reserved__sl & 0x0f );
512                 path->rate = ( path_record->rate_selector__rate & 0x3f );
513                 DBG ( "IPoIB %08lx:%08lx:%08lx:%08lx dlid %x sl %x rate %x\n",
514                       htonl ( path->gid.u.dwords[0] ),
515                       htonl ( path->gid.u.dwords[1] ),
516                       htonl ( path->gid.u.dwords[2] ),
517                       htonl ( path->gid.u.dwords[3] ),
518                       path->dlid, path->sl, path->rate );
519
520                 /* Update path cache index */
521                 ipoib_path_cache_idx++;
522                 if ( ipoib_path_cache_idx == IPOIB_NUM_CACHED_PATHS )
523                         ipoib_path_cache_idx = 0;
524         }
525
526         ipoib->meta.recv_fill--;
527         free_iob ( iobuf );
528 }
529
530 /**
531  * Refill IPoIB receive ring
532  *
533  * @v ipoib             IPoIB device
534  */
535 static void ipoib_refill_recv ( struct ipoib_device *ipoib,
536                                 struct ipoib_queue_set *qset ) {
537         struct ib_device *ibdev = ipoib->ibdev;
538         struct io_buffer *iobuf;
539         int rc;
540
541         while ( qset->recv_fill < qset->recv_max_fill ) {
542                 iobuf = alloc_iob ( IPOIB_MTU );
543                 if ( ! iobuf )
544                         break;
545                 if ( ( rc = ib_post_recv ( ibdev, qset->qp, iobuf ) ) != 0 ) {
546                         free_iob ( iobuf );
547                         break;
548                 }
549                 qset->recv_fill++;
550         }
551 }
552
553 /**
554  * Poll IPoIB network device
555  *
556  * @v netdev            Network device
557  */
558 static void ipoib_poll ( struct net_device *netdev ) {
559         struct ipoib_device *ipoib = netdev->priv;
560         struct ib_device *ibdev = ipoib->ibdev;
561
562         ib_poll_cq ( ibdev, ipoib->data.cq, ipoib_data_complete_send,
563                      ipoib_data_complete_recv );
564         ib_poll_cq ( ibdev, ipoib->meta.cq, ipoib_meta_complete_send,
565                      ipoib_meta_complete_recv );
566         ipoib_refill_recv ( ipoib, &ipoib->meta );
567         ipoib_refill_recv ( ipoib, &ipoib->data );
568 }
569
570 /**
571  * Enable/disable interrupts on IPoIB network device
572  *
573  * @v netdev            Network device
574  * @v enable            Interrupts should be enabled
575  */
576 static void ipoib_irq ( struct net_device *netdev __unused,
577                         int enable __unused ) {
578         /* No implementation */
579 }
580
581 /**
582  * Open IPoIB network device
583  *
584  * @v netdev            Network device
585  * @ret rc              Return status code
586  */
587 static int ipoib_open ( struct net_device *netdev ) {
588         struct ipoib_device *ipoib = netdev->priv;
589         struct ib_device *ibdev = ipoib->ibdev;
590         int rc;
591
592         /* Attach to broadcast multicast GID */
593         if ( ( rc = ib_mcast_attach ( ibdev, ipoib->data.qp,
594                                       &ibdev->broadcast_gid ) ) != 0 ) {
595                 DBG ( "Could not attach to broadcast GID: %s\n",
596                       strerror ( rc ) );
597                 return rc;
598         }
599
600         /* Fill receive rings */
601         ipoib_refill_recv ( ipoib, &ipoib->meta );
602         ipoib_refill_recv ( ipoib, &ipoib->data );
603
604         return 0;
605 }
606
607 /**
608  * Close IPoIB network device
609  *
610  * @v netdev            Network device
611  */
612 static void ipoib_close ( struct net_device *netdev ) {
613         struct ipoib_device *ipoib = netdev->priv;
614         struct ib_device *ibdev = ipoib->ibdev;
615
616         /* Detach from broadcast multicast GID */
617         ib_mcast_detach ( ibdev, ipoib->data.qp, &ipoib_broadcast.gid );
618
619         /* FIXME: should probably flush the receive ring */
620 }
621
622 /** IPoIB network device operations */
623 static struct net_device_operations ipoib_operations = {
624         .open           = ipoib_open,
625         .close          = ipoib_close,
626         .transmit       = ipoib_transmit,
627         .poll           = ipoib_poll,
628         .irq            = ipoib_irq,
629 };
630
631 /**
632  * Probe IPoIB device
633  *
634  * @v ibdev             Infiniband device
635  * @ret rc              Return status code
636  */
637 int ipoib_probe ( struct ib_device *ibdev ) {
638         struct net_device *netdev;
639         struct ipoib_device *ipoib;
640         struct ipoib_mac *mac;
641         int rc;
642
643         /* Allocate network device */
644         netdev = alloc_ipoibdev ( sizeof ( *ipoib ) );
645         if ( ! netdev )
646                 return -ENOMEM;
647         netdev_init ( netdev, &ipoib_operations );
648         ipoib = netdev->priv;
649         ib_set_ownerdata ( ibdev, netdev );
650         netdev->dev = ibdev->dev;
651         memset ( ipoib, 0, sizeof ( *ipoib ) );
652         ipoib->netdev = netdev;
653         ipoib->ibdev = ibdev;
654
655         /* Allocate metadata queue set */
656         if ( ( rc = ipoib_create_qset ( ipoib, &ipoib->meta,
657                                         IPOIB_META_NUM_CQES,
658                                         IPOIB_META_NUM_SEND_WQES,
659                                         IPOIB_META_NUM_RECV_WQES,
660                                         IB_GLOBAL_QKEY ) ) != 0 ) {
661                 DBGC ( ipoib, "IPoIB %p could not allocate metadata QP: %s\n",
662                        ipoib, strerror ( rc ) );
663                 goto err_create_meta_qset;
664         }
665
666         /* Allocate data queue set */
667         if ( ( rc = ipoib_create_qset ( ipoib, &ipoib->data,
668                                         IPOIB_DATA_NUM_CQES,
669                                         IPOIB_DATA_NUM_SEND_WQES,
670                                         IPOIB_DATA_NUM_RECV_WQES,
671                                         hack_ipoib_qkey ) ) != 0 ) {
672                 DBGC ( ipoib, "IPoIB %p could not allocate data QP: %s\n",
673                        ipoib, strerror ( rc ) );
674                 goto err_create_data_qset;
675         }
676
677         /* Construct MAC address */
678         mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
679         mac->qpn = htonl ( ipoib->data.qp->qpn );
680         memcpy ( &mac->gid, &ibdev->port_gid, sizeof ( mac->gid ) );
681
682         /* Register network device */
683         if ( ( rc = register_netdev ( netdev ) ) != 0 )
684                 goto err_register_netdev;
685
686         return 0;
687
688  err_register_netdev:
689         ipoib_destroy_qset ( ipoib, &ipoib->data );
690  err_create_data_qset:
691         ipoib_destroy_qset ( ipoib, &ipoib->meta );
692  err_create_meta_qset:
693         netdev_nullify ( netdev );
694         netdev_put ( netdev );
695         return rc;
696 }
697
698 /**
699  * Remove IPoIB device
700  *
701  * @v ibdev             Infiniband device
702  */
703 void ipoib_remove ( struct ib_device *ibdev ) {
704         struct net_device *netdev = ib_get_ownerdata ( ibdev );
705         struct ipoib_device *ipoib = netdev->priv;
706
707         unregister_netdev ( netdev );
708         ipoib_destroy_qset ( ipoib, &ipoib->data );
709         ipoib_destroy_qset ( ipoib, &ipoib->meta );
710         netdev_nullify ( netdev );
711         netdev_put ( netdev );
712 }