← Back to branch summary

~ubuntu-branches/ubuntu/trusty/grub2/trusty

« back to all changes in this revision

Viewing changes to debian/grub-extras/disabled/gpxe/src/net/infiniband/ib_cmrc.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2014-01-16 15:18:04 UTC
  • mfrom: (17.6.38 experimental)
  • Revision ID: package-import@ubuntu.com-20140116151804-3foouk7fpqcq3sxx
Tags: 2.02~beta2-2
* Convert patch handling to git-dpm.
* Add bi-endian support to ELF parser (Tomohiro B Berry).
* Adjust restore_mkdevicemap.patch to mark get_kfreebsd_version as static,
  to appease "gcc -Werror=missing-prototypes".
* Cherry-pick from upstream:
  - Change grub-macbless' manual page section to 8.
* Install grub-glue-efi, grub-macbless, grub-render-label, and
  grub-syslinux2cfg.
* grub-shell: Pass -no-pad to xorriso when building floppy images.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/grub-extras/disabled/gpxe/src/net/infiniband/ib_cmrc.c
 
1
/*
 
2
 * Copyright (C) 2009 Fen Systems Ltd <mbrown@fensystems.co.uk>.
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 *   Redistributions of source code must retain the above copyright
 
10
 *   notice, this list of conditions and the following disclaimer.
 
11
 *
 
12
 *   Redistributions in binary form must reproduce the above copyright
 
13
 *   notice, this list of conditions and the following disclaimer in
 
14
 *   the documentation and/or other materials provided with the
 
15
 *   distribution.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
18
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
19
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
20
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 
21
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 
22
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
24
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
26
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
27
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
28
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
29
 */
 
30
 
 
31
FILE_LICENCE ( BSD2 );
 
32
 
 
33
#include <stdlib.h>
 
34
#include <string.h>
 
35
#include <errno.h>
 
36
#include <gpxe/iobuf.h>
 
37
#include <gpxe/xfer.h>
 
38
#include <gpxe/process.h>
 
39
#include <gpxe/infiniband.h>
 
40
#include <gpxe/ib_cm.h>
 
41
#include <gpxe/ib_cmrc.h>
 
42
 
 
43
/**
 
44
 * @file
 
45
 *
 
46
 * Infiniband Communication-managed Reliable Connections
 
47
 *
 
48
 */
 
49
 
 
50
/** CMRC number of send WQEs
 
51
 *
 
52
 * This is a policy decision.
 
53
 */
 
54
#define IB_CMRC_NUM_SEND_WQES 4
 
55
 
 
56
/** CMRC number of receive WQEs
 
57
 *
 
58
 * This is a policy decision.
 
59
 */
 
60
#define IB_CMRC_NUM_RECV_WQES 2
 
61
 
 
62
/** CMRC number of completion queue entries
 
63
 *
 
64
 * This is a policy decision
 
65
 */
 
66
#define IB_CMRC_NUM_CQES 8
 
67
 
 
68
/** An Infiniband Communication-Managed Reliable Connection */
 
69
struct ib_cmrc_connection {
 
70
        /** Reference count */
 
71
        struct refcnt refcnt;
 
72
        /** Data transfer interface */
 
73
        struct xfer_interface xfer;
 
74
        /** Infiniband device */
 
75
        struct ib_device *ibdev;
 
76
        /** Completion queue */
 
77
        struct ib_completion_queue *cq;
 
78
        /** Queue pair */
 
79
        struct ib_queue_pair *qp;
 
80
        /** Connection */
 
81
        struct ib_connection *conn;
 
82
        /** Destination GID */
 
83
        struct ib_gid dgid;
 
84
        /** Service ID */
 
85
        struct ib_gid_half service_id;
 
86
        /** QP is connected */
 
87
        int connected;
 
88
        /** Shutdown process */
 
89
        struct process shutdown;
 
90
};
 
