Commit cfe6c547 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/xanclic/tags/pull-block-2019-01-31' into staging 



Block patches:
- New debugging QMP command to explore block graphs
- Converted DPRINTF()s to trace events
- Fixed qemu-io's use of getopt() for systems with optreset
- Minor NVMe emulation fixes
- An iotest fix

# gpg: Signature made Thu 31 Jan 2019 00:51:46 GMT
# gpg:                using RSA key F407DB0061D5CF40
# gpg: Good signature from "Max Reitz <mreitz@redhat.com>" [full]
# Primary key fingerprint: 91BE B60A 30DB 3E88 57D1  1829 F407 DB00 61D5 CF40

* remotes/xanclic/tags/pull-block-2019-01-31:
  iotests: Allow 147 to be run concurrently
  iotests: Bind qemu-nbd to localhost in 147
  iotests.py: Add qemu_nbd_pipe()
  nvme: use pci_dev directly in nvme_realize
  nvme: ensure the num_queues is not zero
  nvme: use TYPE_NVME instead of constant string
  qemu-io: Add generic function for reinitializing optind.
  block/sheepdog: Convert from DPRINTF() macro to trace events
  block/file-posix: Convert from DPRINTF() macro to trace events
  block/curl: Convert from DPRINTF() macro to trace events
  block/ssh: Convert from DPRINTF() macro to trace events
  scripts: add render_block_graph function for QEMUMachine
  qapi: add x-debug-query-block-graph

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents e8977901 908b3016

block.c

+148 −0
Original line number Diff line number Diff line
@@ -4119,6 +4119,154 @@ BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp) 
    return list;

}



#define QAPI_LIST_ADD(list, element) do { \

    typeof(list) _tmp = g_new(typeof(*(list)), 1); \

    _tmp->value = (element); \

    _tmp->next = (list); \

    (list) = _tmp; \

} while (0)



typedef struct XDbgBlockGraphConstructor {

    XDbgBlockGraph *graph;

    GHashTable *graph_nodes;

} XDbgBlockGraphConstructor;



static XDbgBlockGraphConstructor *xdbg_graph_new(void)

{

    XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);



    gr->graph = g_new0(XDbgBlockGraph, 1);

    gr->graph_nodes = g_hash_table_new(NULL, NULL);



    return gr;

}



static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)

{

    XDbgBlockGraph *graph = gr->graph;



    g_hash_table_destroy(gr->graph_nodes);

    g_free(gr);



    return graph;

}



static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)

{

    uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);



    if (ret != 0) {

        return ret;

    }



    /*

     * Start counting from 1, not 0, because 0 interferes with not-found (NULL)

     * answer of g_hash_table_lookup.

     */

    ret = g_hash_table_size(gr->graph_nodes) + 1;

    g_hash_table_insert(gr->graph_nodes, node, (void *)ret);



    return ret;

}



static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,

                                XDbgBlockGraphNodeType type, const char *name)

{

    XDbgBlockGraphNode *n;



    n = g_new0(XDbgBlockGraphNode, 1);



    n->id = xdbg_graph_node_num(gr, node);

    n->type = type;

    n->name = g_strdup(name);



    QAPI_LIST_ADD(gr->graph->nodes, n);

}



static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,

                                const BdrvChild *child)

{

    typedef struct {

        unsigned int flag;

        BlockPermission num;

    } PermissionMap;



    static const PermissionMap permissions[] = {

        { BLK_PERM_CONSISTENT_READ, BLOCK_PERMISSION_CONSISTENT_READ },

        { BLK_PERM_WRITE,           BLOCK_PERMISSION_WRITE },

        { BLK_PERM_WRITE_UNCHANGED, BLOCK_PERMISSION_WRITE_UNCHANGED },

        { BLK_PERM_RESIZE,          BLOCK_PERMISSION_RESIZE },

        { BLK_PERM_GRAPH_MOD,       BLOCK_PERMISSION_GRAPH_MOD },

        { 0, 0 }

    };

    const PermissionMap *p;

    XDbgBlockGraphEdge *edge;



    QEMU_BUILD_BUG_ON(1UL << (ARRAY_SIZE(permissions) - 1) != BLK_PERM_ALL + 1);



    edge = g_new0(XDbgBlockGraphEdge, 1);



    edge->parent = xdbg_graph_node_num(gr, parent);

    edge->child = xdbg_graph_node_num(gr, child->bs);

    edge->name = g_strdup(child->name);



    for (p = permissions; p->flag; p++) {

        if (p->flag & child->perm) {

            QAPI_LIST_ADD(edge->perm, p->num);

        }

        if (p->flag & child->shared_perm) {

            QAPI_LIST_ADD(edge->shared_perm, p->num);

        }

    }



    QAPI_LIST_ADD(gr->graph->edges, edge);

}





XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)

{

    BlockBackend *blk;

    BlockJob *job;

    BlockDriverState *bs;

    BdrvChild *child;

    XDbgBlockGraphConstructor *gr = xdbg_graph_new();



    for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {

        char *allocated_name = NULL;

        const char *name = blk_name(blk);



        if (!*name) {

            name = allocated_name = blk_get_attached_dev_id(blk);

        }

        xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,

                           name);

        g_free(allocated_name);

        if (blk_root(blk)) {

            xdbg_graph_add_edge(gr, blk, blk_root(blk));

        }

    }



    for (job = block_job_next(NULL); job; job = block_job_next(job)) {

        GSList *el;



        xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,

                           job->job.id);

        for (el = job->nodes; el; el = el->next) {

            xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);

        }

    }



    QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {

        xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,

                           bs->node_name);

        QLIST_FOREACH(child, &bs->children, next) {

            xdbg_graph_add_edge(gr, bs, child);

        }

    }



    return xdbg_graph_finalize(gr);

}



BlockDriverState *bdrv_lookup_bs(const char *device,

                                 const char *node_name,

                                 Error **errp)

block/block-backend.c

+5 −0
Original line number Diff line number Diff line
@@ -2249,3 +2249,8 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, 
                              blk_out->root, off_out,

                              bytes, read_flags, write_flags);

}



const BdrvChild *blk_root(BlockBackend *blk)

{

    return blk->root;

}

block/curl.c

+8 −21
Original line number Diff line number Diff line
@@ -32,22 +32,10 @@ 
#include "crypto/secret.h"

#include <curl/curl.h>

#include "qemu/cutils.h"

#include "trace.h"



// #define DEBUG_CURL

// #define DEBUG_VERBOSE



#ifdef DEBUG_CURL

#define DEBUG_CURL_PRINT 1

#else

#define DEBUG_CURL_PRINT 0

#endif

#define DPRINTF(fmt, ...)                                            \

    do {                                                             \

        if (DEBUG_CURL_PRINT) {                                      \

            fprintf(stderr, fmt, ## __VA_ARGS__);                    \

        }                                                            \

    } while (0)



#if LIBCURL_VERSION_NUM >= 0x071000

/* The multi interface timer callback was introduced in 7.16.0 */

#define NEED_CURL_TIMER_CALLBACK
@@ -154,7 +142,7 @@ static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque) 
{

    BDRVCURLState *s = opaque;



    DPRINTF("CURL: timer callback timeout_ms %ld\n", timeout_ms);

    trace_curl_timer_cb(timeout_ms);

    if (timeout_ms == -1) {

        timer_del(&s->timer);

    } else {
@@ -193,7 +181,7 @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action, 
    }

    socket = NULL;



    DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, (int)fd);

    trace_curl_sock_cb(action, (int)fd);

    switch (action) {

        case CURL_POLL_IN:

            aio_set_fd_handler(s->aio_context, fd, false,
@@ -238,7 +226,7 @@ static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) 
    size_t realsize = size * nmemb;

    int i;



    DPRINTF("CURL: Just reading %zd bytes\n", realsize);

    trace_curl_read_cb(realsize);



    if (!s || !s->orig_buf) {

        goto read_end;
@@ -777,7 +765,7 @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags, 
        }

    }



    DPRINTF("CURL: Opening %s\n", file);

    trace_curl_open(file);

    qemu_co_queue_init(&s->free_state_waitq);

    s->aio_context = bdrv_get_aio_context(bs);

    s->url = g_strdup(file);
@@ -830,7 +818,7 @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags, 
                "Server does not support 'range' (byte ranges).");

        goto out;

    }

    DPRINTF("CURL: Size = %" PRIu64 "\n", s->len);

    trace_curl_open_size(s->len);



    qemu_mutex_lock(&s->mutex);

    curl_clean_state(state);
