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)

- 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

Laurent Vivier (4):

block/ssh: Convert from DPRINTF() macro to trace events

block/curl: Convert from DPRINTF() macro to trace events

block/file-posix: Convert from DPRINTF() macro to trace events

block/sheepdog: Convert from DPRINTF() macro to trace events

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: Li Qiang <liq3ea@163.com>

There is no need to make another reference.

Signed-off-by: Li Qiang <liq3ea@163.com>

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

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

Message-id: 20190120055558.32984-4-liq3ea@163.com

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

1 file changed, 4 insertions(+), 4 deletions(-)

pci_conf[PCI_INTERRUPT_PIN] = 1;

pci_config_set_prog_interface(pci_dev->config, 0x2);

pci_config_set_class(pci_dev->config, PCI_CLASS_STORAGE_EXPRESS);

- pcie_endpoint_cap_init(&n->parent_obj, 0x80);

+ pcie_endpoint_cap_init(pci_dev, 0x80);

n->num_namespaces = 1;

n->reg_size = pow2ceil(0x1004 + 2 * (n->num_queues + 1) * 4);

@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)

memory_region_init_io(&n->iomem, OBJECT(n), &nvme_mmio_ops, n,

"nvme", n->reg_size);

- pci_register_bar(&n->parent_obj, 0,

+ pci_register_bar(pci_dev, 0,

PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64,

&n->iomem);

- msix_init_exclusive_bar(&n->parent_obj, n->num_queues, 4, NULL);

+ msix_init_exclusive_bar(pci_dev, n->num_queues, 4, NULL);

id->vid = cpu_to_le16(pci_get_word(pci_conf + PCI_VENDOR_ID));

id->ssvid = cpu_to_le16(pci_get_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID));

@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)

n->cmbuf = g_malloc0(NVME_CMBSZ_GETSIZE(n->bar.cmbsz));

memory_region_init_io(&n->ctrl_mem, OBJECT(n), &nvme_cmb_ops, n,

"nvme-cmb", NVME_CMBSZ_GETSIZE(n->bar.cmbsz));

