To enable virsh console (or equivalent) to be used remotely it is necessary to provide remote access to the /dev/pts/XXX pseudo-TTY associated with the console/serial/parallel device in the guest. The virStream API provide a bi-directional I/O stream capability that can be used for this purpose. This patch thus introduces a virDomainOpenConsole API that uses the stream APIs. * src/libvirt.c, src/libvirt_public.syms, include/libvirt/libvirt.h.in, src/driver.h: Define the new virDomainOpenConsole API * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c, src/xenapi/xenapi_driver.c: Stub API entry point --- include/libvirt/libvirt.h.in | 6 ++++ src/driver.h | 6 ++++ src/esx/esx_driver.c | 1 + src/libvirt.c | 53 ++++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 1 + src/lxc/lxc_driver.c | 4 +++ src/opennebula/one_driver.c | 1 + src/openvz/openvz_driver.c | 1 + src/phyp/phyp_driver.c | 1 + src/qemu/qemu_driver.c | 1 + src/remote/remote_driver.c | 1 + src/test/test_driver.c | 1 + src/uml/uml_driver.c | 1 + src/vbox/vbox_tmpl.c | 1 + src/xen/xen_driver.c | 1 + src/xenapi/xenapi_driver.c | 1 + 16 files changed, 81 insertions(+), 0 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 81db3a2..cc82e5c 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -2400,6 +2400,12 @@ int virNWFilterGetUUIDString (virNWFilterPtr nwfilter, char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter, int flags); + +int virDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags); + #ifdef __cplusplus } #endif diff --git a/src/driver.h b/src/driver.h index 79a96c1..6417ee9 100644 --- a/src/driver.h +++ b/src/driver.h @@ -480,6 +480,11 @@ typedef int (*virDrvQemuDomainMonitorCommand)(virDomainPtr domain, const char *cmd, char **result, unsigned int flags); +typedef int + (*virDrvDomainOpenConsole)(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags); /** @@ -598,6 +603,7 @@ struct _virDriver { virDrvQemuDomainMonitorCommand qemuDomainMonitorCommand; virDrvDomainSetMemoryParameters domainSetMemoryParameters; virDrvDomainGetMemoryParameters domainGetMemoryParameters; + virDrvDomainOpenConsole domainOpenConsole; }; typedef int diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index b3e1284..861247f 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -4253,6 +4253,7 @@ static virDriver esxDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; diff --git a/src/libvirt.c b/src/libvirt.c index aebd3bc..eb68377 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -13118,3 +13118,56 @@ virDomainSnapshotFree(virDomainSnapshotPtr snapshot) } return 0; } + +/** + * virDomainOpenConsole: + * @domain: a domain object + * @devname: the console, serial or parallel port device alias, or NULL + * @st: a stream to associate with the console + * @flags: unused, pass 0 + * + * This opens the backend associated with a console, serial or + * parallel port device on a guest, if the backend is supported. + * If the @devname is omitted, then the first console or serial + * device is opened. The console is associated with the passed + * in @st stream, which should have been opened in non-blocking + * mode for bi-directional I/O. + * + * returns 0 if the console was opened, -1 on error + */ +int virDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags) +{ + virConnectPtr conn; + DEBUG("dom=%p devname=%s, st=%p flags=%u", dom, NULLSTR(devname), st, flags); + + virResetLastError(); + + if (!VIR_IS_DOMAIN(dom)) { + virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + conn = dom->conn; + if (conn->flags & VIR_CONNECT_RO) { + virLibDomainError(dom, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn->driver->domainOpenConsole) { + int ret; + ret = conn->driver->domainOpenConsole(dom, devname, st, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(conn); + return -1; +} diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index a8091b1..5cc6ae2 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -411,6 +411,7 @@ LIBVIRT_0.8.5 { virDomainGetMemoryParameters; virDomainGetVcpusFlags; virDomainSetVcpusFlags; + virDomainOpenConsole; } LIBVIRT_0.8.2; # .... define new API here using predicted next version number .... diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index d39b60e..b36d8d8 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -2842,8 +2842,12 @@ static virDriver lxcDriver = { NULL, /* domainRevertToSnapshot */ NULL, /* domainSnapshotDelete */ NULL, /* qemuDomainMonitorCommand */ +<<<<<<< HEAD lxcDomainSetMemoryParameters, /* domainSetMemoryParameters */ lxcDomainGetMemoryParameters, /* domainGetMemoryParameters */ +======= + NULL, /* domainOpenConsole */ +>>>>>>> Introduce a virDomainOpenConsole API }; static virStateDriver lxcStateDriver = { diff --git a/src/opennebula/one_driver.c b/src/opennebula/one_driver.c index 199fca3..43a2847 100644 --- a/src/opennebula/one_driver.c +++ b/src/opennebula/one_driver.c @@ -822,6 +822,7 @@ static virDriver oneDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; static virStateDriver oneStateDriver = { diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c index b7c2754..e2fb281 100644 --- a/src/openvz/openvz_driver.c +++ b/src/openvz/openvz_driver.c @@ -1690,6 +1690,7 @@ static virDriver openvzDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; int openvzRegister(void) { diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c index 3d0ed11..bf55581 100644 --- a/src/phyp/phyp_driver.c +++ b/src/phyp/phyp_driver.c @@ -4036,6 +4036,7 @@ static virDriver phypDriver = { NULL, /* qemuMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; static virStorageDriver phypStorageDriver = { diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index a7cce6a..b753ed3 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -13355,6 +13355,7 @@ static virDriver qemuDriver = { qemuDomainMonitorCommand, /* qemuDomainMonitorCommand */ qemuDomainSetMemoryParameters, /* domainSetMemoryParameters */ qemuDomainGetMemoryParameters, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 61da8ff..2ad5ef7 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -10697,6 +10697,7 @@ static virDriver remote_driver = { remoteQemuDomainMonitorCommand, /* qemuDomainMonitorCommand */ remoteDomainSetMemoryParameters, /* domainSetMemoryParameters */ remoteDomainGetMemoryParameters, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; static virNetworkDriver network_driver = { diff --git a/src/test/test_driver.c b/src/test/test_driver.c index a9d3d89..23f79a5 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -5447,6 +5447,7 @@ static virDriver testDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; static virNetworkDriver testNetworkDriver = { diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index 5161012..e0bb4e5 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -2200,6 +2200,7 @@ static virDriver umlDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParamters */ NULL, /* domainGetMemoryParamters */ + NULL, /* domainOpenConsole */ }; static int diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index ddbca97..78f945c 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -8464,6 +8464,7 @@ virDriver NAME(Driver) = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; virNetworkDriver NAME(NetworkDriver) = { diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 66e8518..9cc46ae 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -2087,6 +2087,7 @@ static virDriver xenUnifiedDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; /** diff --git a/src/xenapi/xenapi_driver.c b/src/xenapi/xenapi_driver.c index 5ccdede..03b0a6a 100644 --- a/src/xenapi/xenapi_driver.c +++ b/src/xenapi/xenapi_driver.c @@ -1869,6 +1869,7 @@ static virDriver xenapiDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ + NULL, /* domainOpenConsole */ }; /** -- 1.7.2.3