91
 
 
92
/**
 
93
 * Shut down CMRC connection gracefully
 
94
 *
 
95
 * @v process           Process
 
96
 *
 
97
 * The Infiniband data structures are not reference-counted or
 
98
 * guarded.  It is therefore unsafe to shut them down while we may be
 
99
 * in the middle of a callback from the Infiniband stack (e.g. in a
 
100
 * receive completion handler).
 
101
 *
 
102
 * This shutdown process will run some time after the call to
 
103
 * ib_cmrc_close(), after control has returned out of the Infiniband
 
104
 * core, and will shut down the Infiniband interfaces cleanly.
 
105
 *
 
106
 * The shutdown process holds an implicit reference on the CMRC
 
107
 * connection, ensuring that the structure is not freed before the
 
108
 * shutdown process has run.
 
109
 */
 
110
static void ib_cmrc_shutdown ( struct process *process ) {
 
111
        struct ib_cmrc_connection *cmrc =
 
112
                container_of ( process, struct ib_cmrc_connection, shutdown );
 
113
 
 
114
        DBGC ( cmrc, "CMRC %p shutting down\n", cmrc );
 
115
 
 
116
        /* Shut down Infiniband interface */
 
117
        ib_destroy_conn ( cmrc->ibdev, cmrc->qp, cmrc->conn );
 
118
        ib_destroy_qp ( cmrc->ibdev, cmrc->qp );
 
119
        ib_destroy_cq ( cmrc->ibdev, cmrc->cq );
 
120
        ib_close ( cmrc->ibdev );
 
121
 
 
122
        /* Remove process from run queue */
 
123
        process_del ( &cmrc->shutdown );
 
124
 
 
125
        /* Drop the remaining reference */
 
126
        ref_put ( &cmrc->refcnt );
 
127
}
 
128
 
 
129
/**
 
130
 * Close CMRC connection
 
131
 *
 
132
 * @v cmrc              Communication-Managed Reliable Connection
 
133
 * @v rc                Reason for close
 
134
 */
 
135
static void ib_cmrc_close ( struct ib_cmrc_connection *cmrc, int rc ) {
 
136
 
 
137
        /* Close data transfer interface */
 
138
        xfer_nullify ( &cmrc->xfer );
 
139
        xfer_close ( &cmrc->xfer, rc );
 
140
 
 
141
        /* Schedule shutdown process */
 
142
        process_add ( &cmrc->shutdown );
 
143
}
 
144
 
 
145
/**
 
146
 * Handle change of CMRC connection status
 
147
 *
 
148
 * @v ibdev             Infiniband device
 
149
 * @v qp                Queue pair
 
150
 * @v conn              Connection
 
151
 * @v rc_cm             Connection status code
 
152
 * @v private_data      Private data, if available
 
153
 * @v private_data_len  Length of private data
 
154
 */
 
155
static void ib_cmrc_changed ( struct ib_device *ibdev __unused,
 
156
                              struct ib_queue_pair *qp,
 
157
                              struct ib_connection *conn __unused, int rc_cm,
 
158
                              void *private_data, size_t private_data_len ) {
 
159
        struct ib_cmrc_connection *cmrc = ib_qp_get_ownerdata ( qp );
 
160
        int rc_xfer;
 
161
 
 
162
        /* Record connection status */
 
163
        if ( rc_cm == 0 ) {
 
164
                DBGC ( cmrc, "CMRC %p connected\n", cmrc );
 
165
                cmrc->connected = 1;
 
166
        } else {
 
167
                DBGC ( cmrc, "CMRC %p disconnected: %s\n",
 
168
                       cmrc, strerror ( rc_cm ) );
 
169
                cmrc->connected = 0;
 
170
        }
 
171
 
 
172
        /* Pass up any private data */
 
173
        DBGC2 ( cmrc, "CMRC %p received private data:\n", cmrc );
 
174
        DBGC2_HDA ( cmrc, 0, private_data, private_data_len );
 
175
        if ( private_data &&
 
176
             ( rc_xfer = xfer_deliver_raw ( &cmrc->xfer, private_data,
 
177
                                            private_data_len ) ) != 0 ) {
 
178
                DBGC ( cmrc, "CMRC %p could not deliver private data: %s\n",
 
179
                       cmrc, strerror ( rc_xfer ) );
 
180
                ib_cmrc_close ( cmrc, rc_xfer );
 
181
                return;
 
182
        }
 
183
 
 
184
        /* If we are disconnected, close the upper connection */
 
185
        if ( rc_cm != 0 ) {
 
186
                ib_cmrc_close ( cmrc, rc_cm );
 
187
                return;
 
188
        }
 
189
}
 
