The following changes since commit b4fbe1f65a4769c09e6bf2d79fc84360f840f40e:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20190129' into staging (2019-01-29 12:00:19 +0000)

https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2019-01-31

for you to fetch changes up to 908b30164bbffad7430d551b2a03a8fbcaa631ef:

iotests: Allow 147 to be run concurrently (2019-01-31 00:44:55 +0100)

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

Li Qiang (3):

nvme: use TYPE_NVME instead of constant string

nvme: ensure the num_queues is not zero

nvme: use pci_dev directly in nvme_realize

Max Reitz (3):

iotests.py: Add qemu_nbd_pipe()

iotests: Bind qemu-nbd to localhost in 147

iotests: Allow 147 to be run concurrently

Richard W.M. Jones (1):

qemu-io: Add generic function for reinitializing optind.

Vladimir Sementsov-Ogievskiy (2):

qapi: add x-debug-query-block-graph

scripts: add render_block_graph function for QEMUMachine

configure | 14 ++++

qapi/block-core.json | 108 ++++++++++++++++++++++++

include/block/block.h | 1 +

include/qemu/osdep.h | 16 ++++

include/sysemu/block-backend.h | 2 +

block.c | 148 +++++++++++++++++++++++++++++++++

block/block-backend.c | 5 ++

block/curl.c | 29 ++-----

block/file-posix.c | 25 ++----

block/sheepdog.c | 47 ++++-------

block/ssh.c | 46 ++++------

blockdev.c | 5 ++

hw/block/nvme.c | 15 ++--

qemu-img.c | 2 +-

qemu-io-cmds.c | 2 +-

block/trace-events | 47 +++++++++++

scripts/render_block_graph.py | 120 ++++++++++++++++++++++++++

tests/qemu-iotests/147 | 98 +++++++++++++++-------

tests/qemu-iotests/iotests.py | 14 ++++

19 files changed, 608 insertions(+), 136 deletions(-)

create mode 100755 scripts/render_block_graph.py

2.20.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Add a new command, returning block nodes (and their users) graph.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-id: 20181221170909.25584-2-vsementsov@virtuozzo.com

Signed-off-by: Max Reitz <mreitz@redhat.com>

qapi/block-core.json | 108 ++++++++++++++++++++++++

include/block/block.h | 1 +

include/sysemu/block-backend.h | 2 +

block.c | 148 +++++++++++++++++++++++++++++++++

block/block-backend.c | 5 ++

blockdev.c | 5 ++

6 files changed, 269 insertions(+)

##

{ 'command': 'query-named-block-nodes', 'returns': [ 'BlockDeviceInfo' ] }

+# @XDbgBlockGraphNodeType:

+# @block-backend: corresponds to BlockBackend

+# @block-job: corresonds to BlockJob

+# @block-driver: corresponds to BlockDriverState

+# Since: 4.0

+{ 'enum': 'XDbgBlockGraphNodeType',

+ 'data': [ 'block-backend', 'block-job', 'block-driver' ] }

+

+##

+# @XDbgBlockGraphNode:

+#

+# @id: Block graph node identifier. This @id is generated only for

+# x-debug-query-block-graph and does not relate to any other identifiers in

+# Qemu.

+#

+# @type: Type of graph node. Can be one of block-backend, block-job or

+# block-driver-state.

+#

+# @name: Human readable name of the node. Corresponds to node-name for

+# block-driver-state nodes; is not guaranteed to be unique in the whole

+# graph (with block-jobs and block-backends).

+#

+# Since: 4.0

+##

+{ 'struct': 'XDbgBlockGraphNode',

+ 'data': { 'id': 'uint64', 'type': 'XDbgBlockGraphNodeType', 'name': 'str' } }

+

+##

+# @BlockPermission:

+#

+# Enum of base block permissions.

+#

+# @consistent-read: A user that has the "permission" of consistent reads is

+# guaranteed that their view of the contents of the block

+# device is complete and self-consistent, representing the

+# contents of a disk at a specific point.

+# For most block devices (including their backing files) this

+# is true, but the property cannot be maintained in a few

+# situations like for intermediate nodes of a commit block

+# job.

+#

+# @write: This permission is required to change the visible disk contents.

+#

+# @write-unchanged: This permission (which is weaker than BLK_PERM_WRITE) is

+# both enough and required for writes to the block node when

+# the caller promises that the visible disk content doesn't

+# change.

+# As the BLK_PERM_WRITE permission is strictly stronger,

+# either is sufficient to perform an unchanging write.

+#

+# @resize: This permission is required to change the size of a block node.

+#

+# @graph-mod: This permission is required to change the node that this

+# BdrvChild points to.

+#

+# Since: 4.0

+##

+ { 'enum': 'BlockPermission',

+ 'data': [ 'consistent-read', 'write', 'write-unchanged', 'resize',

+ 'graph-mod' ] }

+##

+# @XDbgBlockGraphEdge:

+#

+# Block Graph edge description for x-debug-query-block-graph.

+#

+# @parent: parent id

+#

+# @child: child id

+#

+# @name: name of the relation (examples are 'file' and 'backing')

+#

+# @perm: granted permissions for the parent operating on the child

+#

+# @shared-perm: permissions that can still be granted to other users of the

+# child while it is still attached to this parent

+#

+# Since: 4.0

+##

+{ 'struct': 'XDbgBlockGraphEdge',

+ 'data': { 'parent': 'uint64', 'child': 'uint64',

+ 'name': 'str', 'perm': [ 'BlockPermission' ],

+ 'shared-perm': [ 'BlockPermission' ] } }