This provides an implementation of the virDomainOpenConsole API for the remote driver client and server. * daemon/remote.c: Server side impl * src/remote/remote_driver.c: Client impl * src/remote/remote_protocol.x: Wire definition --- daemon/remote.c | 52 ++++++++++++++++++++++ daemon/remote_dispatch_args.h | 1 + daemon/remote_dispatch_prototypes.h | 8 +++ daemon/remote_dispatch_table.h | 5 ++ src/lxc/lxc_driver.c | 3 - src/remote/remote_driver.c | 82 +++++++++++++++++++++++++++-------- src/remote/remote_protocol.c | 13 ++++++ src/remote/remote_protocol.h | 10 ++++ src/remote/remote_protocol.x | 9 +++- src/remote_protocol-structs | 5 ++ 10 files changed, 165 insertions(+), 23 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 886d53d..c3e6c3a 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -6906,6 +6906,58 @@ qemuDispatchMonitorCommand (struct qemud_server *server ATTRIBUTE_UNUSED, } +static int +remoteDispatchDomainOpenConsole(struct qemud_server *server ATTRIBUTE_UNUSED, + struct qemud_client *client, + virConnectPtr conn, + remote_message_header *hdr, + remote_error *rerr, + remote_domain_open_console_args *args, + void *ret ATTRIBUTE_UNUSED) +{ + int r; + struct qemud_client_stream *stream; + virDomainPtr dom; + + CHECK_CONN (client); + + dom = get_nonnull_domain (conn, args->domain); + if (dom == NULL) { + remoteDispatchConnError(rerr, conn); + return -1; + } + + stream = remoteCreateClientStream(conn, hdr); + if (!stream) { + virDomainFree(dom); + remoteDispatchOOMError(rerr); + return -1; + } + + r = virDomainOpenConsole(dom, + args->devname ? *args->devname : NULL, + stream->st, + args->flags); + if (r == -1) { + virDomainFree(dom); + remoteFreeClientStream(client, stream); + remoteDispatchConnError(rerr, conn); + return -1; + } + + if (remoteAddClientStream(client, stream, 1) < 0) { + virDomainFree(dom); + remoteDispatchConnError(rerr, conn); + virStreamAbort(stream->st); + remoteFreeClientStream(client, stream); + return -1; + } + + virDomainFree(dom); + return 0; +} + + /*----- Helpers. -----*/ /* get_nonnull_domain and get_nonnull_network turn an on-wire diff --git a/daemon/remote_dispatch_args.h b/daemon/remote_dispatch_args.h index 9583e9c..971af80 100644 --- a/daemon/remote_dispatch_args.h +++ b/daemon/remote_dispatch_args.h @@ -169,3 +169,4 @@ remote_domain_get_memory_parameters_args val_remote_domain_get_memory_parameters_args; remote_domain_set_vcpus_flags_args val_remote_domain_set_vcpus_flags_args; remote_domain_get_vcpus_flags_args val_remote_domain_get_vcpus_flags_args; + remote_domain_open_console_args val_remote_domain_open_console_args; diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h index 6b35851..15c7ec7 100644 --- a/daemon/remote_dispatch_prototypes.h +++ b/daemon/remote_dispatch_prototypes.h @@ -466,6 +466,14 @@ static int remoteDispatchDomainMigrateSetMaxDowntime( remote_error *err, remote_domain_migrate_set_max_downtime_args *args, void *ret); +static int remoteDispatchDomainOpenConsole( + struct qemud_server *server, + struct qemud_client *client, + virConnectPtr conn, + remote_message_header *hdr, + remote_error *err, + remote_domain_open_console_args *args, + void *ret); static int remoteDispatchDomainPinVcpu( struct qemud_server *server, struct qemud_client *client, diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h index dd2adc7..4cfa1b1 100644 --- a/daemon/remote_dispatch_table.h +++ b/daemon/remote_dispatch_table.h @@ -1007,3 +1007,8 @@ .args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_flags_args, .ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_flags_ret, }, +{ /* DomainOpenConsole => 201 */ + .fn = (dispatch_fn) remoteDispatchDomainOpenConsole, + .args_filter = (xdrproc_t) xdr_remote_domain_open_console_args, + .ret_filter = (xdrproc_t) xdr_void, +}, diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index b36d8d8..48a38d1 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -2842,12 +2842,9 @@ static virDriver lxcDriver = { NULL, /* domainRevertToSnapshot */ NULL, /* domainSnapshotDelete */ NULL, /* qemuDomainMonitorCommand */ -<<<<<<< HEAD lxcDomainSetMemoryParameters, /* domainSetMemoryParameters */ lxcDomainGetMemoryParameters, /* domainGetMemoryParameters */ -======= NULL, /* domainOpenConsole */ ->>>>>>> Introduce a virDomainOpenConsole API }; static virStateDriver lxcStateDriver = { diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 2ad5ef7..57aec96 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -8158,11 +8158,16 @@ remoteStreamEventTimerUpdate(struct private_stream_data *privst) if (!privst->cb) return; - if (!privst->cbEvents) - virEventUpdateTimeout(privst->cbTimer, -1); - else if (privst->incoming && - (privst->cbEvents & VIR_STREAM_EVENT_READABLE)) + VIR_DEBUG("Check timer offset=%d %d", privst->incomingOffset, privst->cbEvents); + if ((privst->incomingOffset && + (privst->cbEvents & VIR_STREAM_EVENT_READABLE)) || + (privst->cbEvents & VIR_STREAM_EVENT_WRITABLE)) { + VIR_DEBUG0("Enabling event timer"); virEventUpdateTimeout(privst->cbTimer, 0); + } else { + VIR_DEBUG0("Disabling event timer"); + virEventUpdateTimeout(privst->cbTimer, -1); + } } @@ -8428,24 +8433,33 @@ remoteStreamEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) virStreamPtr st = opaque; struct private_data *priv = st->conn->privateData; struct private_stream_data *privst = st->privateData; + int events = 0; remoteDriverLock(priv); + if (privst->cb && (privst->cbEvents & VIR_STREAM_EVENT_READABLE) && - privst->incomingOffset) { + privst->incomingOffset) + events |= VIR_STREAM_EVENT_READABLE; + if (privst->cb && + (privst->cbEvents & VIR_STREAM_EVENT_WRITABLE)) + events |= VIR_STREAM_EVENT_WRITABLE; + VIR_DEBUG("Got Timer dispatch %d %d offset=%d", events, privst->cbEvents, privst->incomingOffset); + if (events) { virStreamEventCallback cb = privst->cb; void *cbOpaque = privst->cbOpaque; virFreeCallback cbFree = privst->cbFree; privst->cbDispatch = 1; remoteDriverUnlock(priv); - (cb)(st, VIR_STREAM_EVENT_READABLE, cbOpaque); + (cb)(st, events, cbOpaque); remoteDriverLock(priv); privst->cbDispatch = 0; if (!privst->cb && cbFree) (cbFree)(cbOpaque); } + remoteDriverUnlock(priv); } @@ -8471,12 +8485,6 @@ remoteStreamEventAddCallback(virStreamPtr st, remoteDriverLock(priv); - if (events & ~VIR_STREAM_EVENT_READABLE) { - remoteError(VIR_ERR_INTERNAL_ERROR, - _("unsupported stream events %d"), events); - goto cleanup; - } - if (privst->cb) { remoteError(VIR_ERR_INTERNAL_ERROR, _("multiple stream callbacks not supported")); @@ -8498,6 +8506,8 @@ remoteStreamEventAddCallback(virStreamPtr st, privst->cbFree = ff; privst->cbEvents = events; + remoteStreamEventTimerUpdate(privst); + ret = 0; cleanup: @@ -8515,12 +8525,6 @@ remoteStreamEventUpdateCallback(virStreamPtr st, remoteDriverLock(priv); - if (events & ~VIR_STREAM_EVENT_READABLE) { - remoteError(VIR_ERR_INTERNAL_ERROR, - _("unsupported stream events %d"), events); - goto cleanup; - } - if (!privst->cb) { remoteError(VIR_ERR_INTERNAL_ERROR, _("no stream callback registered")); @@ -9202,6 +9206,46 @@ done: } +static int +remoteDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags) +{ + struct private_data *priv = dom->conn->privateData; + struct private_stream_data *privst = NULL; + int rv = -1; + remote_domain_open_console_args args; + + remoteDriverLock(priv); + + if (!(privst = remoteStreamOpen(st, 1, REMOTE_PROC_DOMAIN_OPEN_CONSOLE, priv->counter))) + goto done; + + st->driver = &remoteStreamDrv; + st->privateData = privst; + + make_nonnull_domain (&args.domain, dom); + args.devname = devname ? (char **)&devname : NULL; + args.flags = flags; + + if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_OPEN_CONSOLE, + (xdrproc_t) xdr_remote_domain_open_console_args, (char *) &args, + (xdrproc_t) xdr_void, NULL) == -1) { + remoteStreamRelease(st); + goto done; + } + + rv = 0; + +done: + remoteDriverUnlock(priv); + + return rv; + +} + + /*----------------------------------------------------------------------*/ static int @@ -10697,7 +10741,7 @@ static virDriver remote_driver = { remoteQemuDomainMonitorCommand, /* qemuDomainMonitorCommand */ remoteDomainSetMemoryParameters, /* domainSetMemoryParameters */ remoteDomainGetMemoryParameters, /* domainGetMemoryParameters */ - NULL, /* domainOpenConsole */ + remoteDomainOpenConsole, /* domainOpenConsole */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.c b/src/remote/remote_protocol.c index 38ea050..41f5e7d 100644 --- a/src/remote/remote_protocol.c +++ b/src/remote/remote_protocol.c @@ -3709,6 +3709,19 @@ xdr_remote_domain_snapshot_delete_args (XDR *xdrs, remote_domain_snapshot_delete } bool_t +xdr_remote_domain_open_console_args (XDR *xdrs, remote_domain_open_console_args *objp) +{ + + if (!xdr_remote_nonnull_domain (xdrs, &objp->domain)) + return FALSE; + if (!xdr_remote_string (xdrs, &objp->devname)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->flags)) + return FALSE; + return TRUE; +} + +bool_t xdr_remote_procedure (XDR *xdrs, remote_procedure *objp) { diff --git a/src/remote/remote_protocol.h b/src/remote/remote_protocol.h index d75e76c..8dc89a5 100644 --- a/src/remote/remote_protocol.h +++ b/src/remote/remote_protocol.h @@ -2097,6 +2097,13 @@ struct remote_domain_snapshot_delete_args { int flags; }; typedef struct remote_domain_snapshot_delete_args remote_domain_snapshot_delete_args; + +struct remote_domain_open_console_args { + remote_nonnull_domain domain; + remote_string devname; + u_int flags; +}; +typedef struct remote_domain_open_console_args remote_domain_open_console_args; #define REMOTE_PROGRAM 0x20008086 #define REMOTE_PROTOCOL_VERSION 1 @@ -2301,6 +2308,7 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS = 198, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS = 199, REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS = 200, + REMOTE_PROC_DOMAIN_OPEN_CONSOLE = 201, }; typedef enum remote_procedure remote_procedure; @@ -2670,6 +2678,7 @@ extern bool_t xdr_remote_domain_snapshot_current_args (XDR *, remote_domain_sna extern bool_t xdr_remote_domain_snapshot_current_ret (XDR *, remote_domain_snapshot_current_ret*); extern bool_t xdr_remote_domain_revert_to_snapshot_args (XDR *, remote_domain_revert_to_snapshot_args*); extern bool_t xdr_remote_domain_snapshot_delete_args (XDR *, remote_domain_snapshot_delete_args*); +extern bool_t xdr_remote_domain_open_console_args (XDR *, remote_domain_open_console_args*); extern bool_t xdr_remote_procedure (XDR *, remote_procedure*); extern bool_t xdr_remote_message_type (XDR *, remote_message_type*); extern bool_t xdr_remote_message_status (XDR *, remote_message_status*); @@ -3013,6 +3022,7 @@ extern bool_t xdr_remote_domain_snapshot_current_args (); extern bool_t xdr_remote_domain_snapshot_current_ret (); extern bool_t xdr_remote_domain_revert_to_snapshot_args (); extern bool_t xdr_remote_domain_snapshot_delete_args (); +extern bool_t xdr_remote_domain_open_console_args (); extern bool_t xdr_remote_procedure (); extern bool_t xdr_remote_message_type (); extern bool_t xdr_remote_message_status (); diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index d57e6d0..e84afe5 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -1853,6 +1853,11 @@ struct remote_domain_snapshot_delete_args { int flags; }; +struct remote_domain_open_console_args { + remote_nonnull_domain domain; + remote_string devname; + unsigned int flags; +}; /*----- Protocol. -----*/ @@ -2079,7 +2084,9 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_SET_MEMORY_PARAMETERS = 197, REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS = 198, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS = 199, - REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS = 200 + REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS = 200, + + REMOTE_PROC_DOMAIN_OPEN_CONSOLE = 201 /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index d505886..3054bbf 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1352,6 +1352,11 @@ struct remote_domain_snapshot_delete_args { remote_nonnull_domain_snapshot snap; int flags; }; +struct remote_domain_open_console_args { + remote_nonnull_domain domain; + remote_string devname; + u_int flags; +}; struct remote_message_header { u_int prog; u_int vers; -- 1.7.2.3

Now that bi-directional, non-blocking streams are supported in the remote driver, some of the VIR_WARN statements need to be reduced to VIR_DEBUG. * src/remote/remote_driver.c: Lower logging level --- src/remote/remote_driver.c | 26 +++++++++++++------------- 1 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 57aec96..0ec8c39 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -8273,7 +8273,7 @@ remoteStreamHasError(virStreamPtr st) { return 0; } - VIR_WARN0("Raising async error"); + VIR_DEBUG0("Raising async error"); virRaiseErrorFull(st->conn, __FILE__, __FUNCTION__, __LINE__, privst->err.domain, @@ -9893,8 +9893,8 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, privst = privst->next; if (!privst) { - VIR_WARN("No registered stream matching serial=%d, proc=%d", - hdr->serial, hdr->proc); + VIR_DEBUG("No registered stream matching serial=%d, proc=%d", + hdr->serial, hdr->proc); return -1; } @@ -9913,7 +9913,7 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, case REMOTE_CONTINUE: { int avail = privst->incomingLength - privst->incomingOffset; int need = priv->bufferLength - priv->bufferOffset; - VIR_WARN0("Got a stream data packet"); + VIR_DEBUG0("Got a stream data packet"); /* XXX flag stream as complete somwhere if need==0 */ @@ -9921,7 +9921,7 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, int extra = need - avail; if (VIR_REALLOC_N(privst->incoming, privst->incomingLength + extra) < 0) { - VIR_WARN0("Out of memory"); + VIR_DEBUG0("Out of memory handling stream data"); return -1; } privst->incomingLength += extra; @@ -9933,19 +9933,19 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, privst->incomingOffset += (priv->bufferLength - priv->bufferOffset); if (thecall && thecall->want_reply) { - VIR_WARN("Got sync data packet offset=%d", privst->incomingOffset); + VIR_DEBUG("Got sync data packet offset=%d", privst->incomingOffset); thecall->mode = REMOTE_MODE_COMPLETE; } else { - VIR_WARN("Got aysnc data packet offset=%d", privst->incomingOffset); + VIR_DEBUG("Got aysnc data packet offset=%d", privst->incomingOffset); remoteStreamEventTimerUpdate(privst); } return 0; } case REMOTE_OK: - VIR_WARN0("Got a synchronous confirm"); + VIR_DEBUG0("Got a synchronous confirm"); if (!thecall) { - VIR_WARN0("Got unexpected stream finish confirmation"); + VIR_DEBUG0("Got unexpected stream finish confirmation"); return -1; } thecall->mode = REMOTE_MODE_COMPLETE; @@ -9953,7 +9953,7 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, case REMOTE_ERROR: if (thecall && thecall->want_reply) { - VIR_WARN0("Got a synchronous error"); + VIR_DEBUG0("Got a synchronous error"); /* Give the error straight to this call */ memset (&thecall->err, 0, sizeof thecall->err); if (!xdr_remote_error (xdr, &thecall->err)) { @@ -9962,16 +9962,16 @@ processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED, } thecall->mode = REMOTE_MODE_ERROR; } else { - VIR_WARN0("Got a asynchronous error"); + VIR_DEBUG0("Got a asynchronous error"); /* No call, so queue the error against the stream */ if (privst->has_error) { - VIR_WARN0("Got unexpected duplicate stream error"); + VIR_DEBUG0("Got unexpected duplicate stream error"); return -1; } privst->has_error = 1; memset (&privst->err, 0, sizeof privst->err); if (!xdr_remote_error (xdr, &privst->err)) { - VIR_WARN0("Failed to unmarshall error"); + VIR_DEBUG0("Failed to unmarshall error"); return -1; } } -- 1.7.2.3

To avoid the need for duplicating implementations of virStream drivers, provide a generic implementation that can handle any FD based stream. This code is copied from the existing impl in the QEMU driver, with the locking moved into the stream impl, and addition of a read callback The FD stream code will refuse to operate on regular files or block devices, since those can't report EAGAIN properly when they would block on I/O * include/libvirt/virterror.h, include/libvirt/virterror.h: Add VIR_FROM_STREAM error domain * src/qemu/qemu_driver.c: Remove code obsoleted by the new generic streams driver. * src/fdstream.h, src/fdstream.c, src/fdstream.c, src/libvirt_private.syms: Generic reusable FD based streams --- include/libvirt/virterror.h | 3 +- src/Makefile.am | 1 + src/fdstream.c | 472 +++++++++++++++++++++++++++++++++++++++++++ src/fdstream.h | 44 ++++ src/libvirt_private.syms | 7 + src/qemu/qemu_driver.c | 284 +------------------------- src/util/virterror.c | 3 + 7 files changed, 534 insertions(+), 280 deletions(-) create mode 100644 src/fdstream.c create mode 100644 src/fdstream.h diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h index 94d686c..abf6945 100644 --- a/include/libvirt/virterror.h +++ b/include/libvirt/virterror.h @@ -73,7 +73,8 @@ typedef enum { VIR_FROM_NWFILTER, /* Error from network filter driver */ VIR_FROM_HOOK, /* Error from Synchronous hooks */ VIR_FROM_DOMAIN_SNAPSHOT, /* Error from domain snapshot */ - VIR_FROM_AUDIT /* Error from auditing subsystem */ + VIR_FROM_AUDIT, /* Error from auditing subsystem */ + VIR_FROM_STREAMS, /* Error from I/O streams */ } virErrorDomain; diff --git a/src/Makefile.am b/src/Makefile.am index 4a11c37..2022b85 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -94,6 +94,7 @@ DRIVER_SOURCES = \ driver.c driver.h \ internal.h \ datatypes.c datatypes.h \ + fdstream.c fdstream.h \ $(NODE_INFO_SOURCES) \ libvirt.c libvirt_internal.h diff --git a/src/fdstream.c b/src/fdstream.c new file mode 100644 index 0000000..1ad2454 --- /dev/null +++ b/src/fdstream.c @@ -0,0 +1,472 @@ +/* + * fdstream.h: generic streams impl for file descriptors + * + * Copyright (C) 2009-2010 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include <config.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <netinet/tcp.h> + +#include "fdstream.h" +#include "virterror_internal.h" +#include "datatypes.h" +#include "memory.h" +#include "event.h" +#include "util.h" + +#define VIR_FROM_THIS VIR_FROM_STREAMS +#define streamsReportError(code, ...) \ + virReportErrorHelper(NULL, VIR_FROM_THIS, code, __FILE__, \ + __FUNCTION__, __LINE__, __VA_ARGS__) + +/* Tunnelled migration stream support */ +struct virFDStreamData { + int fd; + + int watch; + unsigned int cbRemoved; + unsigned int dispatching; + virStreamEventCallback cb; + void *opaque; + virFreeCallback ff; + + virMutex lock; +}; + +static int virFDStreamRemoveCallback(virStreamPtr stream) +{ + struct virFDStreamData *fdst = stream->privateData; + int ret = -1; + + if (!fdst) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream is not open")); + return -1; + } + + virMutexLock(&fdst->lock); + if (fdst->watch == 0) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream does not have a callback registered")); + goto cleanup; + } + + virEventRemoveHandle(fdst->watch); + if (fdst->dispatching) + fdst->cbRemoved = 1; + else if (fdst->ff) + (fdst->ff)(fdst->opaque); + + fdst->watch = 0; + fdst->ff = NULL; + fdst->cb = NULL; + fdst->opaque = NULL; + + ret = 0; + +cleanup: + virMutexUnlock(&fdst->lock); + return ret; +} + +static int virFDStreamUpdateCallback(virStreamPtr stream, int events) +{ + struct virFDStreamData *fdst = stream->privateData; + int ret = -1; + + if (!fdst) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream is not open")); + return -1; + } + + virMutexLock(&fdst->lock); + if (fdst->watch == 0) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream does not have a callback registered")); + goto cleanup; + } + + virEventUpdateHandle(fdst->watch, events); + + ret = 0; + +cleanup: + virMutexUnlock(&fdst->lock); + return ret; +} + +static void virFDStreamEvent(int watch ATTRIBUTE_UNUSED, + int fd ATTRIBUTE_UNUSED, + int events, + void *opaque) +{ + virStreamPtr stream = opaque; + struct virFDStreamData *fdst = stream->privateData; + virStreamEventCallback cb; + void *cbopaque; + virFreeCallback ff; + + if (!fdst) + return; + + virMutexLock(&fdst->lock); + if (!fdst->cb) { + virMutexUnlock(&fdst->lock); + return; + } + + cb = fdst->cb; + cbopaque = fdst->opaque; + ff = fdst->ff; + fdst->dispatching = 1; + virMutexUnlock(&fdst->lock); + + cb(stream, events, cbopaque); + + virMutexLock(&fdst->lock); + fdst->dispatching = 0; + if (fdst->cbRemoved && ff) + (ff)(cbopaque); + virMutexUnlock(&fdst->lock); +} + +static int +virFDStreamAddCallback(virStreamPtr st, + int events, + virStreamEventCallback cb, + void *opaque, + virFreeCallback ff) +{ + struct virFDStreamData *fdst = st->privateData; + int ret = -1; + + if (!fdst) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream is not open")); + return -1; + } + + virMutexLock(&fdst->lock); + if (fdst->watch != 0) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream already has a callback registered")); + goto cleanup; + } + + if ((fdst->watch = virEventAddHandle(fdst->fd, + events, + virFDStreamEvent, + st, + NULL)) < 0) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("cannot register file watch on stream")); + goto cleanup; + } + + fdst->cbRemoved = 0; + fdst->cb = cb; + fdst->opaque = opaque; + fdst->ff = ff; + virStreamRef(st); + + ret = 0; + +cleanup: + virMutexUnlock(&fdst->lock); + return ret; +} + +static void virFDStreamFree(struct virFDStreamData *fdst) +{ + if (fdst->fd != -1) + close(fdst->fd); + VIR_FREE(fdst); +} + + +static int +virFDStreamClose(virStreamPtr st) +{ + struct virFDStreamData *fdst = st->privateData; + + if (!fdst) + return 0; + + virMutexLock(&fdst->lock); + + virFDStreamFree(fdst); + + st->privateData = NULL; + + virMutexUnlock(&fdst->lock); + + return 0; +} + +static int virFDStreamWrite(virStreamPtr st, const char *bytes, size_t nbytes) +{ + struct virFDStreamData *fdst = st->privateData; + int ret; + + if (!fdst) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream is not open")); + return -1; + } + + virMutexLock(&fdst->lock); + +retry: + ret = write(fdst->fd, bytes, nbytes); + if (ret < 0) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + ret = -2; + } else if (errno == EINTR) { + goto retry; + } else { + ret = -1; + virReportSystemError(errno, "%s", + _("cannot write to stream")); + } + } + + virMutexUnlock(&fdst->lock); + return ret; +} + + +static int virFDStreamRead(virStreamPtr st, char *bytes, size_t nbytes) +{ + struct virFDStreamData *fdst = st->privateData; + int ret; + + if (!fdst) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("stream is not open")); + return -1; + } + + virMutexLock(&fdst->lock); + +retry: + ret = read(fdst->fd, bytes, nbytes); + if (ret < 0) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + ret = -2; + } else if (errno == EINTR) { + goto retry; + } else { + ret = -1; + virReportSystemError(errno, "%s", + _("cannot read from stream")); + } + } + + virMutexUnlock(&fdst->lock); + return ret; +} + + +static virStreamDriver virFDStreamDrv = { + .streamSend = virFDStreamWrite, + .streamRecv = virFDStreamRead, + .streamFinish = virFDStreamClose, + .streamAbort = virFDStreamClose, + .streamAddCallback = virFDStreamAddCallback, + .streamUpdateCallback = virFDStreamUpdateCallback, + .streamRemoveCallback = virFDStreamRemoveCallback +}; + +int virFDStreamOpen(virStreamPtr st, + int fd) +{ + struct virFDStreamData *fdst; + + if ((st->flags & VIR_STREAM_NONBLOCK) && + virSetNonBlock(fdst->fd) < 0) + return -1; + + if (VIR_ALLOC(fdst) < 0) { + virReportOOMError(); + return -1; + } + + fdst->fd = fd; + if (virMutexInit(&fdst->lock) < 0) { + VIR_FREE(fdst); + streamsReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to initialize mutex")); + return -1; + } + + st->driver = &virFDStreamDrv; + st->privateData = fdst; + + return 0; +} + + +int virFDStreamConnectUNIX(virStreamPtr st, + const char *path, + bool abstract) +{ + struct sockaddr_un sa; + int i = 0; + int timeout = 3; + int ret; + + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd < 0) { + virReportSystemError(errno, "%s", _("Unable to open UNIX socket")); + goto error; + } + + memset(&sa, 0, sizeof(sa)); + sa.sun_family = AF_UNIX; + if (abstract) { + if (virStrcpy(sa.sun_path+1, path, sizeof(sa.sun_path)-1) == NULL) + goto error; + sa.sun_path[0] = '\0'; + } else { + if (virStrcpy(sa.sun_path, path, sizeof(sa.sun_path)) == NULL) + goto error; + } + + do { + ret = connect(fd, (struct sockaddr *)&sa, sizeof(sa)); + if (ret == 0) + break; + + if (errno == ENOENT || errno == ECONNREFUSED) { + /* ENOENT : Socket may not have shown up yet + * ECONNREFUSED : Leftover socket hasn't been removed yet */ + continue; + } + + goto error; + } while ((++i <= timeout*5) && (usleep(.2 * 1000000) <= 0)); + + if (virFDStreamOpen(st, fd) < 0) + goto error; + return 0; + +error: + close(fd); + return -1; +} + +int virFDStreamOpenFile(virStreamPtr st, + const char *path, + int flags) +{ + int fd = open(path, flags); + struct stat sb; + + if (fd < 0) { + virReportSystemError(errno, + _("Unable to open stream for '%s'"), + path); + return -1; + } + + if (fstat(fd, &sb) < 0) { + virReportSystemError(errno, + _("Unable to access stream for '%s'"), + path); + goto error; + } + + /* Thanks to the POSIX i/o model, we can't reliably get + * non-blocking I/O on block devs/regular files. To + * support those we need to fork a helper process todo + * the I/O so we just have a fifo. Or use AIO :-( + */ + if ((st->flags & VIR_STREAM_NONBLOCK) && + (!S_ISCHR(sb.st_mode) && + !S_ISFIFO(sb.st_mode))) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + _("Non-blocking I/O is not supported on %s"), + path); + goto error; + } + + if (virFDStreamOpen(st, fd) < 0) + goto error; + + return 0; + +error: + close(fd); + return -1; +} + +int virFDStreamCreateFile(virStreamPtr st, + const char *path, + int flags, + mode_t mode) +{ + int fd = open(path, flags, mode); + struct stat sb; + + if (fd < 0) { + virReportSystemError(errno, + _("Unable to open stream for '%s'"), + path); + return -1; + } + + if (fstat(fd, &sb) < 0) { + virReportSystemError(errno, + _("Unable to access stream for '%s'"), + path); + goto error; + } + + /* Thanks to the POSIX i/o model, we can't reliably get + * non-blocking I/O on block devs/regular files. To + * support those we need to fork a helper process todo + * the I/O so we just have a fifo. Or use AIO :-( + */ + if ((st->flags & VIR_STREAM_NONBLOCK) && + (!S_ISCHR(sb.st_mode) && + !S_ISFIFO(sb.st_mode))) { + streamsReportError(VIR_ERR_INTERNAL_ERROR, + _("Non-blocking I/O is not supported on %s"), + path); + goto error; + } + + if (virFDStreamOpen(st, fd) < 0) + goto error; + + return 0; + +error: + close(fd); + return -1; +} + diff --git a/src/fdstream.h b/src/fdstream.h new file mode 100644 index 0000000..f8d22d5 --- /dev/null +++ b/src/fdstream.h @@ -0,0 +1,44 @@ +/* + * fdstream.h: generic streams impl for file descriptors + * + * Copyright (C) 2009-2010 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + + +#ifndef __VIR_FDSTREAM_H_ +# define __VIR_FDSTREAM_H_ + +# include "internal.h" +# include <stdbool.h> + +int virFDStreamOpen(virStreamPtr st, + int fd); + +int virFDStreamConnectUNIX(virStreamPtr st, + const char *path, + bool abstract); + +int virFDStreamOpenFile(virStreamPtr st, + const char *path, + int flags); +int virFDStreamCreateFile(virStreamPtr st, + const char *path, + int flags, + mode_t mode); + +#endif /* __VIR_FDSTREAM_H_ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index cf64bd3..fc9021a 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -335,6 +335,13 @@ virEventUpdateTimeout; virClose; +# fdstream.h +virFDStreamOpen; +virFDStreamConnectUNIX; +virFDStreamOpenFile; +virFDStreamCreateFile; + + # hash.h virHashAddEntry; virHashCreate; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index b753ed3..2c07ac7 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -81,6 +81,7 @@ #include "hooks.h" #include "storage_file.h" #include "virtaudit.h" +#include "fdstream.h" #define VIR_FROM_THIS VIR_FROM_QEMU @@ -10746,279 +10747,6 @@ qemuDomainIsMigratable(virDomainDefPtr def) return true; } - -/* Tunnelled migration stream support */ -struct qemuStreamMigFile { - int fd; - - int watch; - unsigned int cbRemoved; - unsigned int dispatching; - virStreamEventCallback cb; - void *opaque; - virFreeCallback ff; -}; - -static int qemuStreamMigRemoveCallback(virStreamPtr stream) -{ - struct qemud_driver *driver = stream->conn->privateData; - struct qemuStreamMigFile *qemust = stream->privateData; - int ret = -1; - - if (!qemust) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream is not open")); - return -1; - } - - qemuDriverLock(driver); - if (qemust->watch == 0) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream does not have a callback registered")); - goto cleanup; - } - - virEventRemoveHandle(qemust->watch); - if (qemust->dispatching) - qemust->cbRemoved = 1; - else if (qemust->ff) - (qemust->ff)(qemust->opaque); - - qemust->watch = 0; - qemust->ff = NULL; - qemust->cb = NULL; - qemust->opaque = NULL; - - ret = 0; - -cleanup: - qemuDriverUnlock(driver); - return ret; -} - -static int qemuStreamMigUpdateCallback(virStreamPtr stream, int events) -{ - struct qemud_driver *driver = stream->conn->privateData; - struct qemuStreamMigFile *qemust = stream->privateData; - int ret = -1; - - if (!qemust) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream is not open")); - return -1; - } - - qemuDriverLock(driver); - if (qemust->watch == 0) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream does not have a callback registered")); - goto cleanup; - } - - virEventUpdateHandle(qemust->watch, events); - - ret = 0; - -cleanup: - qemuDriverUnlock(driver); - return ret; -} - -static void qemuStreamMigEvent(int watch ATTRIBUTE_UNUSED, - int fd ATTRIBUTE_UNUSED, - int events, - void *opaque) -{ - virStreamPtr stream = opaque; - struct qemud_driver *driver = stream->conn->privateData; - struct qemuStreamMigFile *qemust = stream->privateData; - virStreamEventCallback cb; - void *cbopaque; - virFreeCallback ff; - - qemuDriverLock(driver); - if (!qemust || !qemust->cb) { - qemuDriverUnlock(driver); - return; - } - - cb = qemust->cb; - cbopaque = qemust->opaque; - ff = qemust->ff; - qemust->dispatching = 1; - qemuDriverUnlock(driver); - - cb(stream, events, cbopaque); - - qemuDriverLock(driver); - qemust->dispatching = 0; - if (qemust->cbRemoved && ff) - (ff)(cbopaque); - qemuDriverUnlock(driver); -} - -static int -qemuStreamMigAddCallback(virStreamPtr st, - int events, - virStreamEventCallback cb, - void *opaque, - virFreeCallback ff) -{ - struct qemud_driver *driver = st->conn->privateData; - struct qemuStreamMigFile *qemust = st->privateData; - int ret = -1; - - if (!qemust) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream is not open")); - return -1; - } - - qemuDriverLock(driver); - if (qemust->watch != 0) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream already has a callback registered")); - goto cleanup; - } - - if ((qemust->watch = virEventAddHandle(qemust->fd, - events, - qemuStreamMigEvent, - st, - NULL)) < 0) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("cannot register file watch on stream")); - goto cleanup; - } - - qemust->cbRemoved = 0; - qemust->cb = cb; - qemust->opaque = opaque; - qemust->ff = ff; - virStreamRef(st); - - ret = 0; - -cleanup: - qemuDriverUnlock(driver); - return ret; -} - -static void qemuStreamMigFree(struct qemuStreamMigFile *qemust) -{ - if (qemust->fd != -1) - close(qemust->fd); - VIR_FREE(qemust); -} - -static struct qemuStreamMigFile *qemuStreamMigOpen(virStreamPtr st, - const char *unixfile) -{ - struct qemuStreamMigFile *qemust = NULL; - struct sockaddr_un sa_qemu; - int i = 0; - int timeout = 3; - int ret; - - if (VIR_ALLOC(qemust) < 0) { - virReportOOMError(); - return NULL; - } - - qemust->fd = socket(AF_UNIX, SOCK_STREAM, 0); - if (qemust->fd < 0) - goto cleanup; - - memset(&sa_qemu, 0, sizeof(sa_qemu)); - sa_qemu.sun_family = AF_UNIX; - if (virStrcpy(sa_qemu.sun_path, unixfile, sizeof(sa_qemu.sun_path)) == NULL) - goto cleanup; - - do { - ret = connect(qemust->fd, (struct sockaddr *)&sa_qemu, sizeof(sa_qemu)); - if (ret == 0) - break; - - if (errno == ENOENT || errno == ECONNREFUSED) { - /* ENOENT : Socket may not have shown up yet - * ECONNREFUSED : Leftover socket hasn't been removed yet */ - continue; - } - - goto cleanup; - } while ((++i <= timeout*5) && (usleep(.2 * 1000000) <= 0)); - - if ((st->flags & VIR_STREAM_NONBLOCK) && virSetNonBlock(qemust->fd) < 0) - goto cleanup; - - return qemust; - -cleanup: - qemuStreamMigFree(qemust); - return NULL; -} - -static int -qemuStreamMigClose(virStreamPtr st) -{ - struct qemud_driver *driver = st->conn->privateData; - struct qemuStreamMigFile *qemust = st->privateData; - - if (!qemust) - return 0; - - qemuDriverLock(driver); - - qemuStreamMigFree(qemust); - - st->privateData = NULL; - - qemuDriverUnlock(driver); - - return 0; -} - -static int qemuStreamMigWrite(virStreamPtr st, const char *bytes, size_t nbytes) -{ - struct qemud_driver *driver = st->conn->privateData; - struct qemuStreamMigFile *qemust = st->privateData; - int ret; - - if (!qemust) { - qemuReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("stream is not open")); - return -1; - } - - qemuDriverLock(driver); - -retry: - ret = write(qemust->fd, bytes, nbytes); - if (ret < 0) { - if (errno == EAGAIN || errno == EWOULDBLOCK) { - ret = -2; - } else if (errno == EINTR) { - goto retry; - } else { - ret = -1; - virReportSystemError(errno, "%s", - _("cannot write to stream")); - } - } - - qemuDriverUnlock(driver); - return ret; -} - -static virStreamDriver qemuStreamMigDrv = { - .streamSend = qemuStreamMigWrite, - .streamFinish = qemuStreamMigClose, - .streamAbort = qemuStreamMigClose, - .streamAddCallback = qemuStreamMigAddCallback, - .streamUpdateCallback = qemuStreamMigUpdateCallback, - .streamRemoveCallback = qemuStreamMigRemoveCallback -}; - /* Prepare is the first step, and it runs on the destination host. * * This version starts an empty VM listening on a localhost TCP port, and @@ -11041,7 +10769,6 @@ qemudDomainMigratePrepareTunnel(virConnectPtr dconn, int internalret; char *unixfile = NULL; unsigned long long qemuCmdFlags; - struct qemuStreamMigFile *qemust = NULL; qemuDomainObjPrivatePtr priv = NULL; struct timeval now; @@ -11151,8 +10878,9 @@ qemudDomainMigratePrepareTunnel(virConnectPtr dconn, goto endjob; } - qemust = qemuStreamMigOpen(st, unixfile); - if (qemust == NULL) { + if (virFDStreamConnectUNIX(st, + unixfile, + false) < 0) { qemuDomainStartAudit(vm, "migrated", false); qemudShutdownVMDaemon(driver, vm, 0); if (!vm->persistent) { @@ -11166,10 +10894,8 @@ qemudDomainMigratePrepareTunnel(virConnectPtr dconn, goto endjob; } - st->driver = &qemuStreamMigDrv; - st->privateData = qemust; - qemuDomainStartAudit(vm, "migrated", true); + event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_MIGRATED); diff --git a/src/util/virterror.c b/src/util/virterror.c index 70749a7..4214d6b 100644 --- a/src/util/virterror.c +++ b/src/util/virterror.c @@ -190,6 +190,9 @@ static const char *virErrorDomainName(virErrorDomain domain) { case VIR_FROM_AUDIT: dom = "Audit"; break; + case VIR_FROM_STREAMS: + dom = "Streams "; + break; } return(dom); } -- 1.7.2.3

On Mon, Nov 01, 2010 at 02:38:14PM -0600, Eric Blake wrote: IMHO, leaving off the comma needlessly enlarges future patches because 2 lines have to be changed to add an entry instead of just one. Yes, i guess so. Doesn't gnulib take care of TCP socket portability for us ? virFDStreamFree is what actually closes the FD in this case, and could return an error status to the caller. No, this has to return an int, to match the public API calling convention. It doesn't help, because the API has to return 'int' regardless. Yep, probably should. AFAIK, there's no way to open a socket as a path on the filesystem is there ? So there'd be no way that open(path) could return an FD for which S_ISSOCK() is true. When I fix the code to deal with non-blocking I/O on regular files, they will probably need some different handling in each case. Looks like a bug to me. Regards, Daniel -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://deltacloud.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|

* src/util/virterror.c (virErrorDomainName): Always supply trailing space if category was present. --- Then I'm pushing this under the trivial rule (okay, it's a bit of a stretch, since the whitespace is significant as part of a string literal rather than insignificant as in indentation, but I didn't think anyone would mind :) src/util/virterror.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/virterror.c b/src/util/virterror.c index 70749a7..dc08aaa 100644 --- a/src/util/virterror.c +++ b/src/util/virterror.c @@ -179,7 +179,7 @@ static const char *virErrorDomainName(virErrorDomain domain) { dom = "CPU "; break; case VIR_FROM_NWFILTER: - dom = "Network Filter"; + dom = "Network Filter "; break; case VIR_FROM_HOOK: dom = "Sync Hook "; @@ -188,7 +188,7 @@ static const char *virErrorDomainName(virErrorDomain domain) { dom = "Domain Snapshot "; break; case VIR_FROM_AUDIT: - dom = "Audit"; + dom = "Audit "; break; } return(dom); -- 1.7.2.3

When closing open streams after a client quits, the event callback was not removed. This mean that poll() was using a closed FD and returning POLLNVAL in a busy-wait loop. * daemon/stream.c: Disconnect stream callbacks --- daemon/stream.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-) diff --git a/daemon/stream.c b/daemon/stream.c index d64fe73..cac54ea 100644 --- a/daemon/stream.c +++ b/daemon/stream.c @@ -108,6 +108,7 @@ remoteStreamEvent(virStreamPtr st, int events, void *opaque) remote_error rerr; memset(&rerr, 0, sizeof rerr); stream->closed = 1; + virStreamEventRemoveCallback(stream->st); virStreamAbort(stream->st); if (events & VIR_STREAM_EVENT_HANGUP) remoteDispatchFormatError(&rerr, "%s", _("stream had unexpected termination")); @@ -345,8 +346,10 @@ remoteRemoveClientStream(struct qemud_client *client, } } - if (!stream->closed) + if (!stream->closed) { + virStreamEventRemoveCallback(stream->st); virStreamAbort(stream->st); + } while (curr) { if (curr == stream) { @@ -429,6 +432,7 @@ remoteStreamHandleFinish(struct qemud_client *client, memset(&rerr, 0, sizeof rerr); stream->closed = 1; + virStreamEventRemoveCallback(stream->st); ret = virStreamFinish(stream->st); if (ret < 0) { @@ -462,6 +466,7 @@ remoteStreamHandleAbort(struct qemud_client *client, memset(&rerr, 0, sizeof rerr); stream->closed = 1; + virStreamEventRemoveCallback(stream->st); virStreamAbort(stream->st); if (msg->hdr.status == REMOTE_ERROR) -- 1.7.2.3

* src/lxc/lxc_driver.c, src/lxc/lxc_driver.c, src/xen/xen_driver.c: Wire up virDomainOpenConsole --- src/lxc/lxc_driver.c | 67 ++++++++++++++++++++++++++++++++++++++++++- src/uml/uml_driver.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++---- src/xen/xen_driver.c | 59 +++++++++++++++++++++++++++++++++++++- 3 files changed, 195 insertions(+), 8 deletions(-) diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index 48a38d1..f0d16a7 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -51,6 +51,7 @@ #include "uuid.h" #include "stats_linux.h" #include "hooks.h" +#include "fdstream.h" #define VIR_FROM_THIS VIR_FROM_LXC @@ -2738,6 +2739,70 @@ cleanup: return ret; } +static int +lxcDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags) +{ + lxc_driver_t *driver = dom->conn->privateData; + virDomainObjPtr vm = NULL; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + int ret = -1; + virDomainChrDefPtr chr = NULL; + + virCheckFlags(0, -1); + + lxcDriverLock(driver); + virUUIDFormat(dom->uuid, uuidstr); + vm = virDomainFindByUUID(&driver->domains, dom->uuid); + if (!vm) { + lxcError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s'"), uuidstr); + goto cleanup; + } + + if (!virDomainObjIsActive(vm)) { + lxcError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto cleanup; + } + + if (devname) { + /* XXX support device aliases in future */ + lxcError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Named device aliases are not supported")); + goto cleanup; + } else { + if (vm->def->console) + chr = vm->def->console; + else if (vm->def->nserials) + chr = vm->def->serials[0]; + } + + if (!chr) { + lxcError(VIR_ERR_INTERNAL_ERROR, "%s", + _("cannot find default console device")); + goto cleanup; + } + + if (chr->type != VIR_DOMAIN_CHR_TYPE_PTY) { + lxcError(VIR_ERR_INTERNAL_ERROR, + _("character device %s is not using a PTY"), devname); + goto cleanup; + } + + if (virFDStreamOpenFile(st, chr->data.file.path, O_RDWR) < 0) + goto cleanup; + + ret = 0; +cleanup: + if (vm) + virDomainObjUnlock(vm); + lxcDriverUnlock(driver); + return ret; +} + /* Function Tables */ static virDriver lxcDriver = { @@ -2844,7 +2909,7 @@ static virDriver lxcDriver = { NULL, /* qemuDomainMonitorCommand */ lxcDomainSetMemoryParameters, /* domainSetMemoryParameters */ lxcDomainGetMemoryParameters, /* domainGetMemoryParameters */ - NULL, /* domainOpenConsole */ + lxcDomainOpenConsole, /* domainOpenConsole */ }; static virStateDriver lxcStateDriver = { diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index e0bb4e5..e54db3d 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -59,6 +59,7 @@ #include "datatypes.h" #include "logging.h" #include "domain_nwfilter.h" +#include "fdstream.h" #define VIR_FROM_THIS VIR_FROM_UML @@ -2025,11 +2026,11 @@ cleanup: static int -umlDomainBlockPeek (virDomainPtr dom, - const char *path, - unsigned long long offset, size_t size, - void *buffer, - unsigned int flags ATTRIBUTE_UNUSED) +umlDomainBlockPeek(virDomainPtr dom, + const char *path, + unsigned long long offset, size_t size, + void *buffer, + unsigned int flags ATTRIBUTE_UNUSED) { struct uml_driver *driver = dom->conn->privateData; virDomainObjPtr vm; @@ -2095,6 +2096,70 @@ cleanup: } +static int +umlDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags) +{ + struct uml_driver *driver = dom->conn->privateData; + virDomainObjPtr vm = NULL; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + int ret = -1; + virDomainChrDefPtr chr = NULL; + + virCheckFlags(0, -1); + + umlDriverLock(driver); + virUUIDFormat(dom->uuid, uuidstr); + vm = virDomainFindByUUID(&driver->domains, dom->uuid); + if (!vm) { + umlReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s'"), uuidstr); + goto cleanup; + } + + if (!virDomainObjIsActive(vm)) { + umlReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto cleanup; + } + + if (devname) { + /* XXX support device aliases in future */ + umlReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Named device aliases are not supported")); + goto cleanup; + } else { + if (vm->def->console) + chr = vm->def->console; + else if (vm->def->nserials) + chr = vm->def->serials[0]; + } + + if (!chr) { + umlReportError(VIR_ERR_INTERNAL_ERROR, + _("cannot find character device %s"), devname); + goto cleanup; + } + + if (chr->type != VIR_DOMAIN_CHR_TYPE_PTY) { + umlReportError(VIR_ERR_INTERNAL_ERROR, + _("character device %s is not using a PTY"), devname); + goto cleanup; + } + + if (virFDStreamOpenFile(st, chr->data.file.path, O_RDWR) < 0) + goto cleanup; + + ret = 0; +cleanup: + if (vm) + virDomainObjUnlock(vm); + umlDriverUnlock(driver); + return ret; +} + static virDriver umlDriver = { VIR_DRV_UML, @@ -2200,7 +2265,7 @@ static virDriver umlDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParamters */ NULL, /* domainGetMemoryParamters */ - NULL, /* domainOpenConsole */ + umlDomainOpenConsole, /* domainOpenConsole */ }; static int diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 9cc46ae..008a4c9 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -24,6 +24,7 @@ #include <string.h> #include <errno.h> #include <sys/types.h> +#include <fcntl.h> #include <xen/dom0_ops.h> #include <libxml/uri.h> @@ -46,6 +47,7 @@ #include "node_device_conf.h" #include "pci.h" #include "uuid.h" +#include "fdstream.h" #define VIR_FROM_THIS VIR_FROM_XEN @@ -1980,6 +1982,61 @@ out: } +static int +xenUnifiedDomainOpenConsole(virDomainPtr dom, + const char *devname, + virStreamPtr st, + unsigned int flags) +{ + virDomainDefPtr def = NULL; + int ret = -1; + virDomainChrDefPtr chr = NULL; + + virCheckFlags(0, -1); + + if (dom->id == -1) { + xenUnifiedError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto cleanup; + } + + if (devname) { + /* XXX support device aliases in future */ + xenUnifiedError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Named device aliases are not supported")); + goto cleanup; + } + + def = xenDaemonDomainFetch(dom->conn, dom->id, dom->name, NULL); + if (!def) + goto cleanup; + + if (def->console) + chr = def->console; + else if (def->nserials) + chr = def->serials[0]; + + if (!chr) { + xenUnifiedError(VIR_ERR_INTERNAL_ERROR, "%s", + _("cannot find default console device")); + goto cleanup; + } + + if (chr->type != VIR_DOMAIN_CHR_TYPE_PTY) { + xenUnifiedError(VIR_ERR_INTERNAL_ERROR, + _("character device %s is not using a PTY"), devname); + goto cleanup; + } + + if (virFDStreamOpenFile(st, chr->data.file.path, O_RDWR) < 0) + goto cleanup; + + ret = 0; +cleanup: + if (def) + virDomainDefFree(def); + return ret; +} /*----- Register with libvirt.c, and initialize Xen drivers. -----*/ /* The interface which we export upwards to libvirt.c. */ @@ -2087,7 +2144,7 @@ static virDriver xenUnifiedDriver = { NULL, /* qemuDomainMonitorCommand */ NULL, /* domainSetMemoryParameters */ NULL, /* domainGetMemoryParameters */ - NULL, /* domainOpenConsole */ + xenUnifiedDomainOpenConsole, /* domainOpenConsole */ }; /** -- 1.7.2.3