2012-08-10 21:00:43 +04:00
|
|
|
#ifndef QDEV_CORE_H
|
|
|
|
#define QDEV_CORE_H
|
|
|
|
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/queue.h"
|
2013-07-29 18:17:43 +04:00
|
|
|
#include "qemu/bitmap.h"
|
2012-12-17 21:19:50 +04:00
|
|
|
#include "qom/object.h"
|
2014-02-05 19:36:45 +04:00
|
|
|
#include "hw/hotplug.h"
|
2020-01-30 19:02:04 +03:00
|
|
|
#include "hw/resettable.h"
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
enum {
|
|
|
|
DEV_NVECTORS_UNSPECIFIED = -1,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TYPE_DEVICE "device"
|
|
|
|
#define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE)
|
|
|
|
#define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE)
|
|
|
|
#define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE)
|
|
|
|
|
2013-07-29 18:17:44 +04:00
|
|
|
typedef enum DeviceCategory {
|
|
|
|
DEVICE_CATEGORY_BRIDGE,
|
|
|
|
DEVICE_CATEGORY_USB,
|
|
|
|
DEVICE_CATEGORY_STORAGE,
|
|
|
|
DEVICE_CATEGORY_NETWORK,
|
|
|
|
DEVICE_CATEGORY_INPUT,
|
|
|
|
DEVICE_CATEGORY_DISPLAY,
|
|
|
|
DEVICE_CATEGORY_SOUND,
|
|
|
|
DEVICE_CATEGORY_MISC,
|
2017-01-20 16:01:16 +03:00
|
|
|
DEVICE_CATEGORY_CPU,
|
2013-07-29 18:17:44 +04:00
|
|
|
DEVICE_CATEGORY_MAX
|
|
|
|
} DeviceCategory;
|
|
|
|
|
2013-01-09 06:58:11 +04:00
|
|
|
typedef void (*DeviceRealize)(DeviceState *dev, Error **errp);
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 18:29:24 +03:00
|
|
|
typedef void (*DeviceUnrealize)(DeviceState *dev);
|
2018-01-14 05:04:10 +03:00
|
|
|
typedef void (*DeviceReset)(DeviceState *dev);
|
2013-11-26 02:48:40 +04:00
|
|
|
typedef void (*BusRealize)(BusState *bus, Error **errp);
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 18:29:24 +03:00
|
|
|
typedef void (*BusUnrealize)(BusState *bus);
|
2012-08-10 21:00:43 +04:00
|
|
|
|
2013-01-09 06:58:11 +04:00
|
|
|
/**
|
|
|
|
* DeviceClass:
|
|
|
|
* @props: Properties accessing state fields.
|
|
|
|
* @realize: Callback function invoked when the #DeviceState:realized
|
2018-05-28 17:45:09 +03:00
|
|
|
* property is changed to %true.
|
2013-01-09 06:58:11 +04:00
|
|
|
* @unrealize: Callback function invoked when the #DeviceState:realized
|
|
|
|
* property is changed to %false.
|
2014-02-05 19:36:46 +04:00
|
|
|
* @hotpluggable: indicates if #DeviceClass is hotpluggable, available
|
|
|
|
* as readonly "hotpluggable" property of #DeviceState instance
|
2013-01-09 06:58:11 +04:00
|
|
|
*
|
|
|
|
* # Realization #
|
|
|
|
* Devices are constructed in two stages,
|
|
|
|
* 1) object instantiation via object_initialize() and
|
|
|
|
* 2) device realization via #DeviceState:realized property.
|
2018-09-10 10:46:26 +03:00
|
|
|
* The former may not fail (and must not abort or exit, since it is called
|
|
|
|
* during device introspection already), and the latter may return error
|
|
|
|
* information to the caller and must be re-entrant.
|
2013-01-09 06:58:11 +04:00
|
|
|
* Trivial field initializations should go into #TypeInfo.instance_init.
|
|
|
|
* Operations depending on @props static properties should go into @realize.
|
|
|
|
* After successful realization, setting static properties will fail.
|
|
|
|
*
|
2015-06-19 17:17:23 +03:00
|
|
|
* As an interim step, the #DeviceState:realized property can also be
|
2020-06-10 08:32:46 +03:00
|
|
|
* set with qdev_realize().
|
2013-01-09 06:58:11 +04:00
|
|
|
* In the future, devices will propagate this state change to their children
|
|
|
|
* and along busses they expose.
|
|
|
|
* The point in time will be deferred to machine creation, so that values
|
|
|
|
* set in @realize will not be introspectable beforehand. Therefore devices
|
|
|
|
* must not create children during @realize; they should initialize them via
|
|
|
|
* object_initialize() in their own #TypeInfo.instance_init and forward the
|
|
|
|
* realization events appropriately.
|
|
|
|
*
|
|
|
|
* Any type may override the @realize and/or @unrealize callbacks but needs
|
2013-01-17 11:31:50 +04:00
|
|
|
* to call the parent type's implementation if keeping their functionality
|
|
|
|
* is desired. Refer to QOM documentation for further discussion and examples.
|
|
|
|
*
|
|
|
|
* <note>
|
|
|
|
* <para>
|
2018-05-28 17:45:09 +03:00
|
|
|
* Since TYPE_DEVICE doesn't implement @realize and @unrealize, types
|
|
|
|
* derived directly from it need not call their parent's @realize and
|
|
|
|
* @unrealize.
|
2013-01-17 11:31:50 +04:00
|
|
|
* For other types consult the documentation and implementation of the
|
|
|
|
* respective parent types.
|
|
|
|
* </para>
|
|
|
|
* </note>
|
2019-10-29 14:48:55 +03:00
|
|
|
*
|
|
|
|
* # Hiding a device #
|
|
|
|
* To hide a device, a DeviceListener function should_be_hidden() needs to
|
|
|
|
* be registered.
|
|
|
|
* It can be used to defer adding a device and therefore hide it from the
|
|
|
|
* guest. The handler registering to this DeviceListener can save the QOpts
|
|
|
|
* passed to it for re-using it later and must return that it wants the device
|
|
|
|
* to be/remain hidden or not. When the handler function decides the device
|
|
|
|
* shall not be hidden it will be added in qdev_device_add() and
|
|
|
|
* realized as any other device. Otherwise qdev_device_add() will return early
|
|
|
|
* without adding the device. The guest will not see a "hidden" device
|
|
|
|
* until it was marked don't hide and qdev_device_add called again.
|
|
|
|
*
|
2013-01-09 06:58:11 +04:00
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
typedef struct DeviceClass {
|
2013-01-09 06:58:11 +04:00
|
|
|
/*< private >*/
|
2012-08-10 21:00:43 +04:00
|
|
|
ObjectClass parent_class;
|
2013-01-09 06:58:11 +04:00
|
|
|
/*< public >*/
|
2012-08-10 21:00:43 +04:00
|
|
|
|
2013-07-29 18:17:44 +04:00
|
|
|
DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX);
|
2012-08-10 21:00:43 +04:00
|
|
|
const char *fw_name;
|
|
|
|
const char *desc;
|
2020-01-23 14:11:38 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The underscore at the end ensures a compile-time error if someone
|
|
|
|
* assigns to dc->props instead of using device_class_set_props.
|
|
|
|
*/
|
|
|
|
Property *props_;
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-28 20:26:54 +04:00
|
|
|
|
|
|
|
/*
|
2017-05-03 23:35:44 +03:00
|
|
|
* Can this device be instantiated with -device / device_add?
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-28 20:26:54 +04:00
|
|
|
* All devices should support instantiation with device_add, and
|
|
|
|
* this flag should not exist. But we're not there, yet. Some
|
|
|
|
* devices fail to instantiate with cryptic error messages.
|
|
|
|
* Others instantiate, but don't work. Exposing users to such
|
2017-05-03 23:35:44 +03:00
|
|
|
* behavior would be cruel; clearing this flag will protect them.
|
|
|
|
* It should never be cleared without a comment explaining why it
|
|
|
|
* is cleared.
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-28 20:26:54 +04:00
|
|
|
* TODO remove once we're there
|
|
|
|
*/
|
2017-05-03 23:35:44 +03:00
|
|
|
bool user_creatable;
|
2014-02-05 19:36:46 +04:00
|
|
|
bool hotpluggable;
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
/* callbacks */
|
2020-01-30 19:02:04 +03:00
|
|
|
/*
|
|
|
|
* Reset method here is deprecated and replaced by methods in the
|
|
|
|
* resettable class interface to implement a multi-phase reset.
|
|
|
|
* TODO: remove once every reset callback is unused
|
|
|
|
*/
|
2018-01-14 05:04:10 +03:00
|
|
|
DeviceReset reset;
|
2013-01-09 06:58:11 +04:00
|
|
|
DeviceRealize realize;
|
|
|
|
DeviceUnrealize unrealize;
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
/* device state */
|
2019-08-12 08:23:44 +03:00
|
|
|
const VMStateDescription *vmsd;
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
/* Private to qdev / bus. */
|
|
|
|
const char *bus_type;
|
|
|
|
} DeviceClass;
|
|
|
|
|
2014-05-20 10:30:58 +04:00
|
|
|
typedef struct NamedGPIOList NamedGPIOList;
|
|
|
|
|
|
|
|
struct NamedGPIOList {
|
|
|
|
char *name;
|
|
|
|
qemu_irq *in;
|
|
|
|
int num_in;
|
|
|
|
int num_out;
|
|
|
|
QLIST_ENTRY(NamedGPIOList) node;
|
|
|
|
};
|
|
|
|
|
2020-04-06 16:52:45 +03:00
|
|
|
typedef struct Clock Clock;
|
|
|
|
typedef struct NamedClockList NamedClockList;
|
|
|
|
|
|
|
|
struct NamedClockList {
|
|
|
|
char *name;
|
|
|
|
Clock *clock;
|
|
|
|
bool output;
|
|
|
|
bool alias;
|
|
|
|
QLIST_ENTRY(NamedClockList) node;
|
|
|
|
};
|
|
|
|
|
2013-01-09 06:58:10 +04:00
|
|
|
/**
|
|
|
|
* DeviceState:
|
|
|
|
* @realized: Indicates whether the device has been fully constructed.
|
2020-01-30 19:02:04 +03:00
|
|
|
* @reset: ResettableState for the device; handled by Resettable interface.
|
2013-01-09 06:58:10 +04:00
|
|
|
*
|
|
|
|
* This structure should not be accessed directly. We declare it here
|
|
|
|
* so that it can be embedded in individual device state structures.
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
struct DeviceState {
|
2013-01-09 06:58:10 +04:00
|
|
|
/*< private >*/
|
2012-08-10 21:00:43 +04:00
|
|
|
Object parent_obj;
|
2013-01-09 06:58:10 +04:00
|
|
|
/*< public >*/
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
const char *id;
|
qdev: store DeviceState's canonical path to use when unparenting
device_unparent(dev, ...) is called when a device is unparented,
either directly, or as a result of a parent device being
finalized, and handles some final cleanup for the device. Part
of this includes emiting a DEVICE_DELETED QMP event to notify
management, which includes the device's path in the composition
tree as provided by object_get_canonical_path().
object_get_canonical_path() assumes the device is still connected
to the machine/root container, and will assert otherwise, but
in some situations this isn't the case:
If the parent is finalized as a result of object_unparent(), it
will still be attached to the composition tree at the time any
children are unparented as a result of that same call to
object_unparent(). However, in some cases, object_unparent()
will complete without finalizing the parent device, due to
lingering references that won't be released till some time later.
One such example is if the parent has MemoryRegion children (which
take a ref on their parent), who in turn have AddressSpace's (which
take a ref on their regions), since those AddressSpaces get cleaned
up asynchronously by the RCU thread.
In this case qdev:device_unparent() may be called for a child Device
that no longer has a path to the root/machine container, causing
object_get_canonical_path() to assert.
Fix this by storing the canonical path during realize() so the
information will still be available for device_unparent() in such
cases.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Signed-off-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Tested-by: Eric Auger <eric.auger@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Message-Id: <20171016222315.407-2-mdroth@linux.vnet.ibm.com>
[Clear dev->canonical_path at the post_realize_fail label, which is
cleaner. Suggested by David Gibson. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-10-17 01:23:13 +03:00
|
|
|
char *canonical_path;
|
2013-01-09 06:58:10 +04:00
|
|
|
bool realized;
|
2014-06-26 17:10:03 +04:00
|
|
|
bool pending_deleted_event;
|
2012-08-10 21:00:43 +04:00
|
|
|
QemuOpts *opts;
|
|
|
|
int hotplugged;
|
2019-10-29 14:49:01 +03:00
|
|
|
bool allow_unplug_during_migration;
|
2012-08-10 21:00:43 +04:00
|
|
|
BusState *parent_bus;
|
2014-05-20 10:30:58 +04:00
|
|
|
QLIST_HEAD(, NamedGPIOList) gpios;
|
2020-04-06 16:52:45 +03:00
|
|
|
QLIST_HEAD(, NamedClockList) clocks;
|
2012-08-10 21:00:43 +04:00
|
|
|
QLIST_HEAD(, BusState) child_bus;
|
|
|
|
int num_child_bus;
|
|
|
|
int instance_id_alias;
|
|
|
|
int alias_required_for_version;
|
2020-01-30 19:02:04 +03:00
|
|
|
ResettableState reset;
|
2012-08-10 21:00:43 +04:00
|
|
|
};
|
|
|
|
|
2015-01-20 14:05:07 +03:00
|
|
|
struct DeviceListener {
|
|
|
|
void (*realize)(DeviceListener *listener, DeviceState *dev);
|
|
|
|
void (*unrealize)(DeviceListener *listener, DeviceState *dev);
|
2019-10-29 14:48:55 +03:00
|
|
|
/*
|
|
|
|
* This callback is called upon init of the DeviceState and allows to
|
|
|
|
* inform qdev that a device should be hidden, depending on the device
|
|
|
|
* opts, for example, to hide a standby device.
|
|
|
|
*/
|
|
|
|
int (*should_be_hidden)(DeviceListener *listener, QemuOpts *device_opts);
|
2015-01-20 14:05:07 +03:00
|
|
|
QTAILQ_ENTRY(DeviceListener) link;
|
|
|
|
};
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
#define TYPE_BUS "bus"
|
|
|
|
#define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS)
|
|
|
|
#define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS)
|
|
|
|
#define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS)
|
|
|
|
|
|
|
|
struct BusClass {
|
|
|
|
ObjectClass parent_class;
|
|
|
|
|
|
|
|
/* FIXME first arg should be BusState */
|
|
|
|
void (*print_dev)(Monitor *mon, DeviceState *dev, int indent);
|
|
|
|
char *(*get_dev_path)(DeviceState *dev);
|
|
|
|
/*
|
|
|
|
* This callback is used to create Open Firmware device path in accordance
|
|
|
|
* with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus
|
|
|
|
* bindings can be found at http://playground.sun.com/1275/bindings/.
|
|
|
|
*/
|
|
|
|
char *(*get_fw_dev_path)(DeviceState *dev);
|
2013-12-06 20:54:27 +04:00
|
|
|
void (*reset)(BusState *bus);
|
2013-11-26 02:48:40 +04:00
|
|
|
BusRealize realize;
|
|
|
|
BusUnrealize unrealize;
|
|
|
|
|
2013-01-15 03:08:00 +04:00
|
|
|
/* maximum devices allowed on the bus, 0: no limit. */
|
|
|
|
int max_dev;
|
qdev: Keep global allocation counter per bus
When we have 2 separate qdev devices that both create a qbus of the
same type without specifying a bus name or device name, we end up
with two buses of the same name, such as ide.0 on the Mac machines:
dev: macio-ide, id ""
bus: ide.0
type IDE
dev: macio-ide, id ""
bus: ide.0
type IDE
If we now spawn a device that connects to a ide.0 the last created
bus gets the device, with the first created bus inaccessible to the
command line.
After some discussion on IRC we concluded that the best quick fix way
forward for this is to make automated bus-class type based allocation
count a global counter. That's what this patch implements. With this
we instead get
dev: macio-ide, id ""
bus: ide.1
type IDE
dev: macio-ide, id ""
bus: ide.0
type IDE
on the example mentioned above.
This also means that if you did -device ...,bus=ide.0 you got a device
on the first bus (the last created one) before this patch and get that
device on the second one (the first created one) now. Breaks
migration unless you change bus=ide.0 to bus=ide.1 on the destination.
This is intended and makes the bus enumeration work as expected.
As per review request follows a list of otherwise affected boards and
the reasoning for the conclusion that they are ok:
target machine bus id times
------ ------- ------ -----
aarch64 n800 i2c-bus.0 2
aarch64 n810 i2c-bus.0 2
arm n800 i2c-bus.0 2
arm n810 i2c-bus.0 2
-> Devices are only created explicitly on one of the two buses, using
s->mpu->i2c[0], so no change to the guest.
aarch64 vexpress-a15 virtio-mmio-bus.0 4
aarch64 vexpress-a9 virtio-mmio-bus.0 4
aarch64 virt virtio-mmio-bus.0 32
arm vexpress-a15 virtio-mmio-bus.0 4
arm vexpress-a9 virtio-mmio-bus.0 4
arm virt virtio-mmio-bus.0 32
-> Makes -device bus= work for all virtio-mmio buses. Breaks
migration. Workaround for migration from old to new: specify
virtio-mmio-bus.4 or .32 respectively rather than .0 on the
destination.
aarch64 xilinx-zynq-a9 usb-bus.0 2
arm xilinx-zynq-a9 usb-bus.0 2
mips64el fulong2e usb-bus.0 2
-> Normal USB operation not affected. Migration driver needs command
line to use the other bus.
i386 isapc ide.0 2
x86_64 isapc ide.0 2
mips mips ide.0 2
mips64 mips ide.0 2
mips64el mips ide.0 2
mipsel mips ide.0 2
ppc g3beige ide.0 2
ppc mac99 ide.0 2
ppc prep ide.0 2
ppc64 g3beige ide.0 2
ppc64 mac99 ide.0 2
ppc64 prep ide.0 2
-> Makes -device bus= work for all IDE buses. Breaks migration.
Workaround for migration from old to new: specify ide.1 rather than
ide.0 on the destination.
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Andreas Faerber <afaerber@suse.de>
Signed-off-by: Alexander Graf <agraf@suse.de>
2014-02-06 19:08:15 +04:00
|
|
|
/* number of automatically allocated bus ids (e.g. ide.0) */
|
|
|
|
int automatic_ids;
|
2012-08-10 21:00:43 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct BusChild {
|
|
|
|
DeviceState *child;
|
|
|
|
int index;
|
|
|
|
QTAILQ_ENTRY(BusChild) sibling;
|
|
|
|
} BusChild;
|
|
|
|
|
2014-02-05 19:36:45 +04:00
|
|
|
#define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler"
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
/**
|
|
|
|
* BusState:
|
2018-10-30 18:16:37 +03:00
|
|
|
* @hotplug_handler: link to a hotplug handler associated with bus.
|
2020-01-30 19:02:04 +03:00
|
|
|
* @reset: ResettableState for the bus; handled by Resettable interface.
|
2012-08-10 21:00:43 +04:00
|
|
|
*/
|
|
|
|
struct BusState {
|
|
|
|
Object obj;
|
|
|
|
DeviceState *parent;
|
2016-07-15 13:04:49 +03:00
|
|
|
char *name;
|
2014-02-05 19:36:45 +04:00
|
|
|
HotplugHandler *hotplug_handler;
|
2012-08-10 21:00:43 +04:00
|
|
|
int max_index;
|
2013-11-26 02:48:40 +04:00
|
|
|
bool realized;
|
2018-12-17 18:57:30 +03:00
|
|
|
int num_children;
|
2018-12-06 15:10:34 +03:00
|
|
|
QTAILQ_HEAD(, BusChild) children;
|
2012-08-10 21:00:43 +04:00
|
|
|
QLIST_ENTRY(BusState) sibling;
|
2020-01-30 19:02:04 +03:00
|
|
|
ResettableState reset;
|
2012-08-10 21:00:43 +04:00
|
|
|
};
|
|
|
|
|
2017-07-17 15:36:06 +03:00
|
|
|
/**
|
|
|
|
* Property:
|
|
|
|
* @set_default: true if the default value should be set from @defval,
|
|
|
|
* in which case @info->set_default_value must not be NULL
|
|
|
|
* (if false then no default value is set by the property system
|
|
|
|
* and the field retains whatever value it was given by instance_init).
|
|
|
|
* @defval: default value for the property. This is used only if @set_default
|
|
|
|
* is true.
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
struct Property {
|
|
|
|
const char *name;
|
2017-07-14 05:14:54 +03:00
|
|
|
const PropertyInfo *info;
|
2015-03-04 17:09:46 +03:00
|
|
|
ptrdiff_t offset;
|
2012-08-10 21:00:43 +04:00
|
|
|
uint8_t bitnr;
|
2017-07-17 15:36:06 +03:00
|
|
|
bool set_default;
|
2017-06-07 19:36:08 +03:00
|
|
|
union {
|
|
|
|
int64_t i;
|
2017-06-07 19:36:09 +03:00
|
|
|
uint64_t u;
|
2017-06-07 19:36:08 +03:00
|
|
|
} defval;
|
2013-03-15 20:41:57 +04:00
|
|
|
int arrayoffset;
|
2017-07-14 05:14:54 +03:00
|
|
|
const PropertyInfo *arrayinfo;
|
2013-03-15 20:41:57 +04:00
|
|
|
int arrayfieldsize;
|
2017-07-14 05:14:52 +03:00
|
|
|
const char *link_type;
|
2012-08-10 21:00:43 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct PropertyInfo {
|
|
|
|
const char *name;
|
2014-10-07 10:33:20 +04:00
|
|
|
const char *description;
|
2017-08-24 11:46:10 +03:00
|
|
|
const QEnumLookup *enum_table;
|
2012-08-10 21:00:43 +04:00
|
|
|
int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len);
|
2020-01-10 18:30:34 +03:00
|
|
|
void (*set_default_value)(ObjectProperty *op, const Property *prop);
|
2020-05-05 18:29:23 +03:00
|
|
|
void (*create)(ObjectClass *oc, Property *prop);
|
2012-08-10 21:00:43 +04:00
|
|
|
ObjectPropertyAccessor *get;
|
|
|
|
ObjectPropertyAccessor *set;
|
|
|
|
ObjectPropertyRelease *release;
|
|
|
|
};
|
|
|
|
|
2014-05-05 22:03:06 +04:00
|
|
|
/**
|
|
|
|
* GlobalProperty:
|
2014-08-08 23:03:31 +04:00
|
|
|
* @used: Set to true if property was used when initializing a device.
|
2019-07-29 19:29:02 +03:00
|
|
|
* @optional: If set to true, GlobalProperty will be skipped without errors
|
|
|
|
* if the property doesn't exist.
|
2018-11-07 14:25:58 +03:00
|
|
|
*
|
|
|
|
* An error is fatal for non-hotplugged devices, when the global is applied.
|
2014-05-05 22:03:06 +04:00
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
typedef struct GlobalProperty {
|
|
|
|
const char *driver;
|
|
|
|
const char *property;
|
|
|
|
const char *value;
|
2014-08-08 23:03:31 +04:00
|
|
|
bool used;
|
2019-07-29 19:29:02 +03:00
|
|
|
bool optional;
|
2012-08-10 21:00:43 +04:00
|
|
|
} GlobalProperty;
|
|
|
|
|
2018-11-26 21:04:32 +03:00
|
|
|
static inline void
|
|
|
|
compat_props_add(GPtrArray *arr,
|
|
|
|
GlobalProperty props[], size_t nelem)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < nelem; i++) {
|
|
|
|
g_ptr_array_add(arr, (void *)&props[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
/*** Board API. This should go away once we have a machine config file. ***/
|
|
|
|
|
2020-07-11 17:24:23 +03:00
|
|
|
/**
|
|
|
|
* qdev_new: Create a device on the heap
|
|
|
|
* @name: device type to create (we assert() that this type exists)
|
|
|
|
*
|
|
|
|
* This only allocates the memory and initializes the device state
|
|
|
|
* structure, ready for the caller to set properties if they wish.
|
|
|
|
* The device still needs to be realized.
|
|
|
|
* The returned object has a reference count of 1.
|
|
|
|
*/
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
DeviceState *qdev_new(const char *name);
|
2020-07-11 17:24:23 +03:00
|
|
|
/**
|
|
|
|
* qdev_try_new: Try to create a device on the heap
|
|
|
|
* @name: device type to create
|
|
|
|
*
|
|
|
|
* This is like qdev_new(), except it returns %NULL when type @name
|
|
|
|
* does not exist, rather than asserting.
|
|
|
|
*/
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
DeviceState *qdev_try_new(const char *name);
|
2020-07-11 17:24:23 +03:00
|
|
|
/**
|
|
|
|
* qdev_realize: Realize @dev.
|
|
|
|
* @dev: device to realize
|
|
|
|
* @bus: bus to plug it into (may be NULL)
|
|
|
|
* @errp: pointer to error object
|
|
|
|
*
|
|
|
|
* "Realize" the device, i.e. perform the second phase of device
|
|
|
|
* initialization.
|
|
|
|
* @dev must not be plugged into a bus already.
|
|
|
|
* If @bus, plug @dev into @bus. This takes a reference to @dev.
|
|
|
|
* If @dev has no QOM parent, make one up, taking another reference.
|
|
|
|
* On success, return true.
|
|
|
|
* On failure, store an error through @errp and return false.
|
|
|
|
*
|
|
|
|
* If you created @dev using qdev_new(), you probably want to use
|
|
|
|
* qdev_realize_and_unref() instead.
|
|
|
|
*/
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp);
|
2020-07-11 17:24:23 +03:00
|
|
|
/**
|
|
|
|
* qdev_realize_and_unref: Realize @dev and drop a reference
|
|
|
|
* @dev: device to realize
|
|
|
|
* @bus: bus to plug it into (may be NULL)
|
|
|
|
* @errp: pointer to error object
|
|
|
|
*
|
|
|
|
* Realize @dev and drop a reference.
|
|
|
|
* This is like qdev_realize(), except the caller must hold a
|
|
|
|
* (private) reference, which is dropped on return regardless of
|
|
|
|
* success or failure. Intended use::
|
|
|
|
*
|
|
|
|
* dev = qdev_new();
|
|
|
|
* [...]
|
|
|
|
* qdev_realize_and_unref(dev, bus, errp);
|
|
|
|
*
|
|
|
|
* Now @dev can go away without further ado.
|
|
|
|
*
|
|
|
|
* If you are embedding the device into some other QOM device and
|
|
|
|
* initialized it via some variant on object_initialize_child() then
|
|
|
|
* do not use this function, because that family of functions arrange
|
|
|
|
* for the only reference to the child device to be held by the parent
|
|
|
|
* via the child<> property, and so the reference-count-drop done here
|
|
|
|
* would be incorrect. For that use case you want qdev_realize().
|
|
|
|
*/
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp);
|
2020-07-11 17:24:24 +03:00
|
|
|
/**
|
|
|
|
* qdev_unrealize: Unrealize a device
|
|
|
|
* @dev: device to unrealize
|
|
|
|
*
|
|
|
|
* This function will "unrealize" a device, which is the first phase
|
|
|
|
* of correctly destroying a device that has been realized. It will:
|
|
|
|
*
|
|
|
|
* - unrealize any child buses by calling qbus_unrealize()
|
|
|
|
* (this will recursively unrealize any devices on those buses)
|
|
|
|
* - call the the unrealize method of @dev
|
|
|
|
*
|
|
|
|
* The device can then be freed by causing its reference count to go
|
|
|
|
* to zero.
|
|
|
|
*
|
|
|
|
* Warning: most devices in QEMU do not expect to be unrealized. Only
|
|
|
|
* devices which are hot-unpluggable should be unrealized (as part of
|
|
|
|
* the unplugging process); all other devices are expected to last for
|
|
|
|
* the life of the simulation and should not be unrealized and freed.
|
|
|
|
*/
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
void qdev_unrealize(DeviceState *dev);
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
|
|
|
|
int required_for_version);
|
2019-02-28 15:28:49 +03:00
|
|
|
HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev);
|
2017-11-02 13:10:06 +03:00
|
|
|
HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev);
|
2019-09-16 11:07:16 +03:00
|
|
|
bool qdev_hotplug_allowed(DeviceState *dev, Error **errp);
|
2019-02-28 15:28:48 +03:00
|
|
|
/**
|
|
|
|
* qdev_get_hotplug_handler: Get handler responsible for device wiring
|
|
|
|
*
|
|
|
|
* Find HOTPLUG_HANDLER for @dev that provides [pre|un]plug callbacks for it.
|
|
|
|
*
|
|
|
|
* Note: in case @dev has a parent bus, it will be returned as handler unless
|
|
|
|
* machine handler overrides it.
|
|
|
|
*
|
|
|
|
* Returns: pointer to object that implements TYPE_HOTPLUG_HANDLER interface
|
|
|
|
* or NULL if there aren't any.
|
|
|
|
*/
|
2015-04-27 11:47:21 +03:00
|
|
|
HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev);
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_unplug(DeviceState *dev, Error **errp);
|
2014-09-26 13:28:21 +04:00
|
|
|
void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
|
|
|
|
DeviceState *dev, Error **errp);
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_machine_creation_done(void);
|
|
|
|
bool qdev_machine_modified(void);
|
|
|
|
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_get_gpio_in: Get one of a device's anonymous input GPIO lines
|
|
|
|
* @dev: Device whose GPIO we want
|
|
|
|
* @n: Number of the anonymous GPIO line (which must be in range)
|
|
|
|
*
|
|
|
|
* Returns the qemu_irq corresponding to an anonymous input GPIO line
|
|
|
|
* (which the device has set up with qdev_init_gpio_in()). The index
|
|
|
|
* @n of the GPIO line must be valid (i.e. be at least 0 and less than
|
|
|
|
* the total number of anonymous input GPIOs the device has); this
|
|
|
|
* function will assert() if passed an invalid index.
|
|
|
|
*
|
|
|
|
* This function is intended to be used by board code or SoC "container"
|
|
|
|
* device models to wire up the GPIO lines; usually the return value
|
|
|
|
* will be passed to qdev_connect_gpio_out() or a similar function to
|
|
|
|
* connect another device's output GPIO line to this input.
|
|
|
|
*
|
|
|
|
* For named input GPIO lines, use qdev_get_gpio_in_named().
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
qemu_irq qdev_get_gpio_in(DeviceState *dev, int n);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_get_gpio_in_named: Get one of a device's named input GPIO lines
|
|
|
|
* @dev: Device whose GPIO we want
|
|
|
|
* @name: Name of the input GPIO array
|
|
|
|
* @n: Number of the GPIO line in that array (which must be in range)
|
|
|
|
*
|
|
|
|
* Returns the qemu_irq corresponding to a named input GPIO line
|
|
|
|
* (which the device has set up with qdev_init_gpio_in_named()).
|
|
|
|
* The @name string must correspond to an input GPIO array which exists on
|
|
|
|
* the device, and the index @n of the GPIO line must be valid (i.e.
|
|
|
|
* be at least 0 and less than the total number of input GPIOs in that
|
|
|
|
* array); this function will assert() if passed an invalid name or index.
|
|
|
|
*
|
|
|
|
* For anonymous input GPIO lines, use qdev_get_gpio_in().
|
|
|
|
*/
|
2014-05-20 10:30:58 +04:00
|
|
|
qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n);
|
|
|
|
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_connect_gpio_out: Connect one of a device's anonymous output GPIO lines
|
|
|
|
* @dev: Device whose GPIO to connect
|
|
|
|
* @n: Number of the anonymous output GPIO line (which must be in range)
|
|
|
|
* @pin: qemu_irq to connect the output line to
|
|
|
|
*
|
|
|
|
* This function connects an anonymous output GPIO line on a device
|
|
|
|
* up to an arbitrary qemu_irq, so that when the device asserts that
|
|
|
|
* output GPIO line, the qemu_irq's callback is invoked.
|
|
|
|
* The index @n of the GPIO line must be valid (i.e. be at least 0 and
|
|
|
|
* less than the total number of anonymous output GPIOs the device has
|
|
|
|
* created with qdev_init_gpio_out()); otherwise this function will assert().
|
|
|
|
*
|
|
|
|
* Outbound GPIO lines can be connected to any qemu_irq, but the common
|
|
|
|
* case is connecting them to another device's inbound GPIO line, using
|
|
|
|
* the qemu_irq returned by qdev_get_gpio_in() or qdev_get_gpio_in_named().
|
|
|
|
*
|
|
|
|
* It is not valid to try to connect one outbound GPIO to multiple
|
|
|
|
* qemu_irqs at once, or to connect multiple outbound GPIOs to the
|
|
|
|
* same qemu_irq. (Warning: there is no assertion or other guard to
|
|
|
|
* catch this error: the model will just not do the right thing.)
|
|
|
|
* Instead, for fan-out you can use the TYPE_IRQ_SPLIT device: connect
|
|
|
|
* a device's outbound GPIO to the splitter's input, and connect each
|
|
|
|
* of the splitter's outputs to a different device. For fan-in you
|
|
|
|
* can use the TYPE_OR_IRQ device, which is a model of a logical OR
|
|
|
|
* gate with multiple inputs and one output.
|
|
|
|
*
|
|
|
|
* For named output GPIO lines, use qdev_connect_gpio_out_named().
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_connect_gpio_out: Connect one of a device's anonymous output GPIO lines
|
|
|
|
* @dev: Device whose GPIO to connect
|
|
|
|
* @name: Name of the output GPIO array
|
|
|
|
* @n: Number of the anonymous output GPIO line (which must be in range)
|
|
|
|
* @pin: qemu_irq to connect the output line to
|
|
|
|
*
|
|
|
|
* This function connects an anonymous output GPIO line on a device
|
|
|
|
* up to an arbitrary qemu_irq, so that when the device asserts that
|
|
|
|
* output GPIO line, the qemu_irq's callback is invoked.
|
|
|
|
* The @name string must correspond to an output GPIO array which exists on
|
|
|
|
* the device, and the index @n of the GPIO line must be valid (i.e.
|
|
|
|
* be at least 0 and less than the total number of input GPIOs in that
|
|
|
|
* array); this function will assert() if passed an invalid name or index.
|
|
|
|
*
|
|
|
|
* Outbound GPIO lines can be connected to any qemu_irq, but the common
|
|
|
|
* case is connecting them to another device's inbound GPIO line, using
|
|
|
|
* the qemu_irq returned by qdev_get_gpio_in() or qdev_get_gpio_in_named().
|
|
|
|
*
|
|
|
|
* It is not valid to try to connect one outbound GPIO to multiple
|
|
|
|
* qemu_irqs at once, or to connect multiple outbound GPIOs to the
|
|
|
|
* same qemu_irq; see qdev_connect_gpio_out() for details.
|
|
|
|
*
|
|
|
|
* For named output GPIO lines, use qdev_connect_gpio_out_named().
|
|
|
|
*/
|
2014-05-20 10:30:58 +04:00
|
|
|
void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
|
|
|
|
qemu_irq pin);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_get_gpio_out_connector: Get the qemu_irq connected to an output GPIO
|
|
|
|
* @dev: Device whose output GPIO we are interested in
|
|
|
|
* @name: Name of the output GPIO array
|
|
|
|
* @n: Number of the output GPIO line within that array
|
|
|
|
*
|
|
|
|
* Returns whatever qemu_irq is currently connected to the specified
|
|
|
|
* output GPIO line of @dev. This will be NULL if the output GPIO line
|
|
|
|
* has never been wired up to the anything. Note that the qemu_irq
|
|
|
|
* returned does not belong to @dev -- it will be the input GPIO or
|
|
|
|
* IRQ of whichever device the board code has connected up to @dev's
|
|
|
|
* output GPIO.
|
|
|
|
*
|
|
|
|
* You probably don't need to use this function -- it is used only
|
|
|
|
* by the platform-bus subsystem.
|
|
|
|
*/
|
2014-09-24 14:32:17 +04:00
|
|
|
qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_intercept_gpio_out: Intercept an existing GPIO connection
|
|
|
|
* @dev: Device to intercept the outbound GPIO line from
|
|
|
|
* @icpt: New qemu_irq to connect instead
|
|
|
|
* @name: Name of the output GPIO array
|
|
|
|
* @n: Number of the GPIO line in the array
|
|
|
|
*
|
|
|
|
* This function is provided only for use by the qtest testing framework
|
|
|
|
* and is not suitable for use in non-testing parts of QEMU.
|
|
|
|
*
|
|
|
|
* This function breaks an existing connection of an outbound GPIO
|
|
|
|
* line from @dev, and replaces it with the new qemu_irq @icpt, as if
|
|
|
|
* ``qdev_connect_gpio_out_named(dev, icpt, name, n)`` had been called.
|
|
|
|
* The previously connected qemu_irq is returned, so it can be restored
|
|
|
|
* by a second call to qdev_intercept_gpio_out() if desired.
|
|
|
|
*/
|
2014-09-26 09:20:58 +04:00
|
|
|
qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
|
|
|
|
const char *name, int n);
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
BusState *qdev_get_child_bus(DeviceState *dev, const char *name);
|
|
|
|
|
|
|
|
/*** Device API. ***/
|
|
|
|
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_init_gpio_in: create an array of anonymous input GPIO lines
|
|
|
|
* @dev: Device to create input GPIOs for
|
|
|
|
* @handler: Function to call when GPIO line value is set
|
|
|
|
* @n: Number of GPIO lines to create
|
|
|
|
*
|
|
|
|
* Devices should use functions in the qdev_init_gpio_in* family in
|
|
|
|
* their instance_init or realize methods to create any input GPIO
|
|
|
|
* lines they need. There is no functional difference between
|
|
|
|
* anonymous and named GPIO lines. Stylistically, named GPIOs are
|
|
|
|
* preferable (easier to understand at callsites) unless a device
|
|
|
|
* has exactly one uniform kind of GPIO input whose purpose is obvious.
|
|
|
|
* Note that input GPIO lines can serve as 'sinks' for IRQ lines.
|
|
|
|
*
|
|
|
|
* See qdev_get_gpio_in() for how code that uses such a device can get
|
|
|
|
* hold of an input GPIO line to manipulate it.
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_init_gpio_out: create an array of anonymous output GPIO lines
|
|
|
|
* @dev: Device to create output GPIOs for
|
|
|
|
* @pins: Pointer to qemu_irq or qemu_irq array for the GPIO lines
|
|
|
|
* @n: Number of GPIO lines to create
|
|
|
|
*
|
|
|
|
* Devices should use functions in the qdev_init_gpio_out* family
|
|
|
|
* in their instance_init or realize methods to create any output
|
|
|
|
* GPIO lines they need. There is no functional difference between
|
|
|
|
* anonymous and named GPIO lines. Stylistically, named GPIOs are
|
|
|
|
* preferable (easier to understand at callsites) unless a device
|
|
|
|
* has exactly one uniform kind of GPIO output whose purpose is obvious.
|
|
|
|
*
|
|
|
|
* The @pins argument should be a pointer to either a "qemu_irq"
|
|
|
|
* (if @n == 1) or a "qemu_irq []" array (if @n > 1) in the device's
|
|
|
|
* state structure. The device implementation can then raise and
|
|
|
|
* lower the GPIO line by calling qemu_set_irq(). (If anything is
|
|
|
|
* connected to the other end of the GPIO this will cause the handler
|
|
|
|
* function for that input GPIO to be called.)
|
|
|
|
*
|
|
|
|
* See qdev_connect_gpio_out() for how code that uses such a device
|
|
|
|
* can connect to one of its output GPIO lines.
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n);
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_init_gpio_out: create an array of named output GPIO lines
|
|
|
|
* @dev: Device to create output GPIOs for
|
|
|
|
* @pins: Pointer to qemu_irq or qemu_irq array for the GPIO lines
|
|
|
|
* @name: Name to give this array of GPIO lines
|
|
|
|
* @n: Number of GPIO lines to create
|
|
|
|
*
|
|
|
|
* Like qdev_init_gpio_out(), but creates an array of GPIO output lines
|
|
|
|
* with a name. Code using the device can then connect these GPIO lines
|
|
|
|
* using qdev_connect_gpio_out_named().
|
|
|
|
*/
|
2014-05-20 10:30:58 +04:00
|
|
|
void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
|
|
|
|
const char *name, int n);
|
2018-03-02 13:45:38 +03:00
|
|
|
/**
|
|
|
|
* qdev_init_gpio_in_named_with_opaque: create an array of input GPIO lines
|
|
|
|
* for the specified device
|
|
|
|
*
|
|
|
|
* @dev: Device to create input GPIOs for
|
|
|
|
* @handler: Function to call when GPIO line value is set
|
|
|
|
* @opaque: Opaque data pointer to pass to @handler
|
|
|
|
* @name: Name of the GPIO input (must be unique for this device)
|
|
|
|
* @n: Number of GPIO lines in this input set
|
|
|
|
*/
|
|
|
|
void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
|
|
|
|
qemu_irq_handler handler,
|
|
|
|
void *opaque,
|
|
|
|
const char *name, int n);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qdev_init_gpio_in_named: create an array of input GPIO lines
|
|
|
|
* for the specified device
|
|
|
|
*
|
|
|
|
* Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer
|
|
|
|
* passed to the handler is @dev (which is the most commonly desired behaviour).
|
|
|
|
*/
|
|
|
|
static inline void qdev_init_gpio_in_named(DeviceState *dev,
|
|
|
|
qemu_irq_handler handler,
|
|
|
|
const char *name, int n)
|
|
|
|
{
|
|
|
|
qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n);
|
|
|
|
}
|
2012-08-10 21:00:43 +04:00
|
|
|
|
2020-07-11 17:24:25 +03:00
|
|
|
/**
|
|
|
|
* qdev_pass_gpios: create GPIO lines on container which pass through to device
|
|
|
|
* @dev: Device which has GPIO lines
|
|
|
|
* @container: Container device which needs to expose them
|
|
|
|
* @name: Name of GPIO array to pass through (NULL for the anonymous GPIO array)
|
|
|
|
*
|
|
|
|
* In QEMU, complicated devices like SoCs are often modelled with a
|
|
|
|
* "container" QOM device which itself contains other QOM devices and
|
|
|
|
* which wires them up appropriately. This function allows the container
|
|
|
|
* to create GPIO arrays on itself which simply pass through to a GPIO
|
|
|
|
* array of one of its internal devices.
|
|
|
|
*
|
|
|
|
* If @dev has both input and output GPIOs named @name then both will
|
|
|
|
* be passed through. It is not possible to pass a subset of the array
|
|
|
|
* with this function.
|
|
|
|
*
|
|
|
|
* To users of the container device, the GPIO array created on @container
|
|
|
|
* behaves exactly like any other.
|
|
|
|
*/
|
2014-09-26 09:23:42 +04:00
|
|
|
void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
|
|
|
|
const char *name);
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
BusState *qdev_get_parent_bus(DeviceState *dev);
|
|
|
|
|
|
|
|
/*** BUS API. ***/
|
|
|
|
|
|
|
|
DeviceState *qdev_find_recursive(BusState *bus, const char *id);
|
|
|
|
|
|
|
|
/* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */
|
|
|
|
typedef int (qbus_walkerfn)(BusState *bus, void *opaque);
|
|
|
|
typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque);
|
|
|
|
|
2013-08-24 02:02:27 +04:00
|
|
|
void qbus_create_inplace(void *bus, size_t size, const char *typename,
|
2012-08-10 21:00:43 +04:00
|
|
|
DeviceState *parent, const char *name);
|
|
|
|
BusState *qbus_create(const char *typename, DeviceState *parent, const char *name);
|
qdev: New qdev_new(), qdev_realize(), etc.
We commonly plug devices into their bus right when we create them,
like this:
dev = qdev_create(bus, type_name);
Note that @dev is a weak reference. The reference from @bus to @dev
is the only strong one.
We realize at some later time, either with
object_property_set_bool(OBJECT(dev), true, "realized", errp);
or its convenience wrapper
qdev_init_nofail(dev);
If @dev still has no QOM parent then, realizing makes the
/machine/unattached/ orphanage its QOM parent.
Note that the device returned by qdev_create() is plugged into a bus,
but doesn't have a QOM parent, yet. Until it acquires one,
unrealizing the bus will hang in bus_unparent():
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
DeviceState *dev = kid->child;
object_unparent(OBJECT(dev));
}
object_unparent() does nothing when its argument has no QOM parent,
and the loop spins forever.
Device state "no QOM parent, but plugged into bus" is dangerous.
Paolo suggested to delay plugging into the bus until realize. We need
to plug into the parent bus before we call the device's realize
method, in case it uses the parent bus. So the dangerous state still
exists, but only within realization, where we can manage it safely.
This commit creates infrastructure to do this:
dev = qdev_new(type_name);
...
qdev_realize_and_unref(dev, bus, errp)
Note that @dev becomes a strong reference here.
qdev_realize_and_unref() drops it. There is also plain
qdev_realize(), which doesn't drop it.
The remainder of this series will convert all users to this new
interface.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Marcel Apfelbaum <marcel.apfelbaum@gmail.com>
Cc: Alistair Francis <alistair@alistair23.me>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Cc: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-5-armbru@redhat.com>
2020-06-10 08:31:53 +03:00
|
|
|
bool qbus_realize(BusState *bus, Error **errp);
|
|
|
|
void qbus_unrealize(BusState *bus);
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
/* Returns > 0 if either devfn or busfn skip walk somewhere in cursion,
|
|
|
|
* < 0 if either devfn or busfn terminate walk somewhere in cursion,
|
|
|
|
* 0 otherwise. */
|
2013-12-06 20:54:26 +04:00
|
|
|
int qbus_walk_children(BusState *bus,
|
|
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
|
|
void *opaque);
|
|
|
|
int qdev_walk_children(DeviceState *dev,
|
|
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
|
|
void *opaque);
|
|
|
|
|
2020-01-30 19:02:04 +03:00
|
|
|
/**
|
|
|
|
* @qdev_reset_all:
|
|
|
|
* Reset @dev. See @qbus_reset_all() for more details.
|
|
|
|
*
|
|
|
|
* Note: This function is deprecated and will be removed when it becomes unused.
|
|
|
|
* Please use device_cold_reset() now.
|
|
|
|
*/
|
2012-08-10 21:00:43 +04:00
|
|
|
void qdev_reset_all(DeviceState *dev);
|
2015-07-21 09:32:07 +03:00
|
|
|
void qdev_reset_all_fn(void *opaque);
|
2013-01-10 18:49:07 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qbus_reset_all:
|
|
|
|
* @bus: Bus to be reset.
|
|
|
|
*
|
|
|
|
* Reset @bus and perform a bus-level ("hard") reset of all devices connected
|
|
|
|
* to it, including recursive processing of all buses below @bus itself. A
|
|
|
|
* hard reset means that qbus_reset_all will reset all state of the device.
|
|
|
|
* For PCI devices, for example, this will include the base address registers
|
|
|
|
* or configuration space.
|
2020-01-30 19:02:04 +03:00
|
|
|
*
|
|
|
|
* Note: This function is deprecated and will be removed when it becomes unused.
|
|
|
|
* Please use bus_cold_reset() now.
|
2013-01-10 18:49:07 +04:00
|
|
|
*/
|
|
|
|
void qbus_reset_all(BusState *bus);
|
2012-08-10 21:00:43 +04:00
|
|
|
void qbus_reset_all_fn(void *opaque);
|
|
|
|
|
2020-01-30 19:02:04 +03:00
|
|
|
/**
|
|
|
|
* device_cold_reset:
|
|
|
|
* Reset device @dev and perform a recursive processing using the resettable
|
|
|
|
* interface. It triggers a RESET_TYPE_COLD.
|
|
|
|
*/
|
|
|
|
void device_cold_reset(DeviceState *dev);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bus_cold_reset:
|
|
|
|
*
|
|
|
|
* Reset bus @bus and perform a recursive processing using the resettable
|
|
|
|
* interface. It triggers a RESET_TYPE_COLD.
|
|
|
|
*/
|
|
|
|
void bus_cold_reset(BusState *bus);
|
|
|
|
|
2020-01-30 19:02:04 +03:00
|
|
|
/**
|
|
|
|
* device_is_in_reset:
|
|
|
|
* Return true if the device @dev is currently being reset.
|
|
|
|
*/
|
|
|
|
bool device_is_in_reset(DeviceState *dev);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bus_is_in_reset:
|
|
|
|
* Return true if the bus @bus is currently being reset.
|
|
|
|
*/
|
|
|
|
bool bus_is_in_reset(BusState *bus);
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
/* This should go away once we get rid of the NULL bus hack */
|
|
|
|
BusState *sysbus_get_default(void);
|
|
|
|
|
|
|
|
char *qdev_get_fw_dev_path(DeviceState *dev);
|
2015-01-29 10:08:51 +03:00
|
|
|
char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev);
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qdev_machine_init
|
|
|
|
*
|
|
|
|
* Initialize platform devices before machine init. This is a hack until full
|
|
|
|
* support for composition is added.
|
|
|
|
*/
|
|
|
|
void qdev_machine_init(void);
|
|
|
|
|
|
|
|
/**
|
2020-01-30 19:02:03 +03:00
|
|
|
* device_legacy_reset:
|
2012-08-10 21:00:43 +04:00
|
|
|
*
|
|
|
|
* Reset a single device (by calling the reset method).
|
2020-01-30 19:02:04 +03:00
|
|
|
* Note: This function is deprecated and will be removed when it becomes unused.
|
|
|
|
* Please use device_cold_reset() now.
|
2012-08-10 21:00:43 +04:00
|
|
|
*/
|
2020-01-30 19:02:03 +03:00
|
|
|
void device_legacy_reset(DeviceState *dev);
|
2012-08-10 21:00:43 +04:00
|
|
|
|
2020-01-10 18:30:32 +03:00
|
|
|
void device_class_set_props(DeviceClass *dc, Property *props);
|
|
|
|
|
2020-01-30 19:02:04 +03:00
|
|
|
/**
|
|
|
|
* device_class_set_parent_reset:
|
|
|
|
* TODO: remove the function when DeviceClass's reset method
|
|
|
|
* is not used anymore.
|
|
|
|
*/
|
2018-01-14 05:04:11 +03:00
|
|
|
void device_class_set_parent_reset(DeviceClass *dc,
|
|
|
|
DeviceReset dev_reset,
|
|
|
|
DeviceReset *parent_reset);
|
|
|
|
void device_class_set_parent_realize(DeviceClass *dc,
|
|
|
|
DeviceRealize dev_realize,
|
|
|
|
DeviceRealize *parent_realize);
|
|
|
|
void device_class_set_parent_unrealize(DeviceClass *dc,
|
|
|
|
DeviceUnrealize dev_unrealize,
|
|
|
|
DeviceUnrealize *parent_unrealize);
|
|
|
|
|
2019-08-12 08:23:44 +03:00
|
|
|
const VMStateDescription *qdev_get_vmsd(DeviceState *dev);
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
const char *qdev_fw_name(DeviceState *dev);
|
|
|
|
|
|
|
|
Object *qdev_get_machine(void);
|
|
|
|
|
|
|
|
/* FIXME: make this a link<> */
|
|
|
|
void qdev_set_parent_bus(DeviceState *dev, BusState *bus);
|
|
|
|
|
2017-03-28 12:08:52 +03:00
|
|
|
extern bool qdev_hotplug;
|
2017-03-28 12:22:10 +03:00
|
|
|
extern bool qdev_hot_removed;
|
2012-08-10 21:00:43 +04:00
|
|
|
|
|
|
|
char *qdev_get_dev_path(DeviceState *dev);
|
|
|
|
|
qdev: Drop qbus_set_hotplug_handler() parameter @errp
qbus_set_hotplug_handler() is a simple wrapper around
object_property_set_link().
object_property_set_link() fails when the property doesn't exist, is
not settable, or its .check() method fails. These are all programming
errors here, so passing &error_abort to qbus_set_hotplug_handler() is
appropriate.
Most of its callers do. Exceptions:
* pcie_cap_slot_init(), shpc_init(), spapr_phb_realize() pass NULL,
i.e. they ignore errors.
* spapr_machine_init() passes &error_fatal.
* s390_pcihost_realize(), virtio_serial_device_realize(),
s390_pcihost_plug() pass the error to their callers. The latter two
keep going after the error, which looks wrong.
Drop the @errp parameter, and instead pass &error_abort to
object_property_set_link().
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: "Daniel P. Berrangé" <berrange@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20200630090351.1247703-15-armbru@redhat.com>
2020-06-30 12:03:39 +03:00
|
|
|
void qbus_set_hotplug_handler(BusState *bus, Object *handler);
|
2020-06-30 12:03:38 +03:00
|
|
|
void qbus_set_bus_hotplug_handler(BusState *bus);
|
2014-09-26 13:28:17 +04:00
|
|
|
|
|
|
|
static inline bool qbus_is_hotpluggable(BusState *bus)
|
|
|
|
{
|
2014-09-26 13:28:40 +04:00
|
|
|
return bus->hotplug_handler;
|
2014-09-26 13:28:17 +04:00
|
|
|
}
|
2015-01-20 14:05:07 +03:00
|
|
|
|
|
|
|
void device_listener_register(DeviceListener *listener);
|
|
|
|
void device_listener_unregister(DeviceListener *listener);
|
|
|
|
|
2019-10-29 14:48:55 +03:00
|
|
|
/**
|
|
|
|
* @qdev_should_hide_device:
|
|
|
|
* @opts: QemuOpts as passed on cmdline.
|
|
|
|
*
|
|
|
|
* Check if a device should be added.
|
|
|
|
* When a device is added via qdev_device_add() this will be called,
|
|
|
|
* and return if the device should be added now or not.
|
|
|
|
*/
|
|
|
|
bool qdev_should_hide_device(QemuOpts *opts);
|
|
|
|
|
2012-08-10 21:00:43 +04:00
|
|
|
#endif
|