190
 
 
191
/** CMRC connection operations */
 
192
static struct ib_connection_operations ib_cmrc_conn_op = {
 
193
        .changed = ib_cmrc_changed,
 
194
};
 
195
 
 
196
/**
 
197
 * Handle CMRC send completion
 
198
 *
 
199
 * @v ibdev             Infiniband device
 
200
 * @v qp                Queue pair
 
201
 * @v iobuf             I/O buffer
 
202
 * @v rc                Completion status code
 
203
 */
 
204
static void ib_cmrc_complete_send ( struct ib_device *ibdev __unused,
 
205
                                    struct ib_queue_pair *qp,
 
206
                                    struct io_buffer *iobuf, int rc ) {
 
207
        struct ib_cmrc_connection *cmrc = ib_qp_get_ownerdata ( qp );
 
208
 
 
209
        /* Free the completed I/O buffer */
 
210
        free_iob ( iobuf );
 
211
 
 
212
        /* Close the connection on any send errors */
 
213
        if ( rc != 0 ) {
 
214
                DBGC ( cmrc, "CMRC %p send error: %s\n",
 
215
                       cmrc, strerror ( rc ) );
 
216
                ib_cmrc_close ( cmrc, rc );
 
217
                return;
 
218
        }
 
219
}
 
220
 
 
221
/**
 
222
 * Handle CMRC receive completion
 
223
 *
 
224
 * @v ibdev             Infiniband device
 
225
 * @v qp                Queue pair
 
226
 * @v av                Address vector, or NULL
 
227
 * @v iobuf             I/O buffer
 
228
 * @v rc                Completion status code
 
229
 */
 
230
static void ib_cmrc_complete_recv ( struct ib_device *ibdev __unused,
 
231
                                    struct ib_queue_pair *qp,
 
232
                                    struct ib_address_vector *av __unused,
 
233
                                    struct io_buffer *iobuf, int rc ) {
 
234
        struct ib_cmrc_connection *cmrc = ib_qp_get_ownerdata ( qp );
 
235
 
 
236
        /* Close the connection on any receive errors */
 
237
        if ( rc != 0 ) {
 
238
                DBGC ( cmrc, "CMRC %p receive error: %s\n",
 
239
                       cmrc, strerror ( rc ) );
 
240
                free_iob ( iobuf );
 
241
                ib_cmrc_close ( cmrc, rc );
 
242
                return;
 
243
        }
 
244
 
 
245
        DBGC2 ( cmrc, "CMRC %p received:\n", cmrc );
 
246
        DBGC2_HDA ( cmrc, 0, iobuf->data, iob_len ( iobuf ) );
 
247
 
 
248
        /* Pass up data */
 
249
        if ( ( rc = xfer_deliver_iob ( &cmrc->xfer, iobuf ) ) != 0 ) {
 
250
                DBGC ( cmrc, "CMRC %p could not deliver data: %s\n",
 
251
                       cmrc, strerror ( rc ) );
 
252
                ib_cmrc_close ( cmrc, rc );
 
253
                return;
 
254
        }
 
255
}
 
256
 
 
257
/** Infiniband CMRC completion operations */
 
258
static struct ib_completion_queue_operations ib_cmrc_completion_ops = {
 
259
        .complete_send = ib_cmrc_complete_send,
 
260
        .complete_recv = ib_cmrc_complete_recv,
 
261
};
 
262
 
 
263
/**
 
264
 * Send data via CMRC
 
265
 *
 
266
 * @v xfer              Data transfer interface
 
267
 * @v iobuf             Datagram I/O buffer
 
268
 * @v meta              Data transfer metadata
 
269
 * @ret rc              Return status code
 
270
 */
 