- pci_register_bar(&n->parent_obj, NVME_CMBLOC_BIR(n->bar.cmbloc),

+ pci_register_bar(pci_dev, NVME_CMBLOC_BIR(n->bar.cmbloc),

PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |

PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);

2.20.1

Render block nodes graph with help of graphviz. This new function is

for debugging, so there is no sense to put it into qemu.py as a method

of QEMUMachine. Let's instead put it separately.

Acked-by: Eduardo Habkost <ehabkost@redhat.com>

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

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

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

1 file changed, 120 insertions(+)

create mode 100755 scripts/render_block_graph.py

diff --git a/scripts/render_block_graph.py b/scripts/render_block_graph.py

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/scripts/render_block_graph.py

@@ -XXX,XX +XXX,XX @@

+#!/usr/bin/env python

+#

+# Render Qemu Block Graph

+#

+# Copyright (c) 2018 Virtuozzo International GmbH. All rights reserved.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program. If not, see <http://www.gnu.org/licenses/>.

+#

+

+import os

+import sys

+import subprocess

+import json

+from graphviz import Digraph

+from qemu import MonitorResponseError

+

+

+def perm(arr):

+ s = 'w' if 'write' in arr else '_'

+ s += 'r' if 'consistent-read' in arr else '_'

+ s += 'u' if 'write-unchanged' in arr else '_'

+ s += 'g' if 'graph-mod' in arr else '_'

+ s += 's' if 'resize' in arr else '_'

+ return s

+

+

+def render_block_graph(qmp, filename, format='png'):

+ '''

+ Render graph in text (dot) representation into "@filename" and

+ representation in @format into "@filename.@format"

+ '''

+

+ bds_nodes = qmp.command('query-named-block-nodes')

+ bds_nodes = {n['node-name']: n for n in bds_nodes}

+

+ job_nodes = qmp.command('query-block-jobs')

+ job_nodes = {n['device']: n for n in job_nodes}

+

+ block_graph = qmp.command('x-debug-query-block-graph')

+

+ graph = Digraph(comment='Block Nodes Graph')

+ graph.format = format

+ graph.node('permission symbols:\l'

+ ' w - Write\l'

+ ' r - consistent-Read\l'

+ ' u - write - Unchanged\l'

+ ' g - Graph-mod\l'

+ ' s - reSize\l'

+ 'edge label scheme:\l'

+ ' <child type>\l'

+ ' <perm>\l'

+ ' <shared_perm>\l', shape='none')

+

+ for n in block_graph['nodes']:

+ if n['type'] == 'block-driver':

+ info = bds_nodes[n['name']]

+ label = n['name'] + ' [' + info['drv'] + ']'

+ if info['drv'] == 'file':

+ label += '\n' + os.path.basename(info['file'])

+ shape = 'ellipse'

+ elif n['type'] == 'block-job':

+ info = job_nodes[n['name']]

+ label = info['type'] + ' job (' + n['name'] + ')'

+ shape = 'box'

+ else:

+ assert n['type'] == 'block-backend'

+ label = n['name'] if n['name'] else 'unnamed blk'

+ shape = 'box'

+

+ graph.node(str(n['id']), label, shape=shape)

+

+ for e in block_graph['edges']:

+ label = '%s\l%s\l%s\l' % (e['name'], perm(e['perm']),

+ perm(e['shared-perm']))

+ graph.edge(str(e['parent']), str(e['child']), label=label)

+

+ graph.render(filename)

+

+

+class LibvirtGuest():

+ def __init__(self, name):

+ self.name = name

+

+ def command(self, cmd):

+ # only supports qmp commands without parameters

+ m = {'execute': cmd}

+ ar = ['virsh', 'qemu-monitor-command', self.name, json.dumps(m)]

+

+ reply = json.loads(subprocess.check_output(ar))

+

+ if 'error' in reply:

+ raise MonitorResponseError(reply)

+

+ return reply['return']

+

+

+if __name__ == '__main__':

+ obj = sys.argv[1]

+ out = sys.argv[2]

+

+ if os.path.exists(obj):

+ # assume unix socket

+ qmp = QEMUMonitorProtocol(obj)

+ qmp.connect()

+ else:

+ # assume libvirt guest name

+ qmp = LibvirtGuest(obj)

+

+ render_block_graph(qmp, out)

2.20.1

To do this, we need to allow creating the NBD server on various ports

instead of a single one (which may not even work if you run just one

instance, because something entirely else might be using that port).

So we just pick a random port in [32768, 32768 + 1024) and try to create

a server there. If that fails, we just retry until something sticks.

For the IPv6 test, we need a different range, though (just above that

one). This is because "localhost" resolves to both 127.0.0.1 and ::1.

This means that if you bind to it, it will bind to both, if possible, or

just one if the other is already in use. Therefore, if the IPv6 test

has already taken [::1]:some_port and we then try to take

localhost:some_port, that will work -- only the second server will be

bound to 127.0.0.1:some_port alone and not [::1]:some_port in addition.

So we have two different servers on the same port, one for IPv4 and one

for IPv6.

But when we then try to connect to the server through

localhost:some_port, we will always end up at the IPv6 one (as long as

it is up), and this may not be the one we want.

Thus, we must make sure not to create an IPv6-only NBD server on the

same port as a normal "dual-stack" NBD server -- which is done by using

distinct port ranges, as explained above.

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

Message-id: 20181221234750.23577-4-mreitz@redhat.com

Reviewed-by: John Snow <jsnow@redhat.com>

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

1 file changed, 68 insertions(+), 30 deletions(-)

diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147

--- a/tests/qemu-iotests/147

+++ b/tests/qemu-iotests/147

@@ -XXX,XX +XXX,XX @@

#

import os

+import random

import socket

import stat

import time

import iotests

-from iotests import cachemode, imgfmt, qemu_img, qemu_nbd

+from iotests import cachemode, imgfmt, qemu_img, qemu_nbd, qemu_nbd_pipe

-NBD_PORT = 10811

+NBD_PORT_START = 32768

+NBD_PORT_END = NBD_PORT_START + 1024

+NBD_IPV6_PORT_START = NBD_PORT_END

+NBD_IPV6_PORT_END = NBD_IPV6_PORT_START + 1024

test_img = os.path.join(iotests.test_dir, 'test.img')

unix_socket = os.path.join(iotests.test_dir, 'nbd.socket')

@@ -XXX,XX +XXX,XX @@ class QemuNBD(NBDBlockdevAddBase):

except OSError:

pass

+ def _try_server_up(self, *args):

+ status, msg = qemu_nbd_pipe('-f', imgfmt, test_img, *args)

+ if status == 0:

+ return True

+ if 'Address already in use' in msg:

+ return False

+ self.fail(msg)

def _server_up(self, *args):

- self.assertEqual(qemu_nbd('-f', imgfmt, test_img, *args), 0)

+ self.assertTrue(self._try_server_up(*args))

def test_inet(self):

- self._server_up('-b', 'localhost', '-p', str(NBD_PORT))

+ while True:

+ nbd_port = random.randrange(NBD_PORT_START, NBD_PORT_END)

+ if self._try_server_up('-b', 'localhost', '-p', str(nbd_port)):

+ break

address = { 'type': 'inet',

'data': {

'host': 'localhost',

- 'port': str(NBD_PORT)

+ 'port': str(nbd_port)

} }

- self.client_test('nbd://localhost:%i' % NBD_PORT,

+ self.client_test('nbd://localhost:%i' % nbd_port,

flatten_sock_addr(address))

def test_unix(self):

@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):

except OSError:

pass

- def _server_up(self, address, export_name=None, export_name2=None):

+ # Returns False on EADDRINUSE; fails an assertion on other errors.

+ # Returns True on success.

+ def _try_server_up(self, address, export_name=None, export_name2=None):

result = self.server.qmp('nbd-server-start', addr=address)

+ if 'error' in result and \

+ 'Address already in use' in result['error']['desc']:

+ return False

self.assert_qmp(result, 'return', {})

if export_name is None:

@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):

