NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2026-09-03 20:53:04 -05:00
Code Issues Packages Projects Releases Wiki Activity

conf,remote: add channel lifecycle domain event

Browse Source 
Add support for a new domain event which can be used to track
the state of any virtio channel.

Previously one could only monitor the "org.qemu.guest_agent.0" channel
which had a dedicated agent lifecycle event. The channel lifecycle event
will be emitted alongside the agent specific one.

Signed-off-by: Lucas Kornicki <lucas.kornicki@nutanix.com>
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
This commit is contained in:
Lucas Kornicki
2026-05-21 15:32:50 +02:00
committed by Michal Privoznik
parent 57467ba683
commit faa3ece92c
10 changed files with 359 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/c/misc/event-test.c
+57
View File
@@ -353,6 +353,45 @@ guestAgentLifecycleEventReasonToString(int event)
return "unknown";
}
static const char *
guestChannelLifecycleEventStateToString(int event)
{
switch ((virConnectDomainEventChannelLifecycleState) event) {
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_DISCONNECTED:
return "Disconnected";
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_CONNECTED:
return "Connected";
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST:
break;
}
return "unknown";
}
static const char *
guestChannelLifecycleEventReasonToString(int event)
{
switch ((virConnectDomainEventChannelLifecycleReason) event) {
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_UNKNOWN:
return "Unknown";
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_DOMAIN_STARTED:
return "Domain started";
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL:
return "Channel event";
case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST:
break;
}
return "unknown";
}
static const char *
storagePoolEventToString(int event)
{
@@ -869,6 +908,23 @@ myDomainEventAgentLifecycleCallback(virConnectPtr conn G_GNUC_UNUSED,
}
static int
myDomainEventChannelLifecycleCallback(virConnectPtr conn G_GNUC_UNUSED,
virDomainPtr dom,
const char *channelName,
int state,
int reason,
void *opaque G_GNUC_UNUSED)
{
printf("%s EVENT: Domain %s(%d) guest channel(%s) state changed: %s reason: %s\n",
__func__, virDomainGetName(dom), virDomainGetID(dom), channelName,
guestChannelLifecycleEventStateToString(state),
guestChannelLifecycleEventReasonToString(reason));
return 0;
}
static int
myDomainEventDeviceAddedCallback(virConnectPtr conn G_GNUC_UNUSED,
virDomainPtr dom,
@@ -1195,6 +1251,7 @@ struct domainEventData domainEvents[] = {
DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE, myDomainEventMemoryDeviceSizeChangeCallback),
DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_NIC_MAC_CHANGE, myDomainEventNICMACChangeCallback),
DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_VCPU_REMOVED, myDomainEventVcpuRemovedCallback),
DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE, myDomainEventChannelLifecycleCallback),
};
struct storagePoolEventData {
include/libvirt/libvirt-domain.h
+61
View File
@@ -7673,6 +7673,66 @@ typedef void (*virConnectDomainEventNICMACChangeCallback)(virConnectPtr conn,
const char *newMAC,
void *opaque);
/**
* virConnectDomainEventChannelLifecycleState:
*
* Since: 12.4.0
*/
typedef enum {
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_CONNECTED = 1, /* channel connected (Since: 12.4.0) */
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_DISCONNECTED = 2, /* channel disconnected (Since: 12.4.0) */
# ifdef VIR_ENUM_SENTINELS
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST /* (Since: 12.4.0) */
# endif
} virConnectDomainEventChannelLifecycleState;
/**
* virConnectDomainEventChannelLifecycleReason:
*
* Since: 12.4.0
*/
typedef enum {
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_UNKNOWN = 0, /* unknown state change reason (Since: 12.4.0) */
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_DOMAIN_STARTED = 1, /* state changed due to domain start (Since: 12.4.0) */
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL = 2, /* channel state changed (Since: 12.4.0) */
# ifdef VIR_ENUM_SENTINELS
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST /* (Since: 12.4.0) */
# endif
} virConnectDomainEventChannelLifecycleReason;
/**
* virConnectDomainEventChannelLifecycleCallback:
* @conn: connection object
* @dom: domain on which the event occurred
* @channelName: the name of the channel on which the event occurred
* @state: new state of the guest channel, one of virConnectDomainEventChannelLifecycleState
* @reason: reason for state change, one of virConnectDomainEventChannelLifecycleReason
* @opaque: application specified data
*
* This callback occurs when libvirt detects a change in the state of a guest
* virtio-serial channel. Unlike VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE which is
* tied to the QEMU guest agent channel ("org.qemu.guest_agent.0"), this event
* is emitted for every virtio-serial channel attached to the domain,
* including the guest agent channel.
*
* The hypervisor must support virtio-serial port state notifications for the
* event to be delivered.
*
* The callback signature to use when registering for an event of type
* VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE with virConnectDomainEventRegisterAny()
*
* Since: 12.4.0
*/
typedef void (*virConnectDomainEventChannelLifecycleCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *channelName,
int state,
int reason,
void *opaque);
/**
* VIR_DOMAIN_EVENT_CALLBACK:
*
@@ -7723,6 +7783,7 @@ typedef enum {
VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE = 26, /* virConnectDomainEventMemoryDeviceSizeChangeCallback (Since: 7.9.0) */
VIR_DOMAIN_EVENT_ID_NIC_MAC_CHANGE = 27, /* virConnectDomainEventNICMACChangeCallback (Since: 11.2.0) */
VIR_DOMAIN_EVENT_ID_VCPU_REMOVED = 28, /* virConnectDomainEventVcpuRemovedCallback (Since: 12.4.0) */
VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE = 29, /* virConnectDomainEventChannelLifecycleCallback (Since: 12.4.0) */
# ifdef VIR_ENUM_SENTINELS
VIR_DOMAIN_EVENT_ID_LAST
src/conf/domain_event.c
+101
View File
@@ -59,6 +59,7 @@ static virClass *virDomainEventBlockThresholdClass;
static virClass *virDomainEventMemoryFailureClass;
static virClass *virDomainEventMemoryDeviceSizeChangeClass;
static virClass *virDomainEventNICMACChangeClass;
static virClass *virDomainEventChannelLifecycleClass;
static void virDomainEventDispose(void *obj);
static void virDomainEventLifecycleDispose(void *obj);
@@ -85,6 +86,7 @@ static void virDomainEventBlockThresholdDispose(void *obj);
static void virDomainEventMemoryFailureDispose(void *obj);
static void virDomainEventMemoryDeviceSizeChangeDispose(void *obj);
static void virDomainEventNICMACChangeDispose(void *obj);
static void virDomainEventChannelLifecycleDispose(void *obj);
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
@@ -305,6 +307,27 @@ struct _virDomainEventNICMACChange {
};
typedef struct _virDomainEventNICMACChange virDomainEventNICMACChange;
struct _virDomainEventChannelLifecycle {
virDomainEvent parent;
char *channelName;
int state;
int reason;
};
typedef struct _virDomainEventChannelLifecycle virDomainEventChannelLifecycle;
/* Make sure the AGENT and CHANNEL lifecycle enums stay in sync with each other. */
G_STATIC_ASSERT((int)VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED ==
(int)VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_DOMAIN_STARTED);
G_STATIC_ASSERT((int)VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL ==
(int)VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL);
G_STATIC_ASSERT((int)VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_LAST ==
(int)VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST);
G_STATIC_ASSERT((int)VIR_DOMAIN_CHR_DEVICE_STATE_CONNECTED ==
(int)VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_CONNECTED);
G_STATIC_ASSERT((int)VIR_DOMAIN_CHR_DEVICE_STATE_DISCONNECTED ==
(int)VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_DISCONNECTED);
static int
virDomainEventsOnceInit(void)
{
@@ -358,6 +381,8 @@ virDomainEventsOnceInit(void)
return -1;
if (!VIR_CLASS_NEW(virDomainEventNICMACChange, virDomainEventClass))
return -1;
if (!VIR_CLASS_NEW(virDomainEventChannelLifecycle, virDomainEventClass))
return -1;
return 0;
}
@@ -600,6 +625,14 @@ virDomainEventNICMACChangeDispose(void *obj)
g_free(event->newMAC);
}
static void
virDomainEventChannelLifecycleDispose(void *obj)
{
virDomainEventChannelLifecycle *event = obj;
g_free(event->channelName);
}
static void *
virDomainEventNew(virClass *klass,
int eventID,
@@ -1867,6 +1900,61 @@ virDomainEventNICMACChangeNewFromDom(virDomainPtr dom,
}
static virObjectEvent *
virDomainEventChannelLifecycleNew(int id,
const char *name,
const unsigned char *uuid,
const char *channelName,
int state,
int reason)
{
virDomainEventChannelLifecycle *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
if (!(ev = virDomainEventNew(virDomainEventChannelLifecycleClass,
VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE,
id, name, uuid)))
return NULL;
ev->channelName = g_strdup(channelName);
ev->state = state;
ev->reason = reason;
return (virObjectEvent *)ev;
}
virObjectEvent *
virDomainEventChannelLifecycleNewFromObj(virDomainObj *obj,
const char *channelName,
int state,
int reason)
{
return virDomainEventChannelLifecycleNew(obj->def->id,
obj->def->name,
obj->def->uuid,
channelName,
state,
reason);
}
virObjectEvent *
virDomainEventChannelLifecycleNewFromDom(virDomainPtr dom,
const char *channelName,
int state,
int reason)
{
return virDomainEventChannelLifecycleNew(dom->id,
dom->name,
dom->uuid,
channelName,
state,
reason);
}
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
virObjectEvent *event,
@@ -2200,6 +2288,19 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn,
goto cleanup;
}
case VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE:
{
virDomainEventChannelLifecycle *channelLifecycleEvent;
channelLifecycleEvent = (virDomainEventChannelLifecycle *)event;
((virConnectDomainEventChannelLifecycleCallback)cb)(conn, dom,
channelLifecycleEvent->channelName,
channelLifecycleEvent->state,
channelLifecycleEvent->reason,
cbopaque);
goto cleanup;
}
case VIR_DOMAIN_EVENT_ID_LAST:
break;
}
src/conf/domain_event.h
+12
View File
@@ -295,6 +295,18 @@ virDomainEventNICMACChangeNewFromDom(virDomainPtr dom,
const char *oldMAC,
const char *newMAC);
virObjectEvent *
virDomainEventChannelLifecycleNewFromObj(virDomainObj *obj,
const char *channelName,
int state,
int reason);
virObjectEvent *
virDomainEventChannelLifecycleNewFromDom(virDomainPtr dom,
const char *channelName,
int state,
int reason);
int
virDomainEventStateRegister(virConnectPtr conn,
virObjectEventState *state,
src/libvirt_private.syms
+2
View File
@@ -761,6 +761,8 @@ virDomainEventBlockJobNewFromDom;
virDomainEventBlockJobNewFromObj;
virDomainEventBlockThresholdNewFromDom;
virDomainEventBlockThresholdNewFromObj;
virDomainEventChannelLifecycleNewFromDom;
virDomainEventChannelLifecycleNewFromObj;
virDomainEventControlErrorNewFromDom;
virDomainEventControlErrorNewFromObj;
virDomainEventDeviceAddedNewFromDom;
src/remote/remote_daemon_dispatch.c
+34
View File
@@ -1379,6 +1379,39 @@ remoteRelayDomainEventNICMACChange(virConnectPtr conn,
}
static int
remoteRelayDomainEventChannelLifecycle(virConnectPtr conn,
virDomainPtr dom,
const char *channelName,
int state,
int reason,
void *opaque)
{
daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_channel_lifecycle_msg data = { 0 };
if (callback->callbackID < 0 ||
!remoteRelayDomainEventCheckACL(callback->client, conn, dom))
return -1;
VIR_DEBUG("Relaying domain channel lifecycle event %s %d, callback %d, "
"name %s, state %d, reason %d",
dom->name, dom->id, callback->callbackID, channelName, state, reason);
data.callbackID = callback->callbackID;
make_nonnull_domain(&data.dom, dom);
data.channelName = g_strdup(channelName);
data.state = state;
data.reason = reason;
remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE,
(xdrproc_t)xdr_remote_domain_event_callback_channel_lifecycle_msg,
&data);
return 0;
}
static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot),
@@ -1409,6 +1442,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventMemoryDeviceSizeChange),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventNICMACChange),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventVcpuRemoved),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventChannelLifecycle),
};
G_STATIC_ASSERT(G_N_ELEMENTS(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
src/remote/remote_driver.c
+34
View File
@@ -441,6 +441,11 @@ remoteDomainBuildEventNICMACChange(virNetClientProgram *prog,
virNetClient *client,
void *evdata, void *opaque);
static void
remoteDomainBuildEventCallbackChannelLifecycle(virNetClientProgram *prog,
virNetClient *client,
void *evdata, void *opaque);
static virNetClientProgramEvent remoteEvents[] = {
{ REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
remoteDomainBuildEventLifecycle,
@@ -667,6 +672,10 @@ static virNetClientProgramEvent remoteEvents[] = {
remoteDomainBuildEventVcpuRemoved,
sizeof(remote_domain_event_vcpu_removed_msg),
(xdrproc_t)xdr_remote_domain_event_vcpu_removed_msg },
{ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE,
remoteDomainBuildEventCallbackChannelLifecycle,
sizeof(remote_domain_event_callback_channel_lifecycle_msg),
(xdrproc_t)xdr_remote_domain_event_callback_channel_lifecycle_msg },
};
static void
@@ -5192,6 +5201,31 @@ remoteDomainBuildEventNICMACChange(virNetClientProgram *prog G_GNUC_UNUSED,
}
static void
remoteDomainBuildEventCallbackChannelLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_callback_channel_lifecycle_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
event = virDomainEventChannelLifecycleNewFromDom(dom,
msg->channelName,
msg->state,
msg->reason);
virObjectUnref(dom);
virObjectEventStateQueueRemote(priv->eventState, event, msg->callbackID);
}
static int
remoteStreamSend(virStreamPtr st,
const char *data,
src/remote/remote_protocol.x
+15 -1
View File
@@ -4015,6 +4015,14 @@ struct remote_domain_event_nic_mac_change_msg {
remote_nonnull_string newMAC;
};
struct remote_domain_event_callback_channel_lifecycle_msg {
int callbackID;
remote_nonnull_domain dom;
remote_nonnull_string channelName;
int state;
int reason;
};
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
@@ -7132,5 +7140,11 @@ enum remote_procedure {
* @generate: both
* @acl: none
*/
REMOTE_PROC_DOMAIN_EVENT_VCPU_REMOVED = 454
REMOTE_PROC_DOMAIN_EVENT_VCPU_REMOVED = 454,
/**
* @generate: both
* @acl: none
*/
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE = 455
};
src/remote_protocol-structs
+8
View File
@@ -3342,6 +3342,13 @@ struct remote_domain_event_nic_mac_change_msg {
remote_nonnull_string oldMAC;
remote_nonnull_string newMAC;
};
struct remote_domain_event_callback_channel_lifecycle_msg {
int callbackID;
remote_nonnull_domain dom;
remote_nonnull_string channelName;
int state;
int reason;
};
enum remote_procedure {
REMOTE_PROC_CONNECT_OPEN = 1,
REMOTE_PROC_CONNECT_CLOSE = 2,
@@ -3797,4 +3804,5 @@ enum remote_procedure {
REMOTE_PROC_DOMAIN_DEL_THROTTLE_GROUP = 452,
REMOTE_PROC_DOMAIN_EVENT_NIC_MAC_CHANGE = 453,
REMOTE_PROC_DOMAIN_EVENT_VCPU_REMOVED = 454,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE = 455,
};
tools/virsh-domain-event.c
+35
View File
@@ -655,6 +655,39 @@ virshEventAgentLifecyclePrint(virConnectPtr conn G_GNUC_UNUSED,
virshEventPrint(opaque, &buf);
}
VIR_ENUM_DECL(virshEventChannelLifecycleState);
VIR_ENUM_IMPL(virshEventChannelLifecycleState,
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST,
N_("unknown"),
N_("connected"),
N_("disconnected"));
VIR_ENUM_DECL(virshEventChannelLifecycleReason);
VIR_ENUM_IMPL(virshEventChannelLifecycleReason,
VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST,
N_("unknown"),
N_("domain started"),
N_("channel event"));
static void
virshEventChannelLifecyclePrint(virConnectPtr conn G_GNUC_UNUSED,
virDomainPtr dom,
const char *channelName,
int state,
int reason,
void *opaque)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf,
_("event 'channel-lifecycle' for domain '%1$s': channel name: '%2$s' state: '%3$s' reason: '%4$s'\n"),
virDomainGetName(dom),
channelName,
UNKNOWNSTR(virshEventChannelLifecycleStateTypeToString(state)),
UNKNOWNSTR(virshEventChannelLifecycleReasonTypeToString(reason)));
virshEventPrint(opaque, &buf);
}
static void
virshEventMigrationIterationPrint(virConnectPtr conn G_GNUC_UNUSED,
virDomainPtr dom,
@@ -889,6 +922,8 @@ virshDomainEventCallback virshDomainEventCallbacks[] = {
VIR_DOMAIN_EVENT_CALLBACK(virshEventNICMACChangePrint), },
{ "vcpu-removed",
VIR_DOMAIN_EVENT_CALLBACK(virshEventVcpuRemovedPrint), },
{ "channel-lifecycle",
VIR_DOMAIN_EVENT_CALLBACK(virshEventChannelLifecyclePrint), },
};
G_STATIC_ASSERT(VIR_DOMAIN_EVENT_ID_LAST == G_N_ELEMENTS(virshDomainEventCallbacks));