271
static int ib_cmrc_xfer_deliver_iob ( struct xfer_interface *xfer,
 
272
                                      struct io_buffer *iobuf,
 
273
                                      struct xfer_metadata *meta __unused ) {
 
274
        struct ib_cmrc_connection *cmrc =
 
275
                container_of ( xfer, struct ib_cmrc_connection, xfer );
 
276
        int rc;
 
277
 
 
278
        /* If no connection has yet been attempted, send this datagram
 
279
         * as the CM REQ private data.  Otherwise, send it via the QP.
 
280
         */
 
281
        if ( ! cmrc->connected ) {
 
282
 
 
283
                /* Abort if we have already sent a CM connection request */
 
284
                if ( cmrc->conn ) {
 
285
                        DBGC ( cmrc, "CMRC %p attempt to send before "
 
286
                               "connection is complete\n", cmrc );
 
287
                        rc = -EIO;
 
288
                        goto out;
 
289
                }
 
290
 
 
291
                /* Send via CM connection request */
 
292
                cmrc->conn = ib_create_conn ( cmrc->ibdev, cmrc->qp,
 
293
                                              &cmrc->dgid, &cmrc->service_id,
 
294
                                              iobuf->data, iob_len ( iobuf ),
 
295
                                              &ib_cmrc_conn_op );
 
296
                if ( ! cmrc->conn ) {
 
297
                        DBGC ( cmrc, "CMRC %p could not connect\n", cmrc );
 
298
                        rc = -ENOMEM;
 
299
                        goto out;
 
300
                }
 
301
 
 
302
        } else {
 
303
 
 
304
                /* Send via QP */
 
305
                if ( ( rc = ib_post_send ( cmrc->ibdev, cmrc->qp, NULL,
 
306
                                           iob_disown ( iobuf ) ) ) != 0 ) {
 
307
                        DBGC ( cmrc, "CMRC %p could not send: %s\n",
 
308
                               cmrc, strerror ( rc ) );
 
309
                        goto out;
 
310
                }
 
311
 
 
312
        }
 
313
        return 0;
 
314
 
 
315
 out:
 
316
        /* Free the I/O buffer if necessary */
 
317
        free_iob ( iobuf );
 
318
 
 
319
        /* Close the connection on any errors */
 
320
        if ( rc != 0 )
 
321
                ib_cmrc_close ( cmrc, rc );
 
322
 
 
323
        return rc;
 
324
}
 
325
 
 
326
/**
 
327
 * Check CMRC flow control window
 
328
 *
 
329
 * @v xfer              Data transfer interface
 
330
 * @ret len             Length of window
 
331
 */
 
332
static size_t ib_cmrc_xfer_window ( struct xfer_interface *xfer ) {
 
333
        struct ib_cmrc_connection *cmrc =
 
334
                container_of ( xfer, struct ib_cmrc_connection, xfer );
 
335
 
 
336
        /* We indicate a window only when we are successfully
 
337
         * connected.
 
338
         */
 
339
        return ( cmrc->connected ? IB_MAX_PAYLOAD_SIZE : 0 );
 
340
}
 
341
 
 
342
/**
 
343
 * Close CMRC data-transfer interface
 
344
 *
 
345
 * @v xfer              Data transfer interface
 
346
 * @v rc                Reason for close
 
347
 */
 
348
static void ib_cmrc_xfer_close ( struct xfer_interface *xfer, int rc ) {
 
349
        struct ib_cmrc_connection *cmrc =
 
350
                container_of ( xfer, struct ib_cmrc_connection, xfer );
 
351
 
 
352
        DBGC ( cmrc, "CMRC %p closed: %s\n", cmrc, strerror ( rc ) );
 
353
        ib_cmrc_close ( cmrc, rc );
 
354
}
 
355
 
 
356
/** CMRC data transfer interface operations */
 
