← Back to branch summary

~ubuntu-branches/ubuntu/vivid/qemu-linaro/vivid

« back to all changes in this revision

Viewing changes to block/nbd.c

  • Committer: Ricardo Salveti de Araujo
  • Date: 2012-09-20 18:39:31 UTC
  • mfrom: (12922.1.2 qemu-linaro)
  • Revision ID: ricardo.salveti@linaro.org-20120920183931-sp3cg6kpdl8dmwo9
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control:
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
block/nbd.c
150
150
static void nbd_reply_ready(void *opaque)
151
151
{
152
152
    BDRVNBDState *s = opaque;
153
 
    int i;
 
153
    uint64_t i;
 
154
    int ret;
154
155
 
155
156
    if (s->reply.handle == 0) {
156
 
        /* No reply already in flight.  Fetch a header.  */
157
 
        if (nbd_receive_reply(s->sock, &s->reply) < 0) {
 
157
        /* No reply already in flight.  Fetch a header.  It is possible
 
158
         * that another thread has done the same thing in parallel, so
 
159
         * the socket is not readable anymore.
 
160
         */
 
161
        ret = nbd_receive_reply(s->sock, &s->reply);
 
162
        if (ret == -EAGAIN) {
 
163
            return;
 
164
        }
 
165
        if (ret < 0) {
158
166
            s->reply.handle = 0;
159
167
            goto fail;
160
168
        }
164
172
     * handler acts as a synchronization point and ensures that only
165
173
     * one coroutine is called until the reply finishes.  */
166
174
    i = HANDLE_TO_INDEX(s, s->reply.handle);
 
175
    if (i >= MAX_NBD_REQUESTS) {
 
176
        goto fail;
 
177
    }
 
178
 
167
179
    if (s->recv_coroutine[i]) {
168
180
        qemu_coroutine_enter(s->recv_coroutine[i], NULL);
169
181
        return;
184
196
}
185
197
 
186
198
static int nbd_co_send_request(BDRVNBDState *s, struct nbd_request *request,
187
 
                               struct iovec *iov, int offset)
 
199
                               QEMUIOVector *qiov, int offset)
188
200
{
189
201
    int rc, ret;
190
202
 
191
203
    qemu_co_mutex_lock(&s->send_mutex);
192
204
    s->send_coroutine = qemu_coroutine_self();
193
205
    qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, nbd_restart_write,
194
 
                            nbd_have_request, NULL, s);
 
206
                            nbd_have_request, s);
195
207
    rc = nbd_send_request(s->sock, request);
196
 
    if (rc != -1 && iov) {
197
 
        ret = qemu_co_sendv(s->sock, iov, request->len, offset);
 
208
    if (rc >= 0 && qiov) {
 
209
        ret = qemu_co_sendv(s->sock, qiov->iov, qiov->niov,
 
210
                            offset, request->len);
198
211
        if (ret != request->len) {
199
 
            errno = -EIO;
200
 
            rc = -1;
 
212
            return -EIO;
201
213
        }
202
214
    }
203
215
    qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, NULL,
204
 
                            nbd_have_request, NULL, s);
 
216
                            nbd_have_request, s);
205
217
    s->send_coroutine = NULL;
206
218
    qemu_co_mutex_unlock(&s->send_mutex);
207
219
    return rc;
209
221
 
210
222
static void nbd_co_receive_reply(BDRVNBDState *s, struct nbd_request *request,
211
223
                                 struct nbd_reply *reply,
212
 
                                 struct iovec *iov, int offset)
 
224
                                 QEMUIOVector *qiov, int offset)
