[infiniband] Update subnet management agent to use a management interface
[people/peper/gpxe.git] / src / net / infiniband / ib_gma.c
1 /*
2  * Copyright (C) 2009 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 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <unistd.h>
27 #include <byteswap.h>
28 #include <gpxe/infiniband.h>
29 #include <gpxe/iobuf.h>
30 #include <gpxe/ib_gma.h>
31
32 /**
33  * @file
34  *
35  * Infiniband General Management Agent
36  *
37  */
38
39 /** A MAD request */
40 struct ib_mad_request {
41         /** Associated GMA */
42         struct ib_gma *gma;
43         /** List of outstanding MAD requests */
44         struct list_head list;
45         /** Retry timer */
46         struct retry_timer timer;
47         /** Destination address */
48         struct ib_address_vector av;
49         /** MAD request */
50         union ib_mad mad;
51 };
52
53 /** GMA number of send WQEs
54  *
55  * This is a policy decision.
56  */
57 #define IB_GMA_NUM_SEND_WQES 4
58
59 /** GMA number of receive WQEs
60  *
61  * This is a policy decision.
62  */
63 #define IB_GMA_NUM_RECV_WQES 2
64
65 /** GMA number of completion queue entries
66  *
67  * This is a policy decision
68  */
69 #define IB_GMA_NUM_CQES 8
70
71 /** TID magic signature */
72 #define IB_GMA_TID_MAGIC ( ( 'g' << 24 ) | ( 'P' << 16 ) | ( 'X' << 8 ) | 'E' )
73
74 /** TID to use for next MAD request */
75 static unsigned int next_request_tid;
76
77 /*****************************************************************************
78  *
79  * General management agent
80  *
81  *****************************************************************************
82  */
83
84 /**
85  * Call attribute handler
86  *
87  * @v gma               General management agent
88  * @v mad               MAD
89  * @ret mad             MAD response
90  */
91 static union ib_mad * ib_handle_mad ( struct ib_gma *gma, union ib_mad *mad ) {
92         struct ib_mad_hdr *hdr = &mad->hdr;
93         struct ib_gma_handler *handler;
94
95         for_each_table_entry ( handler, IB_GMA_HANDLERS ) {
96                 if ( ( ( handler->mgmt_class & ~handler->mgmt_class_ignore ) ==
97                        ( hdr->mgmt_class & ~handler->mgmt_class_ignore ) ) &&
98                      ( handler->class_version == hdr->class_version ) &&
99                      ( handler->method == hdr->method ) &&
100                      ( handler->attr_id == hdr->attr_id ) ) {
101                         return handler->handle ( gma, mad );
102                 }
103         }
104
105         hdr->method = IB_MGMT_METHOD_TRAP;
106         hdr->status = htons ( IB_MGMT_STATUS_UNSUPPORTED_METHOD_ATTR );
107         return mad;
108 }
109
110 /**
111  * Complete GMA receive
112  *
113  *
114  * @v ibdev             Infiniband device
115  * @v qp                Queue pair
116  * @v av                Address vector
117  * @v iobuf             I/O buffer
118  * @v rc                Completion status code
119  */
120 static void ib_gma_complete_recv ( struct ib_device *ibdev,
121                                    struct ib_queue_pair *qp,
122                                    struct ib_address_vector *av,
123                                    struct io_buffer *iobuf, int rc ) {
124         struct ib_gma *gma = ib_qp_get_ownerdata ( qp );
125         struct ib_mad_request *request;
126         union ib_mad *mad;
127         struct ib_mad_hdr *hdr;
128         union ib_mad *response;
129
130         /* Ignore errors */
131         if ( rc != 0 ) {
132                 DBGC ( gma, "GMA %p RX error: %s\n", gma, strerror ( rc ) );
133                 goto out;
134         }
135
136         /* Sanity checks */
137         if ( iob_len ( iobuf ) != sizeof ( *mad ) ) {
138                 DBGC ( gma, "GMA %p RX bad size (%zd bytes)\n",
139                        gma, iob_len ( iobuf ) );
140                 DBGC_HDA ( gma, 0, iobuf->data, iob_len ( iobuf ) );
141                 goto out;
142         }
143         mad = iobuf->data;
144         hdr = &mad->hdr;
145         if ( hdr->base_version != IB_MGMT_BASE_VERSION ) {
146                 DBGC ( gma, "GMA %p unsupported base version %x\n",
147                        gma, hdr->base_version );
148                 DBGC_HDA ( gma, 0, mad, sizeof ( *mad ) );
149                 goto out;
150         }
151         DBGC ( gma, "GMA %p RX TID %08x%08x (%02x,%02x,%02x,%04x) status "
152                "%04x\n", gma, ntohl ( hdr->tid[0] ), ntohl ( hdr->tid[1] ),
153                hdr->mgmt_class, hdr->class_version, hdr->method,
154                ntohs ( hdr->attr_id ), ntohs ( hdr->status ) );
155         DBGC2_HDA ( gma, 0, mad, sizeof ( *mad ) );
156
157         /* Dequeue request if applicable */
158         list_for_each_entry ( request, &gma->requests, list ) {
159                 if ( memcmp ( &request->mad.hdr.tid, &hdr->tid,
160                               sizeof ( request->mad.hdr.tid ) ) == 0 ) {
161                         stop_timer ( &request->timer );
162                         list_del ( &request->list );
163                         free ( request );
164                         break;
165                 }
166         }
167
168         /* Handle MAD */
169         if ( ( response = ib_handle_mad ( gma, mad ) ) == NULL )
170                 goto out;
171
172         /* Re-use I/O buffer for response */
173         memcpy ( mad, response, sizeof ( *mad ) );
174         DBGC ( gma, "GMA %p TX TID %08x%08x (%02x,%02x,%02x,%04x) status "
175                "%04x\n", gma, ntohl ( hdr->tid[0] ), ntohl ( hdr->tid[1] ),
176                hdr->mgmt_class, hdr->class_version, hdr->method,
177                ntohs ( hdr->attr_id ), ntohs ( hdr->status ) );
178         DBGC2_HDA ( gma, 0, mad, sizeof ( *mad ) );
179
180         /* Send MAD response, if applicable */
181         if ( ( rc = ib_post_send ( ibdev, qp, av,
182                                    iob_disown ( iobuf ) ) ) != 0 ) {
183                 DBGC ( gma, "GMA %p could not send MAD response: %s\n",
184                        gma, strerror ( rc ) );
185                 goto out;
186         }
187
188  out:
189         free_iob ( iobuf );
190 }
191
192 /** GMA completion operations */
193 static struct ib_completion_queue_operations ib_gma_completion_ops = {
194         .complete_recv = ib_gma_complete_recv,
195 };
196
197 /**
198  * Transmit MAD request
199  *
200  * @v gma               General management agent
201  * @v request           MAD request
202  * @ret rc              Return status code
203  */
204 static int ib_gma_send ( struct ib_gma *gma, struct ib_mad_request *request ) {
205         struct io_buffer *iobuf;
206         int rc;
207
208         DBGC ( gma, "GMA %p TX TID %08x%08x (%02x,%02x,%02x,%04x)\n",
209                gma, ntohl ( request->mad.hdr.tid[0] ),
210                ntohl ( request->mad.hdr.tid[1] ), request->mad.hdr.mgmt_class,
211                request->mad.hdr.class_version, request->mad.hdr.method,
212                ntohs ( request->mad.hdr.attr_id ) );
213         DBGC2_HDA ( gma, 0, &request->mad, sizeof ( request->mad ) );
214
215         /* Construct I/O buffer */
216         iobuf = alloc_iob ( sizeof ( request->mad ) );
217         if ( ! iobuf ) {
218                 DBGC ( gma, "GMA %p could not allocate buffer for TID "
219                        "%08x%08x\n", gma, ntohl ( request->mad.hdr.tid[0] ),
220                        ntohl ( request->mad.hdr.tid[1] ) );
221                 return -ENOMEM;
222         }
223         memcpy ( iob_put ( iobuf, sizeof ( request->mad ) ), &request->mad,
224                  sizeof ( request->mad ) );
225
226         /* Send I/O buffer */
227         if ( ( rc = ib_post_send ( gma->ibdev, gma->qp, &request->av,
228                                    iobuf ) ) != 0 ) {
229                 DBGC ( gma, "GMA %p could not send TID %08x%08x: %s\n",
230                        gma,  ntohl ( request->mad.hdr.tid[0] ),
231                        ntohl ( request->mad.hdr.tid[1] ), strerror ( rc ) );
232                 free_iob ( iobuf );
233                 return rc;
234         }
235
236         return 0;
237 }
238
239 /**
240  * Handle MAD request timer expiry
241  *
242  * @v timer             Retry timer
243  * @v expired           Failure indicator
244  */
245 static void ib_gma_timer_expired ( struct retry_timer *timer, int expired ) {
246         struct ib_mad_request *request =
247                 container_of ( timer, struct ib_mad_request, timer );
248         struct ib_gma *gma = request->gma;
249
250         /* Abandon TID if we have tried too many times */
251         if ( expired ) {
252                 DBGC ( gma, "GMA %p abandoning TID %08x%08x\n",
253                        gma, ntohl ( request->mad.hdr.tid[0] ),
254                        ntohl ( request->mad.hdr.tid[1] ) );
255                 list_del ( &request->list );
256                 free ( request );
257                 return;
258         }
259
260         /* Restart retransmission timer */
261         start_timer ( timer );
262
263         /* Resend request */
264         ib_gma_send ( gma, request );
265 }
266
267 /**
268  * Issue MAD request
269  *
270  * @v gma               General management agent
271  * @v mad               MAD request
272  * @v av                Destination address, or NULL for SM
273  * @v retry             Request should be retried until a response arrives
274  * @ret rc              Return status code
275  */
276 int ib_gma_request ( struct ib_gma *gma, union ib_mad *mad,
277                      struct ib_address_vector *av, int retry ) {
278         struct ib_device *ibdev = gma->ibdev;
279         struct ib_mad_request *request;
280
281         /* Allocate and initialise structure */
282         request = zalloc ( sizeof ( *request ) );
283         if ( ! request ) {
284                 DBGC ( gma, "GMA %p could not allocate MAD request\n", gma );
285                 return -ENOMEM;
286         }
287         request->gma = gma;
288         request->timer.expired = ib_gma_timer_expired;
289
290         /* Determine address vector */
291         if ( av ) {
292                 memcpy ( &request->av, av, sizeof ( request->av ) );
293         } else {
294                 request->av.lid = ibdev->sm_lid;
295                 request->av.sl = ibdev->sm_sl;
296                 request->av.qpn = IB_QPN_GSI;
297                 request->av.qkey = IB_QKEY_GSI;
298         }
299
300         /* Copy MAD body */
301         memcpy ( &request->mad, mad, sizeof ( request->mad ) );
302
303         /* Allocate TID */
304         request->mad.hdr.tid[0] = htonl ( IB_GMA_TID_MAGIC );
305         request->mad.hdr.tid[1] = htonl ( ++next_request_tid );
306
307         /* Send initial request.  Ignore errors; the retry timer will
308          * take care of those we care about.
309          */
310         ib_gma_send ( gma, request );
311
312         /* Add to list and start timer if applicable */
313         if ( retry ) {
314                 list_add ( &request->list, &gma->requests );
315                 start_timer ( &request->timer );
316         } else {
317                 free ( request );
318         }
319
320         return 0;
321 }
322
323 /**
324  * Create GMA
325  *
326  * @v ibdev             Infiniband device
327  * @v type              Queue pair type
328  * @ret gma             General management agent, or NULL
329  */
330 struct ib_gma * ib_create_gma ( struct ib_device *ibdev,
331                                 enum ib_queue_pair_type type ) {
332         struct ib_gma *gma;
333         int rc;
334
335         /* Allocate and initialise fields */
336         gma = zalloc ( sizeof ( *gma ) );
337         if ( ! gma )
338                 goto err_alloc;
339         gma->ibdev = ibdev;
340         INIT_LIST_HEAD ( &gma->requests );
341
342         /* Create completion queue */
343         gma->cq = ib_create_cq ( ibdev, IB_GMA_NUM_CQES,
344                                  &ib_gma_completion_ops );
345         if ( ! gma->cq ) {
346                 DBGC ( gma, "GMA %p could not allocate completion queue\n",
347                        gma );
348                 goto err_create_cq;
349         }
350
351         /* Create queue pair */
352         gma->qp = ib_create_qp ( ibdev, type, IB_GMA_NUM_SEND_WQES, gma->cq,
353                                  IB_GMA_NUM_RECV_WQES, gma->cq );
354         if ( ! gma->qp ) {
355                 DBGC ( gma, "GMA %p could not allocate queue pair\n", gma );
356                 goto err_create_qp;
357         }
358         ib_qp_set_ownerdata ( gma->qp, gma );
359         DBGC ( gma, "GMA %p running on QPN %#lx\n", gma, gma->qp->qpn );
360
361         /* Set queue key */
362         gma->qp->qkey = ( ( type == IB_QPT_SMI ) ? IB_QKEY_SMI : IB_QKEY_GSI );
363         if ( ( rc = ib_modify_qp ( ibdev, gma->qp ) ) != 0 ) {
364                 DBGC ( gma, "GMA %p could not set queue key: %s\n",
365                        gma, strerror ( rc ) );
366                 goto err_modify_qp;
367         }
368
369         /* Fill receive ring */
370         ib_refill_recv ( ibdev, gma->qp );
371         return gma;
372
373  err_modify_qp:
374         ib_destroy_qp ( ibdev, gma->qp );
375  err_create_qp:
376         ib_destroy_cq ( ibdev, gma->cq );
377  err_create_cq:
378         free ( gma );
379  err_alloc:
380         return NULL;
381 }
382
383 /**
384  * Destroy GMA
385  *
386  * @v gma               General management agent
387  */
388 void ib_destroy_gma ( struct ib_gma *gma ) {
389         struct ib_device *ibdev = gma->ibdev;
390         struct ib_mad_request *request;
391         struct ib_mad_request *tmp;
392
393         /* Flush any outstanding requests */
394         list_for_each_entry_safe ( request, tmp, &gma->requests, list ) {
395                 stop_timer ( &request->timer );
396                 list_del ( &request->list );
397                 free ( request );
398         }
399
400         ib_destroy_qp ( ibdev, gma->qp );
401         ib_destroy_cq ( ibdev, gma->cq );
402         free ( gma );
403 }