@@ -908,8 +896,7 @@ static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb) 
    state->acb[0] = acb;



    snprintf(state->range, 127, "%" PRIu64 "-%" PRIu64, start, end);

    DPRINTF("CURL (AIO): Reading %" PRIu64 " at %" PRIu64 " (%s)\n",

            acb->bytes, start, state->range);

    trace_curl_setup_preadv(acb->bytes, start, state->range);

    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);



    curl_multi_add_handle(s->multi, state->curl);
@@ -943,7 +930,7 @@ static void curl_close(BlockDriverState *bs) 
{

    BDRVCURLState *s = bs->opaque;



    DPRINTF("CURL: Close\n");

    trace_curl_close();

    curl_detach_aio_context(bs);

    qemu_mutex_destroy(&s->mutex);

block/file-posix.c

+6 −19
Original line number Diff line number Diff line
@@ -102,19 +102,7 @@ 
#include <xfs/xfs.h>

#endif



//#define DEBUG_BLOCK



#ifdef DEBUG_BLOCK

# define DEBUG_BLOCK_PRINT 1

#else

# define DEBUG_BLOCK_PRINT 0

#endif

#define DPRINTF(fmt, ...) \

do { \

    if (DEBUG_BLOCK_PRINT) { \

        printf(fmt, ## __VA_ARGS__); \

    } \

} while (0)

#include "trace.h"



/* OS X does not have O_DSYNC */

#ifndef O_DSYNC
@@ -1411,7 +1399,7 @@ static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes) 


    if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {

        err = errno;

        DPRINTF("cannot write zero range (%s)\n", strerror(errno));

        trace_file_xfs_write_zeroes(strerror(errno));

        return -err;

    }
@@ -1430,7 +1418,7 @@ static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes) 


    if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {

        err = errno;

        DPRINTF("cannot punch hole (%s)\n", strerror(errno));

        trace_file_xfs_discard(strerror(errno));

        return -err;

    }
@@ -2819,7 +2807,7 @@ static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator) 


        /* If a match was found, leave the loop */

        if (*mediaIterator != 0) {

            DPRINTF("Matching using %s\n", matching_array[index]);

            trace_file_FindEjectableOpticalMedia(matching_array[index]);

            mediaType = g_strdup(matching_array[index]);

            break;

        }
@@ -2879,7 +2867,7 @@ static bool setup_cdrom(char *bsd_path, Error **errp) 
    if (partition_found == false) {

        error_setg(errp, "Failed to find a working partition on disc");

    } else {

        DPRINTF("Using %s as optical disc\n", test_partition);

        trace_file_setup_cdrom(test_partition);

        pstrcpy(bsd_path, MAXPATHLEN, test_partition);

    }

    return partition_found;
@@ -2974,8 +2962,7 @@ static bool hdev_is_sg(BlockDriverState *bs) 


    ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);

    if (ret >= 0) {

        DPRINTF("SG device found: type=%d, version=%d\n",

            scsiid.scsi_type, sg_version);

        trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);

        return true;

    }

block/sheepdog.c

+17 −30
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include "sysemu/block-backend.h"

#include "qemu/bitops.h"

#include "qemu/cutils.h"

#include "trace.h"



#define SD_PROTO_VER 0x01
@@ -299,19 +300,6 @@ static inline size_t count_data_objs(const struct SheepdogInode *inode) 
                        (1UL << inode->block_size_shift));

}



#undef DPRINTF

#ifdef DEBUG_SDOG

#define DEBUG_SDOG_PRINT 1

#else

#define DEBUG_SDOG_PRINT 0

#endif

#define DPRINTF(fmt, args...)                                           \

    do {                                                                \

        if (DEBUG_SDOG_PRINT) {                                         \

            fprintf(stderr, "%s %d: " fmt, __func__, __LINE__, ##args); \

        }                                                               \

    } while (0)



typedef struct SheepdogAIOCB SheepdogAIOCB;

typedef struct BDRVSheepdogState BDRVSheepdogState;
@@ -750,7 +738,7 @@ static coroutine_fn void reconnect_to_sdog(void *opaque) 
        Error *local_err = NULL;

        s->fd = get_sheep_fd(s, &local_err);

        if (s->fd < 0) {

            DPRINTF("Wait for connection to be established\n");

            trace_sheepdog_reconnect_to_sdog();

            error_report_err(local_err);

            qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000000ULL);

        }