213
225
{
214
226
    int ret;
215
227
 
220
232
    if (reply->handle != request->handle) {
221
233
        reply->error = EIO;
222
234
    } else {
223
 
        if (iov && reply->error == 0) {
224
 
            ret = qemu_co_recvv(s->sock, iov, request->len, offset);
 
235
        if (qiov && reply->error == 0) {
 
236
            ret = qemu_co_recvv(s->sock, qiov->iov, qiov->niov,
 
237
                                offset, request->len);
225
238
            if (ret != request->len) {
226
239
                reply->error = EIO;
227
240
            }
256
269
    }
257
270
 
258
271
    /* Failed to establish connection */
259
 
    if (sock == -1) {
 
272
    if (sock < 0) {
260
273
        logout("Failed to establish connection to NBD server\n");
261
274
        return -errno;
262
275
    }
264
277
    /* NBD handshake */
265
278
    ret = nbd_receive_negotiate(sock, s->export_name, &s->nbdflags, &size,
266
279
                                &blocksize);
267
 
    if (ret == -1) {
 
280
    if (ret < 0) {
268
281
        logout("Failed to negotiate with the NBD server\n");
269
282
        closesocket(sock);
270
 
        return -errno;
 
283
        return ret;
271
284
    }
272
285
 
273
286
    /* Now that we're connected, set the socket to be non-blocking and
274
287
     * kick the reply mechanism.  */
275
288
    socket_set_nonblock(sock);
276
 
    qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, NULL,
277
 
                            nbd_have_request, NULL, s);
 
289
    qemu_aio_set_fd_handler(sock, nbd_reply_ready, NULL,
 
290
                            nbd_have_request, s);
278
291
 
279
292
    s->sock = sock;
280
293
    s->size = size;
294
307
    request.len = 0;
295
308
    nbd_send_request(s->sock, &request);
296
309
 
297
 
    qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL, NULL, NULL);
 
310
    qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL, NULL);
298
311
    closesocket(s->sock);
299
312
}
300
313
 
327
340
    BDRVNBDState *s = bs->opaque;
328
341
    struct nbd_request request;
329
342
    struct nbd_reply reply;
 
343
    ssize_t ret;
330
344
 
331
345
    request.type = NBD_CMD_READ;
332
346
    request.from = sector_num * 512;
333
347
    request.len = nb_sectors * 512;
334
348
 
335
349
    nbd_coroutine_start(s, &request);
336
 
    if (nbd_co_send_request(s, &request, NULL, 0) == -1) {
337
 
        reply.error = errno;
 
350
    ret = nbd_co_send_request(s, &request, NULL, 0);
 
351
    if (ret < 0) {
 
352
        reply.error = -ret;
338
353
    } else {
339
 
        nbd_co_receive_reply(s, &request, &reply, qiov->iov, offset);
 
354
        nbd_co_receive_reply(s, &request, &reply, qiov, offset);
340
355
    }
341
356
    nbd_coroutine_end(s, &request);
342
357
    return -reply.error;
350
365
    BDRVNBDState *s = bs->opaque;
351
366
    struct nbd_request request;
352
367
    struct nbd_reply reply;
 
368
    ssize_t ret;
353
369
 
354
370
    request.type = NBD_CMD_WRITE;
355
371
    if (!bdrv_enable_write_cache(bs) && (s->nbdflags & NBD_FLAG_SEND_FUA)) {
360
376
    request.len = nb_sectors * 512;
361
377
 
362
378
    nbd_coroutine_start(s, &request);
363
 
    if (nbd_co_send_request(s, &request, qiov->iov, offset) == -1) {
364
 
        reply.error = errno;
 
379
    ret = nbd_co_send_request(s, &request, qiov, offset);
 
380
    if (ret < 0) {
 
381
        reply.error = -ret;
365
382
    } else {
366
383
        nbd_co_receive_reply(s, &request, &reply, NULL, 0);
367
384
    }
412
429
    BDRVNBDState *s = bs->opaque;
413
430
    struct nbd_request request;
414
431
    struct nbd_reply reply;
 
432
    ssize_t ret;
415
433
 
416
434
    if (!(s->nbdflags & NBD_FLAG_SEND_FLUSH)) {
417
435
        return 0;
426
444
    request.len = 0;
427
445
 
428
446
    nbd_coroutine_start(s, &request);
429
 
    if (nbd_co_send_request(s, &request, NULL, 0) == -1) {
430
 
        reply.error = errno;
 
447
    ret = nbd_co_send_request(s, &request, NULL, 0);
 
448
    if (ret < 0) {
 
449
        reply.error = -ret;
431
450
    } else {
432
451
        nbd_co_receive_reply(s, &request, &reply, NULL, 0);
433
452
    }
441
460
    BDRVNBDState *s = bs->opaque;
442
461
    struct nbd_request request;
443
462
    struct nbd_reply reply;
 
463
    ssize_t ret;
444
464
 
445
465
    if (!(s->nbdflags & NBD_FLAG_SEND_TRIM)) {
446
466
        return 0;
450
470
    request.len = nb_sectors * 512;
451
471
 
452
472
    nbd_coroutine_start(s, &request);
453
 
    if (nbd_co_send_request(s, &request, NULL, 0) == -1) {
454
 
        reply.error = errno;
 
473
    ret = nbd_co_send_request(s, &request, NULL, 0);
 
474
    if (ret < 0) {
 
475
        reply.error = -ret;
455
476
    } else {
456
477
        nbd_co_receive_reply(s, &request, &reply, NULL, 0);
457
478
    }