name=export_name2)

self.assert_qmp(result, 'return', {})

+ return True

+ def _server_up(self, address, export_name=None, export_name2=None):

+ self.assertTrue(self._try_server_up(address, export_name, export_name2))

def _server_down(self):

result = self.server.qmp('nbd-server-stop')

self.assert_qmp(result, 'return', {})

def do_test_inet(self, export_name=None):

- address = { 'type': 'inet',

- 'data': {

- 'host': 'localhost',

- 'port': str(NBD_PORT)

- } }

- self._server_up(address, export_name)

+ while True:

+ nbd_port = random.randrange(NBD_PORT_START, NBD_PORT_END)

+ address = { 'type': 'inet',

+ 'data': {

+ 'host': 'localhost',

+ 'port': str(nbd_port)

+ } }

+ if self._try_server_up(address, export_name):

+ break

export_name = export_name or 'nbd-export'

- self.client_test('nbd://localhost:%i/%s' % (NBD_PORT, export_name),

+ self.client_test('nbd://localhost:%i/%s' % (nbd_port, export_name),

flatten_sock_addr(address), export_name)

self._server_down()

@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):

self.do_test_inet('shadow')

def test_inet_two_exports(self):

- address = { 'type': 'inet',

- 'data': {

- 'host': 'localhost',

- 'port': str(NBD_PORT)

- } }

- self._server_up(address, 'exp1', 'exp2')