+

+##

+# @XDbgBlockGraph:

+#

+# Block Graph - list of nodes and list of edges.

+#

+# Since: 4.0

+##

+{ 'struct': 'XDbgBlockGraph',

+ 'data': { 'nodes': ['XDbgBlockGraphNode'], 'edges': ['XDbgBlockGraphEdge'] } }

+

+##

+# @x-debug-query-block-graph:

+#

+# Get the block graph.

+#

+# Since: 4.0

+##

+{ 'command': 'x-debug-query-block-graph', 'returns': 'XDbgBlockGraph' }

# @drive-mirror:

diff --git a/include/block/block.h b/include/block/block.h

--- a/include/block/block.h

+++ b/include/block/block.h

@@ -XXX,XX +XXX,XX @@ void bdrv_eject(BlockDriverState *bs, bool eject_flag);

const char *bdrv_get_format_name(BlockDriverState *bs);

BlockDriverState *bdrv_find_node(const char *node_name);

BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);

+XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);

BlockDriverState *bdrv_lookup_bs(const char *device,

const char *node_name,

Error **errp);

diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h

index XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/block-backend.h

+++ b/include/sysemu/block-backend.h

@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,

int bytes, BdrvRequestFlags read_flags,

BdrvRequestFlags write_flags);

+const BdrvChild *blk_root(BlockBackend *blk);

#endif

diff --git a/block.c b/block.c

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ 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)

diff --git a/block/block-backend.c b/block/block-backend.c

index XXXXXXX..XXXXXXX 100644

--- a/block/block-backend.c

+++ b/block/block-backend.c

@@ -XXX,XX +XXX,XX @@ 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;

+}

diff --git a/blockdev.c b/blockdev.c

index XXXXXXX..XXXXXXX 100644

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)

return bdrv_named_nodes_list(errp);

}

+XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)

+{

+ return bdrv_get_xdbg_block_graph(errp);

+}

+

BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,

Error **errp)

{

2.20.1

From: Laurent Vivier <lvivier@redhat.com>

Signed-off-by: Laurent Vivier <lvivier@redhat.com>

Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Message-id: 20181213162727.17438-5-lvivier@redhat.com

[mreitz: Fixed sheepdog_snapshot_create_inode's format string to use

PRIx32 for uint32_ts]

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/sheepdog.c | 47 +++++++++++++++++-----------------------------

block/trace-events | 14 ++++++++++++++

2 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/block/sheepdog.c b/block/sheepdog.c

--- a/block/sheepdog.c

+++ b/block/sheepdog.c

#include "sysemu/block-backend.h"

#include "qemu/bitops.h"

#include "qemu/cutils.h"

+#include "trace.h"

#define SD_PROTO_VER 0x01

@@ -XXX,XX +XXX,XX @@ 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;

@@ -XXX,XX +XXX,XX @@ 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);

}

@@ -XXX,XX +XXX,XX @@ 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;

}

@@ -XXX,XX +XXX,XX @@ 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;

}

@@ -XXX,XX +XXX,XX @@ 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) {

@@ -XXX,XX +XXX,XX @@ 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);

@@ -XXX,XX +XXX,XX @@ static int sd_create_branch(BDRVSheepdogState *s)

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

+ trace_sheepdog_create_branch_created(vid);

fd = connect_to_sdog(s, &local_err);

if (fd < 0) {

@@ -XXX,XX +XXX,XX @@ 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);

@@ -XXX,XX +XXX,XX @@ 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,

@@ -XXX,XX +XXX,XX @@ 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, "

@@ -XXX,XX +XXX,XX @@ 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;

@@ -XXX,XX +XXX,XX @@ 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);

diff --git a/block/trace-events b/block/trace-events

--- a/block/trace-events

+++ b/block/trace-events

@@ -XXX,XX +XXX,XX @@ file_xfs_discard(const char *error) "cannot punch hole (%s)"

file_FindEjectableOpticalMedia(const char *media) "Matching using %s"

file_setup_cdrom(const char *partition) "Using %s as optical disc"

file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"

+

+# block/sheepdog.c

+sheepdog_reconnect_to_sdog(void) "Wait for connection to be established"

+sheepdog_aio_read_response(void) "disable cache since the server doesn't support it"

+sheepdog_open(uint32_t vid) "0x%" PRIx32 " snapshot inode was open"

+sheepdog_close(const char *name) "%s"

+sheepdog_create_branch_snapshot(uint32_t vdi) "0x%" PRIx32 " is snapshot"

+sheepdog_create_branch_created(uint32_t vdi) "0x%" PRIx32 " is created"

+sheepdog_create_branch_new(uint32_t vdi) "0x%" PRIx32 " was newly created"

+sheepdog_co_rw_vector_update(uint32_t vdi, uint64_t oid, uint64_t data, long idx) "update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld"

+sheepdog_co_rw_vector_new(uint64_t oid) "new oid 0x%" PRIx64

+sheepdog_snapshot_create_info(const char *sn_name, const char *id, const char *name, int64_t size, int is_snapshot) "sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " " "is_snapshot %d"

+sheepdog_snapshot_create(const char *sn_name, const char *id) "%s %s"

+sheepdog_snapshot_create_inode(const char *name, uint32_t snap, uint32_t vdi) "s->inode: name %s snap_id 0x%" PRIx32 " vdi 0x%" PRIx32

2.20.1