Archipelago » qemu

BlockInfo *bdrv_query_info(BlockDriverState *bs)

{

    BlockInfo *info = g_malloc0(sizeof(*info));

    info->device = g_strdup(bs->device_name);

    info->type = g_strdup("unknown");

    info->locked = bdrv_dev_is_medium_locked(bs);

    info->removable = bdrv_dev_has_removable_media(bs);

    if (bdrv_dev_has_removable_media(bs)) {

        info->has_tray_open = true;

        info->tray_open = bdrv_dev_is_tray_open(bs);

    }

    if (bdrv_iostatus_is_enabled(bs)) {

        info->has_io_status = true;

        info->io_status = bs->iostatus;

    }

    if (bs->dirty_bitmap) {

        info->has_dirty = true;

        info->dirty = g_malloc0(sizeof(*info->dirty));

        info->dirty->count = bdrv_get_dirty_count(bs) * BDRV_SECTOR_SIZE;

        info->dirty->granularity =

            ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bs->dirty_bitmap));

    }

    if (bs->drv) {

        info->has_inserted = true;

        info->inserted = g_malloc0(sizeof(*info->inserted));

        info->inserted->file = g_strdup(bs->filename);

        info->inserted->ro = bs->read_only;

        info->inserted->drv = g_strdup(bs->drv->format_name);

        info->inserted->encrypted = bs->encrypted;

        info->inserted->encryption_key_missing = bdrv_key_required(bs);

        if (bs->backing_file[0]) {

            info->inserted->has_backing_file = true;

            info->inserted->backing_file = g_strdup(bs->backing_file);

        }

        info->inserted->backing_file_depth = bdrv_get_backing_file_depth(bs);

        if (bs->io_limits_enabled) {

            info->inserted->bps =

                           bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];

            info->inserted->bps_rd =

                           bs->io_limits.bps[BLOCK_IO_LIMIT_READ];

            info->inserted->bps_wr =

                           bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];

            info->inserted->iops =

                           bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];

            info->inserted->iops_rd =

                           bs->io_limits.iops[BLOCK_IO_LIMIT_READ];

            info->inserted->iops_wr =

                           bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];

        }

    }

    return info;

}

BlockInfoList *qmp_query_block(Error **errp)

{

    BlockInfoList *head = NULL, **p_next = &head;

    BlockDriverState *bs;

    QTAILQ_FOREACH(bs, &bdrv_states, list) {

        BlockInfoList *info = g_malloc0(sizeof(*info));

        info->value = bdrv_query_info(bs);

        *p_next = info;

        p_next = &info->next;

    }

    return head;

}

BlockStats *bdrv_query_stats(const BlockDriverState *bs)

{

    BlockStats *s;

    s = g_malloc0(sizeof(*s));

    if (bs->device_name[0]) {

        s->has_device = true;

        s->device = g_strdup(bs->device_name);

    }

    s->stats = g_malloc0(sizeof(*s->stats));

    s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];

    s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];

    s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];

    s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];

    s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;

    s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];

    s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];

    s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];

    s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];

    if (bs->file) {

        s->has_parent = true;

        s->parent = bdrv_query_stats(bs->file);

    }

    return s;

}

BlockStatsList *qmp_query_blockstats(Error **errp)

{

    BlockStatsList *head = NULL, **p_next = &head;

    BlockDriverState *bs;

    QTAILQ_FOREACH(bs, &bdrv_states, list) {

        BlockStatsList *info = g_malloc0(sizeof(*info));

        info->value = bdrv_query_stats(bs);

        *p_next = info;

        p_next = &info->next;

    }

    return head;

}

#define NB_SUFFIXES 4

char *get_human_readable_size(char *buf, int buf_size, int64_t size)

{

    static const char suffixes[NB_SUFFIXES] = "KMGT";

    int64_t base;

    int i;

    if (size <= 999) {

        snprintf(buf, buf_size, "%" PRId64, size);

    } else {

        base = 1024;

        for(i = 0; i < NB_SUFFIXES; i++) {

            if (size < (10 * base)) {

                snprintf(buf, buf_size, "%0.1f%c",

                         (double)size / base,

                         suffixes[i]);

                break;

            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {

                snprintf(buf, buf_size, "%" PRId64 "%c",

                         ((size + (base >> 1)) / base),

                         suffixes[i]);

                break;

            }

            base = base * 1024;

        }

    }

    return buf;

}

char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)

{

    char buf1[128], date_buf[128], clock_buf[128];

    struct tm tm;

    time_t ti;

    int64_t secs;

    if (!sn) {

        snprintf(buf, buf_size,

                 "%-10s%-20s%7s%20s%15s",

                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");

    } else {

        ti = sn->date_sec;

        localtime_r(&ti, &tm);

        strftime(date_buf, sizeof(date_buf),

                 "%Y-%m-%d %H:%M:%S", &tm);

        secs = sn->vm_clock_nsec / 1000000000;

        snprintf(clock_buf, sizeof(clock_buf),

                 "%02d:%02d:%02d.%03d",

                 (int)(secs / 3600),

                 (int)((secs / 60) % 60),

                 (int)(secs % 60),

                 (int)((sn->vm_clock_nsec / 1000000) % 1000));

        snprintf(buf, buf_size,

                 "%-10s%-20s%7s%20s%15s",

                 sn->id_str, sn->name,

                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),

                 date_buf,

                 clock_buf);

    }

    return buf;

}