- self.client_test('nbd://localhost:%i/%s' % (NBD_PORT, 'exp1'),

+ while True:

+ nbd_port = random.randrange(NBD_PORT_START, NBD_PORT_END)

+ address = { 'type': 'inet',

+ 'data': {

+ 'host': 'localhost',

+ 'port': str(nbd_port)

+ } }

+ if self._try_server_up(address, 'exp1', 'exp2'):

+ break

+

+ self.client_test('nbd://localhost:%i/%s' % (nbd_port, 'exp1'),

flatten_sock_addr(address), 'exp1', 'node1', False)

- self.client_test('nbd://localhost:%i/%s' % (NBD_PORT, 'exp2'),

+ self.client_test('nbd://localhost:%i/%s' % (nbd_port, 'exp2'),

flatten_sock_addr(address), 'exp2', 'node2', False)

result = self.vm.qmp('blockdev-del', node_name='node1')

self.assert_qmp(result, 'return', {})

@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):

except socket.gaierror:

# IPv6 not available, skip

return

- address = { 'type': 'inet',

- 'data': {

- 'host': '::1',

- 'port': str(NBD_PORT),

- 'ipv4': False,

- 'ipv6': True

- } }

+

+ while True:

+ nbd_port = random.randrange(NBD_IPV6_PORT_START, NBD_IPV6_PORT_END)

+ address = { 'type': 'inet',

+ 'data': {

+ 'host': '::1',

+ 'port': str(nbd_port),

+ 'ipv4': False,

+ 'ipv6': True

+ } }

+ if self._try_server_up(address):

+ break

+

filename = { 'driver': 'raw',

'file': {

'driver': 'nbd',

'export': 'nbd-export',

'server': flatten_sock_addr(address)

} }

- self._server_up(address)

self.client_test(filename, flatten_sock_addr(address), 'nbd-export')

self._server_down()

2.20.1

In some cases, we may want to deal with qemu-nbd errors (e.g. by

launching it in a different configuration until it no longer throws

any). In that case, we do not want its output ending up in the test

output.

It may still be useful for handling the error, though, so add a new

function that works basically like qemu_nbd(), only that it returns the

qemu-nbd output instead of making it end up in the log. In contrast to

qemu_img_pipe(), it does still return the exit code as well, though,

because that is even more important for error handling.

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

Message-id: 20181221234750.23577-2-mreitz@redhat.com

Reviewed-by: John Snow <jsnow@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

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

1 file changed, 14 insertions(+)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py

--- a/tests/qemu-iotests/iotests.py

+++ b/tests/qemu-iotests/iotests.py

@@ -XXX,XX +XXX,XX @@ def qemu_nbd(*args):

'''Run qemu-nbd in daemon mode and return the parent's exit code'''

return subprocess.call(qemu_nbd_args + ['--fork'] + list(args))

+def qemu_nbd_pipe(*args):

+ '''Run qemu-nbd in daemon mode and return both the parent's exit code

+ and its output'''

+ subp = subprocess.Popen(qemu_nbd_args + ['--fork'] + list(args),

+ stdout=subprocess.PIPE,

+ stderr=subprocess.STDOUT,

+ universal_newlines=True)

+ exitcode = subp.wait()

+ if exitcode < 0:

+ sys.stderr.write('qemu-nbd received signal %i: %s\n' %

+ (-exitcode,

+ ' '.join(qemu_nbd_args + ['--fork'] + list(args))))

+ return exitcode, subp.communicate()[0]

+

def compare_images(img1, img2, fmt1=imgfmt, fmt2=imgfmt):

'''Return True if two image files are identical'''

return qemu_img('compare', '-f', fmt1,

2.20.1

From: Li Qiang <liq3ea@163.com>

When it is zero, it causes segv.

Using following command:

"-drive file=//home/test/test1.img,if=none,id=id0

-device nvme,drive=id0,serial=test,num_queues=0"

causes following Backtrack:

Thread 4 "qemu-system-x86" received signal SIGSEGV, Segmentation fault.

[Switching to Thread 0x7fffe9735700 (LWP 30952)]

0x0000555555a7a77c in nvme_start_ctrl (n=0x5555577473f0) at hw/block/nvme.c:825

825     if (unlikely(n->cq[0])) {

(gdb) bt

0 0x0000555555a7a77c in nvme_start_ctrl (n=0x5555577473f0)

at hw/block/nvme.c:825

1 0x0000555555a7af7f in nvme_write_bar (n=0x5555577473f0, offset=20,

data=4587521, size=4) at hw/block/nvme.c:969

2 0x0000555555a7b81a in nvme_mmio_write (opaque=0x5555577473f0, addr=20,

data=4587521, size=4) at hw/block/nvme.c:1163

3 0x0000555555869236 in memory_region_write_accessor (mr=0x555557747cd0,

addr=20, value=0x7fffe97320f8, size=4, shift=0, mask=4294967295, attrs=...)

at /home/test/qemu1/qemu/memory.c:502

4 0x0000555555869446 in access_with_adjusted_size (addr=20,

value=0x7fffe97320f8, size=4, access_size_min=2, access_size_max=8,

access_fn=0x55555586914d <memory_region_write_accessor>,

mr=0x555557747cd0, attrs=...) at /home/test/qemu1/qemu/memory.c:568

5 0x000055555586c479 in memory_region_dispatch_write (mr=0x555557747cd0,

addr=20, data=4587521, size=4, attrs=...)

at /home/test/qemu1/qemu/memory.c:1499

6 0x00005555558030af in flatview_write_continue (fv=0x7fffe0061130,

addr=4273930260, attrs=..., buf=0x7ffff7ff0028 "\001", len=4, addr1=20,

l=4, mr=0x555557747cd0) at /home/test/qemu1/qemu/exec.c:3234

7 0x00005555558031f9 in flatview_write (fv=0x7fffe0061130, addr=4273930260,

attrs=..., buf=0x7ffff7ff0028 "\001", len=4)

at /home/test/qemu1/qemu/exec.c:3273

8 0x00005555558034ff in address_space_write (

---Type <return> to continue, or q <return> to quit---

as=0x555556758480 <address_space_memory>, addr=4273930260, attrs=...,

buf=0x7ffff7ff0028 "\001", len=4) at /home/test/qemu1/qemu/exec.c:3363

9 0x0000555555803550 in address_space_rw (

as=0x555556758480 <address_space_memory>, addr=4273930260, attrs=...,

buf=0x7ffff7ff0028 "\001", len=4, is_write=true)

at /home/test/qemu1/qemu/exec.c:3374

10 0x00005555558884a1 in kvm_cpu_exec (cpu=0x555556920e40)

at /home/test/qemu1/qemu/accel/kvm/kvm-all.c:2031

11 0x000055555584cd9d in qemu_kvm_cpu_thread_fn (arg=0x555556920e40)

at /home/test/qemu1/qemu/cpus.c:1281

12 0x0000555555dbaf6d in qemu_thread_start (args=0x5555569438a0)

at util/qemu-thread-posix.c:502

13 0x00007ffff5dc86db in start_thread (arg=0x7fffe9735700)

at pthread_create.c:463

14 0x00007ffff5af188f in clone ()

at ../sysdeps/unix/sysv/linux/x86_64/clone.S:95

Signed-off-by: Li Qiang <liq3ea@163.com>

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

Message-id: 20190120055558.32984-3-liq3ea@163.com

hw/block/nvme.c | 5 +++++

1 file changed, 5 insertions(+)

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

--- a/hw/block/nvme.c

+++ b/hw/block/nvme.c

@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)

int64_t bs_size;

uint8_t *pci_conf;

+ if (!n->num_queues) {

+ error_setg(errp, "num_queues can't be zero");

+ return;

+ }

+

if (!n->conf.blk) {

error_setg(errp, "drive property not set");

return;

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

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(+)

diff --git a/qapi/block-core.json b/qapi/block-core.json

--- a/qapi/block-core.json

+++ b/qapi/block-core.json

@@ -XXX,XX +XXX,XX @@

##

{ '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

index XXXXXXX..XXXXXXX 100644

--- 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) {

+ /*

+ * 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);

+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);