@@ -847,7 +835,7 @@ static void coroutine_fn aio_read_response(void *opaque) 
        break;

    case AIOCB_FLUSH_CACHE:

        if (rsp.result == SD_RES_INVALID_PARMS) {

            DPRINTF("disable cache since the server doesn't support it\n");

            trace_sheepdog_aio_read_response();

            s->cache_flags = SD_FLAG_CMD_DIRECT;

            rsp.result = SD_RES_SUCCESS;

        }
@@ -1639,7 +1627,7 @@ static int sd_open(BlockDriverState *bs, QDict *options, int flags, 
    s->discard_supported = true;



    if (snap_id || tag[0]) {

        DPRINTF("%" PRIx32 " snapshot inode was open.\n", vid);

        trace_sheepdog_open(vid);

        s->is_snapshot = true;

    }
@@ -2252,7 +2240,7 @@ static void sd_close(BlockDriverState *bs) 
    unsigned int wlen, rlen = 0;

    int fd, ret;



    DPRINTF("%s\n", s->name);

    trace_sheepdog_close(s->name);



    fd = connect_to_sdog(s, &local_err);

    if (fd < 0) {
@@ -2429,7 +2417,7 @@ static int sd_create_branch(BDRVSheepdogState *s) 
    char *buf;

    bool deleted;



    DPRINTF("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);

    trace_sheepdog_create_branch_snapshot(s->inode.vdi_id);



    buf = g_malloc(SD_INODE_SIZE);
@@ -2445,7 +2433,7 @@ static int sd_create_branch(BDRVSheepdogState *s) 
        goto out;

    }



    DPRINTF("%" PRIx32 " is created.\n", vid);

    trace_sheepdog_create_branch_created(vid);



    fd = connect_to_sdog(s, &local_err);

    if (fd < 0) {
@@ -2467,7 +2455,7 @@ static int sd_create_branch(BDRVSheepdogState *s) 


    s->is_snapshot = false;

    ret = 0;

    DPRINTF("%" PRIx32 " was newly created.\n", s->inode.vdi_id);

    trace_sheepdog_create_branch_new(s->inode.vdi_id);



out:

    g_free(buf);
@@ -2561,11 +2549,11 @@ static void coroutine_fn sd_co_rw_vector(SheepdogAIOCB *acb) 
        }



        if (create) {

            DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",

                    inode->vdi_id, oid,

                    vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);

            trace_sheepdog_co_rw_vector_update(inode->vdi_id, oid,

                                  vid_to_data_oid(inode->data_vdi_id[idx], idx),

                                  idx);

            oid = vid_to_data_oid(inode->vdi_id, idx);

            DPRINTF("new oid %" PRIx64 "\n", oid);

            trace_sheepdog_co_rw_vector_new(oid);

        }



        aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, create,
@@ -2670,9 +2658,8 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) 
    SheepdogInode *inode;

    unsigned int datalen;



    DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "

            "is_snapshot %d\n", sn_info->name, sn_info->id_str,

            s->name, sn_info->vm_state_size, s->is_snapshot);

    trace_sheepdog_snapshot_create_info(sn_info->name, sn_info->id_str, s->name,

                                        sn_info->vm_state_size, s->is_snapshot);



    if (s->is_snapshot) {

        error_report("You can't create a snapshot of a snapshot VDI, "
@@ -2681,7 +2668,7 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) 
        return -EINVAL;

    }



    DPRINTF("%s %s\n", sn_info->name, sn_info->id_str);

    trace_sheepdog_snapshot_create(sn_info->name, sn_info->id_str);



    s->inode.vm_state_size = sn_info->vm_state_size;

    s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
@@ -2726,8 +2713,8 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) 
    }



    memcpy(&s->inode, inode, datalen);

    DPRINTF("s->inode: name %s snap_id %x oid %x\n",

            s->inode.name, s->inode.snap_id, s->inode.vdi_id);

    trace_sheepdog_snapshot_create_inode(s->inode.name, s->inode.snap_id,

                                         s->inode.vdi_id);



cleanup:

    g_free(inode);