357
static struct xfer_interface_operations ib_cmrc_xfer_operations = {
 
358
        .close          = ib_cmrc_xfer_close,
 
359
        .vredirect      = ignore_xfer_vredirect,
 
360
        .window         = ib_cmrc_xfer_window,
 
361
        .alloc_iob      = default_xfer_alloc_iob,
 
362
        .deliver_iob    = ib_cmrc_xfer_deliver_iob,
 
363
        .deliver_raw    = xfer_deliver_as_iob,
 
364
};
 
365
 
 
366
/**
 
367
 * Open CMRC connection
 
368
 *
 
369
 * @v xfer              Data transfer interface
 
370
 * @v ibdev             Infiniband device
 
371
 * @v dgid              Destination GID
 
372
 * @v service_id        Service ID
 
373
 * @ret rc              Returns status code
 
374
 */
 
375
int ib_cmrc_open ( struct xfer_interface *xfer, struct ib_device *ibdev,
 
376
                   struct ib_gid *dgid, struct ib_gid_half *service_id ) {
 
377
        struct ib_cmrc_connection *cmrc;
 
378
        int rc;
 
379
 
 
380
        /* Allocate and initialise structure */
 
381
        cmrc = zalloc ( sizeof ( *cmrc ) );
 
382
        if ( ! cmrc ) {
 
383
                rc = -ENOMEM;
 
384
                goto err_alloc;
 
385
        }
 
386
        xfer_init ( &cmrc->xfer, &ib_cmrc_xfer_operations, &cmrc->refcnt );
 
387
        cmrc->ibdev = ibdev;
 
388
        memcpy ( &cmrc->dgid, dgid, sizeof ( cmrc->dgid ) );
 
389
        memcpy ( &cmrc->service_id, service_id, sizeof ( cmrc->service_id ) );
 
390
        process_init_stopped ( &cmrc->shutdown, ib_cmrc_shutdown,
 
391
                               &cmrc->refcnt );
 
392
 
 
393
        /* Open Infiniband device */
 
394
        if ( ( rc = ib_open ( ibdev ) ) != 0 ) {
 
395
                DBGC ( cmrc, "CMRC %p could not open device: %s\n",
 
396
                       cmrc, strerror ( rc ) );
 
397
                goto err_open;
 
398
        }
 
399
 
 
400
        /* Create completion queue */
 
401
        cmrc->cq = ib_create_cq ( ibdev, IB_CMRC_NUM_CQES,
 
402
                                  &ib_cmrc_completion_ops );
 
403
        if ( ! cmrc->cq ) {
 
404
                DBGC ( cmrc, "CMRC %p could not create completion queue\n",
 
405
                       cmrc );
 
406
                rc = -ENOMEM;
 
407
                goto err_create_cq;
 
408
        }
 
409
 
 
410
        /* Create queue pair */
 
411
        cmrc->qp = ib_create_qp ( ibdev, IB_QPT_RC, IB_CMRC_NUM_SEND_WQES,
 
412
                                  cmrc->cq, IB_CMRC_NUM_RECV_WQES, cmrc->cq );
 
413
        if ( ! cmrc->qp ) {
 
414
                DBGC ( cmrc, "CMRC %p could not create queue pair\n", cmrc );
 
415
                rc = -ENOMEM;
 
416
                goto err_create_qp;
 
417
        }
 
418
        ib_qp_set_ownerdata ( cmrc->qp, cmrc );
 
419
        DBGC ( cmrc, "CMRC %p using QPN %lx\n", cmrc, cmrc->qp->qpn );
 
420
 
 
421
        /* Attach to parent interface, transfer reference (implicitly)
 
422
         * to our shutdown process, and return.
 
423
         */
 
424
        xfer_plug_plug ( &cmrc->xfer, xfer );
 
425
        return 0;
 
426
 
 
427
        ib_destroy_qp ( ibdev, cmrc->qp );
 
428
 err_create_qp:
 
429
        ib_destroy_cq ( ibdev, cmrc->cq );
 
430
 err_create_cq:
 
431
        ib_close ( ibdev );
 
432
 err_open:
 
433
        ref_put ( &cmrc->refcnt );
 
434
 err_alloc:
 
435
        return rc;
 
436
}