| /qemu/include/io/ |
| H A D | channel-socket.h | 11 * This library is distributed in the hope that it will be useful,
90 * will run in the foreground so the caller will not regain
106 * context will be used.
109 * will run in the background so the caller will regain
111 * will be invoked on completion or failure. The @addr
112 * parameter will be copied, so may be freed as soon
131 * will run in the foreground so the caller will not regain
149 * context will be used.
152 * will run in the background so the caller will regain
154 * will be invoked on completion or failure. The @addr
[all …]
|
| H A D | channel-tls.h | 11 * This library is distributed in the hope that it will be useful,
60 * Perform the TLS session termination. This method will return
61 * immediately and the termination will continue in the background,
74 * a TLS session. The TLS session handshake will use the
76 * is non-NULL, then the client will have to provide
77 * credentials (ie a x509 client certificate) which will
104 * a TLS session. The TLS session handshake will use the
107 * and will be validated against the server's credentials
132 * @context: the context that TLS handshake will run with. If %NULL,
133 * the default context will be used
[all …]
|
| H A D | channel.h | 11 * This library is distributed in the hope that it will be useful,
78 * will be subclasses for dealing with sockets, files, and higher
211 * @fds: pointer to an array that will received file handles
218 * in the @iov will be fully populated with data
224 * one byte of data will be read, but no more is
226 * data is available, it will return QIO_CHANNEL_ERR_BLOCK
229 * the @fds array pointer will be allocated and
231 * descriptors. The @nfds pointer will be updated
266 * in the @iov will be fully sent, before the next
272 * one byte of data will be sent, but no more is
[all …]
|
| H A D | task.h | 11 * This library is distributed in the hope that it will be useful,
55 * When the operation completes, the 'func' callback will be
107 * QIOTask will hold a reference on that. This ensure that
111 * In this case, myobject_operation_timer will fire after
137 * The 'qio_task_complete' call in this method will trigger
141 * Once this function returns false, object_unref will be called
154 * For example, the socket_listen() method will block the caller
193 * will be invoked from the main event thread, despite the
207 * @func will be invoked. The callback can access the
211 * The returned task will be released when qio_task_complete()
[all …]
|
| /qemu/docs/devel/ |
| H A D | multi-process.rst | 51 A QEMU control process would remain, but in multi-process mode, will
85 parent object (such as "pci-device" for a PCI device) and QEMU will
195 emulation applications will need to include the QEMU block objects.
209 The remote emulation process will run the QEMU object hierarchy without
210 modification. The device emulation objects will be also be based on the
215 The processes will communicate with the QEMU process over UNIX domain
218 processes will provide are specified on its command line, as they would
237 The first argument to the remote emulation process will be a Unix domain
304 The proxy object model will use device proxy objects to replace the
305 device emulation code within the QEMU process. These objects will live
[all …]
|
| H A D | tcg-plugins.rst | 29 The core code will refuse to load a plugin that doesn't export a
34 ``qemu_plugin_install`` method of a plugin will detail the minimum and
35 current API versions supported by QEMU. The API version will be
36 incremented if new APIs are added. The minimum API version will be
53 is called. The plugin will then register callbacks for various plugin
54 events. Generally plugins will register a handler for the *atexit*
91 All code will go through a translation phase although not all
92 translations will be necessarily be executed. You need to instrument
99 paging this will change too.
101 Not all instructions in a block will always execute so if its
[all …]
|
| H A D | s390-dasd-ipl.rst | 12 so when it is complete another ccw will be fetched and executed from memory
21 the original READ IPL ccw. The read ccw will read the IPL2 data into memory
22 and the TIC (Transfer In Channel) will transfer control to the channel
29 The TIC ccw instruction at the end of the IPL1 channel program will begin
31 process and will contain a larger channel program than IPL1. The point of
50 psw's instruction address will point to the location in memory where we want
58 off the reading of IPL1 data. Since the channel program from IPL1 will be
60 will be executed immediately (the special read ccw has the chaining bit turned
61 on). The TIC at the end of the IPL1 channel program will cause the IPL2 channel
83 channel commands that read additional channel commands will not work as expected
[all …]
|
| H A D | qapi-domain.rst | 30 these forms will not be needed for documentation writing purposes,
31 understanding the cross-referencing syntax *will* be helpful when
78 * Creates an ungrouped field: i.e., each entry will create its own
79 section and they will not be combined.
89 * Creates a grouped field: i.e. multiple adjacent entries will be
90 merged into one section, and the content will form a bulleted list.
96 * All items will be generated with the form: "argument -- body"
104 * Creates a grouped, typed field. Multiple adjacent entres will be
105 merged into one section, and the content will form a bulleted list.
112 * All items will be generated with the form "name (type) -- body"
[all …]
|
| /qemu/include/hw/ |
| H A D | ptimer.h | 17 * using ptimer_run(), the value will count downwards at the frequency
19 * When it reaches zero it will trigger a callback function, and
26 * When ptimer_transaction_commit() is called it will evaluate the state
32 * bug in the QEMU device and will cause warning messages to be printed
89 * ptimer_set_count() or ptimer_set_limit() will not trigger the timer
90 * (though it will cause a reload). Only a counter decrement to "0"
91 * will cause a trigger. Not compatible with NO_IMMEDIATE_TRIGGER;
92 * ptimer_init() will assert() that you don't set both.
108 * If a ptimer is created using this API then will use the
119 * is called it will evaluate the state of the timer after all the
[all …]
|
| /qemu/crypto/ |
| H A D | der.h | 10 * This library is distributed in the hope that it will be useful,
46 * callback will be invoked
52 * will be set to the rest length of data, if cb is not NULL, must
54 * part of the decoded INTEGER will be returned. Otherwise, -1 is
70 * callback will be invoked
74 * will be set to the rest length of data, if cb is not NULL, must
76 * part of the decoded SEQUENCE will be returned. Otherwise, -1 is
93 * callback will be invoked
97 * will be set to the rest length of data, if cb is not NULL, must
99 * part of the decoded OID will be returned. Otherwise, -1 is
[all …]
|
| /qemu/docs/system/ |
| H A D | virtio-net-failover.rst | 12 module will pair net devices with the same MAC address.
33 another host QEMU will unplug the primary device via the PCIe based hotplug
34 handler and traffic will go through the virtio-net device. On the target
35 system the primary device will be automatically plugged back and the
46 With the parameter failover=on the VIRTIO_NET_F_STANDBY feature will be enabled.
52 net_failover will match devices with identical MAC addresses.
58 that if the virtio-net device is plugged first a warning will be issued that it
65 devices are present in the configuration, migration will go into this state.
66 It will wait until the device unplug is completed in the guest and then move into
67 active state. On the target system the primary devices will be automatically hotplugged
|
| H A D | gdb.rst | 14 The ``-s`` option will make QEMU listen for an incoming connection
15 from gdb on TCP port 1234, and ``-S`` will make QEMU not start the
25 QEMU will launch but will silently wait for gdb to connect.
56 accelerators it will depend on if support has been added (see
97 When you connect gdb to the gdbstub, it will automatically
109 Once connected, gdb will have a single inferior, for the
123 Once you've done this, ``info threads`` will show CPUs in
157 Note that to use a unix socket for the connection you will need
178 This will display the MASK bits used to control the single stepping
188 This will display the current value of the mask used when single
[all …]
|
| H A D | device-emulation.rst | 22 options ``--device help`` will list all devices it is aware of. Using
23 the command line ``--device foo,help`` will list the additional
32 Most devices will exist on a BUS of some sort. Depending on the
33 machine model you choose (``-M foo``) a number of buses will have been
41 Some devices, for example a PCI SCSI host controller, will add an
56 The back end describes how the data from the emulated device will be
59 devices will be backed by a ``--chardev`` which can redirect the data
61 by ``--blockdev`` which will specify how blocks are handled, for
67 there are cases where features will not be reported to the guest if
|
| /qemu/include/crypto/ |
| H A D | hash.h | 12 * This library is distributed in the hope that it will be useful,
81 * @result_len match the size of the hash output. The digest will
84 * If @result_len is set to zero, then this function will allocate
113 * @result_len match the size of the hash output. The digest will
116 * If @result_len is set to zero, then this function will allocate
140 * present in @iov. The @digest pointer will be
142 * hash, which will be terminated by '\0'. The
195 * The @digest pointer will be filled with the printable hex digest of the
196 * computed hash, which will be terminated by '\0'. The memory pointer
214 * The @base64 pointer will be filled with the base64 encoding of the computed
[all …]
|
| /qemu/block/ |
| H A D | graph-lock.c | 12 * This library is distributed in the hope that it will be useful,
98 /* rd can temporarily be negative, but the total will *always* be >= 0 */ in reader_count()
119 * reader_count == 0: this means writer will read has_reader as 1 in bdrv_graph_wrlock()
185 * has_writer == 0: this means writer will read reader_count as >= 1 in bdrv_graph_co_rdlock()
188 * it will write. in bdrv_graph_co_rdlock()
197 * If this critical section gets executed first, reader_count will in bdrv_graph_co_rdlock()
198 * decrease and the reader will go to sleep. in bdrv_graph_co_rdlock()
199 * Then the writer will read reader_count that does not take into in bdrv_graph_co_rdlock()
200 * account this reader, and if there's no other reader it will in bdrv_graph_co_rdlock()
204 * then writer will read reader_count >= 1. in bdrv_graph_co_rdlock()
[all …]
|
| /qemu/tests/qemu-iotests/ |
| H A D | 060.out | 11 …lid write on metadata (overlaps with active L1 table); further corruption events will be suppressed
39 …alid write on metadata (overlaps with refcount block); further corruption events will be suppressed
75 …d write on metadata (overlaps with inactive L2 table); further corruption events will be suppressed
110 …lid write on metadata (overlaps with active L2 table); further corruption events will be suppressed
121 …nvalid write on metadata (overlaps with qcow2_header); further corruption events will be suppressed
129 …rupt: L2 table offset 0x42a00 unaligned (L1 index: 0); further corruption events will be suppressed
134 …rupt: L2 table offset 0x42a00 unaligned (L1 index: 0); further corruption events will be suppressed
142 …t 0x52a00 unaligned (L2 offset: 0x40000, L2 index: 0); further corruption events will be suppressed
150 …t 0x52a00 unaligned (L2 offset: 0x40000, L2 index: 0); further corruption events will be suppressed
156 …Refblock offset 0x22a00 unaligned (reftable index: 0); further corruption events will be suppressed
[all …]
|
| /qemu/linux-headers/linux/ |
| H A D | userfaultfd.h | 69 * same UFFD_API more ioctl can be added and userland will be aware of
176 * with UFFDIO_REGISTER_MODE_MISSING mode will succeed on
185 * will be returned by UFFDIO_API on a kernel without
189 * uffdio_api.features and instead it will be set by the
200 * (UFFD_EVENT_PAGEFAULT) event will be delivered, instead
201 * a SIGBUS signal will be sent to the faulting process.
203 * UFFD_FEATURE_THREAD_ID pid of the page faulted task_struct will
204 * be returned, if feature is not requested 0 will be returned.
221 * write-protection mode will always apply to unpopulated pages
222 * (i.e. empty ptes). This will be the default behavior for shmem
[all …]
|
| /qemu/target/hexagon/idef-parser/ |
| H A D | README.rst | 22 idef-parser will compile the above code into the following code:
36 The output of the compilation process will be a function, containing the
37 tinycode generator code, implementing the correct semantics. That function will
38 not access any global variable, because all the accessed data structures will be
39 passed explicitly as function parameters. Among the passed parameters we will
52 TCG variables that will be passed to the generated function. Parameters marked
55 We will leverage this information to infer several information:
77 will be declared, ``RsV`` and ``RtV`` will also be read and ``RdV`` will be
101 correct destination register. This code may seem inefficient, but QEMU will
253 ``riV``, etc. refer to immediate arguments and will map to C integers.
[all …]
|
| /qemu/docs/tools/ |
| H A D | qemu-img.rst | 95 If specified, ``qemu-img`` will open the image in shared mode, allowing
104 Will enumerate information about backing files in a disk image chain. Refer
192 but will not automatically sparsify zero sectors, and may result in a fully
203 will still be printed. Areas that cannot be read from the source will be
208 Assume that reading the destination image will always return
359 will yield the exit code 0, independently of the image state before.
364 If the backing file is smaller than the snapshot, then the backing file will be
366 the backing file, the backing file will not be truncated. If you want the
375 layer, the backing file into which the changes will be committed may be
378 image (which is *FILENAME*) will be used. Note that after a commit operation
[all …]
|
| /qemu/python/ |
| H A D | README.rst | 10 ``setup.py``. You will generally invoke it by doing one of the following:
12 1. ``pip3 install .`` will install these packages to your current
13 environment. If you are inside a virtual environment, they will
14 install there. If you are not, it will attempt to install to the
17 2. ``pip3 install --user .`` will install these packages to your user's
19 this will fail; you want the first invocation above.
22 above, pip will install in "editable" mode. This installs the package as
27 Installing ".[devel]" instead of "." will additionally pull in required
31 Running ``make develop`` will pull in all testing dependencies and
|
| /qemu/tests/qemu-iotests/tests/ |
| H A D | block-status-cache | 13 # This program is distributed in the hope that it will be useful,
75 # This will probably detect an allocated data sector first (qemu likes
77 # then the rest to be zero. The BSC will thus contain (if anything)
91 # have the first sector in the cache, and so this will be served from
92 # the cache; and only the subsequent range will be queried from the
93 # block driver. This subsequent range will then be entered into the
103 # will go to the driver, which will return a result that reports the
104 # whole image to be a single data area. This result will then go into
105 # the cache, and so the cache will then report the whole image to
109 # subsequent map operation will be served from the cache, and so we can
|
| /qemu/docs/specs/ |
| H A D | fw_cfg.rst | 25 Setting the selector register will cause the data offset to be set
31 read, and all write access to the data port will be ignored. A value
38 longer supported, and will be ignored (treated as no-ops)!
63 port number will always be one greater than the port number of the
72 will be set to zero. Each successful access to the data register will
77 end of this maximum data length, then any reads will return a data
78 value of 0x00, and all writes will be ignored.
80 An N-byte wide read of the data register will return the next available
116 present, the four bytes read will contain the characters ``QEMU``.
217 If the ``control`` field has bit 1 set, a read operation will be performed.
[all …]
|
| H A D | ppc-spapr-numa.rst | 62 to the same first boundary will have the shortest distance from each
195 * user distance 11 to 30 will be interpreted as 20
196 * user distance 31 to 60 will be interpreted as 40
197 * user distance 61 to 120 will be interpreted as 80
198 * user distance 121 and beyond will be interpreted as 160
206 have to accept that a large array of values will be translated to the same
225 Will both be translated to the same values internally:
277 * distance from 0 to 1 is 40 (no match at 0x4 and 0x3, will match
279 * distance from 0 to 2 is 20 (no match at 0x4, will match at 0x3)
280 * distance from 0 to 3 is 40 (no match at 0x4 and 0x3, will match
[all …]
|
| H A D | riscv-aia.rst | 16 From an user standpoint, these modes will behave the same regardless of the accelerator
17 used. From a developer standpoint the accelerator settings will change what it being
27 - with "aia=aplic", s-mode APLIC will be emulated by userspace
29 is provided there will be no APLIC or IMSIC emulation in userspace, and the virtual
30 machine will use the provided in-kernel APLIC and IMSIC controllers. If the user
32 s-mode APLIC will be emulated while using the s-mode IMSIC from the irqchip
35 we will emulate in userspace:
|
| /qemu/tests/qtest/libqos/ |
| H A D | qgraph.h | 10 * This library is distributed in the hope that it will be useful,
53 * @arg: optional arg that will be used by dest edge
54 * @size_arg: @arg size that will be used by dest edge
85 * @edge: edge arguments that will be used by test.
105 * Each driver, test or machine of this framework will have a
116 * previous node, the framework will call
129 * In case no constructor is provided, no destructor will be
175 * The test will consume a @interface node, and once the
176 * graph walking algorithm has found it, the @test_func will be
193 * This node will be of type QNODE_MACHINE and have @function
[all …]
|