← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to block/qapi.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
block/qapi.c
237
237
 
238
238
    size = bdrv_getlength(bs);
239
239
    if (size < 0) {
240
 
        error_setg_errno(errp, -size, "Can't get size of device '%s'",
241
 
                         bdrv_get_device_name(bs));
 
240
        error_setg_errno(errp, -size, "Can't get image size '%s'",
 
241
                         bs->exact_filename);
242
242
        goto out;
243
243
    }
244
244
 
357
357
    qapi_free_BlockInfo(info);
358
358
}
359
359
 
360
 
static BlockStats *bdrv_query_stats(BlockBackend *blk,
361
 
                                    const BlockDriverState *bs,
362
 
                                    bool query_backing);
363
 
 
364
360
static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
365
361
{
366
362
    BlockAcctStats *stats = blk_get_stats(blk);
428
424
    }
429
425
}
430
426
 
431
 
static void bdrv_query_bds_stats(BlockStats *s, const BlockDriverState *bs,
 
427
static BlockStats *bdrv_query_bds_stats(const BlockDriverState *bs,
432
428
                                 bool query_backing)
433
429
{
 
430
    BlockStats *s = NULL;
 
431
 
 
432
    s = g_malloc0(sizeof(*s));
 
433
    s->stats = g_malloc0(sizeof(*s->stats));
 
434
 
 
435
    if (!bs) {
 
436
        return s;
 
437
    }
 
438
 
434
439
    if (bdrv_get_node_name(bs)[0]) {
435
440
        s->has_node_name = true;
436
441
        s->node_name = g_strdup(bdrv_get_node_name(bs));
440
445
 
441
446
    if (bs->file) {
442
447
        s->has_parent = true;
443
 
        s->parent = bdrv_query_stats(NULL, bs->file->bs, query_backing);
 
448
        s->parent = bdrv_query_bds_stats(bs->file->bs, query_backing);
444
449
    }
445
450
 
446
451
    if (query_backing && bs->backing) {
447
452
        s->has_backing = true;
448
 
        s->backing = bdrv_query_stats(NULL, bs->backing->bs, query_backing);
449
 
    }
450
 
 
451
 
}
452
 
 
453
 
static BlockStats *bdrv_query_stats(BlockBackend *blk,
454
 
                                    const BlockDriverState *bs,
455
 
                                    bool query_backing)
456
 
{
457
 
    BlockStats *s;
458
 
 
459
 
    s = g_malloc0(sizeof(*s));
460
 
    s->stats = g_malloc0(sizeof(*s->stats));
461
 
 
462
 
    if (blk) {
463
 
        s->has_device = true;
464
 
        s->device = g_strdup(blk_name(blk));
465
 
        bdrv_query_blk_stats(s->stats, blk);
466
 
    }
467
 
    if (bs) {
468
 
        bdrv_query_bds_stats(s, bs, query_backing);
 
453
        s->backing = bdrv_query_bds_stats(bs->backing->bs, query_backing);
469
454
    }
470
455
 
471
456
    return s;
494
479
    return head;
495
480
}
496
481
 
497
 
static bool next_query_bds(BlockBackend **blk, BlockDriverState **bs,
498
 
                           bool query_nodes)
499
 
{
500
 
    if (query_nodes) {
501
 
        *bs = bdrv_next_node(*bs);
502
 
        return !!*bs;
503
 
    }
504
 
 
505
 
    *blk = blk_next(*blk);
506
 
    *bs = *blk ? blk_bs(*blk) : NULL;
507
 
 
508
 
    return !!*blk;
509
 
}
510
 
 
511
482
BlockStatsList *qmp_query_blockstats(bool has_query_nodes,
512
483
                                     bool query_nodes,
513
484
                                     Error **errp)
514
485
{
515
486
    BlockStatsList *head = NULL, **p_next = &head;
516
 
    BlockBackend *blk = NULL;
517
 
    BlockDriverState *bs = NULL;
 
487
    BlockBackend *blk;
 
488
    BlockDriverState *bs;
518
489
 
519
490
    /* Just to be safe if query_nodes is not always initialized */
520
 
    query_nodes = has_query_nodes && query_nodes;
521
 
 
522
 
    while (next_query_bds(&blk, &bs, query_nodes)) {
523
 
        BlockStatsList *info = g_malloc0(sizeof(*info));
524
 
        AioContext *ctx = blk ? blk_get_aio_context(blk)
525
 
                              : bdrv_get_aio_context(bs);
526
 
 
527
 
        aio_context_acquire(ctx);
528
 
        info->value = bdrv_query_stats(blk, bs, !query_nodes);
529
 
        aio_context_release(ctx);
530
 
 
531
 
        *p_next = info;
532
 
        p_next = &info->next;
 
491
    if (has_query_nodes && query_nodes) {
 
492
        for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) {
 
493
            BlockStatsList *info = g_malloc0(sizeof(*info));
 
494
            AioContext *ctx = bdrv_get_aio_context(bs);
 
495
 
 
496
            aio_context_acquire(ctx);
 
497
            info->value = bdrv_query_bds_stats(bs, false);
 
498
            aio_context_release(ctx);
 
499
 
 
500
            *p_next = info;
 
501
            p_next = &info->next;
 
502
        }
 
503
    } else {
 
504
        for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
 
505
            BlockStatsList *info = g_malloc0(sizeof(*info));
 
506
            AioContext *ctx = blk_get_aio_context(blk);
 
507
            BlockStats *s;
 
508
 
 
509
            aio_context_acquire(ctx);
 
510
            s = bdrv_query_bds_stats(blk_bs(blk), true);
 
511
            s->has_device = true;
 
512
            s->device = g_strdup(blk_name(blk));
 
513
            bdrv_query_blk_stats(s->stats, blk);
 
514
            aio_context_release(ctx);
 
515
 
 
516
            info->value = s;
 
517
            *p_next = info;
 
518
            p_next = &info->next;
 
519
        }
533
520
    }
534
521
 
535
522
    return head;
695
682
 
696
683
    visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort);
697
684
    visit_complete(v, &obj);
698
 
    assert(qobject_type(obj) == QTYPE_QDICT);
699
685
    data = qdict_get(qobject_to_qdict(obj), "data");
700
686
    dump_qobject(func_fprintf, f, 1, data);
701
687
    qobject_decref(obj);