==5414== by 0x34D9021734: (below main) (in /usr/lib64/libc-2.15.so)
In this example, the ``virDomainDefParseXML()`` had an error
-path where the ``virDomainVideoDefPtr video`` pointer was not
+path where the ``virDomainVideoDef *video`` pointer was not
properly disposed. By simply adding a
``virDomainVideoDefFree(video);`` in the error path, the issue
was resolved.
If the new API is applicable to more than one driver, it may make sense
to provide some utility routines, or to factor some of the work into the
dispatcher, to avoid reimplementing the same code in every driver. In
-the example code, this involved adding a member to the virDomainDefPtr
+the example code, this involved adding a member to the virDomainDef
struct for mapping between the XML API addition and the in-memory
representation of a domain, along with updating all clients to use the
new member. Up to this point, there have been no changes to existing
::
- void virCommandAddEnvFormat(virCommandPtr cmd, const char *format, ...)
+ void virCommandAddEnvFormat(virCommand *cmd, const char *format, ...)
G_GNUC_PRINTF(2, 3);
This makes it so gcc's -Wformat and -Wformat-security options can
</p>
<pre>
-virCommandPtr cmd = virCommandNew("/usr/bin/dnsmasq");
+virCommand *cmd = virCommandNew("/usr/bin/dnsmasq");
</pre>
<p>
<p>
This can also be done at the time of initial construction of
- the <code>virCommandPtr</code> object:
+ the <code>virCommand *</code> object:
</p>
<pre>
"--strict-order", "--except-interface",
"lo", "--domain", "localdomain", NULL
};
-virCommandPtr cmd1 = virCommandNewArgs(cmd, args);
-virCommandPtr cmd2 = virCommandNewArgList("/usr/bin/dnsmasq",
+virCommand *cmd1 = virCommandNewArgs(cmd, args);
+virCommand *cmd2 = virCommandNewArgList("/usr/bin/dnsmasq",
"--domain", "localdomain", NULL);
</pre>
<p>
Once the command has been executed, or if execution
has been abandoned, it is necessary to release
- resources associated with the <code>virCommandPtr</code>
+ resources associated with the <code>virCommand *</code>
object. This is done with:
</p>
{
int ret;
char *path;
- virCommandPtr cmd;
+ virCommand *cmd;
virBuildPath(&path, LIBVIRT_HOOK_DIR, drvstr);
</p>
<dl>
- <dt><code>virNetSASLContextPtr</code> (virnetsaslcontext.h)</dt>
+ <dt><code>virNetSASLContext *</code> (virnetsaslcontext.h)</dt>
<dd>The virNetSASLContext APIs maintain SASL state for a network
service (server or client). This is primarily used on the server
to provide an access control list of SASL usernames permitted as
clients.
</dd>
- <dt><code>virNetSASLSessionPtr</code> (virnetsaslcontext.h)</dt>
+ <dt><code>virNetSASLSession *</code> (virnetsaslcontext.h)</dt>
<dd>The virNetSASLSession APIs maintain SASL state for a single
network connection (socket). This is used to perform the multi-step
SASL handshake and perform encryption/decryption of data once
authenticated, via integration with virNetSocket.
</dd>
- <dt><code>virNetTLSContextPtr</code> (virnettlscontext.h)</dt>
+ <dt><code>virNetTLSContext *</code> (virnettlscontext.h)</dt>
<dd>The virNetTLSContext APIs maintain TLS state for a network
service (server or client). This is primarily used on the server
to provide an access control list of x509 distinguished names, as
to improve detection of configuration errors.
</dd>
- <dt><code>virNetTLSSessionPtr</code> (virnettlscontext.h)</dt>
+ <dt><code>virNetTLSSession *</code> (virnettlscontext.h)</dt>
<dd>The virNetTLSSession APIs maintain TLS state for a single
network connection (socket). This is used to perform the multi-step
TLS handshake and perform encryption/decryption of data once
authenticated, via integration with virNetSocket.
</dd>
- <dt><code>virNetSocketPtr</code> (virnetsocket.h)</dt>
+ <dt><code>virNetSocket *</code> (virnetsocket.h)</dt>
<dd>The virNetSocket APIs provide a higher level wrapper around
the raw BSD sockets and getaddrinfo APIs. They allow for creation
of both server and client sockets. Data transports supported are
TCP, UNIX, SSH tunnel or external command tunnel. Internally the
TCP socket impl uses the getaddrinfo info APIs to ensure correct
protocol-independent behaviour, thus supporting both IPv4 and IPv6.
- The socket APIs can be associated with a virNetSASLSessionPtr or
- virNetTLSSessionPtr object to allow seamless encryption/decryption
+ The socket APIs can be associated with a virNetSASLSession *or
+ virNetTLSSession *object to allow seamless encryption/decryption
of all writes and reads. For UNIX sockets it is possible to obtain
the remote client user ID and process ID. Integration with the
libvirt event loop also allows use of callbacks for notification
of various I/O conditions
</dd>
- <dt><code>virNetMessagePtr</code> (virnetmessage.h)</dt>
+ <dt><code>virNetMessage *</code> (virnetmessage.h)</dt>
<dd>The virNetMessage APIs provide a wrapper around the libxdr
API calls, to facilitate processing and creation of RPC
packets. There are convenience APIs for encoding/encoding the
encoding a virErrorPtr object. There is also a means to
add to/serve from a linked-list queue of messages.</dd>
- <dt><code>virNetClientPtr</code> (virnetclient.h)</dt>
+ <dt><code>virNetClient *</code> (virnetclient.h)</dt>
<dd>The virNetClient APIs provide a way to connect to a
remote server and run one or more RPC protocols over
the connection. Connections can be made over TCP, UNIX
being interleaved on the wire as required.
</dd>
- <dt><code>virNetClientProgramPtr</code> (virnetclientprogram.h)</dt>
+ <dt><code>virNetClientProgram *</code> (virnetclientprogram.h)</dt>
<dd>The virNetClientProgram APIs are used to register a
program+version with the connection. This then enables
invocation of method calls, receipt of asynchronous
care of dispatching any incoming asynchronous events.
</dd>
- <dt><code>virNetClientStreamPtr</code> (virnetclientstream.h)</dt>
+ <dt><code>virNetClientStream *</code> (virnetclientstream.h)</dt>
<dd>The virNetClientStream APIs are used to control transmission and
receipt of data over a stream active on a client. Streams provide
a low latency, unlimited length, bi-directional raw data exchange
mechanism layered over the RPC connection
</dd>
- <dt><code>virNetServerPtr</code> (virnetserver.h)</dt>
+ <dt><code>virNetServer *</code> (virnetserver.h)</dt>
<dd>The virNetServer APIs are used to manage a network server. A
server exposed one or more programs, over one or more services.
It manages multiple client connections invoking multiple RPC
calls in parallel, with dispatch across multiple worker threads.
</dd>
- <dt><code>virNetDaemonPtr</code> (virnetdaemon.h)</dt>
+ <dt><code>virNetDaemon *</code> (virnetdaemon.h)</dt>
<dd>The virNetDaemon APIs are used to manage a daemon process. A
daemon is a process that might expose one or more servers. It
handles most process-related details, network-related should
be part of the underlying server.
</dd>
- <dt><code>virNetServerClientPtr</code> (virnetserverclient.h)</dt>
+ <dt><code>virNetServerClient *</code> (virnetserverclient.h)</dt>
<dd>The virNetServerClient APIs are used to manage I/O related
to a single client network connection. It handles initial
validation and routing of incoming RPC packets, and transmission
of outgoing packets.
</dd>
- <dt><code>virNetServerProgramPtr</code> (virnetserverprogram.h)</dt>
+ <dt><code>virNetServerProgram *</code> (virnetserverprogram.h)</dt>
<dd>The virNetServerProgram APIs are used to provide the implementation
of a single program/version set. Primarily this includes a set of
callbacks used to actually invoke the APIs corresponding to
program procedure numbers. It is responsible for all the serialization
of payloads to/from XDR.</dd>
- <dt><code>virNetServerServicePtr</code> (virnetserverservice.h)</dt>
+ <dt><code>virNetServerService *</code> (virnetserverservice.h)</dt>
<dd>The virNetServerService APIs are used to connect the server to
one or more network protocols. A single service may involve multiple
sockets (ie both IPv4 and IPv6). A service also has an associated
header += ((
"int esxVI_%s_Serialize(esxVI_%s *item, "
" const char *element, "
- " virBufferPtr output);\n") %
+ " virBuffer *output);\n") %
(self.name, self.name))
if self.features & Object.FEATURE__LIST:
header += ((
"int esxVI_%s_SerializeList(esxVI_%s *list, "
" const char *element, "
- " virBufferPtr output);\n") %
+ " virBuffer *output);\n") %
(self.name, self.name))
if self.features & Object.FEATURE__DESERIALIZE:
if self.features & Enum.FEATURE__SERIALIZE:
header += ("int esxVI_%s_Serialize(esxVI_%s item, const char *element, "
- " virBufferPtr output);\n") \
+ " virBuffer *output);\n") \
% (self.name, self.name)
if self.features & Enum.FEATURE__DESERIALIZE:
header += "#define %s_WQL_SELECT \\\n" % name_upper
header += " \"SELECT * FROM %s \"\n" % self.name
header += "\n"
- header += "extern hypervWmiClassInfoPtr %s_WmiInfo;\n\n" % self.name
+ header += "extern hypervWmiClassInfo *%s_WmiInfo;\n\n" % self.name
header += self._declare_data_structs()
header += self._declare_hypervObject_struct()
header = "\n/* must match hypervObject */\n"
header += "struct _%s {\n" % self.name
header += " %s_Data *data;\n" % self.name
- header += " hypervWmiClassInfoPtr info;\n"
+ header += " hypervWmiClassInfo *info;\n"
header += " %s *next;\n" % self.name
header += "};\n"
This struct holds info with meta-data needed to make wsman requests for the WMI class.
"""
- source = "hypervWmiClassInfoPtr %s_WmiInfo = &(hypervWmiClassInfo) {\n" % self.name
+ source = "hypervWmiClassInfo *%s_WmiInfo = &(hypervWmiClassInfo) {\n" % self.name
source += " .name = \"%s\",\n" % self.name
source += " .rootUri = %s,\n" % self.uri_info.rootUri
source += " .resourceUri = %s_RESOURCE_URI,\n" % self.name.upper()
#include "conf/domain_conf.h"
#include "access/viraccessmanager.h"
-typedef int (*virAccessDriverCheckConnectDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckConnectDrv)(virAccessManager *manager,
const char *driverName,
virAccessPermConnect av);
-typedef int (*virAccessDriverCheckDomainDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckDomainDrv)(virAccessManager *manager,
const char *driverName,
- virDomainDefPtr domain,
+ virDomainDef *domain,
virAccessPermDomain av);
-typedef int (*virAccessDriverCheckInterfaceDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckInterfaceDrv)(virAccessManager *manager,
const char *driverName,
- virInterfaceDefPtr iface,
+ virInterfaceDef *iface,
virAccessPermInterface av);
-typedef int (*virAccessDriverCheckNetworkDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckNetworkDrv)(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
+ virNetworkDef *network,
virAccessPermNetwork av);
-typedef int (*virAccessDriverCheckNetworkPortDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckNetworkPortDrv)(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
- virNetworkPortDefPtr port,
+ virNetworkDef *network,
+ virNetworkPortDef *port,
virAccessPermNetworkPort av);
-typedef int (*virAccessDriverCheckNodeDeviceDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckNodeDeviceDrv)(virAccessManager *manager,
const char *driverName,
- virNodeDeviceDefPtr nodedev,
+ virNodeDeviceDef *nodedev,
virAccessPermNodeDevice av);
-typedef int (*virAccessDriverCheckNWFilterDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckNWFilterDrv)(virAccessManager *manager,
const char *driverName,
- virNWFilterDefPtr nwfilter,
+ virNWFilterDef *nwfilter,
virAccessPermNWFilter av);
-typedef int (*virAccessDriverCheckNWFilterBindingDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckNWFilterBindingDrv)(virAccessManager *manager,
const char *driverName,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
virAccessPermNWFilterBinding av);
-typedef int (*virAccessDriverCheckSecretDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckSecretDrv)(virAccessManager *manager,
const char *driverName,
- virSecretDefPtr secret,
+ virSecretDef *secret,
virAccessPermSecret av);
-typedef int (*virAccessDriverCheckStoragePoolDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckStoragePoolDrv)(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
+ virStoragePoolDef *pool,
virAccessPermStoragePool av);
-typedef int (*virAccessDriverCheckStorageVolDrv)(virAccessManagerPtr manager,
+typedef int (*virAccessDriverCheckStorageVolDrv)(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolDef *pool,
+ virStorageVolDef *vol,
virAccessPermStorageVol av);
-typedef int (*virAccessDriverSetupDrv)(virAccessManagerPtr manager);
-typedef void (*virAccessDriverCleanupDrv)(virAccessManagerPtr manager);
+typedef int (*virAccessDriverSetupDrv)(virAccessManager *manager);
+typedef void (*virAccessDriverCleanupDrv)(virAccessManager *manager);
typedef struct _virAccessDriver virAccessDriver;
-typedef virAccessDriver *virAccessDriverPtr;
-
struct _virAccessDriver {
size_t privateDataLen;
const char *name;
#include "access/viraccessdrivernop.h"
static int
-virAccessDriverNopCheckConnect(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckConnect(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
virAccessPermConnect perm G_GNUC_UNUSED)
{
}
static int
-virAccessDriverNopCheckDomain(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckDomain(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virDomainDefPtr domain G_GNUC_UNUSED,
+ virDomainDef *domain G_GNUC_UNUSED,
virAccessPermDomain perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckInterface(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckInterface(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virInterfaceDefPtr iface G_GNUC_UNUSED,
+ virInterfaceDef *iface G_GNUC_UNUSED,
virAccessPermInterface perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckNetwork(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckNetwork(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virNetworkDefPtr network G_GNUC_UNUSED,
+ virNetworkDef *network G_GNUC_UNUSED,
virAccessPermNetwork perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckNetworkPort(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckNetworkPort(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virNetworkDefPtr network G_GNUC_UNUSED,
- virNetworkPortDefPtr port G_GNUC_UNUSED,
+ virNetworkDef *network G_GNUC_UNUSED,
+ virNetworkPortDef *port G_GNUC_UNUSED,
virAccessPermNetworkPort perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckNodeDevice(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckNodeDevice(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virNodeDeviceDefPtr nodedev G_GNUC_UNUSED,
+ virNodeDeviceDef *nodedev G_GNUC_UNUSED,
virAccessPermNodeDevice perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckNWFilter(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckNWFilter(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virNWFilterDefPtr nwfilter G_GNUC_UNUSED,
+ virNWFilterDef *nwfilter G_GNUC_UNUSED,
virAccessPermNWFilter perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckNWFilterBinding(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckNWFilterBinding(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virNWFilterBindingDefPtr binding G_GNUC_UNUSED,
+ virNWFilterBindingDef *binding G_GNUC_UNUSED,
virAccessPermNWFilterBinding perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckSecret(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckSecret(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virSecretDefPtr secret G_GNUC_UNUSED,
+ virSecretDef *secret G_GNUC_UNUSED,
virAccessPermSecret perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckStoragePool(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckStoragePool(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virStoragePoolDefPtr pool G_GNUC_UNUSED,
+ virStoragePoolDef *pool G_GNUC_UNUSED,
virAccessPermStoragePool perm G_GNUC_UNUSED)
{
return 1; /* Allow */
}
static int
-virAccessDriverNopCheckStorageVol(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverNopCheckStorageVol(virAccessManager *manager G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
- virStoragePoolDefPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol G_GNUC_UNUSED,
+ virStoragePoolDef *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol G_GNUC_UNUSED,
virAccessPermStorageVol perm G_GNUC_UNUSED)
{
return 1; /* Allow */
#define VIR_ACCESS_DRIVER_POLKIT_ACTION_PREFIX "org.libvirt.api"
typedef struct _virAccessDriverPolkitPrivate virAccessDriverPolkitPrivate;
-typedef virAccessDriverPolkitPrivate *virAccessDriverPolkitPrivatePtr;
-
struct _virAccessDriverPolkitPrivate {
bool ignore;
};
-static void virAccessDriverPolkitCleanup(virAccessManagerPtr manager G_GNUC_UNUSED)
+static void virAccessDriverPolkitCleanup(virAccessManager *manager G_GNUC_UNUSED)
{
}
static int
-virAccessDriverPolkitCheck(virAccessManagerPtr manager G_GNUC_UNUSED,
+virAccessDriverPolkitCheck(virAccessManager *manager G_GNUC_UNUSED,
const char *typename,
const char *permname,
const char **attrs)
static int
-virAccessDriverPolkitCheckConnect(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckConnect(virAccessManager *manager,
const char *driverName,
virAccessPermConnect perm)
{
}
static int
-virAccessDriverPolkitCheckDomain(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckDomain(virAccessManager *manager,
const char *driverName,
- virDomainDefPtr domain,
+ virDomainDef *domain,
virAccessPermDomain perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckInterface(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckInterface(virAccessManager *manager,
const char *driverName,
- virInterfaceDefPtr iface,
+ virInterfaceDef *iface,
virAccessPermInterface perm)
{
const char *attrs[] = {
}
static int
-virAccessDriverPolkitCheckNetwork(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckNetwork(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
+ virNetworkDef *network,
virAccessPermNetwork perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckNetworkPort(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckNetworkPort(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
- virNetworkPortDefPtr port,
+ virNetworkDef *network,
+ virNetworkPortDef *port,
virAccessPermNetworkPort perm)
{
char uuidstr1[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckNodeDevice(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckNodeDevice(virAccessManager *manager,
const char *driverName,
- virNodeDeviceDefPtr nodedev,
+ virNodeDeviceDef *nodedev,
virAccessPermNodeDevice perm)
{
const char *attrs[] = {
}
static int
-virAccessDriverPolkitCheckNWFilter(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckNWFilter(virAccessManager *manager,
const char *driverName,
- virNWFilterDefPtr nwfilter,
+ virNWFilterDef *nwfilter,
virAccessPermNWFilter perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckNWFilterBinding(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckNWFilterBinding(virAccessManager *manager,
const char *driverName,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
virAccessPermNWFilterBinding perm)
{
const char *attrs[] = {
}
static int
-virAccessDriverPolkitCheckSecret(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckSecret(virAccessManager *manager,
const char *driverName,
- virSecretDefPtr secret,
+ virSecretDef *secret,
virAccessPermSecret perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckStoragePool(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckStoragePool(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
+ virStoragePoolDef *pool,
virAccessPermStoragePool perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-virAccessDriverPolkitCheckStorageVol(virAccessManagerPtr manager,
+virAccessDriverPolkitCheckStorageVol(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolDef *pool,
+ virStorageVolDef *vol,
virAccessPermStorageVol perm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
#define VIR_FROM_THIS VIR_FROM_ACCESS
typedef struct _virAccessDriverStackPrivate virAccessDriverStackPrivate;
-typedef virAccessDriverStackPrivate *virAccessDriverStackPrivatePtr;
-
struct _virAccessDriverStackPrivate {
- virAccessManagerPtr *managers;
+ virAccessManager **managers;
size_t managersLen;
};
-int virAccessDriverStackAppend(virAccessManagerPtr manager,
- virAccessManagerPtr child)
+int virAccessDriverStackAppend(virAccessManager *manager,
+ virAccessManager *child)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
VIR_EXPAND_N(priv->managers, priv->managersLen, 1);
}
-static void virAccessDriverStackCleanup(virAccessManagerPtr manager)
+static void virAccessDriverStackCleanup(virAccessManager *manager)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
size_t i;
for (i = 0; i < priv->managersLen; i++)
static int
-virAccessDriverStackCheckConnect(virAccessManagerPtr manager,
+virAccessDriverStackCheckConnect(virAccessManager *manager,
const char *driverName,
virAccessPermConnect perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckDomain(virAccessManagerPtr manager,
+virAccessDriverStackCheckDomain(virAccessManager *manager,
const char *driverName,
- virDomainDefPtr domain,
+ virDomainDef *domain,
virAccessPermDomain perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckInterface(virAccessManagerPtr manager,
+virAccessDriverStackCheckInterface(virAccessManager *manager,
const char *driverName,
- virInterfaceDefPtr iface,
+ virInterfaceDef *iface,
virAccessPermInterface perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckNetwork(virAccessManagerPtr manager,
+virAccessDriverStackCheckNetwork(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
+ virNetworkDef *network,
virAccessPermNetwork perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckNetworkPort(virAccessManagerPtr manager,
+virAccessDriverStackCheckNetworkPort(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
- virNetworkPortDefPtr port,
+ virNetworkDef *network,
+ virNetworkPortDef *port,
virAccessPermNetworkPort perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckNodeDevice(virAccessManagerPtr manager,
+virAccessDriverStackCheckNodeDevice(virAccessManager *manager,
const char *driverName,
- virNodeDeviceDefPtr nodedev,
+ virNodeDeviceDef *nodedev,
virAccessPermNodeDevice perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckNWFilter(virAccessManagerPtr manager,
+virAccessDriverStackCheckNWFilter(virAccessManager *manager,
const char *driverName,
- virNWFilterDefPtr nwfilter,
+ virNWFilterDef *nwfilter,
virAccessPermNWFilter perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckNWFilterBinding(virAccessManagerPtr manager,
+virAccessDriverStackCheckNWFilterBinding(virAccessManager *manager,
const char *driverName,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
virAccessPermNWFilterBinding perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckSecret(virAccessManagerPtr manager,
+virAccessDriverStackCheckSecret(virAccessManager *manager,
const char *driverName,
- virSecretDefPtr secret,
+ virSecretDef *secret,
virAccessPermSecret perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckStoragePool(virAccessManagerPtr manager,
+virAccessDriverStackCheckStoragePool(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
+ virStoragePoolDef *pool,
virAccessPermStoragePool perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
}
static int
-virAccessDriverStackCheckStorageVol(virAccessManagerPtr manager,
+virAccessDriverStackCheckStorageVol(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolDef *pool,
+ virStorageVolDef *vol,
virAccessPermStorageVol perm)
{
- virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager);
+ virAccessDriverStackPrivate *priv = virAccessManagerGetPrivateData(manager);
int ret = 1;
size_t i;
#include "access/viraccessdriver.h"
-int virAccessDriverStackAppend(virAccessManagerPtr manager,
- virAccessManagerPtr child);
+int virAccessDriverStackAppend(virAccessManager *manager,
+ virAccessManager *child);
extern virAccessDriver accessDriverStack;
struct _virAccessManager {
virObjectLockable parent;
- virAccessDriverPtr drv;
+ virAccessDriver *drv;
void *privateData;
};
-static virClassPtr virAccessManagerClass;
-static virAccessManagerPtr virAccessManagerDefault;
+static virClass *virAccessManagerClass;
+static virAccessManager *virAccessManagerDefault;
static void virAccessManagerDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virAccessManager);
-virAccessManagerPtr virAccessManagerGetDefault(void)
+virAccessManager *virAccessManagerGetDefault(void)
{
if (virAccessManagerDefault == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-void virAccessManagerSetDefault(virAccessManagerPtr mgr)
+void virAccessManagerSetDefault(virAccessManager *mgr)
{
virObjectUnref(virAccessManagerDefault);
}
-static virAccessManagerPtr virAccessManagerNewDriver(virAccessDriverPtr drv)
+static virAccessManager *virAccessManagerNewDriver(virAccessDriver *drv)
{
- virAccessManagerPtr mgr;
+ virAccessManager *mgr;
char *privateData;
if (virAccessManagerInitialize() < 0)
}
-static virAccessDriverPtr accessDrivers[] = {
+static virAccessDriver *accessDrivers[] = {
&accessDriverNop,
#if WITH_POLKIT
&accessDriverPolkit,
};
-static virAccessDriverPtr virAccessManagerFindDriver(const char *name)
+static virAccessDriver *virAccessManagerFindDriver(const char *name)
{
size_t i;
for (i = 0; i < G_N_ELEMENTS(accessDrivers); i++) {
}
-virAccessManagerPtr virAccessManagerNew(const char *name)
+virAccessManager *virAccessManagerNew(const char *name)
{
- virAccessDriverPtr drv;
+ virAccessDriver *drv;
if (virAccessManagerInitialize() < 0)
return NULL;
}
-virAccessManagerPtr virAccessManagerNewStack(const char **names)
+virAccessManager *virAccessManagerNewStack(const char **names)
{
- virAccessManagerPtr manager = virAccessManagerNewDriver(&accessDriverStack);
+ virAccessManager *manager = virAccessManagerNewDriver(&accessDriverStack);
size_t i;
if (!manager)
return NULL;
for (i = 0; names[i] != NULL; i++) {
- virAccessManagerPtr child = virAccessManagerNew(names[i]);
+ virAccessManager *child = virAccessManagerNew(names[i]);
if (!child)
goto error;
}
-void *virAccessManagerGetPrivateData(virAccessManagerPtr mgr)
+void *virAccessManagerGetPrivateData(virAccessManager *mgr)
{
return mgr->privateData;
}
static void virAccessManagerDispose(void *object)
{
- virAccessManagerPtr mgr = object;
+ virAccessManager *mgr = object;
if (mgr->drv->cleanup)
mgr->drv->cleanup(mgr);
return ret;
}
-int virAccessManagerCheckConnect(virAccessManagerPtr manager,
+int virAccessManagerCheckConnect(virAccessManager *manager,
const char *driverName,
virAccessPermConnect perm)
{
}
-int virAccessManagerCheckDomain(virAccessManagerPtr manager,
+int virAccessManagerCheckDomain(virAccessManager *manager,
const char *driverName,
- virDomainDefPtr domain,
+ virDomainDef *domain,
virAccessPermDomain perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckInterface(virAccessManagerPtr manager,
+int virAccessManagerCheckInterface(virAccessManager *manager,
const char *driverName,
- virInterfaceDefPtr iface,
+ virInterfaceDef *iface,
virAccessPermInterface perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckNetwork(virAccessManagerPtr manager,
+int virAccessManagerCheckNetwork(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
+ virNetworkDef *network,
virAccessPermNetwork perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckNetworkPort(virAccessManagerPtr manager,
+int virAccessManagerCheckNetworkPort(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
- virNetworkPortDefPtr port,
+ virNetworkDef *network,
+ virNetworkPortDef *port,
virAccessPermNetworkPort perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckNodeDevice(virAccessManagerPtr manager,
+int virAccessManagerCheckNodeDevice(virAccessManager *manager,
const char *driverName,
- virNodeDeviceDefPtr nodedev,
+ virNodeDeviceDef *nodedev,
virAccessPermNodeDevice perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckNWFilter(virAccessManagerPtr manager,
+int virAccessManagerCheckNWFilter(virAccessManager *manager,
const char *driverName,
- virNWFilterDefPtr nwfilter,
+ virNWFilterDef *nwfilter,
virAccessPermNWFilter perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckNWFilterBinding(virAccessManagerPtr manager,
+int virAccessManagerCheckNWFilterBinding(virAccessManager *manager,
const char *driverName,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
virAccessPermNWFilterBinding perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckSecret(virAccessManagerPtr manager,
+int virAccessManagerCheckSecret(virAccessManager *manager,
const char *driverName,
- virSecretDefPtr secret,
+ virSecretDef *secret,
virAccessPermSecret perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckStoragePool(virAccessManagerPtr manager,
+int virAccessManagerCheckStoragePool(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
+ virStoragePoolDef *pool,
virAccessPermStoragePool perm)
{
int ret = 0;
return virAccessManagerSanitizeError(ret, driverName);
}
-int virAccessManagerCheckStorageVol(virAccessManagerPtr manager,
+int virAccessManagerCheckStorageVol(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolDef *pool,
+ virStorageVolDef *vol,
virAccessPermStorageVol perm)
{
int ret = 0;
#include "access/viraccessperm.h"
typedef struct _virAccessManager virAccessManager;
-typedef virAccessManager *virAccessManagerPtr;
-virAccessManagerPtr virAccessManagerGetDefault(void);
-void virAccessManagerSetDefault(virAccessManagerPtr manager);
+virAccessManager *virAccessManagerGetDefault(void);
+void virAccessManagerSetDefault(virAccessManager *manager);
-virAccessManagerPtr virAccessManagerNew(const char *name);
-virAccessManagerPtr virAccessManagerNewStack(const char **names);
+virAccessManager *virAccessManagerNew(const char *name);
+virAccessManager *virAccessManagerNewStack(const char **names);
-void *virAccessManagerGetPrivateData(virAccessManagerPtr manager);
+void *virAccessManagerGetPrivateData(virAccessManager *manager);
/*
* Return 0 on auth deny
* Return 1 on auth allow
*/
-int virAccessManagerCheckConnect(virAccessManagerPtr manager,
+int virAccessManagerCheckConnect(virAccessManager *manager,
const char *driverName,
virAccessPermConnect perm);
-int virAccessManagerCheckDomain(virAccessManagerPtr manager,
+int virAccessManagerCheckDomain(virAccessManager *manager,
const char *driverName,
- virDomainDefPtr domain,
+ virDomainDef *domain,
virAccessPermDomain perm);
-int virAccessManagerCheckInterface(virAccessManagerPtr manager,
+int virAccessManagerCheckInterface(virAccessManager *manager,
const char *driverName,
- virInterfaceDefPtr iface,
+ virInterfaceDef *iface,
virAccessPermInterface perm);
-int virAccessManagerCheckNetwork(virAccessManagerPtr manager,
+int virAccessManagerCheckNetwork(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
+ virNetworkDef *network,
virAccessPermNetwork perm);
-int virAccessManagerCheckNetworkPort(virAccessManagerPtr manager,
+int virAccessManagerCheckNetworkPort(virAccessManager *manager,
const char *driverName,
- virNetworkDefPtr network,
- virNetworkPortDefPtr port,
+ virNetworkDef *network,
+ virNetworkPortDef *port,
virAccessPermNetworkPort perm);
-int virAccessManagerCheckNodeDevice(virAccessManagerPtr manager,
+int virAccessManagerCheckNodeDevice(virAccessManager *manager,
const char *driverName,
- virNodeDeviceDefPtr nodedev,
+ virNodeDeviceDef *nodedev,
virAccessPermNodeDevice perm);
-int virAccessManagerCheckNWFilter(virAccessManagerPtr manager,
+int virAccessManagerCheckNWFilter(virAccessManager *manager,
const char *driverName,
- virNWFilterDefPtr nwfilter,
+ virNWFilterDef *nwfilter,
virAccessPermNWFilter perm);
-int virAccessManagerCheckNWFilterBinding(virAccessManagerPtr manager,
+int virAccessManagerCheckNWFilterBinding(virAccessManager *manager,
const char *driverName,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
virAccessPermNWFilterBinding perm);
-int virAccessManagerCheckSecret(virAccessManagerPtr manager,
+int virAccessManagerCheckSecret(virAccessManager *manager,
const char *driverName,
- virSecretDefPtr secret,
+ virSecretDef *secret,
virAccessPermSecret perm);
-int virAccessManagerCheckStoragePool(virAccessManagerPtr manager,
+int virAccessManagerCheckStoragePool(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
+ virStoragePoolDef *pool,
virAccessPermStoragePool perm);
-int virAccessManagerCheckStorageVol(virAccessManagerPtr manager,
+int virAccessManagerCheckStorageVol(virAccessManager *manager,
const char *driverName,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolDef *pool,
+ virStorageVolDef *vol,
virAccessPermStorageVol perm);
#include "admin_protocol.h"
typedef struct _remoteAdminPriv remoteAdminPriv;
-typedef remoteAdminPriv *remoteAdminPrivPtr;
-
struct _remoteAdminPriv {
virObjectLockable parent;
int counter;
- virNetClientPtr client;
- virNetClientProgramPtr program;
+ virNetClient *client;
+ virNetClientProgram *program;
};
-static virClassPtr remoteAdminPrivClass;
+static virClass *remoteAdminPrivClass;
static void
remoteAdminPrivDispose(void *opaque)
{
- remoteAdminPrivPtr priv = opaque;
+ remoteAdminPriv *priv = opaque;
virObjectUnref(priv->program);
virObjectUnref(priv->client);
static int
callFull(virAdmConnectPtr conn G_GNUC_UNUSED,
- remoteAdminPrivPtr priv,
+ remoteAdminPriv *priv,
int *fdin,
size_t fdinlen,
int **fdout,
xdrproc_t ret_filter, char *ret)
{
int rv;
- virNetClientProgramPtr prog = priv->program;
+ virNetClientProgram *prog = priv->program;
int counter = priv->counter++;
- virNetClientPtr client = priv->client;
+ virNetClient *client = priv->client;
/* Unlock, so that if we get any async events/stream data
* while processing the RPC, we don't deadlock when our
#include "admin_client.h"
static void
-remoteAdminClientCloseFunc(virNetClientPtr client G_GNUC_UNUSED,
+remoteAdminClientCloseFunc(virNetClient *client G_GNUC_UNUSED,
int reason,
void *opaque)
{
- virAdmConnectCloseCallbackDataPtr cbdata = opaque;
+ virAdmConnectCloseCallbackData *cbdata = opaque;
virObjectLock(cbdata);
remoteAdminConnectOpen(virAdmConnectPtr conn, unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = conn->privateData;
+ remoteAdminPriv *priv = conn->privateData;
admin_connect_open_args args;
virObjectLock(priv);
remoteAdminConnectClose(virAdmConnectPtr conn)
{
int rv = -1;
- remoteAdminPrivPtr priv = conn->privateData;
+ remoteAdminPriv *priv = conn->privateData;
virObjectLock(priv);
virObjectUnref(conn->privateData);
}
-static remoteAdminPrivPtr
+static remoteAdminPriv *
remoteAdminPrivNew(const char *sock_path)
{
- remoteAdminPrivPtr priv = NULL;
+ remoteAdminPriv *priv = NULL;
if (!(priv = virObjectLockableNew(remoteAdminPrivClass)))
goto error;
unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = srv->conn->privateData;
+ remoteAdminPriv *priv = srv->conn->privateData;
admin_server_get_threadpool_parameters_args args;
admin_server_get_threadpool_parameters_ret ret;
(xdrproc_t)xdr_admin_server_get_threadpool_parameters_ret, (char *) &ret) == -1)
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
params,
unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = srv->conn->privateData;
+ remoteAdminPriv *priv = srv->conn->privateData;
admin_server_set_threadpool_parameters_args args;
args.flags = flags;
if (virTypedParamsSerialize(params, nparams,
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
0) < 0)
goto cleanup;
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
virObjectUnlock(priv);
return rv;
unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = client->srv->conn->privateData;
+ remoteAdminPriv *priv = client->srv->conn->privateData;
admin_client_get_info_args args;
admin_client_get_info_ret ret;
(xdrproc_t)xdr_admin_client_get_info_ret, (char *) &ret) == -1)
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
ADMIN_CLIENT_INFO_PARAMETERS_MAX,
params,
int rv = -1;
admin_server_get_client_limits_args args;
admin_server_get_client_limits_ret ret;
- remoteAdminPrivPtr priv = srv->conn->privateData;
+ remoteAdminPriv *priv = srv->conn->privateData;
args.flags = flags;
make_nonnull_server(&args.srv, srv);
(char *) &ret) == -1)
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
ADMIN_SERVER_CLIENT_LIMITS_MAX,
params,
{
int rv = -1;
admin_server_set_client_limits_args args;
- remoteAdminPrivPtr priv = srv->conn->privateData;
+ remoteAdminPriv *priv = srv->conn->privateData;
args.flags = flags;
make_nonnull_server(&args.srv, srv);
if (virTypedParamsSerialize(params, nparams,
ADMIN_SERVER_CLIENT_LIMITS_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
0) < 0)
goto cleanup;
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
virObjectUnlock(priv);
return rv;
unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = conn->privateData;
+ remoteAdminPriv *priv = conn->privateData;
admin_connect_get_logging_outputs_args args;
admin_connect_get_logging_outputs_ret ret;
unsigned int flags)
{
int rv = -1;
- remoteAdminPrivPtr priv = conn->privateData;
+ remoteAdminPriv *priv = conn->privateData;
admin_connect_get_logging_filters_args args;
admin_connect_get_logging_filters_ret ret;
VIR_LOG_INIT("daemon.admin_server");
int
-adminConnectListServers(virNetDaemonPtr dmn,
- virNetServerPtr **servers,
+adminConnectListServers(virNetDaemon *dmn,
+ virNetServer ***servers,
unsigned int flags)
{
int ret = -1;
- virNetServerPtr *srvs = NULL;
+ virNetServer **srvs = NULL;
virCheckFlags(0, -1);
return ret;
}
-virNetServerPtr
-adminConnectLookupServer(virNetDaemonPtr dmn,
+virNetServer *
+adminConnectLookupServer(virNetDaemon *dmn,
const char *name,
unsigned int flags)
{
}
int
-adminServerGetThreadPoolParameters(virNetServerPtr srv,
+adminServerGetThreadPoolParameters(virNetServer *srv,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
}
int
-adminServerSetThreadPoolParameters(virNetServerPtr srv,
+adminServerSetThreadPoolParameters(virNetServer *srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
}
int
-adminServerListClients(virNetServerPtr srv,
- virNetServerClientPtr **clients,
+adminServerListClients(virNetServer *srv,
+ virNetServerClient ***clients,
unsigned int flags)
{
int ret = -1;
- virNetServerClientPtr *clts;
+ virNetServerClient **clts;
virCheckFlags(0, -1);
return ret;
}
-virNetServerClientPtr
-adminServerLookupClient(virNetServerPtr srv,
+virNetServerClient *
+adminServerLookupClient(virNetServer *srv,
unsigned long long id,
unsigned int flags)
{
}
int
-adminClientGetInfo(virNetServerClientPtr client,
+adminClientGetInfo(virNetServerClient *client,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
return 0;
}
-int adminClientClose(virNetServerClientPtr client,
+int adminClientClose(virNetServerClient *client,
unsigned int flags)
{
virCheckFlags(0, -1);
}
int
-adminServerGetClientLimits(virNetServerPtr srv,
+adminServerGetClientLimits(virNetServer *srv,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
}
int
-adminServerSetClientLimits(virNetServerPtr srv,
+adminServerSetClientLimits(virNetServer *srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
}
int
-adminServerUpdateTlsFiles(virNetServerPtr srv,
+adminServerUpdateTlsFiles(virNetServer *srv,
unsigned int flags)
{
virCheckFlags(0, -1);
#include "rpc/virnetdaemon.h"
#include "rpc/virnetserver.h"
-int adminConnectListServers(virNetDaemonPtr dmn,
- virNetServerPtr **servers,
+int adminConnectListServers(virNetDaemon *dmn,
+ virNetServer ***servers,
unsigned int flags);
-virNetServerPtr adminConnectLookupServer(virNetDaemonPtr dmn,
+virNetServer *adminConnectLookupServer(virNetDaemon *dmn,
const char *name,
unsigned int flags);
int
-adminServerGetThreadPoolParameters(virNetServerPtr srv,
+adminServerGetThreadPoolParameters(virNetServer *srv,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags);
int
-adminServerSetThreadPoolParameters(virNetServerPtr srv,
+adminServerSetThreadPoolParameters(virNetServer *srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
-int adminServerListClients(virNetServerPtr srv,
- virNetServerClientPtr **clients,
+int adminServerListClients(virNetServer *srv,
+ virNetServerClient ***clients,
unsigned int flags);
-virNetServerClientPtr adminServerLookupClient(virNetServerPtr srv,
+virNetServerClient *adminServerLookupClient(virNetServer *srv,
unsigned long long id,
unsigned int flags);
-int adminClientGetInfo(virNetServerClientPtr client,
+int adminClientGetInfo(virNetServerClient *client,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags);
-int adminClientClose(virNetServerClientPtr client,
+int adminClientClose(virNetServerClient *client,
unsigned int flags);
-int adminServerGetClientLimits(virNetServerPtr srv,
+int adminServerGetClientLimits(virNetServer *srv,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags);
-int adminServerSetClientLimits(virNetServerPtr srv,
+int adminServerSetClientLimits(virNetServer *srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
-int adminServerUpdateTlsFiles(virNetServerPtr srv,
+int adminServerUpdateTlsFiles(virNetServer *srv,
unsigned int flags);
VIR_LOG_INIT("daemon.admin");
typedef struct daemonAdmClientPrivate daemonAdmClientPrivate;
-typedef daemonAdmClientPrivate *daemonAdmClientPrivatePtr;
/* Separate private data for admin connection */
struct daemonAdmClientPrivate {
/* Just a placeholder, not that there is anything to be locked */
virMutex lock;
- virNetDaemonPtr dmn;
+ virNetDaemon *dmn;
};
void
}
void *
-remoteAdmClientNew(virNetServerClientPtr client G_GNUC_UNUSED,
+remoteAdmClientNew(virNetServerClient *client G_GNUC_UNUSED,
void *opaque)
{
struct daemonAdmClientPrivate *priv;
return priv;
}
-void *remoteAdmClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object G_GNUC_UNUSED,
+void *remoteAdmClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object G_GNUC_UNUSED,
void *opaque)
{
return remoteAdmClientNew(client, opaque);
}
-virJSONValuePtr remoteAdmClientPreExecRestart(virNetServerClientPtr client G_GNUC_UNUSED,
- void *data G_GNUC_UNUSED)
+virJSONValue *remoteAdmClientPreExecRestart(virNetServerClient *client G_GNUC_UNUSED,
+ void *data G_GNUC_UNUSED)
{
- virJSONValuePtr object = virJSONValueNewObject();
+ virJSONValue *object = virJSONValueNewObject();
/* No content to add at this time - just need empty object */
/* Helpers */
-static virNetServerPtr
-get_nonnull_server(virNetDaemonPtr dmn, admin_nonnull_server srv)
+static virNetServer *
+get_nonnull_server(virNetDaemon *dmn, admin_nonnull_server srv)
{
return virNetDaemonGetServer(dmn, srv.name);
}
static void
make_nonnull_server(admin_nonnull_server *srv_dst,
- virNetServerPtr srv_src)
+ virNetServer *srv_src)
{
srv_dst->name = g_strdup(virNetServerGetName(srv_src));
}
-static virNetServerClientPtr
-get_nonnull_client(virNetServerPtr srv, admin_nonnull_client clnt)
+static virNetServerClient *
+get_nonnull_client(virNetServer *srv, admin_nonnull_client clnt)
{
return virNetServerGetClient(srv, clnt.id);
}
static void
make_nonnull_client(admin_nonnull_client *clt_dst,
- virNetServerClientPtr clt_src)
+ virNetServerClient *clt_src)
{
clt_dst->id = virNetServerClientGetID(clt_src);
clt_dst->timestamp = virNetServerClientGetTimestamp(clt_src);
/* Functions */
static int
-adminDispatchConnectOpen(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchConnectOpen(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
struct admin_connect_open_args *args)
{
unsigned int flags;
}
static int
-adminDispatchConnectClose(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED)
+adminDispatchConnectClose(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED)
{
virNetServerClientDelayedClose(client);
return 0;
}
static int
-adminConnectGetLibVersion(virNetDaemonPtr dmn G_GNUC_UNUSED,
+adminConnectGetLibVersion(virNetDaemon *dmn G_GNUC_UNUSED,
unsigned long long *libVer)
{
if (libVer)
return 0;
}
-static virNetDaemonPtr
-adminGetConn(virNetServerClientPtr client)
+static virNetDaemon *
+adminGetConn(virNetServerClient *client)
{
struct daemonAdmClientPrivate *priv =
virNetServerClientGetPrivateData(client);
}
static int
-adminDispatchServerGetThreadpoolParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchServerGetThreadpoolParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
struct admin_server_get_threadpool_parameters_args *args,
struct admin_server_get_threadpool_parameters_ret *ret)
{
int rv = -1;
- virNetServerPtr srv = NULL;
+ virNetServer *srv = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
struct daemonAdmClientPrivate *priv =
if (virTypedParamsSerialize(params, nparams,
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len, 0) < 0)
goto cleanup;
}
static int
-adminDispatchServerSetThreadpoolParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchServerSetThreadpoolParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
struct admin_server_set_threadpool_parameters_args *args)
{
int rv = -1;
- virNetServerPtr srv = NULL;
+ virNetServer *srv = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
struct daemonAdmClientPrivate *priv =
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
¶ms,
}
static int
-adminDispatchClientGetInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchClientGetInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
struct admin_client_get_info_args *args,
struct admin_client_get_info_ret *ret)
{
int rv = -1;
- virNetServerPtr srv = NULL;
- virNetServerClientPtr clnt = NULL;
+ virNetServer *srv = NULL;
+ virNetServerClient *clnt = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
struct daemonAdmClientPrivate *priv =
if (virTypedParamsSerialize(params, nparams,
ADMIN_CLIENT_INFO_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
goto cleanup;
}
static int
-adminDispatchServerGetClientLimits(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+adminDispatchServerGetClientLimits(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
admin_server_get_client_limits_args *args,
admin_server_get_client_limits_ret *ret)
{
int rv = -1;
- virNetServerPtr srv = NULL;
+ virNetServer *srv = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
struct daemonAdmClientPrivate *priv =
if (virTypedParamsSerialize(params, nparams,
ADMIN_SERVER_CLIENT_LIMITS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len, 0) < 0)
goto cleanup;
}
static int
-adminDispatchServerSetClientLimits(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+adminDispatchServerSetClientLimits(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
admin_server_set_client_limits_args *args)
{
int rv = -1;
- virNetServerPtr srv = NULL;
+ virNetServer *srv = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
struct daemonAdmClientPrivate *priv =
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
ADMIN_SERVER_CLIENT_LIMITS_MAX, ¶ms, &nparams) < 0)
goto cleanup;
}
static int
-adminConnectSetLoggingOutputs(virNetDaemonPtr dmn G_GNUC_UNUSED,
+adminConnectSetLoggingOutputs(virNetDaemon *dmn G_GNUC_UNUSED,
const char *outputs,
unsigned int flags)
{
}
static int
-adminConnectSetLoggingFilters(virNetDaemonPtr dmn G_GNUC_UNUSED,
+adminConnectSetLoggingFilters(virNetDaemon *dmn G_GNUC_UNUSED,
const char *filters,
unsigned int flags)
{
}
static int
-adminDispatchConnectGetLoggingOutputs(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchConnectGetLoggingOutputs(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
admin_connect_get_logging_outputs_args *args,
admin_connect_get_logging_outputs_ret *ret)
{
}
static int
-adminDispatchConnectGetLoggingFilters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+adminDispatchConnectGetLoggingFilters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
admin_connect_get_logging_filters_args *args,
admin_connect_get_logging_filters_ret *ret)
{
extern size_t adminNProcs;
void remoteAdmClientFree(void *data);
-void *remoteAdmClientNew(virNetServerClientPtr client, void *opaque);
-void *remoteAdmClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object,
+void *remoteAdmClientNew(virNetServerClient *client, void *opaque);
+void *remoteAdmClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object,
void *opaque);
-virJSONValuePtr remoteAdmClientPreExecRestart(virNetServerClientPtr client,
+virJSONValue *remoteAdmClientPreExecRestart(virNetServerClient *client,
void *data);
}
static char *
-getSocketPath(virURIPtr uri)
+getSocketPath(virURI *uri)
{
g_autofree char *rundir = virGetUserRuntimeDirectory();
g_autofree char *sock_path = NULL;
for (i = 0; i < uri->paramsCount; i++) {
- virURIParamPtr param = &uri->params[i];
+ virURIParam *param = &uri->params[i];
if (STREQ(param->name, "socket")) {
g_free(sock_path);
}
static int
-virAdmGetDefaultURI(virConfPtr conf, char **uristr)
+virAdmGetDefaultURI(virConf *conf, char **uristr)
{
const char *defname = getenv("LIBVIRT_ADMIN_DEFAULT_URI");
if (defname && *defname) {
virAdmConnectIsAlive(virAdmConnectPtr conn)
{
bool ret;
- remoteAdminPrivPtr priv = NULL;
+ remoteAdminPriv *priv = NULL;
VIR_DEBUG("conn=%p", conn);
VIR_LOG_INIT("bhyve.bhyve_capabilities");
-virCapsPtr
+virCaps *
virBhyveCapsBuild(void)
{
- virCapsPtr caps;
- virCapsGuestPtr guest;
+ virCaps *caps;
+ virCapsGuest *guest;
if ((caps = virCapabilitiesNew(virArchFromHost(),
false, false)) == NULL)
}
int
-virBhyveDomainCapsFill(virDomainCapsPtr caps,
+virBhyveDomainCapsFill(virDomainCaps *caps,
unsigned int bhyvecaps,
- virDomainCapsStringValuesPtr firmwares)
+ virDomainCapsStringValues *firmwares)
{
caps->disk.supported = VIR_TRISTATE_BOOL_YES;
caps->disk.diskDevice.report = true;
}
-virDomainCapsPtr
-virBhyveDomainCapsBuild(bhyveConnPtr conn,
+virDomainCaps *
+virBhyveDomainCapsBuild(struct _bhyveConn *conn,
const char *emulatorbin,
const char *machine,
virArch arch,
virDomainVirtType virttype)
{
- virDomainCapsPtr caps = NULL;
+ virDomainCaps *caps = NULL;
unsigned int bhyve_caps = 0;
g_autoptr(DIR) dir = NULL;
struct dirent *entry;
size_t firmwares_alloc = 0;
- virBhyveDriverConfigPtr cfg = virBhyveDriverGetConfig(conn);
+ struct _virBhyveDriverConfig *cfg = virBhyveDriverGetConfig(conn);
const char *firmware_dir = cfg->firmwareDir;
- virDomainCapsStringValuesPtr firmwares = NULL;
+ virDomainCapsStringValues *firmwares = NULL;
if (!(caps = virDomainCapsNew(emulatorbin, machine, arch, virttype)))
goto cleanup;
virBhyveProbeGrubCaps(virBhyveGrubCapsFlags *caps)
{
char *binary, *help;
- virCommandPtr cmd;
+ virCommand *cmd;
int ret, exit;
ret = 0;
unsigned int flag)
{
char *error;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
int ret = -1, exit;
cmd = virCommandNew(binary);
bhyveProbeCapsFromHelp(unsigned int *caps, char *binary)
{
char *help;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
int ret = 0, exit;
cmd = virCommandNew(binary);
#include "bhyve_utils.h"
-virCapsPtr virBhyveCapsBuild(void);
-int virBhyveDomainCapsFill(virDomainCapsPtr caps,
+virCaps *virBhyveCapsBuild(void);
+int virBhyveDomainCapsFill(virDomainCaps *caps,
unsigned int bhyvecaps,
- virDomainCapsStringValuesPtr firmwares);
-virDomainCapsPtr virBhyveDomainCapsBuild(bhyveConnPtr,
- const char *emulatorbin,
- const char *machine,
- virArch arch,
- virDomainVirtType virttype);
+ virDomainCapsStringValues *firmwares);
+virDomainCaps *virBhyveDomainCapsBuild(bhyveConn *conn,
+ const char *emulatorbin,
+ const char *machine,
+ virArch arch,
+ virDomainVirtType virttype);
/* These are bit flags: */
typedef enum {
static int
bhyveBuildNetArgStr(const virDomainDef *def,
- virDomainNetDefPtr net,
- bhyveConnPtr driver,
- virCommandPtr cmd,
+ virDomainNetDef *net,
+ struct _bhyveConn *driver,
+ virCommand *cmd,
bool dryRun)
{
char macaddr[VIR_MAC_STRING_BUFLEN];
}
static int
-bhyveBuildConsoleArgStr(const virDomainDef *def, virCommandPtr cmd)
+bhyveBuildConsoleArgStr(const virDomainDef *def, virCommand *cmd)
{
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
if (!def->nserials)
return 0;
static int
bhyveBuildAHCIControllerArgStr(const virDomainDef *def,
- virDomainControllerDefPtr controller,
- bhyveConnPtr driver,
- virCommandPtr cmd)
+ virDomainControllerDef *controller,
+ struct _bhyveConn *driver,
+ virCommand *cmd)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *disk_source;
for (i = 0; i < def->ndisks; i++) {
g_auto(virBuffer) device = VIR_BUFFER_INITIALIZER;
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (disk->bus != VIR_DOMAIN_DISK_BUS_SATA)
continue;
static int
bhyveBuildUSBControllerArgStr(const virDomainDef *def,
- virDomainControllerDefPtr controller,
- virCommandPtr cmd)
+ virDomainControllerDef *controller,
+ virCommand *cmd)
{
size_t i;
int ndevices = 0;
for (i = 0; i < def->ninputs; i++) {
- virDomainInputDefPtr input = def->inputs[i];
+ virDomainInputDef *input = def->inputs[i];
if (input->bus != VIR_DOMAIN_INPUT_BUS_USB) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
static int
bhyveBuildVirtIODiskArgStr(const virDomainDef *def G_GNUC_UNUSED,
- virDomainDiskDefPtr disk,
- virCommandPtr cmd)
+ virDomainDiskDef *disk,
+ virCommand *cmd)
{
const char *disk_source;
static int
bhyveBuildDiskArgStr(const virDomainDef *def,
- virDomainDiskDefPtr disk,
- virCommandPtr cmd)
+ virDomainDiskDef *disk,
+ virCommand *cmd)
{
switch (disk->bus) {
case VIR_DOMAIN_DISK_BUS_SATA:
static int
bhyveBuildControllerArgStr(const virDomainDef *def,
- virDomainControllerDefPtr controller,
- bhyveConnPtr driver,
- virCommandPtr cmd,
+ virDomainControllerDef *controller,
+ struct _bhyveConn *driver,
+ virCommand *cmd,
unsigned *nusbcontrollers,
unsigned *nisacontrollers)
{
static int
bhyveBuildGraphicsArgStr(const virDomainDef *def,
- virDomainGraphicsDefPtr graphics,
- virDomainVideoDefPtr video,
- bhyveConnPtr driver,
- virCommandPtr cmd,
+ virDomainGraphicsDef *graphics,
+ virDomainVideoDef *video,
+ struct _bhyveConn *driver,
+ virCommand *cmd,
bool dryRun)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
bool escapeAddr;
unsigned short port;
static int
bhyveBuildSoundArgStr(const virDomainDef *def G_GNUC_UNUSED,
- virDomainSoundDefPtr sound,
- virDomainAudioDefPtr audio,
- bhyveConnPtr driver,
- virCommandPtr cmd)
+ virDomainSoundDef *sound,
+ virDomainAudioDef *audio,
+ struct _bhyveConn *driver,
+ virCommand *cmd)
{
g_auto(virBuffer) params = VIR_BUFFER_INITIALIZER;
static int
bhyveBuildFSArgStr(const virDomainDef *def G_GNUC_UNUSED,
- virDomainFSDefPtr fs,
- virCommandPtr cmd)
+ virDomainFSDef *fs,
+ virCommand *cmd)
{
g_auto(virBuffer) params = VIR_BUFFER_INITIALIZER;
return 0;
}
-virCommandPtr
-virBhyveProcessBuildBhyveCmd(bhyveConnPtr driver, virDomainDefPtr def,
+virCommand *
+virBhyveProcessBuildBhyveCmd(struct _bhyveConn *driver, virDomainDef *def,
bool dryRun)
{
/*
* -S 31,uart,stdio \
* vm0
*/
- virCommandPtr cmd = virCommandNew(BHYVE);
+ virCommand *cmd = virCommandNew(BHYVE);
size_t i;
unsigned nusbcontrollers = 0;
unsigned nisacontrollers = 0;
goto error;
if (def->namespaceData) {
- bhyveDomainCmdlineDefPtr bhyvecmd;
+ bhyveDomainCmdlineDef *bhyvecmd;
VIR_WARN("Booting the guest using command line pass-through feature, "
"which could potentially cause inconsistent state and "
return NULL;
}
-virCommandPtr
-virBhyveProcessBuildDestroyCmd(bhyveConnPtr driver G_GNUC_UNUSED,
- virDomainDefPtr def)
+virCommand *
+virBhyveProcessBuildDestroyCmd(struct _bhyveConn *driver G_GNUC_UNUSED,
+ virDomainDef *def)
{
- virCommandPtr cmd = virCommandNew(BHYVECTL);
+ virCommand *cmd = virCommandNew(BHYVECTL);
virCommandAddArg(cmd, "--destroy");
virCommandAddArgPair(cmd, "--vm", def->name);
}
static void
-virAppendBootloaderArgs(virCommandPtr cmd, virDomainDefPtr def)
+virAppendBootloaderArgs(virCommand *cmd, virDomainDef *def)
{
char **blargs;
g_strfreev(blargs);
}
-static virCommandPtr
-virBhyveProcessBuildBhyveloadCmd(virDomainDefPtr def, virDomainDiskDefPtr disk)
+static virCommand *
+virBhyveProcessBuildBhyveloadCmd(virDomainDef *def, virDomainDiskDef *disk)
{
- virCommandPtr cmd;
+ virCommand *cmd;
cmd = virCommandNew(BHYVELOAD);
return cmd;
}
-static virCommandPtr
-virBhyveProcessBuildCustomLoaderCmd(virDomainDefPtr def)
+static virCommand *
+virBhyveProcessBuildCustomLoaderCmd(virDomainDef *def)
{
- virCommandPtr cmd;
+ virCommand *cmd;
if (def->os.bootloaderArgs == NULL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
static bool
-virBhyveUsableDisk(virDomainDiskDefPtr disk)
+virBhyveUsableDisk(virDomainDiskDef *disk)
{
if (virDomainDiskTranslateSourcePool(disk) < 0)
return false;
}
static void
-virBhyveFormatGrubDevice(virBufferPtr devicemap, virDomainDiskDefPtr def)
+virBhyveFormatGrubDevice(virBuffer *devicemap, virDomainDiskDef *def)
{
if (def->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAsprintf(devicemap, "(cd) %s\n",
virDomainDiskGetSource(def));
}
-static virCommandPtr
-virBhyveProcessBuildGrubbhyveCmd(virDomainDefPtr def,
- bhyveConnPtr driver,
+static virCommand *
+virBhyveProcessBuildGrubbhyveCmd(virDomainDef *def,
+ struct _bhyveConn *driver,
const char *devmap_file,
char **devicesmap_out)
{
- virDomainDiskDefPtr hdd;
- virDomainDiskDefPtr cd;
- virDomainDiskDefPtr userdef;
- virDomainDiskDefPtr diskdef;
- virCommandPtr cmd;
+ virDomainDiskDef *hdd;
+ virDomainDiskDef *cd;
+ virDomainDiskDef *userdef;
+ virDomainDiskDef *diskdef;
+ virCommand *cmd;
unsigned int best_idx = UINT_MAX;
size_t i;
if ((bhyveDriverGetGrubCaps(driver) & BHYVE_GRUB_CAP_CONSDEV) != 0 &&
def->nserials > 0) {
- virDomainChrDefPtr chr;
+ virDomainChrDef *chr;
chr = def->serials[0];
return cmd;
}
-static virDomainDiskDefPtr
-virBhyveGetBootDisk(virDomainDefPtr def)
+static virDomainDiskDef *
+virBhyveGetBootDisk(virDomainDef *def)
{
size_t i;
- virDomainDiskDefPtr match = NULL;
+ virDomainDiskDef *match = NULL;
int boot_dev = -1;
if (def->ndisks < 1) {
return match;
}
-virCommandPtr
-virBhyveProcessBuildLoadCmd(bhyveConnPtr driver, virDomainDefPtr def,
+virCommand *
+virBhyveProcessBuildLoadCmd(struct _bhyveConn *driver, virDomainDef *def,
const char *devmap_file, char **devicesmap_out)
{
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
if (def->os.bootloader == NULL) {
disk = virBhyveGetBootDisk(def);
#define BHYVE_CONFIG_FORMAT_ARGV "bhyve-argv"
-virCommandPtr virBhyveProcessBuildBhyveCmd(bhyveConnPtr driver,
- virDomainDefPtr def,
- bool dryRun);
+virCommand *virBhyveProcessBuildBhyveCmd(struct _bhyveConn *driver,
+ virDomainDef *def,
+ bool dryRun);
-virCommandPtr
-virBhyveProcessBuildDestroyCmd(bhyveConnPtr driver,
- virDomainDefPtr def);
+virCommand *
+virBhyveProcessBuildDestroyCmd(struct _bhyveConn *driver,
+ virDomainDef *def);
-virCommandPtr
-virBhyveProcessBuildLoadCmd(bhyveConnPtr driver, virDomainDefPtr def,
+virCommand *
+virBhyveProcessBuildLoadCmd(struct _bhyveConn *driver, virDomainDef *def,
const char *devmap_file, char **devicesmap_out);
VIR_LOG_INIT("bhyve.bhyve_conf");
-static virClassPtr virBhyveDriverConfigClass;
+static virClass *virBhyveDriverConfigClass;
static void virBhyveDriverConfigDispose(void *obj);
static int virBhyveConfigOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virBhyveConfig);
-virBhyveDriverConfigPtr
+struct _virBhyveDriverConfig *
virBhyveDriverConfigNew(void)
{
- virBhyveDriverConfigPtr cfg;
+ struct _virBhyveDriverConfig *cfg;
if (virBhyveConfigInitialize() < 0)
return NULL;
}
int
-virBhyveLoadDriverConfig(virBhyveDriverConfigPtr cfg,
+virBhyveLoadDriverConfig(struct _virBhyveDriverConfig *cfg,
const char *filename)
{
g_autoptr(virConf) conf = NULL;
return 0;
}
-virBhyveDriverConfigPtr
-virBhyveDriverGetConfig(bhyveConnPtr driver)
+struct _virBhyveDriverConfig *
+virBhyveDriverGetConfig(struct _bhyveConn *driver)
{
- virBhyveDriverConfigPtr cfg;
+ struct _virBhyveDriverConfig *cfg;
bhyveDriverLock(driver);
cfg = virObjectRef(driver->config);
bhyveDriverUnlock(driver);
static void
virBhyveDriverConfigDispose(void *obj)
{
- virBhyveDriverConfigPtr cfg = obj;
+ struct _virBhyveDriverConfig *cfg = obj;
g_free(cfg->firmwareDir);
}
void
-bhyveDomainCmdlineDefFree(bhyveDomainCmdlineDefPtr def)
+bhyveDomainCmdlineDefFree(bhyveDomainCmdlineDef *def)
{
size_t i;
#include "bhyve_utils.h"
-virBhyveDriverConfigPtr virBhyveDriverConfigNew(void);
-virBhyveDriverConfigPtr virBhyveDriverGetConfig(bhyveConnPtr driver);
-int virBhyveLoadDriverConfig(virBhyveDriverConfigPtr cfg,
+struct _virBhyveDriverConfig *virBhyveDriverConfigNew(void);
+struct _virBhyveDriverConfig *virBhyveDriverGetConfig(struct _bhyveConn *driver);
+int virBhyveLoadDriverConfig(struct _virBhyveDriverConfig *cfg,
const char *filename);
typedef struct _bhyveDomainCmdlineDef bhyveDomainCmdlineDef;
-typedef bhyveDomainCmdlineDef *bhyveDomainCmdlineDefPtr;
struct _bhyveDomainCmdlineDef {
size_t num_args;
char **args;
};
-void bhyveDomainCmdlineDefFree(bhyveDomainCmdlineDefPtr def);
+void bhyveDomainCmdlineDefFree(bhyveDomainCmdlineDef *def);
VIR_LOG_INIT("bhyve.bhyve_device");
static int
-bhyveCollectPCIAddress(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+bhyveCollectPCIAddress(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE)
return 0;
- virDomainPCIAddressSetPtr addrs = opaque;
- virPCIDeviceAddressPtr addr = &info->addr.pci;
+ virDomainPCIAddressSet *addrs = opaque;
+ virPCIDeviceAddress *addr = &info->addr.pci;
if (addr->domain == 0 && addr->bus == 0 && addr->slot == 0) {
return 0;
return 0;
}
-virDomainPCIAddressSetPtr
-bhyveDomainPCIAddressSetCreate(virDomainDefPtr def, unsigned int nbuses)
+virDomainPCIAddressSet *
+bhyveDomainPCIAddressSetCreate(virDomainDef *def, unsigned int nbuses)
{
- virDomainPCIAddressSetPtr addrs;
+ virDomainPCIAddressSet *addrs;
if ((addrs = virDomainPCIAddressSetAlloc(nbuses,
VIR_PCI_ADDRESS_EXTENSION_NONE)) == NULL)
}
static int
-bhyveAssignDevicePCISlots(virDomainDefPtr def,
- virDomainPCIAddressSetPtr addrs)
+bhyveAssignDevicePCISlots(virDomainDef *def,
+ virDomainPCIAddressSet *addrs)
{
size_t i;
virPCIDeviceAddress lpc_addr;
return 0;
}
-int bhyveDomainAssignPCIAddresses(virDomainDefPtr def,
- virDomainObjPtr obj)
+int bhyveDomainAssignPCIAddresses(virDomainDef *def,
+ virDomainObj *obj)
{
- virDomainPCIAddressSetPtr addrs = NULL;
- bhyveDomainObjPrivatePtr priv = NULL;
+ virDomainPCIAddressSet *addrs = NULL;
+ bhyveDomainObjPrivate *priv = NULL;
if (!(addrs = bhyveDomainPCIAddressSetCreate(def, 1)))
return -1;
return 0;
}
-int bhyveDomainAssignAddresses(virDomainDefPtr def, virDomainObjPtr obj)
+int bhyveDomainAssignAddresses(virDomainDef *def, virDomainObj *obj)
{
return bhyveDomainAssignPCIAddresses(def, obj);
}
#include "virpci.h"
#include "bhyve_domain.h"
-int bhyveDomainAssignPCIAddresses(virDomainDefPtr def, virDomainObjPtr obj);
+int bhyveDomainAssignPCIAddresses(virDomainDef *def, virDomainObj *obj);
-virDomainPCIAddressSetPtr bhyveDomainPCIAddressSetCreate(virDomainDefPtr def,
- unsigned int nbuses);
+virDomainPCIAddressSet *bhyveDomainPCIAddressSetCreate(virDomainDef *def,
+ unsigned int nbuses);
-int bhyveDomainAssignAddresses(virDomainDefPtr def, virDomainObjPtr obj)
+int bhyveDomainAssignAddresses(virDomainDef *def, virDomainObj *obj)
ATTRIBUTE_NONNULL(1);
static void *
bhyveDomainObjPrivateAlloc(void *opaque G_GNUC_UNUSED)
{
- bhyveDomainObjPrivatePtr priv;
+ bhyveDomainObjPrivate *priv;
priv = g_new0(bhyveDomainObjPrivate, 1);
static void
bhyveDomainObjPrivateFree(void *data)
{
- bhyveDomainObjPrivatePtr priv = data;
+ bhyveDomainObjPrivate *priv = data;
virDomainPCIAddressSetFree(priv->pciaddrs);
};
static bool
-bhyveDomainDefNeedsISAController(virDomainDefPtr def)
+bhyveDomainDefNeedsISAController(virDomainDef *def)
{
if (def->os.bootloader == NULL && def->os.loader)
return true;
}
static int
-bhyveDomainDefPostParse(virDomainDefPtr def,
+bhyveDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- bhyveConnPtr driver = opaque;
+ struct _bhyveConn *driver = opaque;
g_autoptr(virCaps) caps = bhyveDriverGetCapabilities(driver);
if (!caps)
return -1;
}
static int
-bhyveDomainDiskDefAssignAddress(bhyveConnPtr driver,
- virDomainDiskDefPtr def,
+bhyveDomainDiskDefAssignAddress(struct _bhyveConn *driver,
+ virDomainDiskDef *def,
const virDomainDef *vmdef G_GNUC_UNUSED)
{
int idx = virDiskNameToIndex(def->dst);
}
static int
-bhyveDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+bhyveDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- bhyveConnPtr driver = opaque;
+ struct _bhyveConn *driver = opaque;
if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
- virDomainDiskDefPtr disk = dev->data.disk;
+ virDomainDiskDef *disk = dev->data.disk;
if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
bhyveDomainDiskDefAssignAddress(driver, disk, def) < 0)
}
if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
- virDomainControllerDefPtr cont = dev->data.controller;
+ virDomainControllerDef *cont = dev->data.controller;
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
(cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT ||
if (dev->type == VIR_DOMAIN_DEVICE_CHR &&
dev->data.chr->source->type == VIR_DOMAIN_CHR_TYPE_NMDM) {
- virDomainChrDefPtr chr = dev->data.chr;
+ virDomainChrDef *chr = dev->data.chr;
if (!chr->source->data.nmdm.master) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
return 0;
}
-virDomainXMLOptionPtr
-virBhyveDriverCreateXMLConf(bhyveConnPtr driver)
+virDomainXMLOption *
+virBhyveDriverCreateXMLConf(struct _bhyveConn *driver)
{
virBhyveDriverDomainDefParserConfig.priv = driver;
return virDomainXMLOptionNew(&virBhyveDriverDomainDefParserConfig,
static void
bhyveDomainDefNamespaceFree(void *nsdata)
{
- bhyveDomainCmdlineDefPtr cmd = nsdata;
+ bhyveDomainCmdlineDef *cmd = nsdata;
bhyveDomainCmdlineDefFree(cmd);
}
bhyveDomainDefNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- bhyveDomainCmdlineDefPtr cmd = NULL;
+ bhyveDomainCmdlineDef *cmd = NULL;
xmlNodePtr *nodes = NULL;
int n;
size_t i;
}
static int
-bhyveDomainDefNamespaceFormatXML(virBufferPtr buf,
+bhyveDomainDefNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
- bhyveDomainCmdlineDefPtr cmd = nsdata;
+ bhyveDomainCmdlineDef *cmd = nsdata;
size_t i;
if (!cmd->num_args)
#include "bhyve_monitor.h"
typedef struct _bhyveDomainObjPrivate bhyveDomainObjPrivate;
-typedef bhyveDomainObjPrivate *bhyveDomainObjPrivatePtr;
struct _bhyveDomainObjPrivate {
- virDomainPCIAddressSetPtr pciaddrs;
+ virDomainPCIAddressSet *pciaddrs;
bool persistentAddrs;
- bhyveMonitorPtr mon;
+ bhyveMonitor *mon;
};
-virDomainXMLOptionPtr virBhyveDriverCreateXMLConf(bhyveConnPtr);
+virDomainXMLOption *virBhyveDriverCreateXMLConf(struct _bhyveConn *);
extern virDomainXMLPrivateDataCallbacks virBhyveDriverPrivateDataCallbacks;
extern virDomainDefParserConfig virBhyveDriverDomainDefParserConfig;
VIR_LOG_INIT("bhyve.bhyve_driver");
-bhyveConnPtr bhyve_driver = NULL;
+struct _bhyveConn *bhyve_driver = NULL;
void
-bhyveDriverLock(bhyveConnPtr driver)
+bhyveDriverLock(struct _bhyveConn *driver)
{
virMutexLock(&driver->lock);
}
void
-bhyveDriverUnlock(bhyveConnPtr driver)
+bhyveDriverUnlock(struct _bhyveConn *driver)
{
virMutexUnlock(&driver->lock);
}
static int
-bhyveAutostartDomain(virDomainObjPtr vm, void *opaque)
+bhyveAutostartDomain(virDomainObj *vm, void *opaque)
{
const struct bhyveAutostartData *data = opaque;
int ret = 0;
}
static void
-bhyveAutostartDomains(bhyveConnPtr driver)
+bhyveAutostartDomains(struct _bhyveConn *driver)
{
/* XXX: Figure out a better way todo this. The domain
* startup code needs a connection handle in order
/**
* bhyveDriverGetCapabilities:
*
- * Get a reference to the virCapsPtr instance for the
+ * Get a reference to the virCaps *instance for the
* driver.
*
* The caller must release the reference with virObjetUnref
*
- * Returns: a reference to a virCapsPtr instance or NULL
+ * Returns: a reference to a virCaps *instance or NULL
*/
-virCapsPtr ATTRIBUTE_NONNULL(1)
-bhyveDriverGetCapabilities(bhyveConnPtr driver)
+virCaps *ATTRIBUTE_NONNULL(1)
+bhyveDriverGetCapabilities(struct _bhyveConn *driver)
{
return virObjectRef(driver->caps);
}
static char *
bhyveConnectGetCapabilities(virConnectPtr conn)
{
- bhyveConnPtr privconn = conn->privateData;
- virCapsPtr caps;
+ struct _bhyveConn *privconn = conn->privateData;
+ virCaps *caps;
char *xml = NULL;
if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
return xml;
}
-static virDomainObjPtr
+static virDomainObj *
bhyveDomObjFromDomain(virDomainPtr domain)
{
- virDomainObjPtr vm;
- bhyveConnPtr privconn = domain->conn->privateData;
+ virDomainObj *vm;
+ struct _bhyveConn *privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(privconn->domains, domain->uuid);
static virDrvOpenStatus
bhyveConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int
bhyveConnectClose(virConnectPtr conn)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
virCloseCallbacksRun(privconn->closeCallbacks, conn, privconn->domains, privconn);
conn->privateData = NULL;
static char *
bhyveConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
static int
bhyveDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = bhyveDomObjFromDomain(domain)))
int *reason,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
static int
bhyveDomainGetAutostart(virDomainPtr domain, int *autostart)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = bhyveDomObjFromDomain(domain)))
static int
bhyveDomainSetAutostart(virDomainPtr domain, int autostart)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *configFile = NULL;
char *autostartLink = NULL;
int ret = -1;
static int
bhyveDomainIsActive(virDomainPtr domain)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = bhyveDomObjFromDomain(domain)))
static int
bhyveDomainIsPersistent(virDomainPtr domain)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = bhyveDomObjFromDomain(domain)))
static char *
bhyveDomainGetOSType(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = bhyveDomObjFromDomain(dom)))
static char *
bhyveDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
- bhyveConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = domain->conn->privateData;
+ virDomainObj *vm;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
static virDomainPtr
bhyveDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
virDomainPtr dom = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr oldDef = NULL;
- virDomainObjPtr vm = NULL;
- virObjectEventPtr event = NULL;
- virCapsPtr caps = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *oldDef = NULL;
+ virDomainObj *vm = NULL;
+ virObjectEvent *event = NULL;
+ virCaps *caps = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
static int
bhyveDomainUndefineFlags(virDomainPtr domain, unsigned int flags)
{
- bhyveConnPtr privconn = domain->conn->privateData;
- virObjectEventPtr event = NULL;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = domain->conn->privateData;
+ virObjectEvent *event = NULL;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
static int
bhyveConnectListDomains(virConnectPtr conn, int *ids, int maxids)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
if (virConnectListDomainsEnsureACL(conn) < 0)
return -1;
static int
bhyveConnectNumOfDomains(virConnectPtr conn)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
if (virConnectNumOfDomainsEnsureACL(conn) < 0)
return -1;
bhyveConnectListDefinedDomains(virConnectPtr conn, char **const names,
int maxnames)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int
bhyveConnectNumOfDefinedDomains(virConnectPtr conn)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
return -1;
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- bhyveConnPtr privconn = conn->privateData;
- virDomainDefPtr def = NULL;
- virCommandPtr cmd = NULL;
- virCommandPtr loadcmd = NULL;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainDef *def = NULL;
+ virCommand *cmd = NULL;
+ virCommand *loadcmd = NULL;
char *ret = NULL;
virCheckFlags(0, NULL);
virDomainPtr **domains,
unsigned int flags)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
bhyveDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- bhyveConnPtr privconn = conn->privateData;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByUUID(privconn->domains, uuid);
static virDomainPtr bhyveDomainLookupByName(virConnectPtr conn,
const char *name)
{
- bhyveConnPtr privconn = conn->privateData;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByName(privconn->domains, name);
bhyveDomainLookupByID(virConnectPtr conn,
int id)
{
- bhyveConnPtr privconn = conn->privateData;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByID(privconn->domains, id);
bhyveDomainCreateWithFlags(virDomainPtr dom,
unsigned int flags)
{
- bhyveConnPtr privconn = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ struct _bhyveConn *privconn = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
unsigned int start_flags = 0;
int ret = -1;
const char *xml,
unsigned int flags)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
virDomainPtr dom = NULL;
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
- virObjectEventPtr event = NULL;
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
+ virObjectEvent *event = NULL;
unsigned int start_flags = 0;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
bhyveDomainDestroyFlags(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn = dom->conn;
- bhyveConnPtr privconn = conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int
bhyveDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
bhyveDomainReboot(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn = dom->conn;
- virDomainObjPtr vm;
- bhyveDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ bhyveDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(VIR_DOMAIN_REBOOT_ACPI_POWER_BTN, -1);
virStreamPtr st,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainChrDefPtr chr = NULL;
+ virDomainObj *vm = NULL;
+ virDomainChrDef *chr = NULL;
int ret = -1;
virCheckFlags(0, -1);
unsigned int flags)
{
virConnectPtr conn = dom->conn;
- bhyveConnPtr privconn = conn->privateData;
- virDomainObjPtr vm;
+ struct _bhyveConn *privconn = conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
BHYVE_CONFIG_DIR, flags);
if (ret == 0) {
- virObjectEventPtr ev = NULL;
+ virObjectEvent *ev = NULL;
ev = virDomainEventMetadataChangeNewFromObj(vm, type, uri);
virObjectEventStateQueue(privconn->domainEventState, ev);
}
const char *uri,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = bhyveDomObjFromDomain(dom)))
}
unsigned
-bhyveDriverGetBhyveCaps(bhyveConnPtr driver)
+bhyveDriverGetBhyveCaps(struct _bhyveConn *driver)
{
if (driver != NULL)
return driver->bhyvecaps;
}
unsigned
-bhyveDriverGetGrubCaps(bhyveConnPtr driver)
+bhyveDriverGetGrubCaps(struct _bhyveConn *driver)
{
if (driver != NULL)
return driver->grubcaps;
unsigned int ncpus,
unsigned int flags)
{
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
const char *xmlDesc,
unsigned int flags)
{
- bhyveConnPtr driver = conn->privateData;
+ struct _bhyveConn *driver = conn->privateData;
int ret = VIR_CPU_COMPARE_ERROR;
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
bool failIncompatible;
bool validateXML;
void *opaque,
virFreeCallback freecb)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
int ret;
if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
bhyveConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- bhyveConnPtr privconn = conn->privateData;
+ struct _bhyveConn *privconn = conn->privateData;
if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
static int
bhyveDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
unsigned int flags)
{
char *xml = NULL;
- virDomainDefPtr def = NULL;
- bhyveConnPtr privconn = conn->privateData;
+ virDomainDef *def = NULL;
+ struct _bhyveConn *privconn = conn->privateData;
unsigned bhyveCaps = bhyveDriverGetBhyveCaps(privconn);
virCheckFlags(0, NULL);
const char *virttype_str,
unsigned int flags)
{
- virDomainCapsPtr caps = NULL;
+ virDomainCaps *caps = NULL;
char *ret = NULL;
int virttype = VIR_DOMAIN_VIRT_BHYVE;
int arch = virArchFromHost(); /* virArch */
int bhyveRegister(void);
-unsigned bhyveDriverGetBhyveCaps(bhyveConnPtr driver);
+unsigned bhyveDriverGetBhyveCaps(struct _bhyveConn *driver);
-unsigned bhyveDriverGetGrubCaps(bhyveConnPtr driver);
+unsigned bhyveDriverGetGrubCaps(struct _bhyveConn *driver);
-virCapsPtr bhyveDriverGetCapabilities(bhyveConnPtr driver);
+virCaps *bhyveDriverGetCapabilities(struct _bhyveConn *driver);
#define BHYVE_DEFAULT_FIRMWARE "BHYVE_UEFI.fd"
int
-bhyveFirmwareFillDomain(bhyveConnPtr driver,
- virDomainDefPtr def,
+bhyveFirmwareFillDomain(bhyveConn *driver,
+ virDomainDef *def,
unsigned int flags)
{
g_autoptr(DIR) dir = NULL;
#include "bhyve_utils.h"
int
-bhyveFirmwareFillDomain(bhyveConnPtr driver,
- virDomainDefPtr def,
+bhyveFirmwareFillDomain(bhyveConn *driver,
+ virDomainDef *def,
unsigned int flags);
struct _bhyveMonitor {
virObject parent;
- bhyveConnPtr driver;
- virDomainObjPtr vm;
+ struct _bhyveConn *driver;
+ virDomainObj *vm;
int kq;
int watch;
bool reboot;
};
-static virClassPtr bhyveMonitorClass;
+static virClass *bhyveMonitorClass;
static void
bhyveMonitorDispose(void *obj)
{
- bhyveMonitorPtr mon = obj;
+ bhyveMonitor *mon = obj;
VIR_FORCE_CLOSE(mon->kq);
virObjectUnref(mon->vm);
static void bhyveMonitorIO(int, int, int, void *);
static bool
-bhyveMonitorRegister(bhyveMonitorPtr mon)
+bhyveMonitorRegister(bhyveMonitor *mon)
{
virObjectRef(mon);
mon->watch = virEventAddHandle(mon->kq,
}
static void
-bhyveMonitorUnregister(bhyveMonitorPtr mon)
+bhyveMonitorUnregister(bhyveMonitor *mon)
{
if (mon->watch < 0)
return;
}
void
-bhyveMonitorSetReboot(bhyveMonitorPtr mon)
+bhyveMonitorSetReboot(bhyveMonitor *mon)
{
mon->reboot = true;
}
bhyveMonitorIO(int watch, int kq, int events G_GNUC_UNUSED, void *opaque)
{
const struct timespec zerowait = { 0, 0 };
- bhyveMonitorPtr mon = opaque;
- virDomainObjPtr vm = mon->vm;
- bhyveConnPtr driver = mon->driver;
+ bhyveMonitor *mon = opaque;
+ virDomainObj *vm = mon->vm;
+ struct _bhyveConn *driver = mon->driver;
const char *name;
struct kevent kev;
int rc, status;
}
}
-static bhyveMonitorPtr
-bhyveMonitorOpenImpl(virDomainObjPtr vm, bhyveConnPtr driver)
+static bhyveMonitor *
+bhyveMonitorOpenImpl(virDomainObj *vm, struct _bhyveConn *driver)
{
- bhyveMonitorPtr mon;
+ bhyveMonitor *mon;
struct kevent kev;
if (bhyveMonitorInitialize() < 0)
return NULL;
}
-bhyveMonitorPtr
-bhyveMonitorOpen(virDomainObjPtr vm, bhyveConnPtr driver)
+bhyveMonitor *
+bhyveMonitorOpen(virDomainObj *vm, struct _bhyveConn *driver)
{
- bhyveMonitorPtr mon;
+ bhyveMonitor *mon;
virObjectRef(vm);
mon = bhyveMonitorOpenImpl(vm, driver);
}
void
-bhyveMonitorClose(bhyveMonitorPtr mon)
+bhyveMonitorClose(bhyveMonitor *mon)
{
if (mon == NULL)
return;
#include "bhyve_utils.h"
typedef struct _bhyveMonitor bhyveMonitor;
-typedef bhyveMonitor *bhyveMonitorPtr;
-bhyveMonitorPtr bhyveMonitorOpen(virDomainObjPtr vm, bhyveConnPtr driver);
-void bhyveMonitorClose(bhyveMonitorPtr mon);
+bhyveMonitor *bhyveMonitorOpen(virDomainObj *vm, struct _bhyveConn *driver);
+void bhyveMonitorClose(bhyveMonitor *mon);
-void bhyveMonitorSetReboot(bhyveMonitorPtr mon);
+void bhyveMonitorSetReboot(bhyveMonitor *mon);
}
static int
-bhyveParseBhyveLPCArg(virDomainDefPtr def,
+bhyveParseBhyveLPCArg(virDomainDef *def,
unsigned caps G_GNUC_UNUSED,
const char *arg)
{
const char *separator = NULL;
const char *param = NULL;
size_t last = 0;
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
char *type = NULL;
separator = strchr(arg, ',');
}
static int
-bhyveParsePCIDisk(virDomainDefPtr def,
+bhyveParsePCIDisk(virDomainDef *def,
unsigned caps G_GNUC_UNUSED,
unsigned pcibus,
unsigned pcislot,
/* -s slot,virtio-blk|ahci-cd|ahci-hd,/path/to/file */
const char *separator = NULL;
int idx = -1;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
if (!(disk = virDomainDiskDefNew(NULL)))
return 0;
}
static int
-bhyveParsePCINet(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+bhyveParsePCINet(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned caps G_GNUC_UNUSED,
unsigned bus,
unsigned slot,
{
/* -s slot,virtio-net,tapN[,mac=xx:xx:xx:xx:xx:xx] */
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
const char *separator = NULL;
const char *mac = NULL;
}
static int
-bhyveParsePCIFbuf(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+bhyveParsePCIFbuf(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned caps G_GNUC_UNUSED,
unsigned bus,
unsigned slot,
{
/* -s slot,fbuf,wait,vga=on|io|off,rfb=<ip>:port,w=width,h=height */
- virDomainVideoDefPtr video = NULL;
- virDomainGraphicsDefPtr graphics = NULL;
+ virDomainVideoDef *video = NULL;
+ virDomainGraphicsDef *graphics = NULL;
g_auto(GStrv) params = NULL;
GStrv next;
}
static int
-bhyveParseBhyvePCIArg(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+bhyveParseBhyvePCIArg(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned caps,
unsigned *nvirtiodisk,
unsigned *nahcidisk,
* Parse the /usr/sbin/bhyve command line.
*/
static int
-bhyveParseBhyveCommandLine(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+bhyveParseBhyveCommandLine(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned caps,
int argc, char **argv)
{
* Parse the /usr/sbin/bhyveload command line.
*/
static int
-bhyveParseBhyveLoadCommandLine(virDomainDefPtr def,
+bhyveParseBhyveLoadCommandLine(virDomainDef *def,
int argc, char **argv)
{
/* bhyveload called with default arguments when only -m and -d are given.
#undef CONSUME_ARG
static int
-bhyveParseCustomLoaderCommandLine(virDomainDefPtr def,
+bhyveParseCustomLoaderCommandLine(virDomainDef *def,
int argc G_GNUC_UNUSED,
char **argv)
{
return 0;
}
-virDomainDefPtr
+virDomainDef *
bhyveParseCommandLineString(const char* nativeConfig,
unsigned caps,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
int bhyve_argc = 0;
char **bhyve_argv = NULL;
int loader_argc = 0;
#pragma once
-virDomainDefPtr bhyveParseCommandLineString(const char* nativeConfig,
- unsigned caps,
- virDomainXMLOptionPtr xmlopt);
+virDomainDef *bhyveParseCommandLineString(const char* nativeConfig,
+ unsigned caps,
+ virDomainXMLOption *xmlopt);
VIR_LOG_INIT("bhyve.bhyve_process");
static void
-bhyveProcessAutoDestroy(virDomainObjPtr vm,
+bhyveProcessAutoDestroy(virDomainObj *vm,
virConnectPtr conn G_GNUC_UNUSED,
void *opaque)
{
- bhyveConnPtr driver = opaque;
+ struct _bhyveConn *driver = opaque;
virBhyveProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED);
}
static void
-bhyveNetCleanup(virDomainObjPtr vm)
+bhyveNetCleanup(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
virDomainNetType actualType = virDomainNetGetActualType(net);
if (actualType == VIR_DOMAIN_NET_TYPE_BRIDGE) {
}
static int
-bhyveProcessStartHook(virDomainObjPtr vm, virHookBhyveOpType op)
+bhyveProcessStartHook(virDomainObj *vm, virHookBhyveOpType op)
{
if (!virHookPresent(VIR_HOOK_DRIVER_BHYVE))
return 0;
}
static void
-bhyveProcessStopHook(virDomainObjPtr vm, virHookBhyveOpType op)
+bhyveProcessStopHook(virDomainObj *vm, virHookBhyveOpType op)
{
if (virHookPresent(VIR_HOOK_DRIVER_BHYVE))
virHookCall(VIR_HOOK_DRIVER_BHYVE, vm->def->name, op,
}
static int
-virBhyveProcessStartImpl(bhyveConnPtr driver,
- virDomainObjPtr vm,
+virBhyveProcessStartImpl(struct _bhyveConn *driver,
+ virDomainObj *vm,
virDomainRunningReason reason)
{
char *devmap_file = NULL;
char *devicemap = NULL;
char *logfile = NULL;
int logfd = -1;
- virCommandPtr cmd = NULL;
- virCommandPtr load_cmd = NULL;
- bhyveDomainObjPrivatePtr priv = vm->privateData;
+ virCommand *cmd = NULL;
+ virCommand *load_cmd = NULL;
+ bhyveDomainObjPrivate *priv = vm->privateData;
int ret = -1, rc;
logfile = g_strdup_printf("%s/%s.log", BHYVE_LOG_DIR, vm->def->name);
if (ret < 0) {
int exitstatus; /* Needed to avoid logging non-zero status */
- virCommandPtr destroy_cmd;
+ virCommand *destroy_cmd;
if ((destroy_cmd = virBhyveProcessBuildDestroyCmd(driver,
vm->def)) != NULL) {
virCommandSetOutputFD(load_cmd, &logfd);
}
int
-bhyveProcessPrepareDomain(bhyveConnPtr driver,
- virDomainObjPtr vm,
+bhyveProcessPrepareDomain(bhyveConn *driver,
+ virDomainObj *vm,
unsigned int flags)
{
if (bhyveFirmwareFillDomain(driver, vm->def, flags) < 0)
int
virBhyveProcessStart(virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
virDomainRunningReason reason,
unsigned int flags)
{
- bhyveConnPtr driver = conn->privateData;
+ struct _bhyveConn *driver = conn->privateData;
/* Run an early hook to setup missing devices. */
if (bhyveProcessStartHook(vm, VIR_HOOK_BHYVE_OP_PREPARE) < 0)
}
int
-virBhyveProcessStop(bhyveConnPtr driver,
- virDomainObjPtr vm,
+virBhyveProcessStop(struct _bhyveConn *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason)
{
int ret = -1;
- virCommandPtr cmd = NULL;
- bhyveDomainObjPrivatePtr priv = vm->privateData;
+ virCommand *cmd = NULL;
+ bhyveDomainObjPrivate *priv = vm->privateData;
if (!virDomainObjIsActive(vm)) {
VIR_DEBUG("VM '%s' not active", vm->def->name);
}
int
-virBhyveProcessShutdown(virDomainObjPtr vm)
+virBhyveProcessShutdown(virDomainObj *vm)
{
if (vm->pid <= 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
int
-virBhyveProcessRestart(bhyveConnPtr driver,
- virDomainObjPtr vm)
+virBhyveProcessRestart(struct _bhyveConn *driver,
+ virDomainObj *vm)
{
if (virBhyveProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN) < 0)
return -1;
}
int
-virBhyveGetDomainTotalCpuStats(virDomainObjPtr vm,
+virBhyveGetDomainTotalCpuStats(virDomainObj *vm,
unsigned long long *cpustats)
{
struct kinfo_proc *kp;
}
struct bhyveProcessReconnectData {
- bhyveConnPtr driver;
+ struct _bhyveConn *driver;
kvm_t *kd;
};
static int
-virBhyveProcessReconnect(virDomainObjPtr vm,
+virBhyveProcessReconnect(virDomainObj *vm,
void *opaque)
{
struct bhyveProcessReconnectData *data = opaque;
int nprocs;
char **proc_argv;
char *expected_proctitle = NULL;
- bhyveDomainObjPrivatePtr priv = vm->privateData;
+ bhyveDomainObjPrivate *priv = vm->privateData;
int ret = -1;
if (!virDomainObjIsActive(vm))
}
void
-virBhyveProcessReconnectAll(bhyveConnPtr driver)
+virBhyveProcessReconnectAll(struct _bhyveConn *driver)
{
kvm_t *kd;
struct bhyveProcessReconnectData data;
#include "bhyve_utils.h"
int
-bhyveProcessPrepareDomain(bhyveConnPtr driver,
- virDomainObjPtr vm,
+bhyveProcessPrepareDomain(bhyveConn *driver,
+ virDomainObj *vm,
unsigned int flags);
-int virBhyveProcessStart(virConnectPtr conn,
- virDomainObjPtr vm,
+int virBhyveProcessStart(virConnect *conn,
+ virDomainObj *vm,
virDomainRunningReason reason,
unsigned int flags);
-int virBhyveProcessStop(bhyveConnPtr driver,
- virDomainObjPtr vm,
+int virBhyveProcessStop(struct _bhyveConn *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason);
-int virBhyveProcessRestart(bhyveConnPtr driver,
- virDomainObjPtr vm);
+int virBhyveProcessRestart(struct _bhyveConn *driver,
+ virDomainObj *vm);
-int virBhyveProcessShutdown(virDomainObjPtr vm);
+int virBhyveProcessShutdown(virDomainObj *vm);
-int virBhyveGetDomainTotalCpuStats(virDomainObjPtr vm,
+int virBhyveGetDomainTotalCpuStats(virDomainObj *vm,
unsigned long long *cpustats);
-void virBhyveProcessReconnectAll(bhyveConnPtr driver);
+void virBhyveProcessReconnectAll(struct _bhyveConn *driver);
typedef enum {
VIR_BHYVE_PROCESS_START_AUTODESTROY = 1 << 0,
#define BHYVE_LOG_DIR LOCALSTATEDIR "/log/libvirt/bhyve"
typedef struct _virBhyveDriverConfig virBhyveDriverConfig;
-typedef struct _virBhyveDriverConfig *virBhyveDriverConfigPtr;
-
struct _virBhyveDriverConfig {
virObject parent;
struct _bhyveConn {
virMutex lock;
- virBhyveDriverConfigPtr config;
+ struct _virBhyveDriverConfig *config;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
- virDomainObjListPtr domains;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
+ virDomainObjList *domains;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
char *pidfile;
- virSysinfoDefPtr hostsysinfo;
+ virSysinfoDef *hostsysinfo;
- virObjectEventStatePtr domainEventState;
+ virObjectEventState *domainEventState;
- virCloseCallbacksPtr closeCallbacks;
+ virCloseCallbacks *closeCallbacks;
- virPortAllocatorRangePtr remotePorts;
+ virPortAllocatorRange *remotePorts;
unsigned bhyvecaps;
unsigned grubcaps;
};
typedef struct _bhyveConn bhyveConn;
-typedef struct _bhyveConn *bhyveConnPtr;
struct bhyveAutostartData {
- bhyveConnPtr driver;
+ struct _bhyveConn *driver;
virConnectPtr conn;
};
-void bhyveDriverLock(bhyveConnPtr driver);
-void bhyveDriverUnlock(bhyveConnPtr driver);
+void bhyveDriverLock(struct _bhyveConn *driver);
+void bhyveDriverUnlock(struct _bhyveConn *driver);
"incremental");
void
-virDomainBackupDefFree(virDomainBackupDefPtr def)
+virDomainBackupDefFree(virDomainBackupDef *def)
{
size_t i;
virStorageNetHostDefFree(1, def->server);
for (i = 0; i < def->ndisks; i++) {
- virDomainBackupDiskDefPtr disk = def->disks + i;
+ virDomainBackupDiskDef *disk = def->disks + i;
g_free(disk->name);
g_free(disk->incremental);
static int
virDomainBackupDiskDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainBackupDiskDefPtr def,
+ virDomainBackupDiskDef *def,
bool push,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *type = NULL;
static void
-virDomainBackupDefParsePrivate(virDomainBackupDefPtr def,
+virDomainBackupDefParsePrivate(virDomainBackupDef *def,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
}
-static virDomainBackupDefPtr
+static virDomainBackupDef *
virDomainBackupDefParse(xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_autoptr(virDomainBackupDef) def = NULL;
}
-virDomainBackupDefPtr
+virDomainBackupDef *
virDomainBackupDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
- virDomainBackupDefPtr ret = NULL;
+ virDomainBackupDef *ret = NULL;
g_autoptr(xmlDoc) xml = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
}
-virDomainBackupDefPtr
+virDomainBackupDef *
virDomainBackupDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
static int
-virDomainBackupDiskDefFormat(virBufferPtr buf,
- virDomainBackupDiskDefPtr disk,
+virDomainBackupDiskDefFormat(virBuffer *buf,
+ virDomainBackupDiskDef *disk,
bool push,
bool internal)
{
static void
-virDomainBackupDefFormatPrivate(virBufferPtr buf,
- virDomainBackupDefPtr def,
+virDomainBackupDefFormatPrivate(virBuffer *buf,
+ virDomainBackupDef *def,
bool internal)
{
g_auto(virBuffer) privChildBuf = VIR_BUFFER_INIT_CHILD(buf);
int
-virDomainBackupDefFormat(virBufferPtr buf,
- virDomainBackupDefPtr def,
+virDomainBackupDefFormat(virBuffer *buf,
+ virDomainBackupDef *def,
bool internal)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static int
-virDomainBackupDefAssignStore(virDomainBackupDiskDefPtr disk,
- virStorageSourcePtr src,
+virDomainBackupDefAssignStore(virDomainBackupDiskDef *disk,
+ virStorageSource *src,
const char *suffix)
{
if (virStorageSourceIsEmpty(src)) {
int
-virDomainBackupAlignDisks(virDomainBackupDefPtr def,
- virDomainDefPtr dom,
+virDomainBackupAlignDisks(virDomainBackupDef *def,
+ virDomainDef *dom,
const char *suffix)
{
g_autoptr(GHashTable) disks = virHashNew(NULL);
/* Double check requested disks. */
for (i = 0; i < def->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = &def->disks[i];
- virDomainDiskDefPtr domdisk;
+ virDomainBackupDiskDef *backupdisk = &def->disks[i];
+ virDomainDiskDef *domdisk;
if (!(domdisk = virDomainDiskByTarget(dom, backupdisk->name))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
VIR_EXPAND_N(def->disks, def->ndisks, dom->ndisks - def->ndisks);
for (i = 0; i < dom->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = NULL;
- virDomainDiskDefPtr domdisk = dom->disks[i];
+ virDomainBackupDiskDef *backupdisk = NULL;
+ virDomainDiskDef *domdisk = dom->disks[i];
if (virHashHasEntry(disks, domdisk->dst))
continue;
}
for (i = 0; i < def->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = &def->disks[i];
+ virDomainBackupDiskDef *backupdisk = &def->disks[i];
if (backupdisk->backupmode == VIR_DOMAIN_BACKUP_DISK_BACKUP_MODE_DEFAULT) {
if (def->incremental || backupdisk->incremental) {
/* Stores disk-backup information */
typedef struct _virDomainBackupDiskDef virDomainBackupDiskDef;
-typedef virDomainBackupDiskDef *virDomainBackupDiskDefPtr;
struct _virDomainBackupDiskDef {
char *name; /* name matching the <target dev='...' of the domain */
virTristateBool backup; /* whether backup is requested */
char *exportbitmap; /* name of the bitmap exposed in NBD for pull mode backup */
/* details of target for push-mode, or of the scratch file for pull-mode */
- virStorageSourcePtr store;
+ virStorageSource *store;
/* internal data */
virDomainBackupDiskState state;
/* Stores the complete backup metadata */
typedef struct _virDomainBackupDef virDomainBackupDef;
-typedef virDomainBackupDef *virDomainBackupDefPtr;
struct _virDomainBackupDef {
/* Public XML. */
int type; /* virDomainBackupType */
char *incremental;
- virStorageNetHostDefPtr server; /* only when type == PULL */
+ virStorageNetHostDef *server; /* only when type == PULL */
virTristateBool tls; /* use TLS for NBD */
size_t ndisks; /* should not exceed dom->ndisks */
VIR_DOMAIN_BACKUP_PARSE_INTERNAL = 1 << 0,
} virDomainBackupParseFlags;
-virDomainBackupDefPtr
+virDomainBackupDef *
virDomainBackupDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-virDomainBackupDefPtr
+virDomainBackupDef *
virDomainBackupDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
void
-virDomainBackupDefFree(virDomainBackupDefPtr def);
+virDomainBackupDefFree(virDomainBackupDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainBackupDef, virDomainBackupDefFree);
int
-virDomainBackupDefFormat(virBufferPtr buf,
- virDomainBackupDefPtr def,
+virDomainBackupDefFormat(virBuffer *buf,
+ virDomainBackupDef *def,
bool internal);
int
-virDomainBackupAlignDisks(virDomainBackupDefPtr backup,
- virDomainDefPtr dom,
+virDomainBackupAlignDisks(virDomainBackupDef *backup,
+ virDomainDef *dom,
const char *suffix);
"suspend_mem", "suspend_disk", "suspend_hybrid",
);
-static virClassPtr virCapsClass;
+static virClass *virCapsClass;
static void virCapsDispose(void *obj);
static int virCapabilitiesOnceInit(void)
*
* Allocate a new capabilities object
*/
-virCapsPtr
+virCaps *
virCapabilitiesNew(virArch hostarch,
bool offlineMigrate,
bool liveMigrate)
{
- virCapsPtr caps;
+ virCaps *caps;
if (virCapabilitiesInitialize() < 0)
return NULL;
}
void
-virCapabilitiesClearHostNUMACellCPUTopology(virCapsHostNUMACellCPUPtr cpus,
+virCapabilitiesClearHostNUMACellCPUTopology(virCapsHostNUMACellCPU *cpus,
size_t ncpus)
{
size_t i;
}
static void
-virCapabilitiesFreeHostNUMACell(virCapsHostNUMACellPtr cell)
+virCapabilitiesFreeHostNUMACell(virCapsHostNUMACell *cell)
{
if (cell == NULL)
return;
}
static void
-virCapabilitiesFreeGuestMachine(virCapsGuestMachinePtr machine)
+virCapabilitiesFreeGuestMachine(virCapsGuestMachine *machine)
{
if (machine == NULL)
return;
}
static void
-virCapabilitiesFreeGuestDomain(virCapsGuestDomainPtr dom)
+virCapabilitiesFreeGuestDomain(virCapsGuestDomain *dom)
{
size_t i;
if (dom == NULL)
}
void
-virCapabilitiesFreeGuest(virCapsGuestPtr guest)
+virCapabilitiesFreeGuest(virCapsGuest *guest)
{
size_t i;
if (guest == NULL)
static void
-virCapabilitiesFreeStoragePool(virCapsStoragePoolPtr pool)
+virCapabilitiesFreeStoragePool(virCapsStoragePool *pool)
{
if (!pool)
return;
void
-virCapabilitiesHostNUMAUnref(virCapsHostNUMAPtr caps)
+virCapabilitiesHostNUMAUnref(virCapsHostNUMA *caps)
{
if (!caps)
return;
}
void
-virCapabilitiesHostNUMARef(virCapsHostNUMAPtr caps)
+virCapabilitiesHostNUMARef(virCapsHostNUMA *caps)
{
g_atomic_int_inc(&caps->refs);
}
static void
-virCapsHostMemBWNodeFree(virCapsHostMemBWNodePtr ptr)
+virCapsHostMemBWNodeFree(virCapsHostMemBWNode *ptr)
{
if (!ptr)
return;
}
static void
-virCapabilitiesClearSecModel(virCapsHostSecModelPtr secmodel)
+virCapabilitiesClearSecModel(virCapsHostSecModel *secmodel)
{
size_t i;
for (i = 0; i < secmodel->nlabels; i++) {
static void
virCapsDispose(void *object)
{
- virCapsPtr caps = object;
+ virCaps *caps = object;
size_t i;
for (i = 0; i < caps->npools; i++)
* Registers a new host CPU feature, eg 'pae', or 'vmx'
*/
int
-virCapabilitiesAddHostFeature(virCapsPtr caps,
+virCapabilitiesAddHostFeature(virCaps *caps,
const char *name)
{
VIR_RESIZE_N(caps->host.features, caps->host.nfeatures_max,
* Registers a new domain migration transport URI
*/
int
-virCapabilitiesAddHostMigrateTransport(virCapsPtr caps,
+virCapabilitiesAddHostMigrateTransport(virCaps *caps,
const char *name)
{
VIR_RESIZE_N(caps->host.migrateTrans, caps->host.nmigrateTrans_max,
* Registers the prefix that is used for generated network interfaces
*/
int
-virCapabilitiesSetNetPrefix(virCapsPtr caps,
+virCapabilitiesSetNetPrefix(virCaps *caps,
const char *prefix)
{
caps->host.netprefix = g_strdup(prefix);
* array of CPU IDs belonging to the cell
*/
void
-virCapabilitiesHostNUMAAddCell(virCapsHostNUMAPtr caps,
+virCapabilitiesHostNUMAAddCell(virCapsHostNUMA *caps,
int num,
unsigned long long mem,
int ncpus,
- virCapsHostNUMACellCPUPtr cpus,
+ virCapsHostNUMACellCPU *cpus,
int nsiblings,
- virCapsHostNUMACellSiblingInfoPtr siblings,
+ virCapsHostNUMACellSiblingInfo *siblings,
int npageinfo,
- virCapsHostNUMACellPageInfoPtr pageinfo)
+ virCapsHostNUMACellPageInfo *pageinfo)
{
- virCapsHostNUMACellPtr cell = g_new0(virCapsHostNUMACell, 1);
+ virCapsHostNUMACell *cell = g_new0(virCapsHostNUMACell, 1);
cell->num = num;
cell->mem = mem;
* @machines: machine variants for emulator ('pc', or 'isapc', etc)
* @nmachines: number of machine variants for emulator
*
- * Allocate a table of virCapsGuestMachinePtr from the supplied table
+ * Allocate a table of virCapsGuestMachine *from the supplied table
* of machine names.
*/
-virCapsGuestMachinePtr *
+virCapsGuestMachine **
virCapabilitiesAllocMachines(const char *const *names, int nnames)
{
- virCapsGuestMachinePtr *machines;
+ virCapsGuestMachine **machines;
size_t i;
- machines = g_new0(virCapsGuestMachinePtr, nnames);
+ machines = g_new0(virCapsGuestMachine *, nnames);
for (i = 0; i < nnames; i++) {
machines[i] = g_new0(virCapsGuestMachine, 1);
* virCapabilitiesFreeMachines:
* @machines: table of vircapsGuestMachinePtr
*
- * Free a table of virCapsGuestMachinePtr
+ * Free a table of virCapsGuestMachine *
*/
void
-virCapabilitiesFreeMachines(virCapsGuestMachinePtr *machines,
+virCapabilitiesFreeMachines(virCapsGuestMachine **machines,
int nmachines)
{
size_t i;
* followed by registration of at least one domain for
* running the guest
*/
-virCapsGuestPtr
-virCapabilitiesAddGuest(virCapsPtr caps,
+virCapsGuest *
+virCapabilitiesAddGuest(virCaps *caps,
int ostype,
virArch arch,
const char *emulator,
const char *loader,
int nmachines,
- virCapsGuestMachinePtr *machines)
+ virCapsGuestMachine **machines)
{
- virCapsGuestPtr guest;
+ virCapsGuest *guest;
guest = g_new0(virCapsGuest, 1);
* Registers a virtual domain capable of running a
* guest operating system
*/
-virCapsGuestDomainPtr
-virCapabilitiesAddGuestDomain(virCapsGuestPtr guest,
+virCapsGuestDomain *
+virCapabilitiesAddGuestDomain(virCapsGuest *guest,
int hvtype,
const char *emulator,
const char *loader,
int nmachines,
- virCapsGuestMachinePtr *machines)
+ virCapsGuestMachine **machines)
{
- virCapsGuestDomainPtr dom;
+ virCapsGuestDomain *dom;
dom = g_new0(virCapsGuestDomain, 1);
static void
-virCapabilitiesAddGuestFeatureInternal(virCapsGuestPtr guest,
+virCapabilitiesAddGuestFeatureInternal(virCapsGuest *guest,
virCapsGuestFeatureType feature,
bool defaultOn,
bool toggle)
* Registers a feature for a guest domain.
*/
void
-virCapabilitiesAddGuestFeature(virCapsGuestPtr guest,
+virCapabilitiesAddGuestFeature(virCapsGuest *guest,
virCapsGuestFeatureType feature)
{
virCapabilitiesAddGuestFeatureInternal(guest, feature, false, false);
* Registers a feature with toggles for a guest domain.
*/
void
-virCapabilitiesAddGuestFeatureWithToggle(virCapsGuestPtr guest,
+virCapabilitiesAddGuestFeatureWithToggle(virCapsGuest *guest,
virCapsGuestFeatureType feature,
bool defaultOn,
bool toggle)
* Returns non-zero on error.
*/
extern int
-virCapabilitiesHostSecModelAddBaseLabel(virCapsHostSecModelPtr secmodel,
+virCapabilitiesHostSecModelAddBaseLabel(virCapsHostSecModel *secmodel,
const char *type,
const char *label)
{
}
-static virCapsDomainDataPtr
-virCapabilitiesDomainDataLookupInternal(virCapsPtr caps,
+static virCapsDomainData *
+virCapabilitiesDomainDataLookupInternal(virCaps *caps,
int ostype,
virArch arch,
virDomainVirtType domaintype,
const char *emulator,
const char *machinetype)
{
- virCapsGuestPtr foundguest = NULL;
- virCapsGuestDomainPtr founddomain = NULL;
- virCapsGuestMachinePtr foundmachine = NULL;
- virCapsDomainDataPtr ret = NULL;
+ virCapsGuest *foundguest = NULL;
+ virCapsGuestDomain *founddomain = NULL;
+ virCapsGuestMachine *foundmachine = NULL;
+ virCapsDomainData *ret = NULL;
size_t i, j, k;
VIR_DEBUG("Lookup ostype=%d arch=%d domaintype=%d emulator=%s machine=%s",
ostype, arch, domaintype, NULLSTR(emulator), NULLSTR(machinetype));
for (i = 0; i < caps->nguests; i++) {
- virCapsGuestPtr guest = caps->guests[i];
+ virCapsGuest *guest = caps->guests[i];
if (ostype != -1 && guest->ostype != ostype) {
VIR_DEBUG("Skip os type want=%d vs got=%d", ostype, guest->ostype);
VIR_DEBUG("Match arch %d", arch);
for (j = 0; j < guest->arch.ndomains; j++) {
- virCapsGuestDomainPtr domain = guest->arch.domains[j];
- virCapsGuestMachinePtr *machinelist;
+ virCapsGuestDomain *domain = guest->arch.domains[j];
+ virCapsGuestMachine **machinelist;
int nmachines;
const char *check_emulator = NULL;
}
for (k = 0; k < nmachines; k++) {
- virCapsGuestMachinePtr machine = machinelist[k];
+ virCapsGuestMachine *machine = machinelist[k];
if (machinetype &&
STRNEQ(machine->name, machinetype) &&
* Search capabilities for the passed values, and if found return
* virCapabilitiesDomainDataLookup filled in with the default values
*/
-virCapsDomainDataPtr
-virCapabilitiesDomainDataLookup(virCapsPtr caps,
+virCapsDomainData *
+virCapabilitiesDomainDataLookup(virCaps *caps,
int ostype,
virArch arch,
int domaintype,
const char *emulator,
const char *machinetype)
{
- virCapsDomainDataPtr ret;
+ virCapsDomainData *ret;
if (arch == VIR_ARCH_NONE) {
/* Prefer host arch if its available */
bool
-virCapabilitiesDomainSupported(virCapsPtr caps,
+virCapabilitiesDomainSupported(virCaps *caps,
int ostype,
virArch arch,
int virttype)
{
- g_autofree virCapsDomainDataPtr capsdata = NULL;
+ g_autofree virCapsDomainData *capsdata = NULL;
capsdata = virCapabilitiesDomainDataLookup(caps, ostype,
arch,
int
-virCapabilitiesAddStoragePool(virCapsPtr caps,
+virCapabilitiesAddStoragePool(virCaps *caps,
int poolType)
{
- virCapsStoragePoolPtr pool;
+ virCapsStoragePool *pool;
pool = g_new0(virCapsStoragePool, 1);
static int
-virCapabilitiesHostNUMAFormat(virCapsHostNUMAPtr caps,
- virBufferPtr buf)
+virCapabilitiesHostNUMAFormat(virCapsHostNUMA *caps,
+ virBuffer *buf)
{
size_t i;
size_t j;
virBufferAsprintf(buf, "<cells num='%d'>\n", caps->cells->len);
virBufferAdjustIndent(buf, 2);
for (i = 0; i < caps->cells->len; i++) {
- virCapsHostNUMACellPtr cell = g_ptr_array_index(caps->cells, i);
+ virCapsHostNUMACell *cell = g_ptr_array_index(caps->cells, i);
virBufferAsprintf(buf, "<cell id='%d'>\n", cell->num);
virBufferAdjustIndent(buf, 2);
static int
-virCapabilitiesFormatResctrlMonitor(virBufferPtr buf,
- virResctrlInfoMonPtr monitor)
+virCapabilitiesFormatResctrlMonitor(virBuffer *buf,
+ virResctrlInfoMon *monitor)
{
size_t i = 0;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
}
static int
-virCapabilitiesFormatCaches(virBufferPtr buf,
- virCapsHostCachePtr cache)
+virCapabilitiesFormatCaches(virBuffer *buf,
+ virCapsHostCache *cache)
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < cache->nbanks; i++) {
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
- virCapsHostCacheBankPtr bank = cache->banks[i];
+ virCapsHostCacheBank *bank = cache->banks[i];
g_autofree char *cpus_str = virBitmapFormat(bank->cpus);
const char *unit = NULL;
unsigned long long short_size = virFormatIntPretty(bank->size, &unit);
for (j = 0; j < bank->ncontrols; j++) {
const char *min_unit;
- virResctrlInfoPerCachePtr controls = bank->controls[j];
+ virResctrlInfoPerCache *controls = bank->controls[j];
unsigned long long gran_short_size = controls->granularity;
unsigned long long min_short_size = controls->min;
}
static int
-virCapabilitiesFormatMemoryBandwidth(virBufferPtr buf,
- virCapsHostMemBWPtr memBW)
+virCapabilitiesFormatMemoryBandwidth(virBuffer *buf,
+ virCapsHostMemBW *memBW)
{
size_t i = 0;
for (i = 0; i < memBW->nnodes; i++) {
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
- virCapsHostMemBWNodePtr node = memBW->nodes[i];
- virResctrlInfoMemBWPerNodePtr control = &node->control;
+ virCapsHostMemBWNode *node = memBW->nodes[i];
+ virResctrlInfoMemBWPerNode *control = &node->control;
g_autofree char *cpus_str = virBitmapFormat(node->cpus);
if (!cpus_str)
static int
-virCapabilitiesFormatHostXML(virCapsHostPtr host,
- virBufferPtr buf)
+virCapabilitiesFormatHostXML(virCapsHost *host,
+ virBuffer *buf)
{
size_t i, j;
char host_uuid[VIR_UUID_STRING_BUFLEN];
static void
-virCapabilitiesFormatGuestFeatures(virCapsGuestPtr guest,
- virBufferPtr buf)
+virCapabilitiesFormatGuestFeatures(virCapsGuest *guest,
+ virBuffer *buf)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
size_t i;
for (i = 0; i < VIR_CAPS_GUEST_FEATURE_TYPE_LAST; i++) {
- virCapsGuestFeaturePtr feature = guest->features + i;
+ virCapsGuestFeature *feature = guest->features + i;
if (!feature->present)
continue;
static void
-virCapabilitiesFormatGuestXML(virCapsGuestPtr *guests,
+virCapabilitiesFormatGuestXML(virCapsGuest **guests,
size_t nguests,
- virBufferPtr buf)
+ virBuffer *buf)
{
size_t i, j, k;
guests[i]->arch.defaultInfo.loader);
for (j = 0; j < guests[i]->arch.defaultInfo.nmachines; j++) {
- virCapsGuestMachinePtr machine = guests[i]->arch.defaultInfo.machines[j];
+ virCapsGuestMachine *machine = guests[i]->arch.defaultInfo.machines[j];
virBufferAddLit(buf, "<machine");
if (machine->canonical)
virBufferAsprintf(buf, " canonical='%s'", machine->canonical);
guests[i]->arch.domains[j]->info.loader);
for (k = 0; k < guests[i]->arch.domains[j]->info.nmachines; k++) {
- virCapsGuestMachinePtr machine = guests[i]->arch.domains[j]->info.machines[k];
+ virCapsGuestMachine *machine = guests[i]->arch.domains[j]->info.machines[k];
virBufferAddLit(buf, "<machine");
if (machine->canonical)
virBufferAsprintf(buf, " canonical='%s'", machine->canonical);
static void
-virCapabilitiesFormatStoragePoolXML(virCapsStoragePoolPtr *pools,
+virCapabilitiesFormatStoragePoolXML(virCapsStoragePool **pools,
size_t npools,
- virBufferPtr buf)
+ virBuffer *buf)
{
size_t i;
* Returns the XML document as a string
*/
char *
-virCapabilitiesFormatXML(virCapsPtr caps)
+virCapabilitiesFormatXML(virCaps *caps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
/* get the maximum ID of cpus in the host */
static unsigned int
-virCapabilitiesHostNUMAGetMaxcpu(virCapsHostNUMAPtr caps)
+virCapabilitiesHostNUMAGetMaxcpu(virCapsHostNUMA *caps)
{
unsigned int maxcpu = 0;
size_t node;
size_t cpu;
for (node = 0; node < caps->cells->len; node++) {
- virCapsHostNUMACellPtr cell =
- g_ptr_array_index(caps->cells, node);
+ virCapsHostNUMACell *cell = g_ptr_array_index(caps->cells, node);
for (cpu = 0; cpu < cell->ncpus; cpu++) {
if (cell->cpus[cpu].id > maxcpu)
/* set cpus of a numa node in the bitmask */
static int
-virCapabilitiesHostNUMAGetCellCpus(virCapsHostNUMAPtr caps,
+virCapabilitiesHostNUMAGetCellCpus(virCapsHostNUMA *caps,
size_t node,
- virBitmapPtr cpumask)
+ virBitmap *cpumask)
{
- virCapsHostNUMACellPtr cell = NULL;
+ virCapsHostNUMACell *cell = NULL;
size_t cpu;
size_t i;
/* The numa node numbers can be non-contiguous. Ex: 0,1,16,17. */
return 0;
}
-virBitmapPtr
-virCapabilitiesHostNUMAGetCpus(virCapsHostNUMAPtr caps,
- virBitmapPtr nodemask)
+virBitmap *
+virCapabilitiesHostNUMAGetCpus(virCapsHostNUMA *caps,
+ virBitmap *nodemask)
{
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
unsigned int maxcpu = virCapabilitiesHostNUMAGetMaxcpu(caps);
ssize_t node = -1;
/* returns 1 on success, 0 if the detection failed and -1 on hard error */
static int
virCapabilitiesFillCPUInfo(int cpu_id G_GNUC_UNUSED,
- virCapsHostNUMACellCPUPtr cpu G_GNUC_UNUSED)
+ virCapsHostNUMACellCPU *cpu G_GNUC_UNUSED)
{
#ifdef __linux__
cpu->id = cpu_id;
static int
virCapabilitiesGetNUMASiblingInfo(int node,
- virCapsHostNUMACellSiblingInfoPtr *siblings,
+ virCapsHostNUMACellSiblingInfo **siblings,
int *nsiblings)
{
- virCapsHostNUMACellSiblingInfoPtr tmp = NULL;
+ virCapsHostNUMACellSiblingInfo *tmp = NULL;
int tmp_size = 0;
int ret = -1;
int *distances = NULL;
static int
virCapabilitiesGetNUMAPagesInfo(int node,
- virCapsHostNUMACellPageInfoPtr *pageinfo,
+ virCapsHostNUMACellPageInfo **pageinfo,
int *npageinfo)
{
int ret = -1;
static int
-virCapabilitiesHostNUMAInitFake(virCapsHostNUMAPtr caps)
+virCapabilitiesHostNUMAInitFake(virCapsHostNUMA *caps)
{
virNodeInfo nodeinfo;
- virCapsHostNUMACellCPUPtr cpus;
+ virCapsHostNUMACellCPU *cpus;
int ncpus;
int n, s, c, t;
int id, cid;
static int
-virCapabilitiesHostNUMAInitReal(virCapsHostNUMAPtr caps)
+virCapabilitiesHostNUMAInitReal(virCapsHostNUMA *caps)
{
int n;
unsigned long long memory;
- virCapsHostNUMACellCPUPtr cpus = NULL;
- virBitmapPtr cpumap = NULL;
- virCapsHostNUMACellSiblingInfoPtr siblings = NULL;
+ virCapsHostNUMACellCPU *cpus = NULL;
+ virBitmap *cpumap = NULL;
+ virCapsHostNUMACellSiblingInfo *siblings = NULL;
int nsiblings = 0;
- virCapsHostNUMACellPageInfoPtr pageinfo = NULL;
+ virCapsHostNUMACellPageInfo *pageinfo = NULL;
int npageinfo;
int ret = -1;
int ncpus = 0;
}
-virCapsHostNUMAPtr
+virCapsHostNUMA *
virCapabilitiesHostNUMANew(void)
{
- virCapsHostNUMAPtr caps = NULL;
+ virCapsHostNUMA *caps = NULL;
caps = g_new0(virCapsHostNUMA, 1);
caps->refs = 1;
}
-virCapsHostNUMAPtr
+virCapsHostNUMA *
virCapabilitiesHostNUMANewHost(void)
{
- virCapsHostNUMAPtr caps = virCapabilitiesHostNUMANew();
+ virCapsHostNUMA *caps = virCapabilitiesHostNUMANew();
if (virNumaIsAvailable()) {
if (virCapabilitiesHostNUMAInitReal(caps) == 0)
int
-virCapabilitiesInitPages(virCapsPtr caps)
+virCapabilitiesInitPages(virCaps *caps)
{
int ret = -1;
unsigned int *pages_size = NULL;
bool
-virCapsHostCacheBankEquals(virCapsHostCacheBankPtr a,
- virCapsHostCacheBankPtr b)
+virCapsHostCacheBankEquals(virCapsHostCacheBank *a,
+ virCapsHostCacheBank *b)
{
return (a->id == b->id &&
a->level == b->level &&
}
void
-virCapsHostCacheBankFree(virCapsHostCacheBankPtr ptr)
+virCapsHostCacheBankFree(virCapsHostCacheBank *ptr)
{
size_t i;
virCapsHostCacheBankSorter(const void *a,
const void *b)
{
- virCapsHostCacheBankPtr ca = *(virCapsHostCacheBankPtr *)a;
- virCapsHostCacheBankPtr cb = *(virCapsHostCacheBankPtr *)b;
+ virCapsHostCacheBank *ca = *(virCapsHostCacheBank **)a;
+ virCapsHostCacheBank *cb = *(virCapsHostCacheBank **)b;
if (ca->level < cb->level)
return -1;
static int
-virCapabilitiesInitResctrl(virCapsPtr caps)
+virCapabilitiesInitResctrl(virCaps *caps)
{
if (caps->host.resctrl)
return 0;
static int
-virCapabilitiesInitResctrlMemory(virCapsPtr caps)
+virCapabilitiesInitResctrlMemory(virCaps *caps)
{
- virCapsHostMemBWNodePtr node = NULL;
+ virCapsHostMemBWNode *node = NULL;
size_t i = 0;
int ret = -1;
const virResctrlMonitorType montype = VIR_RESCTRL_MONITOR_TYPE_MEMBW;
const char *prefix = virResctrlMonitorPrefixTypeToString(montype);
for (i = 0; i < caps->host.cache.nbanks; i++) {
- virCapsHostCacheBankPtr bank = caps->host.cache.banks[i];
+ virCapsHostCacheBank *bank = caps->host.cache.banks[i];
node = g_new0(virCapsHostMemBWNode, 1);
if (virResctrlInfoGetMemoryBandwidth(caps->host.resctrl,
int
-virCapabilitiesInitCaches(virCapsPtr caps)
+virCapabilitiesInitCaches(virCaps *caps)
{
size_t i = 0;
- virBitmapPtr cpus = NULL;
+ virBitmap *cpus = NULL;
ssize_t pos = -1;
int ret = -1;
char *path = NULL;
char *type = NULL;
struct dirent *ent = NULL;
- virCapsHostCacheBankPtr bank = NULL;
+ virCapsHostCacheBank *bank = NULL;
const virResctrlMonitorType montype = VIR_RESCTRL_MONITOR_TYPE_CACHE;
const char *prefix = virResctrlMonitorPrefixTypeToString(montype);
void
-virCapabilitiesHostInitIOMMU(virCapsPtr caps)
+virCapabilitiesHostInitIOMMU(virCaps *caps)
{
caps->host.iommu = virHostHasIOMMU();
}
char *emulator;
char *loader;
int nmachines;
- virCapsGuestMachinePtr *machines;
+ virCapsGuestMachine **machines;
};
struct _virCapsGuestDomain {
virCapsGuestDomainInfo defaultInfo;
size_t ndomains;
size_t ndomains_max;
- virCapsGuestDomainPtr *domains;
+ virCapsGuestDomain **domains;
};
struct _virCapsGuest {
unsigned int socket_id;
unsigned int die_id;
unsigned int core_id;
- virBitmapPtr siblings;
+ virBitmap *siblings;
};
struct _virCapsHostNUMACellSiblingInfo {
int num;
int ncpus;
unsigned long long mem; /* in kibibytes */
- virCapsHostNUMACellCPUPtr cpus;
+ virCapsHostNUMACellCPU *cpus;
int nsiblings;
- virCapsHostNUMACellSiblingInfoPtr siblings;
+ virCapsHostNUMACellSiblingInfo *siblings;
int npageinfo;
- virCapsHostNUMACellPageInfoPtr pageinfo;
+ virCapsHostNUMACellPageInfo *pageinfo;
};
struct _virCapsHostNUMA {
char *model;
char *doi;
size_t nlabels;
- virCapsHostSecModelLabelPtr labels;
+ virCapsHostSecModelLabel *labels;
};
struct _virCapsHostCacheBank {
unsigned int level; /* 1=L1, 2=L2, 3=L3, etc. */
unsigned long long size; /* B */
virCacheType type; /* Data, Instruction or Unified */
- virBitmapPtr cpus; /* All CPUs that share this bank */
+ virBitmap *cpus; /* All CPUs that share this bank */
size_t ncontrols;
- virResctrlInfoPerCachePtr *controls;
+ virResctrlInfoPerCache **controls;
};
struct _virCapsHostCache {
size_t nbanks;
- virCapsHostCacheBankPtr *banks;
+ virCapsHostCacheBank **banks;
- virResctrlInfoMonPtr monitor;
+ virResctrlInfoMon *monitor;
};
struct _virCapsHostMemBWNode {
unsigned int id;
- virBitmapPtr cpus; /* All CPUs that belong to this node */
+ virBitmap *cpus; /* All CPUs that belong to this node */
virResctrlInfoMemBWPerNode control;
};
struct _virCapsHostMemBW {
size_t nnodes;
- virCapsHostMemBWNodePtr *nodes;
+ virCapsHostMemBWNode **nodes;
- virResctrlInfoMonPtr monitor;
+ virResctrlInfoMon *monitor;
};
struct _virCapsHost {
size_t nmigrateTrans_max;
char **migrateTrans;
- virCapsHostNUMAPtr numa;
+ virCapsHostNUMA *numa;
- virResctrlInfoPtr resctrl;
+ virResctrlInfo *resctrl;
virCapsHostCache cache;
virCapsHostMemBW memBW;
size_t nsecModels;
- virCapsHostSecModelPtr secModels;
+ virCapsHostSecModel *secModels;
char *netprefix;
- virCPUDefPtr cpu;
+ virCPUDef *cpu;
int nPagesSize; /* size of pagesSize array */
unsigned int *pagesSize; /* page sizes support on the system */
unsigned char host_uuid[VIR_UUID_BUFLEN];
virCapsHost host;
size_t nguests;
size_t nguests_max;
- virCapsGuestPtr *guests;
+ virCapsGuest **guests;
size_t npools;
size_t npools_max;
- virCapsStoragePoolPtr *pools;
+ virCapsStoragePool **pools;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCaps, virObjectUnref);
};
-virCapsPtr
+virCaps *
virCapabilitiesNew(virArch hostarch,
bool offlineMigrate,
bool liveMigrate);
void
-virCapabilitiesHostNUMAUnref(virCapsHostNUMAPtr caps);
+virCapabilitiesHostNUMAUnref(virCapsHostNUMA *caps);
void
-virCapabilitiesHostNUMARef(virCapsHostNUMAPtr caps);
+virCapabilitiesHostNUMARef(virCapsHostNUMA *caps);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCapsHostNUMA, virCapabilitiesHostNUMAUnref);
int
-virCapabilitiesAddHostFeature(virCapsPtr caps,
+virCapabilitiesAddHostFeature(virCaps *caps,
const char *name);
int
-virCapabilitiesAddHostMigrateTransport(virCapsPtr caps,
+virCapabilitiesAddHostMigrateTransport(virCaps *caps,
const char *name);
int
-virCapabilitiesSetNetPrefix(virCapsPtr caps,
+virCapabilitiesSetNetPrefix(virCaps *caps,
const char *prefix);
void
-virCapabilitiesHostNUMAAddCell(virCapsHostNUMAPtr caps,
+virCapabilitiesHostNUMAAddCell(virCapsHostNUMA *caps,
int num,
unsigned long long mem,
int ncpus,
- virCapsHostNUMACellCPUPtr cpus,
+ virCapsHostNUMACellCPU *cpus,
int nsiblings,
- virCapsHostNUMACellSiblingInfoPtr siblings,
+ virCapsHostNUMACellSiblingInfo *siblings,
int npageinfo,
- virCapsHostNUMACellPageInfoPtr pageinfo);
+ virCapsHostNUMACellPageInfo *pageinfo);
-virCapsGuestMachinePtr *
+virCapsGuestMachine **
virCapabilitiesAllocMachines(const char *const *names,
int nnames);
void
-virCapabilitiesFreeMachines(virCapsGuestMachinePtr *machines,
+virCapabilitiesFreeMachines(virCapsGuestMachine **machines,
int nmachines);
void
-virCapabilitiesFreeGuest(virCapsGuestPtr guest);
+virCapabilitiesFreeGuest(virCapsGuest *guest);
-virCapsGuestPtr
-virCapabilitiesAddGuest(virCapsPtr caps,
+virCapsGuest *
+virCapabilitiesAddGuest(virCaps *caps,
int ostype,
virArch arch,
const char *emulator,
const char *loader,
int nmachines,
- virCapsGuestMachinePtr *machines);
+ virCapsGuestMachine **machines);
-virCapsGuestDomainPtr
-virCapabilitiesAddGuestDomain(virCapsGuestPtr guest,
+virCapsGuestDomain *
+virCapabilitiesAddGuestDomain(virCapsGuest *guest,
int hvtype,
const char *emulator,
const char *loader,
int nmachines,
- virCapsGuestMachinePtr *machines);
+ virCapsGuestMachine **machines);
void
-virCapabilitiesAddGuestFeature(virCapsGuestPtr guest,
+virCapabilitiesAddGuestFeature(virCapsGuest *guest,
virCapsGuestFeatureType feature);
void
-virCapabilitiesAddGuestFeatureWithToggle(virCapsGuestPtr guest,
+virCapabilitiesAddGuestFeatureWithToggle(virCapsGuest *guest,
virCapsGuestFeatureType feature,
bool defaultOn,
bool toggle);
int
-virCapabilitiesAddStoragePool(virCapsPtr caps,
+virCapabilitiesAddStoragePool(virCaps *caps,
int poolType);
int
-virCapabilitiesHostSecModelAddBaseLabel(virCapsHostSecModelPtr secmodel,
+virCapabilitiesHostSecModelAddBaseLabel(virCapsHostSecModel *secmodel,
const char *type,
const char *label);
-virCapsDomainDataPtr
-virCapabilitiesDomainDataLookup(virCapsPtr caps,
+virCapsDomainData *
+virCapabilitiesDomainDataLookup(virCaps *caps,
int ostype,
virArch arch,
int domaintype,
const char *machinetype);
bool
-virCapabilitiesDomainSupported(virCapsPtr caps,
+virCapabilitiesDomainSupported(virCaps *caps,
int ostype,
virArch arch,
int domaintype);
void
-virCapabilitiesClearHostNUMACellCPUTopology(virCapsHostNUMACellCPUPtr cpu,
+virCapabilitiesClearHostNUMACellCPUTopology(virCapsHostNUMACellCPU *cpu,
size_t ncpus);
char *
-virCapabilitiesFormatXML(virCapsPtr caps);
+virCapabilitiesFormatXML(virCaps *caps);
-virBitmapPtr virCapabilitiesHostNUMAGetCpus(virCapsHostNUMAPtr caps,
- virBitmapPtr nodemask);
+virBitmap *virCapabilitiesHostNUMAGetCpus(virCapsHostNUMA *caps,
+ virBitmap *nodemask);
int virCapabilitiesGetNodeInfo(virNodeInfoPtr nodeinfo);
-int virCapabilitiesInitPages(virCapsPtr caps);
+int virCapabilitiesInitPages(virCaps *caps);
-virCapsHostNUMAPtr virCapabilitiesHostNUMANew(void);
-virCapsHostNUMAPtr virCapabilitiesHostNUMANewHost(void);
+virCapsHostNUMA *virCapabilitiesHostNUMANew(void);
+virCapsHostNUMA *virCapabilitiesHostNUMANewHost(void);
-bool virCapsHostCacheBankEquals(virCapsHostCacheBankPtr a,
- virCapsHostCacheBankPtr b);
-void virCapsHostCacheBankFree(virCapsHostCacheBankPtr ptr);
+bool virCapsHostCacheBankEquals(virCapsHostCacheBank *a,
+ virCapsHostCacheBank *b);
+void virCapsHostCacheBankFree(virCapsHostCacheBank *ptr);
-int virCapabilitiesInitCaches(virCapsPtr caps);
+int virCapabilitiesInitCaches(virCaps *caps);
-void virCapabilitiesHostInitIOMMU(virCapsPtr caps);
+void virCapabilitiesHostInitIOMMU(virCaps *caps);
VIR_LOG_INIT("conf.checkpoint_conf");
-static virClassPtr virDomainCheckpointDefClass;
+static virClass *virDomainCheckpointDefClass;
static void virDomainCheckpointDefDispose(void *obj);
static int
/* Checkpoint Def functions */
static void
-virDomainCheckpointDiskDefClear(virDomainCheckpointDiskDefPtr disk)
+virDomainCheckpointDiskDefClear(virDomainCheckpointDiskDef *disk)
{
VIR_FREE(disk->name);
VIR_FREE(disk->bitmap);
}
/* Allocate a new virDomainCheckpointDef; free with virObjectUnref() */
-virDomainCheckpointDefPtr
+virDomainCheckpointDef *
virDomainCheckpointDefNew(void)
{
if (virDomainCheckpointInitialize() < 0)
static void
virDomainCheckpointDefDispose(void *obj)
{
- virDomainCheckpointDefPtr def = obj;
+ virDomainCheckpointDef *def = obj;
size_t i;
for (i = 0; i < def->ndisks; i++)
static int
virDomainCheckpointDiskDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainCheckpointDiskDefPtr def)
+ virDomainCheckpointDiskDef *def)
{
g_autofree char *checkpoint = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
/* flags is bitwise-or of virDomainCheckpointParseFlags.
*/
-static virDomainCheckpointDefPtr
+static virDomainCheckpointDef *
virDomainCheckpointDefParse(xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
- virDomainCheckpointDefPtr ret = NULL;
+ virDomainCheckpointDef *ret = NULL;
size_t i;
int n;
g_autofree xmlNodePtr *nodes = NULL;
return ret;
}
-static virDomainCheckpointDefPtr
+static virDomainCheckpointDef *
virDomainCheckpointDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
return virDomainCheckpointDefParse(ctxt, xmlopt, parseOpaque, flags);
}
-virDomainCheckpointDefPtr
+virDomainCheckpointDef *
virDomainCheckpointDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
- virDomainCheckpointDefPtr ret = NULL;
+ virDomainCheckpointDef *ret = NULL;
xmlDocPtr xml;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
* success, -1 on error.
*/
static int
-virDomainCheckpointDefAssignBitmapNames(virDomainCheckpointDefPtr def)
+virDomainCheckpointDefAssignBitmapNames(virDomainCheckpointDef *def)
{
size_t i;
for (i = 0; i < def->ndisks; i++) {
- virDomainCheckpointDiskDefPtr disk = &def->disks[i];
+ virDomainCheckpointDiskDef *disk = &def->disks[i];
if (disk->type != VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP ||
disk->bitmap)
* if any def->disks[n]->name appears more than once or does not map
* to dom->disks. */
int
-virDomainCheckpointAlignDisks(virDomainCheckpointDefPtr chkdef)
+virDomainCheckpointAlignDisks(virDomainCheckpointDef *chkdef)
{
- virDomainDefPtr domdef = chkdef->parent.dom;
+ virDomainDef *domdef = chkdef->parent.dom;
g_autoptr(GHashTable) map = virHashNew(NULL);
- g_autofree virDomainCheckpointDiskDefPtr olddisks = NULL;
+ g_autofree virDomainCheckpointDiskDef *olddisks = NULL;
size_t i;
int checkpoint_default = VIR_DOMAIN_CHECKPOINT_TYPE_NONE;
/* Double check requested disks. */
for (i = 0; i < chkdef->ndisks; i++) {
- virDomainCheckpointDiskDefPtr chkdisk = &chkdef->disks[i];
- virDomainDiskDefPtr domdisk = virDomainDiskByName(domdef, chkdisk->name, false);
+ virDomainCheckpointDiskDef *chkdisk = &chkdef->disks[i];
+ virDomainDiskDef *domdisk = virDomainDiskByName(domdef, chkdisk->name, false);
if (!domdisk) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
chkdef->ndisks = domdef->ndisks;
for (i = 0; i < domdef->ndisks; i++) {
- virDomainDiskDefPtr domdisk = domdef->disks[i];
- virDomainCheckpointDiskDefPtr chkdisk = chkdef->disks + i;
- virDomainCheckpointDiskDefPtr existing;
+ virDomainDiskDef *domdisk = domdef->disks[i];
+ virDomainCheckpointDiskDef *chkdisk = chkdef->disks + i;
+ virDomainCheckpointDiskDef *existing;
/* copy existing disks */
if ((existing = virHashLookup(map, domdisk->dst))) {
static int
-virDomainCheckpointDiskDefFormat(virBufferPtr buf,
- virDomainCheckpointDiskDefPtr disk,
+virDomainCheckpointDiskDefFormat(virBuffer *buf,
+ virDomainCheckpointDiskDef *disk,
unsigned int flags)
{
if (!disk->name)
static int
-virDomainCheckpointDefFormatInternal(virBufferPtr buf,
- virDomainCheckpointDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainCheckpointDefFormatInternal(virBuffer *buf,
+ virDomainCheckpointDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
size_t i;
char *
-virDomainCheckpointDefFormat(virDomainCheckpointDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainCheckpointDefFormat(virDomainCheckpointDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int
-virDomainCheckpointRedefinePrep(virDomainObjPtr vm,
- virDomainCheckpointDefPtr def,
+virDomainCheckpointRedefinePrep(virDomainObj *vm,
+ virDomainCheckpointDef *def,
bool *update_current)
{
- virDomainMomentObjPtr parent = NULL;
+ virDomainMomentObj *parent = NULL;
if (virDomainCheckpointCheckCycles(vm->checkpoints, def, vm->def->name) < 0)
return -1;
}
-virDomainMomentObjPtr
-virDomainCheckpointRedefineCommit(virDomainObjPtr vm,
- virDomainCheckpointDefPtr *defptr)
+virDomainMomentObj *
+virDomainCheckpointRedefineCommit(virDomainObj *vm,
+ virDomainCheckpointDef **defptr)
{
- virDomainCheckpointDefPtr def = *defptr;
- virDomainMomentObjPtr other = NULL;
- virDomainCheckpointDefPtr otherdef = NULL;
- virDomainMomentObjPtr chk = NULL;
+ virDomainCheckpointDef *def = *defptr;
+ virDomainMomentObj *other = NULL;
+ virDomainCheckpointDef *otherdef = NULL;
+ virDomainMomentObj *chk = NULL;
other = virDomainCheckpointFindByName(vm->checkpoints, def->parent.name);
if (other) {
/* Stores disk-checkpoint information */
typedef struct _virDomainCheckpointDiskDef virDomainCheckpointDiskDef;
-typedef virDomainCheckpointDiskDef *virDomainCheckpointDiskDefPtr;
struct _virDomainCheckpointDiskDef {
char *name; /* name matching the <target dev='...' of the domain */
int type; /* virDomainCheckpointType */
unsigned int
virDomainCheckpointFormatConvertXMLFlags(unsigned int flags);
-virDomainCheckpointDefPtr
+virDomainCheckpointDef *
virDomainCheckpointDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags);
-virDomainCheckpointDefPtr
+virDomainCheckpointDef *
virDomainCheckpointDefNew(void);
char *
-virDomainCheckpointDefFormat(virDomainCheckpointDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainCheckpointDefFormat(virDomainCheckpointDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
int
-virDomainCheckpointAlignDisks(virDomainCheckpointDefPtr checkpoint);
+virDomainCheckpointAlignDisks(virDomainCheckpointDef *checkpoint);
int
-virDomainCheckpointRedefinePrep(virDomainObjPtr vm,
- virDomainCheckpointDefPtr def,
+virDomainCheckpointRedefinePrep(virDomainObj *vm,
+ virDomainCheckpointDef *def,
bool *update_current);
-virDomainMomentObjPtr
-virDomainCheckpointRedefineCommit(virDomainObjPtr vm,
- virDomainCheckpointDefPtr *defptr);
+virDomainMomentObj *
+virDomainCheckpointRedefineCommit(virDomainObj *vm,
+ virDomainCheckpointDef **defptr);
VIR_ENUM_DECL(virDomainCheckpoint);
);
-virCPUDefPtr virCPUDefNew(void)
+virCPUDef *virCPUDefNew(void)
{
- virCPUDefPtr cpu = g_new0(virCPUDef, 1);
+ virCPUDef *cpu = g_new0(virCPUDef, 1);
cpu->refs = 1;
return cpu;
}
void
-virCPUDefFreeFeatures(virCPUDefPtr def)
+virCPUDefFreeFeatures(virCPUDef *def)
{
size_t i;
void ATTRIBUTE_NONNULL(1)
-virCPUDefFreeModel(virCPUDefPtr def)
+virCPUDefFreeModel(virCPUDef *def)
{
VIR_FREE(def->model);
VIR_FREE(def->vendor);
}
void
-virCPUDefRef(virCPUDefPtr def)
+virCPUDefRef(virCPUDef *def)
{
g_atomic_int_inc(&def->refs);
}
void
-virCPUDefFree(virCPUDefPtr def)
+virCPUDefFree(virCPUDef *def)
{
if (!def)
return;
int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
-virCPUDefCopyModel(virCPUDefPtr dst,
+virCPUDefCopyModel(virCPUDef *dst,
const virCPUDef *src,
bool resetPolicy)
{
int
-virCPUDefCopyModelFilter(virCPUDefPtr dst,
+virCPUDefCopyModelFilter(virCPUDef *dst,
const virCPUDef *src,
bool resetPolicy,
virCPUDefFeatureFilter filter,
* than overwriting it with the values from @src.
*/
void
-virCPUDefStealModel(virCPUDefPtr dst,
- virCPUDefPtr src,
+virCPUDefStealModel(virCPUDef *dst,
+ virCPUDef *src,
bool keepVendor)
{
char *vendor = NULL;
}
-virCPUDefPtr
+virCPUDef *
virCPUDefCopyWithoutModel(const virCPUDef *cpu)
{
g_autoptr(virCPUDef) copy = NULL;
}
-virCPUDefPtr
+virCPUDef *
virCPUDefCopy(const virCPUDef *cpu)
{
g_autoptr(virCPUDef) copy = NULL;
int
virCPUDefParseXMLString(const char *xml,
virCPUType type,
- virCPUDefPtr *cpu,
+ virCPUDef **cpu,
bool validateXML)
{
xmlDocPtr doc = NULL;
virCPUDefParseXML(xmlXPathContextPtr ctxt,
const char *xpath,
virCPUType type,
- virCPUDefPtr *cpu,
+ virCPUDef **cpu,
bool validateXML)
{
g_autoptr(virCPUDef) def = NULL;
g_autofree char *vendor_id = NULL;
g_autofree char *tscScaling = NULL;
g_autofree char *migratable = NULL;
- g_autofree virHostCPUTscInfoPtr tsc = NULL;
+ g_autofree virHostCPUTscInfo *tsc = NULL;
*cpu = NULL;
char *
-virCPUDefFormat(virCPUDefPtr def,
- virDomainNumaPtr numa)
+virCPUDefFormat(virCPUDef *def,
+ virDomainNuma *numa)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int
-virCPUDefFormatBufFull(virBufferPtr buf,
- virCPUDefPtr def,
- virDomainNumaPtr numa)
+virCPUDefFormatBufFull(virBuffer *buf,
+ virCPUDef *def,
+ virDomainNuma *numa)
{
g_auto(virBuffer) attributeBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
}
int
-virCPUDefFormatBuf(virBufferPtr buf,
- virCPUDefPtr def)
+virCPUDefFormatBuf(virBuffer *buf,
+ virCPUDef *def)
{
size_t i;
bool formatModel;
}
for (i = 0; i < def->nfeatures; i++) {
- virCPUFeatureDefPtr feature = def->features + i;
+ virCPUFeatureDef *feature = def->features + i;
if (!feature->name) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
} virCPUDefAddFeatureMode;
static int
-virCPUDefAddFeatureInternal(virCPUDefPtr def,
+virCPUDefAddFeatureInternal(virCPUDef *def,
const char *name,
int policy,
virCPUDefAddFeatureMode mode)
{
- virCPUFeatureDefPtr feat;
+ virCPUFeatureDef *feat;
if (def->type == VIR_CPU_TYPE_HOST)
policy = -1;
}
int
-virCPUDefUpdateFeature(virCPUDefPtr def,
+virCPUDefUpdateFeature(virCPUDef *def,
const char *name,
int policy)
{
}
int
-virCPUDefAddFeature(virCPUDefPtr def,
+virCPUDefAddFeature(virCPUDef *def,
const char *name,
int policy)
{
int
-virCPUDefAddFeatureIfMissing(virCPUDefPtr def,
+virCPUDefAddFeatureIfMissing(virCPUDef *def,
const char *name,
int policy)
{
}
-virCPUFeatureDefPtr
+virCPUFeatureDef *
virCPUDefFindFeature(const virCPUDef *def,
const char *name)
{
int
-virCPUDefFilterFeatures(virCPUDefPtr cpu,
+virCPUDefFilterFeatures(virCPUDef *cpu,
virCPUDefFeatureFilter filter,
void *opaque)
{
* Returns the number of features matching @filter or -1 on error.
*/
int
-virCPUDefCheckFeatures(virCPUDefPtr cpu,
+virCPUDefCheckFeatures(virCPUDef *cpu,
virCPUDefFeatureFilter filter,
void *opaque,
char ***features)
bool
-virCPUDefIsEqual(virCPUDefPtr src,
- virCPUDefPtr dst,
+virCPUDefIsEqual(virCPUDef *src,
+ virCPUDef *dst,
bool reportError)
{
size_t i;
/*
* Parses a list of CPU XMLs into a NULL-terminated list of CPU defs.
*/
-virCPUDefPtr *
+virCPUDef **
virCPUDefListParse(const char **xmlCPUs,
unsigned int ncpus,
virCPUType cpuType)
{
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
- virCPUDefPtr *cpus = NULL;
+ virCPUDef **cpus = NULL;
size_t i;
VIR_DEBUG("xmlCPUs=%p, ncpus=%u", xmlCPUs, ncpus);
goto error;
}
- cpus = g_new0(virCPUDefPtr, ncpus + 1);
+ cpus = g_new0(virCPUDef *, ncpus + 1);
for (i = 0; i < ncpus; i++) {
if (!(doc = virXMLParseStringCtxt(xmlCPUs[i], _("(CPU_definition)"), &ctxt)))
* Frees NULL-terminated list of CPUs created by virCPUDefListParse.
*/
void
-virCPUDefListFree(virCPUDefPtr *cpus)
+virCPUDefListFree(virCPUDef **cpus)
{
- virCPUDefPtr *cpu;
+ virCPUDef **cpu;
if (!cpus)
return;
VIR_ENUM_DECL(virCPUFeaturePolicy);
typedef struct _virCPUFeatureDef virCPUFeatureDef;
-typedef virCPUFeatureDef *virCPUFeatureDefPtr;
struct _virCPUFeatureDef {
char *name;
int policy; /* enum virCPUFeaturePolicy */
VIR_ENUM_DECL(virCPUCacheMode);
typedef struct _virCPUCacheDef virCPUCacheDef;
-typedef virCPUCacheDef *virCPUCacheDefPtr;
struct _virCPUCacheDef {
int level; /* -1 for unspecified */
virCPUCacheMode mode;
typedef struct _virCPUDef virCPUDef;
-typedef virCPUDef *virCPUDefPtr;
struct _virCPUDef {
int refs;
int type; /* enum virCPUType */
unsigned int threads;
size_t nfeatures;
size_t nfeatures_max;
- virCPUFeatureDefPtr features;
- virCPUCacheDefPtr cache;
- virHostCPUTscInfoPtr tsc;
+ virCPUFeatureDef *features;
+ virCPUCacheDef *cache;
+ virHostCPUTscInfo *tsc;
virTristateSwitch migratable; /* for host-passthrough mode */
};
-virCPUDefPtr virCPUDefNew(void);
+virCPUDef *virCPUDefNew(void);
void ATTRIBUTE_NONNULL(1)
-virCPUDefFreeFeatures(virCPUDefPtr def);
+virCPUDefFreeFeatures(virCPUDef *def);
void ATTRIBUTE_NONNULL(1)
-virCPUDefFreeModel(virCPUDefPtr def);
+virCPUDefFreeModel(virCPUDef *def);
void
-virCPUDefRef(virCPUDefPtr def);
+virCPUDefRef(virCPUDef *def);
void
-virCPUDefFree(virCPUDefPtr def);
+virCPUDefFree(virCPUDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUDef, virCPUDefFree);
int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
-virCPUDefCopyModel(virCPUDefPtr dst,
+virCPUDefCopyModel(virCPUDef *dst,
const virCPUDef *src,
bool resetPolicy);
void *opaque);
int
-virCPUDefCopyModelFilter(virCPUDefPtr dst,
+virCPUDefCopyModelFilter(virCPUDef *dst,
const virCPUDef *src,
bool resetPolicy,
virCPUDefFeatureFilter filter,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void
-virCPUDefStealModel(virCPUDefPtr dst,
- virCPUDefPtr src,
+virCPUDefStealModel(virCPUDef *dst,
+ virCPUDef *src,
bool keepVendor);
-virCPUDefPtr
+virCPUDef *
virCPUDefCopy(const virCPUDef *cpu);
-virCPUDefPtr
+virCPUDef *
virCPUDefCopyWithoutModel(const virCPUDef *cpu);
int
virCPUDefParseXMLString(const char *xml,
virCPUType type,
- virCPUDefPtr *cpu,
+ virCPUDef **cpu,
bool validateXML);
int
virCPUDefParseXML(xmlXPathContextPtr ctxt,
const char *xpath,
virCPUType mode,
- virCPUDefPtr *cpu,
+ virCPUDef **cpu,
bool validateXML);
bool
-virCPUDefIsEqual(virCPUDefPtr src,
- virCPUDefPtr dst,
+virCPUDefIsEqual(virCPUDef *src,
+ virCPUDef *dst,
bool reportError);
char *
-virCPUDefFormat(virCPUDefPtr def,
- virDomainNumaPtr numa);
+virCPUDefFormat(virCPUDef *def,
+ virDomainNuma *numa);
int
-virCPUDefFormatBuf(virBufferPtr buf,
- virCPUDefPtr def);
+virCPUDefFormatBuf(virBuffer *buf,
+ virCPUDef *def);
int
-virCPUDefFormatBufFull(virBufferPtr buf,
- virCPUDefPtr def,
- virDomainNumaPtr numa);
+virCPUDefFormatBufFull(virBuffer *buf,
+ virCPUDef *def,
+ virDomainNuma *numa);
int
-virCPUDefAddFeature(virCPUDefPtr cpu,
+virCPUDefAddFeature(virCPUDef *cpu,
const char *name,
int policy);
int
-virCPUDefUpdateFeature(virCPUDefPtr cpu,
+virCPUDefUpdateFeature(virCPUDef *cpu,
const char *name,
int policy);
int
-virCPUDefAddFeatureIfMissing(virCPUDefPtr def,
+virCPUDefAddFeatureIfMissing(virCPUDef *def,
const char *name,
int policy);
-virCPUFeatureDefPtr
+virCPUFeatureDef *
virCPUDefFindFeature(const virCPUDef *def,
const char *name);
int
-virCPUDefFilterFeatures(virCPUDefPtr cpu,
+virCPUDefFilterFeatures(virCPUDef *cpu,
virCPUDefFeatureFilter filter,
void *opaque);
int
-virCPUDefCheckFeatures(virCPUDefPtr cpu,
+virCPUDefCheckFeatures(virCPUDef *cpu,
virCPUDefFeatureFilter filter,
void *opaque,
char ***features);
-virCPUDefPtr *
+virCPUDef **
virCPUDefListParse(const char **xmlCPUs,
unsigned int ncpus,
virCPUType cpuType);
void
-virCPUDefListFree(virCPUDefPtr *cpus);
+virCPUDefListFree(virCPUDef **cpus);
static int
virZPCIDeviceAddressParseXML(xmlNodePtr node,
- virPCIDeviceAddressPtr addr)
+ virPCIDeviceAddress *addr)
{
virZPCIDeviceAddress def = { .uid = { 0 }, .fid = { 0 } };
g_autofree char *uid = NULL;
}
void
-virDomainDeviceInfoClear(virDomainDeviceInfoPtr info)
+virDomainDeviceInfoClear(virDomainDeviceInfo *info)
{
VIR_FREE(info->alias);
memset(&info->addr, 0, sizeof(info->addr));
}
void
-virDomainDeviceInfoFree(virDomainDeviceInfoPtr info)
+virDomainDeviceInfoFree(virDomainDeviceInfo *info)
{
if (info) {
virDomainDeviceInfoClear(info);
int
virPCIDeviceAddressParseXML(xmlNodePtr node,
- virPCIDeviceAddressPtr addr)
+ virPCIDeviceAddress *addr)
{
xmlNodePtr cur;
xmlNodePtr zpci = NULL;
}
void
-virPCIDeviceAddressFormat(virBufferPtr buf,
+virPCIDeviceAddressFormat(virBuffer *buf,
virPCIDeviceAddress addr,
bool includeTypeInAddr)
{
}
bool
-virDomainDeviceCCWAddressIsValid(virDomainDeviceCCWAddressPtr addr)
+virDomainDeviceCCWAddressIsValid(virDomainDeviceCCWAddress *addr)
{
return addr->cssid <= VIR_DOMAIN_DEVICE_CCW_MAX_CSSID &&
addr->ssid <= VIR_DOMAIN_DEVICE_CCW_MAX_SSID &&
int
virDomainDeviceCCWAddressParseXML(xmlNodePtr node,
- virDomainDeviceCCWAddressPtr addr)
+ virDomainDeviceCCWAddress *addr)
{
g_autofree char *cssid = virXMLPropString(node, "cssid");
g_autofree char *ssid = virXMLPropString(node, "ssid");
}
bool
-virDomainDeviceCCWAddressEqual(virDomainDeviceCCWAddressPtr addr1,
- virDomainDeviceCCWAddressPtr addr2)
+virDomainDeviceCCWAddressEqual(virDomainDeviceCCWAddress *addr1,
+ virDomainDeviceCCWAddress *addr2)
{
if (addr1->cssid == addr2->cssid &&
addr1->ssid == addr2->ssid &&
int
virDomainDeviceDriveAddressParseXML(xmlNodePtr node,
- virDomainDeviceDriveAddressPtr addr)
+ virDomainDeviceDriveAddress *addr)
{
g_autofree char *controller = virXMLPropString(node, "controller");
g_autofree char *bus = virXMLPropString(node, "bus");
int
virDomainDeviceVirtioSerialAddressParseXML(xmlNodePtr node,
- virDomainDeviceVirtioSerialAddressPtr addr)
+ virDomainDeviceVirtioSerialAddress *addr)
{
g_autofree char *controller = virXMLPropString(node, "controller");
g_autofree char *bus = virXMLPropString(node, "bus");
int
virDomainDeviceCcidAddressParseXML(xmlNodePtr node,
- virDomainDeviceCcidAddressPtr addr)
+ virDomainDeviceCcidAddress *addr)
{
g_autofree char *controller = virXMLPropString(node, "controller");
g_autofree char *slot = virXMLPropString(node, "slot");
}
static int
-virDomainDeviceUSBAddressParsePort(virDomainDeviceUSBAddressPtr addr,
+virDomainDeviceUSBAddressParsePort(virDomainDeviceUSBAddress *addr,
char *port)
{
char *tmp = port;
int
virDomainDeviceUSBAddressParseXML(xmlNodePtr node,
- virDomainDeviceUSBAddressPtr addr)
+ virDomainDeviceUSBAddress *addr)
{
g_autofree char *port = virXMLPropString(node, "port");
g_autofree char *bus = virXMLPropString(node, "bus");
int
virDomainDeviceSpaprVioAddressParseXML(xmlNodePtr node,
- virDomainDeviceSpaprVioAddressPtr addr)
+ virDomainDeviceSpaprVioAddress *addr)
{
g_autofree char *reg = virXMLPropString(node, "reg");
}
bool
-virDomainDeviceAddressIsValid(virDomainDeviceInfoPtr info,
+virDomainDeviceAddressIsValid(virDomainDeviceInfo *info,
int type)
{
if (info->type != type)
int
virInterfaceLinkParseXML(xmlNodePtr node,
- virNetDevIfLinkPtr lnk)
+ virNetDevIfLink *lnk)
{
int state;
}
int
-virInterfaceLinkFormat(virBufferPtr buf,
+virInterfaceLinkFormat(virBuffer *buf,
const virNetDevIfLink *lnk)
{
if (!lnk->speed && !lnk->state) {
VIR_ENUM_DECL(virDomainDeviceAddress);
typedef struct _virDomainDeviceDriveAddress virDomainDeviceDriveAddress;
-typedef virDomainDeviceDriveAddress *virDomainDeviceDriveAddressPtr;
struct _virDomainDeviceDriveAddress {
unsigned int controller;
unsigned int bus;
};
typedef struct _virDomainDeviceVirtioSerialAddress virDomainDeviceVirtioSerialAddress;
-typedef virDomainDeviceVirtioSerialAddress *virDomainDeviceVirtioSerialAddressPtr;
struct _virDomainDeviceVirtioSerialAddress {
unsigned int controller;
unsigned int bus;
#define VIR_DOMAIN_DEVICE_CCW_MAX_DEVNO 65535
typedef struct _virDomainDeviceCCWAddress virDomainDeviceCCWAddress;
-typedef virDomainDeviceCCWAddress *virDomainDeviceCCWAddressPtr;
struct _virDomainDeviceCCWAddress {
unsigned int cssid;
unsigned int ssid;
};
typedef struct _virDomainDeviceCcidAddress virDomainDeviceCcidAddress;
-typedef virDomainDeviceCcidAddress *virDomainDeviceCcidAddressPtr;
struct _virDomainDeviceCcidAddress {
unsigned int controller;
unsigned int slot;
#define VIR_DOMAIN_DEVICE_USB_MAX_PORT_DEPTH 4
typedef struct _virDomainDeviceUSBAddress virDomainDeviceUSBAddress;
-typedef virDomainDeviceUSBAddress *virDomainDeviceUSBAddressPtr;
struct _virDomainDeviceUSBAddress {
unsigned int bus;
unsigned int port[VIR_DOMAIN_DEVICE_USB_MAX_PORT_DEPTH];
};
typedef struct _virDomainDeviceSpaprVioAddress virDomainDeviceSpaprVioAddress;
-typedef virDomainDeviceSpaprVioAddress *virDomainDeviceSpaprVioAddressPtr;
struct _virDomainDeviceSpaprVioAddress {
unsigned long long reg;
bool has_reg;
} virDomainControllerMaster;
typedef struct _virDomainDeviceUSBMaster virDomainDeviceUSBMaster;
-typedef virDomainDeviceUSBMaster *virDomainDeviceUSBMasterPtr;
struct _virDomainDeviceUSBMaster {
unsigned int startport;
};
typedef struct _virDomainDeviceISAAddress virDomainDeviceISAAddress;
-typedef virDomainDeviceISAAddress *virDomainDeviceISAAddressPtr;
struct _virDomainDeviceISAAddress {
unsigned int iobase;
unsigned int irq;
};
typedef struct _virDomainDeviceDimmAddress virDomainDeviceDimmAddress;
-typedef virDomainDeviceDimmAddress *virDomainDeviceDimmAddressPtr;
struct _virDomainDeviceDimmAddress {
unsigned int slot;
unsigned long long base;
};
typedef struct _virDomainDeviceInfo virDomainDeviceInfo;
-typedef virDomainDeviceInfo *virDomainDeviceInfoPtr;
struct _virDomainDeviceInfo {
char *alias;
int type; /* virDomainDeviceAddressType */
bool isolationGroupLocked;
};
-void virDomainDeviceInfoClear(virDomainDeviceInfoPtr info);
-void virDomainDeviceInfoFree(virDomainDeviceInfoPtr info);
+void virDomainDeviceInfoClear(virDomainDeviceInfo *info);
+void virDomainDeviceInfoFree(virDomainDeviceInfo *info);
bool virDomainDeviceInfoAddressIsEqual(const virDomainDeviceInfo *a,
const virDomainDeviceInfo *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-bool virDomainDeviceAddressIsValid(virDomainDeviceInfoPtr info,
+bool virDomainDeviceAddressIsValid(virDomainDeviceInfo *info,
int type);
bool virDeviceInfoPCIAddressIsWanted(const virDomainDeviceInfo *info);
bool virDeviceInfoPCIAddressExtensionIsPresent(const virDomainDeviceInfo *info);
int virPCIDeviceAddressParseXML(xmlNodePtr node,
- virPCIDeviceAddressPtr addr);
+ virPCIDeviceAddress *addr);
-void virPCIDeviceAddressFormat(virBufferPtr buf,
+void virPCIDeviceAddressFormat(virBuffer *buf,
virPCIDeviceAddress addr,
bool includeTypeInAddr);
-bool virDomainDeviceCCWAddressIsValid(virDomainDeviceCCWAddressPtr addr);
+bool virDomainDeviceCCWAddressIsValid(virDomainDeviceCCWAddress *addr);
int virDomainDeviceCCWAddressParseXML(xmlNodePtr node,
- virDomainDeviceCCWAddressPtr addr);
-bool virDomainDeviceCCWAddressEqual(virDomainDeviceCCWAddressPtr addr1,
- virDomainDeviceCCWAddressPtr addr2);
+ virDomainDeviceCCWAddress *addr);
+bool virDomainDeviceCCWAddressEqual(virDomainDeviceCCWAddress *addr1,
+ virDomainDeviceCCWAddress *addr2);
#define VIR_CCW_DEVICE_ADDRESS_FMT "%x.%x.%04x"
int virDomainDeviceDriveAddressParseXML(xmlNodePtr node,
- virDomainDeviceDriveAddressPtr addr);
+ virDomainDeviceDriveAddress *addr);
int virDomainDeviceVirtioSerialAddressParseXML(xmlNodePtr node,
- virDomainDeviceVirtioSerialAddressPtr addr);
+ virDomainDeviceVirtioSerialAddress *addr);
int virDomainDeviceCcidAddressParseXML(xmlNodePtr node,
- virDomainDeviceCcidAddressPtr addr);
+ virDomainDeviceCcidAddress *addr);
int virDomainDeviceUSBAddressParseXML(xmlNodePtr node,
- virDomainDeviceUSBAddressPtr addr);
+ virDomainDeviceUSBAddress *addr);
int virDomainDeviceSpaprVioAddressParseXML(xmlNodePtr node,
- virDomainDeviceSpaprVioAddressPtr addr);
+ virDomainDeviceSpaprVioAddress *addr);
int virInterfaceLinkParseXML(xmlNodePtr node,
- virNetDevIfLinkPtr lnk);
+ virNetDevIfLink *lnk);
-int virInterfaceLinkFormat(virBufferPtr buf,
+int virInterfaceLinkFormat(virBuffer *buf,
const virNetDevIfLink *lnk);
static int
virDomainZPCIAddressReserveUid(GHashTable *set,
- virZPCIDeviceAddressPtr addr)
+ virZPCIDeviceAddress *addr)
{
return virDomainZPCIAddressReserveId(set, &addr->uid, "uid");
}
static int
virDomainZPCIAddressReserveFid(GHashTable *set,
- virZPCIDeviceAddressPtr addr)
+ virZPCIDeviceAddress *addr)
{
return virDomainZPCIAddressReserveId(set, &addr->fid, "fid");
}
static int
virDomainZPCIAddressAssignUid(GHashTable *set,
- virZPCIDeviceAddressPtr addr)
+ virZPCIDeviceAddress *addr)
{
return virDomainZPCIAddressAssignId(set, &addr->uid, 1,
VIR_DOMAIN_DEVICE_ZPCI_MAX_UID, "uid");
static int
virDomainZPCIAddressAssignFid(GHashTable *set,
- virZPCIDeviceAddressPtr addr)
+ virZPCIDeviceAddress *addr)
{
return virDomainZPCIAddressAssignId(set, &addr->fid, 0,
VIR_DOMAIN_DEVICE_ZPCI_MAX_FID, "fid");
static void
-virDomainZPCIAddressReleaseIds(virDomainZPCIAddressIdsPtr zpciIds,
- virZPCIDeviceAddressPtr addr)
+virDomainZPCIAddressReleaseIds(virDomainZPCIAddressIds *zpciIds,
+ virZPCIDeviceAddress *addr)
{
if (!zpciIds)
return;
static int
-virDomainZPCIAddressEnsureAddr(virDomainZPCIAddressIdsPtr zpciIds,
- virZPCIDeviceAddressPtr addr)
+virDomainZPCIAddressEnsureAddr(virDomainZPCIAddressIds *zpciIds,
+ virZPCIDeviceAddress *addr)
{
if (virDomainZPCIAddressAssignUid(zpciIds->uids, addr) < 0)
return -1;
int
-virDomainPCIAddressExtensionReserveAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressExtensionReserveAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
if (addr->extFlags & VIR_PCI_ADDRESS_EXTENSION_ZPCI) {
/* Reserve uid/fid to ZPCI device which has defined uid/fid
int
-virDomainPCIAddressExtensionReserveNextAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressExtensionReserveNextAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
if (addr->extFlags & VIR_PCI_ADDRESS_EXTENSION_ZPCI) {
virZPCIDeviceAddress zpci = addr->zpci;
static int
-virDomainPCIAddressExtensionEnsureAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressExtensionEnsureAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
if (addr->extFlags & VIR_PCI_ADDRESS_EXTENSION_ZPCI) {
- virZPCIDeviceAddressPtr zpci = &addr->zpci;
+ virZPCIDeviceAddress *zpci = &addr->zpci;
if (virDomainZPCIAddressEnsureAddr(addrs->zpciIds, zpci) < 0)
return -1;
static bool
-virDomainPCIAddressFlagsCompatible(virPCIDeviceAddressPtr addr,
+virDomainPCIAddressFlagsCompatible(virPCIDeviceAddress *addr,
const char *addrStr,
virDomainPCIConnectFlags busFlags,
virDomainPCIConnectFlags devFlags,
* comparing the flags).
*/
bool
-virDomainPCIAddressValidate(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+virDomainPCIAddressValidate(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
const char *addrStr,
virDomainPCIConnectFlags flags,
bool fromConfig)
{
- virDomainPCIAddressBusPtr bus;
+ virDomainPCIAddressBus *bus;
virErrorNumber errType = (fromConfig
? VIR_ERR_XML_ERROR : VIR_ERR_INTERNAL_ERROR);
int
-virDomainPCIAddressBusSetModel(virDomainPCIAddressBusPtr bus,
+virDomainPCIAddressBusSetModel(virDomainPCIAddressBus *bus,
virDomainControllerModelPCI model,
bool allowHotplug)
{
bool
-virDomainPCIAddressBusIsFullyReserved(virDomainPCIAddressBusPtr bus)
+virDomainPCIAddressBusIsFullyReserved(virDomainPCIAddressBus *bus)
{
size_t i;
static bool ATTRIBUTE_NONNULL(1)
-virDomainPCIAddressBusIsEmpty(virDomainPCIAddressBusPtr bus)
+virDomainPCIAddressBusIsEmpty(virDomainPCIAddressBus *bus)
{
size_t i;
* >0 = number of buses added
*/
static int
-virDomainPCIAddressSetGrow(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+virDomainPCIAddressSetGrow(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
virDomainPCIConnectFlags flags)
{
int add;
* Check if the PCI slot is used by another device.
*/
bool
-virDomainPCIAddressSlotInUse(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressSlotInUse(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
return !!addrs->buses[addr->bus].slot[addr->slot].functions;
}
* XML).
*/
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
-virDomainPCIAddressReserveAddrInternal(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+virDomainPCIAddressReserveAddrInternal(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
virDomainPCIConnectFlags flags,
unsigned int isolationGroup,
bool fromConfig)
{
g_autofree char *addrStr = NULL;
- virDomainPCIAddressBusPtr bus;
+ virDomainPCIAddressBus *bus;
virErrorNumber errType = (fromConfig
? VIR_ERR_XML_ERROR : VIR_ERR_INTERNAL_ERROR);
int
-virDomainPCIAddressReserveAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+virDomainPCIAddressReserveAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
virDomainPCIConnectFlags flags,
unsigned int isolationGroup)
{
}
int
-virDomainPCIAddressEnsureAddr(virDomainPCIAddressSetPtr addrs,
- virDomainDeviceInfoPtr dev,
+virDomainPCIAddressEnsureAddr(virDomainPCIAddressSet *addrs,
+ virDomainDeviceInfo *dev,
virDomainPCIConnectFlags flags)
{
g_autofree char *addrStr = NULL;
void
-virDomainPCIAddressExtensionReleaseAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressExtensionReleaseAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
if (addr->extFlags & VIR_PCI_ADDRESS_EXTENSION_ZPCI)
virDomainZPCIAddressReleaseIds(addrs->zpciIds, &addr->zpci);
void
-virDomainPCIAddressReleaseAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+virDomainPCIAddressReleaseAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
{
addrs->buses[addr->bus].slot[addr->slot].functions &= ~(1 << addr->function);
}
static void
-virDomainPCIAddressSetExtensionFree(virDomainZPCIAddressIdsPtr zpciIds)
+virDomainPCIAddressSetExtensionFree(virDomainZPCIAddressIds *zpciIds)
{
if (!zpciIds)
return;
static int
-virDomainPCIAddressSetExtensionAlloc(virDomainPCIAddressSetPtr addrs,
+virDomainPCIAddressSetExtensionAlloc(virDomainPCIAddressSet *addrs,
virPCIDeviceAddressExtensionFlags extFlags)
{
if (extFlags & VIR_PCI_ADDRESS_EXTENSION_ZPCI) {
}
-virDomainPCIAddressSetPtr
+virDomainPCIAddressSet *
virDomainPCIAddressSetAlloc(unsigned int nbuses,
virPCIDeviceAddressExtensionFlags extFlags)
{
- virDomainPCIAddressSetPtr addrs;
+ virDomainPCIAddressSet *addrs;
addrs = g_new0(virDomainPCIAddressSet, 1);
addrs->buses = g_new0(virDomainPCIAddressBus, nbuses);
void
-virDomainPCIAddressSetFree(virDomainPCIAddressSetPtr addrs)
+virDomainPCIAddressSetFree(virDomainPCIAddressSet *addrs)
{
if (!addrs)
return;
static int
-virDomainPCIAddressFindUnusedFunctionOnBus(virDomainPCIAddressBusPtr bus,
- virPCIDeviceAddressPtr searchAddr,
+virDomainPCIAddressFindUnusedFunctionOnBus(virDomainPCIAddressBus *bus,
+ virPCIDeviceAddress *searchAddr,
int function,
virDomainPCIConnectFlags flags,
bool *found)
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
-virDomainPCIAddressGetNextAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr next_addr,
+virDomainPCIAddressGetNextAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *next_addr,
virDomainPCIConnectFlags flags,
unsigned int isolationGroup,
int function)
* don't match. This ensures all devices sharing the same isolation
* group will end up on the same bus */
for (a.bus = 0; a.bus < addrs->nbuses; a.bus++) {
- virDomainPCIAddressBusPtr bus = &addrs->buses[a.bus];
+ virDomainPCIAddressBus *bus = &addrs->buses[a.bus];
bool found = false;
if (bus->isolationGroup != isolationGroup)
* might still be able to make this work by altering the isolation
* group for a bus that's currently empty. So let's try that */
for (a.bus = 0; a.bus < addrs->nbuses; a.bus++) {
- virDomainPCIAddressBusPtr bus = &addrs->buses[a.bus];
+ virDomainPCIAddressBus *bus = &addrs->buses[a.bus];
bool found = false;
/* We can only change the isolation group for a bus when
* returns 0 on success, or -1 on failure.
*/
int
-virDomainPCIAddressReserveNextAddr(virDomainPCIAddressSetPtr addrs,
- virDomainDeviceInfoPtr dev,
+virDomainPCIAddressReserveNextAddr(virDomainPCIAddressSet *addrs,
+ virDomainDeviceInfo *dev,
virDomainPCIConnectFlags flags,
int function)
{
static int
-virDomainPCIAddressSetMultiIter(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainPCIAddressSetMultiIter(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data)
{
- virPCIDeviceAddressPtr testAddr = data;
- virPCIDeviceAddressPtr thisAddr;
+ virPCIDeviceAddress *testAddr = data;
+ virPCIDeviceAddress *thisAddr;
if (!info || info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
return 0;
static int
-virDomainPCIAddressSetAllMultiIter(virDomainDefPtr def,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainPCIAddressSetAllMultiIter(virDomainDef *def,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data G_GNUC_UNUSED)
{
- virPCIDeviceAddressPtr testAddr;
+ virPCIDeviceAddress *testAddr;
if (!info || info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
return 0;
* No return code, since there is no possibility of failure.
*/
void
-virDomainPCIAddressSetAllMulti(virDomainDefPtr def)
+virDomainPCIAddressSetAllMulti(virDomainDef *def)
{
/* Use nested iterators over all the devices - the outer iterator
* scans through all the devices looking for those whose address
char*
-virDomainCCWAddressAsString(virDomainDeviceCCWAddressPtr addr)
+virDomainCCWAddressAsString(virDomainDeviceCCWAddress *addr)
{
return g_strdup_printf("%x.%x.%04x", addr->cssid, addr->ssid, addr->devno);
}
static int
-virDomainCCWAddressIncrement(virDomainDeviceCCWAddressPtr addr)
+virDomainCCWAddressIncrement(virDomainDeviceCCWAddress *addr)
{
virDomainDeviceCCWAddress ccwaddr = *addr;
int
-virDomainCCWAddressAssign(virDomainDeviceInfoPtr dev,
- virDomainCCWAddressSetPtr addrs,
+virDomainCCWAddressAssign(virDomainDeviceInfo *dev,
+ virDomainCCWAddressSet *addrs,
bool autoassign)
{
g_autofree char *addr = NULL;
}
static int ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-virDomainCCWAddressAllocate(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainCCWAddressAllocate(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data)
{
return virDomainCCWAddressAssign(info, data, true);
}
static int ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-virDomainCCWAddressValidate(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainCCWAddressValidate(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data)
{
return virDomainCCWAddressAssign(info, data, false);
}
-void virDomainCCWAddressSetFree(virDomainCCWAddressSetPtr addrs)
+void virDomainCCWAddressSetFree(virDomainCCWAddressSet *addrs)
{
if (!addrs)
return;
g_free(addrs);
}
-static virDomainCCWAddressSetPtr
+static virDomainCCWAddressSet *
virDomainCCWAddressSetCreate(void)
{
- virDomainCCWAddressSetPtr addrs = NULL;
+ virDomainCCWAddressSet *addrs = NULL;
addrs = g_new0(virDomainCCWAddressSet, 1);
}
-virDomainCCWAddressSetPtr
-virDomainCCWAddressSetCreateFromDomain(virDomainDefPtr def)
+virDomainCCWAddressSet *
+virDomainCCWAddressSetCreateFromDomain(virDomainDef *def)
{
- virDomainCCWAddressSetPtr addrs = NULL;
+ virDomainCCWAddressSet *addrs = NULL;
if (!(addrs = virDomainCCWAddressSetCreate()))
goto error;
*
* Allocates an address set for virtio serial addresses
*/
-static virDomainVirtioSerialAddrSetPtr
+static virDomainVirtioSerialAddrSet *
virDomainVirtioSerialAddrSetCreate(void)
{
- virDomainVirtioSerialAddrSetPtr ret = NULL;
+ virDomainVirtioSerialAddrSet *ret = NULL;
ret = g_new0(virDomainVirtioSerialAddrSet, 1);
}
static void
-virDomainVirtioSerialControllerFree(virDomainVirtioSerialControllerPtr cont)
+virDomainVirtioSerialControllerFree(virDomainVirtioSerialController *cont)
{
if (cont) {
virBitmapFree(cont->ports);
}
static ssize_t
-virDomainVirtioSerialAddrPlaceController(virDomainVirtioSerialAddrSetPtr addrs,
- virDomainVirtioSerialControllerPtr cont)
+virDomainVirtioSerialAddrPlaceController(virDomainVirtioSerialAddrSet *addrs,
+ virDomainVirtioSerialController *cont)
{
size_t i;
}
static ssize_t
-virDomainVirtioSerialAddrFindController(virDomainVirtioSerialAddrSetPtr addrs,
+virDomainVirtioSerialAddrFindController(virDomainVirtioSerialAddrSet *addrs,
unsigned int idx)
{
size_t i;
* to the address set.
*/
static int
-virDomainVirtioSerialAddrSetAddController(virDomainVirtioSerialAddrSetPtr addrs,
- virDomainControllerDefPtr cont)
+virDomainVirtioSerialAddrSetAddController(virDomainVirtioSerialAddrSet *addrs,
+ virDomainControllerDef *cont)
{
int ret = -1;
int ports;
- virDomainVirtioSerialControllerPtr cnt = NULL;
+ virDomainVirtioSerialController *cnt = NULL;
ssize_t insertAt;
if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL)
* to the address set.
*/
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
-virDomainVirtioSerialAddrSetAddControllers(virDomainVirtioSerialAddrSetPtr addrs,
- virDomainDefPtr def)
+virDomainVirtioSerialAddrSetAddControllers(virDomainVirtioSerialAddrSet *addrs,
+ virDomainDef *def)
{
size_t i;
void
-virDomainVirtioSerialAddrSetFree(virDomainVirtioSerialAddrSetPtr addrs)
+virDomainVirtioSerialAddrSetFree(virDomainVirtioSerialAddrSet *addrs)
{
size_t i;
if (addrs) {
* opaque should be the address set
*/
static int ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-virDomainVirtioSerialAddrReserve(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrReserve(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data)
{
- virDomainVirtioSerialAddrSetPtr addrs = data;
- virBitmapPtr map = NULL;
+ virDomainVirtioSerialAddrSet *addrs = data;
+ virBitmap *map = NULL;
bool b;
ssize_t i;
* Inspect the domain definition and return an address set containing
* every virtio serial address we find
*/
-virDomainVirtioSerialAddrSetPtr
-virDomainVirtioSerialAddrSetCreateFromDomain(virDomainDefPtr def)
+virDomainVirtioSerialAddrSet *
+virDomainVirtioSerialAddrSetCreateFromDomain(virDomainDef *def)
{
- virDomainVirtioSerialAddrSetPtr addrs = NULL;
- virDomainVirtioSerialAddrSetPtr ret = NULL;
+ virDomainVirtioSerialAddrSet *addrs = NULL;
+ virDomainVirtioSerialAddrSet *ret = NULL;
if (!(addrs = virDomainVirtioSerialAddrSetCreate()))
goto cleanup;
}
static int
-virDomainVirtioSerialAddrSetAutoaddController(virDomainDefPtr def,
- virDomainVirtioSerialAddrSetPtr addrs,
+virDomainVirtioSerialAddrSetAutoaddController(virDomainDef *def,
+ virDomainVirtioSerialAddrSet *addrs,
unsigned int idx)
{
int contidx;
}
static int
-virDomainVirtioSerialAddrNext(virDomainDefPtr def,
- virDomainVirtioSerialAddrSetPtr addrs,
+virDomainVirtioSerialAddrNext(virDomainDef *def,
+ virDomainVirtioSerialAddrSet *addrs,
virDomainDeviceVirtioSerialAddress *addr,
bool allowZero)
{
}
for (i = 0; i < addrs->ncontrollers; i++) {
- virBitmapPtr map = addrs->controllers[i]->ports;
+ virBitmap *map = addrs->controllers[i]->ports;
if ((port = virBitmapNextClearBit(map, startPort)) >= 0) {
controller = addrs->controllers[i]->idx;
goto success;
}
static int
-virDomainVirtioSerialAddrNextFromController(virDomainVirtioSerialAddrSetPtr addrs,
+virDomainVirtioSerialAddrNextFromController(virDomainVirtioSerialAddrSet *addrs,
virDomainDeviceVirtioSerialAddress *addr)
{
ssize_t port;
ssize_t i;
- virBitmapPtr map;
+ virBitmap *map;
i = virDomainVirtioSerialAddrFindController(addrs, addr->controller);
if (i < 0) {
}
static int ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
-virDomainVirtioSerialAddrAssign(virDomainDefPtr def,
- virDomainVirtioSerialAddrSetPtr addrs,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrAssign(virDomainDef *def,
+ virDomainVirtioSerialAddrSet *addrs,
+ virDomainDeviceInfo *info,
bool allowZero,
bool portOnly)
{
virDomainDeviceInfo nfo = { 0 };
- virDomainDeviceInfoPtr ptr = allowZero ? &nfo : info;
+ virDomainDeviceInfo *ptr = allowZero ? &nfo : info;
ptr->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL;
* or assign a virtio serial address to the device
*/
int
-virDomainVirtioSerialAddrAutoAssignFromCache(virDomainDefPtr def,
- virDomainVirtioSerialAddrSetPtr addrs,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrAutoAssignFromCache(virDomainDef *def,
+ virDomainVirtioSerialAddrSet *addrs,
+ virDomainDeviceInfo *info,
bool allowZero)
{
bool portOnly = info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL;
}
int
-virDomainVirtioSerialAddrAutoAssign(virDomainDefPtr def,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrAutoAssign(virDomainDef *def,
+ virDomainDeviceInfo *info,
bool allowZero)
{
- virDomainVirtioSerialAddrSetPtr addrs = NULL;
+ virDomainVirtioSerialAddrSet *addrs = NULL;
int ret = -1;
if (!(addrs = virDomainVirtioSerialAddrSetCreateFromDomain(def)))
* Check if the address is complete, or it needs auto-assignment
*/
bool
-virDomainVirtioSerialAddrIsComplete(virDomainDeviceInfoPtr info)
+virDomainVirtioSerialAddrIsComplete(virDomainDeviceInfo *info)
{
return info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
info->addr.vioserial.port != 0;
void
-virDomainUSBAddressPortFormatBuf(virBufferPtr buf,
+virDomainUSBAddressPortFormatBuf(virBuffer *buf,
unsigned int *port)
{
size_t i;
}
-virDomainUSBAddressSetPtr
+virDomainUSBAddressSet *
virDomainUSBAddressSetCreate(void)
{
- virDomainUSBAddressSetPtr addrs;
+ virDomainUSBAddressSet *addrs;
addrs = g_new0(virDomainUSBAddressSet, 1);
static void
-virDomainUSBAddressHubFree(virDomainUSBAddressHubPtr hub)
+virDomainUSBAddressHubFree(virDomainUSBAddressHub *hub)
{
size_t i;
void
-virDomainUSBAddressSetFree(virDomainUSBAddressSetPtr addrs)
+virDomainUSBAddressSetFree(virDomainUSBAddressSet *addrs)
{
size_t i;
static size_t
-virDomainUSBAddressControllerModelToPorts(virDomainControllerDefPtr cont)
+virDomainUSBAddressControllerModelToPorts(virDomainControllerDef *cont)
{
switch ((virDomainControllerModelUSB) cont->model) {
case VIR_DOMAIN_CONTROLLER_MODEL_USB_DEFAULT:
}
-static virDomainUSBAddressHubPtr
+static virDomainUSBAddressHub *
virDomainUSBAddressHubNew(size_t nports)
{
- virDomainUSBAddressHubPtr hub;
+ virDomainUSBAddressHub *hub;
hub = g_new0(virDomainUSBAddressHub, 1);
hub->portmap = virBitmapNew(nports);
- hub->ports = g_new0(virDomainUSBAddressHubPtr, nports);
+ hub->ports = g_new0(virDomainUSBAddressHub *, nports);
hub->nports = nports;
return hub;
static int
-virDomainUSBAddressSetAddController(virDomainUSBAddressSetPtr addrs,
- virDomainControllerDefPtr cont)
+virDomainUSBAddressSetAddController(virDomainUSBAddressSet *addrs,
+ virDomainControllerDef *cont)
{
size_t nports = virDomainUSBAddressControllerModelToPorts(cont);
- virDomainUSBAddressHubPtr hub = NULL;
+ virDomainUSBAddressHub *hub = NULL;
int ret = -1;
VIR_DEBUG("Adding a USB controller model=%s with %zu ports",
static ssize_t
-virDomainUSBAddressGetLastIdx(virDomainDeviceInfoPtr info)
+virDomainUSBAddressGetLastIdx(virDomainDeviceInfo *info)
{
ssize_t i;
for (i = VIR_DOMAIN_DEVICE_USB_MAX_PORT_DEPTH - 1; i > 0; i--) {
* that corresponds to the bus/port path specified by info.
* Returns the index of the requested port in targetIdx.
*/
-static virDomainUSBAddressHubPtr
-virDomainUSBAddressFindPort(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info,
+static virDomainUSBAddressHub *
+virDomainUSBAddressFindPort(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info,
int *targetIdx,
const char *portStr)
{
- virDomainUSBAddressHubPtr hub = NULL;
+ virDomainUSBAddressHub *hub = NULL;
ssize_t i, lastIdx, targetPort;
if (info->addr.usb.bus >= addrs->nbuses ||
int
-virDomainUSBAddressSetAddHub(virDomainUSBAddressSetPtr addrs,
- virDomainHubDefPtr hub)
+virDomainUSBAddressSetAddHub(virDomainUSBAddressSet *addrs,
+ virDomainHubDef *hub)
{
- virDomainUSBAddressHubPtr targetHub = NULL;
- virDomainUSBAddressHubPtr newHub = NULL;
+ virDomainUSBAddressHub *targetHub = NULL;
+ virDomainUSBAddressHub *newHub = NULL;
int ret = -1;
int targetPort;
g_autofree char *portStr = NULL;
int
-virDomainUSBAddressSetAddControllers(virDomainUSBAddressSetPtr addrs,
- virDomainDefPtr def)
+virDomainUSBAddressSetAddControllers(virDomainUSBAddressSet *addrs,
+ virDomainDef *def)
{
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
if (virDomainUSBAddressSetAddController(addrs, cont) < 0)
return -1;
}
for (i = 0; i < def->nhubs; i++) {
- virDomainHubDefPtr hub = def->hubs[i];
+ virDomainHubDef *hub = def->hubs[i];
if (hub->type == VIR_DOMAIN_HUB_TYPE_USB &&
hub->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB &&
virDomainUSBAddressPortIsValid(hub->info.addr.usb.port)) {
static int
-virDomainUSBAddressFindFreePort(virDomainUSBAddressHubPtr hub,
+virDomainUSBAddressFindFreePort(virDomainUSBAddressHub *hub,
unsigned int *portpath,
unsigned int level)
{
size_t
-virDomainUSBAddressCountAllPorts(virDomainDefPtr def)
+virDomainUSBAddressCountAllPorts(virDomainDef *def)
{
size_t i, ret = 0;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB)
ret += virDomainUSBAddressControllerModelToPorts(cont);
}
for (i = 0; i < def->nhubs; i++) {
- virDomainHubDefPtr hub = def->hubs[i];
+ virDomainHubDef *hub = def->hubs[i];
if (hub->type == VIR_DOMAIN_HUB_TYPE_USB)
ret += VIR_DOMAIN_USB_HUB_PORTS;
}
* -2 if there is no bus at @bus or no free port on this bus
*/
static int
-virDomainUSBAddressAssignFromBus(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info,
+virDomainUSBAddressAssignFromBus(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info,
size_t bus)
{
unsigned int portpath[VIR_DOMAIN_DEVICE_USB_MAX_PORT_DEPTH] = { 0 };
- virDomainUSBAddressHubPtr hub = addrs->buses[bus];
+ virDomainUSBAddressHub *hub = addrs->buses[bus];
g_autofree char *portStr = NULL;
if (!hub)
int
-virDomainUSBAddressAssign(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressAssign(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
{
size_t i;
int rc;
int
-virDomainUSBAddressPresent(virDomainDeviceInfoPtr info,
+virDomainUSBAddressPresent(virDomainDeviceInfo *info,
void *data G_GNUC_UNUSED)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB &&
int
-virDomainUSBAddressReserve(virDomainDeviceInfoPtr info,
+virDomainUSBAddressReserve(virDomainDeviceInfo *info,
void *data)
{
- virDomainUSBAddressSetPtr addrs = data;
- virDomainUSBAddressHubPtr targetHub = NULL;
+ virDomainUSBAddressSet *addrs = data;
+ virDomainUSBAddressHub *targetHub = NULL;
g_autofree char *portStr = NULL;
int targetPort;
int
-virDomainUSBAddressEnsure(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressEnsure(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
{
if (!addrs)
return 0;
int
-virDomainUSBAddressRelease(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressRelease(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
{
- virDomainUSBAddressHubPtr targetHub = NULL;
+ virDomainUSBAddressHub *targetHub = NULL;
g_autofree char *portStr = NULL;
int targetPort;
/* See virDomainDeviceInfo::isolationGroupLocked */
bool isolationGroupLocked;
} virDomainPCIAddressBus;
-typedef virDomainPCIAddressBus *virDomainPCIAddressBusPtr;
typedef struct {
GHashTable *uids;
GHashTable *fids;
} virDomainZPCIAddressIds;
-typedef virDomainZPCIAddressIds *virDomainZPCIAddressIdsPtr;
struct _virDomainPCIAddressSet {
virDomainPCIAddressBus *buses;
bool areMultipleRootsSupported;
/* If true, the guest can use the pcie-to-pci-bridge controller */
bool isPCIeToPCIBridgeSupported;
- virDomainZPCIAddressIdsPtr zpciIds;
+ virDomainZPCIAddressIds *zpciIds;
};
typedef struct _virDomainPCIAddressSet virDomainPCIAddressSet;
-typedef virDomainPCIAddressSet *virDomainPCIAddressSetPtr;
-virDomainPCIAddressSetPtr virDomainPCIAddressSetAlloc(unsigned int nbuses,
- virPCIDeviceAddressExtensionFlags extFlags);
+virDomainPCIAddressSet *
+virDomainPCIAddressSetAlloc(unsigned int nbuses,
+ virPCIDeviceAddressExtensionFlags extFlags);
-void virDomainPCIAddressSetFree(virDomainPCIAddressSetPtr addrs);
+void virDomainPCIAddressSetFree(virDomainPCIAddressSet *addrs);
-bool virDomainPCIAddressValidate(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+bool virDomainPCIAddressValidate(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
const char *addrStr,
virDomainPCIConnectFlags flags,
bool fromConfig)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int virDomainPCIAddressBusSetModel(virDomainPCIAddressBusPtr bus,
+int virDomainPCIAddressBusSetModel(virDomainPCIAddressBus *bus,
virDomainControllerModelPCI model,
bool allowHotplug)
ATTRIBUTE_NONNULL(1);
-bool virDomainPCIAddressBusIsFullyReserved(virDomainPCIAddressBusPtr bus)
+bool virDomainPCIAddressBusIsFullyReserved(virDomainPCIAddressBus *bus)
ATTRIBUTE_NONNULL(1);
-bool virDomainPCIAddressSlotInUse(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+bool virDomainPCIAddressSlotInUse(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainPCIAddressExtensionReserveAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+int virDomainPCIAddressExtensionReserveAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainPCIAddressExtensionReserveNextAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+int virDomainPCIAddressExtensionReserveNextAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainPCIAddressReserveAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr,
+int virDomainPCIAddressReserveAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr,
virDomainPCIConnectFlags flags,
unsigned int isolationGroup)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainPCIAddressReserveNextAddr(virDomainPCIAddressSetPtr addrs,
- virDomainDeviceInfoPtr dev,
+int virDomainPCIAddressReserveNextAddr(virDomainPCIAddressSet *addrs,
+ virDomainDeviceInfo *dev,
virDomainPCIConnectFlags flags,
int function)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainPCIAddressEnsureAddr(virDomainPCIAddressSetPtr addrs,
- virDomainDeviceInfoPtr dev,
+int virDomainPCIAddressEnsureAddr(virDomainPCIAddressSet *addrs,
+ virDomainDeviceInfo *dev,
virDomainPCIConnectFlags flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainPCIAddressReleaseAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+void virDomainPCIAddressReleaseAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainPCIAddressExtensionReleaseAddr(virDomainPCIAddressSetPtr addrs,
- virPCIDeviceAddressPtr addr)
+void virDomainPCIAddressExtensionReleaseAddr(virDomainPCIAddressSet *addrs,
+ virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainPCIAddressSetAllMulti(virDomainDefPtr def)
+void virDomainPCIAddressSetAllMulti(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
struct _virDomainCCWAddressSet {
virDomainDeviceCCWAddress next;
};
typedef struct _virDomainCCWAddressSet virDomainCCWAddressSet;
-typedef virDomainCCWAddressSet *virDomainCCWAddressSetPtr;
-int virDomainCCWAddressAssign(virDomainDeviceInfoPtr dev,
- virDomainCCWAddressSetPtr addrs,
+int virDomainCCWAddressAssign(virDomainDeviceInfo *dev,
+ virDomainCCWAddressSet *addrs,
bool autoassign)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainCCWAddressSetFree(virDomainCCWAddressSetPtr addrs);
+void virDomainCCWAddressSetFree(virDomainCCWAddressSet *addrs);
-char* virDomainCCWAddressAsString(virDomainDeviceCCWAddressPtr addr)
+char* virDomainCCWAddressAsString(virDomainDeviceCCWAddress *addr)
ATTRIBUTE_NONNULL(1);
-virDomainCCWAddressSetPtr
-virDomainCCWAddressSetCreateFromDomain(virDomainDefPtr def)
+virDomainCCWAddressSet *
+virDomainCCWAddressSetCreateFromDomain(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
struct _virDomainVirtioSerialController {
unsigned int idx;
- virBitmapPtr ports;
+ virBitmap *ports;
};
typedef struct _virDomainVirtioSerialController virDomainVirtioSerialController;
-typedef virDomainVirtioSerialController *virDomainVirtioSerialControllerPtr;
struct _virDomainVirtioSerialAddrSet {
- virDomainVirtioSerialControllerPtr *controllers;
+ virDomainVirtioSerialController **controllers;
size_t ncontrollers;
};
typedef struct _virDomainVirtioSerialAddrSet virDomainVirtioSerialAddrSet;
-typedef virDomainVirtioSerialAddrSet *virDomainVirtioSerialAddrSetPtr;
void
-virDomainVirtioSerialAddrSetFree(virDomainVirtioSerialAddrSetPtr addrs);
-virDomainVirtioSerialAddrSetPtr
-virDomainVirtioSerialAddrSetCreateFromDomain(virDomainDefPtr def)
+virDomainVirtioSerialAddrSetFree(virDomainVirtioSerialAddrSet *addrs);
+virDomainVirtioSerialAddrSet *
+virDomainVirtioSerialAddrSetCreateFromDomain(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
bool
-virDomainVirtioSerialAddrIsComplete(virDomainDeviceInfoPtr info);
+virDomainVirtioSerialAddrIsComplete(virDomainDeviceInfo *info);
int
-virDomainVirtioSerialAddrAutoAssignFromCache(virDomainDefPtr def,
- virDomainVirtioSerialAddrSetPtr addrs,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrAutoAssignFromCache(virDomainDef *def,
+ virDomainVirtioSerialAddrSet *addrs,
+ virDomainDeviceInfo *info,
bool allowZero)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-virDomainVirtioSerialAddrAutoAssign(virDomainDefPtr def,
- virDomainDeviceInfoPtr info,
+virDomainVirtioSerialAddrAutoAssign(virDomainDef *def,
+ virDomainDeviceInfo *info,
bool allowZero)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
ATTRIBUTE_NONNULL(1);
void
-virDomainUSBAddressPortFormatBuf(virBufferPtr buf,
+virDomainUSBAddressPortFormatBuf(virBuffer *buf,
unsigned int *port)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
#define VIR_DOMAIN_USB_HUB_PORTS 8
typedef struct _virDomainUSBAddressHub virDomainUSBAddressHub;
-typedef virDomainUSBAddressHub *virDomainUSBAddressHubPtr;
struct _virDomainUSBAddressHub {
/* indexes are shifted by one:
* ports[0] represents port 1, because ports are numbered from 1 */
- virBitmapPtr portmap;
+ virBitmap *portmap;
size_t nports;
- virDomainUSBAddressHubPtr *ports;
+ virDomainUSBAddressHub **ports;
};
struct _virDomainUSBAddressSet {
/* every <controller type='usb' index='i'> is represented
* as a hub at buses[i] */
- virDomainUSBAddressHubPtr *buses;
+ virDomainUSBAddressHub **buses;
size_t nbuses;
};
typedef struct _virDomainUSBAddressSet virDomainUSBAddressSet;
-typedef virDomainUSBAddressSet *virDomainUSBAddressSetPtr;
-virDomainUSBAddressSetPtr virDomainUSBAddressSetCreate(void);
+virDomainUSBAddressSet *virDomainUSBAddressSetCreate(void);
-int virDomainUSBAddressSetAddControllers(virDomainUSBAddressSetPtr addrs,
- virDomainDefPtr def)
+int virDomainUSBAddressSetAddControllers(virDomainUSBAddressSet *addrs,
+ virDomainDef *def)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainUSBAddressSetAddHub(virDomainUSBAddressSetPtr addrs,
- virDomainHubDefPtr hub)
+virDomainUSBAddressSetAddHub(virDomainUSBAddressSet *addrs,
+ virDomainHubDef *hub)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
size_t
-virDomainUSBAddressCountAllPorts(virDomainDefPtr def);
-void virDomainUSBAddressSetFree(virDomainUSBAddressSetPtr addrs);
+virDomainUSBAddressCountAllPorts(virDomainDef *def);
+void virDomainUSBAddressSetFree(virDomainUSBAddressSet *addrs);
int
-virDomainUSBAddressPresent(virDomainDeviceInfoPtr info,
+virDomainUSBAddressPresent(virDomainDeviceInfo *info,
void *data)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainUSBAddressReserve(virDomainDeviceInfoPtr info,
+virDomainUSBAddressReserve(virDomainDeviceInfo *info,
void *data)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainUSBAddressAssign(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressAssign(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainUSBAddressEnsure(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressEnsure(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
ATTRIBUTE_NONNULL(2);
int
-virDomainUSBAddressRelease(virDomainUSBAddressSetPtr addrs,
- virDomainDeviceInfoPtr info)
+virDomainUSBAddressRelease(virDomainUSBAddressSet *addrs,
+ virDomainDeviceInfo *info)
ATTRIBUTE_NONNULL(2);
static const char *
-virDomainAuditGetVirtType(virDomainDefPtr def)
+virDomainAuditGetVirtType(virDomainDef *def)
{
const char *virt;
static void
-virDomainAuditGenericDev(virDomainObjPtr vm,
+virDomainAuditGenericDev(virDomainObj *vm,
const char *type,
const char *oldsrcpath,
const char *newsrcpath,
void
-virDomainAuditChardev(virDomainObjPtr vm,
- virDomainChrDefPtr oldDef,
- virDomainChrDefPtr newDef,
+virDomainAuditChardev(virDomainObj *vm,
+ virDomainChrDef *oldDef,
+ virDomainChrDef *newDef,
const char *reason,
bool success)
{
- virDomainChrSourceDefPtr oldsrc = NULL;
- virDomainChrSourceDefPtr newsrc = NULL;
+ virDomainChrSourceDef *oldsrc = NULL;
+ virDomainChrSourceDef *newsrc = NULL;
if (oldDef)
oldsrc = oldDef->source;
static void
-virDomainAuditSmartcard(virDomainObjPtr vm,
- virDomainSmartcardDefPtr def,
+virDomainAuditSmartcard(virDomainObj *vm,
+ virDomainSmartcardDef *def,
const char *reason,
bool success)
{
void
-virDomainAuditDisk(virDomainObjPtr vm,
- virStorageSourcePtr oldDef,
- virStorageSourcePtr newDef,
+virDomainAuditDisk(virDomainObj *vm,
+ virStorageSource *oldDef,
+ virStorageSource *newDef,
const char *reason,
bool success)
{
void
-virDomainAuditRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr oldDef, virDomainRNGDefPtr newDef,
+virDomainAuditRNG(virDomainObj *vm,
+ virDomainRNGDef *oldDef, virDomainRNGDef *newDef,
const char *reason, bool success)
{
const char *newsrcpath = NULL;
void
-virDomainAuditFS(virDomainObjPtr vm,
- virDomainFSDefPtr oldDef, virDomainFSDefPtr newDef,
+virDomainAuditFS(virDomainObj *vm,
+ virDomainFSDef *oldDef, virDomainFSDef *newDef,
const char *reason, bool success)
{
virDomainAuditGenericDev(vm, "fs",
void
-virDomainAuditNet(virDomainObjPtr vm,
- virDomainNetDefPtr oldDef, virDomainNetDefPtr newDef,
+virDomainAuditNet(virDomainObj *vm,
+ virDomainNetDef *oldDef, virDomainNetDef *newDef,
const char *reason, bool success)
{
char newMacstr[VIR_MAC_STRING_BUFLEN];
* Log an audit message about an attempted network device open.
*/
void
-virDomainAuditNetDevice(virDomainDefPtr vmDef, virDomainNetDefPtr netDef,
+virDomainAuditNetDevice(virDomainDef *vmDef, virDomainNetDef *netDef,
const char *device, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* Log an audit message about an attempted device passthrough change.
*/
void
-virDomainAuditHostdev(virDomainObjPtr vm, virDomainHostdevDefPtr hostdev,
+virDomainAuditHostdev(virDomainObj *vm, virDomainHostdevDef *hostdev,
const char *reason, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *device = NULL;
const char *virt = virDomainAuditGetVirtType(vm->def);
- virDomainHostdevSubsysUSBPtr usbsrc = &hostdev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &hostdev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &hostdev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &hostdev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &hostdev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &hostdev->source.subsys.u.mdev;
virUUIDFormat(vm->def->uuid, uuidstr);
if (!(vmname = virAuditEncode("vm", vm->def->name))) {
*/
goto cleanup;
} else {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc =
- &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
+
address = g_strdup_printf("%s:%u:%u:%llu",
scsihostsrc->adapter, scsihostsrc->bus,
scsihostsrc->target,
* Log an audit message about an attempted device passthrough change.
*/
void
-virDomainAuditRedirdev(virDomainObjPtr vm, virDomainRedirdevDefPtr redirdev,
+virDomainAuditRedirdev(virDomainObj *vm, virDomainRedirdevDef *redirdev,
const char *reason, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* change.
*/
static void
-virDomainAuditTPM(virDomainObjPtr vm, virDomainTPMDefPtr tpm,
+virDomainAuditTPM(virDomainObj *vm, virDomainTPMDef *tpm,
const char *reason, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* Log an audit message about an attempted cgroup device ACL change.
*/
void
-virDomainAuditCgroup(virDomainObjPtr vm, virCgroupPtr cgroup,
+virDomainAuditCgroup(virDomainObj *vm, virCgroup *cgroup,
const char *reason, const char *extra, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* Log an audit message about an attempted cgroup device ACL change.
*/
void
-virDomainAuditCgroupMajor(virDomainObjPtr vm, virCgroupPtr cgroup,
+virDomainAuditCgroupMajor(virDomainObj *vm, virCgroup *cgroup,
const char *reason, int maj, const char *name,
const char *perms, bool success)
{
* a specific device.
*/
void
-virDomainAuditCgroupPath(virDomainObjPtr vm, virCgroupPtr cgroup,
+virDomainAuditCgroupPath(virDomainObj *vm, virCgroup *cgroup,
const char *reason, const char *path, const char *perms,
int rc)
{
* Log an audit message about an attempted resource change.
*/
static void
-virDomainAuditResource(virDomainObjPtr vm, const char *resource,
+virDomainAuditResource(virDomainObj *vm, const char *resource,
unsigned long long oldval, unsigned long long newval,
const char *reason, bool success)
{
}
void
-virDomainAuditMemory(virDomainObjPtr vm,
+virDomainAuditMemory(virDomainObj *vm,
unsigned long long oldmem, unsigned long long newmem,
const char *reason, bool success)
{
}
void
-virDomainAuditVcpu(virDomainObjPtr vm,
+virDomainAuditVcpu(virDomainObj *vm,
unsigned int oldvcpu, unsigned int newvcpu,
const char *reason, bool success)
{
}
void
-virDomainAuditIOThread(virDomainObjPtr vm,
+virDomainAuditIOThread(virDomainObj *vm,
unsigned int oldiothread, unsigned int newiothread,
const char *reason, bool success)
{
}
static void
-virDomainAuditLifecycle(virDomainObjPtr vm, const char *op,
+virDomainAuditLifecycle(virDomainObj *vm, const char *op,
const char *reason, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
void
-virDomainAuditStart(virDomainObjPtr vm, const char *reason, bool success)
+virDomainAuditStart(virDomainObj *vm, const char *reason, bool success)
{
size_t i;
virDomainAuditDisk(vm, NULL, vm->def->disks[i]->src, "start", true);
for (i = 0; i < vm->def->nfss; i++) {
- virDomainFSDefPtr fs = vm->def->fss[i];
+ virDomainFSDef *fs = vm->def->fss[i];
virDomainAuditFS(vm, NULL, fs, "start", true);
}
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
virDomainAuditNet(vm, NULL, net, "start", true);
}
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
+ virDomainHostdevDef *hostdev = vm->def->hostdevs[i];
virDomainAuditHostdev(vm, hostdev, "start", true);
}
for (i = 0; i < vm->def->nredirdevs; i++) {
- virDomainRedirdevDefPtr redirdev = vm->def->redirdevs[i];
+ virDomainRedirdevDef *redirdev = vm->def->redirdevs[i];
virDomainAuditRedirdev(vm, redirdev, "start", true);
}
}
void
-virDomainAuditInit(virDomainObjPtr vm,
+virDomainAuditInit(virDomainObj *vm,
pid_t initpid,
ino_t pidns)
{
}
void
-virDomainAuditStop(virDomainObjPtr vm, const char *reason)
+virDomainAuditStop(virDomainObj *vm, const char *reason)
{
virDomainAuditLifecycle(vm, "stop", reason, true);
}
void
-virDomainAuditSecurityLabel(virDomainObjPtr vm, bool success)
+virDomainAuditSecurityLabel(virDomainObj *vm, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *vmname;
}
void
-virDomainAuditShmem(virDomainObjPtr vm,
- virDomainShmemDefPtr def,
+virDomainAuditShmem(virDomainObj *vm,
+ virDomainShmemDef *def,
const char *reason, bool success)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
void
-virDomainAuditInput(virDomainObjPtr vm,
- virDomainInputDefPtr input,
+virDomainAuditInput(virDomainObj *vm,
+ virDomainInputDef *input,
const char *reason,
bool success)
{
#include "domain_conf.h"
#include "vircgroup.h"
-void virDomainAuditStart(virDomainObjPtr vm,
+void virDomainAuditStart(virDomainObj *vm,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainAuditInit(virDomainObjPtr vm,
+void virDomainAuditInit(virDomainObj *vm,
pid_t pid,
ino_t pidns)
ATTRIBUTE_NONNULL(1);
-void virDomainAuditStop(virDomainObjPtr vm,
+void virDomainAuditStop(virDomainObj *vm,
const char *reason)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virDomainAuditDisk(virDomainObjPtr vm,
- virStorageSourcePtr oldDef,
- virStorageSourcePtr newDef,
+void virDomainAuditDisk(virDomainObj *vm,
+ virStorageSource *oldDef,
+ virStorageSource *newDef,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditFS(virDomainObjPtr vm,
- virDomainFSDefPtr oldDef,
- virDomainFSDefPtr newDef,
+void virDomainAuditFS(virDomainObj *vm,
+ virDomainFSDef *oldDef,
+ virDomainFSDef *newDef,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditNet(virDomainObjPtr vm,
- virDomainNetDefPtr oldDef,
- virDomainNetDefPtr newDef,
+void virDomainAuditNet(virDomainObj *vm,
+ virDomainNetDef *oldDef,
+ virDomainNetDef *newDef,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditNetDevice(virDomainDefPtr vmDef,
- virDomainNetDefPtr netDef,
+void virDomainAuditNetDevice(virDomainDef *vmDef,
+ virDomainNetDef *netDef,
const char *device,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void virDomainAuditHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr def,
+void virDomainAuditHostdev(virDomainObj *vm,
+ virDomainHostdevDef *def,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void virDomainAuditCgroup(virDomainObjPtr vm,
- virCgroupPtr group,
+void virDomainAuditCgroup(virDomainObj *vm,
+ virCgroup *group,
const char *reason,
const char *extra,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
-void virDomainAuditCgroupMajor(virDomainObjPtr vm,
- virCgroupPtr group,
+void virDomainAuditCgroupMajor(virDomainObj *vm,
+ virCgroup *group,
const char *reason,
int maj,
const char *name,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6);
-void virDomainAuditCgroupPath(virDomainObjPtr vm,
- virCgroupPtr group,
+void virDomainAuditCgroupPath(virDomainObj *vm,
+ virCgroup *group,
const char *reason,
const char *path,
const char *perms,
int rc)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
-void virDomainAuditMemory(virDomainObjPtr vm,
+void virDomainAuditMemory(virDomainObj *vm,
unsigned long long oldmem,
unsigned long long newmem,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditVcpu(virDomainObjPtr vm,
+void virDomainAuditVcpu(virDomainObj *vm,
unsigned int oldvcpu,
unsigned int newvcpu,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditIOThread(virDomainObjPtr vm,
+void virDomainAuditIOThread(virDomainObj *vm,
unsigned int oldiothread,
unsigned int newiothread,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditSecurityLabel(virDomainObjPtr vm,
+void virDomainAuditSecurityLabel(virDomainObj *vm,
bool success)
ATTRIBUTE_NONNULL(1);
-void virDomainAuditRedirdev(virDomainObjPtr vm,
- virDomainRedirdevDefPtr def,
+void virDomainAuditRedirdev(virDomainObj *vm,
+ virDomainRedirdevDef *def,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void virDomainAuditChardev(virDomainObjPtr vm,
- virDomainChrDefPtr oldDef,
- virDomainChrDefPtr newDef,
+void virDomainAuditChardev(virDomainObj *vm,
+ virDomainChrDef *oldDef,
+ virDomainChrDef *newDef,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr oldDef,
- virDomainRNGDefPtr newDef,
+void virDomainAuditRNG(virDomainObj *vm,
+ virDomainRNGDef *oldDef,
+ virDomainRNGDef *newDef,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-void virDomainAuditShmem(virDomainObjPtr vm,
- virDomainShmemDefPtr def,
+void virDomainAuditShmem(virDomainObj *vm,
+ virDomainShmemDef *def,
const char *reason, bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void virDomainAuditInput(virDomainObjPtr vm,
- virDomainInputDefPtr input,
+void virDomainAuditInput(virDomainObj *vm,
+ virDomainInputDef *input,
const char *reason,
bool success)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
"backup",
);
-static virClassPtr virDomainCapsClass;
-static virClassPtr virDomainCapsCPUModelsClass;
+static virClass *virDomainCapsClass;
+static virClass *virDomainCapsCPUModelsClass;
static void virDomainCapsDispose(void *obj);
static void virDomainCapsCPUModelsDispose(void *obj);
static void
virDomainCapsDispose(void *obj)
{
- virDomainCapsPtr caps = obj;
- virDomainCapsStringValuesPtr values;
+ virDomainCaps *caps = obj;
+ virDomainCapsStringValues *values;
size_t i;
g_free(caps->path);
static void
virDomainCapsCPUModelsDispose(void *obj)
{
- virDomainCapsCPUModelsPtr cpuModels = obj;
+ virDomainCapsCPUModels *cpuModels = obj;
size_t i;
for (i = 0; i < cpuModels->nmodels; i++) {
}
-virDomainCapsPtr
+virDomainCaps *
virDomainCapsNew(const char *path,
const char *machine,
virArch arch,
virDomainVirtType virttype)
{
- virDomainCapsPtr caps = NULL;
+ virDomainCaps *caps = NULL;
if (virDomainCapsInitialize() < 0)
return NULL;
}
-virDomainCapsCPUModelsPtr
+virDomainCapsCPUModels *
virDomainCapsCPUModelsNew(size_t nmodels)
{
- virDomainCapsCPUModelsPtr cpuModels = NULL;
+ virDomainCapsCPUModels *cpuModels = NULL;
if (virDomainCapsInitialize() < 0)
return NULL;
}
-virDomainCapsCPUModelsPtr
-virDomainCapsCPUModelsCopy(virDomainCapsCPUModelsPtr old)
+virDomainCapsCPUModels *
+virDomainCapsCPUModelsCopy(virDomainCapsCPUModels *old)
{
- virDomainCapsCPUModelsPtr cpuModels;
+ virDomainCapsCPUModels *cpuModels;
size_t i;
if (!(cpuModels = virDomainCapsCPUModelsNew(old->nmodels)))
int
-virDomainCapsCPUModelsAdd(virDomainCapsCPUModelsPtr cpuModels,
+virDomainCapsCPUModelsAdd(virDomainCapsCPUModels *cpuModels,
const char *name,
virDomainCapsCPUUsable usable,
char **blockers,
bool deprecated)
{
g_autofree char * nameCopy = NULL;
- virDomainCapsCPUModelPtr cpu;
+ virDomainCapsCPUModel *cpu;
nameCopy = g_strdup(name);
}
-virDomainCapsCPUModelPtr
-virDomainCapsCPUModelsGet(virDomainCapsCPUModelsPtr cpuModels,
+virDomainCapsCPUModel *
+virDomainCapsCPUModelsGet(virDomainCapsCPUModels *cpuModels,
const char *name)
{
size_t i;
int
-virDomainCapsEnumSet(virDomainCapsEnumPtr capsEnum,
+virDomainCapsEnumSet(virDomainCapsEnum *capsEnum,
const char *capsEnumName,
size_t nvalues,
unsigned int *values)
void
-virDomainCapsEnumClear(virDomainCapsEnumPtr capsEnum)
+virDomainCapsEnumClear(virDomainCapsEnum *capsEnum)
{
capsEnum->values = 0;
}
static int
-virDomainCapsEnumFormat(virBufferPtr buf,
+virDomainCapsEnumFormat(virBuffer *buf,
const virDomainCapsEnum *capsEnum,
const char *capsEnumName,
virDomainCapsValToStr valToStr)
static void
-virDomainCapsStringValuesFormat(virBufferPtr buf,
+virDomainCapsStringValuesFormat(virBuffer *buf,
const virDomainCapsStringValues *values)
{
size_t i;
static void
-qemuDomainCapsFeatureFormatSimple(virBufferPtr buf,
+qemuDomainCapsFeatureFormatSimple(virBuffer *buf,
const char *featurename,
virTristateBool supported)
{
static void
-virDomainCapsLoaderFormat(virBufferPtr buf,
+virDomainCapsLoaderFormat(virBuffer *buf,
const virDomainCapsLoader *loader)
{
FORMAT_PROLOGUE(loader);
}
static void
-virDomainCapsOSFormat(virBufferPtr buf,
+virDomainCapsOSFormat(virBuffer *buf,
const virDomainCapsOS *os)
{
const virDomainCapsLoader *loader = &os->loader;
}
static void
-virDomainCapsCPUCustomFormat(virBufferPtr buf,
- virDomainCapsCPUModelsPtr custom)
+virDomainCapsCPUCustomFormat(virBuffer *buf,
+ virDomainCapsCPUModels *custom)
{
size_t i;
virBufferAdjustIndent(buf, 2);
for (i = 0; i < custom->nmodels; i++) {
- virDomainCapsCPUModelPtr model = custom->models + i;
+ virDomainCapsCPUModel *model = custom->models + i;
virBufferAsprintf(buf, "<model usable='%s'",
virDomainCapsCPUUsableTypeToString(model->usable));
if (model->deprecated)
}
static void
-virDomainCapsCPUFormat(virBufferPtr buf,
+virDomainCapsCPUFormat(virBuffer *buf,
const virDomainCapsCPU *cpu)
{
virBufferAddLit(buf, "<cpu>\n");
}
static void
-virDomainCapsDeviceDiskFormat(virBufferPtr buf,
+virDomainCapsDeviceDiskFormat(virBuffer *buf,
const virDomainCapsDeviceDisk *disk)
{
FORMAT_PROLOGUE(disk);
static void
-virDomainCapsDeviceGraphicsFormat(virBufferPtr buf,
+virDomainCapsDeviceGraphicsFormat(virBuffer *buf,
const virDomainCapsDeviceGraphics *graphics)
{
FORMAT_PROLOGUE(graphics);
static void
-virDomainCapsDeviceVideoFormat(virBufferPtr buf,
+virDomainCapsDeviceVideoFormat(virBuffer *buf,
const virDomainCapsDeviceVideo *video)
{
FORMAT_PROLOGUE(video);
static void
-virDomainCapsDeviceHostdevFormat(virBufferPtr buf,
+virDomainCapsDeviceHostdevFormat(virBuffer *buf,
const virDomainCapsDeviceHostdev *hostdev)
{
FORMAT_PROLOGUE(hostdev);
static void
-virDomainCapsDeviceRNGFormat(virBufferPtr buf,
+virDomainCapsDeviceRNGFormat(virBuffer *buf,
const virDomainCapsDeviceRNG *rng)
{
FORMAT_PROLOGUE(rng);
* </gic>
*/
static void
-virDomainCapsFeatureGICFormat(virBufferPtr buf,
+virDomainCapsFeatureGICFormat(virBuffer *buf,
const virDomainCapsFeatureGIC *gic)
{
FORMAT_PROLOGUE(gic);
}
static void
-virDomainCapsFeatureSEVFormat(virBufferPtr buf,
+virDomainCapsFeatureSEVFormat(virBuffer *buf,
const virSEVCapability *sev)
{
if (!sev) {
static void
virDomainCapsFormatFeatures(const virDomainCaps *caps,
- virBufferPtr buf)
+ virBuffer *buf)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
size_t i;
typedef const char * (*virDomainCapsValToStr)(int value);
typedef struct _virDomainCaps virDomainCaps;
-typedef virDomainCaps *virDomainCapsPtr;
typedef struct _virDomainCapsEnum virDomainCapsEnum;
-typedef virDomainCapsEnum *virDomainCapsEnumPtr;
struct _virDomainCapsEnum {
bool report; /* Whether the format the enum at all */
unsigned int values; /* Bitmask of values supported in the corresponding enum */
G_STATIC_ASSERT(last <= sizeof(unsigned int) * CHAR_BIT)
typedef struct _virDomainCapsStringValues virDomainCapsStringValues;
-typedef virDomainCapsStringValues *virDomainCapsStringValuesPtr;
struct _virDomainCapsStringValues {
char **values; /* raw string values */
size_t nvalues; /* number of strings */
STATIC_ASSERT_ENUM(VIR_DOMAIN_LOADER_TYPE_LAST);
STATIC_ASSERT_ENUM(VIR_TRISTATE_BOOL_LAST);
typedef struct _virDomainCapsLoader virDomainCapsLoader;
-typedef virDomainCapsLoader *virDomainCapsLoaderPtr;
struct _virDomainCapsLoader {
virTristateBool supported;
virDomainCapsStringValues values; /* Info about values for the element */
STATIC_ASSERT_ENUM(VIR_DOMAIN_OS_DEF_FIRMWARE_LAST);
typedef struct _virDomainCapsOS virDomainCapsOS;
-typedef virDomainCapsOS *virDomainCapsOSPtr;
struct _virDomainCapsOS {
virTristateBool supported;
virDomainCapsEnum firmware; /* Info about virDomainOsDefFirmware */
STATIC_ASSERT_ENUM(VIR_DOMAIN_DISK_BUS_LAST);
STATIC_ASSERT_ENUM(VIR_DOMAIN_DISK_MODEL_LAST);
typedef struct _virDomainCapsDeviceDisk virDomainCapsDeviceDisk;
-typedef virDomainCapsDeviceDisk *virDomainCapsDeviceDiskPtr;
struct _virDomainCapsDeviceDisk {
virTristateBool supported;
virDomainCapsEnum diskDevice; /* Info about virDomainDiskDevice enum values */
STATIC_ASSERT_ENUM(VIR_DOMAIN_GRAPHICS_TYPE_LAST);
typedef struct _virDomainCapsDeviceGraphics virDomainCapsDeviceGraphics;
-typedef virDomainCapsDeviceGraphics *virDomainCapsDeviceGraphicsPtr;
struct _virDomainCapsDeviceGraphics {
virTristateBool supported;
virDomainCapsEnum type; /* virDomainGraphicsType */
STATIC_ASSERT_ENUM(VIR_DOMAIN_VIDEO_TYPE_LAST);
typedef struct _virDomainCapsDeviceVideo virDomainCapsDeviceVideo;
-typedef virDomainCapsDeviceVideo *virDomainCapsDeviceVideoPtr;
struct _virDomainCapsDeviceVideo {
virTristateBool supported;
virDomainCapsEnum modelType; /* virDomainVideoType */
STATIC_ASSERT_ENUM(VIR_DOMAIN_HOSTDEV_CAPS_TYPE_LAST);
STATIC_ASSERT_ENUM(VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST);
typedef struct _virDomainCapsDeviceHostdev virDomainCapsDeviceHostdev;
-typedef virDomainCapsDeviceHostdev *virDomainCapsDeviceHostdevPtr;
struct _virDomainCapsDeviceHostdev {
virTristateBool supported;
virDomainCapsEnum mode; /* Info about virDomainHostdevMode */
STATIC_ASSERT_ENUM(VIR_DOMAIN_RNG_MODEL_LAST);
STATIC_ASSERT_ENUM(VIR_DOMAIN_RNG_BACKEND_LAST);
typedef struct _virDomainCapsDeviceRNG virDomainCapsDeviceRNG;
-typedef virDomainCapsDeviceRNG *virDomainCapsDeviceRNGPtr;
struct _virDomainCapsDeviceRNG {
virTristateBool supported;
virDomainCapsEnum model; /* virDomainRNGModel */
STATIC_ASSERT_ENUM(VIR_GIC_VERSION_LAST);
typedef struct _virDomainCapsFeatureGIC virDomainCapsFeatureGIC;
-typedef virDomainCapsFeatureGIC *virDomainCapsFeatureGICPtr;
struct _virDomainCapsFeatureGIC {
virTristateBool supported;
virDomainCapsEnum version; /* Info about virGICVersion */
VIR_ENUM_DECL(virDomainCapsCPUUsable);
typedef struct _virDomainCapsCPUModel virDomainCapsCPUModel;
-typedef virDomainCapsCPUModel *virDomainCapsCPUModelPtr;
struct _virDomainCapsCPUModel {
char *name;
virDomainCapsCPUUsable usable;
};
typedef struct _virDomainCapsCPUModels virDomainCapsCPUModels;
-typedef virDomainCapsCPUModels *virDomainCapsCPUModelsPtr;
struct _virDomainCapsCPUModels {
virObject parent;
size_t nmodels_max;
size_t nmodels;
- virDomainCapsCPUModelPtr models;
+ virDomainCapsCPUModel *models;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainCapsCPUModels, virObjectUnref);
typedef struct _virDomainCapsCPU virDomainCapsCPU;
-typedef virDomainCapsCPU *virDomainCapsCPUPtr;
struct _virDomainCapsCPU {
bool hostPassthrough;
virDomainCapsEnum hostPassthroughMigratable;
bool maximum;
virDomainCapsEnum maximumMigratable;
- virCPUDefPtr hostModel;
- virDomainCapsCPUModelsPtr custom;
+ virCPUDef *hostModel;
+ virDomainCapsCPUModels *custom;
};
typedef struct _virSEVCapability virSEVCapability;
-typedef virSEVCapability *virSEVCapabilityPtr;
struct _virSEVCapability {
char *pdh;
char *cert_chain;
/* add new domain devices here */
virDomainCapsFeatureGIC gic;
- virSEVCapabilityPtr sev;
+ virSEVCapability *sev;
/* add new domain features here */
virTristateBool features[VIR_DOMAIN_CAPS_FEATURE_LAST];
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainCaps, virObjectUnref);
-virDomainCapsPtr virDomainCapsNew(const char *path,
+virDomainCaps *virDomainCapsNew(const char *path,
const char *machine,
virArch arch,
virDomainVirtType virttype);
-virDomainCapsCPUModelsPtr virDomainCapsCPUModelsNew(size_t nmodels);
-virDomainCapsCPUModelsPtr virDomainCapsCPUModelsCopy(virDomainCapsCPUModelsPtr old);
-int virDomainCapsCPUModelsAdd(virDomainCapsCPUModelsPtr cpuModels,
+virDomainCapsCPUModels *virDomainCapsCPUModelsNew(size_t nmodels);
+virDomainCapsCPUModels *virDomainCapsCPUModelsCopy(virDomainCapsCPUModels *old);
+int virDomainCapsCPUModelsAdd(virDomainCapsCPUModels *cpuModels,
const char *name,
virDomainCapsCPUUsable usable,
char **blockers,
bool deprecated);
-virDomainCapsCPUModelPtr
-virDomainCapsCPUModelsGet(virDomainCapsCPUModelsPtr cpuModels,
+virDomainCapsCPUModel *
+virDomainCapsCPUModelsGet(virDomainCapsCPUModels *cpuModels,
const char *name);
#define VIR_DOMAIN_CAPS_ENUM_IS_SET(capsEnum, value) \
} while (0)
-int virDomainCapsEnumSet(virDomainCapsEnumPtr capsEnum,
+int virDomainCapsEnumSet(virDomainCapsEnum *capsEnum,
const char *capsEnumName,
size_t nvalues,
unsigned int *values);
-void virDomainCapsEnumClear(virDomainCapsEnumPtr capsEnum);
+void virDomainCapsEnumClear(virDomainCapsEnum *capsEnum);
char * virDomainCapsFormat(const virDomainCaps *caps);
"sev",
);
-static virClassPtr virDomainObjClass;
-static virClassPtr virDomainXMLOptionClass;
+static virClass *virDomainObjClass;
+static virClass *virDomainXMLOptionClass;
static void virDomainObjDispose(void *obj);
static void virDomainXMLOptionDispose(void *obj);
static void
-virDomainChrSourceDefFormat(virBufferPtr buf,
- virDomainChrSourceDefPtr def,
+virDomainChrSourceDefFormat(virBuffer *buf,
+ virDomainChrSourceDef *def,
unsigned int flags);
static int
-virDomainChrSourceReconnectDefParseXML(virDomainChrSourceReconnectDefPtr def,
+virDomainChrSourceReconnectDefParseXML(virDomainChrSourceReconnectDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt);
static void
virDomainXMLOptionDispose(void *obj)
{
- virDomainXMLOptionPtr xmlopt = obj;
+ virDomainXMLOption *xmlopt = obj;
if (xmlopt->config.privFree)
(xmlopt->config.privFree)(xmlopt->config.priv);
* -1 otherwise
*/
static int
-virDomainKeyWrapCipherDefParseXML(virDomainKeyWrapDefPtr keywrap,
+virDomainKeyWrapCipherDefParseXML(virDomainKeyWrapDef *keywrap,
xmlNodePtr node)
{
int state_type;
}
static int
-virDomainKeyWrapDefParseXML(virDomainDefPtr def, xmlXPathContextPtr ctxt)
+virDomainKeyWrapDefParseXML(virDomainDef *def, xmlXPathContextPtr ctxt)
{
size_t i;
int n;
g_autofree xmlNodePtr *nodes = NULL;
- g_autofree virDomainKeyWrapDefPtr keywrap = NULL;
+ g_autofree virDomainKeyWrapDef *keywrap = NULL;
if ((n = virXPathNodeSet("./keywrap/cipher", ctxt, &nodes)) < 0)
return n;
*
* Allocate a new domain XML configuration
*/
-virDomainXMLOptionPtr
-virDomainXMLOptionNew(virDomainDefParserConfigPtr config,
- virDomainXMLPrivateDataCallbacksPtr priv,
- virXMLNamespacePtr xmlns,
- virDomainABIStabilityPtr abi,
- virSaveCookieCallbacksPtr saveCookie)
+virDomainXMLOption *
+virDomainXMLOptionNew(virDomainDefParserConfig *config,
+ virDomainXMLPrivateDataCallbacks *priv,
+ virXMLNamespace *xmlns,
+ virDomainABIStability *abi,
+ virSaveCookieCallbacks *saveCookie)
{
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
if (virDomainObjInitialize() < 0)
return NULL;
* Returns a pointer to the stored namespace structure.
* The lifetime of the pointer is equal to @xmlopt;
*/
-virXMLNamespacePtr
-virDomainXMLOptionGetNamespace(virDomainXMLOptionPtr xmlopt)
+virXMLNamespace *
+virDomainXMLOptionGetNamespace(virDomainXMLOption *xmlopt)
{
return &xmlopt->ns;
}
static int
virDomainVirtioOptionsParseXML(xmlNodePtr driver,
- virDomainVirtioOptionsPtr *virtio)
+ virDomainVirtioOptions **virtio)
{
int val;
- virDomainVirtioOptionsPtr res;
+ virDomainVirtioOptions *res;
g_autofree char *str = NULL;
if (*virtio || !driver)
}
-virSaveCookieCallbacksPtr
-virDomainXMLOptionGetSaveCookie(virDomainXMLOptionPtr xmlopt)
+virSaveCookieCallbacks *
+virDomainXMLOptionGetSaveCookie(virDomainXMLOption *xmlopt)
{
return &xmlopt->saveCookie;
}
void
-virDomainXMLOptionSetMomentPostParse(virDomainXMLOptionPtr xmlopt,
+virDomainXMLOptionSetMomentPostParse(virDomainXMLOption *xmlopt,
virDomainMomentPostParseCallback cb)
{
xmlopt->momentPostParse = cb;
int
-virDomainXMLOptionRunMomentPostParse(virDomainXMLOptionPtr xmlopt,
- virDomainMomentDefPtr def)
+virDomainXMLOptionRunMomentPostParse(virDomainXMLOption *xmlopt,
+ virDomainMomentDef *def)
{
if (!xmlopt->momentPostParse)
return virDomainMomentDefPostParse(def);
void
-virBlkioDeviceArrayClear(virBlkioDevicePtr devices,
+virBlkioDeviceArrayClear(virBlkioDevice *devices,
int ndevices)
{
size_t i;
* <write_iops_sec>iops</write_iops_sec>
* </device>
*
- * and fills a virBlkioDevicePtr struct.
+ * and fills a virBlkioDevice *struct.
*/
static int
virDomainBlkioDeviceParseXML(xmlNodePtr root,
- virBlkioDevicePtr dev)
+ virBlkioDevice *dev)
{
xmlNodePtr node;
g_autofree char *path = NULL;
* <maxMemory> tunable and reports an error. Otherwise returns 0.
*/
static int
-virDomainDefCheckUnsupportedMemoryHotplug(virDomainDefPtr def)
+virDomainDefCheckUnsupportedMemoryHotplug(virDomainDef *def)
{
/* memory hotplug tunables are not supported by this driver */
if (virDomainDefHasMemoryHotplug(def)) {
* error. Otherwise returns 0.
*/
static int
-virDomainDeviceDefCheckUnsupportedMemoryDevice(virDomainDeviceDefPtr dev)
+virDomainDeviceDefCheckUnsupportedMemoryDevice(virDomainDeviceDef *dev)
{
/* This driver doesn't yet know how to handle memory devices */
if (dev->type == VIR_DOMAIN_DEVICE_MEMORY) {
}
-bool virDomainObjTaint(virDomainObjPtr obj,
+bool virDomainObjTaint(virDomainObj *obj,
virDomainTaintFlags taint)
{
unsigned int flag = (1 << taint);
}
-void virDomainObjDeprecation(virDomainObjPtr obj,
+void virDomainObjDeprecation(virDomainObj *obj,
const char *msg)
{
obj->deprecations = g_renew(char *, obj->deprecations,
static void
-virDomainGraphicsAuthDefClear(virDomainGraphicsAuthDefPtr def)
+virDomainGraphicsAuthDefClear(virDomainGraphicsAuthDef *def)
{
if (!def)
return;
}
static void
-virDomainGraphicsListenDefClear(virDomainGraphicsListenDefPtr def)
+virDomainGraphicsListenDefClear(virDomainGraphicsListenDef *def)
{
if (!def)
return;
}
-void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def)
+void virDomainGraphicsDefFree(virDomainGraphicsDef *def)
{
size_t i;
g_free(def);
}
-const char *virDomainInputDefGetPath(virDomainInputDefPtr input)
+const char *virDomainInputDefGetPath(virDomainInputDef *input)
{
switch ((virDomainInputType) input->type) {
case VIR_DOMAIN_INPUT_TYPE_MOUSE:
return NULL;
}
-void virDomainInputDefFree(virDomainInputDefPtr def)
+void virDomainInputDefFree(virDomainInputDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainLeaseDefFree(virDomainLeaseDefPtr def)
+void virDomainLeaseDefFree(virDomainLeaseDef *def)
{
if (!def)
return;
}
-static virDomainVcpuDefPtr
-virDomainVcpuDefNew(virDomainXMLOptionPtr xmlopt)
+static virDomainVcpuDef *
+virDomainVcpuDefNew(virDomainXMLOption *xmlopt)
{
- virDomainVcpuDefPtr ret = NULL;
+ virDomainVcpuDef *ret = NULL;
g_autoptr(virObject) priv = NULL;
if (xmlopt && xmlopt->privateData.vcpuNew &&
static void
-virDomainVcpuDefFree(virDomainVcpuDefPtr info)
+virDomainVcpuDefFree(virDomainVcpuDef *info)
{
if (!info)
return;
int
-virDomainDefSetVcpusMax(virDomainDefPtr def,
+virDomainDefSetVcpusMax(virDomainDef *def,
unsigned int maxvcpus,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
size_t oldmax = def->maxvcpus;
size_t i;
int
-virDomainDefSetVcpus(virDomainDefPtr def,
+virDomainDefSetVcpus(virDomainDef *def,
unsigned int vcpus)
{
size_t i;
*
* Returns a bitmap representing state of individual vcpus.
*/
-virBitmapPtr
+virBitmap *
virDomainDefGetOnlineVcpumap(const virDomainDef *def)
{
- virBitmapPtr ret = virBitmapNew(def->maxvcpus);
+ virBitmap *ret = virBitmapNew(def->maxvcpus);
size_t i;
for (i = 0; i < def->maxvcpus; i++) {
}
-virDomainVcpuDefPtr
-virDomainDefGetVcpu(virDomainDefPtr def,
+virDomainVcpuDef *
+virDomainDefGetVcpu(virDomainDef *def,
unsigned int vcpu)
{
if (vcpu >= def->maxvcpus)
}
-static virDomainThreadSchedParamPtr
-virDomainDefGetVcpuSched(virDomainDefPtr def,
+static virDomainThreadSchedParam *
+virDomainDefGetVcpuSched(virDomainDef *def,
unsigned int vcpu)
{
- virDomainVcpuDefPtr vcpuinfo;
+ virDomainVcpuDef *vcpuinfo;
if (!(vcpuinfo = virDomainDefGetVcpu(def, vcpu))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
* Returns number of filled entries.
*/
int
-virDomainDefGetVcpuPinInfoHelper(virDomainDefPtr def,
+virDomainDefGetVcpuPinInfoHelper(virDomainDef *def,
int maplen,
int ncpumaps,
unsigned char *cpumaps,
- virBitmapPtr hostcpus,
- virBitmapPtr autoCpuset)
+ virBitmap *hostcpus,
+ virBitmap *autoCpuset)
{
int maxvcpus = virDomainDefGetVcpusMax(def);
size_t i;
for (i = 0; i < maxvcpus && i < ncpumaps; i++) {
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(def, i);
- virBitmapPtr bitmap = NULL;
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(def, i);
+ virBitmap *bitmap = NULL;
if (vcpu && vcpu->cpumask)
bitmap = vcpu->cpumask;
}
-virDomainDiskDefPtr
-virDomainDiskDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainDiskDef *
+virDomainDiskDefNew(virDomainXMLOption *xmlopt)
{
- virDomainDiskDefPtr ret;
+ virDomainDiskDef *ret;
ret = g_new0(virDomainDiskDef, 1);
void
-virDomainDiskDefFree(virDomainDiskDefPtr def)
+virDomainDiskDefFree(virDomainDiskDef *def)
{
if (!def)
return;
int
-virDomainDiskGetType(virDomainDiskDefPtr def)
+virDomainDiskGetType(virDomainDiskDef *def)
{
return def->src->type;
}
void
-virDomainDiskSetType(virDomainDiskDefPtr def, int type)
+virDomainDiskSetType(virDomainDiskDef *def, int type)
{
def->src->type = type;
}
void
-virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
+virDomainDiskSetSource(virDomainDiskDef *def, const char *src)
{
char *tmp = g_strdup(src);
g_free(def->src->path);
void
-virDomainDiskEmptySource(virDomainDiskDefPtr def)
+virDomainDiskEmptySource(virDomainDiskDef *def)
{
- virStorageSourcePtr src = def->src;
+ virStorageSource *src = def->src;
bool readonly = src->readonly;
virStorageSourceClear(src);
void
-virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
+virDomainDiskSetDriver(virDomainDiskDef *def, const char *name)
{
char *tmp = g_strdup(name);
g_free(def->driverName);
int
-virDomainDiskGetFormat(virDomainDiskDefPtr def)
+virDomainDiskGetFormat(virDomainDiskDef *def)
{
return def->src->format;
}
void
-virDomainDiskSetFormat(virDomainDiskDefPtr def, int format)
+virDomainDiskSetFormat(virDomainDiskDef *def, int format)
{
def->src->format = format;
}
-virDomainControllerDefPtr
+virDomainControllerDef *
virDomainControllerDefNew(virDomainControllerType type)
{
- virDomainControllerDefPtr def;
+ virDomainControllerDef *def;
def = g_new0(virDomainControllerDef, 1);
}
-void virDomainControllerDefFree(virDomainControllerDefPtr def)
+void virDomainControllerDefFree(virDomainControllerDef *def)
{
if (!def)
return;
}
-virDomainFSDefPtr
-virDomainFSDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainFSDef *
+virDomainFSDefNew(virDomainXMLOption *xmlopt)
{
- virDomainFSDefPtr ret;
+ virDomainFSDef *ret;
ret = g_new0(virDomainFSDef, 1);
}
-void virDomainFSDefFree(virDomainFSDefPtr def)
+void virDomainFSDefFree(virDomainFSDef *def)
{
if (!def)
return;
}
void
-virDomainActualNetDefFree(virDomainActualNetDefPtr def)
+virDomainActualNetDefFree(virDomainActualNetDef *def)
{
if (!def)
return;
}
-virDomainVsockDefPtr
-virDomainVsockDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainVsockDef *
+virDomainVsockDefNew(virDomainXMLOption *xmlopt)
{
- virDomainVsockDefPtr ret = NULL;
- virDomainVsockDefPtr vsock;
+ virDomainVsockDef *ret = NULL;
+ virDomainVsockDef *vsock;
vsock = g_new0(virDomainVsockDef, 1);
void
-virDomainVsockDefFree(virDomainVsockDefPtr vsock)
+virDomainVsockDefFree(virDomainVsockDef *vsock)
{
if (!vsock)
return;
void
-virDomainNetTeamingInfoFree(virDomainNetTeamingInfoPtr teaming)
+virDomainNetTeamingInfoFree(virDomainNetTeamingInfo *teaming)
{
if (!teaming)
return;
void
-virDomainNetDefFree(virDomainNetDefPtr def)
+virDomainNetDefFree(virDomainNetDef *def)
{
if (!def)
return;
const char *
-virDomainChrSourceDefGetPath(virDomainChrSourceDefPtr chr)
+virDomainChrSourceDefGetPath(virDomainChrSourceDef *chr)
{
if (!chr)
return NULL;
void ATTRIBUTE_NONNULL(1)
-virDomainChrSourceDefClear(virDomainChrSourceDefPtr def)
+virDomainChrSourceDefClear(virDomainChrSourceDef *def)
{
switch (def->type) {
case VIR_DOMAIN_CHR_TYPE_PTY:
/* Deep copies the contents of src into dest. Return -1 and report
* error on failure. */
int
-virDomainChrSourceDefCopy(virDomainChrSourceDefPtr dest,
- virDomainChrSourceDefPtr src)
+virDomainChrSourceDefCopy(virDomainChrSourceDef *dest,
+ virDomainChrSourceDef *src)
{
if (!dest || !src)
return -1;
static void
virDomainChrSourceDefDispose(void *obj)
{
- virDomainChrSourceDefPtr def = obj;
+ virDomainChrSourceDef *def = obj;
size_t i;
virDomainChrSourceDefClear(def);
return true;
}
-void virDomainChrDefFree(virDomainChrDefPtr def)
+void virDomainChrDefFree(virDomainChrDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainSmartcardDefFree(virDomainSmartcardDefPtr def)
+void virDomainSmartcardDefFree(virDomainSmartcardDef *def)
{
size_t i;
if (!def)
g_free(def);
}
-void virDomainSoundCodecDefFree(virDomainSoundCodecDefPtr def)
+void virDomainSoundCodecDefFree(virDomainSoundCodecDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainSoundDefFree(virDomainSoundDefPtr def)
+void virDomainSoundDefFree(virDomainSoundDef *def)
{
size_t i;
}
static void
-virDomainAudioIOALSAFree(virDomainAudioIOALSAPtr def)
+virDomainAudioIOALSAFree(virDomainAudioIOALSA *def)
{
g_free(def->dev);
}
static void
-virDomainAudioIOJackFree(virDomainAudioIOJackPtr def)
+virDomainAudioIOJackFree(virDomainAudioIOJack *def)
{
g_free(def->serverName);
g_free(def->clientName);
}
static void
-virDomainAudioIOOSSFree(virDomainAudioIOOSSPtr def)
+virDomainAudioIOOSSFree(virDomainAudioIOOSS *def)
{
g_free(def->dev);
}
static void
-virDomainAudioIOPulseAudioFree(virDomainAudioIOPulseAudioPtr def)
+virDomainAudioIOPulseAudioFree(virDomainAudioIOPulseAudio *def)
{
g_free(def->name);
g_free(def->streamName);
}
void
-virDomainAudioDefFree(virDomainAudioDefPtr def)
+virDomainAudioDefFree(virDomainAudioDef *def)
{
if (!def)
return;
g_free(def);
}
-virDomainSoundDefPtr
-virDomainSoundDefRemove(virDomainDefPtr def, size_t idx)
+virDomainSoundDef *
+virDomainSoundDefRemove(virDomainDef *def, size_t idx)
{
- virDomainSoundDefPtr ret = def->sounds[idx];
+ virDomainSoundDef *ret = def->sounds[idx];
VIR_DELETE_ELEMENT(def->sounds, idx, def->nsounds);
return ret;
}
-void virDomainMemballoonDefFree(virDomainMemballoonDefPtr def)
+void virDomainMemballoonDefFree(virDomainMemballoonDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainNVRAMDefFree(virDomainNVRAMDefPtr def)
+void virDomainNVRAMDefFree(virDomainNVRAMDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainWatchdogDefFree(virDomainWatchdogDefPtr def)
+void virDomainWatchdogDefFree(virDomainWatchdogDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainShmemDefFree(virDomainShmemDefPtr def)
+void virDomainShmemDefFree(virDomainShmemDef *def)
{
if (!def)
return;
}
-virDomainVideoDefPtr
-virDomainVideoDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainVideoDef *
+virDomainVideoDefNew(virDomainXMLOption *xmlopt)
{
- virDomainVideoDefPtr def;
+ virDomainVideoDef *def;
def = g_new0(virDomainVideoDef, 1);
void
-virDomainVideoDefClear(virDomainVideoDefPtr def)
+virDomainVideoDefClear(virDomainVideoDef *def)
{
if (!def)
return;
}
-void virDomainVideoDefFree(virDomainVideoDefPtr def)
+void virDomainVideoDefFree(virDomainVideoDef *def)
{
if (!def)
return;
}
-virDomainHostdevDefPtr
+virDomainHostdevDef *
virDomainHostdevDefNew(void)
{
- virDomainHostdevDefPtr def;
+ virDomainHostdevDef *def;
def = g_new0(virDomainHostdevDef, 1);
static void
-virDomainHostdevSubsysSCSIClear(virDomainHostdevSubsysSCSIPtr scsisrc)
+virDomainHostdevSubsysSCSIClear(virDomainHostdevSubsysSCSI *scsisrc)
{
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
virObjectUnref(scsisrc->u.iscsi.src);
}
-void virDomainHostdevDefClear(virDomainHostdevDefPtr def)
+void virDomainHostdevDefClear(virDomainHostdevDef *def)
{
if (!def)
return;
}
}
-void virDomainTPMDefFree(virDomainTPMDefPtr def)
+void virDomainTPMDefFree(virDomainTPMDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainHostdevDefFree(virDomainHostdevDefPtr def)
+void virDomainHostdevDefFree(virDomainHostdevDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainHubDefFree(virDomainHubDefPtr def)
+void virDomainHubDefFree(virDomainHubDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainRedirdevDefFree(virDomainRedirdevDefPtr def)
+void virDomainRedirdevDefFree(virDomainRedirdevDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainRedirFilterDefFree(virDomainRedirFilterDefPtr def)
+void virDomainRedirFilterDefFree(virDomainRedirFilterDef *def)
{
size_t i;
g_free(def);
}
-void virDomainMemoryDefFree(virDomainMemoryDefPtr def)
+void virDomainMemoryDefFree(virDomainMemoryDef *def)
{
if (!def)
return;
g_free(def);
}
-void virDomainDeviceDefFree(virDomainDeviceDefPtr def)
+void virDomainDeviceDefFree(virDomainDeviceDef *def)
{
if (!def)
return;
}
static void
-virDomainClockDefClear(virDomainClockDefPtr def)
+virDomainClockDefClear(virDomainClockDef *def)
{
size_t i;
static bool
-virDomainIOThreadIDArrayHasPin(virDomainDefPtr def)
+virDomainIOThreadIDArrayHasPin(virDomainDef *def)
{
size_t i;
void
-virDomainIOThreadIDDefFree(virDomainIOThreadIDDefPtr def)
+virDomainIOThreadIDDefFree(virDomainIOThreadIDDef *def)
{
if (!def)
return;
static void
-virDomainIOThreadIDDefArrayFree(virDomainIOThreadIDDefPtr *def,
+virDomainIOThreadIDDefArrayFree(virDomainIOThreadIDDef **def,
int nids)
{
size_t i;
static int
-virDomainIOThreadIDDefArrayInit(virDomainDefPtr def,
+virDomainIOThreadIDDefArrayInit(virDomainDef *def,
unsigned int iothreads)
{
size_t i;
ssize_t nxt = -1;
- virDomainIOThreadIDDefPtr iothrid = NULL;
+ virDomainIOThreadIDDef *iothrid = NULL;
g_autoptr(virBitmap) thrmap = NULL;
/* Same value (either 0 or some number), then we have none to fill in or
void
-virDomainResourceDefFree(virDomainResourceDefPtr resource)
+virDomainResourceDefFree(virDomainResourceDef *resource)
{
if (!resource)
return;
}
void
-virDomainPanicDefFree(virDomainPanicDefPtr panic)
+virDomainPanicDefFree(virDomainPanicDef *panic)
{
if (!panic)
return;
}
void
-virDomainLoaderDefFree(virDomainLoaderDefPtr loader)
+virDomainLoaderDefFree(virDomainLoaderDef *loader)
{
if (!loader)
return;
static void
-virDomainResctrlMonDefFree(virDomainResctrlMonDefPtr domresmon)
+virDomainResctrlMonDefFree(virDomainResctrlMonDef *domresmon)
{
if (!domresmon)
return;
static void
-virDomainResctrlDefFree(virDomainResctrlDefPtr resctrl)
+virDomainResctrlDefFree(virDomainResctrlDef *resctrl)
{
size_t i = 0;
static void
-virDomainSEVDefFree(virDomainSEVDefPtr def)
+virDomainSEVDefFree(virDomainSEVDef *def)
{
if (!def)
return;
}
-void virDomainDefFree(virDomainDefPtr def)
+void virDomainDefFree(virDomainDef *def)
{
size_t i;
static void virDomainObjDispose(void *obj)
{
- virDomainObjPtr dom = obj;
+ virDomainObj *dom = obj;
VIR_DEBUG("obj=%p", dom);
virCondDestroy(&dom->cond);
virDomainCheckpointObjListFree(dom->checkpoints);
}
-virDomainObjPtr
-virDomainObjNew(virDomainXMLOptionPtr xmlopt)
+virDomainObj *
+virDomainObjNew(virDomainXMLOption *xmlopt)
{
- virDomainObjPtr domain;
+ virDomainObj *domain;
if (virDomainObjInitialize() < 0)
return NULL;
}
-virDomainDefPtr
+virDomainDef *
virDomainDefNew(void)
{
- virDomainDefPtr ret;
+ virDomainDef *ret;
ret = g_new0(virDomainDef, 1);
}
-void virDomainObjAssignDef(virDomainObjPtr domain,
- virDomainDefPtr def,
+void virDomainObjAssignDef(virDomainObj *domain,
+ virDomainDef *def,
bool live,
- virDomainDefPtr *oldDef)
+ virDomainDef **oldDef)
{
if (oldDef)
*oldDef = NULL;
* cleared.
*/
void
-virDomainObjEndAPI(virDomainObjPtr *vm)
+virDomainObjEndAPI(virDomainObj **vm)
{
if (!*vm)
return;
void
-virDomainObjBroadcast(virDomainObjPtr vm)
+virDomainObjBroadcast(virDomainObj *vm)
{
virCondBroadcast(&vm->cond);
}
int
-virDomainObjWait(virDomainObjPtr vm)
+virDomainObjWait(virDomainObj *vm)
{
if (virCondWait(&vm->cond, &vm->parent.lock) < 0) {
virReportSystemError(errno, "%s",
* 1 on timeout
*/
int
-virDomainObjWaitUntil(virDomainObjPtr vm,
+virDomainObjWaitUntil(virDomainObj *vm,
unsigned long long whenms)
{
if (virCondWaitUntil(&vm->cond, &vm->parent.lock, whenms) < 0) {
* @return 0 on success, -1 on failure
*/
int
-virDomainObjSetDefTransient(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr domain,
+virDomainObjSetDefTransient(virDomainXMLOption *xmlopt,
+ virDomainObj *domain,
void *parseOpaque)
{
if (!domain->persistent)
* @param domain domain object pointer
*/
void
-virDomainObjRemoveTransientDef(virDomainObjPtr domain)
+virDomainObjRemoveTransientDef(virDomainObj *domain)
{
if (!domain->newDef)
return;
* @param caps pointer to capabilities info
* @param xmlopt pointer to XML parser configuration object
* @param domain domain object pointer
- * @return NULL on error, virDOmainDefPtr on success
+ * @return NULL on error, virDomainDef * on success
*/
-virDomainDefPtr
-virDomainObjGetPersistentDef(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr domain,
+virDomainDef *
+virDomainObjGetPersistentDef(virDomainXMLOption *xmlopt,
+ virDomainObj *domain,
void *parseOpaque)
{
if (virDomainObjIsActive(domain) &&
* error.
*/
int
-virDomainObjUpdateModificationImpact(virDomainObjPtr vm,
+virDomainObjUpdateModificationImpact(virDomainObj *vm,
unsigned int *flags)
{
bool isActive = virDomainObjIsActive(vm);
* inappropriate.
*/
int
-virDomainObjGetDefs(virDomainObjPtr vm,
+virDomainObjGetDefs(virDomainObj *vm,
unsigned int flags,
- virDomainDefPtr *liveDef,
- virDomainDefPtr *persDef)
+ virDomainDef **liveDef,
+ virDomainDef **persDef)
{
if (liveDef)
*liveDef = NULL;
*
* Returns the correct definition pointer or NULL on error.
*/
-virDomainDefPtr
-virDomainObjGetOneDefState(virDomainObjPtr vm,
+virDomainDef *
+virDomainObjGetOneDefState(virDomainObj *vm,
unsigned int flags,
bool *live)
{
*
* Returns the correct definition pointer or NULL on error.
*/
-virDomainDefPtr
-virDomainObjGetOneDef(virDomainObjPtr vm,
+virDomainDef *
+virDomainObjGetOneDef(virDomainObj *vm,
unsigned int flags)
{
return virDomainObjGetOneDefState(vm, flags, NULL);
}
-virDomainDeviceInfoPtr
-virDomainDeviceGetInfo(virDomainDeviceDefPtr device)
+virDomainDeviceInfo *
+virDomainDeviceGetInfo(virDomainDeviceDef *device)
{
switch ((virDomainDeviceType) device->type) {
case VIR_DOMAIN_DEVICE_DISK:
/**
* virDomainDeviceSetData
- * @device: virDomainDeviceDefPtr with ->type filled in
- * @devicedata: *DefPtr data for a device. Ex: virDomainDiskDefPtr
+ * @device: virDomainDeviceDef * with ->type filled in
+ * @devicedata: *Def * data for a device. Ex: virDomainDiskDef *
*
* Set the data.X variable for the device->type value. Basically
* a mapping of virDomainDeviceType to the associated name in
* the virDomainDeviceDef union
*/
void
-virDomainDeviceSetData(virDomainDeviceDefPtr device,
+virDomainDeviceSetData(virDomainDeviceDef *device,
void *devicedata)
{
switch ((virDomainDeviceType) device->type) {
static int
-virDomainDefHasDeviceAddressIterator(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainDefHasDeviceAddressIterator(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virDomainDeviceInfoPtr needle = opaque;
+ virDomainDeviceInfo *needle = opaque;
/* break iteration if the info was found */
if (virDomainDeviceInfoAddressIsEqual(info, needle))
static bool
-virDomainSkipBackcompatConsole(virDomainDefPtr def,
+virDomainSkipBackcompatConsole(virDomainDef *def,
size_t idx,
bool all)
{
- virDomainChrDefPtr console = def->consoles[idx];
+ virDomainChrDef *console = def->consoles[idx];
if (!all && idx == 0 &&
(console->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL ||
* behaviour can be altered with virDomainDeviceIterateFlags.
*/
int
-virDomainDeviceInfoIterateFlags(virDomainDefPtr def,
+virDomainDeviceInfoIterateFlags(virDomainDef *def,
virDomainDeviceInfoCallback cb,
unsigned int iteratorFlags,
void *opaque)
int
-virDomainDeviceInfoIterate(virDomainDefPtr def,
+virDomainDeviceInfoIterate(virDomainDef *def,
virDomainDeviceInfoCallback cb,
void *opaque)
{
bool
-virDomainDefHasDeviceAddress(virDomainDefPtr def,
- virDomainDeviceInfoPtr info)
+virDomainDefHasDeviceAddress(virDomainDef *def,
+ virDomainDeviceInfo *info)
{
if (virDomainDeviceInfoIterateFlags(def,
virDomainDefHasDeviceAddressIterator,
static int
-virDomainDefRejectDuplicateControllers(virDomainDefPtr def)
+virDomainDefRejectDuplicateControllers(virDomainDef *def)
{
int max_idx[VIR_DOMAIN_CONTROLLER_TYPE_LAST];
- virBitmapPtr bitmaps[VIR_DOMAIN_CONTROLLER_TYPE_LAST] = { NULL };
- virDomainControllerDefPtr cont;
+ virBitmap *bitmaps[VIR_DOMAIN_CONTROLLER_TYPE_LAST] = { NULL };
+ virDomainControllerDef *cont;
size_t nbitmaps = 0;
int ret = -1;
size_t i;
}
static int
-virDomainDefRejectDuplicatePanics(virDomainDefPtr def)
+virDomainDefRejectDuplicatePanics(virDomainDef *def)
{
bool exists[VIR_DOMAIN_PANIC_MODEL_LAST];
size_t i;
static int
-virDomainDefPostParseMemory(virDomainDefPtr def,
+virDomainDefPostParseMemory(virDomainDef *def,
unsigned int parseFlags)
{
size_t i;
static void
-virDomainDefPostParseOs(virDomainDefPtr def)
+virDomainDefPostParseOs(virDomainDef *def)
{
if (!def->os.loader)
return;
static void
-virDomainDefPostParseMemtune(virDomainDefPtr def)
+virDomainDefPostParseMemtune(virDomainDef *def)
{
size_t i;
static int
-virDomainDefAddConsoleCompat(virDomainDefPtr def)
+virDomainDefAddConsoleCompat(virDomainDef *def)
{
size_t i;
* verify that no other console is of type serial
*/
for (i = 1; i < def->nconsoles; i++) {
- virDomainChrDefPtr cons = def->consoles[i];
+ virDomainChrDef *cons = def->consoles[i];
if (cons->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
* console[0] either does not exist
* or has a different type than SERIAL or NONE.
*/
- virDomainChrDefPtr chr;
+ virDomainChrDef *chr;
if (!(chr = virDomainChrDefNew(NULL)))
return -1;
static int
-virDomainDefPostParseTimer(virDomainDefPtr def)
+virDomainDefPostParseTimer(virDomainDef *def)
{
size_t i;
/* verify settings of guest timers */
for (i = 0; i < def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = def->clock.timers[i];
+ virDomainTimerDef *timer = def->clock.timers[i];
if (timer->name == VIR_DOMAIN_TIMER_NAME_KVMCLOCK ||
timer->name == VIR_DOMAIN_TIMER_NAME_HYPERVCLOCK) {
size_t i;
for (i = 0; i < def->ngraphics; i++) {
- virDomainGraphicsDefPtr graphics = def->graphics[i];
+ virDomainGraphicsDef *graphics = def->graphics[i];
/* If spice graphics is configured without ports and with autoport='no'
* then we start qemu with Spice to not listen anywhere. Let's convert
* this configuration to the new listen type='none' which does the
* same. */
if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
- virDomainGraphicsListenDefPtr glisten = &graphics->listens[0];
+ virDomainGraphicsListenDef *glisten = &graphics->listens[0];
if (glisten->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS &&
graphics->data.spice.port == 0 &&
virDomainDiskBus bus_type,
const virDomainDeviceDriveAddress *addr)
{
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
size_t i;
for (i = 0; i < def->ndisks; i++) {
virDomainHostdevSubsysType type,
const virDomainDeviceDriveAddress *addr)
{
- virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDef *hostdev;
size_t i;
for (i = 0; i < def->nhostdevs; i++) {
#define SCSI_NARROW_BUS_MAX_CONT_UNIT 7
static void
-virDomainHostdevAssignAddress(virDomainXMLOptionPtr xmlopt,
+virDomainHostdevAssignAddress(virDomainXMLOption *xmlopt,
const virDomainDef *def,
- virDomainHostdevDefPtr hostdev)
+ virDomainHostdevDef *hostdev)
{
int next_unit = 0;
int controller = 0;
static int
-virDomainHostdevDefPostParse(virDomainHostdevDefPtr dev,
+virDomainHostdevDefPostParse(virDomainHostdevDef *dev,
const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainHostdevSubsysSCSIPtr scsisrc;
- virDomainDeviceDriveAddressPtr addr = NULL;
+ virDomainHostdevSubsysSCSI *scsisrc;
+ virDomainDeviceDriveAddress *addr = NULL;
if (dev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
return 0;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
scsisrc = &dev->source.subsys.u.scsi;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
virDomainPostParseCheckISCSIPath(&iscsisrc->src->path);
}
static void
-virDomainChrDefPostParse(virDomainChrDefPtr chr,
+virDomainChrDefPostParse(virDomainChrDef *chr,
const virDomainDef *def)
{
const virDomainChrDef **arrPtr;
static void
-virDomainRNGDefPostParse(virDomainRNGDefPtr rng)
+virDomainRNGDefPostParse(virDomainRNGDef *rng)
{
/* set default path for virtio-rng "random" backend to /dev/random */
if (rng->backend == VIR_DOMAIN_RNG_BACKEND_RANDOM &&
static void
-virDomainDiskExpandGroupIoTune(virDomainDiskDefPtr disk,
+virDomainDiskExpandGroupIoTune(virDomainDiskDef *disk,
const virDomainDef *def)
{
size_t i;
return;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr d = def->disks[i];
+ virDomainDiskDef *d = def->disks[i];
if (STRNEQ_NULLABLE(disk->blkdeviotune.group_name, d->blkdeviotune.group_name) ||
!virDomainBlockIoTuneInfoHasAny(&d->blkdeviotune))
static int
-virDomainDiskDefPostParse(virDomainDiskDefPtr disk,
+virDomainDiskDefPostParse(virDomainDiskDef *disk,
const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
/* internal snapshots and config files are currently supported
* only with rbd: */
static void
-virDomainVideoDefPostParse(virDomainVideoDefPtr video,
+virDomainVideoDefPostParse(virDomainVideoDef *video,
const virDomainDef *def)
{
/* Fill out (V)RAM if the driver-specific callback did not do so */
static int
-virDomainControllerDefPostParse(virDomainControllerDefPtr cdev)
+virDomainControllerDefPostParse(virDomainControllerDef *cdev)
{
if (cdev->iothread &&
cdev->model != VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI &&
static void
-virDomainVsockDefPostParse(virDomainVsockDefPtr vsock)
+virDomainVsockDefPostParse(virDomainVsockDef *vsock)
{
if (vsock->auto_cid == VIR_TRISTATE_BOOL_ABSENT) {
if (vsock->guest_cid != 0)
static int
-virDomainMemoryDefPostParse(virDomainMemoryDefPtr mem,
+virDomainMemoryDefPostParse(virDomainMemoryDef *mem,
const virDomainDef *def)
{
switch (mem->model) {
static int
-virDomainDeviceDefPostParseCommon(virDomainDeviceDefPtr dev,
+virDomainDeviceDefPostParseCommon(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
int ret = -1;
* designed to be used for drivers which don't support offline vcpupin.
*/
static void
-virDomainDefRemoveOfflineVcpuPin(virDomainDefPtr def)
+virDomainDefRemoveOfflineVcpuPin(virDomainDef *def)
{
size_t i;
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
for (i = 0; i < virDomainDefGetVcpusMax(def); i++) {
vcpu = virDomainDefGetVcpu(def, i);
static void
-virDomainAssignControllerIndexes(virDomainDefPtr def)
+virDomainAssignControllerIndexes(virDomainDef *def)
{
/* the index attribute of a controller is optional in the XML, but
* is required to be valid at any time after parse. When no index
size_t outer;
for (outer = 0; outer < def->ncontrollers; outer++) {
- virDomainControllerDefPtr cont = def->controllers[outer];
- virDomainControllerDefPtr prev = NULL;
+ virDomainControllerDef *cont = def->controllers[outer];
+ virDomainControllerDef *prev = NULL;
size_t inner;
if (cont->idx != -1)
* Returns 0 on success and -1 on error with an appropriate libvirt error.
*/
static int
-virDomainDefPostParseCheckFeatures(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt)
+virDomainDefPostParseCheckFeatures(virDomainDef *def,
+ virDomainXMLOption *xmlopt)
{
if (UNSUPPORTED(VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG) &&
virDomainDefCheckUnsupportedMemoryHotplug(def) < 0)
* Returns 0 on success and -1 on error with an appropriate libvirt error.
*/
static int
-virDomainDeviceDefPostParseCheckFeatures(virDomainDeviceDefPtr dev,
- virDomainXMLOptionPtr xmlopt)
+virDomainDeviceDefPostParseCheckFeatures(virDomainDeviceDef *dev,
+ virDomainXMLOption *xmlopt)
{
if (UNSUPPORTED(VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG) &&
virDomainDeviceDefCheckUnsupportedMemoryDevice(dev) < 0)
static int
-virDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+virDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
int ret;
}
static int
-virDomainDeviceDefPostParseOne(virDomainDeviceDefPtr dev,
+virDomainDeviceDefPostParseOne(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
void *data = NULL;
static int
-virDomainDefPostParseDeviceIterator(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info G_GNUC_UNUSED,
+virDomainDefPostParseDeviceIterator(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info G_GNUC_UNUSED,
void *opaque)
{
struct virDomainDefPostParseDeviceIteratorData *data = opaque;
static int
-virDomainVcpuDefPostParse(virDomainDefPtr def)
+virDomainVcpuDefPostParse(virDomainDef *def)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t maxvcpus = virDomainDefGetVcpusMax(def);
size_t i;
static int
-virDomainDefPostParseCPU(virDomainDefPtr def)
+virDomainDefPostParseCPU(virDomainDef *def)
{
if (!def->cpu)
return 0;
static int
-virDomainDefCollectBootOrder(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainDefCollectBootOrder(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *data)
{
GHashTable *bootHash = data;
static int
-virDomainDefBootOrderPostParse(virDomainDefPtr def)
+virDomainDefBootOrderPostParse(virDomainDef *def)
{
g_autoptr(GHashTable) bootHash = NULL;
static int
-virDomainDefPostParseVideo(virDomainDefPtr def,
+virDomainDefPostParseVideo(virDomainDef *def,
void *opaque)
{
if (def->nvideos == 0)
static int
-virDomainDefPostParseCommon(virDomainDefPtr def,
+virDomainDefPostParseCommon(virDomainDef *def,
struct virDomainDefPostParseDeviceIteratorData *data,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
size_t i;
static int
-virDomainDefPostParseCheckFailure(virDomainDefPtr def,
+virDomainDefPostParseCheckFailure(virDomainDef *def,
unsigned int parseFlags,
int ret)
{
int
-virDomainDefPostParse(virDomainDefPtr def,
+virDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
int ret = -1;
int
-virDomainObjCheckActive(virDomainObjPtr dom)
+virDomainObjCheckActive(virDomainObj *dom)
{
if (!virDomainObjIsActive(dom)) {
virReportError(VIR_ERR_OPERATION_INVALID,
static void
-virDomainVirtioOptionsFormat(virBufferPtr buf,
- virDomainVirtioOptionsPtr virtio)
+virDomainVirtioOptionsFormat(virBuffer *buf,
+ virDomainVirtioOptions *virtio)
{
if (!virtio)
return;
static void ATTRIBUTE_NONNULL(2)
-virDomainDeviceInfoFormat(virBufferPtr buf,
- virDomainDeviceInfoPtr info,
+virDomainDeviceInfoFormat(virBuffer *buf,
+ virDomainDeviceInfo *info,
unsigned int flags)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static int
virDomainDeviceUSBMasterParseXML(xmlNodePtr node,
- virDomainDeviceUSBMasterPtr master)
+ virDomainDeviceUSBMaster *master)
{
g_autofree char *startport = NULL;
static int
virDomainDeviceBootParseXML(xmlNodePtr node,
- virDomainDeviceInfoPtr info)
+ virDomainDeviceInfo *info)
{
g_autofree char *order = NULL;
g_autofree char *loadparm = NULL;
static int
virDomainDeviceISAAddressParseXML(xmlNodePtr node,
- virDomainDeviceISAAddressPtr addr)
+ virDomainDeviceISAAddress *addr)
{
g_autofree char *iobase = NULL;
g_autofree char *irq = NULL;
static int
virDomainDeviceDimmAddressParseXML(xmlNodePtr node,
- virDomainDeviceDimmAddressPtr addr)
+ virDomainDeviceDimmAddress *addr)
{
g_autofree char *tmp = NULL;
static int
virDomainDeviceAddressParseXML(xmlNodePtr address,
- virDomainDeviceInfoPtr info)
+ virDomainDeviceInfo *info)
{
g_autofree char *type = virXMLPropString(address, "type");
static int
-virDomainDeviceInfoParseXML(virDomainXMLOptionPtr xmlopt,
+virDomainDeviceInfoParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainDeviceInfoPtr info,
+ virDomainDeviceInfo *info,
unsigned int flags)
{
xmlNodePtr address = NULL;
static int
virDomainHostdevSubsysUSBDefParseXML(xmlNodePtr node,
- virDomainHostdevDefPtr def)
+ virDomainHostdevDef *def)
{
bool got_product, got_vendor;
xmlNodePtr cur;
- virDomainHostdevSubsysUSBPtr usbsrc = &def->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *usbsrc = &def->source.subsys.u.usb;
g_autofree char *startupPolicy = NULL;
g_autofree char *autoAddress = NULL;
*/
static int
virDomainHostdevSubsysPCIOrigStatesDefParseXML(xmlNodePtr node,
- virDomainHostdevOrigStatesPtr def)
+ virDomainHostdevOrigStates *def)
{
xmlNodePtr cur;
cur = node->children;
static int
virDomainHostdevSubsysPCIDefParseXML(xmlNodePtr node,
- virDomainHostdevDefPtr def,
+ virDomainHostdevDef *def,
unsigned int flags)
{
g_autofree char *filtering = NULL;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
if (virXMLNodeNameEqual(cur, "address")) {
- virPCIDeviceAddressPtr addr =
+ virPCIDeviceAddress *addr =
&def->source.subsys.u.pci.addr;
if (virPCIDeviceAddressParseXML(cur, addr) < 0)
return -1;
} else if ((flags & VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES) &&
virXMLNodeNameEqual(cur, "origstates")) {
- virDomainHostdevOrigStatesPtr states = &def->origstates;
+ virDomainHostdevOrigStates *states = &def->origstates;
if (virDomainHostdevSubsysPCIOrigStatesDefParseXML(cur, states) < 0)
return -1;
} else {
int
virDomainStorageNetworkParseHost(xmlNodePtr hostnode,
- virStorageNetHostDefPtr host)
+ virStorageNetHostDef *host)
{
int ret = -1;
g_autofree char *transport = NULL;
static int
virDomainStorageNetworkParseHosts(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageNetHostDefPtr *hosts,
+ virStorageNetHostDef **hosts,
size_t *nhosts)
{
g_autofree xmlNodePtr *hostnodes = NULL;
static void
virDomainStorageNetworkParseNFS(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
xmlNodePtr nfsIdentityNode = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt);
static int
virDomainHostdevSubsysSCSIHostDefParseXML(xmlNodePtr sourcenode,
xmlXPathContextPtr ctxt,
- virDomainHostdevSubsysSCSIPtr scsisrc,
+ virDomainHostdevSubsysSCSI *scsisrc,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autofree char *bus = NULL;
g_autofree char *target = NULL;
g_autofree char *unit = NULL;
static int
virDomainHostdevSubsysSCSIiSCSIDefParseXML(xmlNodePtr sourcenode,
- virDomainHostdevSubsysSCSIPtr def,
+ virDomainHostdevSubsysSCSI *def,
xmlXPathContextPtr ctxt,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
int auth_secret_usage = -1;
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &def->u.iscsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &def->u.iscsi;
g_autoptr(virStorageAuthDef) authdef = NULL;
xmlNodePtr node;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virDomainHostdevSubsysSCSIDefParseXML(xmlNodePtr sourcenode,
- virDomainHostdevSubsysSCSIPtr scsisrc,
+ virDomainHostdevSubsysSCSI *scsisrc,
xmlXPathContextPtr ctxt,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_autofree char *protocol = NULL;
static int
virDomainHostdevSubsysSCSIVHostDefParseXML(xmlNodePtr sourcenode,
- virDomainHostdevDefPtr def)
+ virDomainHostdevDef *def)
{
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &def->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &def->source.subsys.u.scsi_host;
g_autofree char *protocol = NULL;
g_autofree char *wwpn = NULL;
}
static int
-virDomainHostdevSubsysMediatedDevDefParseXML(virDomainHostdevDefPtr def,
+virDomainHostdevSubsysMediatedDevDefParseXML(virDomainHostdevDef *def,
xmlXPathContextPtr ctxt)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {0};
xmlNodePtr node = NULL;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &def->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &def->source.subsys.u.mdev;
g_autofree char *uuidxml = NULL;
if (!(node = virXPathNode("./source/address", ctxt))) {
virDomainHostdevDefParseXMLSubsys(xmlNodePtr node,
xmlXPathContextPtr ctxt,
const char *type,
- virDomainHostdevDefPtr def,
+ virDomainHostdevDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
xmlNodePtr sourcenode;
int backend;
- virDomainHostdevSubsysPCIPtr pcisrc = &def->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &def->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr scsihostsrc = &def->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &def->source.subsys.u.mdev;
+ virDomainHostdevSubsysPCI *pcisrc = &def->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &def->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *scsihostsrc = &def->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &def->source.subsys.u.mdev;
g_autofree char *managed = NULL;
g_autofree char *sgio = NULL;
g_autofree char *rawio = NULL;
return 0;
}
-static virNetDevIPAddrPtr
+static virNetDevIPAddr *
virDomainNetIPParseXML(xmlNodePtr node)
{
/* Parse the prefix in every case */
unsigned int prefixValue = 0;
int family = AF_UNSPEC;
- g_autofree virNetDevIPAddrPtr ip = NULL;
+ g_autofree virNetDevIPAddr *ip = NULL;
g_autofree char *prefixStr = NULL;
g_autofree char *familyStr = NULL;
g_autofree char *address = NULL;
}
-/* fill in a virNetDevIPInfoPtr from the <route> and <ip>
+/* fill in a virNetDevIPInfo *from the <route> and <ip>
* elements found in the given XML context.
*
* return 0 on success (including none found) and -1 on failure.
static int
virDomainNetIPInfoParseXML(const char *source,
xmlXPathContextPtr ctxt,
- virNetDevIPInfoPtr def)
+ virNetDevIPInfo *def)
{
g_autoptr(virNetDevIPRoute) route = NULL;
int nnodes;
int ret = -1;
size_t i;
g_autofree xmlNodePtr *nodes = NULL;
- g_autofree virNetDevIPAddrPtr ip = NULL;
+ g_autofree virNetDevIPAddr *ip = NULL;
if ((nnodes = virXPathNodeSet("./ip", ctxt, &nodes)) < 0)
goto cleanup;
static int
virDomainNetDefCoalesceParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetDevCoalescePtr *coalesce)
+ virNetDevCoalesce **coalesce)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
unsigned long long tmp = 0;
}
static void
-virDomainNetDefCoalesceFormatXML(virBufferPtr buf,
- virNetDevCoalescePtr coalesce)
+virDomainNetDefCoalesceFormatXML(virBuffer *buf,
+ virNetDevCoalesce *coalesce)
{
if (!coalesce || !coalesce->rx_max_coalesced_frames)
return;
virDomainHostdevDefParseXMLCaps(xmlNodePtr node G_GNUC_UNUSED,
xmlXPathContextPtr ctxt,
const char *type,
- virDomainHostdevDefPtr def)
+ virDomainHostdevDef *def)
{
/* @type is passed in from the caller rather than read from the
* xml document, because it is specified in different places for
}
-virDomainControllerDefPtr
+virDomainControllerDef *
virDomainDeviceFindSCSIController(const virDomainDef *def,
const virDomainDeviceDriveAddress *addr)
{
}
int
-virDomainDiskDefAssignAddress(virDomainXMLOptionPtr xmlopt,
- virDomainDiskDefPtr def,
+virDomainDiskDefAssignAddress(virDomainXMLOption *xmlopt,
+ virDomainDiskDef *def,
const virDomainDef *vmdef)
{
int idx = virDiskNameToIndex(def->dst);
return 0;
}
-static virSecurityLabelDefPtr
+static virSecurityLabelDef *
virSecurityLabelDefParseXML(xmlXPathContextPtr ctxt,
unsigned int flags)
{
char *p;
- virSecurityLabelDefPtr seclabel = NULL;
+ virSecurityLabelDef *seclabel = NULL;
p = virXMLPropStringLimit(ctxt->node, "model",
VIR_SECURITY_MODEL_BUFLEN - 1);
}
static int
-virSecurityLabelDefsParseXML(virDomainDefPtr def,
+virSecurityLabelDefsParseXML(virDomainDef *def,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
if (n == 0)
return 0;
- def->seclabels = g_new0(virSecurityLabelDefPtr, n);
+ def->seclabels = g_new0(virSecurityLabelDef *, n);
/* Parse each "seclabel" tag */
for (i = 0; i < n; i++) {
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
ctxt->node = list[i];
if (!(seclabel = virSecurityLabelDefParseXML(ctxt, flags)))
/* Parse the <seclabel> from a disk or character device. */
static int
-virSecurityDeviceLabelDefParseXML(virSecurityDeviceLabelDefPtr **seclabels_rtn,
+virSecurityDeviceLabelDefParseXML(virSecurityDeviceLabelDef ***seclabels_rtn,
size_t *nseclabels_rtn,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virSecurityDeviceLabelDefPtr *seclabels = NULL;
+ virSecurityDeviceLabelDef **seclabels = NULL;
size_t nseclabels = 0;
int n;
size_t i, j;
if (n == 0)
return 0;
- seclabels = g_new0(virSecurityDeviceLabelDefPtr, n);
+ seclabels = g_new0(virSecurityDeviceLabelDef *, n);
nseclabels = n;
for (i = 0; i < n; i++)
seclabels[i] = g_new0(virSecurityDeviceLabelDef, 1);
/* Parse the XML definition for a lease
*/
-static virDomainLeaseDefPtr
+static virDomainLeaseDef *
virDomainLeaseDefParseXML(xmlNodePtr node)
{
- virDomainLeaseDefPtr def;
+ virDomainLeaseDef *def;
xmlNodePtr cur;
g_autofree char *lockspace = NULL;
g_autofree char *key = NULL;
static int
virDomainDiskSourcePoolDefParse(xmlNodePtr node,
- virStorageSourcePoolDefPtr *srcpool)
+ virStorageSourcePoolDef **srcpool)
{
- virStorageSourcePoolDefPtr source;
+ virStorageSourcePoolDef *source;
int ret = -1;
g_autofree char *mode = NULL;
}
-static virStorageNetCookieDefPtr
+static virStorageNetCookieDef *
virDomainStorageNetCookieParse(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
static int
virDomainStorageNetCookiesParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
if ((nnodes = virXPathNodeSet("./cookie", ctxt, &nodes)) < 0)
return -1;
- src->cookies = g_new0(virStorageNetCookieDefPtr, nnodes);
+ src->cookies = g_new0(virStorageNetCookieDef *, nnodes);
src->ncookies = nnodes;
for (i = 0; i < nnodes; i++) {
static int
virDomainDiskSourceNetworkParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src,
+ virStorageSource *src,
unsigned int flags)
{
int tlsCfgVal;
static int
virDomainDiskSourceNVMeParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
g_autoptr(virStorageSourceNVMeDef) nvme = NULL;
g_autofree char *type = NULL;
static int
virDomainDiskSourceVHostUserParse(xmlNodePtr node,
- virStorageSourcePtr src,
- virDomainXMLOptionPtr xmlopt,
+ virStorageSource *src,
+ virDomainXMLOption *xmlopt,
xmlXPathContextPtr ctxt)
{
g_autofree char *type = virXMLPropString(node, "type");
static int
virDomainDiskSourcePRParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStoragePRDefPtr *pr)
+ virStoragePRDef **pr)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
}
-virStorageSourcePtr
+virStorageSource *
virDomainStorageSourceParseBase(const char *type,
const char *format,
const char *index)
}
-static virStorageSourceSlicePtr
+static virStorageSourceSlice *
virDomainStorageSourceParseSlice(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *offset = NULL;
g_autofree char *size = NULL;
- g_autofree virStorageSourceSlicePtr ret = g_new0(virStorageSourceSlice, 1);
+ g_autofree virStorageSourceSlice *ret = g_new0(virStorageSourceSlice, 1);
ctxt->node = node;
static int
-virDomainStorageSourceParseSlices(virStorageSourcePtr src,
+virDomainStorageSourceParseSlices(virStorageSource *src,
xmlXPathContextPtr ctxt)
{
xmlNodePtr node;
int
virDomainStorageSourceParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src,
+ virStorageSource *src,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr tmp;
int
virDomainDiskBackingStoreParse(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src,
+ virStorageSource *src,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr source;
}
static int
-virDomainDiskDefIotuneParse(virDomainDiskDefPtr def,
+virDomainDiskDefIotuneParse(virDomainDiskDef *def,
xmlXPathContextPtr ctxt)
{
PARSE_IOTUNE(total_bytes_sec);
static int
-virDomainDiskDefMirrorParse(virDomainDiskDefPtr def,
+virDomainDiskDefMirrorParse(virDomainDiskDef *def,
xmlNodePtr cur,
xmlXPathContextPtr ctxt,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
xmlNodePtr mirrorNode;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
-virDomainDiskDefGeometryParse(virDomainDiskDefPtr def,
+virDomainDiskDefGeometryParse(virDomainDiskDef *def,
xmlNodePtr cur)
{
g_autofree char *tmp = NULL;
static int
virDomainDiskSourceDefParseAuthValidate(const virStorageSource *src)
{
- virStorageAuthDefPtr authdef = src->auth;
+ virStorageAuthDef *authdef = src->auth;
int actUsage;
if (src->type != VIR_STORAGE_TYPE_NETWORK || !authdef)
virDomainDiskDefParseValidate(const virDomainDiskDef *def)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
if (def->bus != VIR_DOMAIN_DISK_BUS_VIRTIO) {
if (def->event_idx != VIR_TRISTATE_SWITCH_ABSENT) {
return -1;
if (next->encryption) {
- virStorageEncryptionPtr encryption = next->encryption;
+ virStorageEncryption *encryption = next->encryption;
if (encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS &&
encryption->encinfo.cipher_name) {
static int
-virDomainDiskDefDriverParseXML(virDomainDiskDefPtr def,
+virDomainDiskDefDriverParseXML(virDomainDiskDef *def,
xmlNodePtr cur,
xmlXPathContextPtr ctxt)
{
static int
virDomainDiskDefParsePrivateData(xmlXPathContextPtr ctxt,
- virDomainDiskDefPtr disk,
- virDomainXMLOptionPtr xmlopt)
+ virDomainDiskDef *disk,
+ virDomainXMLOption *xmlopt)
{
xmlNodePtr private_node = virXPathNode("./privateData", ctxt);
VIR_XPATH_NODE_AUTORESTORE(ctxt)
}
-static virDomainDiskDefPtr
-virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainDiskDef *
+virDomainDiskDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
* additional memory modules.
*/
void
-virDomainDefSetMemoryTotal(virDomainDefPtr def,
+virDomainDefSetMemoryTotal(virDomainDef *def,
unsigned long long size)
{
def->mem.total_memory = size;
static const char *
-virDomainControllerModelTypeToString(virDomainControllerDefPtr def,
+virDomainControllerModelTypeToString(virDomainControllerDef *def,
int model)
{
if (def->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
}
-static virDomainControllerDefPtr
-virDomainControllerDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainControllerDef *
+virDomainControllerDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
void
-virDomainNetGenerateMAC(virDomainXMLOptionPtr xmlopt,
- virMacAddrPtr mac)
+virDomainNetGenerateMAC(virDomainXMLOption *xmlopt,
+ virMacAddr *mac)
{
virMacAddrGenerate(xmlopt->config.macPrefix, mac);
}
-static virDomainFSDefPtr
-virDomainFSDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainFSDef *
+virDomainFSDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainFSDefPtr def;
+ virDomainFSDef *def;
xmlNodePtr cur;
g_autofree char *type = NULL;
g_autofree char *fsdriver = NULL;
static int
virDomainActualNetDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainNetDefPtr parent,
- virDomainActualNetDefPtr *def,
+ virDomainNetDef *parent,
+ virDomainActualNetDef **def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainActualNetDefPtr actual = NULL;
+ virDomainActualNetDef *actual = NULL;
int ret = -1;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr bandwidth_node = NULL;
}
}
} else if (actual->type == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
- virDomainHostdevDefPtr hostdev = &actual->data.hostdev.def;
+ virDomainHostdevDef *hostdev = &actual->data.hostdev.def;
hostdev->parentnet = parent;
hostdev->info = &parent->info;
int
-virDomainNetAppendIPAddress(virDomainNetDefPtr def,
+virDomainNetAppendIPAddress(virDomainNetDef *def,
const char *address,
int family,
unsigned int prefix)
{
- virNetDevIPAddrPtr ipDef = NULL;
+ virNetDevIPAddr *ipDef = NULL;
ipDef = g_new0(virNetDevIPAddr, 1);
if (virSocketAddrParse(&ipDef->address, address, family) < 0)
static int
-virDomainChrSourceReconnectDefParseXML(virDomainChrSourceReconnectDefPtr def,
+virDomainChrSourceReconnectDefParseXML(virDomainChrSourceReconnectDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
static int
virDomainNetTeamingInfoParseXML(xmlXPathContextPtr ctxt,
- virDomainNetTeamingInfoPtr *teaming)
+ virDomainNetTeamingInfo **teaming)
{
g_autofree char *typeStr = virXPathString("string(./teaming/@type)", ctxt);
g_autofree char *persistentStr = virXPathString("string(./teaming/@persistent)", ctxt);
}
-static virDomainNetDefPtr
-virDomainNetDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainNetDef *
+virDomainNetDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainNetDefPtr def;
- virDomainHostdevDefPtr hostdev;
+ virDomainNetDef *def;
+ virDomainHostdevDef *hostdev;
xmlNodePtr cur;
xmlNodePtr tmpNode;
GHashTable *filterparams = NULL;
- virDomainActualNetDefPtr actual = NULL;
+ virDomainActualNetDef *actual = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
virDomainChrSourceReconnectDef reconnect = {0};
int rv, val;
}
static int
-virDomainChrDefParseTargetXML(virDomainChrDefPtr def,
+virDomainChrDefParseTargetXML(virDomainChrDef *def,
xmlNodePtr cur,
unsigned int flags)
{
static int
-virDomainChrSourceDefParseTCP(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseTCP(virDomainChrSourceDef *def,
xmlNodePtr source,
xmlXPathContextPtr ctxt,
unsigned int flags)
static int
-virDomainChrSourceDefParseUDP(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseUDP(virDomainChrSourceDef *def,
xmlNodePtr source)
{
int mode;
static int
-virDomainChrSourceDefParseUnix(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseUnix(virDomainChrSourceDef *def,
xmlNodePtr source,
xmlXPathContextPtr ctxt)
{
static int
-virDomainChrSourceDefParseFile(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseFile(virDomainChrSourceDef *def,
xmlNodePtr source)
{
g_autofree char *append = NULL;
static int
-virDomainChrSourceDefParseProtocol(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseProtocol(virDomainChrSourceDef *def,
xmlNodePtr protocol)
{
g_autofree char *prot = NULL;
static int
-virDomainChrSourceDefParseLog(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseLog(virDomainChrSourceDef *def,
xmlNodePtr log)
{
g_autofree char *append = NULL;
*
* Return -1 on failure, 0 on success. */
static int
-virDomainChrSourceDefParseXML(virDomainChrSourceDefPtr def,
+virDomainChrSourceDefParseXML(virDomainChrSourceDef *def,
xmlNodePtr cur, unsigned int flags,
- virDomainChrDefPtr chr_def,
+ virDomainChrDef *chr_def,
xmlXPathContextPtr ctxt)
{
bool logParsed = false;
}
-static virClassPtr virDomainChrSourceDefClass;
+static virClass *virDomainChrSourceDefClass;
static int
virDomainChrSourceDefOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virDomainChrSourceDef);
-virDomainChrSourceDefPtr
-virDomainChrSourceDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainChrSourceDef *
+virDomainChrSourceDefNew(virDomainXMLOption *xmlopt)
{
- virDomainChrSourceDefPtr def = NULL;
+ virDomainChrSourceDef *def = NULL;
if (virDomainChrSourceDefInitialize() < 0)
return NULL;
/* Create a new character device definition and set
* default port.
*/
-virDomainChrDefPtr
-virDomainChrDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainChrDef *
+virDomainChrDefNew(virDomainXMLOption *xmlopt)
{
- virDomainChrDefPtr def = NULL;
+ virDomainChrDef *def = NULL;
def = g_new0(virDomainChrDef, 1);
* </serial>
*
*/
-static virDomainChrDefPtr
-virDomainChrDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainChrDef *
+virDomainChrDefParseXML(virDomainXMLOption *xmlopt,
xmlXPathContextPtr ctxt,
xmlNodePtr node,
unsigned int flags)
{
xmlNodePtr cur;
const char *nodeName;
- virDomainChrDefPtr def;
+ virDomainChrDef *def;
bool seenTarget = false;
g_autofree char *type = NULL;
return NULL;
}
-static virDomainSmartcardDefPtr
-virDomainSmartcardDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainSmartcardDef *
+virDomainSmartcardDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
* <backend type='emulator' version='2.0' persistent_state='yes'>
* </tpm>
*/
-static virDomainTPMDefPtr
-virDomainTPMDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainTPMDef *
+virDomainTPMDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainTPMDefPtr def;
+ virDomainTPMDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int nbackends;
g_autofree char *path = NULL;
return NULL;
}
-static virDomainPanicDefPtr
-virDomainPanicDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainPanicDef *
+virDomainPanicDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainPanicDefPtr panic;
+ virDomainPanicDef *panic;
g_autofree char *model = NULL;
panic = g_new0(virDomainPanicDef, 1);
}
/* Parse the XML definition for an input device */
-static virDomainInputDefPtr
-virDomainInputDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainInputDef *
+virDomainInputDefParseXML(virDomainXMLOption *xmlopt,
const virDomainDef *dom,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainInputDefPtr def;
+ virDomainInputDef *def;
g_autofree char *evdev = NULL;
g_autofree char *type = NULL;
g_autofree char *bus = NULL;
/* Parse the XML definition for a hub device */
-static virDomainHubDefPtr
-virDomainHubDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainHubDef *
+virDomainHubDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainHubDefPtr def;
+ virDomainHubDef *def;
g_autofree char *type = NULL;
def = g_new0(virDomainHubDef, 1);
/* Parse the XML definition for a clock timer */
-static virDomainTimerDefPtr
+static virDomainTimerDef *
virDomainTimerDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
- virDomainTimerDefPtr def;
+ virDomainTimerDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr catchup;
int ret;
static int
virDomainGraphicsAuthDefParseXML(xmlNodePtr node,
- virDomainGraphicsAuthDefPtr def,
+ virDomainGraphicsAuthDef *def,
int type)
{
g_autofree char *validTo = NULL;
* elements.
*/
static int
-virDomainGraphicsListenDefParseXML(virDomainGraphicsListenDefPtr def,
- virDomainGraphicsDefPtr graphics,
+virDomainGraphicsListenDefParseXML(virDomainGraphicsListenDef *def,
+ virDomainGraphicsDef *graphics,
xmlNodePtr node,
xmlNodePtr parent,
unsigned int flags)
static int
-virDomainGraphicsListensParseXML(virDomainGraphicsDefPtr def,
+virDomainGraphicsListensParseXML(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
if (VIR_APPEND_ELEMENT(def->listens, def->nListens, newListen) < 0)
goto cleanup;
} else {
- virDomainGraphicsListenDefPtr glisten = &def->listens[0];
+ virDomainGraphicsListenDef *glisten = &def->listens[0];
/* If the first <listen/> element is 'address' or 'network' and we found
* 'socket' attribute inside <graphics/> element for backward
static int
-virDomainGraphicsDefParseXMLVNC(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLVNC(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
static int
-virDomainGraphicsDefParseXMLSDL(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLSDL(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
static int
-virDomainGraphicsDefParseXMLRDP(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLRDP(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
static int
-virDomainGraphicsDefParseXMLDesktop(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLDesktop(virDomainGraphicsDef *def,
xmlNodePtr node)
{
g_autofree char *fullscreen = virXMLPropString(node, "fullscreen");
static int
-virDomainGraphicsDefParseXMLSpice(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLSpice(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
static void
-virDomainGraphicsDefParseXMLEGLHeadless(virDomainGraphicsDefPtr def,
+virDomainGraphicsDefParseXMLEGLHeadless(virDomainGraphicsDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
}
-virDomainGraphicsDefPtr
-virDomainGraphicsDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainGraphicsDef *
+virDomainGraphicsDefNew(virDomainXMLOption *xmlopt)
{
- virDomainGraphicsDefPtr def = NULL;
+ virDomainGraphicsDef *def = NULL;
def = g_new0(virDomainGraphicsDef, 1);
}
-virDomainNetDefPtr
-virDomainNetDefNew(virDomainXMLOptionPtr xmlopt)
+virDomainNetDef *
+virDomainNetDefNew(virDomainXMLOption *xmlopt)
{
- virDomainNetDefPtr def = NULL;
+ virDomainNetDef *def = NULL;
def = g_new0(virDomainNetDef, 1);
/* Parse the XML definition for a graphics device */
-static virDomainGraphicsDefPtr
-virDomainGraphicsDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainGraphicsDef *
+virDomainGraphicsDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainGraphicsDefPtr def;
+ virDomainGraphicsDef *def;
int typeVal;
g_autofree char *type = NULL;
}
-static virDomainSoundCodecDefPtr
+static virDomainSoundCodecDef *
virDomainSoundCodecDefParseXML(xmlNodePtr node)
{
- virDomainSoundCodecDefPtr def;
+ virDomainSoundCodecDef *def;
g_autofree char *type = NULL;
def = g_new0(virDomainSoundCodecDef, 1);
}
-static virDomainSoundDefPtr
-virDomainSoundDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainSoundDef *
+virDomainSoundDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainSoundDefPtr def;
+ virDomainSoundDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *model = NULL;
xmlNodePtr audioNode;
if (ncodecs > 0) {
size_t i;
- def->codecs = g_new0(virDomainSoundCodecDefPtr, ncodecs);
+ def->codecs = g_new0(virDomainSoundCodecDef *, ncodecs);
for (i = 0; i < ncodecs; i++) {
- virDomainSoundCodecDefPtr codec = virDomainSoundCodecDefParseXML(codecNodes[i]);
+ virDomainSoundCodecDef *codec = virDomainSoundCodecDefParseXML(codecNodes[i]);
if (codec == NULL)
goto error;
static int
-virDomainAudioCommonParse(virDomainAudioIOCommonPtr def,
+virDomainAudioCommonParse(virDomainAudioIOCommon *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
static void
-virDomainAudioALSAParse(virDomainAudioIOALSAPtr def,
+virDomainAudioALSAParse(virDomainAudioIOALSA *def,
xmlNodePtr node)
{
def->dev = virXMLPropString(node, "dev");
static int
-virDomainAudioCoreAudioParse(virDomainAudioIOCoreAudioPtr def,
+virDomainAudioCoreAudioParse(virDomainAudioIOCoreAudio *def,
xmlNodePtr node)
{
g_autofree char *bufferCount = virXMLPropString(node, "bufferCount");
static int
-virDomainAudioJackParse(virDomainAudioIOJackPtr def,
+virDomainAudioJackParse(virDomainAudioIOJack *def,
xmlNodePtr node)
{
g_autofree char *exactName = virXMLPropString(node, "exactName");
static int
-virDomainAudioOSSParse(virDomainAudioIOOSSPtr def,
+virDomainAudioOSSParse(virDomainAudioIOOSS *def,
xmlNodePtr node)
{
g_autofree char *tryPoll = virXMLPropString(node, "tryPoll");
static int
-virDomainAudioPulseAudioParse(virDomainAudioIOPulseAudioPtr def,
+virDomainAudioPulseAudioParse(virDomainAudioIOPulseAudio *def,
xmlNodePtr node)
{
g_autofree char *latency = virXMLPropString(node, "latency");
static int
-virDomainAudioSDLParse(virDomainAudioIOSDLPtr def,
+virDomainAudioSDLParse(virDomainAudioIOSDL *def,
xmlNodePtr node)
{
g_autofree char *bufferCount = virXMLPropString(node, "bufferCount");
}
-static virDomainAudioDefPtr
-virDomainAudioDefParseXML(virDomainXMLOptionPtr xmlopt G_GNUC_UNUSED,
+static virDomainAudioDef *
+virDomainAudioDefParseXML(virDomainXMLOption *xmlopt G_GNUC_UNUSED,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
- virDomainAudioDefPtr def;
+ virDomainAudioDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *tmp = NULL;
g_autofree char *type = NULL;
virDomainAudioDefFree(def);
return NULL;
}
-static virDomainWatchdogDefPtr
-virDomainWatchdogDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainWatchdogDef *
+virDomainWatchdogDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainWatchdogDefPtr def;
+ virDomainWatchdogDef *def;
g_autofree char *model = NULL;
g_autofree char *action = NULL;
}
-static virDomainRNGDefPtr
-virDomainRNGDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainRNGDef *
+virDomainRNGDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainRNGDefPtr def;
+ virDomainRNGDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int nbackends;
g_autofree xmlNodePtr *backends = NULL;
}
-static virDomainMemballoonDefPtr
-virDomainMemballoonDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainMemballoonDef *
+virDomainMemballoonDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainMemballoonDefPtr def;
+ virDomainMemballoonDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
unsigned int period = 0;
g_autofree char *model = NULL;
return NULL;
}
-static virDomainNVRAMDefPtr
-virDomainNVRAMDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainNVRAMDef *
+virDomainNVRAMDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainNVRAMDefPtr def;
+ virDomainNVRAMDef *def;
def = g_new0(virDomainNVRAMDef, 1);
return NULL;
}
-static virDomainShmemDefPtr
-virDomainShmemDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainShmemDef *
+virDomainShmemDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainShmemDefPtr def = NULL;
- virDomainShmemDefPtr ret = NULL;
+ virDomainShmemDef *def = NULL;
+ virDomainShmemDef *ret = NULL;
xmlNodePtr msi = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr server = NULL;
static int
virSysinfoBIOSParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virSysinfoBIOSDefPtr *bios)
+ virSysinfoBIOSDef **bios)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int ret = -1;
- virSysinfoBIOSDefPtr def;
+ virSysinfoBIOSDef *def;
ctxt->node = node;
static int
virSysinfoSystemParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virSysinfoSystemDefPtr *sysdef,
+ virSysinfoSystemDef **sysdef,
unsigned char *domUUID,
bool uuid_generated)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int ret = -1;
- virSysinfoSystemDefPtr def;
+ virSysinfoSystemDef *def;
g_autofree char *tmpUUID = NULL;
ctxt->node = node;
static int
virSysinfoBaseBoardParseXML(xmlXPathContextPtr ctxt,
- virSysinfoBaseBoardDefPtr *baseBoard,
+ virSysinfoBaseBoardDef **baseBoard,
size_t *nbaseBoard)
{
size_t i, nboards = 0;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int n;
- g_autofree virSysinfoBaseBoardDefPtr boards = NULL;
+ g_autofree virSysinfoBaseBoardDef *boards = NULL;
g_autofree xmlNodePtr *nodes = NULL;
if ((n = virXPathNodeSet("./baseBoard", ctxt, &nodes)) < 0)
boards = g_new0(virSysinfoBaseBoardDef, n);
for (i = 0; i < n; i++) {
- virSysinfoBaseBoardDefPtr def = boards + nboards;
+ virSysinfoBaseBoardDef *def = boards + nboards;
ctxt->node = nodes[i];
static int
virSysinfoOEMStringsParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virSysinfoOEMStringsDefPtr *oem)
+ virSysinfoOEMStringsDef **oem)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int ret = -1;
- virSysinfoOEMStringsDefPtr def;
+ virSysinfoOEMStringsDef *def;
int nstrings;
size_t i;
g_autofree xmlNodePtr *strings = NULL;
static int
virSysinfoChassisParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virSysinfoChassisDefPtr *chassisdef)
+ virSysinfoChassisDef **chassisdef)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int ret = -1;
- virSysinfoChassisDefPtr def;
+ virSysinfoChassisDef *def;
ctxt->node = node;
static int
-virSysinfoParseSMBIOSDef(virSysinfoDefPtr def,
+virSysinfoParseSMBIOSDef(virSysinfoDef *def,
xmlXPathContextPtr ctxt,
unsigned char *domUUID,
bool uuid_generated)
static int
-virSysinfoParseFWCfgDef(virSysinfoDefPtr def,
+virSysinfoParseFWCfgDef(virSysinfoDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
}
-static virSysinfoDefPtr
+static virSysinfoDef *
virSysinfoParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned char *domUUID,
bool uuid_generated)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virSysinfoDefPtr def;
+ virSysinfoDef *def;
g_autofree char *typeStr = NULL;
int type;
}
-static virDomainVideoAccelDefPtr
+static virDomainVideoAccelDef *
virDomainVideoAccelDefParseXML(xmlNodePtr node)
{
- g_autofree virDomainVideoAccelDefPtr def = NULL;
+ g_autofree virDomainVideoAccelDef *def = NULL;
int val;
g_autofree char *accel2d = NULL;
g_autofree char *accel3d = NULL;
return g_steal_pointer(&def);
}
-static virDomainVideoResolutionDefPtr
+static virDomainVideoResolutionDef *
virDomainVideoResolutionDefParseXML(xmlNodePtr node)
{
- g_autofree virDomainVideoResolutionDefPtr def = NULL;
+ g_autofree virDomainVideoResolutionDef *def = NULL;
g_autofree char *x = NULL;
g_autofree char *y = NULL;
return g_steal_pointer(&def);
}
-static virDomainVideoDriverDefPtr
+static virDomainVideoDriverDef *
virDomainVideoDriverDefParseXML(xmlNodePtr node)
{
xmlNodePtr cur;
- virDomainVideoDriverDefPtr def;
+ virDomainVideoDriverDef *def;
int val;
g_autofree char *vgaconf = NULL;
return def;
}
-static virDomainVideoDefPtr
-virDomainVideoDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainVideoDef *
+virDomainVideoDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
return g_steal_pointer(&def);
}
-static virDomainHostdevDefPtr
-virDomainHostdevDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainHostdevDef *
+virDomainHostdevDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virDomainHostdevDefPtr def;
+ virDomainHostdevDef *def;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *mode = virXMLPropString(node, "mode");
g_autofree char *type = virXMLPropString(node, "type");
}
-static virDomainRedirdevDefPtr
-virDomainRedirdevDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainRedirdevDef *
+virDomainRedirdevDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
xmlNodePtr cur;
- virDomainRedirdevDefPtr def;
+ virDomainRedirdevDef *def;
g_autofree char *bus = NULL;
g_autofree char *type = NULL;
*/
static int
virDomainRedirFilterUSBVersionHelper(const char *version,
- virDomainRedirFilterUSBDevDefPtr def)
+ virDomainRedirFilterUSBDevDef *def)
{
unsigned int major, minor;
char *s = NULL;
return -1;
}
-static virDomainRedirFilterUSBDevDefPtr
+static virDomainRedirFilterUSBDevDef *
virDomainRedirFilterUSBDevDefParseXML(xmlNodePtr node)
{
- virDomainRedirFilterUSBDevDefPtr def;
+ virDomainRedirFilterUSBDevDef *def;
g_autofree char *class = NULL;
g_autofree char *vendor = NULL;
g_autofree char *product = NULL;
return NULL;
}
-static virDomainRedirFilterDefPtr
+static virDomainRedirFilterDef *
virDomainRedirFilterDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
int n;
size_t i;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainRedirFilterDefPtr def = NULL;
+ virDomainRedirFilterDef *def = NULL;
g_autofree xmlNodePtr *nodes = NULL;
def = g_new0(virDomainRedirFilterDef, 1);
goto error;
if (n)
- def->usbdevs = g_new0(virDomainRedirFilterUSBDevDefPtr, n);
+ def->usbdevs = g_new0(virDomainRedirFilterUSBDevDef *, n);
for (i = 0; i < n; i++) {
- virDomainRedirFilterUSBDevDefPtr usbdev =
+ virDomainRedirFilterUSBDevDef *usbdev =
virDomainRedirFilterUSBDevDefParseXML(nodes[i]);
if (!usbdev)
static int
-virDomainPerfEventDefParseXML(virDomainPerfDefPtr perf,
+virDomainPerfEventDefParseXML(virDomainPerfDef *perf,
xmlNodePtr node)
{
int event;
}
static int
-virDomainPerfDefParseXML(virDomainDefPtr def,
+virDomainPerfDefParseXML(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
size_t i;
static int
virDomainMemorySourceDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainMemoryDefPtr def)
+ virDomainMemoryDef *def)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *nodemask = NULL;
static int
virDomainMemoryTargetDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainMemoryDefPtr def)
+ virDomainMemoryDef *def)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int rv;
}
-static virDomainSEVDefPtr
+static virDomainSEVDef *
virDomainSEVDefParseXML(xmlNodePtr sevNode,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainSEVDefPtr def;
+ virDomainSEVDef *def;
unsigned long policy;
g_autofree char *type = NULL;
int rc = -1;
}
-static virDomainMemoryDefPtr
-virDomainMemoryDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainMemoryDef *
+virDomainMemoryDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr memdevNode,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr node;
- virDomainMemoryDefPtr def;
+ virDomainMemoryDef *def;
int val;
g_autofree char *tmp = NULL;
}
-static virDomainIOMMUDefPtr
+static virDomainIOMMUDef *
virDomainIOMMUDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
xmlNodePtr driver;
int val;
g_autofree char *tmp = NULL;
- g_autofree virDomainIOMMUDefPtr iommu = NULL;
+ g_autofree virDomainIOMMUDef *iommu = NULL;
ctxt->node = node;
}
-static virDomainVsockDefPtr
-virDomainVsockDefParseXML(virDomainXMLOptionPtr xmlopt,
+static virDomainVsockDef *
+virDomainVsockDefParseXML(virDomainXMLOption *xmlopt,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
unsigned int flags)
return g_steal_pointer(&vsock);
}
-virDomainDeviceDefPtr
+virDomainDeviceDef *
virDomainDeviceDefParse(const char *xmlStr,
const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
}
-virDomainDiskDefPtr
+virDomainDiskDef *
virDomainDiskDefParse(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_autoptr(xmlDoc) xml = NULL;
}
int
-virDomainHostdevInsert(virDomainDefPtr def, virDomainHostdevDefPtr hostdev)
+virDomainHostdevInsert(virDomainDef *def, virDomainHostdevDef *hostdev)
{
return VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev);
}
-virDomainHostdevDefPtr
-virDomainHostdevRemove(virDomainDefPtr def, size_t i)
+virDomainHostdevDef *
+virDomainHostdevRemove(virDomainDef *def, size_t i)
{
- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+ virDomainHostdevDef *hostdev = def->hostdevs[i];
VIR_DELETE_ELEMENT(def->hostdevs, i, def->nhostdevs);
return hostdev;
static int
-virDomainHostdevMatchSubsysUSB(virDomainHostdevDefPtr first,
- virDomainHostdevDefPtr second)
+virDomainHostdevMatchSubsysUSB(virDomainHostdevDef *first,
+ virDomainHostdevDef *second)
{
- virDomainHostdevSubsysUSBPtr first_usbsrc = &first->source.subsys.u.usb;
- virDomainHostdevSubsysUSBPtr second_usbsrc = &second->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *first_usbsrc = &first->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *second_usbsrc = &second->source.subsys.u.usb;
if (first_usbsrc->bus && first_usbsrc->device) {
/* specified by bus location on host */
}
static int
-virDomainHostdevMatchSubsysPCI(virDomainHostdevDefPtr first,
- virDomainHostdevDefPtr second)
+virDomainHostdevMatchSubsysPCI(virDomainHostdevDef *first,
+ virDomainHostdevDef *second)
{
- virDomainHostdevSubsysPCIPtr first_pcisrc = &first->source.subsys.u.pci;
- virDomainHostdevSubsysPCIPtr second_pcisrc = &second->source.subsys.u.pci;
+ virDomainHostdevSubsysPCI *first_pcisrc = &first->source.subsys.u.pci;
+ virDomainHostdevSubsysPCI *second_pcisrc = &second->source.subsys.u.pci;
if (first_pcisrc->addr.domain == second_pcisrc->addr.domain &&
first_pcisrc->addr.bus == second_pcisrc->addr.bus &&
}
static int
-virDomainHostdevMatchSubsysSCSIHost(virDomainHostdevDefPtr first,
- virDomainHostdevDefPtr second)
+virDomainHostdevMatchSubsysSCSIHost(virDomainHostdevDef *first,
+ virDomainHostdevDef *second)
{
- virDomainHostdevSubsysSCSIHostPtr first_scsihostsrc =
+ virDomainHostdevSubsysSCSIHost *first_scsihostsrc =
&first->source.subsys.u.scsi.u.host;
- virDomainHostdevSubsysSCSIHostPtr second_scsihostsrc =
+ virDomainHostdevSubsysSCSIHost *second_scsihostsrc =
&second->source.subsys.u.scsi.u.host;
if (STREQ(first_scsihostsrc->adapter, second_scsihostsrc->adapter) &&
}
static int
-virDomainHostdevMatchSubsysSCSIiSCSI(virDomainHostdevDefPtr first,
- virDomainHostdevDefPtr second)
+virDomainHostdevMatchSubsysSCSIiSCSI(virDomainHostdevDef *first,
+ virDomainHostdevDef *second)
{
- virDomainHostdevSubsysSCSIiSCSIPtr first_iscsisrc =
+ virDomainHostdevSubsysSCSIiSCSI *first_iscsisrc =
&first->source.subsys.u.scsi.u.iscsi;
- virDomainHostdevSubsysSCSIiSCSIPtr second_iscsisrc =
+ virDomainHostdevSubsysSCSIiSCSI *second_iscsisrc =
&second->source.subsys.u.scsi.u.iscsi;
if (STREQ(first_iscsisrc->src->hosts[0].name, second_iscsisrc->src->hosts[0].name) &&
}
static int
-virDomainHostdevMatchSubsysMediatedDev(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchSubsysMediatedDev(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
- virDomainHostdevSubsysMediatedDevPtr src_a = &a->source.subsys.u.mdev;
- virDomainHostdevSubsysMediatedDevPtr src_b = &b->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *src_a = &a->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *src_b = &b->source.subsys.u.mdev;
if (STREQ(src_a->uuidstr, src_b->uuidstr))
return 1;
}
static int
-virDomainHostdevMatchSubsys(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchSubsys(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
if (a->source.subsys.type != b->source.subsys.type)
return 0;
static int
-virDomainHostdevMatchCapsStorage(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchCapsStorage(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
return STREQ_NULLABLE(a->source.caps.u.storage.block,
b->source.caps.u.storage.block);
static int
-virDomainHostdevMatchCapsMisc(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchCapsMisc(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
return STREQ_NULLABLE(a->source.caps.u.misc.chardev,
b->source.caps.u.misc.chardev);
}
static int
-virDomainHostdevMatchCapsNet(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchCapsNet(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
return STREQ_NULLABLE(a->source.caps.u.net.ifname,
b->source.caps.u.net.ifname);
static int
-virDomainHostdevMatchCaps(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatchCaps(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
if (a->source.caps.type != b->source.caps.type)
return 0;
static int
-virDomainHostdevMatch(virDomainHostdevDefPtr a,
- virDomainHostdevDefPtr b)
+virDomainHostdevMatch(virDomainHostdevDef *a,
+ virDomainHostdevDef *b)
{
if (a->mode != b->mode)
return 0;
* if no match was found.
*/
int
-virDomainHostdevFind(virDomainDefPtr def,
- virDomainHostdevDefPtr match,
- virDomainHostdevDefPtr *found)
+virDomainHostdevFind(virDomainDef *def,
+ virDomainHostdevDef *match,
+ virDomainHostdevDef **found)
{
- virDomainHostdevDefPtr local_found;
+ virDomainHostdevDef *local_found;
size_t i;
if (!found)
int
-virDomainDiskIndexByAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr pci_address,
- virDomainDeviceCCWAddressPtr ccw_addr,
+virDomainDiskIndexByAddress(virDomainDef *def,
+ virPCIDeviceAddress *pci_address,
+ virDomainDeviceCCWAddress *ccw_addr,
unsigned int bus, unsigned int target,
unsigned int unit)
{
- virDomainDiskDefPtr vdisk;
- virDomainControllerDefPtr controller = NULL;
+ virDomainDiskDef *vdisk;
+ virDomainControllerDef *controller = NULL;
size_t i;
int cidx;
return i;
}
if (vdisk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
- virDomainDeviceDriveAddressPtr drive = &vdisk->info.addr.drive;
+ virDomainDeviceDriveAddress *drive = &vdisk->info.addr.drive;
if (controller &&
virDomainDiskControllerMatch(controller->type, vdisk->bus) &&
drive->controller == controller->idx &&
return -1;
}
-virDomainDiskDefPtr
-virDomainDiskByAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr pci_address,
- virDomainDeviceCCWAddressPtr ccw_addr,
+virDomainDiskDef *
+virDomainDiskByAddress(virDomainDef *def,
+ virPCIDeviceAddress *pci_address,
+ virDomainDeviceCCWAddress *ccw_addr,
unsigned int bus,
unsigned int target,
unsigned int unit)
}
int
-virDomainDiskIndexByName(virDomainDefPtr def, const char *name,
+virDomainDiskIndexByName(virDomainDef *def, const char *name,
bool allow_ambiguous)
{
- virDomainDiskDefPtr vdisk;
+ virDomainDiskDef *vdisk;
size_t i;
int candidate = -1;
return candidate;
}
-virDomainDiskDefPtr
-virDomainDiskByName(virDomainDefPtr def,
+virDomainDiskDef *
+virDomainDiskByName(virDomainDef *def,
const char *name,
bool allow_ambiguous)
{
}
-virDomainDiskDefPtr
-virDomainDiskByTarget(virDomainDefPtr def,
+virDomainDiskDef *
+virDomainDiskByTarget(virDomainDef *def,
const char *dst)
{
size_t i;
}
-void virDomainDiskInsert(virDomainDefPtr def,
- virDomainDiskDefPtr disk)
+void virDomainDiskInsert(virDomainDef *def,
+ virDomainDiskDef *disk)
{
- def->disks = g_renew(virDomainDiskDefPtr, def->disks, def->ndisks + 1);
+ def->disks = g_renew(virDomainDiskDef *, def->disks, def->ndisks + 1);
virDomainDiskInsertPreAlloced(def, disk);
}
-void virDomainDiskInsertPreAlloced(virDomainDefPtr def,
- virDomainDiskDefPtr disk)
+void virDomainDiskInsertPreAlloced(virDomainDef *def,
+ virDomainDiskDef *disk)
{
int idx;
/* Tentatively plan to insert disk at the end. */
}
-virDomainDiskDefPtr
-virDomainDiskRemove(virDomainDefPtr def, size_t i)
+virDomainDiskDef *
+virDomainDiskRemove(virDomainDef *def, size_t i)
{
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
VIR_DELETE_ELEMENT(def->disks, i, def->ndisks);
return disk;
}
-virDomainDiskDefPtr
-virDomainDiskRemoveByName(virDomainDefPtr def, const char *name)
+virDomainDiskDef *
+virDomainDiskRemoveByName(virDomainDef *def, const char *name)
{
int idx = virDomainDiskIndexByName(def, name, false);
if (idx < 0)
return virDomainDiskRemove(def, idx);
}
-int virDomainNetInsert(virDomainDefPtr def, virDomainNetDefPtr net)
+int virDomainNetInsert(virDomainDef *def, virDomainNetDef *net)
{
/* hostdev net devices must also exist in the hostdevs array */
if (net->type == VIR_DOMAIN_NET_TYPE_HOSTDEV &&
* -1 otherwise and an error is logged.
*/
int
-virDomainNetFindIdx(virDomainDefPtr def, virDomainNetDefPtr net)
+virDomainNetFindIdx(virDomainDef *def, virDomainNetDef *net)
{
size_t i;
int matchidx = -1;
}
bool
-virDomainHasNet(virDomainDefPtr def, virDomainNetDefPtr net)
+virDomainHasNet(virDomainDef *def, virDomainNetDef *net)
{
size_t i;
bool PCIAddrSpecified = virDomainDeviceAddressIsValid(&net->info,
}
void
-virDomainNetRemoveHostdev(virDomainDefPtr def,
- virDomainNetDefPtr net)
+virDomainNetRemoveHostdev(virDomainDef *def,
+ virDomainNetDef *net)
{
/* hostdev net devices are normally in the hostdevs array, but
* might have already been removed by the time we get here */
- virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);
+ virDomainHostdevDef *hostdev = virDomainNetGetActualHostdev(net);
size_t i;
if (hostdev) {
}
-virDomainNetDefPtr
-virDomainNetRemove(virDomainDefPtr def, size_t i)
+virDomainNetDef *
+virDomainNetRemove(virDomainDef *def, size_t i)
{
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
virDomainNetRemoveHostdev(def, net);
VIR_DELETE_ELEMENT(def->nets, i, def->nnets);
int
-virDomainNetUpdate(virDomainDefPtr def,
+virDomainNetUpdate(virDomainDef *def,
size_t netidx,
- virDomainNetDefPtr newnet)
+ virDomainNetDef *newnet)
{
size_t hostdevidx;
- virDomainNetDefPtr oldnet = def->nets[netidx];
- virDomainHostdevDefPtr oldhostdev = virDomainNetGetActualHostdev(oldnet);
- virDomainHostdevDefPtr newhostdev = virDomainNetGetActualHostdev(newnet);
+ virDomainNetDef *oldnet = def->nets[netidx];
+ virDomainHostdevDef *oldhostdev = virDomainNetGetActualHostdev(oldnet);
+ virDomainHostdevDef *newhostdev = virDomainNetGetActualHostdev(newnet);
/*
* if newnet or oldnet has a valid hostdev*, we need to update the
int
-virDomainNetDHCPInterfaces(virDomainDefPtr def,
+virDomainNetDHCPInterfaces(virDomainDef *def,
virDomainInterfacePtr **ifaces)
{
g_autoptr(virConnect) conn = NULL;
int
-virDomainNetARPInterfaces(virDomainDefPtr def,
+virDomainNetARPInterfaces(virDomainDef *def,
virDomainInterfacePtr **ifaces)
{
size_t i, j;
char macaddr[VIR_MAC_STRING_BUFLEN];
virDomainInterfacePtr *ifaces_ret = NULL;
virDomainInterfacePtr iface = NULL;
- virArpTablePtr table;
+ virArpTable *table;
table = virArpTableGet();
if (!table)
}
-void virDomainControllerInsert(virDomainDefPtr def,
- virDomainControllerDefPtr controller)
+void virDomainControllerInsert(virDomainDef *def,
+ virDomainControllerDef *controller)
{
- def->controllers = g_renew(virDomainControllerDefPtr, def->controllers, def->ncontrollers + 1);
+ def->controllers = g_renew(virDomainControllerDef *, def->controllers, def->ncontrollers + 1);
virDomainControllerInsertPreAlloced(def, controller);
}
-void virDomainControllerInsertPreAlloced(virDomainDefPtr def,
- virDomainControllerDefPtr controller)
+void virDomainControllerInsertPreAlloced(virDomainDef *def,
+ virDomainControllerDef *controller)
{
int idx;
/* Tentatively plan to insert controller at the end. */
int insertAt = -1;
- virDomainControllerDefPtr current = NULL;
+ virDomainControllerDef *current = NULL;
/* Then work backwards looking for controllers of
* the same type. If we find a controller with a
int
-virDomainControllerFindByType(virDomainDefPtr def,
+virDomainControllerFindByType(virDomainDef *def,
int type)
{
size_t i;
}
int
-virDomainControllerFindByCCWAddress(virDomainDefPtr def,
- virDomainDeviceCCWAddressPtr addr)
+virDomainControllerFindByCCWAddress(virDomainDef *def,
+ virDomainDeviceCCWAddress *addr)
{
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainDeviceInfoPtr info = &def->controllers[i]->info;
+ virDomainDeviceInfo *info = &def->controllers[i]->info;
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW &&
virDomainDeviceCCWAddressEqual(&info->addr.ccw, addr))
}
int
-virDomainControllerFindByPCIAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr addr)
+virDomainControllerFindByPCIAddress(virDomainDef *def,
+ virPCIDeviceAddress *addr)
{
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainDeviceInfoPtr info = &def->controllers[i]->info;
+ virDomainDeviceInfo *info = &def->controllers[i]->info;
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
virPCIDeviceAddressEqual(&info->addr.pci, addr))
return -1;
}
-virDomainControllerDefPtr
-virDomainControllerRemove(virDomainDefPtr def, size_t i)
+virDomainControllerDef *
+virDomainControllerRemove(virDomainDef *def, size_t i)
{
- virDomainControllerDefPtr controller = def->controllers[i];
+ virDomainControllerDef *controller = def->controllers[i];
VIR_DELETE_ELEMENT(def->controllers, i, def->ncontrollers);
return controller;
}
-int virDomainLeaseIndex(virDomainDefPtr def,
- virDomainLeaseDefPtr lease)
+int virDomainLeaseIndex(virDomainDef *def,
+ virDomainLeaseDef *lease)
{
- virDomainLeaseDefPtr vlease;
+ virDomainLeaseDef *vlease;
size_t i;
for (i = 0; i < def->nleases; i++) {
}
-void virDomainLeaseInsertPreAlloc(virDomainDefPtr def)
+void virDomainLeaseInsertPreAlloc(virDomainDef *def)
{
- def->leases = g_renew(virDomainLeaseDefPtr, def->leases, def->nleases + 1);
+ def->leases = g_renew(virDomainLeaseDef *, def->leases, def->nleases + 1);
}
-void virDomainLeaseInsert(virDomainDefPtr def, virDomainLeaseDefPtr lease)
+void virDomainLeaseInsert(virDomainDef *def, virDomainLeaseDef *lease)
{
virDomainLeaseInsertPreAlloc(def);
virDomainLeaseInsertPreAlloced(def, lease);
}
-void virDomainLeaseInsertPreAlloced(virDomainDefPtr def,
- virDomainLeaseDefPtr lease)
+void virDomainLeaseInsertPreAlloced(virDomainDef *def,
+ virDomainLeaseDef *lease)
{
if (lease == NULL)
VIR_SHRINK_N(def->leases, def->nleases, 1);
}
-virDomainLeaseDefPtr
-virDomainLeaseRemoveAt(virDomainDefPtr def, size_t i)
+virDomainLeaseDef *
+virDomainLeaseRemoveAt(virDomainDef *def, size_t i)
{
- virDomainLeaseDefPtr lease = def->leases[i];
+ virDomainLeaseDef *lease = def->leases[i];
VIR_DELETE_ELEMENT(def->leases, i, def->nleases);
return lease;
}
-virDomainLeaseDefPtr
-virDomainLeaseRemove(virDomainDefPtr def,
- virDomainLeaseDefPtr lease)
+virDomainLeaseDef *
+virDomainLeaseRemove(virDomainDef *def,
+ virDomainLeaseDef *lease)
{
int idx = virDomainLeaseIndex(def, lease);
if (idx < 0)
}
bool
-virDomainChrEquals(virDomainChrDefPtr src,
- virDomainChrDefPtr tgt)
+virDomainChrEquals(virDomainChrDef *src,
+ virDomainChrDef *tgt)
{
if (!src || !tgt)
return src == tgt;
return false;
}
-virDomainChrDefPtr
-virDomainChrFind(virDomainDefPtr def,
- virDomainChrDefPtr target)
+virDomainChrDef *
+virDomainChrFind(virDomainDef *def,
+ virDomainChrDef *target)
{
- virDomainChrDefPtr chr;
+ virDomainChrDef *chr;
const virDomainChrDef **arrPtr;
size_t i, cnt;
for (i = 0; i < cnt; i++) {
/* Cast away const */
- chr = (virDomainChrDefPtr) arrPtr[i];
+ chr = (virDomainChrDef *) arrPtr[i];
if (virDomainChrEquals(chr, target))
return chr;
}
/* Return the address within vmdef to be modified when working with a
* chrdefptr of the given type. */
static int G_GNUC_WARN_UNUSED_RESULT
-virDomainChrGetDomainPtrsInternal(virDomainDefPtr vmdef,
+virDomainChrGetDomainPtrsInternal(virDomainDef *vmdef,
virDomainChrDeviceType type,
- virDomainChrDefPtr ***arrPtr,
+ virDomainChrDef ****arrPtr,
size_t **cntPtr)
{
switch (type) {
size_t *cntVar = NULL;
/* Cast away const; we add it back in the final assignment. */
- if (virDomainChrGetDomainPtrsInternal((virDomainDefPtr) vmdef, type,
+ if (virDomainChrGetDomainPtrsInternal((virDomainDef *) vmdef, type,
&arrVar, &cntVar) < 0) {
*arrPtr = NULL;
*cntPtr = 0;
int
-virDomainChrPreAlloc(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+virDomainChrPreAlloc(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
- virDomainChrDefPtr **arrPtr = NULL;
+ virDomainChrDef ***arrPtr = NULL;
size_t *cntPtr = NULL;
if (virDomainChrGetDomainPtrsInternal(vmdef, chr->deviceType,
}
void
-virDomainChrInsertPreAlloced(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+virDomainChrInsertPreAlloced(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
- virDomainChrDefPtr **arrPtr = NULL;
+ virDomainChrDef ***arrPtr = NULL;
size_t *cntPtr = NULL;
if (virDomainChrGetDomainPtrsInternal(vmdef, chr->deviceType,
VIR_APPEND_ELEMENT_INPLACE(*arrPtr, *cntPtr, chr);
}
-virDomainChrDefPtr
-virDomainChrRemove(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+virDomainChrDef *
+virDomainChrRemove(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
- virDomainChrDefPtr ret = NULL;
- virDomainChrDefPtr **arrPtr = NULL;
+ virDomainChrDef *ret = NULL;
+ virDomainChrDef ***arrPtr = NULL;
size_t i, *cntPtr = NULL;
if (virDomainChrGetDomainPtrsInternal(vmdef, chr->deviceType,
ssize_t
-virDomainRNGFind(virDomainDefPtr def,
- virDomainRNGDefPtr rng)
+virDomainRNGFind(virDomainDef *def,
+ virDomainRNGDef *rng)
{
size_t i;
for (i = 0; i < def->nrngs; i++) {
- virDomainRNGDefPtr tmp = def->rngs[i];
+ virDomainRNGDef *tmp = def->rngs[i];
if (rng->model != tmp->model || rng->backend != tmp->backend)
continue;
}
-virDomainRNGDefPtr
-virDomainRNGRemove(virDomainDefPtr def,
+virDomainRNGDef *
+virDomainRNGRemove(virDomainDef *def,
size_t idx)
{
- virDomainRNGDefPtr ret = def->rngs[idx];
+ virDomainRNGDef *ret = def->rngs[idx];
VIR_DELETE_ELEMENT(def->rngs, idx, def->nrngs);
static int
-virDomainMemoryFindByDefInternal(virDomainDefPtr def,
- virDomainMemoryDefPtr mem,
+virDomainMemoryFindByDefInternal(virDomainDef *def,
+ virDomainMemoryDef *mem,
bool allowAddressFallback)
{
size_t i;
for (i = 0; i < def->nmems; i++) {
- virDomainMemoryDefPtr tmp = def->mems[i];
+ virDomainMemoryDef *tmp = def->mems[i];
/* address, if present */
if (allowAddressFallback) {
int
-virDomainMemoryFindByDef(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virDomainMemoryFindByDef(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
return virDomainMemoryFindByDefInternal(def, mem, false);
}
int
-virDomainMemoryFindInactiveByDef(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virDomainMemoryFindInactiveByDef(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
int ret;
* total memory size.
*/
int
-virDomainMemoryInsert(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virDomainMemoryInsert(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
unsigned long long memory = virDomainDefGetMemoryTotal(def);
int id = def->nmems;
* should be used only in hot/cold-plug cases as it's blindly modifying the
* total memory size.
*/
-virDomainMemoryDefPtr
-virDomainMemoryRemove(virDomainDefPtr def,
+virDomainMemoryDef *
+virDomainMemoryRemove(virDomainDef *def,
int idx)
{
unsigned long long memory = virDomainDefGetMemoryTotal(def);
- virDomainMemoryDefPtr ret = def->mems[idx];
+ virDomainMemoryDef *ret = def->mems[idx];
VIR_DELETE_ELEMENT(def->mems, idx, def->nmems);
ssize_t
-virDomainRedirdevDefFind(virDomainDefPtr def,
- virDomainRedirdevDefPtr redirdev)
+virDomainRedirdevDefFind(virDomainDef *def,
+ virDomainRedirdevDef *redirdev)
{
size_t i;
for (i = 0; i < def->nredirdevs; i++) {
- virDomainRedirdevDefPtr tmp = def->redirdevs[i];
+ virDomainRedirdevDef *tmp = def->redirdevs[i];
if (redirdev->bus != tmp->bus)
continue;
}
-virDomainRedirdevDefPtr
-virDomainRedirdevDefRemove(virDomainDefPtr def, size_t idx)
+virDomainRedirdevDef *
+virDomainRedirdevDefRemove(virDomainDef *def, size_t idx)
{
- virDomainRedirdevDefPtr ret = def->redirdevs[idx];
+ virDomainRedirdevDef *ret = def->redirdevs[idx];
VIR_DELETE_ELEMENT(def->redirdevs, idx, def->nredirdevs);
int
-virDomainShmemDefInsert(virDomainDefPtr def,
- virDomainShmemDefPtr shmem)
+virDomainShmemDefInsert(virDomainDef *def,
+ virDomainShmemDef *shmem)
{
return VIR_APPEND_ELEMENT(def->shmems, def->nshmems, shmem);
}
bool
-virDomainShmemDefEquals(virDomainShmemDefPtr src,
- virDomainShmemDefPtr dst)
+virDomainShmemDefEquals(virDomainShmemDef *src,
+ virDomainShmemDef *dst)
{
if (STRNEQ_NULLABLE(src->name, dst->name))
return false;
ssize_t
-virDomainShmemDefFind(virDomainDefPtr def,
- virDomainShmemDefPtr shmem)
+virDomainShmemDefFind(virDomainDef *def,
+ virDomainShmemDef *shmem)
{
size_t i;
}
-virDomainShmemDefPtr
-virDomainShmemDefRemove(virDomainDefPtr def,
+virDomainShmemDef *
+virDomainShmemDefRemove(virDomainDef *def,
size_t idx)
{
- virDomainShmemDefPtr ret = def->shmems[idx];
+ virDomainShmemDef *ret = def->shmems[idx];
VIR_DELETE_ELEMENT(def->shmems, idx, def->nshmems);
char *
-virDomainDefGetDefaultEmulator(virDomainDefPtr def,
- virCapsPtr caps)
+virDomainDefGetDefaultEmulator(virDomainDef *def,
+ virCaps *caps)
{
char *retemu;
- g_autofree virCapsDomainDataPtr capsdata = NULL;
+ g_autofree virCapsDomainData *capsdata = NULL;
if (!(capsdata = virCapabilitiesDomainDataLookup(caps, def->os.type,
def->os.arch, def->virtType, NULL, NULL)))
static int
virDomainDefParseBootXML(xmlXPathContextPtr ctxt,
- virDomainDefPtr def)
+ virDomainDef *def)
{
xmlNodePtr node;
size_t i;
* <uid start='0' target='1000' count='10'/>
* <gid start='0' target='1000' count='10'/>
*/
-static virDomainIdMapEntryPtr
+static virDomainIdMapEntry *
virDomainIdmapDefParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr *node,
size_t num)
{
size_t i;
- virDomainIdMapEntryPtr idmap = NULL;
+ virDomainIdMapEntry *idmap = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
idmap = g_new0(virDomainIdMapEntry, num);
* <iothread id='7'/>
* </iothreadids>
*/
-static virDomainIOThreadIDDefPtr
+static virDomainIOThreadIDDef *
virDomainIOThreadIDDefParseXML(xmlNodePtr node)
{
- virDomainIOThreadIDDefPtr iothrid;
+ virDomainIOThreadIDDef *iothrid;
g_autofree char *tmp = NULL;
iothrid = g_new0(virDomainIOThreadIDDef, 1);
static int
-virDomainDefParseIOThreads(virDomainDefPtr def,
+virDomainDefParseIOThreads(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
size_t i;
iothreads = n;
if (n)
- def->iothreadids = g_new0(virDomainIOThreadIDDefPtr, n);
+ def->iothreadids = g_new0(virDomainIOThreadIDDef *, n);
for (i = 0; i < n; i++) {
- virDomainIOThreadIDDefPtr iothrid = NULL;
+ virDomainIOThreadIDDef *iothrid = NULL;
if (!(iothrid = virDomainIOThreadIDDefParseXML(nodes[i])))
return -1;
* <vcpupin vcpu='0' cpuset='0'/>
*/
static int
-virDomainVcpuPinDefParseXML(virDomainDefPtr def,
+virDomainVcpuPinDefParseXML(virDomainDef *def,
xmlNodePtr node)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
unsigned int vcpuid;
g_autofree char *tmp = NULL;
*/
static int
virDomainIOThreadPinDefParseXML(xmlNodePtr node,
- virDomainDefPtr def)
+ virDomainDef *def)
{
- virDomainIOThreadIDDefPtr iothrid;
+ virDomainIOThreadIDDef *iothrid;
unsigned int iothreadid;
g_autofree char *tmp = NULL;
g_autoptr(virBitmap) cpumask = NULL;
* emulatorpin has the form of
* <emulatorpin cpuset='0'/>
*/
-static virBitmapPtr
+static virBitmap *
virDomainEmulatorPinDefParseXML(xmlNodePtr node)
{
g_autofree char *tmp = NULL;
}
-virDomainControllerDefPtr
-virDomainDefAddController(virDomainDefPtr def, int type, int idx, int model)
+virDomainControllerDef *
+virDomainDefAddController(virDomainDef *def, int type, int idx, int model)
{
- virDomainControllerDefPtr cont;
+ virDomainControllerDef *cont;
if (!(cont = virDomainControllerDefNew(type)))
return NULL;
* Returns 0 on success, -1 on failure.
*/
int
-virDomainDefAddUSBController(virDomainDefPtr def, int idx, int model)
+virDomainDefAddUSBController(virDomainDef *def, int idx, int model)
{
- virDomainControllerDefPtr cont; /* this is a *copy* of the DefPtr */
+ virDomainControllerDef *cont; /* this is a *copy* of the virDomainControllerDef */
cont = virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_USB,
idx, model);
int
-virDomainDefMaybeAddController(virDomainDefPtr def,
+virDomainDefMaybeAddController(virDomainDef *def,
int type,
int idx,
int model)
int
-virDomainDefMaybeAddInput(virDomainDefPtr def,
+virDomainDefMaybeAddInput(virDomainDef *def,
int type,
int bus)
{
size_t i;
- virDomainInputDefPtr input;
+ virDomainInputDef *input;
for (i = 0; i < def->ninputs; i++) {
if (def->inputs[i]->type == type &&
static int
virDomainHugepagesParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainHugePagePtr hugepage)
+ virDomainHugePage *hugepage)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *nodeset = NULL;
}
-static virDomainResourceDefPtr
+static virDomainResourceDef *
virDomainResourceDefParse(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainResourceDefPtr def = NULL;
+ virDomainResourceDef *def = NULL;
ctxt->node = node;
static int
-virDomainFeaturesDefParse(virDomainDefPtr def,
+virDomainFeaturesDefParse(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-virDomainDefMaybeAddHostdevSCSIcontroller(virDomainDefPtr def)
+virDomainDefMaybeAddHostdevSCSIcontroller(virDomainDef *def)
{
/* Look for any hostdev scsi dev */
size_t i;
int maxController = -1;
- virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDef *hostdev;
int newModel = -1;
for (i = 0; i < def->nhostdevs; i++) {
hostdev = def->hostdevs[i];
if (virHostdevIsSCSIDevice(hostdev) &&
(int)hostdev->info->addr.drive.controller > maxController) {
- virDomainControllerDefPtr cont;
+ virDomainControllerDef *cont;
maxController = hostdev->info->addr.drive.controller;
/* We may be creating a new controller because this one is full.
static int
virDomainLoaderDefParseXML(xmlNodePtr node,
- virDomainLoaderDefPtr loader,
+ virDomainLoaderDef *loader,
bool fwAutoSelect)
{
g_autofree char *readonly_str = NULL;
static int
virDomainEmulatorSchedParse(xmlNodePtr node,
- virDomainDefPtr def)
+ virDomainDef *def)
{
- g_autofree virDomainThreadSchedParamPtr sched = NULL;
+ g_autofree virDomainThreadSchedParam *sched = NULL;
sched = g_new0(virDomainThreadSchedParam, 1);
}
-static virBitmapPtr
+static virBitmap *
virDomainSchedulerParse(xmlNodePtr node,
const char *elementName,
const char *attributeName,
virProcessSchedPolicy *policy,
int *priority)
{
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
g_autofree char *tmp = NULL;
if (!(tmp = virXMLPropString(node, attributeName))) {
virDomainThreadSchedParseHelper(xmlNodePtr node,
const char *elementName,
const char *attributeName,
- virDomainThreadSchedParamPtr (*func)(virDomainDefPtr, unsigned int),
- virDomainDefPtr def)
+ virDomainThreadSchedParam *(*func)(virDomainDef *, unsigned int),
+ virDomainDef *def)
{
ssize_t next = -1;
- virDomainThreadSchedParamPtr sched = NULL;
+ virDomainThreadSchedParam *sched = NULL;
virProcessSchedPolicy policy = 0;
int priority = 0;
g_autoptr(virBitmap) map = NULL;
static int
virDomainVcpuThreadSchedParse(xmlNodePtr node,
- virDomainDefPtr def)
+ virDomainDef *def)
{
return virDomainThreadSchedParseHelper(node,
"vcpusched",
}
-static virDomainThreadSchedParamPtr
-virDomainDefGetIOThreadSched(virDomainDefPtr def,
+static virDomainThreadSchedParam *
+virDomainDefGetIOThreadSched(virDomainDef *def,
unsigned int iothread)
{
- virDomainIOThreadIDDefPtr iothrinfo;
+ virDomainIOThreadIDDef *iothrinfo;
if (!(iothrinfo = virDomainIOThreadIDFind(def, iothread))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
virDomainIOThreadSchedParse(xmlNodePtr node,
- virDomainDefPtr def)
+ virDomainDef *def)
{
return virDomainThreadSchedParseHelper(node,
"iothreadsched",
static int
-virDomainVcpuParse(virDomainDefPtr def,
+virDomainVcpuParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
int n;
xmlNodePtr vcpuNode;
def->individualvcpus = true;
for (i = 0; i < n; i++) {
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
int state;
unsigned int id;
unsigned int order;
static int
-virDomainDefParseBootInitOptions(virDomainDefPtr def,
+virDomainDefParseBootInitOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
char *name = NULL;
if ((n = virXPathNodeSet("./os/initenv", ctxt, &nodes)) < 0)
return -1;
- def->os.initenv = g_new0(virDomainOSEnvPtr, n+1);
+ def->os.initenv = g_new0(virDomainOSEnv *, n + 1);
for (i = 0; i < n; i++) {
if (!(name = virXMLPropString(nodes[i], "name"))) {
virReportError(VIR_ERR_XML_ERROR, "%s",
static void
-virDomainDefParseBootKernelOptions(virDomainDefPtr def,
+virDomainDefParseBootKernelOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
def->os.kernel = virXPathString("string(./os/kernel[1])", ctxt);
static int
-virDomainDefParseBootFirmwareOptions(virDomainDefPtr def,
+virDomainDefParseBootFirmwareOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
g_autofree char *firmware = virXPathString("string(./os/@firmware)", ctxt);
static int
-virDomainDefParseBootLoaderOptions(virDomainDefPtr def,
+virDomainDefParseBootLoaderOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr loader_node = virXPathNode("./os/loader[1]", ctxt);
static int
-virDomainDefParseBootAcpiOptions(virDomainDefPtr def,
+virDomainDefParseBootAcpiOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
int n;
static int
-virDomainDefParseBootOptions(virDomainDefPtr def,
+virDomainDefParseBootOptions(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
/*
static int
-virDomainResctrlParseVcpus(virDomainDefPtr def,
+virDomainResctrlParseVcpus(virDomainDef *def,
xmlNodePtr node,
- virBitmapPtr *vcpus)
+ virBitmap **vcpus)
{
g_autofree char *vcpus_str = NULL;
static int
-virDomainResctrlVcpuMatch(virDomainDefPtr def,
- virBitmapPtr vcpus,
- virDomainResctrlDefPtr *resctrl)
+virDomainResctrlVcpuMatch(virDomainDef *def,
+ virBitmap *vcpus,
+ virDomainResctrlDef **resctrl)
{
ssize_t i = 0;
static int
virDomainCachetuneDefParseCache(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virResctrlAllocPtr alloc)
+ virResctrlAlloc *alloc)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
unsigned int level;
* not equal to @resctrl->vcpus.
*/
static int
-virDomainResctrlValidateMonitor(virDomainResctrlDefPtr resctrl,
- virDomainResctrlMonDefPtr monitor)
+virDomainResctrlValidateMonitor(virDomainResctrlDef *resctrl,
+ virDomainResctrlMonDef *monitor)
{
size_t i = 0;
int vcpu = -1;
#define VIR_DOMAIN_RESCTRL_MONITOR_CACHELEVEL 3
static int
-virDomainResctrlMonDefParse(virDomainDefPtr def,
+virDomainResctrlMonDefParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
xmlNodePtr node,
virResctrlMonitorType tag,
- virDomainResctrlDefPtr resctrl)
+ virDomainResctrlDef *resctrl)
{
- virDomainResctrlMonDefPtr domresmon = NULL;
+ virDomainResctrlMonDef *domresmon = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
unsigned int level = 0;
size_t i = 0;
}
-static virDomainResctrlDefPtr
+static virDomainResctrlDef *
virDomainResctrlNew(xmlNodePtr node,
- virResctrlAllocPtr alloc,
- virBitmapPtr vcpus,
+ virResctrlAlloc *alloc,
+ virBitmap *vcpus,
unsigned int flags)
{
- virDomainResctrlDefPtr resctrl = NULL;
+ virDomainResctrlDef *resctrl = NULL;
g_autofree char *vcpus_str = NULL;
g_autofree char *alloc_id = NULL;
static int
-virDomainCachetuneDefParse(virDomainDefPtr def,
+virDomainCachetuneDefParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
xmlNodePtr node,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainResctrlDefPtr resctrl = NULL;
+ virDomainResctrlDef *resctrl = NULL;
ssize_t i = 0;
int n;
int ret = -1;
static int
-virDomainDefParseIDs(virDomainDefPtr def,
+virDomainDefParseIDs(virDomainDef *def,
xmlXPathContextPtr ctxt,
unsigned int flags,
bool *uuid_generated)
static int
-virDomainDefParseCaps(virDomainDefPtr def,
+virDomainDefParseCaps(virDomainDef *def,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_autofree char *virttype = NULL;
g_autofree char *arch = NULL;
static int
-virDomainDefParseMemory(virDomainDefPtr def,
+virDomainDefParseMemory(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
virDomainMemorytuneDefParseMemory(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virResctrlAllocPtr alloc)
+ virResctrlAlloc *alloc)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
unsigned int id;
static int
-virDomainMemorytuneDefParse(virDomainDefPtr def,
+virDomainMemorytuneDefParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
xmlNodePtr node,
unsigned int flags)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainResctrlDefPtr resctrl = NULL;
- virDomainResctrlDefPtr newresctrl = NULL;
+ virDomainResctrlDef *resctrl = NULL;
+ virDomainResctrlDef *newresctrl = NULL;
g_autoptr(virBitmap) vcpus = NULL;
g_autofree xmlNodePtr *nodes = NULL;
g_autoptr(virResctrlAlloc) alloc = NULL;
static int
-virDomainDefTunablesParse(virDomainDefPtr def,
+virDomainDefTunablesParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-virDomainDefLifecycleParse(virDomainDefPtr def,
+virDomainDefLifecycleParse(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
if (virDomainEventActionParseXML(ctxt, "on_reboot",
static int
-virDomainDefClockParse(virDomainDefPtr def,
+virDomainDefClockParse(virDomainDef *def,
xmlXPathContextPtr ctxt)
{
size_t i;
goto error;
if (n)
- def->clock.timers = g_new0(virDomainTimerDefPtr, n);
+ def->clock.timers = g_new0(virDomainTimerDef *, n);
for (i = 0; i < n; i++) {
- virDomainTimerDefPtr timer = virDomainTimerDefParseXML(nodes[i],
- ctxt);
+ virDomainTimerDef *timer = virDomainTimerDefParseXML(nodes[i], ctxt);
+
if (!timer)
goto error;
}
static int
-virDomainDefControllersParse(virDomainDefPtr def,
+virDomainDefControllersParse(virDomainDef *def,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags,
bool *usb_none)
{
return -1;
if (n)
- def->controllers = g_new0(virDomainControllerDefPtr, n);
+ def->controllers = g_new0(virDomainControllerDef *, n);
for (i = 0; i < n; i++) {
g_autoptr(virDomainControllerDef) controller = NULL;
return 0;
}
-static virDomainDefPtr
+static virDomainDef *
virDomainDefParseXML(xmlDocPtr xml,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
xmlNodePtr node = NULL;
size_t i, j;
int n;
- virDomainDefPtr def;
+ virDomainDef *def;
bool uuid_generated = false;
bool usb_none = false;
g_autofree xmlNodePtr *nodes = NULL;
goto error;
if (n)
- def->disks = g_new0(virDomainDiskDefPtr, n);
+ def->disks = g_new0(virDomainDiskDef *, n);
for (i = 0; i < n; i++) {
- virDomainDiskDefPtr disk = virDomainDiskDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainDiskDef *disk = virDomainDiskDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!disk)
goto error;
goto error;
}
if (n)
- def->leases = g_new0(virDomainLeaseDefPtr, n);
+ def->leases = g_new0(virDomainLeaseDef *, n);
for (i = 0; i < n; i++) {
- virDomainLeaseDefPtr lease = virDomainLeaseDefParseXML(nodes[i]);
+ virDomainLeaseDef *lease = virDomainLeaseDefParseXML(nodes[i]);
if (!lease)
goto error;
if ((n = virXPathNodeSet("./devices/filesystem", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->fss = g_new0(virDomainFSDefPtr, n);
+ def->fss = g_new0(virDomainFSDef *, n);
for (i = 0; i < n; i++) {
- virDomainFSDefPtr fs = virDomainFSDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainFSDef *fs = virDomainFSDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!fs)
goto error;
if ((n = virXPathNodeSet("./devices/interface", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->nets = g_new0(virDomainNetDefPtr, n);
+ def->nets = g_new0(virDomainNetDef *, n);
for (i = 0; i < n; i++) {
- virDomainNetDefPtr net = virDomainNetDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainNetDef *net = virDomainNetDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!net)
goto error;
if ((n = virXPathNodeSet("./devices/smartcard", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->smartcards = g_new0(virDomainSmartcardDefPtr, n);
+ def->smartcards = g_new0(virDomainSmartcardDef *, n);
for (i = 0; i < n; i++) {
- virDomainSmartcardDefPtr card = virDomainSmartcardDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainSmartcardDef *card = virDomainSmartcardDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!card)
goto error;
if ((n = virXPathNodeSet("./devices/parallel", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->parallels = g_new0(virDomainChrDefPtr, n);
+ def->parallels = g_new0(virDomainChrDef *, n);
for (i = 0; i < n; i++) {
- virDomainChrDefPtr chr = virDomainChrDefParseXML(xmlopt,
- ctxt,
- nodes[i],
- flags);
+ virDomainChrDef *chr = virDomainChrDefParseXML(xmlopt,
+ ctxt,
+ nodes[i],
+ flags);
if (!chr)
goto error;
goto error;
if (n)
- def->serials = g_new0(virDomainChrDefPtr, n);
+ def->serials = g_new0(virDomainChrDef *, n);
for (i = 0; i < n; i++) {
- virDomainChrDefPtr chr = virDomainChrDefParseXML(xmlopt,
- ctxt,
- nodes[i],
- flags);
+ virDomainChrDef *chr = virDomainChrDefParseXML(xmlopt,
+ ctxt,
+ nodes[i],
+ flags);
if (!chr)
goto error;
goto error;
}
if (n)
- def->consoles = g_new0(virDomainChrDefPtr, n);
+ def->consoles = g_new0(virDomainChrDef *, n);
for (i = 0; i < n; i++) {
- virDomainChrDefPtr chr = virDomainChrDefParseXML(xmlopt,
- ctxt,
- nodes[i],
- flags);
+ virDomainChrDef *chr = virDomainChrDefParseXML(xmlopt,
+ ctxt,
+ nodes[i],
+ flags);
if (!chr)
goto error;
if ((n = virXPathNodeSet("./devices/channel", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->channels = g_new0(virDomainChrDefPtr, n);
+ def->channels = g_new0(virDomainChrDef *, n);
for (i = 0; i < n; i++) {
- virDomainChrDefPtr chr = virDomainChrDefParseXML(xmlopt,
- ctxt,
- nodes[i],
- flags);
+ virDomainChrDef *chr = virDomainChrDefParseXML(xmlopt,
+ ctxt,
+ nodes[i],
+ flags);
if (!chr)
goto error;
if ((n = virXPathNodeSet("./devices/input", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->inputs = g_new0(virDomainInputDefPtr, n);
+ def->inputs = g_new0(virDomainInputDef *, n);
for (i = 0; i < n; i++) {
- virDomainInputDefPtr input = virDomainInputDefParseXML(xmlopt,
- def,
- nodes[i],
- ctxt,
- flags);
+ virDomainInputDef *input = virDomainInputDefParseXML(xmlopt,
+ def,
+ nodes[i],
+ ctxt,
+ flags);
if (!input)
goto error;
if ((n = virXPathNodeSet("./devices/graphics", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->graphics = g_new0(virDomainGraphicsDefPtr, n);
+ def->graphics = g_new0(virDomainGraphicsDef *, n);
for (i = 0; i < n; i++) {
- virDomainGraphicsDefPtr graphics = virDomainGraphicsDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainGraphicsDef *graphics = virDomainGraphicsDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!graphics)
goto error;
if ((n = virXPathNodeSet("./devices/sound", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->sounds = g_new0(virDomainSoundDefPtr, n);
+ def->sounds = g_new0(virDomainSoundDef *, n);
for (i = 0; i < n; i++) {
- virDomainSoundDefPtr sound = virDomainSoundDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainSoundDef *sound = virDomainSoundDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!sound)
goto error;
if ((n = virXPathNodeSet("./devices/audio", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->audios = g_new0(virDomainAudioDefPtr, n);
+ def->audios = g_new0(virDomainAudioDef *, n);
for (i = 0; i < n; i++) {
- virDomainAudioDefPtr audio = virDomainAudioDefParseXML(xmlopt,
- nodes[i],
- ctxt);
+ virDomainAudioDef *audio = virDomainAudioDefParseXML(xmlopt,
+ nodes[i],
+ ctxt);
if (!audio)
goto error;
if ((n = virXPathNodeSet("./devices/video", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->videos = g_new0(virDomainVideoDefPtr, n);
+ def->videos = g_new0(virDomainVideoDef *, n);
for (i = 0; i < n; i++) {
g_autoptr(virDomainVideoDef) video = NULL;
ssize_t insertAt = -1;
VIR_REALLOC_N(def->hostdevs, def->nhostdevs + n);
for (i = 0; i < n; i++) {
- virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDef *hostdev;
hostdev = virDomainHostdevDefParseXML(xmlopt, nodes[i], ctxt,
flags);
goto error;
}
if (n > 0) {
- virDomainWatchdogDefPtr watchdog;
+ virDomainWatchdogDef *watchdog;
watchdog = virDomainWatchdogDefParseXML(xmlopt, nodes[0], ctxt, flags);
if (!watchdog)
goto error;
}
if (n > 0) {
- virDomainMemballoonDefPtr memballoon;
+ virDomainMemballoonDef *memballoon;
memballoon = virDomainMemballoonDefParseXML(xmlopt, nodes[0], ctxt, flags);
if (!memballoon)
if ((n = virXPathNodeSet("./devices/rng", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->rngs = g_new0(virDomainRNGDefPtr, n);
+ def->rngs = g_new0(virDomainRNGDef *, n);
for (i = 0; i < n; i++) {
- virDomainRNGDefPtr rng = virDomainRNGDefParseXML(xmlopt, nodes[i],
- ctxt, flags);
+ virDomainRNGDef *rng = virDomainRNGDefParseXML(xmlopt, nodes[i],
+ ctxt, flags);
if (!rng)
goto error;
}
if (n)
- def->tpms = g_new0(virDomainTPMDefPtr, n);
+ def->tpms = g_new0(virDomainTPMDef *, n);
for (i = 0; i < n; i++) {
- virDomainTPMDefPtr tpm = virDomainTPMDefParseXML(xmlopt, nodes[i],
- ctxt, flags);
+ virDomainTPMDef *tpm = virDomainTPMDefParseXML(xmlopt, nodes[i],
+ ctxt, flags);
if (!tpm)
goto error;
_("only a single nvram device is supported"));
goto error;
} else if (n == 1) {
- virDomainNVRAMDefPtr nvram =
+ virDomainNVRAMDef *nvram =
virDomainNVRAMDefParseXML(xmlopt, nodes[0], ctxt, flags);
if (!nvram)
goto error;
if ((n = virXPathNodeSet("./devices/hub", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->hubs = g_new0(virDomainHubDefPtr, n);
+ def->hubs = g_new0(virDomainHubDef *, n);
for (i = 0; i < n; i++) {
- virDomainHubDefPtr hub;
+ virDomainHubDef *hub;
hub = virDomainHubDefParseXML(xmlopt, nodes[i], ctxt, flags);
if (!hub)
if ((n = virXPathNodeSet("./devices/redirdev", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->redirdevs = g_new0(virDomainRedirdevDefPtr, n);
+ def->redirdevs = g_new0(virDomainRedirdevDef *, n);
for (i = 0; i < n; i++) {
- virDomainRedirdevDefPtr redirdev =
+ virDomainRedirdevDef *redirdev =
virDomainRedirdevDefParseXML(xmlopt, nodes[i], ctxt, flags);
if (!redirdev)
goto error;
}
if (n) {
- virDomainRedirFilterDefPtr redirfilter =
+ virDomainRedirFilterDef *redirfilter =
virDomainRedirFilterDefParseXML(nodes[0], ctxt);
if (!redirfilter)
goto error;
if ((n = virXPathNodeSet("./devices/panic", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->panics = g_new0(virDomainPanicDefPtr, n);
+ def->panics = g_new0(virDomainPanicDef *, n);
for (i = 0; i < n; i++) {
- virDomainPanicDefPtr panic;
+ virDomainPanicDef *panic;
panic = virDomainPanicDefParseXML(xmlopt, nodes[i], ctxt, flags);
if (!panic)
if ((n = virXPathNodeSet("./devices/shmem", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->shmems = g_new0(virDomainShmemDefPtr, n);
+ def->shmems = g_new0(virDomainShmemDef *, n);
node = ctxt->node;
for (i = 0; i < n; i++) {
- virDomainShmemDefPtr shmem;
+ virDomainShmemDef *shmem;
ctxt->node = nodes[i];
shmem = virDomainShmemDefParseXML(xmlopt, nodes[i], ctxt, flags);
if (!shmem)
if ((n = virXPathNodeSet("./devices/memory", ctxt, &nodes)) < 0)
goto error;
if (n)
- def->mems = g_new0(virDomainMemoryDefPtr, n);
+ def->mems = g_new0(virDomainMemoryDef *, n);
for (i = 0; i < n; i++) {
- virDomainMemoryDefPtr mem = virDomainMemoryDefParseXML(xmlopt,
- nodes[i],
- ctxt,
- flags);
+ virDomainMemoryDef *mem = virDomainMemoryDefParseXML(xmlopt,
+ nodes[i],
+ ctxt,
+ flags);
if (!mem)
goto error;
if ((n = virXPathNodeSet("./sysinfo", ctxt, &nodes)) < 0)
goto error;
- def->sysinfo = g_new0(virSysinfoDefPtr, n);
+ def->sysinfo = g_new0(virSysinfoDef *, n);
for (i = 0; i < n; i++) {
- virSysinfoDefPtr sysinfo = virSysinfoParseXML(nodes[i], ctxt,
- def->uuid, uuid_generated);
+ virSysinfoDef *sysinfo = virSysinfoParseXML(nodes[i], ctxt,
+ def->uuid, uuid_generated);
if (!sysinfo)
goto error;
}
-static virDomainObjPtr
+static virDomainObj *
virDomainObjParseXML(xmlDocPtr xml,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
long val;
xmlNodePtr config;
xmlNodePtr oldnode;
- virDomainObjPtr obj;
+ virDomainObj *obj;
size_t i;
int n;
int state;
}
-static virDomainDefPtr
+static virDomainDef *
virDomainDefParse(const char *xmlStr,
const char *filename,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
xmlDocPtr xml = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
xmlNodePtr root;
if (!(xml = virXMLParse(filename, xmlStr, _("(domain_definition)"))))
return def;
}
-virDomainDefPtr
+virDomainDef *
virDomainDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
return virDomainDefParse(xmlStr, NULL, xmlopt, parseOpaque, flags);
}
-virDomainDefPtr
+virDomainDef *
virDomainDefParseFile(const char *filename,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
}
-virDomainDefPtr
+virDomainDef *
virDomainDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags)
{
}
-virDomainObjPtr
+virDomainObj *
virDomainObjParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
}
-virDomainObjPtr
+virDomainObj *
virDomainObjParseFile(const char *filename,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
xmlDocPtr xml;
- virDomainObjPtr obj = NULL;
+ virDomainObj *obj = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParseFile(filename))) {
static bool
-virDomainTimerDefCheckABIStability(virDomainTimerDefPtr src,
- virDomainTimerDefPtr dst)
+virDomainTimerDefCheckABIStability(virDomainTimerDef *src,
+ virDomainTimerDef *dst)
{
if (src->name != dst->name) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainDeviceInfoCheckABIStability(virDomainDeviceInfoPtr src,
- virDomainDeviceInfoPtr dst)
+virDomainDeviceInfoCheckABIStability(virDomainDeviceInfo *src,
+ virDomainDeviceInfo *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainVirtioOptionsCheckABIStability(virDomainVirtioOptionsPtr src,
- virDomainVirtioOptionsPtr dst)
+virDomainVirtioOptionsCheckABIStability(virDomainVirtioOptions *src,
+ virDomainVirtioOptions *dst)
{
if (!src && !dst)
return true;
static bool
-virDomainDiskDefCheckABIStability(virDomainDiskDefPtr src,
- virDomainDiskDefPtr dst)
+virDomainDiskDefCheckABIStability(virDomainDiskDef *src,
+ virDomainDiskDef *dst)
{
if (src->device != dst->device) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainControllerDefCheckABIStability(virDomainControllerDefPtr src,
- virDomainControllerDefPtr dst)
+virDomainControllerDefCheckABIStability(virDomainControllerDef *src,
+ virDomainControllerDef *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainFsDefCheckABIStability(virDomainFSDefPtr src,
- virDomainFSDefPtr dst)
+virDomainFsDefCheckABIStability(virDomainFSDef *src,
+ virDomainFSDef *dst)
{
if (STRNEQ(src->dst, dst->dst)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainNetDefCheckABIStability(virDomainNetDefPtr src,
- virDomainNetDefPtr dst)
+virDomainNetDefCheckABIStability(virDomainNetDef *src,
+ virDomainNetDef *dst)
{
char srcmac[VIR_MAC_STRING_BUFLEN];
char dstmac[VIR_MAC_STRING_BUFLEN];
static bool
-virDomainInputDefCheckABIStability(virDomainInputDefPtr src,
- virDomainInputDefPtr dst)
+virDomainInputDefCheckABIStability(virDomainInputDef *src,
+ virDomainInputDef *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainSoundDefCheckABIStability(virDomainSoundDefPtr src,
- virDomainSoundDefPtr dst)
+virDomainSoundDefCheckABIStability(virDomainSoundDef *src,
+ virDomainSoundDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainVideoDefCheckABIStability(virDomainVideoDefPtr src,
- virDomainVideoDefPtr dst)
+virDomainVideoDefCheckABIStability(virDomainVideoDef *src,
+ virDomainVideoDef *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainHostdevDefCheckABIStability(virDomainHostdevDefPtr src,
- virDomainHostdevDefPtr dst)
+virDomainHostdevDefCheckABIStability(virDomainHostdevDef *src,
+ virDomainHostdevDef *dst)
{
if (src->mode != dst->mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainSmartcardDefCheckABIStability(virDomainSmartcardDefPtr src,
- virDomainSmartcardDefPtr dst)
+virDomainSmartcardDefCheckABIStability(virDomainSmartcardDef *src,
+ virDomainSmartcardDef *dst)
{
if (!virDomainDeviceInfoCheckABIStability(&src->info, &dst->info))
return false;
static bool
-virDomainSerialDefCheckABIStability(virDomainChrDefPtr src,
- virDomainChrDefPtr dst)
+virDomainSerialDefCheckABIStability(virDomainChrDef *src,
+ virDomainChrDef *dst)
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainParallelDefCheckABIStability(virDomainChrDefPtr src,
- virDomainChrDefPtr dst)
+virDomainParallelDefCheckABIStability(virDomainChrDef *src,
+ virDomainChrDef *dst)
{
if (src->target.port != dst->target.port) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainChannelDefCheckABIStability(virDomainChrDefPtr src,
- virDomainChrDefPtr dst)
+virDomainChannelDefCheckABIStability(virDomainChrDef *src,
+ virDomainChrDef *dst)
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainConsoleDefCheckABIStability(virDomainChrDefPtr src,
- virDomainChrDefPtr dst)
+virDomainConsoleDefCheckABIStability(virDomainChrDef *src,
+ virDomainChrDef *dst)
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainWatchdogDefCheckABIStability(virDomainWatchdogDefPtr src,
- virDomainWatchdogDefPtr dst)
+virDomainWatchdogDefCheckABIStability(virDomainWatchdogDef *src,
+ virDomainWatchdogDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainMemballoonDefCheckABIStability(virDomainMemballoonDefPtr src,
- virDomainMemballoonDefPtr dst)
+virDomainMemballoonDefCheckABIStability(virDomainMemballoonDef *src,
+ virDomainMemballoonDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainRNGDefCheckABIStability(virDomainRNGDefPtr src,
- virDomainRNGDefPtr dst)
+virDomainRNGDefCheckABIStability(virDomainRNGDef *src,
+ virDomainRNGDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainHubDefCheckABIStability(virDomainHubDefPtr src,
- virDomainHubDefPtr dst)
+virDomainHubDefCheckABIStability(virDomainHubDef *src,
+ virDomainHubDef *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainRedirdevDefCheckABIStability(virDomainRedirdevDefPtr src,
- virDomainRedirdevDefPtr dst)
+virDomainRedirdevDefCheckABIStability(virDomainRedirdevDef *src,
+ virDomainRedirdevDef *dst)
{
if (src->bus != dst->bus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainRedirFilterDefCheckABIStability(virDomainRedirFilterDefPtr src,
- virDomainRedirFilterDefPtr dst)
+virDomainRedirFilterDefCheckABIStability(virDomainRedirFilterDef *src,
+ virDomainRedirFilterDef *dst)
{
size_t i;
}
for (i = 0; i < src->nusbdevs; i++) {
- virDomainRedirFilterUSBDevDefPtr srcUSBDev = src->usbdevs[i];
- virDomainRedirFilterUSBDevDefPtr dstUSBDev = dst->usbdevs[i];
+ virDomainRedirFilterUSBDevDef *srcUSBDev = src->usbdevs[i];
+ virDomainRedirFilterUSBDevDef *dstUSBDev = dst->usbdevs[i];
if (srcUSBDev->usbClass != dstUSBDev->usbClass) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("Target USB Class code does not match source"));
static bool
-virDomainDefFeaturesCheckABIStability(virDomainDefPtr src,
- virDomainDefPtr dst)
+virDomainDefFeaturesCheckABIStability(virDomainDef *src,
+ virDomainDef *dst)
{
size_t i;
}
static bool
-virDomainPanicDefCheckABIStability(virDomainPanicDefPtr src,
- virDomainPanicDefPtr dst)
+virDomainPanicDefCheckABIStability(virDomainPanicDef *src,
+ virDomainPanicDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainShmemDefCheckABIStability(virDomainShmemDefPtr src,
- virDomainShmemDefPtr dst)
+virDomainShmemDefCheckABIStability(virDomainShmemDef *src,
+ virDomainShmemDef *dst)
{
if (src->role != dst->role) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainTPMDefCheckABIStability(virDomainTPMDefPtr src,
- virDomainTPMDefPtr dst)
+virDomainTPMDefCheckABIStability(virDomainTPMDef *src,
+ virDomainTPMDef *dst)
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
static bool
-virDomainMemoryDefCheckABIStability(virDomainMemoryDefPtr src,
- virDomainMemoryDefPtr dst)
+virDomainMemoryDefCheckABIStability(virDomainMemoryDef *src,
+ virDomainMemoryDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainIOMMUDefCheckABIStability(virDomainIOMMUDefPtr src,
- virDomainIOMMUDefPtr dst)
+virDomainIOMMUDefCheckABIStability(virDomainIOMMUDef *src,
+ virDomainIOMMUDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainVsockDefCheckABIStability(virDomainVsockDefPtr src,
- virDomainVsockDefPtr dst)
+virDomainVsockDefCheckABIStability(virDomainVsockDef *src,
+ virDomainVsockDef *dst)
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static bool
-virDomainDefVcpuCheckAbiStability(virDomainDefPtr src,
- virDomainDefPtr dst)
+virDomainDefVcpuCheckAbiStability(virDomainDef *src,
+ virDomainDef *dst)
{
size_t i;
}
for (i = 0; i < src->maxvcpus; i++) {
- virDomainVcpuDefPtr svcpu = src->vcpus[i];
- virDomainVcpuDefPtr dvcpu = dst->vcpus[i];
+ virDomainVcpuDef *svcpu = src->vcpus[i];
+ virDomainVcpuDef *dvcpu = dst->vcpus[i];
if (svcpu->online != dvcpu->online) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
* validation of custom XML config passed in during migration
*/
bool
-virDomainDefCheckABIStabilityFlags(virDomainDefPtr src,
- virDomainDefPtr dst,
- virDomainXMLOptionPtr xmlopt,
+virDomainDefCheckABIStabilityFlags(virDomainDef *src,
+ virDomainDef *dst,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
size_t i;
bool
-virDomainDefCheckABIStability(virDomainDefPtr src,
- virDomainDefPtr dst,
- virDomainXMLOptionPtr xmlopt)
+virDomainDefCheckABIStability(virDomainDef *src,
+ virDomainDef *dst,
+ virDomainXMLOption *xmlopt)
{
return virDomainDefCheckABIStabilityFlags(src, dst, xmlopt, 0);
}
static int
-virDomainDefAddDiskControllersForType(virDomainDefPtr def,
+virDomainDefAddDiskControllersForType(virDomainDef *def,
int controllerType,
int diskBus)
{
static int
-virDomainDefMaybeAddVirtioSerialController(virDomainDefPtr def)
+virDomainDefMaybeAddVirtioSerialController(virDomainDef *def)
{
/* Look for any virtio serial or virtio console devs */
size_t i;
for (i = 0; i < def->nchannels; i++) {
- virDomainChrDefPtr channel = def->channels[i];
+ virDomainChrDef *channel = def->channels[i];
if (channel->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO) {
int idx = 0;
}
for (i = 0; i < def->nconsoles; i++) {
- virDomainChrDefPtr console = def->consoles[i];
+ virDomainChrDef *console = def->consoles[i];
if (console->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO) {
int idx = 0;
static int
-virDomainDefMaybeAddSmartcardController(virDomainDefPtr def)
+virDomainDefMaybeAddSmartcardController(virDomainDef *def)
{
/* Look for any smartcard devs */
size_t i;
for (i = 0; i < def->nsmartcards; i++) {
- virDomainSmartcardDefPtr smartcard = def->smartcards[i];
+ virDomainSmartcardDef *smartcard = def->smartcards[i];
int idx = 0;
if (smartcard->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID) {
int max = -1;
for (j = 0; j < def->nsmartcards; j++) {
- virDomainDeviceInfoPtr info = &def->smartcards[j]->info;
+ virDomainDeviceInfo *info = &def->smartcards[j]->info;
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID &&
info->addr.ccid.controller == 0 &&
(int) info->addr.ccid.slot > max)
* not know/care about <controller> info in the XML
*/
static int
-virDomainDefAddImplicitControllers(virDomainDefPtr def)
+virDomainDefAddImplicitControllers(virDomainDef *def)
{
if (virDomainDefAddDiskControllersForType(def,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
}
static int
-virDomainDefAddImplicitVideo(virDomainDefPtr def, virDomainXMLOptionPtr xmlopt)
+virDomainDefAddImplicitVideo(virDomainDef *def, virDomainXMLOption *xmlopt)
{
g_autoptr(virDomainVideoDef) video = NULL;
}
int
-virDomainDefAddImplicitDevices(virDomainDefPtr def, virDomainXMLOptionPtr xmlopt)
+virDomainDefAddImplicitDevices(virDomainDef *def, virDomainXMLOption *xmlopt)
{
if (virDomainDefAddConsoleCompat(def) < 0)
return -1;
return 0;
}
-virDomainIOThreadIDDefPtr
+virDomainIOThreadIDDef *
virDomainIOThreadIDFind(const virDomainDef *def,
unsigned int iothread_id)
{
return NULL;
}
-virDomainIOThreadIDDefPtr
-virDomainIOThreadIDAdd(virDomainDefPtr def,
+virDomainIOThreadIDDef *
+virDomainIOThreadIDAdd(virDomainDef *def,
unsigned int iothread_id)
{
- virDomainIOThreadIDDefPtr iothrid = NULL;
+ virDomainIOThreadIDDef *iothrid = NULL;
iothrid = g_new0(virDomainIOThreadIDDef, 1);
void
-virDomainIOThreadIDDel(virDomainDefPtr def,
+virDomainIOThreadIDDel(virDomainDef *def,
unsigned int iothread_id)
{
size_t i, j;
static int
-virDomainEventActionDefFormat(virBufferPtr buf,
+virDomainEventActionDefFormat(virBuffer *buf,
int type,
const char *name,
virEventActionToStringFunc convFunc)
static void
-virSecurityLabelDefFormat(virBufferPtr buf,
- virSecurityLabelDefPtr def,
+virSecurityLabelDefFormat(virBuffer *buf,
+ virSecurityLabelDef *def,
unsigned int flags)
{
const char *sectype = virDomainSeclabelTypeToString(def->type);
static void
-virSecurityDeviceLabelDefFormat(virBufferPtr buf,
- virSecurityDeviceLabelDefPtr def,
+virSecurityDeviceLabelDefFormat(virBuffer *buf,
+ virSecurityDeviceLabelDef *def,
unsigned int flags)
{
/* For offline output, skip elements that allow labels but have no
static void
-virDomainLeaseDefFormat(virBufferPtr buf,
- virDomainLeaseDefPtr def)
+virDomainLeaseDefFormat(virBuffer *buf,
+ virDomainLeaseDef *def)
{
virBufferAddLit(buf, "<lease>\n");
virBufferAdjustIndent(buf, 2);
}
static void
-virDomainDiskGeometryDefFormat(virBufferPtr buf,
- virDomainDiskDefPtr def)
+virDomainDiskGeometryDefFormat(virBuffer *buf,
+ virDomainDiskDef *def)
{
const char *trans =
virDomainDiskGeometryTransTypeToString(def->geometry.trans);
}
static void
-virDomainDiskBlockIoDefFormat(virBufferPtr buf,
- virDomainDiskDefPtr def)
+virDomainDiskBlockIoDefFormat(virBuffer *buf,
+ virDomainDiskDef *def)
{
if (def->blockio.logical_block_size > 0 ||
def->blockio.physical_block_size > 0) {
static void
-virDomainSourceDefFormatSeclabel(virBufferPtr buf,
+virDomainSourceDefFormatSeclabel(virBuffer *buf,
size_t nseclabels,
- virSecurityDeviceLabelDefPtr *seclabels,
+ virSecurityDeviceLabelDef **seclabels,
unsigned int flags)
{
size_t n;
static void
-virDomainDiskSourceFormatNetworkCookies(virBufferPtr buf,
- virStorageSourcePtr src,
+virDomainDiskSourceFormatNetworkCookies(virBuffer *buf,
+ virStorageSource *src,
unsigned int flags)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainDiskSourceFormatNetwork(virBufferPtr attrBuf,
- virBufferPtr childBuf,
- virStorageSourcePtr src,
+virDomainDiskSourceFormatNetwork(virBuffer *attrBuf,
+ virBuffer *childBuf,
+ virStorageSource *src,
unsigned int flags)
{
size_t n;
static void
-virDomainDiskSourceNVMeFormat(virBufferPtr attrBuf,
- virBufferPtr childBuf,
+virDomainDiskSourceNVMeFormat(virBuffer *attrBuf,
+ virBuffer *childBuf,
const virStorageSourceNVMeDef *nvme)
{
virBufferAddLit(attrBuf, " type='pci'");
static void
-virDomainChrSourceReconnectDefFormat(virBufferPtr buf,
- virDomainChrSourceReconnectDefPtr def);
+virDomainChrSourceReconnectDefFormat(virBuffer *buf,
+ virDomainChrSourceReconnectDef *def);
static void
-virDomainDiskSourceVhostuserFormat(virBufferPtr attrBuf,
- virBufferPtr childBuf,
- virDomainChrSourceDefPtr vhostuser)
+virDomainDiskSourceVhostuserFormat(virBuffer *attrBuf,
+ virBuffer *childBuf,
+ virDomainChrSourceDef *vhostuser)
{
virBufferAddLit(attrBuf, " type='unix'");
virBufferAsprintf(attrBuf, " path='%s'", vhostuser->data.nix.path);
static int
-virDomainDiskSourceFormatPrivateData(virBufferPtr buf,
- virStorageSourcePtr src,
+virDomainDiskSourceFormatPrivateData(virBuffer *buf,
+ virStorageSource *src,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainDiskSourceFormatSlice(virBufferPtr buf,
+virDomainDiskSourceFormatSlice(virBuffer *buf,
const char *slicetype,
- virStorageSourceSlicePtr slice)
+ virStorageSourceSlice *slice)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static void
-virDomainDiskSourceFormatSlices(virBufferPtr buf,
- virStorageSourcePtr src)
+virDomainDiskSourceFormatSlices(virBuffer *buf,
+ virStorageSource *src)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
* 'type' and 'format' properties of @src.
*/
int
-virDomainDiskSourceFormat(virBufferPtr buf,
- virStorageSourcePtr src,
+virDomainDiskSourceFormat(virBuffer *buf,
+ virStorageSource *src,
const char *element,
int policy,
bool attrIndex,
unsigned int flags,
bool skipAuth,
bool skipEnc,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
int
-virDomainDiskBackingStoreFormat(virBufferPtr buf,
- virStorageSourcePtr src,
- virDomainXMLOptionPtr xmlopt,
+virDomainDiskBackingStoreFormat(virBuffer *buf,
+ virStorageSource *src,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) formatAttrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) formatChildBuf = VIR_BUFFER_INIT_CHILD(&childBuf);
bool inactive = flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE;
- virStorageSourcePtr backingStore = src->backingStore;
+ virStorageSource *backingStore = src->backingStore;
if (!backingStore)
return 0;
}
static void
-virDomainDiskDefFormatIotune(virBufferPtr buf,
- virDomainDiskDefPtr disk)
+virDomainDiskDefFormatIotune(virBuffer *buf,
+ virDomainDiskDef *disk)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainDiskDefFormatDriver(virBufferPtr buf,
- virDomainDiskDefPtr disk)
+virDomainDiskDefFormatDriver(virBuffer *buf,
+ virDomainDiskDef *disk)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static int
-virDomainDiskDefFormatMirror(virBufferPtr buf,
- virDomainDiskDefPtr disk,
+virDomainDiskDefFormatMirror(virBuffer *buf,
+ virDomainDiskDef *disk,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static int
-virDomainDiskDefFormatPrivateData(virBufferPtr buf,
- virDomainDiskDefPtr disk,
+virDomainDiskDefFormatPrivateData(virBuffer *buf,
+ virDomainDiskDef *disk,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static int
-virDomainDiskDefFormat(virBufferPtr buf,
- virDomainDiskDefPtr def,
+virDomainDiskDefFormat(virBuffer *buf,
+ virDomainDiskDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
const char *type = virStorageTypeToString(def->src->type);
const char *device = virDomainDiskDeviceTypeToString(def->device);
static void
-virDomainControllerDriverFormat(virBufferPtr buf,
- virDomainControllerDefPtr def)
+virDomainControllerDriverFormat(virBuffer *buf,
+ virDomainControllerDef *def)
{
g_auto(virBuffer) driverBuf = VIR_BUFFER_INITIALIZER;
static int
-virDomainControllerDefFormat(virBufferPtr buf,
- virDomainControllerDefPtr def,
+virDomainControllerDefFormat(virBuffer *buf,
+ virDomainControllerDef *def,
unsigned int flags)
{
const char *type = virDomainControllerTypeToString(def->type);
int
-virDomainFSIndexByName(virDomainDefPtr def, const char *name)
+virDomainFSIndexByName(virDomainDef *def, const char *name)
{
- virDomainFSDefPtr fs;
+ virDomainFSDef *fs;
size_t i;
for (i = 0; i < def->nfss; i++) {
static int
-virDomainFSDefFormat(virBufferPtr buf,
- virDomainFSDefPtr def,
+virDomainFSDefFormat(virBuffer *buf,
+ virDomainFSDef *def,
unsigned int flags)
{
const char *type = virDomainFSTypeToString(def->type);
static int
-virDomainNetIPInfoFormat(virBufferPtr buf,
- virNetDevIPInfoPtr def)
+virDomainNetIPInfoFormat(virBuffer *buf,
+ virNetDevIPInfo *def)
{
size_t i;
/* Output IP addresses */
for (i = 0; i < def->nips; i++) {
- virSocketAddrPtr address = &def->ips[i]->address;
+ virSocketAddr *address = &def->ips[i]->address;
char *ipStr = virSocketAddrFormat(address);
const char *familyStr = NULL;
static void
-virDomainHostdevDefFormatSubsysUSB(virBufferPtr buf,
- virDomainHostdevDefPtr def,
+virDomainHostdevDefFormatSubsysUSB(virBuffer *buf,
+ virDomainHostdevDef *def,
unsigned int flags,
bool includeTypeInAddr)
{
g_auto(virBuffer) sourceAttrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) sourceChildBuf = VIR_BUFFER_INIT_CHILD(buf);
- virDomainHostdevSubsysUSBPtr usbsrc = &def->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *usbsrc = &def->source.subsys.u.usb;
if (def->startupPolicy)
virBufferAsprintf(&sourceAttrBuf, " startupPolicy='%s'",
static int
-virDomainHostdevDefFormatSubsysPCI(virBufferPtr buf,
- virDomainHostdevDefPtr def,
+virDomainHostdevDefFormatSubsysPCI(virBuffer *buf,
+ virDomainHostdevDef *def,
unsigned int flags,
bool includeTypeInAddr)
{
g_auto(virBuffer) sourceAttrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) sourceChildBuf = VIR_BUFFER_INIT_CHILD(buf);
g_auto(virBuffer) origstatesChildBuf = VIR_BUFFER_INIT_CHILD(&sourceChildBuf);
- virDomainHostdevSubsysPCIPtr pcisrc = &def->source.subsys.u.pci;
+ virDomainHostdevSubsysPCI *pcisrc = &def->source.subsys.u.pci;
if (def->writeFiltering != VIR_TRISTATE_BOOL_ABSENT)
virBufferAsprintf(&sourceAttrBuf, " writeFiltering='%s'",
static int
-virDomainHostdevDefFormatSubsysSCSI(virBufferPtr buf,
- virDomainHostdevDefPtr def,
+virDomainHostdevDefFormatSubsysSCSI(virBuffer *buf,
+ virDomainHostdevDef *def,
unsigned int flags,
bool includeTypeInAddr,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) sourceAttrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) sourceChildBuf = VIR_BUFFER_INIT_CHILD(buf);
- virDomainHostdevSubsysSCSIPtr scsisrc = &def->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &def->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
virBufferAsprintf(&sourceAttrBuf, " protocol='%s' name='%s'",
static void
-virDomainHostdevDefFormatSubsysSCSIHost(virBufferPtr buf,
- virDomainHostdevDefPtr def)
+virDomainHostdevDefFormatSubsysSCSIHost(virBuffer *buf,
+ virDomainHostdevDef *def)
{
g_auto(virBuffer) sourceAttrBuf = VIR_BUFFER_INITIALIZER;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &def->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &def->source.subsys.u.scsi_host;
virBufferAsprintf(&sourceAttrBuf, " protocol='%s' wwpn='%s'",
virDomainHostdevSubsysSCSIHostProtocolTypeToString(hostsrc->protocol),
static void
-virDomainHostdevDefFormatSubsysMdev(virBufferPtr buf,
- virDomainHostdevDefPtr def)
+virDomainHostdevDefFormatSubsysMdev(virBuffer *buf,
+ virDomainHostdevDef *def)
{
g_auto(virBuffer) sourceChildBuf = VIR_BUFFER_INIT_CHILD(buf);
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &def->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &def->source.subsys.u.mdev;
virBufferAsprintf(&sourceChildBuf, "<address uuid='%s'/>\n", mdevsrc->uuidstr);
static int
-virDomainHostdevDefFormatSubsys(virBufferPtr buf,
- virDomainHostdevDefPtr def,
+virDomainHostdevDefFormatSubsys(virBuffer *buf,
+ virDomainHostdevDef *def,
unsigned int flags,
bool includeTypeInAddr,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
switch ((virDomainHostdevSubsysType) def->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
}
static int
-virDomainHostdevDefFormatCaps(virBufferPtr buf,
- virDomainHostdevDefPtr def)
+virDomainHostdevDefFormatCaps(virBuffer *buf,
+ virDomainHostdevDef *def)
{
virBufferAddLit(buf, "<source>\n");
* than enclosed in an <actual> subelement.
*/
static int
-virDomainActualNetDefContentsFormat(virBufferPtr buf,
- virDomainNetDefPtr def,
+virDomainActualNetDefContentsFormat(virBuffer *buf,
+ virDomainNetDef *def,
bool inSubelement,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
virDomainNetType actualType = virDomainNetGetActualType(def);
* of domain status
*/
static int
-virDomainActualNetDefFormat(virBufferPtr buf,
- virDomainNetDefPtr def,
+virDomainActualNetDefFormat(virBuffer *buf,
+ virDomainNetDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
virDomainNetType type;
const char *typeStr;
virBufferAsprintf(buf, "<actual type='%s'", typeStr);
if (type == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
- virDomainHostdevDefPtr hostdef = virDomainNetGetActualHostdev(def);
+ virDomainHostdevDef *hostdef = virDomainNetGetActualHostdev(def);
if (hostdef && hostdef->managed)
virBufferAddLit(buf, " managed='yes'");
}
static void
-virDomainVirtioNetGuestOptsFormat(virBufferPtr buf,
- virDomainNetDefPtr def)
+virDomainVirtioNetGuestOptsFormat(virBuffer *buf,
+ virDomainNetDef *def)
{
if (def->driver.virtio.guest.csum) {
virBufferAsprintf(buf, " csum='%s'",
static void
-virDomainVirtioNetHostOptsFormat(virBufferPtr buf,
- virDomainNetDefPtr def)
+virDomainVirtioNetHostOptsFormat(virBuffer *buf,
+ virDomainNetDef *def)
{
if (def->driver.virtio.host.csum) {
virBufferAsprintf(buf, " csum='%s'",
static void
-virDomainVirtioNetDriverFormat(virBufferPtr buf,
- virDomainNetDefPtr def)
+virDomainVirtioNetDriverFormat(virBuffer *buf,
+ virDomainNetDef *def)
{
if (def->driver.virtio.name) {
virBufferAsprintf(buf, " name='%s'",
static void
-virDomainChrSourceReconnectDefFormat(virBufferPtr buf,
- virDomainChrSourceReconnectDefPtr def)
+virDomainChrSourceReconnectDefFormat(virBuffer *buf,
+ virDomainChrSourceReconnectDef *def)
{
if (def->enabled == VIR_TRISTATE_BOOL_ABSENT)
return;
static void
-virDomainNetTeamingInfoFormat(virDomainNetTeamingInfoPtr teaming,
- virBufferPtr buf)
+virDomainNetTeamingInfoFormat(virDomainNetTeamingInfo *teaming,
+ virBuffer *buf)
{
if (teaming && teaming->type != VIR_DOMAIN_NET_TEAMING_TYPE_NONE) {
virBufferAsprintf(buf, "<teaming type='%s'",
int
-virDomainNetDefFormat(virBufferPtr buf,
- virDomainNetDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainNetDefFormat(virBuffer *buf,
+ virDomainNetDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
virDomainNetType actualType = virDomainNetGetActualType(def);
bool publicActual = false;
int sourceLines = 0;
const char *typeStr;
- virDomainHostdevDefPtr hostdef = NULL;
+ virDomainHostdevDef *hostdef = NULL;
char macstr[VIR_MAC_STRING_BUFLEN];
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
const char *prefix = xmlopt ? xmlopt->config.netPrefix : NULL;
/* Assumes that "<device" has already been generated, and starts
* output at " type='type'>". */
static int
-virDomainChrAttrsDefFormat(virBufferPtr buf,
- virDomainChrSourceDefPtr def,
+virDomainChrAttrsDefFormat(virBuffer *buf,
+ virDomainChrSourceDef *def,
bool tty_compat)
{
const char *type = virDomainChrTypeToString(def->type);
}
static void
-virDomainChrSourceDefFormat(virBufferPtr buf,
- virDomainChrSourceDefPtr def,
+virDomainChrSourceDefFormat(virBuffer *buf,
+ virDomainChrSourceDef *def,
unsigned int flags)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static int
-virDomainChrTargetDefFormat(virBufferPtr buf,
+virDomainChrTargetDefFormat(virBuffer *buf,
const virDomainChrDef *def,
unsigned int flags)
{
static int
-virDomainChrDefFormat(virBufferPtr buf,
- virDomainChrDefPtr def,
+virDomainChrDefFormat(virBuffer *buf,
+ virDomainChrDef *def,
unsigned int flags)
{
const char *elementName = virDomainChrDeviceTypeToString(def->deviceType);
}
static int
-virDomainSmartcardDefFormat(virBufferPtr buf,
- virDomainSmartcardDefPtr def,
+virDomainSmartcardDefFormat(virBuffer *buf,
+ virDomainSmartcardDef *def,
unsigned int flags)
{
const char *mode = virDomainSmartcardTypeToString(def->type);
}
static int
-virDomainSoundCodecDefFormat(virBufferPtr buf,
- virDomainSoundCodecDefPtr def)
+virDomainSoundCodecDefFormat(virBuffer *buf,
+ virDomainSoundCodecDef *def)
{
const char *type = virDomainSoundCodecTypeToString(def->type);
}
static int
-virDomainTPMDefFormat(virBufferPtr buf,
- virDomainTPMDefPtr def,
+virDomainTPMDefFormat(virBuffer *buf,
+ virDomainTPMDef *def,
unsigned int flags)
{
virBufferAsprintf(buf, "<tpm model='%s'>\n",
static int
-virDomainSoundDefFormat(virBufferPtr buf,
- virDomainSoundDefPtr def,
+virDomainSoundDefFormat(virBuffer *buf,
+ virDomainSoundDef *def,
unsigned int flags)
{
const char *model = virDomainSoundModelTypeToString(def->model);
static void
-virDomainAudioCommonFormat(virDomainAudioIOCommonPtr def,
- virBufferPtr childBuf,
- virBufferPtr backendAttrBuf,
+virDomainAudioCommonFormat(virDomainAudioIOCommon *def,
+ virBuffer *childBuf,
+ virBuffer *backendAttrBuf,
const char *direction)
{
g_auto(virBuffer) settingsBuf = VIR_BUFFER_INITIALIZER;
static void
-virDomainAudioALSAFormat(virDomainAudioIOALSAPtr def,
- virBufferPtr buf)
+virDomainAudioALSAFormat(virDomainAudioIOALSA *def,
+ virBuffer *buf)
{
virBufferEscapeString(buf, " dev='%s'", def->dev);
}
static void
-virDomainAudioCoreAudioFormat(virDomainAudioIOCoreAudioPtr def,
- virBufferPtr buf)
+virDomainAudioCoreAudioFormat(virDomainAudioIOCoreAudio *def,
+ virBuffer *buf)
{
if (def->bufferCount)
virBufferAsprintf(buf, " bufferCount='%u'", def->bufferCount);
static void
-virDomainAudioJackFormat(virDomainAudioIOJackPtr def,
- virBufferPtr buf)
+virDomainAudioJackFormat(virDomainAudioIOJack *def,
+ virBuffer *buf)
{
virBufferEscapeString(buf, " serverName='%s'", def->serverName);
virBufferEscapeString(buf, " clientName='%s'", def->clientName);
static void
-virDomainAudioOSSFormat(virDomainAudioIOOSSPtr def,
- virBufferPtr buf)
+virDomainAudioOSSFormat(virDomainAudioIOOSS *def,
+ virBuffer *buf)
{
virBufferEscapeString(buf, " dev='%s'", def->dev);
if (def->bufferCount)
static void
-virDomainAudioPulseAudioFormat(virDomainAudioIOPulseAudioPtr def,
- virBufferPtr buf)
+virDomainAudioPulseAudioFormat(virDomainAudioIOPulseAudio *def,
+ virBuffer *buf)
{
virBufferEscapeString(buf, " name='%s'", def->name);
virBufferEscapeString(buf, " streamName='%s'", def->streamName);
static void
-virDomainAudioSDLFormat(virDomainAudioIOSDLPtr def,
- virBufferPtr buf)
+virDomainAudioSDLFormat(virDomainAudioIOSDL *def,
+ virBuffer *buf)
{
if (def->bufferCount)
virBufferAsprintf(buf, " bufferCount='%u'", def->bufferCount);
static int
-virDomainAudioDefFormat(virBufferPtr buf,
- virDomainAudioDefPtr def)
+virDomainAudioDefFormat(virBuffer *buf,
+ virDomainAudioDef *def)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
g_auto(virBuffer) inputBuf = VIR_BUFFER_INITIALIZER;
static int
-virDomainMemballoonDefFormat(virBufferPtr buf,
- virDomainMemballoonDefPtr def,
+virDomainMemballoonDefFormat(virBuffer *buf,
+ virDomainMemballoonDef *def,
unsigned int flags)
{
const char *model = virDomainMemballoonModelTypeToString(def->model);
}
static void
-virDomainNVRAMDefFormat(virBufferPtr buf,
- virDomainNVRAMDefPtr def,
+virDomainNVRAMDefFormat(virBuffer *buf,
+ virDomainNVRAMDef *def,
unsigned int flags)
{
virBufferAddLit(buf, "<nvram>\n");
static int
-virDomainWatchdogDefFormat(virBufferPtr buf,
- virDomainWatchdogDefPtr def,
+virDomainWatchdogDefFormat(virBuffer *buf,
+ virDomainWatchdogDef *def,
unsigned int flags)
{
const char *model = virDomainWatchdogModelTypeToString(def->model);
return 0;
}
-static void virDomainPanicDefFormat(virBufferPtr buf, virDomainPanicDefPtr def)
+static void virDomainPanicDefFormat(virBuffer *buf, virDomainPanicDef *def)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
}
static void
-virDomainShmemDefFormat(virBufferPtr buf,
- virDomainShmemDefPtr def,
+virDomainShmemDefFormat(virBuffer *buf,
+ virDomainShmemDef *def,
unsigned int flags)
{
virBufferEscapeString(buf, "<shmem name='%s'", def->name);
}
static int
-virDomainRNGDefFormat(virBufferPtr buf,
- virDomainRNGDefPtr def,
+virDomainRNGDefFormat(virBuffer *buf,
+ virDomainRNGDef *def,
unsigned int flags)
{
const char *model = virDomainRNGModelTypeToString(def->model);
}
void
-virDomainRNGDefFree(virDomainRNGDefPtr def)
+virDomainRNGDefFree(virDomainRNGDef *def)
{
if (!def)
return;
static int
-virDomainMemorySourceDefFormat(virBufferPtr buf,
- virDomainMemoryDefPtr def)
+virDomainMemorySourceDefFormat(virBuffer *buf,
+ virDomainMemoryDef *def)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
g_autofree char *bitmap = NULL;
static void
-virDomainMemoryTargetDefFormat(virBufferPtr buf,
- virDomainMemoryDefPtr def)
+virDomainMemoryTargetDefFormat(virBuffer *buf,
+ virDomainMemoryDef *def)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
}
static int
-virDomainMemoryDefFormat(virBufferPtr buf,
- virDomainMemoryDefPtr def,
+virDomainMemoryDefFormat(virBuffer *buf,
+ virDomainMemoryDef *def,
unsigned int flags)
{
const char *model = virDomainMemoryModelTypeToString(def->model);
}
static void
-virDomainVideoAccelDefFormat(virBufferPtr buf,
- virDomainVideoAccelDefPtr def)
+virDomainVideoAccelDefFormat(virBuffer *buf,
+ virDomainVideoAccelDef *def)
{
virBufferAddLit(buf, "<acceleration");
if (def->accel3d) {
}
static void
-virDomainVideoResolutionDefFormat(virBufferPtr buf,
- virDomainVideoResolutionDefPtr def)
+virDomainVideoResolutionDefFormat(virBuffer *buf,
+ virDomainVideoResolutionDef *def)
{
virBufferAddLit(buf, "<resolution");
if (def->x && def->y) {
}
static int
-virDomainVideoDefFormat(virBufferPtr buf,
- virDomainVideoDefPtr def,
+virDomainVideoDefFormat(virBuffer *buf,
+ virDomainVideoDef *def,
unsigned int flags)
{
const char *model = virDomainVideoTypeToString(def->type);
}
static int
-virDomainInputDefFormat(virBufferPtr buf,
- virDomainInputDefPtr def,
+virDomainInputDefFormat(virBuffer *buf,
+ virDomainInputDef *def,
unsigned int flags)
{
const char *type = virDomainInputTypeToString(def->type);
static int
-virDomainTimerDefFormat(virBufferPtr buf,
- virDomainTimerDefPtr def)
+virDomainTimerDefFormat(virBuffer *buf,
+ virDomainTimerDef *def)
{
const char *name = virDomainTimerNameTypeToString(def->name);
}
static void
-virDomainGraphicsAuthDefFormatAttr(virBufferPtr buf,
- virDomainGraphicsAuthDefPtr def,
+virDomainGraphicsAuthDefFormatAttr(virBuffer *buf,
+ virDomainGraphicsAuthDef *def,
unsigned int flags)
{
if (!def->passwd)
static void
-virDomainGraphicsListenDefFormat(virBufferPtr buf,
- virDomainGraphicsListenDefPtr def,
+virDomainGraphicsListenDefFormat(virBuffer *buf,
+ virDomainGraphicsListenDef *def,
unsigned int flags)
{
/* If generating migratable XML, skip listen address
* improve backward compatibility.
*/
static void
-virDomainGraphicsListenDefFormatAddr(virBufferPtr buf,
- virDomainGraphicsListenDefPtr glisten,
+virDomainGraphicsListenDefFormatAddr(virBuffer *buf,
+ virDomainGraphicsListenDef *glisten,
unsigned int flags)
{
if (!glisten)
}
static void
-virDomainSpiceGLDefFormat(virBufferPtr buf, virDomainGraphicsDefPtr def)
+virDomainSpiceGLDefFormat(virBuffer *buf, virDomainGraphicsDef *def)
{
if (def->data.spice.gl == VIR_TRISTATE_BOOL_ABSENT)
return;
}
static int
-virDomainGraphicsDefFormat(virBufferPtr buf,
- virDomainGraphicsDefPtr def,
+virDomainGraphicsDefFormat(virBuffer *buf,
+ virDomainGraphicsDef *def,
unsigned int flags)
{
- virDomainGraphicsListenDefPtr glisten = virDomainGraphicsGetListen(def, 0);
+ virDomainGraphicsListenDef *glisten = virDomainGraphicsGetListen(def, 0);
const char *type = virDomainGraphicsTypeToString(def->type);
bool children = false;
size_t i;
static int
-virDomainHostdevDefFormat(virBufferPtr buf,
- virDomainHostdevDefPtr def,
+virDomainHostdevDefFormat(virBuffer *buf,
+ virDomainHostdevDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
const char *mode = virDomainHostdevModeTypeToString(def->mode);
- virDomainHostdevSubsysSCSIPtr scsisrc = &def->source.subsys.u.scsi;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &def->source.subsys.u.mdev;
- virDomainHostdevSubsysSCSIVHostPtr scsihostsrc = &def->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysSCSI *scsisrc = &def->source.subsys.u.scsi;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &def->source.subsys.u.mdev;
+ virDomainHostdevSubsysSCSIVHost *scsihostsrc = &def->source.subsys.u.scsi_host;
const char *type;
if (!mode) {
}
static int
-virDomainRedirdevDefFormat(virBufferPtr buf,
- virDomainRedirdevDefPtr def,
+virDomainRedirdevDefFormat(virBuffer *buf,
+ virDomainRedirdevDef *def,
unsigned int flags)
{
const char *bus;
}
static void
-virDomainRedirFilterDefFormat(virBufferPtr buf,
- virDomainRedirFilterDefPtr filter)
+virDomainRedirFilterDefFormat(virBuffer *buf,
+ virDomainRedirFilterDef *filter)
{
size_t i;
virBufferAddLit(buf, "<redirfilter>\n");
virBufferAdjustIndent(buf, 2);
for (i = 0; i < filter->nusbdevs; i++) {
- virDomainRedirFilterUSBDevDefPtr usbdev = filter->usbdevs[i];
+ virDomainRedirFilterUSBDevDef *usbdev = filter->usbdevs[i];
virBufferAddLit(buf, "<usbdev");
if (usbdev->usbClass >= 0)
virBufferAsprintf(buf, " class='0x%02X'", usbdev->usbClass);
}
static int
-virDomainHubDefFormat(virBufferPtr buf,
- virDomainHubDefPtr def,
+virDomainHubDefFormat(virBuffer *buf,
+ virDomainHubDef *def,
unsigned int flags)
{
const char *type = virDomainHubTypeToString(def->type);
static void
-virDomainResourceDefFormat(virBufferPtr buf,
- virDomainResourceDefPtr def)
+virDomainResourceDefFormat(virBuffer *buf,
+ virDomainResourceDef *def)
{
virBufferAddLit(buf, "<resource>\n");
virBufferAdjustIndent(buf, 2);
static int
-virDomainHugepagesFormatBuf(virBufferPtr buf,
- virDomainHugePagePtr hugepage)
+virDomainHugepagesFormatBuf(virBuffer *buf,
+ virDomainHugePage *hugepage)
{
virBufferAsprintf(buf, "<page size='%llu' unit='KiB'",
hugepage->size);
}
static void
-virDomainHugepagesFormat(virBufferPtr buf,
- virDomainHugePagePtr hugepages,
+virDomainHugepagesFormat(virBuffer *buf,
+ virDomainHugePage *hugepages,
size_t nhugepages)
{
size_t i;
}
static void
-virDomainLoaderDefFormat(virBufferPtr buf,
- virDomainLoaderDefPtr loader)
+virDomainLoaderDefFormat(virBuffer *buf,
+ virDomainLoaderDef *loader)
{
const char *readonly = virTristateBoolTypeToString(loader->readonly);
const char *secure = virTristateBoolTypeToString(loader->secure);
}
static void
-virDomainKeyWrapDefFormat(virBufferPtr buf, virDomainKeyWrapDefPtr keywrap)
+virDomainKeyWrapDefFormat(virBuffer *buf, virDomainKeyWrapDef *keywrap)
{
virBufferAddLit(buf, "<keywrap>\n");
virBufferAdjustIndent(buf, 2);
static void
-virDomainSEVDefFormat(virBufferPtr buf, virDomainSEVDefPtr sev)
+virDomainSEVDefFormat(virBuffer *buf, virDomainSEVDef *sev)
{
if (!sev)
return;
static void
-virDomainPerfDefFormat(virBufferPtr buf, virDomainPerfDefPtr perf)
+virDomainPerfDefFormat(virBuffer *buf, virDomainPerfDef *perf)
{
size_t i;
bool wantPerf = false;
static void
-virDomainSchedulerFormat(virBufferPtr buf,
+virDomainSchedulerFormat(virBuffer *buf,
const char *name,
- virDomainThreadSchedParamPtr sched,
+ virDomainThreadSchedParam *sched,
size_t id,
bool multiple_threads)
{
void *opaque)
{
const char *unit;
- virBufferPtr buf = opaque;
+ virBuffer *buf = opaque;
unsigned long long short_size = virFormatIntPretty(size, &unit);
virBufferAsprintf(buf,
static int
-virDomainResctrlMonDefFormatHelper(virDomainResctrlMonDefPtr domresmon,
+virDomainResctrlMonDefFormatHelper(virDomainResctrlMonDef *domresmon,
virResctrlMonitorType tag,
- virBufferPtr buf)
+ virBuffer *buf)
{
g_autofree char *vcpus = NULL;
static int
-virDomainCachetuneDefFormat(virBufferPtr buf,
- virDomainResctrlDefPtr resctrl,
+virDomainCachetuneDefFormat(virBuffer *buf,
+ virDomainResctrlDef *resctrl,
unsigned int flags)
{
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
unsigned int bandwidth,
void *opaque)
{
- virBufferPtr buf = opaque;
+ virBuffer *buf = opaque;
virBufferAsprintf(buf,
"<node id='%u' bandwidth='%u'/>\n",
static int
-virDomainMemorytuneDefFormat(virBufferPtr buf,
- virDomainResctrlDefPtr resctrl,
+virDomainMemorytuneDefFormat(virBuffer *buf,
+ virDomainResctrlDef *resctrl,
unsigned int flags)
{
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
}
static int
-virDomainCputuneDefFormat(virBufferPtr buf,
- virDomainDefPtr def,
+virDomainCputuneDefFormat(virBuffer *buf,
+ virDomainDef *def,
unsigned int flags)
{
size_t i;
for (i = 0; i < def->maxvcpus; i++) {
char *cpumask;
- virDomainVcpuDefPtr vcpu = def->vcpus[i];
+ virDomainVcpuDef *vcpu = def->vcpus[i];
if (!vcpu->cpumask)
continue;
static int
-virDomainCpuDefFormat(virBufferPtr buf,
+virDomainCpuDefFormat(virBuffer *buf,
const virDomainDef *def)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t i;
g_autofree char *cpumask = NULL;
static bool
-virDomainDefIothreadShouldFormat(virDomainDefPtr def)
+virDomainDefIothreadShouldFormat(virDomainDef *def)
{
size_t i;
static void
-virDomainIOMMUDefFormat(virBufferPtr buf,
+virDomainIOMMUDefFormat(virBuffer *buf,
const virDomainIOMMUDef *iommu)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainMemtuneFormat(virBufferPtr buf,
+virDomainMemtuneFormat(virBuffer *buf,
const virDomainMemtune *mem)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainMemorybackingFormat(virBufferPtr buf,
+virDomainMemorybackingFormat(virBuffer *buf,
const virDomainMemtune *mem)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-virDomainVsockDefFormat(virBufferPtr buf,
- virDomainVsockDefPtr vsock)
+virDomainVsockDefFormat(virBuffer *buf,
+ virDomainVsockDef *vsock)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static void
-virDomainDefFormatBlkiotune(virBufferPtr buf,
- virDomainDefPtr def)
+virDomainDefFormatBlkiotune(virBuffer *buf,
+ virDomainDef *def)
{
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
ssize_t n;
def->blkio.weight);
for (n = 0; n < def->blkio.ndevices; n++) {
- virBlkioDevicePtr dev = &def->blkio.devices[n];
+ virBlkioDevice *dev = &def->blkio.devices[n];
if (!dev->weight && !dev->riops && !dev->wiops &&
!dev->rbps && !dev->wbps)
static int
-virDomainDefFormatFeatures(virBufferPtr buf,
- virDomainDefPtr def)
+virDomainDefFormatFeatures(virBuffer *buf,
+ virDomainDef *def)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
size_t i;
}
int
-virDomainDefFormatInternal(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- virBufferPtr buf,
+virDomainDefFormatInternal(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ virBuffer *buf,
unsigned int flags)
{
return virDomainDefFormatInternalSetRootName(def, xmlopt, buf,
* to string.
* Return -1 on failure. */
int
-virDomainDefFormatInternalSetRootName(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- virBufferPtr buf,
+virDomainDefFormatInternalSetRootName(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ virBuffer *buf,
const char *rootname,
unsigned int flags)
{
char *
-virDomainDefFormat(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainDefFormat(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
char *
-virDomainObjFormat(virDomainObjPtr obj,
- virDomainXMLOptionPtr xmlopt,
+virDomainObjFormat(virDomainObj *obj,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static bool
-virDomainDeviceIsUSB(virDomainDeviceDefPtr dev)
+virDomainDeviceIsUSB(virDomainDeviceDef *dev)
{
int t = dev->type;
if ((t == VIR_DOMAIN_DEVICE_DISK &&
typedef struct _virDomainCompatibleDeviceData virDomainCompatibleDeviceData;
-typedef virDomainCompatibleDeviceData *virDomainCompatibleDeviceDataPtr;
struct _virDomainCompatibleDeviceData {
- virDomainDeviceInfoPtr newInfo;
- virDomainDeviceInfoPtr oldInfo;
+ virDomainDeviceInfo *newInfo;
+ virDomainDeviceInfo *oldInfo;
};
static int
-virDomainDeviceInfoCheckBootIndex(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+virDomainDeviceInfoCheckBootIndex(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virDomainCompatibleDeviceDataPtr data = opaque;
+ virDomainCompatibleDeviceData *data = opaque;
/* Ignore the device we're about to update */
if (data->oldInfo == info)
}
int
-virDomainDefCompatibleDevice(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceDefPtr oldDev,
+virDomainDefCompatibleDevice(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceDef *oldDev,
virDomainDeviceAction action,
bool live)
{
}
static int
-virDomainDefSaveXML(virDomainDefPtr def,
+virDomainDefSaveXML(virDomainDef *def,
const char *configDir,
const char *xml)
{
}
int
-virDomainDefSave(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+virDomainDefSave(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
const char *configDir)
{
g_autofree char *xml = NULL;
}
int
-virDomainObjSave(virDomainObjPtr obj,
- virDomainXMLOptionPtr xmlopt,
+virDomainObjSave(virDomainObj *obj,
+ virDomainXMLOption *xmlopt,
const char *statusDir)
{
unsigned int flags = (VIR_DOMAIN_DEF_FORMAT_SECURE |
int
virDomainDeleteConfig(const char *configDir,
const char *autostartDir,
- virDomainObjPtr dom)
+ virDomainObj *dom)
{
g_autofree char *configFile = NULL;
g_autofree char *autostartLink = NULL;
* @return 0 on success, -1 on failure
*/
int
-virDiskNameToBusDeviceIndex(virDomainDiskDefPtr disk,
+virDiskNameToBusDeviceIndex(virDomainDiskDef *disk,
int *busIdx,
int *devIdx)
{
}
int
-virDomainFSInsert(virDomainDefPtr def, virDomainFSDefPtr fs)
+virDomainFSInsert(virDomainDef *def, virDomainFSDef *fs)
{
return VIR_APPEND_ELEMENT(def->fss, def->nfss, fs);
}
-virDomainFSDefPtr
-virDomainFSRemove(virDomainDefPtr def, size_t i)
+virDomainFSDef *
+virDomainFSRemove(virDomainDef *def, size_t i)
{
- virDomainFSDefPtr fs = def->fss[i];
+ virDomainFSDef *fs = def->fss[i];
VIR_DELETE_ELEMENT(def->fss, i, def->nfss);
return fs;
}
-virDomainFSDefPtr
-virDomainGetFilesystemForTarget(virDomainDefPtr def,
+virDomainFSDef *
+virDomainGetFilesystemForTarget(virDomainDef *def,
const char *target)
{
size_t i;
int
-virDomainChrDefForeach(virDomainDefPtr def,
+virDomainChrDefForeach(virDomainDef *def,
bool abortOnError,
virDomainChrDefIterator iter,
void *opaque)
int
-virDomainSmartcardDefForeach(virDomainDefPtr def,
+virDomainSmartcardDefForeach(virDomainDef *def,
bool abortOnError,
virDomainSmartcardDefIterator iter,
void *opaque)
int
-virDomainUSBDeviceDefForeach(virDomainDefPtr def,
+virDomainUSBDeviceDefForeach(virDomainDef *def,
virDomainUSBDeviceDefIterator iter,
void *opaque,
bool skipHubs)
/* usb-hub */
if (!skipHubs) {
for (i = 0; i < def->nhubs; i++) {
- virDomainHubDefPtr hub = def->hubs[i];
+ virDomainHubDef *hub = def->hubs[i];
if (hub->type == VIR_DOMAIN_HUB_TYPE_USB) {
if (iter(&hub->info, opaque) < 0)
return -1;
/* usb-host */
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+ virDomainHostdevDef *hostdev = def->hostdevs[i];
if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
if (iter(hostdev->info, opaque) < 0)
return -1;
/* usb-storage */
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
if (iter(&disk->info, opaque) < 0)
return -1;
/* usb-ccid */
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_CCID) {
if (iter(&cont->info, opaque) < 0)
return -1;
/* usb-kbd, usb-mouse, usb-tablet */
for (i = 0; i < def->ninputs; i++) {
- virDomainInputDefPtr input = def->inputs[i];
+ virDomainInputDef *input = def->inputs[i];
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
if (iter(&input->info, opaque) < 0)
/* usb-serial */
for (i = 0; i < def->nserials; i++) {
- virDomainChrDefPtr serial = def->serials[i];
+ virDomainChrDef *serial = def->serials[i];
if (serial->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB) {
if (iter(&serial->info, opaque) < 0)
return -1;
/* usb-audio model=usb */
for (i = 0; i < def->nsounds; i++) {
- virDomainSoundDefPtr sound = def->sounds[i];
+ virDomainSoundDef *sound = def->sounds[i];
if (sound->model == VIR_DOMAIN_SOUND_MODEL_USB) {
if (iter(&sound->info, opaque) < 0)
return -1;
/* usb-redir */
for (i = 0; i < def->nredirdevs; i++) {
- virDomainRedirdevDefPtr redirdev = def->redirdevs[i];
+ virDomainRedirdevDef *redirdev = def->redirdevs[i];
if (redirdev->bus == VIR_DOMAIN_REDIRDEV_BUS_USB) {
if (iter(&redirdev->info, opaque) < 0)
return -1;
* depending on the migratable flag (false for transitions between
* persistent and active, true for transitions across save files or
* snapshots). */
-virDomainDefPtr
-virDomainDefCopy(virDomainDefPtr src,
- virDomainXMLOptionPtr xmlopt,
+virDomainDef *
+virDomainDefCopy(virDomainDef *src,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
bool migratable)
{
return virDomainDefParseString(xml, xmlopt, parseOpaque, parse_flags);
}
-virDomainDefPtr
-virDomainObjCopyPersistentDef(virDomainObjPtr dom,
- virDomainXMLOptionPtr xmlopt,
+virDomainDef *
+virDomainObjCopyPersistentDef(virDomainObj *dom,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
- virDomainDefPtr cur;
+ virDomainDef *cur;
cur = virDomainObjGetPersistentDef(xmlopt, dom, parseOpaque);
if (!cur) {
virDomainState
-virDomainObjGetState(virDomainObjPtr dom, int *reason)
+virDomainObjGetState(virDomainObj *dom, int *reason)
{
if (reason)
*reason = dom->state.reason;
void
-virDomainObjSetState(virDomainObjPtr dom, virDomainState state, int reason)
+virDomainObjSetState(virDomainObj *dom, virDomainState state, int reason)
{
int last;
return 0;
}
-virDomainHostdevDefPtr
-virDomainNetGetActualHostdev(virDomainNetDefPtr iface)
+virDomainHostdevDef *
+virDomainNetGetActualHostdev(virDomainNetDef *iface)
{
if (iface->type == VIR_DOMAIN_NET_TYPE_HOSTDEV)
return &iface->data.hostdev.def;
}
int
-virDomainNetSetModelString(virDomainNetDefPtr net,
+virDomainNetSetModelString(virDomainNetDef *net,
const char *model)
{
size_t i;
* type, or NULL if this is an unsuitable type, or the index is out of
* bounds. If force0 is TRUE, i == 0, and there is no listen array,
* allocate one with a single item. */
-virDomainGraphicsListenDefPtr
-virDomainGraphicsGetListen(virDomainGraphicsDefPtr def, size_t i)
+virDomainGraphicsListenDef *
+virDomainGraphicsGetListen(virDomainGraphicsDef *def, size_t i)
{
if (!def->listens || (def->nListens <= i))
return NULL;
int
-virDomainGraphicsListenAppendAddress(virDomainGraphicsDefPtr def,
+virDomainGraphicsListenAppendAddress(virDomainGraphicsDef *def,
const char *address)
{
virDomainGraphicsListenDef glisten;
int
-virDomainGraphicsListenAppendSocket(virDomainGraphicsDefPtr def,
+virDomainGraphicsListenAppendSocket(virDomainGraphicsDef *def,
const char *socketPath)
{
virDomainGraphicsListenDef glisten;
*
* Returns a pointer to the net def or NULL if not found (error is reported).
*/
-virDomainNetDefPtr
-virDomainNetFind(virDomainDefPtr def, const char *device)
+virDomainNetDef *
+virDomainNetFind(virDomainDef *def, const char *device)
{
bool isMac = false;
virMacAddr mac;
return def->nets[i];
}
} else { /* ifname */
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
if ((net = virDomainNetFindByName(def, device)))
return net;
*
* Returns a pointer to the net def or NULL if not found.
*/
-virDomainNetDefPtr
-virDomainNetFindByName(virDomainDefPtr def,
+virDomainNetDef *
+virDomainNetFindByName(virDomainDef *def,
const char *ifname)
{
size_t i;
*
* Returns a pointer to copied @src or NULL in case of error.
*/
-virDomainDeviceDefPtr
-virDomainDeviceDefCopy(virDomainDeviceDefPtr src,
+virDomainDeviceDef *
+virDomainDeviceDefCopy(virDomainDeviceDef *src,
const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
-virSecurityLabelDefPtr
-virDomainDefGetSecurityLabelDef(virDomainDefPtr def, const char *model)
+virSecurityLabelDef *
+virDomainDefGetSecurityLabelDef(virDomainDef *def, const char *model)
{
size_t i;
- virSecurityLabelDefPtr seclabel = NULL;
+ virSecurityLabelDef *seclabel = NULL;
if (def == NULL || model == NULL)
return NULL;
}
-virSecurityDeviceLabelDefPtr
-virDomainChrSourceDefGetSecurityLabelDef(virDomainChrSourceDefPtr def,
+virSecurityDeviceLabelDef *
+virDomainChrSourceDefGetSecurityLabelDef(virDomainChrSourceDef *def,
const char *model)
{
size_t i;
typedef struct {
const char *devAlias;
- virDomainDeviceDefPtr dev;
+ virDomainDeviceDef *dev;
} virDomainDefFindDeviceCallbackData;
static int
-virDomainDefFindDeviceCallback(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
+virDomainDefFindDeviceCallback(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
void *opaque)
{
virDomainDefFindDeviceCallbackData *data = opaque;
}
int
-virDomainDefFindDevice(virDomainDefPtr def,
+virDomainDefFindDevice(virDomainDef *def,
const char *devAlias,
- virDomainDeviceDefPtr dev,
+ virDomainDeviceDef *dev,
bool reportError)
{
virDomainDefFindDeviceCallbackData data = { devAlias, dev };
}
-virDomainAudioDefPtr
+virDomainAudioDef *
virDomainDefFindAudioByID(const virDomainDef *def,
int id)
{
bool
-virDomainSoundModelSupportsCodecs(virDomainSoundDefPtr def)
+virDomainSoundModelSupportsCodecs(virDomainSoundDef *def)
{
return def->model == VIR_DOMAIN_SOUND_MODEL_ICH6 ||
def->model == VIR_DOMAIN_SOUND_MODEL_ICH9;
}
bool
-virDomainAudioIOCommonIsSet(virDomainAudioIOCommonPtr common)
+virDomainAudioIOCommonIsSet(virDomainAudioIOCommon *common)
{
return common->mixingEngine ||
common->fixedSettings ||
}
char *
-virDomainObjGetMetadata(virDomainObjPtr vm,
+virDomainObjGetMetadata(virDomainObj *vm,
int type,
const char *uri,
unsigned int flags)
{
- virDomainDefPtr def;
+ virDomainDef *def;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
static int
-virDomainDefSetMetadata(virDomainDefPtr def,
+virDomainDefSetMetadata(virDomainDef *def,
int type,
const char *metadata,
const char *key,
int
-virDomainObjSetMetadata(virDomainObjPtr vm,
+virDomainObjSetMetadata(virDomainObj *vm,
int type,
const char *metadata,
const char *key,
const char *uri,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
const char *stateDir,
const char *configDir,
unsigned int flags)
{
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
bool
-virDomainDefNeedsPlacementAdvice(virDomainDefPtr def)
+virDomainDefNeedsPlacementAdvice(virDomainDef *def)
{
if (def->placement_mode == VIR_DOMAIN_CPU_PLACEMENT_MODE_AUTO)
return true;
#undef VIR_DOMAIN_SHORT_NAME_MAX
int
-virDomainGetBlkioParametersAssignFromDef(virDomainDefPtr def,
+virDomainGetBlkioParametersAssignFromDef(virDomainDef *def,
virTypedParameterPtr params,
int *nparams,
int maxparams)
void
-virDomainDefVcpuOrderClear(virDomainDefPtr def)
+virDomainDefVcpuOrderClear(virDomainDef *def)
{
size_t i;
* in case of any error. That is to make sure nothing will fail half-way.
*/
void
-virDomainDiskSetBlockIOTune(virDomainDiskDefPtr disk,
+virDomainDiskSetBlockIOTune(virDomainDiskDef *disk,
virDomainBlockIoTuneInfo *info)
{
char *tmp_group = NULL;
return false;
}
-virNetworkPortDefPtr
-virDomainNetDefToNetworkPort(virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+virNetworkPortDef *
+virDomainNetDefToNetworkPort(virDomainDef *dom,
+ virDomainNetDef *iface)
{
g_autoptr(virNetworkPortDef) port = NULL;
}
int
-virDomainNetDefActualFromNetworkPort(virDomainNetDefPtr iface,
- virNetworkPortDefPtr port)
+virDomainNetDefActualFromNetworkPort(virDomainNetDef *iface,
+ virNetworkPortDef *port)
{
- virDomainActualNetDefPtr actual = NULL;
+ virDomainActualNetDef *actual = NULL;
if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return -1;
}
-virNetworkPortDefPtr
-virDomainNetDefActualToNetworkPort(virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+virNetworkPortDef *
+virDomainNetDefActualToNetworkPort(virDomainDef *dom,
+ virDomainNetDef *iface)
{
- virDomainActualNetDefPtr actual;
+ virDomainActualNetDef *actual;
g_autoptr(virNetworkPortDef) port = NULL;
if (!iface->data.network.actual) {
static int
virDomainNetCreatePort(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface,
+ virDomainDef *dom,
+ virDomainNetDef *iface,
unsigned int flags)
{
virErrorPtr save_err;
int
virDomainNetAllocateActualDevice(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+ virDomainDef *dom,
+ virDomainNetDef *iface)
{
return virDomainNetCreatePort(conn, dom, iface, 0);
}
void
virDomainNetNotifyActualDevice(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+ virDomainDef *dom,
+ virDomainNetDef *iface)
{
virDomainNetType actualType = virDomainNetGetActualType(iface);
int
virDomainNetReleaseActualDevice(virConnectPtr conn,
- virDomainDefPtr dom G_GNUC_UNUSED,
- virDomainNetDefPtr iface)
+ virDomainDef *dom G_GNUC_UNUSED,
+ virDomainNetDef *iface)
{
virNetworkPtr net = NULL;
virNetworkPortPtr port = NULL;
static int
-virDomainNetBandwidthToTypedParams(virNetDevBandwidthPtr bandwidth,
+virDomainNetBandwidthToTypedParams(virNetDevBandwidth *bandwidth,
virTypedParameterPtr *params,
int *nparams)
{
int
-virDomainNetBandwidthUpdate(virDomainNetDefPtr iface,
- virNetDevBandwidthPtr newBandwidth)
+virDomainNetBandwidthUpdate(virDomainNetDef *iface,
+ virNetDevBandwidth *newBandwidth)
{
virNetworkPtr net = NULL;
virNetworkPortPtr port = NULL;
* Returns 0 on success, -1 on failure.
*/
int
-virDomainNetResolveActualType(virDomainNetDefPtr iface)
+virDomainNetResolveActualType(virDomainNetDef *iface)
{
- virNetworkDefPtr def = NULL;
+ virNetworkDef *def = NULL;
int ret = -1;
g_autofree char *xml = NULL;
g_autoptr(virConnect) conn = NULL;
static int
-virDomainDiskAddISCSIPoolSourceHost(virStorageSourcePtr src,
- virStoragePoolDefPtr pooldef)
+virDomainDiskAddISCSIPoolSourceHost(virStorageSource *src,
+ virStoragePoolDef *pooldef)
{
g_auto(GStrv) tokens = NULL;
static int
-virDomainDiskTranslateSourcePoolAuth(virStorageSourcePtr src,
- virStoragePoolSourcePtr source)
+virDomainDiskTranslateSourcePoolAuth(virStorageSource *src,
+ virStoragePoolSource *source)
{
/* Only necessary when authentication set */
if (!source->auth)
static int
-virDomainDiskTranslateISCSIDirect(virStorageSourcePtr src,
- virStoragePoolDefPtr pooldef)
+virDomainDiskTranslateISCSIDirect(virStorageSource *src,
+ virStoragePoolDef *pooldef)
{
src->srcpool->actualtype = VIR_STORAGE_TYPE_NETWORK;
src->protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
static int
-virDomainStorageSourceTranslateSourcePool(virStorageSourcePtr src,
+virDomainStorageSourceTranslateSourcePool(virStorageSource *src,
virConnectPtr conn)
{
virStorageVolInfo info;
int
-virDomainDiskTranslateSourcePool(virDomainDiskDefPtr def)
+virDomainDiskTranslateSourcePool(virDomainDiskDef *def)
{
g_autoptr(virConnect) conn = NULL;
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = def->src; virStorageSourceIsBacking(n); n = n->backingStore) {
if (n->type != VIR_STORAGE_TYPE_VOLUME || !n->srcpool)
size_t i;
for (i = 0; i < def->ngraphics; i++) {
- virDomainGraphicsDefPtr graphics = def->graphics[i];
+ virDomainGraphicsDef *graphics = def->graphics[i];
/* we only care about OpenGL support for a given type here */
switch (graphics->type) {
void
virDomainBlockIoTuneInfoCopy(const virDomainBlockIoTuneInfo *src,
- virDomainBlockIoTuneInfoPtr dst)
+ virDomainBlockIoTuneInfo *dst)
{
*dst = *src;
dst->group_name = g_strdup(src->group_name);
struct _virDomainDeviceDef {
int type; /* enum virDomainDeviceType */
union {
- virDomainDiskDefPtr disk;
- virDomainControllerDefPtr controller;
- virDomainLeaseDefPtr lease;
- virDomainFSDefPtr fs;
- virDomainNetDefPtr net;
- virDomainInputDefPtr input;
- virDomainSoundDefPtr sound;
- virDomainVideoDefPtr video;
- virDomainHostdevDefPtr hostdev;
- virDomainWatchdogDefPtr watchdog;
- virDomainGraphicsDefPtr graphics;
- virDomainHubDefPtr hub;
- virDomainRedirdevDefPtr redirdev;
- virDomainSmartcardDefPtr smartcard;
- virDomainChrDefPtr chr;
- virDomainMemballoonDefPtr memballoon;
- virDomainNVRAMDefPtr nvram;
- virDomainRNGDefPtr rng;
- virDomainShmemDefPtr shmem;
- virDomainTPMDefPtr tpm;
- virDomainPanicDefPtr panic;
- virDomainMemoryDefPtr memory;
- virDomainIOMMUDefPtr iommu;
- virDomainVsockDefPtr vsock;
- virDomainAudioDefPtr audio;
+ virDomainDiskDef *disk;
+ virDomainControllerDef *controller;
+ virDomainLeaseDef *lease;
+ virDomainFSDef *fs;
+ virDomainNetDef *net;
+ virDomainInputDef *input;
+ virDomainSoundDef *sound;
+ virDomainVideoDef *video;
+ virDomainHostdevDef *hostdev;
+ virDomainWatchdogDef *watchdog;
+ virDomainGraphicsDef *graphics;
+ virDomainHubDef *hub;
+ virDomainRedirdevDef *redirdev;
+ virDomainSmartcardDef *smartcard;
+ virDomainChrDef *chr;
+ virDomainMemballoonDef *memballoon;
+ virDomainNVRAMDef *nvram;
+ virDomainRNGDef *rng;
+ virDomainShmemDef *shmem;
+ virDomainTPMDef *tpm;
+ virDomainPanicDef *panic;
+ virDomainMemoryDef *memory;
+ virDomainIOMMUDef *iommu;
+ virDomainVsockDef *vsock;
+ virDomainAudioDef *audio;
} data;
};
unsigned bus;
unsigned target;
unsigned long long unit;
- virStorageSourcePtr src;
+ virStorageSource *src;
};
struct _virDomainHostdevSubsysSCSIiSCSI {
- virStorageSourcePtr src;
+ virStorageSource *src;
};
struct _virDomainHostdevSubsysSCSI {
* hostdevs internally. This hostdev should never be
* visible to the user except as part of the interface
*/
- virDomainNetDefPtr parentnet;
+ virDomainNetDef *parentnet;
int mode; /* enum virDomainHostdevMode */
int startupPolicy; /* enum virDomainStartupPolicy */
virDomainHostdevCaps caps;
} source;
virDomainHostdevOrigStates origstates;
- virDomainNetTeamingInfoPtr teaming;
- virDomainDeviceInfoPtr info; /* Guest address */
+ virDomainNetTeamingInfo *teaming;
+ virDomainDeviceInfo *info; /* Guest address */
};
/* Stores the virtual disk configuration */
struct _virDomainDiskDef {
- virStorageSourcePtr src; /* non-NULL. XXX Allow NULL for empty cdrom? */
+ virStorageSource *src; /* non-NULL. XXX Allow NULL for empty cdrom? */
- virObjectPtr privateData;
+ virObject *privateData;
int device; /* enum virDomainDiskDevice */
int bus; /* enum virDomainDiskBus */
int removable; /* enum virTristateSwitch */
unsigned int rotation_rate;
- virStorageSourcePtr mirror;
+ virStorageSource *mirror;
int mirrorState; /* enum virDomainDiskMirrorState */
int mirrorJob; /* virDomainBlockJobType */
char *domain_name; /* backend domain name */
unsigned int queues;
int model; /* enum virDomainDiskModel */
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
bool diskElementAuth;
bool diskElementEnc;
virDomainXenbusControllerOpts xenbusopts;
} opts;
virDomainDeviceInfo info;
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
};
unsigned int dmode;
int multidevs; /* virDomainFSMultidevs */
unsigned long long usage; /* in bytes */
- virStorageSourcePtr src;
+ virStorageSource *src;
char *dst;
bool readonly;
virDomainDeviceInfo info;
virDomainFSCacheMode cache;
virTristateSwitch posix_lock;
virTristateSwitch flock;
- virDomainVirtioOptionsPtr virtio;
- virObjectPtr privateData;
+ virDomainVirtioOptions *virtio;
+ virObject *privateData;
};
virDomainHostdevDef def;
} hostdev;
} data;
- virNetDevVPortProfilePtr virtPortProfile;
- virNetDevBandwidthPtr bandwidth;
+ virNetDevVPortProfile *virtPortProfile;
+ virNetDevBandwidth *bandwidth;
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
virTristateBool isolatedPort;
char *tap;
char *vhost;
} backend;
- virDomainNetTeamingInfoPtr teaming;
+ virDomainNetTeamingInfo *teaming;
union {
- virDomainChrSourceDefPtr vhostuser;
+ virDomainChrSourceDef *vhostuser;
struct {
char *address;
int port;
* This information is populated from the virNetworkPort
* object associated with the portid UUID above.
*/
- virDomainActualNetDefPtr actual;
+ virDomainActualNetDef *actual;
} network;
struct {
char *devicepath;
} hostdev;
} data;
/* virtPortProfile is used by network/bridge/direct/hostdev */
- virNetDevVPortProfilePtr virtPortProfile;
+ virNetDevVPortProfile *virtPortProfile;
struct {
bool sndbuf_specified;
unsigned long sndbuf;
virDomainDeviceInfo info;
char *filter;
GHashTable *filterparams;
- virNetDevBandwidthPtr bandwidth;
+ virNetDevBandwidth *bandwidth;
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
virTristateBool isolatedPort;
int linkstate;
unsigned int mtu;
- virNetDevCoalescePtr coalesce;
- virDomainVirtioOptionsPtr virtio;
- virObjectPtr privateData;
+ virNetDevCoalesce *coalesce;
+ virDomainVirtioOptions *virtio;
+ virObject *privateData;
};
typedef enum {
struct _virDomainChrSourceDef {
virObject parent;
int type; /* virDomainChrType */
- virObjectPtr privateData;
+ virObject *privateData;
union {
/* no <source> for null, vc, stdio */
struct {
int logappend;
size_t nseclabels;
- virSecurityDeviceLabelDefPtr *seclabels;
+ virSecurityDeviceLabelDef **seclabels;
};
/* A complete character device, both host and domain views. */
union {
int port; /* parallel, serial, console */
- virSocketAddrPtr addr; /* guestfwd */
+ virSocketAddr *addr; /* guestfwd */
char *name; /* virtio */
} target;
virDomainChrDeviceState state;
- virDomainChrSourceDefPtr source;
+ virDomainChrSourceDef *source;
virDomainDeviceInfo info;
};
char *file[VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES];
char *database;
} cert; /* 'host-certificates' */
- virDomainChrSourceDefPtr passthru; /* 'passthrough' */
+ virDomainChrSourceDef *passthru; /* 'passthrough' */
} data;
virDomainDeviceInfo info;
char *evdev;
} source;
virDomainDeviceInfo info;
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
};
typedef enum {
virDomainDeviceInfo info;
size_t ncodecs;
- virDomainSoundCodecDefPtr *codecs;
+ virDomainSoundCodecDef **codecs;
unsigned int audioId;
};
} virDomainAudioFormat;
typedef struct _virDomainAudioIOCommon virDomainAudioIOCommon;
-typedef virDomainAudioIOCommon *virDomainAudioIOCommonPtr;
struct _virDomainAudioIOCommon {
virTristateBool mixingEngine;
virTristateBool fixedSettings;
};
typedef struct _virDomainAudioIOALSA virDomainAudioIOALSA;
-typedef virDomainAudioIOALSA *virDomainAudioIOALSAPtr;
struct _virDomainAudioIOALSA {
char *dev;
};
typedef struct _virDomainAudioIOCoreAudio virDomainAudioIOCoreAudio;
-typedef virDomainAudioIOCoreAudio *virDomainAudioIOCoreAudioPtr;
struct _virDomainAudioIOCoreAudio {
unsigned int bufferCount;
};
typedef struct _virDomainAudioIOJack virDomainAudioIOJack;
-typedef virDomainAudioIOJack *virDomainAudioIOJackPtr;
struct _virDomainAudioIOJack {
char *serverName;
char *clientName;
};
typedef struct _virDomainAudioIOOSS virDomainAudioIOOSS;
-typedef virDomainAudioIOOSS *virDomainAudioIOOSSPtr;
struct _virDomainAudioIOOSS {
char *dev;
unsigned int bufferCount;
};
typedef struct _virDomainAudioIOPulseAudio virDomainAudioIOPulseAudio;
-typedef virDomainAudioIOPulseAudio *virDomainAudioIOPulseAudioPtr;
struct _virDomainAudioIOPulseAudio {
char *name;
char *streamName;
};
typedef struct _virDomainAudioIOSDL virDomainAudioIOSDL;
-typedef virDomainAudioIOSDL *virDomainAudioIOSDLPtr;
struct _virDomainAudioIOSDL {
unsigned int bufferCount;
};
};
struct _virDomainVideoDef {
- virObjectPtr privateData;
+ virObject *privateData;
int type; /* enum virDomainVideoType */
unsigned int ram; /* kibibytes (multiples of 1024) */
unsigned int vgamem; /* kibibytes (multiples of 1024) */
unsigned int heads;
bool primary;
- virDomainVideoAccelDefPtr accel;
- virDomainVideoResolutionDefPtr res;
- virDomainVideoDriverDefPtr driver;
+ virDomainVideoAccelDef *accel;
+ virDomainVideoResolutionDef *res;
+ virDomainVideoDriverDef *driver;
virDomainDeviceInfo info;
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
virDomainVideoBackendType backend;
};
};
struct _virDomainGraphicsDef {
- virObjectPtr privateData;
+ virObject *privateData;
/* Port value discipline:
* Value -1 is legacy syntax indicating that it should be auto-allocated.
* rdp, or spice. They've been extracted from the union only to
* simplify parsing code.*/
size_t nListens;
- virDomainGraphicsListenDefPtr listens;
+ virDomainGraphicsListenDef *listens;
};
typedef enum {
struct _virDomainRedirdevDef {
int bus; /* enum virDomainRedirdevBus */
- virDomainChrSourceDefPtr source;
+ virDomainChrSourceDef *source;
virDomainDeviceInfo info; /* Guest address */
};
struct _virDomainRedirFilterDef {
size_t nusbdevs;
- virDomainRedirFilterUSBDevDefPtr *usbdevs;
+ virDomainRedirFilterUSBDevDef **usbdevs;
};
typedef enum {
int period; /* seconds between collections */
int autodeflate; /* enum virTristateSwitch */
int free_page_reporting; /* enum virTristateSwitch */
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
};
struct _virDomainNVRAMDef {
char *templt; /* user override of path to master nvram */
};
-void virDomainLoaderDefFree(virDomainLoaderDefPtr loader);
+void virDomainLoaderDefFree(virDomainLoaderDef *loader);
typedef enum {
VIR_DOMAIN_IOAPIC_NONE = 0,
bool bm_timeout_set;
char *init;
char **initargv;
- virDomainOSEnvPtr *initenv;
+ virDomainOSEnv **initenv;
char *initdir;
char *inituser;
char *initgroup;
char *dtb;
char *root;
char *slic_table;
- virDomainLoaderDefPtr loader;
+ virDomainLoaderDef *loader;
char *bootloader;
char *bootloaderArgs;
int smbios_mode;
} data;
size_t ntimers;
- virDomainTimerDefPtr *timers;
+ virDomainTimerDef **timers;
};
union {
char *file; /* file name for 'random' source */
- virDomainChrSourceDefPtr chardev; /* a char backend for
- the EGD source */
+ virDomainChrSourceDef *chardev; /* a char backend for the EGD source */
} source;
virDomainDeviceInfo info;
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
};
typedef enum {
virTristateBool discard;
/* source */
- virBitmapPtr sourceNodes;
+ virBitmap *sourceNodes;
unsigned long long pagesize; /* kibibytes */
char *nvdimmPath; /* valid for NVDIMM an VIRTIO_PMEM */
unsigned long long alignsize; /* kibibytes; valid only for NVDIMM */
virDomainDeviceInfo info;
};
-void virDomainMemoryDefFree(virDomainMemoryDefPtr def);
+void virDomainMemoryDefFree(virDomainMemoryDef *def);
struct _virDomainIdMapEntry {
unsigned int start;
struct _virDomainIdMapDef {
size_t nuidmap;
- virDomainIdMapEntryPtr uidmap;
+ virDomainIdMapEntry *uidmap;
size_t ngidmap;
- virDomainIdMapEntryPtr gidmap;
+ virDomainIdMapEntry *gidmap;
};
};
-void virBlkioDeviceArrayClear(virBlkioDevicePtr deviceWeights,
+void virBlkioDeviceArrayClear(virBlkioDevice *deviceWeights,
int ndevices);
struct _virDomainResourceDef {
};
struct _virDomainHugePage {
- virBitmapPtr nodemask; /* guest's NUMA node mask */
+ virBitmap *nodemask; /* guest's NUMA node mask */
unsigned long long size; /* hugepage size in KiB */
};
bool autofill;
unsigned int iothread_id;
int thread_id;
- virBitmapPtr cpumask;
+ virBitmap *cpumask;
virDomainThreadSchedParam sched;
};
-void virDomainIOThreadIDDefFree(virDomainIOThreadIDDefPtr def);
+void virDomainIOThreadIDDefFree(virDomainIOThreadIDDef *def);
struct _virDomainCputune {
long long emulator_quota;
unsigned long long iothread_period;
long long iothread_quota;
- virBitmapPtr emulatorpin;
- virDomainThreadSchedParamPtr emulatorsched;
+ virBitmap *emulatorpin;
+ virDomainThreadSchedParam *emulatorsched;
};
struct _virDomainResctrlMonDef {
- virBitmapPtr vcpus;
+ virBitmap *vcpus;
virResctrlMonitorType tag;
- virResctrlMonitorPtr instance;
+ virResctrlMonitor *instance;
};
struct _virDomainResctrlDef {
- virBitmapPtr vcpus;
- virResctrlAllocPtr alloc;
+ virBitmap *vcpus;
+ virResctrlAlloc *alloc;
- virDomainResctrlMonDefPtr *monitors;
+ virDomainResctrlMonDef **monitors;
size_t nmonitors;
};
virTristateBool hotpluggable;
unsigned int order;
- virBitmapPtr cpumask;
+ virBitmap *cpumask;
virDomainThreadSchedParam sched;
- virObjectPtr privateData;
+ virObject *privateData;
};
struct _virDomainBlkiotune {
unsigned int weight;
size_t ndevices;
- virBlkioDevicePtr devices;
+ virBlkioDevice *devices;
};
struct _virDomainMemtune {
unsigned long long cur_balloon; /* in kibibytes, capped at ulong thanks
to virDomainGetInfo */
- virDomainHugePagePtr hugepages;
+ virDomainHugePage *hugepages;
size_t nhugepages;
/* maximum supported memory for a guest, for hotplugging */
} virDomainVsockModel;
struct _virDomainVsockDef {
- virObjectPtr privateData;
+ virObject *privateData;
virDomainVsockModel model;
unsigned int guest_cid;
virTristateBool auto_cid;
virDomainDeviceInfo info;
- virDomainVirtioOptionsPtr virtio;
+ virDomainVirtioOptions *virtio;
};
struct _virDomainVirtioOptions {
virDomainBlkiotune blkio;
virDomainMemtune mem;
- virDomainVcpuDefPtr *vcpus;
+ virDomainVcpuDef **vcpus;
size_t maxvcpus;
/* set if the vcpu definition was specified individually */
bool individualvcpus;
int placement_mode;
- virBitmapPtr cpumask;
+ virBitmap *cpumask;
size_t niothreadids;
- virDomainIOThreadIDDefPtr *iothreadids;
+ virDomainIOThreadIDDef **iothreadids;
virDomainCputune cputune;
- virDomainResctrlDefPtr *resctrls;
+ virDomainResctrlDef **resctrls;
size_t nresctrls;
- virDomainNumaPtr numa;
- virDomainResourceDefPtr resource;
+ virDomainNuma *numa;
+ virDomainResourceDef *resource;
virDomainIdMapDef idmap;
/* These 3 are based on virDomainLifeCycleAction enum flags */
virDomainClockDef clock;
size_t ngraphics;
- virDomainGraphicsDefPtr *graphics;
+ virDomainGraphicsDef **graphics;
size_t ndisks;
- virDomainDiskDefPtr *disks;
+ virDomainDiskDef **disks;
size_t ncontrollers;
- virDomainControllerDefPtr *controllers;
+ virDomainControllerDef **controllers;
size_t nfss;
- virDomainFSDefPtr *fss;
+ virDomainFSDef **fss;
size_t nnets;
- virDomainNetDefPtr *nets;
+ virDomainNetDef **nets;
size_t ninputs;
- virDomainInputDefPtr *inputs;
+ virDomainInputDef **inputs;
size_t nsounds;
- virDomainSoundDefPtr *sounds;
+ virDomainSoundDef **sounds;
size_t naudios;
- virDomainAudioDefPtr *audios;
+ virDomainAudioDef **audios;
size_t nvideos;
- virDomainVideoDefPtr *videos;
+ virDomainVideoDef **videos;
size_t nhostdevs;
- virDomainHostdevDefPtr *hostdevs;
+ virDomainHostdevDef **hostdevs;
size_t nredirdevs;
- virDomainRedirdevDefPtr *redirdevs;
+ virDomainRedirdevDef **redirdevs;
size_t nsmartcards;
- virDomainSmartcardDefPtr *smartcards;
+ virDomainSmartcardDef **smartcards;
size_t nserials;
- virDomainChrDefPtr *serials;
+ virDomainChrDef **serials;
size_t nparallels;
- virDomainChrDefPtr *parallels;
+ virDomainChrDef **parallels;
size_t nchannels;
- virDomainChrDefPtr *channels;
+ virDomainChrDef **channels;
size_t nconsoles;
- virDomainChrDefPtr *consoles;
+ virDomainChrDef **consoles;
size_t nleases;
- virDomainLeaseDefPtr *leases;
+ virDomainLeaseDef **leases;
size_t nhubs;
- virDomainHubDefPtr *hubs;
+ virDomainHubDef **hubs;
size_t nseclabels;
- virSecurityLabelDefPtr *seclabels;
+ virSecurityLabelDef **seclabels;
size_t nrngs;
- virDomainRNGDefPtr *rngs;
+ virDomainRNGDef **rngs;
size_t nshmems;
- virDomainShmemDefPtr *shmems;
+ virDomainShmemDef **shmems;
size_t nmems;
- virDomainMemoryDefPtr *mems;
+ virDomainMemoryDef **mems;
size_t npanics;
- virDomainPanicDefPtr *panics;
+ virDomainPanicDef **panics;
size_t nsysinfo;
- virSysinfoDefPtr *sysinfo;
+ virSysinfoDef **sysinfo;
/* At maximum 2 TPMs on the domain if a TPM Proxy is present. */
size_t ntpms;
- virDomainTPMDefPtr *tpms;
+ virDomainTPMDef **tpms;
/* Only 1 */
- virDomainWatchdogDefPtr watchdog;
- virDomainMemballoonDefPtr memballoon;
- virDomainNVRAMDefPtr nvram;
- virCPUDefPtr cpu;
- virDomainRedirFilterDefPtr redirfilter;
- virDomainIOMMUDefPtr iommu;
- virDomainVsockDefPtr vsock;
+ virDomainWatchdogDef *watchdog;
+ virDomainMemballoonDef *memballoon;
+ virDomainNVRAMDef *nvram;
+ virCPUDef *cpu;
+ virDomainRedirFilterDef *redirfilter;
+ virDomainIOMMUDef *iommu;
+ virDomainVsockDef *vsock;
void *namespaceData;
virXMLNamespace ns;
- virDomainKeyWrapDefPtr keywrap;
+ virDomainKeyWrapDef *keywrap;
/* SEV-specific domain */
- virDomainSEVDefPtr sev;
+ virDomainSEVDef *sev;
/* Application-specific custom metadata */
xmlNodePtr metadata;
unsigned long long virDomainDefGetMemoryInitial(const virDomainDef *def);
-void virDomainDefSetMemoryTotal(virDomainDefPtr def, unsigned long long size);
+void virDomainDefSetMemoryTotal(virDomainDef *def, unsigned long long size);
unsigned long long virDomainDefGetMemoryTotal(const virDomainDef *def);
bool virDomainDefHasMemoryHotplug(const virDomainDef *def);
unsigned int updated : 1;
unsigned int removing : 1;
- virDomainDefPtr def; /* The current definition */
- virDomainDefPtr newDef; /* New definition to activate at shutdown */
+ virDomainDef *def; /* The current definition */
+ virDomainDef *newDef; /* New definition to activate at shutdown */
- virDomainSnapshotObjListPtr snapshots;
+ virDomainSnapshotObjList *snapshots;
bool hasManagedSave;
- virDomainCheckpointObjListPtr checkpoints;
+ virDomainCheckpointObjList *checkpoints;
void *privateData;
void (*privateDataFreeFunc)(void *);
typedef bool (*virDomainObjListACLFilter)(virConnectPtr conn,
- virDomainDefPtr def);
+ virDomainDef *def);
/* NB: Any new flag to this list be considered to be set in
* This has similar semantics to virDomainDefPostParseCallback, but no
* parseOpaque is used. This callback is run prior to
* virDomainDefPostParseCallback. */
-typedef int (*virDomainDefPostParseBasicCallback)(virDomainDefPtr def,
+typedef int (*virDomainDefPostParseBasicCallback)(virDomainDef *def,
void *opaque);
/* Called once after everything else has been parsed, for adjusting
* cases when that is allowed, such failure is translated to a success return
* value and the failure is noted in def->postParseFailed. Drivers should then
* re-run the post parse callback when attempting to use such definition. */
-typedef int (*virDomainDefPostParseCallback)(virDomainDefPtr def,
+typedef int (*virDomainDefPostParseCallback)(virDomainDef *def,
unsigned int parseFlags,
void *opaque,
void *parseOpaque);
* @parseOpaque is opaque data passed by virDomainDefParse* caller,
* @opaque is opaque data set by driver (usually pointer to driver
* private data). */
-typedef int (*virDomainDeviceDefPostParseCallback)(virDomainDeviceDefPtr dev,
+typedef int (*virDomainDeviceDefPostParseCallback)(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags,
void *opaque,
typedef void *(*virDomainXMLPrivateDataAllocFunc)(void *);
typedef void (*virDomainXMLPrivateDataFreeFunc)(void *);
-typedef virObjectPtr (*virDomainXMLPrivateDataNewFunc)(void);
-typedef int (*virDomainXMLPrivateDataFormatFunc)(virBufferPtr,
- virDomainObjPtr);
+typedef virObject *(*virDomainXMLPrivateDataNewFunc)(void);
+typedef int (*virDomainXMLPrivateDataFormatFunc)(virBuffer *,
+ virDomainObj *);
typedef int (*virDomainXMLPrivateDataParseFunc)(xmlXPathContextPtr,
- virDomainObjPtr,
- virDomainDefParserConfigPtr);
+ virDomainObj *,
+ virDomainDefParserConfig *);
-typedef void *(*virDomainXMLPrivateDataGetParseOpaqueFunc)(virDomainObjPtr vm);
+typedef void *(*virDomainXMLPrivateDataGetParseOpaqueFunc)(virDomainObj *vm);
typedef int (*virDomainXMLPrivateDataDiskParseFunc)(xmlXPathContextPtr ctxt,
- virDomainDiskDefPtr disk);
-typedef int (*virDomainXMLPrivateDataDiskFormatFunc)(virDomainDiskDefPtr disk,
- virBufferPtr buf);
+ virDomainDiskDef *disk);
+typedef int (*virDomainXMLPrivateDataDiskFormatFunc)(virDomainDiskDef *disk,
+ virBuffer *buf);
typedef int (*virDomainXMLPrivateDataStorageSourceParseFunc)(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src);
-typedef int (*virDomainXMLPrivateDataStorageSourceFormatFunc)(virStorageSourcePtr src,
- virBufferPtr buf);
+ virStorageSource *src);
+typedef int (*virDomainXMLPrivateDataStorageSourceFormatFunc)(virStorageSource *src,
+ virBuffer *buf);
struct _virDomainXMLPrivateDataCallbacks {
virDomainABIStabilityDomain domain;
};
-virDomainXMLOptionPtr virDomainXMLOptionNew(virDomainDefParserConfigPtr config,
- virDomainXMLPrivateDataCallbacksPtr priv,
- virXMLNamespacePtr xmlns,
- virDomainABIStabilityPtr abi,
- virSaveCookieCallbacksPtr saveCookie);
+virDomainXMLOption *virDomainXMLOptionNew(virDomainDefParserConfig *config,
+ virDomainXMLPrivateDataCallbacks *priv,
+ virXMLNamespace *xmlns,
+ virDomainABIStability *abi,
+ virSaveCookieCallbacks *saveCookie);
-virSaveCookieCallbacksPtr
-virDomainXMLOptionGetSaveCookie(virDomainXMLOptionPtr xmlopt);
+virSaveCookieCallbacks *
+virDomainXMLOptionGetSaveCookie(virDomainXMLOption *xmlopt);
-typedef int (*virDomainMomentPostParseCallback)(virDomainMomentDefPtr def);
+typedef int (*virDomainMomentPostParseCallback)(virDomainMomentDef *def);
-void virDomainXMLOptionSetMomentPostParse(virDomainXMLOptionPtr xmlopt,
+void virDomainXMLOptionSetMomentPostParse(virDomainXMLOption *xmlopt,
virDomainMomentPostParseCallback cb);
-int virDomainXMLOptionRunMomentPostParse(virDomainXMLOptionPtr xmlopt,
- virDomainMomentDefPtr def);
+int virDomainXMLOptionRunMomentPostParse(virDomainXMLOption *xmlopt,
+ virDomainMomentDef *def);
-void virDomainNetGenerateMAC(virDomainXMLOptionPtr xmlopt, virMacAddrPtr mac);
+void virDomainNetGenerateMAC(virDomainXMLOption *xmlopt, virMacAddr *mac);
-virXMLNamespacePtr
-virDomainXMLOptionGetNamespace(virDomainXMLOptionPtr xmlopt)
+virXMLNamespace *
+virDomainXMLOptionGetNamespace(virDomainXMLOption *xmlopt)
ATTRIBUTE_NONNULL(1);
/* This structure holds various callbacks and data needed
};
struct virDomainDefPostParseDeviceIteratorData {
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
void *parseOpaque;
unsigned int parseFlags;
};
virDomainSCSIDriveAddressIsUsed(const virDomainDef *def,
const virDomainDeviceDriveAddress *addr);
-int virDomainDefPostParse(virDomainDefPtr def,
+int virDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque);
bool virDomainDefHasUSB(const virDomainDef *def);
bool virDomainDeviceAliasIsUserAlias(const char *aliasStr);
static inline bool
-virDomainObjIsActive(virDomainObjPtr dom)
+virDomainObjIsActive(virDomainObj *dom)
{
return dom->def->id != -1;
}
-int virDomainObjCheckActive(virDomainObjPtr dom);
+int virDomainObjCheckActive(virDomainObj *dom);
-int virDomainDefSetVcpusMax(virDomainDefPtr def,
+int virDomainDefSetVcpusMax(virDomainDef *def,
unsigned int vcpus,
- virDomainXMLOptionPtr xmlopt);
+ virDomainXMLOption *xmlopt);
bool virDomainDefHasVcpusOffline(const virDomainDef *def);
unsigned int virDomainDefGetVcpusMax(const virDomainDef *def);
-int virDomainDefSetVcpus(virDomainDefPtr def, unsigned int vcpus);
+int virDomainDefSetVcpus(virDomainDef *def, unsigned int vcpus);
unsigned int virDomainDefGetVcpus(const virDomainDef *def);
-virBitmapPtr virDomainDefGetOnlineVcpumap(const virDomainDef *def);
-virDomainVcpuDefPtr virDomainDefGetVcpu(virDomainDefPtr def, unsigned int vcpu)
+virBitmap *virDomainDefGetOnlineVcpumap(const virDomainDef *def);
+virDomainVcpuDef *virDomainDefGetVcpu(virDomainDef *def, unsigned int vcpu)
G_GNUC_WARN_UNUSED_RESULT;
-void virDomainDefVcpuOrderClear(virDomainDefPtr def);
+void virDomainDefVcpuOrderClear(virDomainDef *def);
int virDomainDefGetVcpusTopology(const virDomainDef *def,
unsigned int *maxvcpus);
-virDomainObjPtr virDomainObjNew(virDomainXMLOptionPtr caps)
+virDomainObj *virDomainObjNew(virDomainXMLOption *caps)
ATTRIBUTE_NONNULL(1);
-void virDomainObjEndAPI(virDomainObjPtr *vm);
+void virDomainObjEndAPI(virDomainObj **vm);
-bool virDomainObjTaint(virDomainObjPtr obj,
+bool virDomainObjTaint(virDomainObj *obj,
virDomainTaintFlags taint);
-void virDomainObjDeprecation(virDomainObjPtr obj,
+void virDomainObjDeprecation(virDomainObj *obj,
const char *msg);
-void virDomainObjBroadcast(virDomainObjPtr vm);
-int virDomainObjWait(virDomainObjPtr vm);
-int virDomainObjWaitUntil(virDomainObjPtr vm,
+void virDomainObjBroadcast(virDomainObj *vm);
+int virDomainObjWait(virDomainObj *vm);
+int virDomainObjWaitUntil(virDomainObj *vm,
unsigned long long whenms);
-void virDomainPanicDefFree(virDomainPanicDefPtr panic);
-void virDomainResourceDefFree(virDomainResourceDefPtr resource);
-void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def);
-const char *virDomainInputDefGetPath(virDomainInputDefPtr input);
-void virDomainInputDefFree(virDomainInputDefPtr def);
-virDomainDiskDefPtr virDomainDiskDefNew(virDomainXMLOptionPtr xmlopt);
-void virDomainDiskDefFree(virDomainDiskDefPtr def);
+void virDomainPanicDefFree(virDomainPanicDef *panic);
+void virDomainResourceDefFree(virDomainResourceDef *resource);
+void virDomainGraphicsDefFree(virDomainGraphicsDef *def);
+const char *virDomainInputDefGetPath(virDomainInputDef *input);
+void virDomainInputDefFree(virDomainInputDef *def);
+virDomainDiskDef *virDomainDiskDefNew(virDomainXMLOption *xmlopt);
+void virDomainDiskDefFree(virDomainDiskDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainDiskDef, virDomainDiskDefFree);
-void virDomainLeaseDefFree(virDomainLeaseDefPtr def);
-int virDomainDiskGetType(virDomainDiskDefPtr def);
-void virDomainDiskSetType(virDomainDiskDefPtr def, int type);
+void virDomainLeaseDefFree(virDomainLeaseDef *def);
+int virDomainDiskGetType(virDomainDiskDef *def);
+void virDomainDiskSetType(virDomainDiskDef *def, int type);
const char *virDomainDiskGetSource(virDomainDiskDef const *def);
-void virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src);
-void virDomainDiskEmptySource(virDomainDiskDefPtr def);
+void virDomainDiskSetSource(virDomainDiskDef *def, const char *src);
+void virDomainDiskEmptySource(virDomainDiskDef *def);
const char *virDomainDiskGetDriver(const virDomainDiskDef *def);
-void virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name);
-int virDomainDiskGetFormat(virDomainDiskDefPtr def);
-void virDomainDiskSetFormat(virDomainDiskDefPtr def, int format);
-virDomainControllerDefPtr
+void virDomainDiskSetDriver(virDomainDiskDef *def, const char *name);
+int virDomainDiskGetFormat(virDomainDiskDef *def);
+void virDomainDiskSetFormat(virDomainDiskDef *def, int format);
+virDomainControllerDef *
virDomainDeviceFindSCSIController(const virDomainDef *def,
const virDomainDeviceDriveAddress *addr);
-virDomainDiskDefPtr virDomainDiskFindByBusAndDst(virDomainDefPtr def,
- int bus,
- char *dst);
+virDomainDiskDef *virDomainDiskFindByBusAndDst(virDomainDef *def,
+ int bus,
+ char *dst);
-virDomainControllerDefPtr virDomainControllerDefNew(virDomainControllerType type);
-void virDomainControllerDefFree(virDomainControllerDefPtr def);
+virDomainControllerDef *virDomainControllerDefNew(virDomainControllerType type);
+void virDomainControllerDefFree(virDomainControllerDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainControllerDef, virDomainControllerDefFree);
bool virDomainControllerIsPSeriesPHB(const virDomainControllerDef *cont);
-virDomainFSDefPtr virDomainFSDefNew(virDomainXMLOptionPtr xmlopt);
-void virDomainFSDefFree(virDomainFSDefPtr def);
-void virDomainActualNetDefFree(virDomainActualNetDefPtr def);
-virDomainVsockDefPtr virDomainVsockDefNew(virDomainXMLOptionPtr xmlopt);
-void virDomainVsockDefFree(virDomainVsockDefPtr vsock);
+virDomainFSDef *virDomainFSDefNew(virDomainXMLOption *xmlopt);
+void virDomainFSDefFree(virDomainFSDef *def);
+void virDomainActualNetDefFree(virDomainActualNetDef *def);
+virDomainVsockDef *virDomainVsockDefNew(virDomainXMLOption *xmlopt);
+void virDomainVsockDefFree(virDomainVsockDef *vsock);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainVsockDef, virDomainVsockDefFree);
-void virDomainNetTeamingInfoFree(virDomainNetTeamingInfoPtr teaming);
+void virDomainNetTeamingInfoFree(virDomainNetTeamingInfo *teaming);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainNetTeamingInfo, virDomainNetTeamingInfoFree);
-void virDomainNetDefFree(virDomainNetDefPtr def);
+void virDomainNetDefFree(virDomainNetDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainNetDef, virDomainNetDefFree);
-void virDomainSmartcardDefFree(virDomainSmartcardDefPtr def);
+void virDomainSmartcardDefFree(virDomainSmartcardDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainSmartcardDef, virDomainSmartcardDefFree);
-void virDomainChrDefFree(virDomainChrDefPtr def);
-int virDomainChrSourceDefCopy(virDomainChrSourceDefPtr dest,
- virDomainChrSourceDefPtr src);
-void virDomainSoundCodecDefFree(virDomainSoundCodecDefPtr def);
+void virDomainChrDefFree(virDomainChrDef *def);
+int virDomainChrSourceDefCopy(virDomainChrSourceDef *dest,
+ virDomainChrSourceDef *src);
+void virDomainSoundCodecDefFree(virDomainSoundCodecDef *def);
ssize_t virDomainSoundDefFind(const virDomainDef *def,
const virDomainSoundDef *sound);
-void virDomainSoundDefFree(virDomainSoundDefPtr def);
-virDomainSoundDefPtr virDomainSoundDefRemove(virDomainDefPtr def, size_t idx);
-void virDomainAudioDefFree(virDomainAudioDefPtr def);
-void virDomainMemballoonDefFree(virDomainMemballoonDefPtr def);
-void virDomainNVRAMDefFree(virDomainNVRAMDefPtr def);
-void virDomainWatchdogDefFree(virDomainWatchdogDefPtr def);
-virDomainVideoDefPtr virDomainVideoDefNew(virDomainXMLOptionPtr xmlopt);
-void virDomainVideoDefFree(virDomainVideoDefPtr def);
+void virDomainSoundDefFree(virDomainSoundDef *def);
+virDomainSoundDef *virDomainSoundDefRemove(virDomainDef *def, size_t idx);
+void virDomainAudioDefFree(virDomainAudioDef *def);
+void virDomainMemballoonDefFree(virDomainMemballoonDef *def);
+void virDomainNVRAMDefFree(virDomainNVRAMDef *def);
+void virDomainWatchdogDefFree(virDomainWatchdogDef *def);
+virDomainVideoDef *virDomainVideoDefNew(virDomainXMLOption *xmlopt);
+void virDomainVideoDefFree(virDomainVideoDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainVideoDef, virDomainVideoDefFree);
-void virDomainVideoDefClear(virDomainVideoDefPtr def);
-virDomainHostdevDefPtr virDomainHostdevDefNew(void);
-void virDomainHostdevDefClear(virDomainHostdevDefPtr def);
-void virDomainHostdevDefFree(virDomainHostdevDefPtr def);
-void virDomainHubDefFree(virDomainHubDefPtr def);
-void virDomainRedirdevDefFree(virDomainRedirdevDefPtr def);
-void virDomainRedirFilterDefFree(virDomainRedirFilterDefPtr def);
-void virDomainShmemDefFree(virDomainShmemDefPtr def);
-void virDomainDeviceDefFree(virDomainDeviceDefPtr def);
+void virDomainVideoDefClear(virDomainVideoDef *def);
+virDomainHostdevDef *virDomainHostdevDefNew(void);
+void virDomainHostdevDefClear(virDomainHostdevDef *def);
+void virDomainHostdevDefFree(virDomainHostdevDef *def);
+void virDomainHubDefFree(virDomainHubDef *def);
+void virDomainRedirdevDefFree(virDomainRedirdevDef *def);
+void virDomainRedirFilterDefFree(virDomainRedirFilterDef *def);
+void virDomainShmemDefFree(virDomainShmemDef *def);
+void virDomainDeviceDefFree(virDomainDeviceDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainDeviceDef, virDomainDeviceDefFree);
-virDomainDeviceDefPtr virDomainDeviceDefCopy(virDomainDeviceDefPtr src,
- const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque);
-virDomainDeviceInfoPtr virDomainDeviceGetInfo(virDomainDeviceDefPtr device);
-void virDomainDeviceSetData(virDomainDeviceDefPtr device,
+virDomainDeviceDef *virDomainDeviceDefCopy(virDomainDeviceDef *src,
+ const virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque);
+virDomainDeviceInfo *virDomainDeviceGetInfo(virDomainDeviceDef *device);
+void virDomainDeviceSetData(virDomainDeviceDef *device,
void *devicedata);
-void virDomainTPMDefFree(virDomainTPMDefPtr def);
+void virDomainTPMDefFree(virDomainTPMDef *def);
-typedef int (*virDomainDeviceInfoCallback)(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
+typedef int (*virDomainDeviceInfoCallback)(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
void *opaque);
-int virDomainDeviceInfoIterate(virDomainDefPtr def,
+int virDomainDeviceInfoIterate(virDomainDef *def,
virDomainDeviceInfoCallback cb,
void *opaque);
-bool virDomainDefHasDeviceAddress(virDomainDefPtr def,
- virDomainDeviceInfoPtr info)
+bool virDomainDefHasDeviceAddress(virDomainDef *def,
+ virDomainDeviceInfo *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-void virDomainDefFree(virDomainDefPtr vm);
+void virDomainDefFree(virDomainDef *vm);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainDef, virDomainDefFree);
-virDomainChrSourceDefPtr
-virDomainChrSourceDefNew(virDomainXMLOptionPtr xmlopt);
+virDomainChrSourceDef *
+virDomainChrSourceDefNew(virDomainXMLOption *xmlopt);
-virDomainChrDefPtr virDomainChrDefNew(virDomainXMLOptionPtr xmlopt);
+virDomainChrDef *virDomainChrDefNew(virDomainXMLOption *xmlopt);
-int virDomainDeviceInfoIterateFlags(virDomainDefPtr def,
+int virDomainDeviceInfoIterateFlags(virDomainDef *def,
virDomainDeviceInfoCallback cb,
unsigned int iteratorFlags,
void *opaque);
-virDomainGraphicsDefPtr
-virDomainGraphicsDefNew(virDomainXMLOptionPtr xmlopt);
+virDomainGraphicsDef *
+virDomainGraphicsDefNew(virDomainXMLOption *xmlopt);
-virDomainNetDefPtr
-virDomainNetDefNew(virDomainXMLOptionPtr xmlopt);
+virDomainNetDef *
+virDomainNetDefNew(virDomainXMLOption *xmlopt);
-virDomainDefPtr virDomainDefNew(void);
+virDomainDef *virDomainDefNew(void);
-void virDomainObjAssignDef(virDomainObjPtr domain,
- virDomainDefPtr def,
+void virDomainObjAssignDef(virDomainObj *domain,
+ virDomainDef *def,
bool live,
- virDomainDefPtr *oldDef);
-int virDomainObjSetDefTransient(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr domain,
+ virDomainDef **oldDef);
+int virDomainObjSetDefTransient(virDomainXMLOption *xmlopt,
+ virDomainObj *domain,
void *parseOpaque);
-void virDomainObjRemoveTransientDef(virDomainObjPtr domain);
-virDomainDefPtr
-virDomainObjGetPersistentDef(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr domain,
+void virDomainObjRemoveTransientDef(virDomainObj *domain);
+virDomainDef *
+virDomainObjGetPersistentDef(virDomainXMLOption *xmlopt,
+ virDomainObj *domain,
void *parseOpaque);
-int virDomainObjUpdateModificationImpact(virDomainObjPtr vm,
+int virDomainObjUpdateModificationImpact(virDomainObj *vm,
unsigned int *flags);
-int virDomainObjGetDefs(virDomainObjPtr vm,
+int virDomainObjGetDefs(virDomainObj *vm,
unsigned int flags,
- virDomainDefPtr *liveDef,
- virDomainDefPtr *persDef);
-virDomainDefPtr virDomainObjGetOneDefState(virDomainObjPtr vm,
- unsigned int flags,
- bool *state);
-virDomainDefPtr virDomainObjGetOneDef(virDomainObjPtr vm, unsigned int flags);
-
-virDomainDefPtr virDomainDefCopy(virDomainDefPtr src,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque,
- bool migratable);
-virDomainDefPtr virDomainObjCopyPersistentDef(virDomainObjPtr dom,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque);
+ virDomainDef **liveDef,
+ virDomainDef **persDef);
+virDomainDef *virDomainObjGetOneDefState(virDomainObj *vm,
+ unsigned int flags,
+ bool *state);
+virDomainDef *virDomainObjGetOneDef(virDomainObj *vm, unsigned int flags);
+
+virDomainDef *virDomainDefCopy(virDomainDef *src,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque,
+ bool migratable);
+virDomainDef *virDomainObjCopyPersistentDef(virDomainObj *dom,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque);
typedef enum {
/* parse internal domain status information */
VIR_DOMAIN_DEF_ABI_CHECK_SKIP_VOLATILE = 1 << 0,
} virDomainDefABICheckFlags;
-virDomainDeviceDefPtr virDomainDeviceDefParse(const char *xmlStr,
- const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque,
- unsigned int flags);
-virDomainDiskDefPtr virDomainDiskDefParse(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
- unsigned int flags);
-virDomainDefPtr virDomainDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque,
+virDomainDeviceDef *virDomainDeviceDefParse(const char *xmlStr,
+ const virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque,
+ unsigned int flags);
+virDomainDiskDef *virDomainDiskDefParse(const char *xmlStr,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-virDomainDefPtr virDomainDefParseFile(const char *filename,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque,
- unsigned int flags);
-virDomainDefPtr virDomainDefParseNode(xmlDocPtr doc,
- xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+virDomainDef *virDomainDefParseString(const char *xmlStr,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
unsigned int flags);
-virDomainObjPtr virDomainObjParseNode(xmlDocPtr xml,
- xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
- unsigned int flags);
-virDomainObjPtr virDomainObjParseFile(const char *filename,
- virDomainXMLOptionPtr xmlopt,
- unsigned int flags);
-
-bool virDomainDefCheckABIStability(virDomainDefPtr src,
- virDomainDefPtr dst,
- virDomainXMLOptionPtr xmlopt);
-
-bool virDomainDefCheckABIStabilityFlags(virDomainDefPtr src,
- virDomainDefPtr dst,
- virDomainXMLOptionPtr xmlopt,
+virDomainDef *virDomainDefParseFile(const char *filename,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque,
+ unsigned int flags);
+virDomainDef *virDomainDefParseNode(xmlDocPtr doc,
+ xmlNodePtr root,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque,
+ unsigned int flags);
+virDomainObj *virDomainObjParseNode(xmlDocPtr xml,
+ xmlNodePtr root,
+ virDomainXMLOption *xmlopt,
+ unsigned int flags);
+virDomainObj *virDomainObjParseFile(const char *filename,
+ virDomainXMLOption *xmlopt,
+ unsigned int flags);
+
+bool virDomainDefCheckABIStability(virDomainDef *src,
+ virDomainDef *dst,
+ virDomainXMLOption *xmlopt);
+
+bool virDomainDefCheckABIStabilityFlags(virDomainDef *src,
+ virDomainDef *dst,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-int virDomainDefAddImplicitDevices(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt);
+int virDomainDefAddImplicitDevices(virDomainDef *def,
+ virDomainXMLOption *xmlopt);
-virDomainIOThreadIDDefPtr virDomainIOThreadIDFind(const virDomainDef *def,
- unsigned int iothread_id);
-virDomainIOThreadIDDefPtr virDomainIOThreadIDAdd(virDomainDefPtr def,
- unsigned int iothread_id);
-void virDomainIOThreadIDDel(virDomainDefPtr def, unsigned int iothread_id);
+virDomainIOThreadIDDef *virDomainIOThreadIDFind(const virDomainDef *def,
+ unsigned int iothread_id);
+virDomainIOThreadIDDef *virDomainIOThreadIDAdd(virDomainDef *def,
+ unsigned int iothread_id);
+void virDomainIOThreadIDDel(virDomainDef *def, unsigned int iothread_id);
/* When extending this list, remember that libvirt 1.2.12-5.0.0 had a
* bug that silently ignored unknown flags. A new flag to add
VIR_DOMAIN_XML_MIGRATABLE)
unsigned int virDomainDefFormatConvertXMLFlags(unsigned int flags);
-char *virDomainDefFormat(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+char *virDomainDefFormat(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-char *virDomainObjFormat(virDomainObjPtr obj,
- virDomainXMLOptionPtr xmlopt,
+char *virDomainObjFormat(virDomainObj *obj,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainDefFormatInternal(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- virBufferPtr buf,
+int virDomainDefFormatInternal(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ virBuffer *buf,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3);
-int virDomainDefFormatInternalSetRootName(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- virBufferPtr buf,
+int virDomainDefFormatInternalSetRootName(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ virBuffer *buf,
const char *rootname,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-int virDomainDiskSourceFormat(virBufferPtr buf,
- virStorageSourcePtr src,
+int virDomainDiskSourceFormat(virBuffer *buf,
+ virStorageSource *src,
const char *element,
int policy,
bool attrIndex,
unsigned int flags,
bool skipAuth,
bool skipEnc,
- virDomainXMLOptionPtr xmlopt);
+ virDomainXMLOption *xmlopt);
int
-virDomainDiskBackingStoreFormat(virBufferPtr buf,
- virStorageSourcePtr src,
- virDomainXMLOptionPtr xmlopt,
+virDomainDiskBackingStoreFormat(virBuffer *buf,
+ virStorageSource *src,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-int virDomainNetDefFormat(virBufferPtr buf,
- virDomainNetDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+int virDomainNetDefFormat(virBuffer *buf,
+ virDomainNetDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
typedef enum {
VIR_DOMAIN_DEVICE_ACTION_UPDATE,
} virDomainDeviceAction;
-int virDomainDefCompatibleDevice(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceDefPtr oldDev,
+int virDomainDefCompatibleDevice(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceDef *oldDev,
virDomainDeviceAction action,
bool live);
-void virDomainRNGDefFree(virDomainRNGDefPtr def);
+void virDomainRNGDefFree(virDomainRNGDef *def);
-int virDomainDiskIndexByAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr pci_controller,
- virDomainDeviceCCWAddressPtr ccw_addr,
+int virDomainDiskIndexByAddress(virDomainDef *def,
+ virPCIDeviceAddress *pci_controller,
+ virDomainDeviceCCWAddress *ccw_addr,
unsigned int bus, unsigned int target,
unsigned int unit);
-virDomainDiskDefPtr virDomainDiskByAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr pci_controller,
- virDomainDeviceCCWAddressPtr ccw_addr,
- unsigned int bus,
- unsigned int target,
- unsigned int unit);
-int virDomainDiskIndexByName(virDomainDefPtr def, const char *name,
+virDomainDiskDef *virDomainDiskByAddress(virDomainDef *def,
+ virPCIDeviceAddress *pci_controller,
+ virDomainDeviceCCWAddress *ccw_addr,
+ unsigned int bus,
+ unsigned int target,
+ unsigned int unit);
+int virDomainDiskIndexByName(virDomainDef *def, const char *name,
bool allow_ambiguous);
-virDomainDiskDefPtr virDomainDiskByName(virDomainDefPtr def,
- const char *name,
- bool allow_ambiguous);
-virDomainDiskDefPtr
-virDomainDiskByTarget(virDomainDefPtr def,
+virDomainDiskDef *virDomainDiskByName(virDomainDef *def,
+ const char *name,
+ bool allow_ambiguous);
+virDomainDiskDef *
+virDomainDiskByTarget(virDomainDef *def,
const char *dst);
-void virDomainDiskInsert(virDomainDefPtr def, virDomainDiskDefPtr disk);
-void virDomainDiskInsertPreAlloced(virDomainDefPtr def,
- virDomainDiskDefPtr disk);
+void virDomainDiskInsert(virDomainDef *def, virDomainDiskDef *disk);
+void virDomainDiskInsertPreAlloced(virDomainDef *def,
+ virDomainDiskDef *disk);
int virDomainStorageNetworkParseHost(xmlNodePtr hostnode,
- virStorageNetHostDefPtr host);
-int virDomainDiskDefAssignAddress(virDomainXMLOptionPtr xmlopt,
- virDomainDiskDefPtr def,
+ virStorageNetHostDef *host);
+int virDomainDiskDefAssignAddress(virDomainXMLOption *xmlopt,
+ virDomainDiskDef *def,
const virDomainDef *vmdef);
-virDomainDiskDefPtr
-virDomainDiskRemove(virDomainDefPtr def, size_t i);
-virDomainDiskDefPtr
-virDomainDiskRemoveByName(virDomainDefPtr def, const char *name);
-
-int virDomainNetFindIdx(virDomainDefPtr def, virDomainNetDefPtr net);
-virDomainNetDefPtr virDomainNetFind(virDomainDefPtr def, const char *device);
-virDomainNetDefPtr virDomainNetFindByName(virDomainDefPtr def, const char *ifname);
-bool virDomainHasNet(virDomainDefPtr def, virDomainNetDefPtr net);
-int virDomainNetInsert(virDomainDefPtr def, virDomainNetDefPtr net);
-int virDomainNetUpdate(virDomainDefPtr def, size_t netidx, virDomainNetDefPtr newnet);
-int virDomainNetDHCPInterfaces(virDomainDefPtr def, virDomainInterfacePtr **ifaces);
-int virDomainNetARPInterfaces(virDomainDefPtr def, virDomainInterfacePtr **ifaces);
-virDomainNetDefPtr virDomainNetRemove(virDomainDefPtr def, size_t i);
-void virDomainNetRemoveHostdev(virDomainDefPtr def, virDomainNetDefPtr net);
-
-int virDomainHostdevInsert(virDomainDefPtr def, virDomainHostdevDefPtr hostdev);
-virDomainHostdevDefPtr
-virDomainHostdevRemove(virDomainDefPtr def, size_t i);
-int virDomainHostdevFind(virDomainDefPtr def, virDomainHostdevDefPtr match,
- virDomainHostdevDefPtr *found);
-
-virDomainGraphicsListenDefPtr
-virDomainGraphicsGetListen(virDomainGraphicsDefPtr def, size_t i);
-int virDomainGraphicsListenAppendAddress(virDomainGraphicsDefPtr def,
+virDomainDiskDef *
+virDomainDiskRemove(virDomainDef *def, size_t i);
+virDomainDiskDef *
+virDomainDiskRemoveByName(virDomainDef *def, const char *name);
+
+int virDomainNetFindIdx(virDomainDef *def, virDomainNetDef *net);
+virDomainNetDef *virDomainNetFind(virDomainDef *def, const char *device);
+virDomainNetDef *virDomainNetFindByName(virDomainDef *def, const char *ifname);
+bool virDomainHasNet(virDomainDef *def, virDomainNetDef *net);
+int virDomainNetInsert(virDomainDef *def, virDomainNetDef *net);
+int virDomainNetUpdate(virDomainDef *def, size_t netidx, virDomainNetDef *newnet);
+int virDomainNetDHCPInterfaces(virDomainDef *def, virDomainInterfacePtr **ifaces);
+int virDomainNetARPInterfaces(virDomainDef *def, virDomainInterfacePtr **ifaces);
+virDomainNetDef *virDomainNetRemove(virDomainDef *def, size_t i);
+void virDomainNetRemoveHostdev(virDomainDef *def, virDomainNetDef *net);
+
+int virDomainHostdevInsert(virDomainDef *def, virDomainHostdevDef *hostdev);
+virDomainHostdevDef *
+virDomainHostdevRemove(virDomainDef *def, size_t i);
+int virDomainHostdevFind(virDomainDef *def, virDomainHostdevDef *match,
+ virDomainHostdevDef **found);
+
+virDomainGraphicsListenDef *
+virDomainGraphicsGetListen(virDomainGraphicsDef *def, size_t i);
+int virDomainGraphicsListenAppendAddress(virDomainGraphicsDef *def,
const char *address)
ATTRIBUTE_NONNULL(1);
-int virDomainGraphicsListenAppendSocket(virDomainGraphicsDefPtr def,
+int virDomainGraphicsListenAppendSocket(virDomainGraphicsDef *def,
const char *socket)
ATTRIBUTE_NONNULL(1);
int virDomainNetGetActualBridgeMACTableManager(const virDomainNetDef *iface);
const char *virDomainNetGetActualDirectDev(const virDomainNetDef *iface);
int virDomainNetGetActualDirectMode(const virDomainNetDef *iface);
-virDomainHostdevDefPtr virDomainNetGetActualHostdev(virDomainNetDefPtr iface);
+virDomainHostdevDef *virDomainNetGetActualHostdev(virDomainNetDef *iface);
const virNetDevVPortProfile *
virDomainNetGetActualVirtPortProfile(const virDomainNetDef *iface);
const virNetDevBandwidth *
virTristateBool
virDomainNetGetActualPortOptionsIsolated(const virDomainNetDef *iface);
const char *virDomainNetGetModelString(const virDomainNetDef *net);
-int virDomainNetSetModelString(virDomainNetDefPtr et,
+int virDomainNetSetModelString(virDomainNetDef *et,
const char *model);
bool virDomainNetIsVirtioModel(const virDomainNetDef *net);
-int virDomainNetAppendIPAddress(virDomainNetDefPtr def,
+int virDomainNetAppendIPAddress(virDomainNetDef *def,
const char *address,
int family,
unsigned int prefix);
-void virDomainControllerInsert(virDomainDefPtr def, virDomainControllerDefPtr controller);
-void virDomainControllerInsertPreAlloced(virDomainDefPtr def,
- virDomainControllerDefPtr controller);
+void virDomainControllerInsert(virDomainDef *def, virDomainControllerDef *controller);
+void virDomainControllerInsertPreAlloced(virDomainDef *def,
+ virDomainControllerDef *controller);
int virDomainControllerFind(const virDomainDef *def, int type, int idx);
-int virDomainControllerFindByType(virDomainDefPtr def, int type);
-int virDomainControllerFindByCCWAddress(virDomainDefPtr def,
- virDomainDeviceCCWAddressPtr addr);
-int virDomainControllerFindByPCIAddress(virDomainDefPtr def,
- virPCIDeviceAddressPtr addr);
+int virDomainControllerFindByType(virDomainDef *def, int type);
+int virDomainControllerFindByCCWAddress(virDomainDef *def,
+ virDomainDeviceCCWAddress *addr);
+int virDomainControllerFindByPCIAddress(virDomainDef *def,
+ virPCIDeviceAddress *addr);
int virDomainControllerFindUnusedIndex(virDomainDef const *def, int type);
-virDomainControllerDefPtr virDomainControllerRemove(virDomainDefPtr def, size_t i);
+virDomainControllerDef *virDomainControllerRemove(virDomainDef *def, size_t i);
const char *virDomainControllerAliasFind(const virDomainDef *def,
int type, int idx)
ATTRIBUTE_NONNULL(1);
-int virDomainLeaseIndex(virDomainDefPtr def,
- virDomainLeaseDefPtr lease);
-void virDomainLeaseInsert(virDomainDefPtr def, virDomainLeaseDefPtr lease);
-void virDomainLeaseInsertPreAlloc(virDomainDefPtr def);
-void virDomainLeaseInsertPreAlloced(virDomainDefPtr def,
- virDomainLeaseDefPtr lease);
-virDomainLeaseDefPtr
-virDomainLeaseRemoveAt(virDomainDefPtr def, size_t i);
-virDomainLeaseDefPtr
-virDomainLeaseRemove(virDomainDefPtr def,
- virDomainLeaseDefPtr lease);
+int virDomainLeaseIndex(virDomainDef *def,
+ virDomainLeaseDef *lease);
+void virDomainLeaseInsert(virDomainDef *def, virDomainLeaseDef *lease);
+void virDomainLeaseInsertPreAlloc(virDomainDef *def);
+void virDomainLeaseInsertPreAlloced(virDomainDef *def,
+ virDomainLeaseDef *lease);
+virDomainLeaseDef *
+virDomainLeaseRemoveAt(virDomainDef *def, size_t i);
+virDomainLeaseDef *
+virDomainLeaseRemove(virDomainDef *def,
+ virDomainLeaseDef *lease);
void
virDomainChrGetDomainPtrs(const virDomainDef *vmdef,
const virDomainChrDef ***arrPtr,
size_t *cntPtr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-virDomainChrDefPtr
-virDomainChrFind(virDomainDefPtr def,
- virDomainChrDefPtr target);
+virDomainChrDef *
+virDomainChrFind(virDomainDef *def,
+ virDomainChrDef *target);
bool
-virDomainChrEquals(virDomainChrDefPtr src,
- virDomainChrDefPtr tgt);
+virDomainChrEquals(virDomainChrDef *src,
+ virDomainChrDef *tgt);
int
-virDomainChrPreAlloc(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr);
+virDomainChrPreAlloc(virDomainDef *vmdef,
+ virDomainChrDef *chr);
void
-virDomainChrInsertPreAlloced(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr);
-virDomainChrDefPtr
-virDomainChrRemove(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr);
+virDomainChrInsertPreAlloced(virDomainDef *vmdef,
+ virDomainChrDef *chr);
+virDomainChrDef *
+virDomainChrRemove(virDomainDef *vmdef,
+ virDomainChrDef *chr);
-ssize_t virDomainRNGFind(virDomainDefPtr def, virDomainRNGDefPtr rng);
-virDomainRNGDefPtr virDomainRNGRemove(virDomainDefPtr def, size_t idx);
+ssize_t virDomainRNGFind(virDomainDef *def, virDomainRNGDef *rng);
+virDomainRNGDef *virDomainRNGRemove(virDomainDef *def, size_t idx);
-ssize_t virDomainRedirdevDefFind(virDomainDefPtr def,
- virDomainRedirdevDefPtr redirdev);
-virDomainRedirdevDefPtr virDomainRedirdevDefRemove(virDomainDefPtr def, size_t idx);
+ssize_t virDomainRedirdevDefFind(virDomainDef *def,
+ virDomainRedirdevDef *redirdev);
+virDomainRedirdevDef *virDomainRedirdevDefRemove(virDomainDef *def, size_t idx);
-int virDomainDefSave(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+int virDomainDefSave(virDomainDef *def,
+ virDomainXMLOption *xmlopt,
const char *configDir)
G_GNUC_WARN_UNUSED_RESULT
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3);
-int virDomainObjSave(virDomainObjPtr obj,
- virDomainXMLOptionPtr xmlopt,
+int virDomainObjSave(virDomainObj *obj,
+ virDomainXMLOption *xmlopt,
const char *statusDir)
G_GNUC_WARN_UNUSED_RESULT
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3);
-typedef void (*virDomainLoadConfigNotify)(virDomainObjPtr dom,
+typedef void (*virDomainLoadConfigNotify)(virDomainObj *dom,
int newDomain,
void *opaque);
int virDomainDeleteConfig(const char *configDir,
const char *autostartDir,
- virDomainObjPtr dom);
+ virDomainObj *dom);
char *virDomainConfigFile(const char *dir,
const char *name);
-int virDiskNameToBusDeviceIndex(virDomainDiskDefPtr disk,
+int virDiskNameToBusDeviceIndex(virDomainDiskDef *disk,
int *busIdx,
int *devIdx);
-virDomainFSDefPtr virDomainGetFilesystemForTarget(virDomainDefPtr def,
+virDomainFSDef *virDomainGetFilesystemForTarget(virDomainDef *def,
const char *target);
-int virDomainFSInsert(virDomainDefPtr def, virDomainFSDefPtr fs);
-int virDomainFSIndexByName(virDomainDefPtr def, const char *name);
-virDomainFSDefPtr virDomainFSRemove(virDomainDefPtr def, size_t i);
+int virDomainFSInsert(virDomainDef *def, virDomainFSDef *fs);
+int virDomainFSIndexByName(virDomainDef *def, const char *name);
+virDomainFSDef *virDomainFSRemove(virDomainDef *def, size_t i);
unsigned int virDomainVideoDefaultRAM(const virDomainDef *def,
const virDomainVideoType type);
-typedef int (*virDomainSmartcardDefIterator)(virDomainDefPtr def,
- virDomainSmartcardDefPtr dev,
+typedef int (*virDomainSmartcardDefIterator)(virDomainDef *def,
+ virDomainSmartcardDef *dev,
void *opaque);
-int virDomainSmartcardDefForeach(virDomainDefPtr def,
+int virDomainSmartcardDefForeach(virDomainDef *def,
bool abortOnError,
virDomainSmartcardDefIterator iter,
void *opaque);
-typedef int (*virDomainChrDefIterator)(virDomainDefPtr def,
- virDomainChrDefPtr dev,
+typedef int (*virDomainChrDefIterator)(virDomainDef *def,
+ virDomainChrDef *dev,
void *opaque);
-int virDomainChrDefForeach(virDomainDefPtr def,
+int virDomainChrDefForeach(virDomainDef *def,
bool abortOnError,
virDomainChrDefIterator iter,
void *opaque);
-typedef int (*virDomainUSBDeviceDefIterator)(virDomainDeviceInfoPtr info,
+typedef int (*virDomainUSBDeviceDefIterator)(virDomainDeviceInfo *info,
void *opaque);
-int virDomainUSBDeviceDefForeach(virDomainDefPtr def,
+int virDomainUSBDeviceDefForeach(virDomainDef *def,
virDomainUSBDeviceDefIterator iter,
void *opaque,
bool skipHubs);
void
-virDomainObjSetState(virDomainObjPtr obj, virDomainState state, int reason)
+virDomainObjSetState(virDomainObj *obj, virDomainState state, int reason)
ATTRIBUTE_NONNULL(1);
virDomainState
-virDomainObjGetState(virDomainObjPtr obj, int *reason)
+virDomainObjGetState(virDomainObj *obj, int *reason)
ATTRIBUTE_NONNULL(1);
-virSecurityLabelDefPtr
-virDomainDefGetSecurityLabelDef(virDomainDefPtr def, const char *model);
+virSecurityLabelDef *
+virDomainDefGetSecurityLabelDef(virDomainDef *def, const char *model);
-virSecurityDeviceLabelDefPtr
-virDomainChrSourceDefGetSecurityLabelDef(virDomainChrSourceDefPtr def,
+virSecurityDeviceLabelDef *
+virDomainChrSourceDefGetSecurityLabelDef(virDomainChrSourceDef *def,
const char *model);
typedef const char* (*virEventActionToStringFunc)(int type);
typedef int (*virEventActionFromStringFunc)(const char *type);
-int virDomainMemoryInsert(virDomainDefPtr def, virDomainMemoryDefPtr mem)
+int virDomainMemoryInsert(virDomainDef *def, virDomainMemoryDef *mem)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-virDomainMemoryDefPtr virDomainMemoryRemove(virDomainDefPtr def, int idx)
+virDomainMemoryDef *virDomainMemoryRemove(virDomainDef *def, int idx)
ATTRIBUTE_NONNULL(1);
-int virDomainMemoryFindByDef(virDomainDefPtr def, virDomainMemoryDefPtr mem)
+int virDomainMemoryFindByDef(virDomainDef *def, virDomainMemoryDef *mem)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virDomainMemoryFindInactiveByDef(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+int virDomainMemoryFindInactiveByDef(virDomainDef *def,
+ virDomainMemoryDef *mem)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virDomainShmemDefInsert(virDomainDefPtr def, virDomainShmemDefPtr shmem)
+int virDomainShmemDefInsert(virDomainDef *def, virDomainShmemDef *shmem)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-bool virDomainShmemDefEquals(virDomainShmemDefPtr src, virDomainShmemDefPtr dst)
+bool virDomainShmemDefEquals(virDomainShmemDef *src, virDomainShmemDef *dst)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-ssize_t virDomainShmemDefFind(virDomainDefPtr def, virDomainShmemDefPtr shmem)
+ssize_t virDomainShmemDefFind(virDomainDef *def, virDomainShmemDef *shmem)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-virDomainShmemDefPtr virDomainShmemDefRemove(virDomainDefPtr def, size_t idx)
+virDomainShmemDef *virDomainShmemDefRemove(virDomainDef *def, size_t idx)
ATTRIBUTE_NONNULL(1);
ssize_t virDomainInputDefFind(const virDomainDef *def,
const virDomainInputDef *input)
VIR_ENUM_DECL(virDomainStartupPolicy);
-virDomainControllerDefPtr
-virDomainDefAddController(virDomainDefPtr def, int type, int idx, int model);
+virDomainControllerDef *
+virDomainDefAddController(virDomainDef *def, int type, int idx, int model);
int
-virDomainDefAddUSBController(virDomainDefPtr def, int idx, int model);
+virDomainDefAddUSBController(virDomainDef *def, int idx, int model);
int
-virDomainDefMaybeAddController(virDomainDefPtr def,
+virDomainDefMaybeAddController(virDomainDef *def,
int type,
int idx,
int model);
int
-virDomainDefMaybeAddInput(virDomainDefPtr def,
+virDomainDefMaybeAddInput(virDomainDef *def,
int type,
int bus);
-char *virDomainDefGetDefaultEmulator(virDomainDefPtr def, virCapsPtr caps);
+char *virDomainDefGetDefaultEmulator(virDomainDef *def, virCaps *caps);
-int virDomainDefFindDevice(virDomainDefPtr def,
+int virDomainDefFindDevice(virDomainDef *def,
const char *devAlias,
- virDomainDeviceDefPtr dev,
+ virDomainDeviceDef *dev,
bool reportError);
-virDomainAudioDefPtr
+virDomainAudioDef *
virDomainDefFindAudioByID(const virDomainDef *def,
int id);
bool
-virDomainSoundModelSupportsCodecs(virDomainSoundDefPtr def);
+virDomainSoundModelSupportsCodecs(virDomainSoundDef *def);
bool
-virDomainAudioIOCommonIsSet(virDomainAudioIOCommonPtr common);
+virDomainAudioIOCommonIsSet(virDomainAudioIOCommon *common);
-const char *virDomainChrSourceDefGetPath(virDomainChrSourceDefPtr chr);
+const char *virDomainChrSourceDefGetPath(virDomainChrSourceDef *chr);
-void virDomainChrSourceDefClear(virDomainChrSourceDefPtr def);
+void virDomainChrSourceDefClear(virDomainChrSourceDef *def);
-char *virDomainObjGetMetadata(virDomainObjPtr vm,
+char *virDomainObjGetMetadata(virDomainObj *vm,
int type,
const char *uri,
unsigned int flags);
-int virDomainObjSetMetadata(virDomainObjPtr vm,
+int virDomainObjSetMetadata(virDomainObj *vm,
int type,
const char *metadata,
const char *key,
const char *uri,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
const char *stateDir,
const char *configDir,
unsigned int flags);
bool required,
bool capped);
-bool virDomainDefNeedsPlacementAdvice(virDomainDefPtr def)
+bool virDomainDefNeedsPlacementAdvice(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
int virDomainDiskDefCheckDuplicateInfo(const virDomainDiskDef *a,
const virDomainDiskDef *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-virStorageSourcePtr
+virStorageSource *
virDomainStorageSourceParseBase(const char *type,
const char *format,
const char *index)
int virDomainStorageSourceParse(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageSourcePtr src,
+ virStorageSource *src,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
virDomainDiskBackingStoreParse(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src,
+ virStorageSource *src,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virDomainDefGetVcpuPinInfoHelper(virDomainDefPtr def,
+int virDomainDefGetVcpuPinInfoHelper(virDomainDef *def,
int maplen,
int ncpumaps,
unsigned char *cpumaps,
- virBitmapPtr hostcpus,
- virBitmapPtr autoCpuset)
+ virBitmap *hostcpus,
+ virBitmap *autoCpuset)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5) G_GNUC_WARN_UNUSED_RESULT;
bool virDomainDefHasMemballoon(const virDomainDef *def) ATTRIBUTE_NONNULL(1);
char *virDomainDefGetShortName(const virDomainDef *def) ATTRIBUTE_NONNULL(1);
int
-virDomainGetBlkioParametersAssignFromDef(virDomainDefPtr def,
+virDomainGetBlkioParametersAssignFromDef(virDomainDef *def,
virTypedParameterPtr params,
int *nparams,
int maxparams);
-void virDomainDiskSetBlockIOTune(virDomainDiskDefPtr disk,
+void virDomainDiskSetBlockIOTune(virDomainDiskDef *disk,
virDomainBlockIoTuneInfo *info);
bool
virDomainDefLifecycleActionAllowed(virDomainLifecycle type,
virDomainLifecycleAction action);
-virNetworkPortDefPtr
-virDomainNetDefToNetworkPort(virDomainDefPtr dom,
- virDomainNetDefPtr iface);
+virNetworkPortDef *
+virDomainNetDefToNetworkPort(virDomainDef *dom,
+ virDomainNetDef *iface);
int
-virDomainNetDefActualFromNetworkPort(virDomainNetDefPtr iface,
- virNetworkPortDefPtr port);
+virDomainNetDefActualFromNetworkPort(virDomainNetDef *iface,
+ virNetworkPortDef *port);
-virNetworkPortDefPtr
-virDomainNetDefActualToNetworkPort(virDomainDefPtr dom,
- virDomainNetDefPtr iface);
+virNetworkPortDef *
+virDomainNetDefActualToNetworkPort(virDomainDef *dom,
+ virDomainNetDef *iface);
int
virDomainNetAllocateActualDevice(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+ virDomainDef *dom,
+ virDomainNetDef *iface)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void
virDomainNetNotifyActualDevice(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+ virDomainDef *dom,
+ virDomainNetDef *iface)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
virDomainNetReleaseActualDevice(virConnectPtr conn,
- virDomainDefPtr dom,
- virDomainNetDefPtr iface)
+ virDomainDef *dom,
+ virDomainNetDef *iface)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainNetBandwidthUpdate(virDomainNetDefPtr iface,
- virNetDevBandwidthPtr newBandwidth)
+virDomainNetBandwidthUpdate(virDomainNetDef *iface,
+ virNetDevBandwidth *newBandwidth)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virDomainNetResolveActualType(virDomainNetDefPtr iface)
+virDomainNetResolveActualType(virDomainNetDef *iface)
ATTRIBUTE_NONNULL(1);
-int virDomainDiskTranslateSourcePool(virDomainDiskDefPtr def);
+int virDomainDiskTranslateSourcePool(virDomainDiskDef *def);
int
virDomainDiskGetDetectZeroesMode(virDomainDiskDiscard discard,
void
virDomainBlockIoTuneInfoCopy(const virDomainBlockIoTuneInfo *src,
- virDomainBlockIoTuneInfoPtr dst);
+ virDomainBlockIoTuneInfo *dst);
bool
virDomainBlockIoTuneInfoEqual(const virDomainBlockIoTuneInfo *a,
VIR_LOG_INIT("util.domain_event");
-static virClassPtr virDomainEventClass;
-static virClassPtr virDomainEventLifecycleClass;
-static virClassPtr virDomainEventRTCChangeClass;
-static virClassPtr virDomainEventWatchdogClass;
-static virClassPtr virDomainEventIOErrorClass;
-static virClassPtr virDomainEventGraphicsClass;
-static virClassPtr virDomainEventBlockJobClass;
-static virClassPtr virDomainEventDiskChangeClass;
-static virClassPtr virDomainEventTrayChangeClass;
-static virClassPtr virDomainEventBalloonChangeClass;
-static virClassPtr virDomainEventDeviceRemovedClass;
-static virClassPtr virDomainEventPMClass;
-static virClassPtr virDomainQemuMonitorEventClass;
-static virClassPtr virDomainEventTunableClass;
-static virClassPtr virDomainEventAgentLifecycleClass;
-static virClassPtr virDomainEventDeviceAddedClass;
-static virClassPtr virDomainEventMigrationIterationClass;
-static virClassPtr virDomainEventJobCompletedClass;
-static virClassPtr virDomainEventDeviceRemovalFailedClass;
-static virClassPtr virDomainEventMetadataChangeClass;
-static virClassPtr virDomainEventBlockThresholdClass;
-static virClassPtr virDomainEventMemoryFailureClass;
+static virClass *virDomainEventClass;
+static virClass *virDomainEventLifecycleClass;
+static virClass *virDomainEventRTCChangeClass;
+static virClass *virDomainEventWatchdogClass;
+static virClass *virDomainEventIOErrorClass;
+static virClass *virDomainEventGraphicsClass;
+static virClass *virDomainEventBlockJobClass;
+static virClass *virDomainEventDiskChangeClass;
+static virClass *virDomainEventTrayChangeClass;
+static virClass *virDomainEventBalloonChangeClass;
+static virClass *virDomainEventDeviceRemovedClass;
+static virClass *virDomainEventPMClass;
+static virClass *virDomainQemuMonitorEventClass;
+static virClass *virDomainEventTunableClass;
+static virClass *virDomainEventAgentLifecycleClass;
+static virClass *virDomainEventDeviceAddedClass;
+static virClass *virDomainEventMigrationIterationClass;
+static virClass *virDomainEventJobCompletedClass;
+static virClass *virDomainEventDeviceRemovalFailedClass;
+static virClass *virDomainEventMetadataChangeClass;
+static virClass *virDomainEventBlockThresholdClass;
+static virClass *virDomainEventMemoryFailureClass;
static void virDomainEventDispose(void *obj);
static void virDomainEventLifecycleDispose(void *obj);
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque);
static void
virDomainQemuMonitorEventDispatchFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque);
bool dummy;
};
typedef struct _virDomainEvent virDomainEvent;
-typedef virDomainEvent *virDomainEventPtr;
struct _virDomainEventLifecycle {
virDomainEvent parent;
int detail;
};
typedef struct _virDomainEventLifecycle virDomainEventLifecycle;
-typedef virDomainEventLifecycle *virDomainEventLifecyclePtr;
struct _virDomainEventRTCChange {
virDomainEvent parent;
long long offset;
};
typedef struct _virDomainEventRTCChange virDomainEventRTCChange;
-typedef virDomainEventRTCChange *virDomainEventRTCChangePtr;
struct _virDomainEventWatchdog {
virDomainEvent parent;
int action;
};
typedef struct _virDomainEventWatchdog virDomainEventWatchdog;
-typedef virDomainEventWatchdog *virDomainEventWatchdogPtr;
struct _virDomainEventIOError {
virDomainEvent parent;
char *reason;
};
typedef struct _virDomainEventIOError virDomainEventIOError;
-typedef virDomainEventIOError *virDomainEventIOErrorPtr;
struct _virDomainEventBlockJob {
virDomainEvent parent;
int status;
};
typedef struct _virDomainEventBlockJob virDomainEventBlockJob;
-typedef virDomainEventBlockJob *virDomainEventBlockJobPtr;
struct _virDomainEventGraphics {
virDomainEvent parent;
virDomainEventGraphicsSubjectPtr subject;
};
typedef struct _virDomainEventGraphics virDomainEventGraphics;
-typedef virDomainEventGraphics *virDomainEventGraphicsPtr;
struct _virDomainEventDiskChange {
virDomainEvent parent;
int reason;
};
typedef struct _virDomainEventDiskChange virDomainEventDiskChange;
-typedef virDomainEventDiskChange *virDomainEventDiskChangePtr;
struct _virDomainEventTrayChange {
virDomainEvent parent;
int reason;
};
typedef struct _virDomainEventTrayChange virDomainEventTrayChange;
-typedef virDomainEventTrayChange *virDomainEventTrayChangePtr;
struct _virDomainEventBalloonChange {
virDomainEvent parent;
unsigned long long actual;
};
typedef struct _virDomainEventBalloonChange virDomainEventBalloonChange;
-typedef virDomainEventBalloonChange *virDomainEventBalloonChangePtr;
struct _virDomainEventDeviceRemoved {
virDomainEvent parent;
char *devAlias;
};
typedef struct _virDomainEventDeviceRemoved virDomainEventDeviceRemoved;
-typedef virDomainEventDeviceRemoved *virDomainEventDeviceRemovedPtr;
struct _virDomainEventDeviceAdded {
virDomainEvent parent;
char *devAlias;
};
typedef struct _virDomainEventDeviceAdded virDomainEventDeviceAdded;
-typedef virDomainEventDeviceAdded *virDomainEventDeviceAddedPtr;
struct _virDomainEventPM {
virDomainEvent parent;
int reason;
};
typedef struct _virDomainEventPM virDomainEventPM;
-typedef virDomainEventPM *virDomainEventPMPtr;
struct _virDomainQemuMonitorEvent {
virObjectEvent parent;
char *details;
};
typedef struct _virDomainQemuMonitorEvent virDomainQemuMonitorEvent;
-typedef virDomainQemuMonitorEvent *virDomainQemuMonitorEventPtr;
struct _virDomainEventTunable {
virDomainEvent parent;
int nparams;
};
typedef struct _virDomainEventTunable virDomainEventTunable;
-typedef virDomainEventTunable *virDomainEventTunablePtr;
struct _virDomainEventAgentLifecycle {
virDomainEvent parent;
int reason;
};
typedef struct _virDomainEventAgentLifecycle virDomainEventAgentLifecycle;
-typedef virDomainEventAgentLifecycle *virDomainEventAgentLifecyclePtr;
struct _virDomainEventMigrationIteration {
virDomainEvent parent;
int iteration;
};
typedef struct _virDomainEventMigrationIteration virDomainEventMigrationIteration;
-typedef virDomainEventMigrationIteration *virDomainEventMigrationIterationPtr;
struct _virDomainEventJobCompleted {
virDomainEvent parent;
int nparams;
};
typedef struct _virDomainEventJobCompleted virDomainEventJobCompleted;
-typedef virDomainEventJobCompleted *virDomainEventJobCompletedPtr;
struct _virDomainEventDeviceRemovalFailed {
virDomainEvent parent;
char *devAlias;
};
typedef struct _virDomainEventDeviceRemovalFailed virDomainEventDeviceRemovalFailed;
-typedef virDomainEventDeviceRemovalFailed *virDomainEventDeviceRemovalFailedPtr;
struct _virDomainEventMetadataChange {
virDomainEvent parent;
char *nsuri;
};
typedef struct _virDomainEventMetadataChange virDomainEventMetadataChange;
-typedef virDomainEventMetadataChange *virDomainEventMetadataChangePtr;
struct _virDomainEventBlockThreshold {
virDomainEvent parent;
unsigned long long excess;
};
typedef struct _virDomainEventBlockThreshold virDomainEventBlockThreshold;
-typedef virDomainEventBlockThreshold *virDomainEventBlockThresholdPtr;
struct _virDomainEventMemoryFailure {
virDomainEvent parent;
unsigned int flags;
};
typedef struct _virDomainEventMemoryFailure virDomainEventMemoryFailure;
-typedef virDomainEventMemoryFailure *virDomainEventMemoryFailurePtr;
static int
virDomainEventsOnceInit(void)
static void
virDomainEventDispose(void *obj)
{
- virDomainEventPtr event = obj;
+ virDomainEvent *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainEventLifecycleDispose(void *obj)
{
- virDomainEventLifecyclePtr event = obj;
+ virDomainEventLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainEventRTCChangeDispose(void *obj)
{
- virDomainEventRTCChangePtr event = obj;
+ virDomainEventRTCChange *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainEventWatchdogDispose(void *obj)
{
- virDomainEventWatchdogPtr event = obj;
+ virDomainEventWatchdog *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainEventIOErrorDispose(void *obj)
{
- virDomainEventIOErrorPtr event = obj;
+ virDomainEventIOError *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->srcPath);
static void
virDomainEventGraphicsDispose(void *obj)
{
- virDomainEventGraphicsPtr event = obj;
+ virDomainEventGraphics *event = obj;
VIR_DEBUG("obj=%p", event);
if (event->local) {
static void
virDomainEventBlockJobDispose(void *obj)
{
- virDomainEventBlockJobPtr event = obj;
+ virDomainEventBlockJob *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->disk);
static void
virDomainEventDiskChangeDispose(void *obj)
{
- virDomainEventDiskChangePtr event = obj;
+ virDomainEventDiskChange *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->oldSrcPath);
static void
virDomainEventTrayChangeDispose(void *obj)
{
- virDomainEventTrayChangePtr event = obj;
+ virDomainEventTrayChange *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->devAlias);
static void
virDomainEventBalloonChangeDispose(void *obj)
{
- virDomainEventBalloonChangePtr event = obj;
+ virDomainEventBalloonChange *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainEventDeviceRemovedDispose(void *obj)
{
- virDomainEventDeviceRemovedPtr event = obj;
+ virDomainEventDeviceRemoved *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->devAlias);
static void
virDomainEventDeviceAddedDispose(void *obj)
{
- virDomainEventDeviceAddedPtr event = obj;
+ virDomainEventDeviceAdded *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->devAlias);
static void
virDomainEventDeviceRemovalFailedDispose(void *obj)
{
- virDomainEventDeviceRemovalFailedPtr event = obj;
+ virDomainEventDeviceRemovalFailed *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->devAlias);
static void
virDomainEventPMDispose(void *obj)
{
- virDomainEventPMPtr event = obj;
+ virDomainEventPM *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virDomainQemuMonitorEventDispose(void *obj)
{
- virDomainQemuMonitorEventPtr event = obj;
+ virDomainQemuMonitorEvent *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->event);
static void
virDomainEventTunableDispose(void *obj)
{
- virDomainEventTunablePtr event = obj;
+ virDomainEventTunable *event = obj;
VIR_DEBUG("obj=%p", event);
virTypedParamsFree(event->params, event->nparams);
static void
virDomainEventAgentLifecycleDispose(void *obj)
{
- virDomainEventAgentLifecyclePtr event = obj;
+ virDomainEventAgentLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
};
static void
virDomainEventMigrationIterationDispose(void *obj)
{
- virDomainEventMigrationIterationPtr event = obj;
+ virDomainEventMigrationIteration *event = obj;
VIR_DEBUG("obj=%p", event);
};
static void
virDomainEventJobCompletedDispose(void *obj)
{
- virDomainEventJobCompletedPtr event = obj;
+ virDomainEventJobCompleted *event = obj;
VIR_DEBUG("obj=%p", event);
virTypedParamsFree(event->params, event->nparams);
static void
virDomainEventMetadataChangeDispose(void *obj)
{
- virDomainEventMetadataChangePtr event = obj;
+ virDomainEventMetadataChange *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->nsuri);
static void
virDomainEventBlockThresholdDispose(void *obj)
{
- virDomainEventBlockThresholdPtr event = obj;
+ virDomainEventBlockThreshold *event = obj;
VIR_DEBUG("obj=%p", event);
g_free(event->dev);
static void
virDomainEventMemoryFailureDispose(void *obj)
{
- virDomainEventMemoryFailurePtr event = obj;
+ virDomainEventMemoryFailure *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void *
-virDomainEventNew(virClassPtr klass,
+virDomainEventNew(virClass *klass,
int eventID,
int id,
const char *name,
const unsigned char *uuid)
{
- virDomainEventPtr event;
+ virDomainEvent *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virDomainEventsInitialize() < 0)
id, name, uuid, uuidstr)))
return NULL;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventLifecycleNew(int id,
const char *name,
const unsigned char *uuid,
int type,
int detail)
{
- virDomainEventLifecyclePtr event;
+ virDomainEventLifecycle *event;
if (virDomainEventsInitialize() < 0)
return NULL;
event->type = type;
event->detail = detail;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventLifecycleNewFromDom(virDomainPtr dom,
int type,
int detail)
type, detail);
}
-virObjectEventPtr
-virDomainEventLifecycleNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventLifecycleNewFromObj(virDomainObj *obj,
int type,
int detail)
{
return virDomainEventLifecycleNewFromDef(obj->def, type, detail);
}
-virObjectEventPtr
-virDomainEventLifecycleNewFromDef(virDomainDefPtr def,
+virObjectEvent *
+virDomainEventLifecycleNewFromDef(virDomainDef *def,
int type,
int detail)
{
type, detail);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventRebootNew(int id,
const char *name,
const unsigned char *uuid)
id, name, uuid);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventRebootNewFromDom(virDomainPtr dom)
{
if (virDomainEventsInitialize() < 0)
dom->id, dom->name, dom->uuid);
}
-virObjectEventPtr
-virDomainEventRebootNewFromObj(virDomainObjPtr obj)
+virObjectEvent *
+virDomainEventRebootNewFromObj(virDomainObj *obj)
{
if (virDomainEventsInitialize() < 0)
return NULL;
obj->def->id, obj->def->name, obj->def->uuid);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
long long offset)
{
- virDomainEventRTCChangePtr ev;
+ virDomainEventRTCChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->offset = offset;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventRTCChangeNewFromObj(virDomainObj *obj,
long long offset)
{
- virDomainEventRTCChangePtr ev;
+ virDomainEventRTCChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->offset = offset;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventWatchdogNewFromDom(virDomainPtr dom,
int action)
{
- virDomainEventWatchdogPtr ev;
+ virDomainEventWatchdog *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->action = action;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventWatchdogNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventWatchdogNewFromObj(virDomainObj *obj,
int action)
{
- virDomainEventWatchdogPtr ev;
+ virDomainEventWatchdog *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->action = action;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventIOErrorNewFromDomImpl(int event,
virDomainPtr dom,
const char *srcPath,
int action,
const char *reason)
{
- virDomainEventIOErrorPtr ev;
+ virDomainEventIOError *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->devAlias = g_strdup(devAlias);
ev->reason = g_strdup(reason);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventIOErrorNewFromObjImpl(int event,
- virDomainObjPtr obj,
+ virDomainObj *obj,
const char *srcPath,
const char *devAlias,
int action,
const char *reason)
{
- virDomainEventIOErrorPtr ev;
+ virDomainEventIOError *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->devAlias = g_strdup(devAlias);
ev->reason = g_strdup(reason);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventIOErrorNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
action, NULL);
}
-virObjectEventPtr
-virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventIOErrorNewFromObj(virDomainObj *obj,
const char *srcPath,
const char *devAlias,
int action)
action, NULL);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
action, reason);
}
-virObjectEventPtr
-virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventIOErrorReasonNewFromObj(virDomainObj *obj,
const char *srcPath,
const char *devAlias,
int action,
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventGraphicsNewFromDom(virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject)
{
- virDomainEventGraphicsPtr ev;
+ virDomainEventGraphics *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->remote = remote;
ev->subject = subject;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventGraphicsNewFromObj(virDomainObj *obj,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject)
{
- virDomainEventGraphicsPtr ev;
+ virDomainEventGraphics *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->remote = remote;
ev->subject = subject;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventBlockJobNew(int event,
int id,
const char *name,
int type,
int status)
{
- virDomainEventBlockJobPtr ev;
+ virDomainEventBlockJob *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->type = type;
ev->status = status;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockJobNewFromObj(virDomainObj *obj,
const char *path,
int type,
int status)
obj->def->uuid, path, type, status);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockJobNewFromDom(virDomainPtr dom,
const char *path,
int type,
path, type, status);
}
-virObjectEventPtr
-virDomainEventBlockJob2NewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockJob2NewFromObj(virDomainObj *obj,
const char *dst,
int type,
int status)
obj->def->uuid, dst, type, status);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockJob2NewFromDom(virDomainPtr dom,
const char *dst,
int type,
dst, type, status);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventControlErrorNewFromDom(virDomainPtr dom)
{
- virObjectEventPtr ev;
+ virObjectEvent *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
}
-virObjectEventPtr
-virDomainEventControlErrorNewFromObj(virDomainObjPtr obj)
+virObjectEvent *
+virDomainEventControlErrorNewFromObj(virDomainObj *obj)
{
- virObjectEventPtr ev;
+ virObjectEvent *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
return ev;
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventDiskChangeNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias,
int reason)
{
- virDomainEventDiskChangePtr ev;
+ virDomainEventDiskChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDiskChangeNewFromObj(virDomainObj *obj,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
newSrcPath, devAlias, reason);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
const char *oldSrcPath,
const char *newSrcPath,
devAlias, reason);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventTrayChangeNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias,
int reason)
{
- virDomainEventTrayChangePtr ev;
+ virDomainEventTrayChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventTrayChangeNewFromObj(virDomainObj *obj,
const char *devAlias,
int reason)
{
reason);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
const char *devAlias,
int reason)
devAlias, reason);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventPMWakeupNew(int id,
const char *name,
unsigned char *uuid,
int reason)
{
- virDomainEventPMPtr ev;
+ virDomainEventPM *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
return NULL;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj)
+virObjectEvent *
+virDomainEventPMWakeupNewFromObj(virDomainObj *obj)
{
return virDomainEventPMWakeupNew(obj->def->id,
obj->def->name,
0);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventPMWakeupNewFromDom(virDomainPtr dom, int reason)
{
return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid, reason);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventPMSuspendNew(int id,
const char *name,
unsigned char *uuid,
int reason)
{
- virDomainEventPMPtr ev;
+ virDomainEventPM *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
return NULL;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
+virObjectEvent *
+virDomainEventPMSuspendNewFromObj(virDomainObj *obj)
{
return virDomainEventPMSuspendNew(obj->def->id,
obj->def->name,
0);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventPMSuspendNewFromDom(virDomainPtr dom, int reason)
{
return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid, reason);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventPMSuspendDiskNew(int id,
const char *name,
unsigned char *uuid,
int reason)
{
- virDomainEventPMPtr ev;
+ virDomainEventPM *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
return NULL;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj)
+virObjectEvent *
+virDomainEventPMSuspendDiskNewFromObj(virDomainObj *obj)
{
return virDomainEventPMSuspendDiskNew(obj->def->id,
obj->def->name,
0);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom, int reason)
{
return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid,
reason);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
unsigned long long actual)
{
- virDomainEventBalloonChangePtr ev;
+ virDomainEventBalloonChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->actual = actual;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBalloonChangeNewFromObj(virDomainObj *obj,
unsigned long long actual)
{
- virDomainEventBalloonChangePtr ev;
+ virDomainEventBalloonChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->actual = actual;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventDeviceRemovedNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias)
{
- virDomainEventDeviceRemovedPtr ev;
+ virDomainEventDeviceRemoved *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->devAlias = g_strdup(devAlias);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDeviceRemovedNewFromObj(virDomainObj *obj,
const char *devAlias)
{
return virDomainEventDeviceRemovedNew(obj->def->id, obj->def->name,
obj->def->uuid, devAlias);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
const char *devAlias)
{
devAlias);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventDeviceAddedNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias)
{
- virDomainEventDeviceAddedPtr ev;
+ virDomainEventDeviceAdded *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->devAlias = g_strdup(devAlias);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventDeviceAddedNewFromObj(virDomainObjPtr obj,
- const char *devAlias)
+virObjectEvent *
+virDomainEventDeviceAddedNewFromObj(virDomainObj *obj,
+ const char *devAlias)
{
return virDomainEventDeviceAddedNew(obj->def->id, obj->def->name,
obj->def->uuid, devAlias);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceAddedNewFromDom(virDomainPtr dom,
- const char *devAlias)
+ const char *devAlias)
{
return virDomainEventDeviceAddedNew(dom->id, dom->name, dom->uuid,
devAlias);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventDeviceRemovalFailedNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias)
{
- virDomainEventDeviceRemovalFailedPtr ev;
+ virDomainEventDeviceRemovalFailed *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->devAlias = g_strdup(devAlias);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventDeviceRemovalFailedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDeviceRemovalFailedNewFromObj(virDomainObj *obj,
const char *devAlias)
{
return virDomainEventDeviceRemovalFailedNew(obj->def->id, obj->def->name,
obj->def->uuid, devAlias);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceRemovalFailedNewFromDom(virDomainPtr dom,
const char *devAlias)
{
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventAgentLifecycleNew(int id,
const char *name,
const unsigned char *uuid,
int state,
int reason)
{
- virDomainEventAgentLifecyclePtr ev;
+ virDomainEventAgentLifecycle *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->state = state;
ev->reason = reason;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventAgentLifecycleNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventAgentLifecycleNewFromObj(virDomainObj *obj,
int state,
int reason)
{
obj->def->uuid, state, reason);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom,
int state,
int reason)
state, reason);
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventMigrationIterationNew(int id,
const char *name,
const unsigned char *uuid,
int iteration)
{
- virDomainEventMigrationIterationPtr ev;
+ virDomainEventMigrationIteration *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->iteration = iteration;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventMigrationIterationNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMigrationIterationNewFromObj(virDomainObj *obj,
int iteration)
{
return virDomainEventMigrationIterationNew(obj->def->id, obj->def->name,
obj->def->uuid, iteration);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventMigrationIterationNewFromDom(virDomainPtr dom,
int iteration)
{
/* This function consumes @params, the caller must not free it.
*/
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventJobCompletedNew(int id,
const char *name,
const unsigned char *uuid,
virTypedParameterPtr params,
int nparams)
{
- virDomainEventJobCompletedPtr ev;
+ virDomainEventJobCompleted *ev;
if (virDomainEventsInitialize() < 0)
goto error;
ev->params = params;
ev->nparams = nparams;
- return (virObjectEventPtr) ev;
+ return (virObjectEvent *) ev;
error:
virTypedParamsFree(params, nparams);
return NULL;
}
-virObjectEventPtr
-virDomainEventJobCompletedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventJobCompletedNewFromObj(virDomainObj *obj,
virTypedParameterPtr params,
int nparams)
{
obj->def->uuid, params, nparams);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventJobCompletedNewFromDom(virDomainPtr dom,
virTypedParameterPtr params,
int nparams)
* freeing it even if error occurs. The reason is to not have to do deep
* copy of params.
*/
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventTunableNew(int id,
const char *name,
unsigned char *uuid,
virTypedParameterPtr params,
int nparams)
{
- virDomainEventTunablePtr ev;
+ virDomainEventTunable *ev;
if (virDomainEventsInitialize() < 0)
goto error;
ev->params = params;
ev->nparams = nparams;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
error:
virTypedParamsFree(params, nparams);
return NULL;
}
-virObjectEventPtr
-virDomainEventTunableNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventTunableNewFromObj(virDomainObj *obj,
virTypedParameterPtr params,
int nparams)
{
nparams);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventTunableNewFromDom(virDomainPtr dom,
virTypedParameterPtr params,
int nparams)
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventMetadataChangeNew(int id,
const char *name,
unsigned char *uuid,
int type,
const char *nsuri)
{
- virDomainEventMetadataChangePtr ev;
+ virDomainEventMetadataChange *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
if (nsuri)
ev->nsuri = g_strdup(nsuri);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventMetadataChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMetadataChangeNewFromObj(virDomainObj *obj,
int type,
const char *nsuri)
{
obj->def->uuid, type, nsuri);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventMetadataChangeNewFromDom(virDomainPtr dom,
int type,
const char *nsuri)
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventBlockThresholdNew(int id,
const char *name,
unsigned char *uuid,
unsigned long long threshold,
unsigned long long excess)
{
- virDomainEventBlockThresholdPtr ev;
+ virDomainEventBlockThreshold *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->threshold = threshold;
ev->excess = excess;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventBlockThresholdNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockThresholdNewFromObj(virDomainObj *obj,
const char *dev,
const char *path,
unsigned long long threshold,
threshold, excess);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockThresholdNewFromDom(virDomainPtr dom,
const char *dev,
const char *path,
}
-static virObjectEventPtr
+static virObjectEvent *
virDomainEventMemoryFailureNew(int id,
const char *name,
unsigned char *uuid,
int action,
unsigned int flags)
{
- virDomainEventMemoryFailurePtr ev;
+ virDomainEventMemoryFailure *ev;
if (virDomainEventsInitialize() < 0)
return NULL;
ev->action = action;
ev->flags = flags;
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
-virObjectEventPtr
-virDomainEventMemoryFailureNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMemoryFailureNewFromObj(virDomainObj *obj,
int recipient,
int action,
unsigned int flags)
flags);
}
-virObjectEventPtr
+virObjectEvent *
virDomainEventMemoryFailureNewFromDom(virDomainPtr dom,
int recipient,
int action,
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
switch ((virDomainEventID) event->eventID) {
case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
{
- virDomainEventLifecyclePtr lifecycleEvent;
+ virDomainEventLifecycle *lifecycleEvent;
- lifecycleEvent = (virDomainEventLifecyclePtr)event;
+ lifecycleEvent = (virDomainEventLifecycle *)event;
((virConnectDomainEventCallback)cb)(conn, dom,
lifecycleEvent->type,
lifecycleEvent->detail,
case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
{
- virDomainEventRTCChangePtr rtcChangeEvent;
+ virDomainEventRTCChange *rtcChangeEvent;
- rtcChangeEvent = (virDomainEventRTCChangePtr)event;
+ rtcChangeEvent = (virDomainEventRTCChange *)event;
((virConnectDomainEventRTCChangeCallback)cb)(conn, dom,
rtcChangeEvent->offset,
cbopaque);
case VIR_DOMAIN_EVENT_ID_WATCHDOG:
{
- virDomainEventWatchdogPtr watchdogEvent;
+ virDomainEventWatchdog *watchdogEvent;
- watchdogEvent = (virDomainEventWatchdogPtr)event;
+ watchdogEvent = (virDomainEventWatchdog *)event;
((virConnectDomainEventWatchdogCallback)cb)(conn, dom,
watchdogEvent->action,
cbopaque);
case VIR_DOMAIN_EVENT_ID_IO_ERROR:
{
- virDomainEventIOErrorPtr ioErrorEvent;
+ virDomainEventIOError *ioErrorEvent;
- ioErrorEvent = (virDomainEventIOErrorPtr)event;
+ ioErrorEvent = (virDomainEventIOError *)event;
((virConnectDomainEventIOErrorCallback)cb)(conn, dom,
ioErrorEvent->srcPath,
ioErrorEvent->devAlias,
case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
{
- virDomainEventIOErrorPtr ioErrorEvent;
+ virDomainEventIOError *ioErrorEvent;
- ioErrorEvent = (virDomainEventIOErrorPtr)event;
+ ioErrorEvent = (virDomainEventIOError *)event;
((virConnectDomainEventIOErrorReasonCallback)cb)(conn, dom,
ioErrorEvent->srcPath,
ioErrorEvent->devAlias,
case VIR_DOMAIN_EVENT_ID_GRAPHICS:
{
- virDomainEventGraphicsPtr graphicsEvent;
+ virDomainEventGraphics *graphicsEvent;
- graphicsEvent = (virDomainEventGraphicsPtr)event;
+ graphicsEvent = (virDomainEventGraphics *)event;
((virConnectDomainEventGraphicsCallback)cb)(conn, dom,
graphicsEvent->phase,
graphicsEvent->local,
case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
case VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2:
{
- virDomainEventBlockJobPtr blockJobEvent;
+ virDomainEventBlockJob *blockJobEvent;
- blockJobEvent = (virDomainEventBlockJobPtr)event;
+ blockJobEvent = (virDomainEventBlockJob *)event;
((virConnectDomainEventBlockJobCallback)cb)(conn, dom,
blockJobEvent->disk,
blockJobEvent->type,
case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
{
- virDomainEventDiskChangePtr diskChangeEvent;
+ virDomainEventDiskChange *diskChangeEvent;
- diskChangeEvent = (virDomainEventDiskChangePtr)event;
+ diskChangeEvent = (virDomainEventDiskChange *)event;
((virConnectDomainEventDiskChangeCallback)cb)(conn, dom,
diskChangeEvent->oldSrcPath,
diskChangeEvent->newSrcPath,
case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
{
- virDomainEventTrayChangePtr trayChangeEvent;
+ virDomainEventTrayChange *trayChangeEvent;
- trayChangeEvent = (virDomainEventTrayChangePtr)event;
+ trayChangeEvent = (virDomainEventTrayChange *)event;
((virConnectDomainEventTrayChangeCallback)cb)(conn, dom,
trayChangeEvent->devAlias,
trayChangeEvent->reason,
case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
{
- virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+ virDomainEventPM *pmEvent = (virDomainEventPM *)event;
((virConnectDomainEventPMWakeupCallback)cb)(conn, dom,
pmEvent->reason,
case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
{
- virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+ virDomainEventPM *pmEvent = (virDomainEventPM *)event;
((virConnectDomainEventPMSuspendCallback)cb)(conn, dom,
pmEvent->reason,
case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE:
{
- virDomainEventBalloonChangePtr balloonChangeEvent;
+ virDomainEventBalloonChange *balloonChangeEvent;
- balloonChangeEvent = (virDomainEventBalloonChangePtr)event;
+ balloonChangeEvent = (virDomainEventBalloonChange *)event;
((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom,
balloonChangeEvent->actual,
cbopaque);
case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK:
{
- virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+ virDomainEventPM *pmEvent = (virDomainEventPM *)event;
((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom,
pmEvent->reason,
case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
{
- virDomainEventDeviceRemovedPtr deviceRemovedEvent;
+ virDomainEventDeviceRemoved *deviceRemovedEvent;
- deviceRemovedEvent = (virDomainEventDeviceRemovedPtr)event;
+ deviceRemovedEvent = (virDomainEventDeviceRemoved *)event;
((virConnectDomainEventDeviceRemovedCallback)cb)(conn, dom,
deviceRemovedEvent->devAlias,
cbopaque);
case VIR_DOMAIN_EVENT_ID_TUNABLE:
{
- virDomainEventTunablePtr tunableEvent;
- tunableEvent = (virDomainEventTunablePtr)event;
+ virDomainEventTunable *tunableEvent;
+ tunableEvent = (virDomainEventTunable *)event;
((virConnectDomainEventTunableCallback)cb)(conn, dom,
tunableEvent->params,
tunableEvent->nparams,
case VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE:
{
- virDomainEventAgentLifecyclePtr agentLifecycleEvent;
- agentLifecycleEvent = (virDomainEventAgentLifecyclePtr)event;
+ virDomainEventAgentLifecycle *agentLifecycleEvent;
+ agentLifecycleEvent = (virDomainEventAgentLifecycle *)event;
((virConnectDomainEventAgentLifecycleCallback)cb)(conn, dom,
agentLifecycleEvent->state,
agentLifecycleEvent->reason,
case VIR_DOMAIN_EVENT_ID_DEVICE_ADDED:
{
- virDomainEventDeviceAddedPtr deviceAddedEvent;
+ virDomainEventDeviceAdded *deviceAddedEvent;
- deviceAddedEvent = (virDomainEventDeviceAddedPtr)event;
+ deviceAddedEvent = (virDomainEventDeviceAdded *)event;
((virConnectDomainEventDeviceAddedCallback)cb)(conn, dom,
deviceAddedEvent->devAlias,
cbopaque);
case VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION:
{
- virDomainEventMigrationIterationPtr ev;
+ virDomainEventMigrationIteration *ev;
- ev = (virDomainEventMigrationIterationPtr) event;
+ ev = (virDomainEventMigrationIteration *) event;
((virConnectDomainEventMigrationIterationCallback)cb)(conn, dom,
ev->iteration,
cbopaque);
case VIR_DOMAIN_EVENT_ID_JOB_COMPLETED:
{
- virDomainEventJobCompletedPtr ev;
+ virDomainEventJobCompleted *ev;
- ev = (virDomainEventJobCompletedPtr) event;
+ ev = (virDomainEventJobCompleted *) event;
((virConnectDomainEventJobCompletedCallback) cb)(conn, dom,
ev->params,
ev->nparams,
case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED:
{
- virDomainEventDeviceRemovalFailedPtr deviceRemovalFailedEvent;
+ virDomainEventDeviceRemovalFailed *deviceRemovalFailedEvent;
- deviceRemovalFailedEvent = (virDomainEventDeviceRemovalFailedPtr)event;
+ deviceRemovalFailedEvent = (virDomainEventDeviceRemovalFailed *)event;
((virConnectDomainEventDeviceRemovalFailedCallback)cb)(conn, dom,
deviceRemovalFailedEvent->devAlias,
cbopaque);
case VIR_DOMAIN_EVENT_ID_METADATA_CHANGE:
{
- virDomainEventMetadataChangePtr metadataChangeEvent;
+ virDomainEventMetadataChange *metadataChangeEvent;
- metadataChangeEvent = (virDomainEventMetadataChangePtr)event;
+ metadataChangeEvent = (virDomainEventMetadataChange *)event;
((virConnectDomainEventMetadataChangeCallback)cb)(conn, dom,
metadataChangeEvent->type,
metadataChangeEvent->nsuri,
case VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD:
{
- virDomainEventBlockThresholdPtr blockThresholdEvent;
+ virDomainEventBlockThreshold *blockThresholdEvent;
- blockThresholdEvent = (virDomainEventBlockThresholdPtr)event;
+ blockThresholdEvent = (virDomainEventBlockThreshold *)event;
((virConnectDomainEventBlockThresholdCallback)cb)(conn, dom,
blockThresholdEvent->dev,
blockThresholdEvent->path,
}
case VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE:
{
- virDomainEventMemoryFailurePtr memoryFailureEvent;
+ virDomainEventMemoryFailure *memoryFailureEvent;
- memoryFailureEvent = (virDomainEventMemoryFailurePtr)event;
+ memoryFailureEvent = (virDomainEventMemoryFailure *)event;
((virConnectDomainEventMemoryFailureCallback)cb)(conn, dom,
memoryFailureEvent->recipient,
memoryFailureEvent->action,
}
-virObjectEventPtr
+virObjectEvent *
virDomainQemuMonitorEventNew(int id,
const char *name,
const unsigned char *uuid,
unsigned int micros,
const char *details)
{
- virDomainQemuMonitorEventPtr ev;
+ virDomainQemuMonitorEvent *ev;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virDomainEventsInitialize() < 0)
ev->micros = micros;
ev->details = g_strdup(details);
- return (virObjectEventPtr)ev;
+ return (virObjectEvent *)ev;
}
static void
virDomainQemuMonitorEventDispatchFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
virDomainPtr dom;
- virDomainQemuMonitorEventPtr qemuMonitorEvent;
+ virDomainQemuMonitorEvent *qemuMonitorEvent;
virDomainQemuMonitorEventData *data = cbopaque;
if (!(dom = virGetDomain(conn, event->meta.name,
event->meta.uuid, event->meta.id)))
return;
- qemuMonitorEvent = (virDomainQemuMonitorEventPtr)event;
+ qemuMonitorEvent = (virDomainQemuMonitorEvent *)event;
((virConnectDomainQemuMonitorEventCallback)cb)(conn, dom,
qemuMonitorEvent->event,
qemuMonitorEvent->seconds,
*/
int
virDomainEventStateRegister(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback callback,
void *opaque,
virFreeCallback freecb)
*/
int
virDomainEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
*/
int
virDomainEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
*/
int
virDomainEventStateCallbackID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback cb,
int *remoteID)
{
*/
int
virDomainEventStateDeregister(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback cb)
{
int callbackID;
*/
static bool
virDomainQemuMonitorEventFilter(virConnectPtr conn G_GNUC_UNUSED,
- virObjectEventPtr event,
+ virObjectEvent *event,
void *opaque)
{
virDomainQemuMonitorEventData *data = opaque;
- virDomainQemuMonitorEventPtr monitorEvent;
+ virDomainQemuMonitorEvent *monitorEvent;
- monitorEvent = (virDomainQemuMonitorEventPtr) event;
+ monitorEvent = (virDomainQemuMonitorEvent *) event;
if (data->flags == -1)
return true;
*/
int
virDomainQemuMonitorEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
const char *event,
virConnectDomainQemuMonitorEventCallback cb,
#include "domain_conf.h"
-virObjectEventPtr
+virObjectEvent *
virDomainEventLifecycleNew(int id,
const char *name,
const unsigned char *uuid,
int type,
int detail);
-virObjectEventPtr
+virObjectEvent *
virDomainEventLifecycleNewFromDom(virDomainPtr dom,
int type,
int detail);
-virObjectEventPtr
-virDomainEventLifecycleNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventLifecycleNewFromObj(virDomainObj *obj,
int type,
int detail);
-virObjectEventPtr
-virDomainEventLifecycleNewFromDef(virDomainDefPtr def,
+virObjectEvent *
+virDomainEventLifecycleNewFromDef(virDomainDef *def,
int type,
int detail);
-virObjectEventPtr
+virObjectEvent *
virDomainEventRebootNew(int id,
const char *name,
const unsigned char *uuid);
-virObjectEventPtr
+virObjectEvent *
virDomainEventRebootNewFromDom(virDomainPtr dom);
-virObjectEventPtr
-virDomainEventRebootNewFromObj(virDomainObjPtr obj);
+virObjectEvent *
+virDomainEventRebootNewFromObj(virDomainObj *obj);
-virObjectEventPtr
+virObjectEvent *
virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
long long offset);
-virObjectEventPtr
-virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventRTCChangeNewFromObj(virDomainObj *obj,
long long offset);
-virObjectEventPtr
+virObjectEvent *
virDomainEventWatchdogNewFromDom(virDomainPtr dom,
int action);
-virObjectEventPtr
-virDomainEventWatchdogNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventWatchdogNewFromObj(virDomainObj *obj,
int action);
-virObjectEventPtr
+virObjectEvent *
virDomainEventIOErrorNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action);
-virObjectEventPtr
-virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventIOErrorNewFromObj(virDomainObj *obj,
const char *srcPath,
const char *devAlias,
int action);
-virObjectEventPtr
+virObjectEvent *
virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
const char *reason);
-virObjectEventPtr
-virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventIOErrorReasonNewFromObj(virDomainObj *obj,
const char *srcPath,
const char *devAlias,
int action,
const char *reason);
-virObjectEventPtr
+virObjectEvent *
virDomainEventGraphicsNewFromDom(virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject);
-virObjectEventPtr
-virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventGraphicsNewFromObj(virDomainObj *obj,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject);
-virObjectEventPtr
+virObjectEvent *
virDomainEventControlErrorNewFromDom(virDomainPtr dom);
-virObjectEventPtr
-virDomainEventControlErrorNewFromObj(virDomainObjPtr obj);
+virObjectEvent *
+virDomainEventControlErrorNewFromObj(virDomainObj *obj);
-virObjectEventPtr
-virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockJobNewFromObj(virDomainObj *obj,
const char *path,
int type,
int status);
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockJobNewFromDom(virDomainPtr dom,
const char *path,
int type,
int status);
-virObjectEventPtr
-virDomainEventBlockJob2NewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockJob2NewFromObj(virDomainObj *obj,
const char *dst,
int type,
int status);
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockJob2NewFromDom(virDomainPtr dom,
const char *dst,
int type,
int status);
-virObjectEventPtr
-virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDiskChangeNewFromObj(virDomainObj *obj,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
int reason);
-virObjectEventPtr
+virObjectEvent *
virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
int reason);
-virObjectEventPtr
-virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventTrayChangeNewFromObj(virDomainObj *obj,
const char *devAlias,
int reason);
-virObjectEventPtr
+virObjectEvent *
virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
const char *devAlias,
int reason);
-virObjectEventPtr
-virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
-virObjectEventPtr
+virObjectEvent *
+virDomainEventPMWakeupNewFromObj(virDomainObj *obj);
+virObjectEvent *
virDomainEventPMWakeupNewFromDom(virDomainPtr dom, int reason);
-virObjectEventPtr
-virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
-virObjectEventPtr
+virObjectEvent *
+virDomainEventPMSuspendNewFromObj(virDomainObj *obj);
+virObjectEvent *
virDomainEventPMSuspendNewFromDom(virDomainPtr dom, int reason);
-virObjectEventPtr
+virObjectEvent *
virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
unsigned long long actual);
-virObjectEventPtr
-virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBalloonChangeNewFromObj(virDomainObj *obj,
unsigned long long actual);
-virObjectEventPtr
-virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
-virObjectEventPtr
+virObjectEvent *
+virDomainEventPMSuspendDiskNewFromObj(virDomainObj *obj);
+virObjectEvent *
virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom, int reason);
-virObjectEventPtr
-virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDeviceRemovedNewFromObj(virDomainObj *obj,
const char *devAlias);
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
const char *devAlias);
-virObjectEventPtr
-virDomainEventDeviceAddedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDeviceAddedNewFromObj(virDomainObj *obj,
const char *devAlias);
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceAddedNewFromDom(virDomainPtr dom,
const char *devAlias);
-virObjectEventPtr
-virDomainEventDeviceRemovalFailedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventDeviceRemovalFailedNewFromObj(virDomainObj *obj,
const char *devAlias);
-virObjectEventPtr
+virObjectEvent *
virDomainEventDeviceRemovalFailedNewFromDom(virDomainPtr dom,
const char *devAlias);
-virObjectEventPtr
-virDomainEventTunableNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventTunableNewFromObj(virDomainObj *obj,
virTypedParameterPtr params,
int nparams);
-virObjectEventPtr
+virObjectEvent *
virDomainEventTunableNewFromDom(virDomainPtr dom,
virTypedParameterPtr params,
int nparams);
-virObjectEventPtr
-virDomainEventAgentLifecycleNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventAgentLifecycleNewFromObj(virDomainObj *obj,
int state,
int reason);
-virObjectEventPtr
+virObjectEvent *
virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom,
int state,
int reason);
-virObjectEventPtr
-virDomainEventMigrationIterationNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMigrationIterationNewFromObj(virDomainObj *obj,
int iteration);
-virObjectEventPtr
+virObjectEvent *
virDomainEventMigrationIterationNewFromDom(virDomainPtr dom,
int iteration);
-virObjectEventPtr
-virDomainEventJobCompletedNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventJobCompletedNewFromObj(virDomainObj *obj,
virTypedParameterPtr params,
int nparams);
-virObjectEventPtr
+virObjectEvent *
virDomainEventJobCompletedNewFromDom(virDomainPtr dom,
virTypedParameterPtr params,
int nparams);
-virObjectEventPtr
-virDomainEventMetadataChangeNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMetadataChangeNewFromObj(virDomainObj *obj,
int type,
const char *nsuri);
-virObjectEventPtr
+virObjectEvent *
virDomainEventMetadataChangeNewFromDom(virDomainPtr dom,
int type,
const char *nsuri);
-virObjectEventPtr
-virDomainEventBlockThresholdNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventBlockThresholdNewFromObj(virDomainObj *obj,
const char *dev,
const char *path,
unsigned long long threshold,
unsigned long long excess);
-virObjectEventPtr
+virObjectEvent *
virDomainEventBlockThresholdNewFromDom(virDomainPtr dom,
const char *dev,
const char *path,
unsigned long long threshold,
unsigned long long excess);
-virObjectEventPtr
-virDomainEventMemoryFailureNewFromObj(virDomainObjPtr obj,
+virObjectEvent *
+virDomainEventMemoryFailureNewFromObj(virDomainObj *obj,
int recipient,
int action,
unsigned int flags);
-virObjectEventPtr
+virObjectEvent *
virDomainEventMemoryFailureNewFromDom(virDomainPtr dom,
int recipient,
int action,
int
virDomainEventStateRegister(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback callback,
void *opaque,
virFreeCallback freecb)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
virDomainEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
int
virDomainEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
int
virDomainEventStateCallbackID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback callback,
int *remoteID)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
int
virDomainEventStateDeregister(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virConnectDomainEventCallback callback)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
virDomainQemuMonitorEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virDomainPtr dom,
const char *event,
virConnectDomainQemuMonitorEventCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
ATTRIBUTE_NONNULL(9);
-virObjectEventPtr
+virObjectEvent *
virDomainQemuMonitorEventNew(int id,
const char *name,
const unsigned char *uuid,
#define VIR_FROM_THIS VIR_FROM_NWFILTER
-static virNWFilterBindingDefPtr
+static virNWFilterBindingDef *
virNWFilterBindingDefForNet(const char *vmname,
const unsigned char *vmuuid,
- virDomainNetDefPtr net)
+ virDomainNetDef *net)
{
- virNWFilterBindingDefPtr ret;
+ virNWFilterBindingDef *ret;
ret = g_new0(virNWFilterBindingDef, 1);
int
virDomainConfNWFilterInstantiate(const char *vmname,
const unsigned char *vmuuid,
- virDomainNetDefPtr net,
+ virDomainNetDef *net,
bool ignoreExists)
{
virConnectPtr conn = virGetConnectNWFilter();
- virNWFilterBindingDefPtr def = NULL;
+ virNWFilterBindingDef *def = NULL;
virNWFilterBindingPtr binding = NULL;
char *xml = NULL;
int ret = -1;
static void
virDomainConfNWFilterTeardownImpl(virConnectPtr conn,
- virDomainNetDefPtr net)
+ virDomainNetDef *net)
{
virNWFilterBindingPtr binding;
void
-virDomainConfNWFilterTeardown(virDomainNetDefPtr net)
+virDomainConfNWFilterTeardown(virDomainNetDef *net)
{
virConnectPtr conn;
}
void
-virDomainConfVMNWFilterTeardown(virDomainObjPtr vm)
+virDomainConfVMNWFilterTeardown(virDomainObj *vm)
{
size_t i;
virConnectPtr conn = NULL;
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
if (!net->filter)
continue;
int virDomainConfNWFilterInstantiate(const char *vmname,
const unsigned char *vmuuid,
- virDomainNetDefPtr net,
+ virDomainNetDef *net,
bool ignoreExists);
-void virDomainConfNWFilterTeardown(virDomainNetDefPtr net);
-void virDomainConfVMNWFilterTeardown(virDomainObjPtr vm);
+void virDomainConfNWFilterTeardown(virDomainNetDef *net);
+void virDomainConfVMNWFilterTeardown(virDomainObj *vm);
static int
-virDomainCheckVirtioOptionsAreAbsent(virDomainVirtioOptionsPtr virtio)
+virDomainCheckVirtioOptionsAreAbsent(virDomainVirtioOptions *virtio)
{
if (!virtio)
return 0;
static int
-virSecurityDeviceLabelDefValidate(virSecurityDeviceLabelDefPtr *seclabels,
+virSecurityDeviceLabelDefValidate(virSecurityDeviceLabelDef **seclabels,
size_t nseclabels,
- virSecurityLabelDefPtr *vmSeclabels,
+ virSecurityLabelDef **vmSeclabels,
size_t nvmSeclabels)
{
- virSecurityDeviceLabelDefPtr seclabel;
+ virSecurityDeviceLabelDef *seclabel;
size_t i;
size_t j;
virDomainDiskDefValidate(const virDomainDef *def,
const virDomainDiskDef *disk)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
/* Validate LUN configuration */
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
size_t j;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk_i = def->disks[i];
- virDomainDeviceInfoPtr disk_info_i = &disk_i->info;
+ virDomainDiskDef *disk_i = def->disks[i];
+ virDomainDeviceInfo *disk_info_i = &disk_i->info;
if (disk_info_i->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE)
continue;
for (j = i + 1; j < def->ndisks; j++) {
- virDomainDiskDefPtr disk_j = def->disks[j];
- virDomainDeviceInfoPtr disk_info_j = &disk_j->info;
+ virDomainDiskDef *disk_j = def->disks[j];
+ virDomainDeviceInfo *disk_info_j = &disk_j->info;
if (disk_i->bus != disk_j->bus)
continue;
}
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hdev_i = def->hostdevs[i];
- virDomainDeviceInfoPtr hdev_info_i = hdev_i->info;
- virDomainDeviceDriveAddressPtr hdev_addr_i;
+ virDomainHostdevDef *hdev_i = def->hostdevs[i];
+ virDomainDeviceInfo *hdev_info_i = hdev_i->info;
+ virDomainDeviceDriveAddress *hdev_addr_i;
if (!virHostdevIsSCSIDevice(hdev_i))
continue;
hdev_addr_i = &hdev_info_i->addr.drive;
for (j = i + 1; j < def->nhostdevs; j++) {
- virDomainHostdevDefPtr hdev_j = def->hostdevs[j];
- virDomainDeviceInfoPtr hdev_info_j = hdev_j->info;
+ virDomainHostdevDef *hdev_j = def->hostdevs[j];
+ virDomainDeviceInfo *hdev_info_j = hdev_j->info;
if (!virHostdevIsSCSIDevice(hdev_j))
continue;
static int
-virDomainDeviceDefValidateAliasesIterator(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
+virDomainDeviceDefValidateAliasesIterator(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
void *opaque)
{
struct virDomainDefValidateAliasesData *data = opaque;
if (!(data.aliases = virHashNew(NULL)))
goto cleanup;
- if (virDomainDeviceInfoIterateFlags((virDomainDefPtr) def,
+ if (virDomainDeviceInfoIterateFlags((virDomainDef *) def,
virDomainDeviceDefValidateAliasesIterator,
DOMAIN_DEVICE_ITERATE_ALL_CONSOLES,
&data) < 0)
static int
virDomainDeviceValidateAliasImpl(const virDomainDef *def,
- virDomainDeviceDefPtr dev)
+ virDomainDeviceDef *dev)
{
GHashTable *aliases = NULL;
- virDomainDeviceInfoPtr info = virDomainDeviceGetInfo(dev);
+ virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
int ret = -1;
if (!info || !info->alias)
int
-virDomainDeviceValidateAliasForHotplug(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+virDomainDeviceValidateAliasForHotplug(virDomainObj *vm,
+ virDomainDeviceDef *dev,
unsigned int flags)
{
- virDomainDefPtr persDef = NULL;
- virDomainDefPtr liveDef = NULL;
+ virDomainDef *persDef = NULL;
+ virDomainDef *liveDef = NULL;
if (virDomainObjGetDefs(vm, flags, &liveDef, &persDef) < 0)
return -1;
static int
virDomainDefOSValidate(const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
if (!def->os.loader)
return 0;
static int
virDomainDefValidateInternal(const virDomainDef *def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
if (virDomainDefDuplicateDiskInfoValidate(def) < 0)
return -1;
static int
-virDomainDefValidateDeviceIterator(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info G_GNUC_UNUSED,
+virDomainDefValidateDeviceIterator(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info G_GNUC_UNUSED,
void *opaque)
{
struct virDomainDefPostParseDeviceIteratorData *data = opaque;
* appropriate message.
*/
int
-virDomainDefValidate(virDomainDefPtr def,
+virDomainDefValidate(virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
struct virDomainDefPostParseDeviceIteratorData data = {
virDomainDeviceDefValidate(const virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque)
{
/* validate configuration only in certain places */
#include "domain_conf.h"
#include "virconftypes.h"
-int virDomainDeviceValidateAliasForHotplug(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+int virDomainDeviceValidateAliasForHotplug(virDomainObj *vm,
+ virDomainDeviceDef *dev,
unsigned int flags);
-int virDomainDefValidate(virDomainDefPtr def,
+int virDomainDefValidate(virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque);
int virDomainActualNetDefValidate(const virDomainNetDef *net);
int virDomainDeviceDefValidate(const virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque);
"ethernet", "bridge", "bond", "vlan",
);
-static virInterfaceDefPtr
+static virInterfaceDef *
virInterfaceDefParseXML(xmlXPathContextPtr ctxt, int parentIfType);
static int
-virInterfaceDefDevFormat(virBufferPtr buf, const virInterfaceDef *def,
+virInterfaceDefDevFormat(virBuffer *buf, const virInterfaceDef *def,
virInterfaceType parentIfType);
static void
-virInterfaceIPDefFree(virInterfaceIPDefPtr def)
+virInterfaceIPDefFree(virInterfaceIPDef *def)
{
if (def == NULL)
return;
static void
-virInterfaceProtocolDefFree(virInterfaceProtocolDefPtr def)
+virInterfaceProtocolDefFree(virInterfaceProtocolDef *def)
{
size_t i;
void
-virInterfaceDefFree(virInterfaceDefPtr def)
+virInterfaceDefFree(virInterfaceDef *def)
{
size_t i;
int pp;
static int
-virInterfaceDefParseName(virInterfaceDefPtr def,
+virInterfaceDefParseName(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
char *tmp;
static int
-virInterfaceDefParseMtu(virInterfaceDefPtr def,
+virInterfaceDefParseMtu(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
unsigned long mtu;
static int
-virInterfaceDefParseStartMode(virInterfaceDefPtr def,
+virInterfaceDefParseStartMode(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
char *tmp;
static int
-virInterfaceDefParseDhcp(virInterfaceProtocolDefPtr def,
+virInterfaceDefParseDhcp(virInterfaceProtocolDef *def,
xmlNodePtr dhcp, xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
-virInterfaceDefParseIP(virInterfaceIPDefPtr def,
+virInterfaceDefParseIP(virInterfaceIPDef *def,
xmlXPathContextPtr ctxt)
{
int ret = 0;
static int
-virInterfaceDefParseProtoIPv4(virInterfaceProtocolDefPtr def,
+virInterfaceDefParseProtoIPv4(virInterfaceProtocolDef *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr dhcp;
if (ipNodes == NULL)
return 0;
- def->ips = g_new0(virInterfaceIPDefPtr, nipNodes);
+ def->ips = g_new0(virInterfaceIPDef *, nipNodes);
def->nips = 0;
for (i = 0; i < nipNodes; i++) {
- virInterfaceIPDefPtr ip;
+ virInterfaceIPDef *ip;
ip = g_new0(virInterfaceIPDef, 1);
static int
-virInterfaceDefParseProtoIPv6(virInterfaceProtocolDefPtr def,
+virInterfaceDefParseProtoIPv6(virInterfaceProtocolDef *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr dhcp, autoconf;
if (ipNodes == NULL)
return 0;
- def->ips = g_new0(virInterfaceIPDefPtr, nipNodes);
+ def->ips = g_new0(virInterfaceIPDef *, nipNodes);
def->nips = 0;
for (i = 0; i < nipNodes; i++) {
- virInterfaceIPDefPtr ip;
+ virInterfaceIPDef *ip;
ip = g_new0(virInterfaceIPDef, 1);
static int
-virInterfaceDefParseIfAdressing(virInterfaceDefPtr def,
+virInterfaceDefParseIfAdressing(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
return 0;
}
- def->protos = g_new0(virInterfaceProtocolDefPtr, nProtoNodes);
+ def->protos = g_new0(virInterfaceProtocolDef *, nProtoNodes);
def->nprotos = 0;
for (pp = 0; pp < nProtoNodes; pp++) {
- virInterfaceProtocolDefPtr proto;
+ virInterfaceProtocolDef *proto;
proto = g_new0(virInterfaceProtocolDef, 1);
static int
-virInterfaceDefParseBridge(virInterfaceDefPtr def,
+virInterfaceDefParseBridge(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr *interfaces = NULL;
xmlNodePtr bridge;
- virInterfaceDefPtr itf;
+ virInterfaceDef *itf;
char *tmp = NULL;
int nbItf;
size_t i;
static int
-virInterfaceDefParseBondItfs(virInterfaceDefPtr def,
+virInterfaceDefParseBondItfs(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr *interfaces = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virInterfaceDefPtr itf;
+ virInterfaceDef *itf;
int nbItf;
size_t i;
int ret = -1;
static int
-virInterfaceDefParseBond(virInterfaceDefPtr def,
+virInterfaceDefParseBond(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
int res;
static int
-virInterfaceDefParseVlan(virInterfaceDefPtr def,
+virInterfaceDefParseVlan(virInterfaceDef *def,
xmlXPathContextPtr ctxt)
{
def->data.vlan.tag = virXPathString("string(./@tag)", ctxt);
}
-static virInterfaceDefPtr
+static virInterfaceDef *
virInterfaceDefParseXML(xmlXPathContextPtr ctxt,
int parentIfType)
{
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
int type;
char *tmp;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
}
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseNode(xmlDocPtr xml,
xmlNodePtr root)
{
}
-static virInterfaceDefPtr
+static virInterfaceDef *
virInterfaceDefParse(const char *xmlStr,
const char *filename)
{
xmlDocPtr xml;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(interface_definition)")))) {
def = virInterfaceDefParseNode(xml, xmlDocGetRootElement(xml));
}
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseString(const char *xmlStr)
{
return virInterfaceDefParse(xmlStr, NULL);
}
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseFile(const char *filename)
{
return virInterfaceDefParse(NULL, filename);
static int
-virInterfaceBridgeDefFormat(virBufferPtr buf,
+virInterfaceBridgeDefFormat(virBuffer *buf,
const virInterfaceDef *def)
{
size_t i;
static int
-virInterfaceBondDefFormat(virBufferPtr buf,
+virInterfaceBondDefFormat(virBuffer *buf,
const virInterfaceDef *def)
{
size_t i;
static int
-virInterfaceVlanDefFormat(virBufferPtr buf,
+virInterfaceVlanDefFormat(virBuffer *buf,
const virInterfaceDef *def)
{
if (def->data.vlan.tag == NULL) {
static int
-virInterfaceProtocolDefFormat(virBufferPtr buf,
+virInterfaceProtocolDefFormat(virBuffer *buf,
const virInterfaceDef *def)
{
size_t i, j;
static int
-virInterfaceStartmodeDefFormat(virBufferPtr buf,
+virInterfaceStartmodeDefFormat(virBuffer *buf,
virInterfaceStartMode startmode)
{
const char *mode;
static int
-virInterfaceDefDevFormat(virBufferPtr buf,
+virInterfaceDefDevFormat(virBuffer *buf,
const virInterfaceDef *def,
virInterfaceType parentIfType)
{
struct _virInterfaceDef; /* forward declaration required for bridge/bond */
typedef struct _virInterfaceBridgeDef virInterfaceBridgeDef;
-typedef virInterfaceBridgeDef *virInterfaceBridgeDefPtr;
struct _virInterfaceBridgeDef {
int stp; /* 0, 1 or -1 if undefined */
char *delay;
};
typedef struct _virInterfaceBondDef virInterfaceBondDef;
-typedef virInterfaceBondDef *virInterfaceBondDefPtr;
struct _virInterfaceBondDef {
int mode; /* virInterfaceBondMode */
int monit; /* virInterfaceBondMonit */
};
typedef struct _virInterfaceVlanDef virInterfaceVlanDef;
-typedef virInterfaceVlanDef *virInterfaceVlanDefPtr;
struct _virInterfaceVlanDef {
char *tag; /* TAG for vlan */
char *dev_name; /* device name for vlan */
};
typedef struct _virInterfaceIPDef virInterfaceIPDef;
-typedef virInterfaceIPDef *virInterfaceIPDefPtr;
struct _virInterfaceIPDef {
char *address; /* ip address */
int prefix; /* ip prefix */
typedef struct _virInterfaceProtocolDef virInterfaceProtocolDef;
-typedef virInterfaceProtocolDef *virInterfaceProtocolDefPtr;
struct _virInterfaceProtocolDef {
char *family; /* ipv4 or ipv6 */
int dhcp; /* use dhcp */
int peerdns; /* dhcp peerdns ? */
int autoconf; /* only useful if family is ipv6 */
int nips;
- virInterfaceIPDefPtr *ips; /* ptr to array of ips[nips] */
+ virInterfaceIPDef **ips; /* ptr to array of ips[nips] */
char *gateway; /* route gateway */
};
typedef struct _virInterfaceDef virInterfaceDef;
-typedef virInterfaceDef *virInterfaceDefPtr;
struct _virInterfaceDef {
int type; /* interface type */
char *name; /* interface name */
} data;
int nprotos;
- virInterfaceProtocolDefPtr *protos; /* ptr to array of protos[nprotos] */
+ virInterfaceProtocolDef **protos; /* ptr to array of protos[nprotos] */
};
void
-virInterfaceDefFree(virInterfaceDefPtr def);
+virInterfaceDefFree(virInterfaceDef *def);
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseString(const char *xmlStr);
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseFile(const char *filename);
-virInterfaceDefPtr
+virInterfaceDef *
virInterfaceDefParseNode(xmlDocPtr xml,
xmlNodePtr root);
VIR_LOG_INIT("conf.moment_conf");
-static virClassPtr virDomainMomentDefClass;
+static virClass *virDomainMomentDefClass;
static void virDomainMomentDefDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(virDomainMoment);
-virClassPtr
+virClass *
virClassForDomainMomentDef(void)
{
if (virDomainMomentInitialize() < 0)
static void
virDomainMomentDefDispose(void *obj)
{
- virDomainMomentDefPtr def = obj;
+ virDomainMomentDef *def = obj;
g_free(def->name);
g_free(def->description);
/* Provide defaults for creation time and moment name after parsing XML */
int
-virDomainMomentDefPostParse(virDomainMomentDefPtr def)
+virDomainMomentDefPostParse(virDomainMomentDef *def)
{
def->creationTime = g_get_real_time() / (1000*1000);
* guest and the inactive domain definition in case of
* offline guest
*/
- virDomainDefPtr dom;
+ virDomainDef *dom;
/*
* Store the inactive domain definition in case of online
* guest and leave NULL in case of offline guest
*/
- virDomainDefPtr inactiveDom;
+ virDomainDef *inactiveDom;
};
-virClassPtr virClassForDomainMomentDef(void);
+virClass *virClassForDomainMomentDef(void);
-int virDomainMomentDefPostParse(virDomainMomentDefPtr def);
+int virDomainMomentDefPostParse(virDomainMomentDef *def);
#define VIR_FROM_THIS VIR_FROM_NONE
static int
-virNetDevBandwidthParseRate(xmlNodePtr node, virNetDevBandwidthRatePtr rate)
+virNetDevBandwidthParseRate(xmlNodePtr node, virNetDevBandwidthRate *rate)
{
g_autofree char *average = NULL;
g_autofree char *peak = NULL;
* Returns !NULL on success, NULL on error.
*/
int
-virNetDevBandwidthParse(virNetDevBandwidthPtr *bandwidth,
+virNetDevBandwidthParse(virNetDevBandwidth **bandwidth,
unsigned int *class_id,
xmlNodePtr node,
bool allowFloor)
}
static int
-virNetDevBandwidthRateFormat(virNetDevBandwidthRatePtr def,
- virBufferPtr buf,
+virNetDevBandwidthRateFormat(virNetDevBandwidthRate *def,
+ virBuffer *buf,
const char *elem_name)
{
if (!buf || !elem_name)
int
virNetDevBandwidthFormat(const virNetDevBandwidth *def,
unsigned int class_id,
- virBufferPtr buf)
+ virBuffer *buf)
{
if (!buf)
return -1;
}
void
-virDomainClearNetBandwidth(virDomainDefPtr def)
+virDomainClearNetBandwidth(virDomainDef *def)
{
size_t i;
virDomainNetType type;
#include "domain_conf.h"
#include "network_conf.h"
-int virNetDevBandwidthParse(virNetDevBandwidthPtr *bandwidth,
+int virNetDevBandwidthParse(virNetDevBandwidth **bandwidth,
unsigned int *class_id,
xmlNodePtr node,
bool allowFloor)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevBandwidthFormat(const virNetDevBandwidth *def,
unsigned int class_id,
- virBufferPtr buf);
+ virBuffer *buf);
-void virDomainClearNetBandwidth(virDomainDefPtr def)
+void virDomainClearNetBandwidth(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
bool virNetDevSupportsBandwidth(virDomainNetType type);
);
int
-virNetDevVlanParse(xmlNodePtr node, xmlXPathContextPtr ctxt, virNetDevVlanPtr def)
+virNetDevVlanParse(xmlNodePtr node, xmlXPathContextPtr ctxt, virNetDevVlan *def)
{
int ret = -1;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
}
int
-virNetDevVlanFormat(const virNetDevVlan *def, virBufferPtr buf)
+virNetDevVlanFormat(const virNetDevVlan *def, virBuffer *buf)
{
size_t i;
#include "virbuffer.h"
#include "virxml.h"
-int virNetDevVlanParse(xmlNodePtr node, xmlXPathContextPtr ctxt, virNetDevVlanPtr def);
-int virNetDevVlanFormat(const virNetDevVlan *def, virBufferPtr buf);
+int virNetDevVlanParse(xmlNodePtr node, xmlXPathContextPtr ctxt, virNetDevVlan *def);
+int virNetDevVlanFormat(const virNetDevVlan *def, virBuffer *buf);
#define VIR_FROM_THIS VIR_FROM_NONE
-virNetDevVPortProfilePtr
+virNetDevVPortProfile *
virNetDevVPortProfileParse(xmlNodePtr node, unsigned int flags)
{
char *virtPortType;
char *virtPortInstanceID = NULL;
char *virtPortProfileID = NULL;
char *virtPortInterfaceID = NULL;
- virNetDevVPortProfilePtr virtPort = NULL;
+ virNetDevVPortProfile *virtPort = NULL;
xmlNodePtr cur = node->children;
virtPort = g_new0(virNetDevVPortProfile, 1);
int
virNetDevVPortProfileFormat(const virNetDevVPortProfile *virtPort,
- virBufferPtr buf)
+ virBuffer *buf)
{
enum virNetDevVPortProfile type;
bool noParameters;
VIR_VPORT_XML_REQUIRE_TYPE = (1<<2),
} virNetDevVPortXMLFlags;
-virNetDevVPortProfilePtr
+virNetDevVPortProfile *
virNetDevVPortProfileParse(xmlNodePtr node, unsigned int flags);
int
virNetDevVPortProfileFormat(const virNetDevVPortProfile *virtPort,
- virBufferPtr buf);
+ virBuffer *buf);
"hours",
);
-static virClassPtr virNetworkXMLOptionClass;
+static virClass *virNetworkXMLOptionClass;
static void
virNetworkXMLOptionDispose(void *obj G_GNUC_UNUSED)
VIR_ONCE_GLOBAL_INIT(virNetworkXML);
-virNetworkXMLOptionPtr
-virNetworkXMLOptionNew(virXMLNamespacePtr xmlns)
+virNetworkXMLOption *
+virNetworkXMLOptionNew(virXMLNamespace *xmlns)
{
- virNetworkXMLOptionPtr xmlopt;
+ virNetworkXMLOption *xmlopt;
if (virNetworkXMLInitialize() < 0)
return NULL;
}
static void
-virPortGroupDefClear(virPortGroupDefPtr def)
+virPortGroupDefClear(virPortGroupDef *def)
{
VIR_FREE(def->name);
VIR_FREE(def->virtPortProfile);
static void
-virNetworkForwardIfDefClear(virNetworkForwardIfDefPtr def)
+virNetworkForwardIfDefClear(virNetworkForwardIfDef *def)
{
if (def->type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV)
VIR_FREE(def->device.dev);
static void
-virNetworkForwardPfDefClear(virNetworkForwardPfDefPtr def)
+virNetworkForwardPfDefClear(virNetworkForwardPfDef *def)
{
VIR_FREE(def->dev);
}
static void
-virNetworkDHCPLeaseTimeDefClear(virNetworkDHCPLeaseTimeDefPtr lease)
+virNetworkDHCPLeaseTimeDefClear(virNetworkDHCPLeaseTimeDef *lease)
{
VIR_FREE(lease);
}
static void
-virNetworkDHCPHostDefClear(virNetworkDHCPHostDefPtr def)
+virNetworkDHCPHostDefClear(virNetworkDHCPHostDef *def)
{
VIR_FREE(def->mac);
VIR_FREE(def->id);
static void
-virNetworkIPDefClear(virNetworkIPDefPtr def)
+virNetworkIPDefClear(virNetworkIPDef *def)
{
VIR_FREE(def->family);
static void
-virNetworkDNSTxtDefClear(virNetworkDNSTxtDefPtr def)
+virNetworkDNSTxtDefClear(virNetworkDNSTxtDef *def)
{
VIR_FREE(def->name);
VIR_FREE(def->value);
static void
-virNetworkDNSHostDefClear(virNetworkDNSHostDefPtr def)
+virNetworkDNSHostDefClear(virNetworkDNSHostDef *def)
{
while (def->nnames)
VIR_FREE(def->names[--def->nnames]);
static void
-virNetworkDNSSrvDefClear(virNetworkDNSSrvDefPtr def)
+virNetworkDNSSrvDefClear(virNetworkDNSSrvDef *def)
{
VIR_FREE(def->domain);
VIR_FREE(def->service);
static void
-virNetworkDNSForwarderClear(virNetworkDNSForwarderPtr def)
+virNetworkDNSForwarderClear(virNetworkDNSForwarder *def)
{
VIR_FREE(def->domain);
}
static void
-virNetworkDNSDefClear(virNetworkDNSDefPtr def)
+virNetworkDNSDefClear(virNetworkDNSDef *def)
{
if (def->forwarders) {
while (def->nfwds)
static void
-virNetworkForwardDefClear(virNetworkForwardDefPtr def)
+virNetworkForwardDefClear(virNetworkForwardDef *def)
{
size_t i;
void
-virNetworkDefFree(virNetworkDefPtr def)
+virNetworkDefFree(virNetworkDef *def)
{
size_t i;
*
* Returns a new NetworkDef on success, or NULL on failure.
*/
-virNetworkDefPtr
-virNetworkDefCopy(virNetworkDefPtr def,
- virNetworkXMLOptionPtr xmlopt,
+virNetworkDef *
+virNetworkDefCopy(virNetworkDef *def,
+ virNetworkXMLOption *xmlopt,
unsigned int flags)
{
g_autofree char *xml = NULL;
/* return ips[index], or NULL if there aren't enough ips */
-virNetworkIPDefPtr
+virNetworkIPDef *
virNetworkDefGetIPByIndex(const virNetworkDef *def,
int family,
size_t n)
/* return routes[index], or NULL if there aren't enough routes */
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetworkDefGetRouteByIndex(const virNetworkDef *def,
int family,
size_t n)
/* find the nth route of type "family" */
for (i = 0; i < def->nroutes; i++) {
- virSocketAddrPtr addr = virNetDevIPRouteGetAddress(def->routes[i]);
+ virSocketAddr *addr = virNetDevIPRouteGetAddress(def->routes[i]);
if (VIR_SOCKET_ADDR_IS_FAMILY(addr, family)
&& (n-- <= 0)) {
return def->routes[i];
* prefix. Return -1 on error (and set the netmask family to AF_UNSPEC)
*/
int virNetworkIPDefNetmask(const virNetworkIPDef *def,
- virSocketAddrPtr netmask)
+ virSocketAddr *netmask)
{
if (VIR_SOCKET_ADDR_IS_FAMILY(&def->netmask, AF_INET)) {
*netmask = def->netmask;
static int
-virNetworkDHCPLeaseTimeDefParseXML(virNetworkDHCPLeaseTimeDefPtr *lease,
+virNetworkDHCPLeaseTimeDefParseXML(virNetworkDHCPLeaseTimeDef **lease,
xmlNodePtr node)
{
- virNetworkDHCPLeaseTimeDefPtr new_lease = NULL;
+ virNetworkDHCPLeaseTimeDef *new_lease = NULL;
g_autofree char *expirystr = NULL;
g_autofree char *unitstr = NULL;
unsigned long expiry;
static int
virNetworkDHCPRangeDefParseXML(const char *networkName,
- virNetworkIPDefPtr ipdef,
+ virNetworkIPDef *ipdef,
xmlNodePtr node,
- virNetworkDHCPRangeDefPtr range)
+ virNetworkDHCPRangeDef *range)
{
- virSocketAddrRangePtr addr = &range->addr;
+ virSocketAddrRange *addr = &range->addr;
xmlNodePtr cur = node->children;
g_autofree char *start = NULL;
g_autofree char *end = NULL;
static int
virNetworkDHCPHostDefParseXML(const char *networkName,
- virNetworkIPDefPtr def,
+ virNetworkIPDef *def,
xmlNodePtr node,
- virNetworkDHCPHostDefPtr host,
+ virNetworkDHCPHostDef *host,
bool partialOkay)
{
g_autofree char *mac = NULL;
static int
virNetworkDHCPDefParseXML(const char *networkName,
xmlNodePtr node,
- virNetworkIPDefPtr def)
+ virNetworkIPDef *def)
{
int ret = -1;
xmlNodePtr cur;
static int
virNetworkDNSHostDefParseXML(const char *networkName,
xmlNodePtr node,
- virNetworkDNSHostDefPtr def,
+ virNetworkDNSHostDef *def,
bool partialOkay)
{
xmlNodePtr cur;
virNetworkDNSSrvDefParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetworkDNSSrvDefPtr def,
+ virNetworkDNSSrvDef *def,
bool partialOkay)
{
int ret;
static int
virNetworkDNSTxtDefParseXML(const char *networkName,
xmlNodePtr node,
- virNetworkDNSTxtDefPtr def,
+ virNetworkDNSTxtDef *def,
bool partialOkay)
{
const char *bad = " ,";
virNetworkDNSDefParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetworkDNSDefPtr def)
+ virNetworkDNSDef *def)
{
g_autofree xmlNodePtr *hostNodes = NULL;
g_autofree xmlNodePtr *srvNodes = NULL;
virNetworkIPDefParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetworkIPDefPtr def)
+ virNetworkIPDef *def)
{
/*
* virNetworkIPDef object is already allocated as part of an array.
static int
-virNetworkPortGroupParseXML(virPortGroupDefPtr def,
+virNetworkPortGroupParseXML(virPortGroupDef *def,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
virNetworkForwardNatDefParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetworkForwardDefPtr def)
+ virNetworkForwardDef *def)
{
int nNatAddrs, nNatPorts;
g_autofree xmlNodePtr *natAddrNodes = NULL;
virNetworkForwardDefParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virNetworkForwardDefPtr def)
+ virNetworkForwardDef *def)
{
size_t i, j;
int nForwardIfs, nForwardAddrs, nForwardPfs, nForwardNats;
switch (def->ifs[i].type) {
case VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI:
{
- virPCIDeviceAddressPtr addr = &def->ifs[i].device.pci;
+ virPCIDeviceAddress *addr = &def->ifs[i].device.pci;
if (virPCIDeviceAddressParseXML(forwardAddrNodes[i], addr) < 0)
return -1;
}
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseXML(xmlXPathContextPtr ctxt,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
g_autoptr(virNetworkDef) def = NULL;
g_autofree char *uuid = NULL;
size_t i;
/* allocate array to hold all the route definitions */
- def->routes = g_new0(virNetDevIPRoutePtr, nRoutes);
+ def->routes = g_new0(virNetDevIPRoute *, nRoutes);
/* parse each definition */
for (i = 0; i < nRoutes; i++) {
- virNetDevIPRoutePtr route = NULL;
+ virNetDevIPRoute *route = NULL;
if (!(route = virNetDevIPRouteParseXML(def->name,
routeNodes[i],
size_t j;
virSocketAddr testAddr, testGw;
bool addrMatch;
- virNetDevIPRoutePtr gwdef = def->routes[i];
- virSocketAddrPtr gateway = virNetDevIPRouteGetGateway(gwdef);
+ virNetDevIPRoute *gwdef = def->routes[i];
+ virSocketAddr *gateway = virNetDevIPRouteGetGateway(gwdef);
addrMatch = false;
for (j = 0; j < nips; j++) {
- virNetworkIPDefPtr def2 = &def->ips[j];
+ virNetworkIPDef *def2 = &def->ips[j];
int prefix;
if (VIR_SOCKET_ADDR_FAMILY(gateway)
}
-static virNetworkDefPtr
+static virNetworkDef *
virNetworkDefParse(const char *xmlStr,
const char *filename,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
g_autoptr(xmlDoc) xml = NULL;
- virNetworkDefPtr def = NULL;
+ virNetworkDef *def = NULL;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParse(filename, xmlStr, _("(network_definition)"))))
}
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseString(const char *xmlStr,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
return virNetworkDefParse(xmlStr, NULL, xmlopt);
}
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseFile(const char *filename,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
return virNetworkDefParse(NULL, filename, xmlopt);
}
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
static int
-virNetworkDNSDefFormat(virBufferPtr buf,
+virNetworkDNSDefFormat(virBuffer *buf,
const virNetworkDNSDef *def)
{
size_t i, j;
static int
-virNetworkIPDefFormat(virBufferPtr buf,
+virNetworkIPDefFormat(virBuffer *buf,
const virNetworkIPDef *def)
{
virBufferAddLit(buf, "<ip");
for (i = 0; i < def->nranges; i++) {
virSocketAddrRange addr = def->ranges[i].addr;
- virNetworkDHCPLeaseTimeDefPtr lease = def->ranges[i].lease;
+ virNetworkDHCPLeaseTimeDef *lease = def->ranges[i].lease;
g_autofree char *saddr = NULL;
g_autofree char *eaddr = NULL;
}
}
for (i = 0; i < def->nhosts; i++) {
- virNetworkDHCPLeaseTimeDefPtr lease = def->hosts[i].lease;
+ virNetworkDHCPLeaseTimeDef *lease = def->hosts[i].lease;
virBufferAddLit(buf, "<host");
if (def->hosts[i].mac)
virBufferAsprintf(buf, " mac='%s'", def->hosts[i].mac);
void
virNetworkPortOptionsFormat(virTristateBool isolatedPort,
- virBufferPtr buf)
+ virBuffer *buf)
{
if (isolatedPort != VIR_TRISTATE_BOOL_ABSENT)
virBufferAsprintf(buf, "<port isolated='%s'/>\n",
}
static int
-virPortGroupDefFormat(virBufferPtr buf,
+virPortGroupDefFormat(virBuffer *buf,
const virPortGroupDef *def)
{
virBufferAsprintf(buf, "<portgroup name='%s'", def->name);
static int
-virNetworkForwardNatDefFormat(virBufferPtr buf,
+virNetworkForwardNatDefFormat(virBuffer *buf,
const virNetworkForwardDef *fwd)
{
g_autofree char *addrStart = NULL;
int
-virNetworkDefFormatBuf(virBufferPtr buf,
+virNetworkDefFormatBuf(virBuffer *buf,
const virNetworkDef *def,
- virNetworkXMLOptionPtr xmlopt G_GNUC_UNUSED,
+ virNetworkXMLOption *xmlopt G_GNUC_UNUSED,
unsigned int flags)
{
const unsigned char *uuid;
char *
virNetworkDefFormat(const virNetworkDef *def,
- virNetworkXMLOptionPtr xmlopt,
+ virNetworkXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
-virPortGroupDefPtr
-virPortGroupFindByName(virNetworkDefPtr net,
+virPortGroupDef *
+virPortGroupFindByName(virNetworkDef *net,
const char *portgroup)
{
size_t i;
int
virNetworkSaveXML(const char *configDir,
- virNetworkDefPtr def,
+ virNetworkDef *def,
const char *xml)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
int
virNetworkSaveConfig(const char *configDir,
- virNetworkDefPtr def,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkDef *def,
+ virNetworkXMLOption *xmlopt)
{
g_autofree char *xml = NULL;
void
-virNetworkSetBridgeMacAddr(virNetworkDefPtr def)
+virNetworkSetBridgeMacAddr(virNetworkDef *def)
{
if (!def->mac_specified) {
/* if the bridge doesn't have a mac address explicitly defined,
/* NetworkObj backend of the virNetworkUpdate API */
static void
-virNetworkDefUpdateNoSupport(virNetworkDefPtr def, const char *section)
+virNetworkDefUpdateNoSupport(virNetworkDef *def, const char *section)
{
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("can't update '%s' section of network '%s'"),
static int
-virNetworkDefUpdateCheckElementName(virNetworkDefPtr def,
+virNetworkDefUpdateCheckElementName(virNetworkDef *def,
xmlNodePtr node,
const char *section)
{
static int
-virNetworkDefUpdateBridge(virNetworkDefPtr def,
+virNetworkDefUpdateBridge(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
static int
-virNetworkDefUpdateDomain(virNetworkDefPtr def,
+virNetworkDefUpdateDomain(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
static int
-virNetworkDefUpdateIP(virNetworkDefPtr def,
+virNetworkDefUpdateIP(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
}
-static virNetworkIPDefPtr
-virNetworkIPDefByIndex(virNetworkDefPtr def, int parentIndex)
+static virNetworkIPDef *
+virNetworkIPDefByIndex(virNetworkDef *def, int parentIndex)
{
- virNetworkIPDefPtr ipdef = NULL;
+ virNetworkIPDef *ipdef = NULL;
size_t i;
/* first find which ip element's dhcp host list to work on */
static int
-virNetworkDefUpdateCheckMultiDHCP(virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+virNetworkDefUpdateCheckMultiDHCP(virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
int family = VIR_SOCKET_ADDR_FAMILY(&ipdef->address);
size_t i;
- virNetworkIPDefPtr ip;
+ virNetworkIPDef *ip;
for (i = 0; (ip = virNetworkDefGetIPByIndex(def, family, i)); i++) {
if (ip != ipdef) {
static int
-virNetworkDefUpdateIPDHCPHost(virNetworkDefPtr def,
+virNetworkDefUpdateIPDHCPHost(virNetworkDef *def,
unsigned int command,
int parentIndex,
xmlXPathContextPtr ctxt,
{
size_t i;
int ret = -1;
- virNetworkIPDefPtr ipdef = virNetworkIPDefByIndex(def, parentIndex);
+ virNetworkIPDef *ipdef = virNetworkIPDefByIndex(def, parentIndex);
virNetworkDHCPHostDef host;
bool partialOkay = (command == VIR_NETWORK_UPDATE_COMMAND_DELETE);
static int
-virNetworkDefUpdateIPDHCPRange(virNetworkDefPtr def,
+virNetworkDefUpdateIPDHCPRange(virNetworkDef *def,
unsigned int command,
int parentIndex,
xmlXPathContextPtr ctxt,
unsigned int fflags G_GNUC_UNUSED)
{
size_t i;
- virNetworkIPDefPtr ipdef = virNetworkIPDefByIndex(def, parentIndex);
+ virNetworkIPDef *ipdef = virNetworkIPDefByIndex(def, parentIndex);
virNetworkDHCPRangeDef range;
memset(&range, 0, sizeof(range));
static int
-virNetworkDefUpdateForward(virNetworkDefPtr def,
+virNetworkDefUpdateForward(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
static int
-virNetworkDefUpdateForwardInterface(virNetworkDefPtr def,
+virNetworkDefUpdateForwardInterface(virNetworkDef *def,
unsigned int command,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt,
static int
-virNetworkDefUpdateForwardPF(virNetworkDefPtr def,
+virNetworkDefUpdateForwardPF(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
static int
-virNetworkDefUpdatePortGroup(virNetworkDefPtr def,
+virNetworkDefUpdatePortGroup(virNetworkDef *def,
unsigned int command,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt,
static int
-virNetworkDefUpdateDNSHost(virNetworkDefPtr def,
+virNetworkDefUpdateDNSHost(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
{
size_t i, j, k;
int foundIdx = -1, ret = -1;
- virNetworkDNSDefPtr dns = &def->dns;
+ virNetworkDNSDef *dns = &def->dns;
virNetworkDNSHostDef host;
bool isAdd = (command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST ||
command == VIR_NETWORK_UPDATE_COMMAND_ADD_LAST);
static int
-virNetworkDefUpdateDNSSrv(virNetworkDefPtr def,
+virNetworkDefUpdateDNSSrv(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
{
size_t i;
int foundIdx = -1, ret = -1;
- virNetworkDNSDefPtr dns = &def->dns;
+ virNetworkDNSDef *dns = &def->dns;
virNetworkDNSSrvDef srv;
bool isAdd = (command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST ||
command == VIR_NETWORK_UPDATE_COMMAND_ADD_LAST);
static int
-virNetworkDefUpdateDNSTxt(virNetworkDefPtr def,
+virNetworkDefUpdateDNSTxt(virNetworkDef *def,
unsigned int command G_GNUC_UNUSED,
int parentIndex G_GNUC_UNUSED,
xmlXPathContextPtr ctxt G_GNUC_UNUSED,
unsigned int fflags G_GNUC_UNUSED)
{
int foundIdx, ret = -1;
- virNetworkDNSDefPtr dns = &def->dns;
+ virNetworkDNSDef *dns = &def->dns;
virNetworkDNSTxtDef txt;
bool isAdd = (command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST ||
command == VIR_NETWORK_UPDATE_COMMAND_ADD_LAST);
int
-virNetworkDefUpdateSection(virNetworkDefPtr def,
+virNetworkDefUpdateSection(virNetworkDef *def,
unsigned int command, /* virNetworkUpdateCommand */
unsigned int section, /* virNetworkUpdateSection */
int parentIndex,
virXMLNamespace ns;
};
typedef struct _virNetworkXMLOption virNetworkXMLOption;
-typedef virNetworkXMLOption *virNetworkXMLOptionPtr;
typedef enum {
VIR_ENUM_DECL(virNetworkForwardDriverName);
typedef struct _virNetworkDHCPLeaseTimeDef virNetworkDHCPLeaseTimeDef;
-typedef virNetworkDHCPLeaseTimeDef *virNetworkDHCPLeaseTimeDefPtr;
struct _virNetworkDHCPLeaseTimeDef {
unsigned long expiry;
virNetworkDHCPLeaseTimeUnitType unit;
};
typedef struct _virNetworkDHCPRangeDef virNetworkDHCPRangeDef;
-typedef virNetworkDHCPRangeDef *virNetworkDHCPRangeDefPtr;
struct _virNetworkDHCPRangeDef {
virSocketAddrRange addr;
- virNetworkDHCPLeaseTimeDefPtr lease;
+ virNetworkDHCPLeaseTimeDef *lease;
};
typedef struct _virNetworkDHCPHostDef virNetworkDHCPHostDef;
-typedef virNetworkDHCPHostDef *virNetworkDHCPHostDefPtr;
struct _virNetworkDHCPHostDef {
char *mac;
char *id;
char *name;
virSocketAddr ip;
- virNetworkDHCPLeaseTimeDefPtr lease;
+ virNetworkDHCPLeaseTimeDef *lease;
};
typedef struct _virNetworkDNSTxtDef virNetworkDNSTxtDef;
-typedef virNetworkDNSTxtDef *virNetworkDNSTxtDefPtr;
struct _virNetworkDNSTxtDef {
char *name;
char *value;
};
typedef struct _virNetworkDNSSrvDef virNetworkDNSSrvDef;
-typedef virNetworkDNSSrvDef *virNetworkDNSSrvDefPtr;
struct _virNetworkDNSSrvDef {
char *domain;
char *service;
};
typedef struct _virNetworkDNSHostDef virNetworkDNSHostDef;
-typedef virNetworkDNSHostDef *virNetworkDNSHostDefPtr;
struct _virNetworkDNSHostDef {
virSocketAddr ip;
size_t nnames;
typedef struct _virNetworkDNSForwarder virNetworkDNSForwarder;
-typedef virNetworkDNSForwarder *virNetworkDNSForwarderPtr;
struct _virNetworkDNSForwarder {
virSocketAddr addr;
char *domain;
};
typedef struct _virNetworkDNSDef virNetworkDNSDef;
-typedef virNetworkDNSDef *virNetworkDNSDefPtr;
struct _virNetworkDNSDef {
int enable; /* enum virTristateBool */
int forwardPlainNames; /* enum virTristateBool */
size_t ntxts;
- virNetworkDNSTxtDefPtr txts;
+ virNetworkDNSTxtDef *txts;
size_t nhosts;
- virNetworkDNSHostDefPtr hosts;
+ virNetworkDNSHostDef *hosts;
size_t nsrvs;
- virNetworkDNSSrvDefPtr srvs;
+ virNetworkDNSSrvDef *srvs;
size_t nfwds;
- virNetworkDNSForwarderPtr forwarders;
+ virNetworkDNSForwarder *forwarders;
};
typedef struct _virNetworkIPDef virNetworkIPDef;
-typedef virNetworkIPDef *virNetworkIPDefPtr;
struct _virNetworkIPDef {
char *family; /* ipv4 or ipv6 - default is ipv4 */
virSocketAddr address; /* Bridge IP address */
int localPTR; /* virTristateBool */
size_t nranges; /* Zero or more dhcp ranges */
- virNetworkDHCPRangeDefPtr ranges;
+ virNetworkDHCPRangeDef *ranges;
size_t nhosts; /* Zero or more dhcp hosts */
- virNetworkDHCPHostDefPtr hosts;
+ virNetworkDHCPHostDef *hosts;
char *tftproot;
char *bootfile;
};
typedef struct _virNetworkForwardIfDef virNetworkForwardIfDef;
-typedef virNetworkForwardIfDef *virNetworkForwardIfDefPtr;
struct _virNetworkForwardIfDef {
int type;
union {
};
typedef struct _virNetworkForwardPfDef virNetworkForwardPfDef;
-typedef virNetworkForwardPfDef *virNetworkForwardPfDefPtr;
struct _virNetworkForwardPfDef {
char *dev; /* name of device */
int connections; /* how many guest interfaces are connected to this device? */
};
typedef struct _virNetworkForwardDef virNetworkForwardDef;
-typedef virNetworkForwardDef *virNetworkForwardDefPtr;
struct _virNetworkForwardDef {
int type; /* One of virNetworkForwardType constants */
bool managed; /* managed attribute for hostdev mode */
* interfaces), they will be listed here.
*/
size_t npfs;
- virNetworkForwardPfDefPtr pfs;
+ virNetworkForwardPfDef *pfs;
size_t nifs;
- virNetworkForwardIfDefPtr ifs;
+ virNetworkForwardIfDef *ifs;
/* ranges for NAT */
virSocketAddrRange addr;
};
typedef struct _virPortGroupDef virPortGroupDef;
-typedef virPortGroupDef *virPortGroupDefPtr;
struct _virPortGroupDef {
char *name;
bool isDefault;
- virNetDevVPortProfilePtr virtPortProfile;
- virNetDevBandwidthPtr bandwidth;
+ virNetDevVPortProfile *virtPortProfile;
+ virNetDevBandwidth *bandwidth;
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
};
typedef struct _virNetworkDef virNetworkDef;
-typedef virNetworkDef *virNetworkDefPtr;
struct _virNetworkDef {
unsigned char uuid[VIR_UUID_BUFLEN];
bool uuid_specified;
virNetworkForwardDef forward;
size_t nips;
- virNetworkIPDefPtr ips; /* ptr to array of IP addresses on this network */
+ virNetworkIPDef *ips; /* ptr to array of IP addresses on this network */
size_t nroutes;
- virNetDevIPRoutePtr *routes; /* ptr to array of static routes on this interface */
+ virNetDevIPRoute **routes; /* ptr to array of static routes on this interface */
virNetworkDNSDef dns; /* dns related configuration */
- virNetDevVPortProfilePtr virtPortProfile;
+ virNetDevVPortProfile *virtPortProfile;
size_t nPortGroups;
- virPortGroupDefPtr portGroups;
- virNetDevBandwidthPtr bandwidth;
+ virPortGroupDef *portGroups;
+ virNetDevBandwidth *bandwidth;
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
virTristateBool isolatedPort;
VIR_NETWORK_TAINT_LAST
} virNetworkTaintFlags;
-void virNetworkDefFree(virNetworkDefPtr def);
+void virNetworkDefFree(virNetworkDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetworkDef, virNetworkDefFree);
enum {
VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1),
};
-virNetworkXMLOptionPtr
-virNetworkXMLOptionNew(virXMLNamespacePtr xmlns);
+virNetworkXMLOption *
+virNetworkXMLOptionNew(virXMLNamespace *xmlns);
-virNetworkDefPtr
-virNetworkDefCopy(virNetworkDefPtr def,
- virNetworkXMLOptionPtr xmlopt,
+virNetworkDef *
+virNetworkDefCopy(virNetworkDef *def,
+ virNetworkXMLOption *xmlopt,
unsigned int flags);
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseXML(xmlXPathContextPtr ctxt,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseString(const char *xmlStr,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseFile(const char *filename,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
-virNetworkDefPtr
+virNetworkDef *
virNetworkDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
char *
virNetworkDefFormat(const virNetworkDef *def,
- virNetworkXMLOptionPtr xmlopt,
+ virNetworkXMLOption *xmlopt,
unsigned int flags);
int
-virNetworkDefFormatBuf(virBufferPtr buf,
+virNetworkDefFormatBuf(virBuffer *buf,
const virNetworkDef *def,
- virNetworkXMLOptionPtr xmlopt,
+ virNetworkXMLOption *xmlopt,
unsigned int flags);
const char *
virNetworkDefForwardIf(const virNetworkDef *def,
size_t n);
-virPortGroupDefPtr
-virPortGroupFindByName(virNetworkDefPtr net,
+virPortGroupDef *
+virPortGroupFindByName(virNetworkDef *net,
const char *portgroup);
-virNetworkIPDefPtr
+virNetworkIPDef *
virNetworkDefGetIPByIndex(const virNetworkDef *def,
int family,
size_t n);
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetworkDefGetRouteByIndex(const virNetworkDef *def,
int family,
size_t n);
int
virNetworkIPDefNetmask(const virNetworkIPDef *def,
- virSocketAddrPtr netmask);
+ virSocketAddr *netmask);
int
virNetworkSaveXML(const char *configDir,
- virNetworkDefPtr def,
+ virNetworkDef *def,
const char *xml);
int
virNetworkSaveConfig(const char *configDir,
- virNetworkDefPtr def,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkDef *def,
+ virNetworkXMLOption *xmlopt);
char *
virNetworkConfigFile(const char *dir,
const char *name);
void
-virNetworkSetBridgeMacAddr(virNetworkDefPtr def);
+virNetworkSetBridgeMacAddr(virNetworkDef *def);
int
virNetworkPortOptionsParseXML(xmlXPathContextPtr ctxt,
void
virNetworkPortOptionsFormat(virTristateBool isolatedPort,
- virBufferPtr buf);
+ virBuffer *buf);
VIR_ENUM_DECL(virNetworkForward);
/* for testing */
int
-virNetworkDefUpdateSection(virNetworkDefPtr def,
+virNetworkDefUpdateSection(virNetworkDef *def,
unsigned int command, /* virNetworkUpdateCommand */
unsigned int section, /* virNetworkUpdateSection */
int parentIndex,
bool dummy;
};
typedef struct _virNetworkEvent virNetworkEvent;
-typedef virNetworkEvent *virNetworkEventPtr;
struct _virNetworkEventLifecycle {
virNetworkEvent parent;
int detail;
};
typedef struct _virNetworkEventLifecycle virNetworkEventLifecycle;
-typedef virNetworkEventLifecycle *virNetworkEventLifecyclePtr;
-static virClassPtr virNetworkEventClass;
-static virClassPtr virNetworkEventLifecycleClass;
+static virClass *virNetworkEventClass;
+static virClass *virNetworkEventLifecycleClass;
static void virNetworkEventDispose(void *obj);
static void virNetworkEventLifecycleDispose(void *obj);
static void
virNetworkEventDispose(void *obj)
{
- virNetworkEventPtr event = obj;
+ virNetworkEvent *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virNetworkEventLifecycleDispose(void *obj)
{
- virNetworkEventLifecyclePtr event = obj;
+ virNetworkEventLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virNetworkEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
switch ((virNetworkEventID)event->eventID) {
case VIR_NETWORK_EVENT_ID_LIFECYCLE:
{
- virNetworkEventLifecyclePtr networkLifecycleEvent;
+ virNetworkEventLifecycle *networkLifecycleEvent;
- networkLifecycleEvent = (virNetworkEventLifecyclePtr)event;
+ networkLifecycleEvent = (virNetworkEventLifecycle *)event;
((virConnectNetworkEventLifecycleCallback)cb)(conn, net,
networkLifecycleEvent->type,
networkLifecycleEvent->detail,
*/
int
virNetworkEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNetworkPtr net,
int eventID,
virConnectNetworkEventGenericCallback cb,
*/
int
virNetworkEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNetworkPtr net,
int eventID,
virConnectNetworkEventGenericCallback cb,
*
* Create a new network lifecycle event.
*/
-virObjectEventPtr
+virObjectEvent *
virNetworkEventLifecycleNew(const char *name,
const unsigned char *uuid,
int type,
int detail)
{
- virNetworkEventLifecyclePtr event;
+ virNetworkEventLifecycle *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virNetworkEventsInitialize() < 0)
event->type = type;
event->detail = detail;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
int
virNetworkEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNetworkPtr net,
int eventID,
virConnectNetworkEventGenericCallback cb,
int
virNetworkEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNetworkPtr net,
int eventID,
virConnectNetworkEventGenericCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
ATTRIBUTE_NONNULL(8);
-virObjectEventPtr
+virObjectEvent *
virNetworkEventLifecycleNew(const char *name,
const unsigned char *uuid,
int type,
#define VIR_FROM_THIS VIR_FROM_NETWORK
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetDevIPRouteCreate(const char *errorDetail,
const char *family,
const char *address,
return g_steal_pointer(&def);
}
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetDevIPRouteParseXML(const char *errorDetail,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
}
int
-virNetDevIPRouteFormat(virBufferPtr buf,
+virNetDevIPRouteFormat(virBuffer *buf,
const virNetDevIPRoute *def)
{
g_autofree char *address = NULL;
#include "virsocketaddr.h"
#include "virnetdevip.h"
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetDevIPRouteCreate(const char *networkName,
const char *family,
const char *address,
unsigned int metric,
bool hasMetric);
-virNetDevIPRoutePtr
+virNetDevIPRoute *
virNetDevIPRouteParseXML(const char *networkName,
xmlNodePtr node,
xmlXPathContextPtr ctxt);
int
-virNetDevIPRouteFormat(virBufferPtr buf,
+virNetDevIPRouteFormat(virBuffer *buf,
const virNetDevIPRoute *def);
void
-virNodeDeviceDefFree(virNodeDeviceDefPtr def)
+virNodeDeviceDefFree(virNodeDeviceDef *def)
{
- virNodeDevCapsDefPtr caps;
+ virNodeDevCapsDef *caps;
if (!def)
return;
caps = def->caps;
while (caps) {
- virNodeDevCapsDefPtr next = caps->next;
+ virNodeDevCapsDef *next = caps->next;
virNodeDevCapsDefFree(caps);
caps = next;
}
static void
-virPCIELinkFormat(virBufferPtr buf,
- virPCIELinkPtr lnk,
+virPCIELinkFormat(virBuffer *buf,
+ virPCIELink *lnk,
const char *attrib)
{
if (!lnk)
static void
-virPCIEDeviceInfoFormat(virBufferPtr buf,
- virPCIEDeviceInfoPtr info)
+virPCIEDeviceInfoFormat(virBuffer *buf,
+ virPCIEDeviceInfo *info)
{
if (!info->link_cap && !info->link_sta) {
virBufferAddLit(buf, "<pci-express/>\n");
static void
-virNodeDeviceCapSystemDefFormat(virBufferPtr buf,
+virNodeDeviceCapSystemDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
static void
-virNodeDeviceCapMdevTypesFormat(virBufferPtr buf,
- virMediatedDeviceTypePtr *mdev_types,
+virNodeDeviceCapMdevTypesFormat(virBuffer *buf,
+ virMediatedDeviceType **mdev_types,
const size_t nmdev_types)
{
size_t i;
virBufferAddLit(buf, "<capability type='mdev_types'>\n");
virBufferAdjustIndent(buf, 2);
for (i = 0; i < nmdev_types; i++) {
- virMediatedDeviceTypePtr type = mdev_types[i];
+ virMediatedDeviceType *type = mdev_types[i];
virBufferEscapeString(buf, "<type id='%s'>\n", type->id);
virBufferAdjustIndent(buf, 2);
if (type->name)
static void
-virNodeDeviceCapPCIDefFormat(virBufferPtr buf,
+virNodeDeviceCapPCIDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
size_t i;
static void
-virNodeDeviceCapUSBDevDefFormat(virBufferPtr buf,
+virNodeDeviceCapUSBDevDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferAsprintf(buf, "<bus>%d</bus>\n", data->usb_dev.bus);
static void
-virNodeDeviceCapUSBInterfaceDefFormat(virBufferPtr buf,
+virNodeDeviceCapUSBInterfaceDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferAsprintf(buf, "<number>%d</number>\n",
static void
-virNodeDeviceCapNetDefFormat(virBufferPtr buf,
+virNodeDeviceCapNetDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
size_t i;
static void
-virNodeDeviceCapSCSIHostDefFormat(virBufferPtr buf,
+virNodeDeviceCapSCSIHostDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferAsprintf(buf, "<host>%d</host>\n",
static void
-virNodeDeviceCapSCSIDefFormat(virBufferPtr buf,
+virNodeDeviceCapSCSIDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferAsprintf(buf, "<host>%d</host>\n", data->scsi.host);
static void
-virNodeDeviceCapStorageDefFormat(virBufferPtr buf,
+virNodeDeviceCapStorageDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferEscapeString(buf, "<block>%s</block>\n",
}
static void
-virNodeDeviceCapMdevDefFormat(virBufferPtr buf,
+virNodeDeviceCapMdevDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
size_t i;
data->mdev.iommuGroupNumber);
for (i = 0; i < data->mdev.nattributes; i++) {
- virMediatedDeviceAttrPtr attr = data->mdev.attributes[i];
+ virMediatedDeviceAttr *attr = data->mdev.attributes[i];
virBufferAsprintf(buf, "<attr name='%s' value='%s'/>\n",
attr->name, attr->value);
}
}
static void
-virNodeDeviceCapVDPADefFormat(virBufferPtr buf,
+virNodeDeviceCapVDPADefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferEscapeString(buf, "<chardev>%s</chardev>\n", data->vdpa.chardev);
static void
-virNodeDeviceCapCCWDefFormat(virBufferPtr buf,
+virNodeDeviceCapCCWDefFormat(virBuffer *buf,
const virNodeDevCapData *data)
{
virBufferAsprintf(buf, "<cssid>0x%x</cssid>\n",
virNodeDeviceDefFormat(const virNodeDeviceDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virNodeDevCapsDefPtr caps;
+ virNodeDevCapsDef *caps;
size_t i = 0;
virBufferAddLit(&buf, "<device>\n");
}
for (caps = def->caps; caps; caps = caps->next) {
- virNodeDevCapDataPtr data = &caps->data;
+ virNodeDevCapData *data = &caps->data;
virBufferAsprintf(&buf, "<capability type='%s'>\n",
virNodeDevCapTypeToString(caps->data.type));
virNodeDevCapsDefParseIntOptional(const char *xpath,
xmlXPathContextPtr ctxt,
int *value,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
const char *invalid_error_fmt)
{
int ret;
virNodeDevCapsDefParseULong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned *value,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
const char *missing_error_fmt,
const char *invalid_error_fmt)
{
virNodeDevCapsDefParseULongLong(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned long long *value,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
const char *missing_error_fmt,
const char *invalid_error_fmt)
{
static int
virNodeDevCapDRMParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapDRMPtr drm)
+ virNodeDevCapDRM *drm)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int val;
static int
virNodeDevCapMdevTypesParseXML(xmlXPathContextPtr ctxt,
- virMediatedDeviceTypePtr **mdev_types,
+ virMediatedDeviceType ***mdev_types,
size_t *nmdev_types)
{
int ret = -1;
xmlNodePtr orignode = NULL;
g_autofree xmlNodePtr *nodes = NULL;
int ntypes = -1;
- virMediatedDeviceTypePtr type = NULL;
+ virMediatedDeviceType *type = NULL;
size_t i;
if ((ntypes = virXPathNodeSet("./type", ctxt, &nodes)) < 0)
static int
virNodeDevAPMatrixCapabilityParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virNodeDevCapAPMatrixPtr apm_dev)
+ virNodeDevCapAPMatrix *apm_dev)
{
g_autofree char *type = virXMLPropString(node, "type");
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCSSCapabilityParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virNodeDevCapCCWPtr ccw_dev)
+ virNodeDevCapCCW *ccw_dev)
{
g_autofree char *type = virXMLPropString(node, "type");
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCapCCWParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapCCWPtr ccw_dev)
+ virNodeDevCapCCW *ccw_dev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
static int
virNodeDevCapAPAdapterParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
unsigned int *ap_adapter)
{
g_autofree char *adapter = NULL;
static int
virNodeDevCapAPCardParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapAPCardPtr ap_card)
+ virNodeDevCapAPCard *ap_card)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
ctxt->node = node;
static int
virNodeDevCapAPQueueParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapAPQueuePtr ap_queue)
+ virNodeDevCapAPQueue *ap_queue)
{
int ret = -1;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCapAPMatrixParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def G_GNUC_UNUSED,
+ virNodeDeviceDef *def G_GNUC_UNUSED,
xmlNodePtr node,
- virNodeDevCapAPMatrixPtr ap_matrix)
+ virNodeDevCapAPMatrix *ap_matrix)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
static int
virNodeDevCapStorageParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapStoragePtr storage)
+ virNodeDevCapStorage *storage)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
static int
virNodeDevCapSCSIParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapSCSIPtr scsi)
+ virNodeDevCapSCSI *scsi)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCapSCSITargetParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapSCSITargetPtr scsi_target)
+ virNodeDevCapSCSITarget *scsi_target)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
static int
virNodeDevCapSCSIHostParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapSCSIHostPtr scsi_host,
+ virNodeDevCapSCSIHost *scsi_host,
int create,
const char *virt_type)
{
static int
virNodeDevCapNetParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapNetPtr net)
+ virNodeDevCapNet *net)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr lnk;
static int
virNodeDevCapUSBInterfaceParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapUSBIfPtr usb_if)
+ virNodeDevCapUSBIf *usb_if)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
virNodeDevCapsDefParseHexId(const char *xpath,
xmlXPathContextPtr ctxt,
unsigned *value,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
const char *missing_error_fmt,
const char *invalid_error_fmt)
{
static int
virNodeDevCapUSBDevParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapUSBDevPtr usb_dev)
+ virNodeDevCapUSBDev *usb_dev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCapPCIDevIommuGroupParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr iommuGroupNode,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *addrNodes = NULL;
static int
virPCIEDeviceInfoLinkParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr linkNode,
- virPCIELinkPtr lnk)
+ virPCIELink *lnk)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int speed;
static int
virPCIEDeviceInfoParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr pciExpressNode,
- virPCIEDeviceInfoPtr pci_express)
+ virPCIEDeviceInfo *pci_express)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr lnk;
static int
virNodeDevPCICapSRIOVPhysicalParseXML(xmlXPathContextPtr ctxt,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
xmlNodePtr address = virXPathNode("./address[1]", ctxt);
static int
virNodeDevPCICapSRIOVVirtualParseXML(xmlXPathContextPtr ctxt,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
g_autofree xmlNodePtr *addresses = NULL;
int naddresses = virXPathNodeSet("./address", ctxt, &addresses);
return -1;
}
- pci_dev->virtual_functions = g_new0(virPCIDeviceAddressPtr, naddresses);
+ pci_dev->virtual_functions = g_new0(virPCIDeviceAddress *, naddresses);
for (i = 0; i < naddresses; i++) {
g_autoptr(virPCIDeviceAddress) addr = NULL;
static int
virNodeDevPCICapabilityParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
g_autofree char *type = virXMLPropString(node, "type");
VIR_XPATH_NODE_AUTORESTORE(ctxt)
static int
virNodeDevCapPCIDevParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr iommuGroupNode;
g_autofree xmlNodePtr *nodes = NULL;
int n = 0;
int ret = -1;
- virPCIEDeviceInfoPtr pci_express = NULL;
+ virPCIEDeviceInfo *pci_express = NULL;
g_autofree char *tmp = NULL;
size_t i = 0;
static int
virNodeDevCapSystemParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapSystemPtr syscap)
+ virNodeDevCapSystem *syscap)
{
- virNodeDevCapSystemHardwarePtr hardware = &syscap->hardware;
- virNodeDevCapSystemFirmwarePtr firmware = &syscap->firmware;
+ virNodeDevCapSystemHardware *hardware = &syscap->hardware;
+ virNodeDevCapSystemFirmware *firmware = &syscap->firmware;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *tmp = NULL;
static int
virNodeDevCapMdevAttributeParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr node,
- virNodeDevCapMdevPtr mdev)
+ virNodeDevCapMdev *mdev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autoptr(virMediatedDeviceAttr) attr = virMediatedDeviceAttrNew();
static int
virNodeDevCapMdevParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
- virNodeDevCapMdevPtr mdev)
+ virNodeDevCapMdev *mdev)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int nattrs = 0;
}
-static virNodeDevCapsDefPtr
+static virNodeDevCapsDef *
virNodeDevCapsDefParseXML(xmlXPathContextPtr ctxt,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
xmlNodePtr node,
int create,
const char *virt_type)
{
- virNodeDevCapsDefPtr caps;
+ virNodeDevCapsDef *caps;
g_autofree char *tmp = NULL;
int val, ret = -1;
}
-static virNodeDeviceDefPtr
+static virNodeDeviceDef *
virNodeDeviceDefParseXML(xmlXPathContextPtr ctxt,
int create,
const char *virt_type)
{
- virNodeDeviceDefPtr def;
- virNodeDevCapsDefPtr *next_cap;
+ virNodeDeviceDef *def;
+ virNodeDevCapsDef **next_cap;
xmlNodePtr *nodes = NULL;
int n, m;
size_t i;
}
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
int create,
}
-static virNodeDeviceDefPtr
+static virNodeDeviceDef *
virNodeDeviceDefParse(const char *str,
const char *filename,
int create,
const char *virt_type)
{
xmlDocPtr xml;
- virNodeDeviceDefPtr def = NULL;
+ virNodeDeviceDef *def = NULL;
if ((xml = virXMLParse(filename, str, _("(node_device_definition)")))) {
def = virNodeDeviceDefParseNode(xml, xmlDocGetRootElement(xml),
}
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseString(const char *str,
int create,
const char *virt_type)
}
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseFile(const char *filename,
int create,
const char *virt_type)
* Return fc_host dev's WWNN and WWPN
*/
int
-virNodeDeviceGetWWNs(virNodeDeviceDefPtr def,
+virNodeDeviceGetWWNs(virNodeDeviceDef *def,
char **wwnn,
char **wwpn)
{
- virNodeDevCapsDefPtr cap = NULL;
+ virNodeDevCapsDef *cap = NULL;
cap = def->caps;
while (cap != NULL) {
void
-virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps)
+virNodeDevCapsDefFree(virNodeDevCapsDef *caps)
{
size_t i = 0;
- virNodeDevCapDataPtr data = &caps->data;
+ virNodeDevCapData *data = &caps->data;
switch (caps->data.type) {
case VIR_NODE_DEV_CAP_SYSTEM:
int
-virNodeDeviceUpdateCaps(virNodeDeviceDefPtr def)
+virNodeDeviceUpdateCaps(virNodeDeviceDef *def)
{
- virNodeDevCapsDefPtr cap = def->caps;
+ virNodeDevCapsDef *cap = def->caps;
while (cap) {
switch (cap->data.type) {
* Returns the number of capabilities the device supports, -1 on error.
*/
int
-virNodeDeviceCapsListExport(virNodeDeviceDefPtr def,
+virNodeDeviceCapsListExport(virNodeDeviceDef *def,
virNodeDevCapType **list)
{
- virNodeDevCapsDefPtr caps = NULL;
+ virNodeDevCapsDef *caps = NULL;
g_autofree virNodeDevCapType *tmp = NULL;
bool want_list = !!list;
int ncaps = 0;
#ifdef __linux__
int
-virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHostPtr scsi_host)
+virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHost *scsi_host)
{
g_autofree char *tmp = NULL;
int ret = -1;
int
virNodeDeviceGetSCSITargetCaps(const char *sysfsPath,
- virNodeDevCapSCSITargetPtr scsi_target)
+ virNodeDevCapSCSITarget *scsi_target)
{
int ret = -1;
g_autofree char *dir = NULL;
static int
virNodeDeviceGetPCISRIOVCaps(const char *sysfsPath,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
size_t i;
int ret;
static int
-virNodeDeviceGetPCIIOMMUGroupCaps(virNodeDevCapPCIDevPtr pci_dev)
+virNodeDeviceGetPCIIOMMUGroupCaps(virNodeDevCapPCIDev *pci_dev)
{
size_t i;
int tmpGroup;
static int
virNodeDeviceGetMdevTypesCaps(const char *sysfspath,
- virMediatedDeviceTypePtr **mdev_types,
+ virMediatedDeviceType ***mdev_types,
size_t *nmdev_types)
{
- virMediatedDeviceTypePtr *types = NULL;
+ virMediatedDeviceType **types = NULL;
size_t ntypes = 0;
size_t i;
*/
int
virNodeDeviceGetPCIDynamicCaps(const char *sysfsPath,
- virNodeDevCapPCIDevPtr pci_dev)
+ virNodeDevCapPCIDev *pci_dev)
{
if (virNodeDeviceGetPCISRIOVCaps(sysfsPath, pci_dev) < 0 ||
virNodeDeviceGetPCIIOMMUGroupCaps(pci_dev) < 0)
*/
int
virNodeDeviceGetCSSDynamicCaps(const char *sysfsPath,
- virNodeDevCapCCWPtr ccw_dev)
+ virNodeDevCapCCW *ccw_dev)
{
ccw_dev->flags &= ~VIR_NODE_DEV_CAP_FLAG_CSS_MDEV;
if (virNodeDeviceGetMdevTypesCaps(sysfsPath,
*/
int
virNodeDeviceGetAPMatrixDynamicCaps(const char *sysfsPath,
- virNodeDevCapAPMatrixPtr ap_matrix)
+ virNodeDevCapAPMatrix *ap_matrix)
{
ap_matrix->flags &= ~VIR_NODE_DEV_CAP_FLAG_AP_MATRIX_MDEV;
if (virNodeDeviceGetMdevTypesCaps(sysfsPath,
#else
int
-virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHostPtr scsi_host G_GNUC_UNUSED)
+virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHost *scsi_host G_GNUC_UNUSED)
{
return -1;
}
int
virNodeDeviceGetPCIDynamicCaps(const char *sysfsPath G_GNUC_UNUSED,
- virNodeDevCapPCIDevPtr pci_dev G_GNUC_UNUSED)
+ virNodeDevCapPCIDev *pci_dev G_GNUC_UNUSED)
{
return -1;
}
int virNodeDeviceGetSCSITargetCaps(const char *sysfsPath G_GNUC_UNUSED,
- virNodeDevCapSCSITargetPtr scsi_target G_GNUC_UNUSED)
+ virNodeDevCapSCSITarget *scsi_target G_GNUC_UNUSED)
{
return -1;
}
int
virNodeDeviceGetCSSDynamicCaps(const char *sysfsPath G_GNUC_UNUSED,
- virNodeDevCapCCWPtr ccw_dev G_GNUC_UNUSED)
+ virNodeDevCapCCW *ccw_dev G_GNUC_UNUSED)
{
return -1;
}
int
virNodeDeviceGetAPMatrixDynamicCaps(const char *sysfsPath G_GNUC_UNUSED,
- virNodeDevCapAPMatrixPtr ap_matrix G_GNUC_UNUSED)
+ virNodeDevCapAPMatrix *ap_matrix G_GNUC_UNUSED)
{
return -1;
}
VIR_ENUM_DECL(virNodeDevDRM);
typedef struct _virNodeDevCapSystemHardware virNodeDevCapSystemHardware;
-typedef virNodeDevCapSystemHardware *virNodeDevCapSystemHardwarePtr;
struct _virNodeDevCapSystemHardware {
char *vendor_name;
char *version;
};
typedef struct _virNodeDevCapSystemFirmware virNodeDevCapSystemFirmware;
-typedef virNodeDevCapSystemFirmware *virNodeDevCapSystemFirmwarePtr;
struct _virNodeDevCapSystemFirmware {
char *vendor_name;
char *version;
};
typedef struct _virNodeDevCapSystem virNodeDevCapSystem;
-typedef virNodeDevCapSystem *virNodeDevCapSystemPtr;
struct _virNodeDevCapSystem {
char *product_name;
virNodeDevCapSystemHardware hardware;
};
typedef struct _virNodeDevCapMdev virNodeDevCapMdev;
-typedef virNodeDevCapMdev *virNodeDevCapMdevPtr;
struct _virNodeDevCapMdev {
char *type;
unsigned int iommuGroupNumber;
char *uuid;
- virMediatedDeviceAttrPtr *attributes;
+ virMediatedDeviceAttr **attributes;
size_t nattributes;
};
typedef struct _virNodeDevCapPCIDev virNodeDevCapPCIDev;
-typedef virNodeDevCapPCIDev *virNodeDevCapPCIDevPtr;
struct _virNodeDevCapPCIDev {
unsigned int domain;
unsigned int bus;
int klass;
char *product_name;
char *vendor_name;
- virPCIDeviceAddressPtr physical_function;
- virPCIDeviceAddressPtr *virtual_functions;
+ virPCIDeviceAddress *physical_function;
+ virPCIDeviceAddress **virtual_functions;
size_t num_virtual_functions;
unsigned int max_virtual_functions;
unsigned int flags;
- virPCIDeviceAddressPtr *iommuGroupDevices;
+ virPCIDeviceAddress **iommuGroupDevices;
size_t nIommuGroupDevices;
unsigned int iommuGroupNumber;
int numa_node;
- virPCIEDeviceInfoPtr pci_express;
+ virPCIEDeviceInfo *pci_express;
int hdrType; /* enum virPCIHeaderType or -1 */
- virMediatedDeviceTypePtr *mdev_types;
+ virMediatedDeviceType **mdev_types;
size_t nmdev_types;
};
typedef struct _virNodeDevCapUSBDev virNodeDevCapUSBDev;
-typedef virNodeDevCapUSBDev *virNodeDevCapUSBDevPtr;
struct _virNodeDevCapUSBDev {
unsigned int bus;
unsigned int device;
};
typedef struct _virNodeDevCapUSBIf virNodeDevCapUSBIf;
-typedef virNodeDevCapUSBIf *virNodeDevCapUSBIfPtr;
struct _virNodeDevCapUSBIf {
unsigned int number;
unsigned int klass;
};
typedef struct _virNodeDevCapNet virNodeDevCapNet;
-typedef virNodeDevCapNet *virNodeDevCapNetPtr;
struct _virNodeDevCapNet {
char *address;
unsigned int address_len;
char *ifname;
virNetDevIfLink lnk;
virNodeDevNetCapType subtype; /* LAST -> no subtype */
- virBitmapPtr features; /* enum virNetDevFeature */
+ virBitmap *features; /* enum virNetDevFeature */
};
typedef struct _virNodeDevCapSCSIHost virNodeDevCapSCSIHost;
-typedef virNodeDevCapSCSIHost *virNodeDevCapSCSIHostPtr;
struct _virNodeDevCapSCSIHost {
unsigned int host;
int unique_id;
};
typedef struct _virNodeDevCapSCSITarget virNodeDevCapSCSITarget;
-typedef virNodeDevCapSCSITarget *virNodeDevCapSCSITargetPtr;
struct _virNodeDevCapSCSITarget {
char *name;
unsigned int flags; /* enum virNodeDevSCSITargetCapsFlags */
};
typedef struct _virNodeDevCapSCSI virNodeDevCapSCSI;
-typedef virNodeDevCapSCSI *virNodeDevCapSCSIPtr;
struct _virNodeDevCapSCSI {
unsigned int host;
unsigned int bus;
};
typedef struct _virNodeDevCapStorage virNodeDevCapStorage;
-typedef virNodeDevCapStorage *virNodeDevCapStoragePtr;
struct _virNodeDevCapStorage {
unsigned long long size;
unsigned long long num_blocks;
};
typedef struct _virNodeDevCapSCSIGeneric virNodeDevCapSCSIGeneric;
-typedef virNodeDevCapSCSIGeneric *virNodeDevCapSCSIGenericPtr;
struct _virNodeDevCapSCSIGeneric {
char *path;
};
typedef struct _virNodeDevCapDRM virNodeDevCapDRM;
-typedef virNodeDevCapDRM *virNodeDevCapDRMPtr;
struct _virNodeDevCapDRM {
virNodeDevDRMType type;
};
typedef struct _virNodeDevCapCCW virNodeDevCapCCW;
-typedef virNodeDevCapCCW *virNodeDevCapCCWPtr;
struct _virNodeDevCapCCW {
unsigned int cssid;
unsigned int ssid;
unsigned int devno;
unsigned int flags; /* enum virNodeDevCCWCapFlags */
- virMediatedDeviceTypePtr *mdev_types;
+ virMediatedDeviceType **mdev_types;
size_t nmdev_types;
};
typedef struct _virNodeDevCapVDPA virNodeDevCapVDPA;
-typedef virNodeDevCapVDPA *virNodeDevCapVDPAPtr;
struct _virNodeDevCapVDPA {
char *chardev;
};
typedef struct _virNodeDevCapAPCard virNodeDevCapAPCard;
-typedef virNodeDevCapAPCard *virNodeDevCapAPCardPtr;
struct _virNodeDevCapAPCard {
unsigned int ap_adapter;
};
typedef struct _virNodeDevCapAPQueue virNodeDevCapAPQueue;
-typedef virNodeDevCapAPQueue *virNodeDevCapAPQueuePtr;
struct _virNodeDevCapAPQueue {
unsigned int ap_adapter;
unsigned int ap_domain;
};
typedef struct _virNodeDevCapAPMatrix virNodeDevCapAPMatrix;
-typedef virNodeDevCapAPMatrix *virNodeDevCapAPMatrixPtr;
struct _virNodeDevCapAPMatrix {
char *addr;
unsigned int flags; /* enum virNodeDevAPMatrixCapFlags */
- virMediatedDeviceTypePtr *mdev_types;
+ virMediatedDeviceType **mdev_types;
size_t nmdev_types;
};
typedef struct _virNodeDevCapData virNodeDevCapData;
-typedef virNodeDevCapData *virNodeDevCapDataPtr;
struct _virNodeDevCapData {
virNodeDevCapType type;
union {
};
typedef struct _virNodeDevCapsDef virNodeDevCapsDef;
-typedef virNodeDevCapsDef *virNodeDevCapsDefPtr;
struct _virNodeDevCapsDef {
virNodeDevCapData data;
- virNodeDevCapsDefPtr next; /* next capability */
+ virNodeDevCapsDef *next; /* next capability */
};
typedef struct _virNodeDeviceDef virNodeDeviceDef;
-typedef virNodeDeviceDef *virNodeDeviceDefPtr;
struct _virNodeDeviceDef {
char *name; /* device name (unique on node) */
char *sysfs_path; /* udev name/sysfs path */
char *driver; /* optional driver name */
char *devnode; /* /dev path */
char **devlinks; /* /dev links */
- virNodeDevCapsDefPtr caps; /* optional device capabilities */
+ virNodeDevCapsDef *caps; /* optional device capabilities */
};
char *
virNodeDeviceDefFormat(const virNodeDeviceDef *def);
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseString(const char *str,
int create,
const char *virt_type);
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseFile(const char *filename,
int create,
const char *virt_type);
-virNodeDeviceDefPtr
+virNodeDeviceDef *
virNodeDeviceDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
int create,
const char *virt_type);
int
-virNodeDeviceGetWWNs(virNodeDeviceDefPtr def,
+virNodeDeviceGetWWNs(virNodeDeviceDef *def,
char **wwnn,
char **wwpn);
void
-virNodeDeviceDefFree(virNodeDeviceDefPtr def);
+virNodeDeviceDefFree(virNodeDeviceDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNodeDeviceDef, virNodeDeviceDefFree);
void
-virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps);
+virNodeDevCapsDefFree(virNodeDevCapsDef *caps);
#define VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP \
(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM | \
VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_ACTIVE
int
-virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHostPtr scsi_host);
+virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHost *scsi_host);
int
virNodeDeviceGetSCSITargetCaps(const char *sysfsPath,
- virNodeDevCapSCSITargetPtr scsi_target);
+ virNodeDevCapSCSITarget *scsi_target);
int
virNodeDeviceGetPCIDynamicCaps(const char *sysfsPath,
- virNodeDevCapPCIDevPtr pci_dev);
+ virNodeDevCapPCIDev *pci_dev);
int
virNodeDeviceGetCSSDynamicCaps(const char *sysfsPath,
- virNodeDevCapCCWPtr ccw_dev);
+ virNodeDevCapCCW *ccw_dev);
int
virNodeDeviceGetAPMatrixDynamicCaps(const char *sysfsPath,
- virNodeDevCapAPMatrixPtr ap_matrix);
+ virNodeDevCapAPMatrix *ap_matrix);
int
-virNodeDeviceUpdateCaps(virNodeDeviceDefPtr def);
+virNodeDeviceUpdateCaps(virNodeDeviceDef *def);
int
-virNodeDeviceCapsListExport(virNodeDeviceDefPtr def,
+virNodeDeviceCapsListExport(virNodeDeviceDef *def,
virNodeDevCapType **list);
bool dummy;
};
typedef struct _virNodeDeviceEvent virNodeDeviceEvent;
-typedef virNodeDeviceEvent *virNodeDeviceEventPtr;
struct _virNodeDeviceEventLifecycle {
virNodeDeviceEvent parent;
int detail;
};
typedef struct _virNodeDeviceEventLifecycle virNodeDeviceEventLifecycle;
-typedef virNodeDeviceEventLifecycle *virNodeDeviceEventLifecyclePtr;
struct _virNodeDeviceEventUpdate {
virNodeDeviceEvent parent;
bool dummy;
};
typedef struct _virNodeDeviceEventUpdate virNodeDeviceEventUpdate;
-typedef virNodeDeviceEventUpdate *virNodeDeviceEventUpdatePtr;
-static virClassPtr virNodeDeviceEventClass;
-static virClassPtr virNodeDeviceEventLifecycleClass;
-static virClassPtr virNodeDeviceEventUpdateClass;
+static virClass *virNodeDeviceEventClass;
+static virClass *virNodeDeviceEventLifecycleClass;
+static virClass *virNodeDeviceEventUpdateClass;
static void virNodeDeviceEventDispose(void *obj);
static void virNodeDeviceEventLifecycleDispose(void *obj);
static void virNodeDeviceEventUpdateDispose(void *obj);
static void
virNodeDeviceEventDispose(void *obj)
{
- virNodeDeviceEventPtr event = obj;
+ virNodeDeviceEvent *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virNodeDeviceEventLifecycleDispose(void *obj)
{
- virNodeDeviceEventLifecyclePtr event = obj;
+ virNodeDeviceEventLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virNodeDeviceEventUpdateDispose(void *obj)
{
- virNodeDeviceEventUpdatePtr event = obj;
+ virNodeDeviceEventUpdate *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virNodeDeviceEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
switch ((virNodeDeviceEventID)event->eventID) {
case VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE:
{
- virNodeDeviceEventLifecyclePtr nodeDeviceLifecycleEvent;
+ virNodeDeviceEventLifecycle *nodeDeviceLifecycleEvent;
- nodeDeviceLifecycleEvent = (virNodeDeviceEventLifecyclePtr)event;
+ nodeDeviceLifecycleEvent = (virNodeDeviceEventLifecycle *)event;
((virConnectNodeDeviceEventLifecycleCallback)cb)(conn, dev,
nodeDeviceLifecycleEvent->type,
nodeDeviceLifecycleEvent->detail,
*/
int
virNodeDeviceEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNodeDevicePtr dev,
int eventID,
virConnectNodeDeviceEventGenericCallback cb,
*/
int
virNodeDeviceEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNodeDevicePtr dev,
int eventID,
virConnectNodeDeviceEventGenericCallback cb,
*
* Create a new node device lifecycle event.
*/
-virObjectEventPtr
+virObjectEvent *
virNodeDeviceEventLifecycleNew(const char *name,
int type,
int detail)
{
- virNodeDeviceEventLifecyclePtr event;
+ virNodeDeviceEventLifecycle *event;
if (virNodeDeviceEventsInitialize() < 0)
return NULL;
event->type = type;
event->detail = detail;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
*
* Create a new node device update event.
*/
-virObjectEventPtr
+virObjectEvent *
virNodeDeviceEventUpdateNew(const char *name)
{
- virNodeDeviceEventUpdatePtr event;
+ virNodeDeviceEventUpdate *event;
if (virNodeDeviceEventsInitialize() < 0)
return NULL;
0, name, NULL, name)))
return NULL;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
int
virNodeDeviceEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNodeDevicePtr dev,
int eventID,
virConnectNodeDeviceEventGenericCallback cb,
int
virNodeDeviceEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virNodeDevicePtr dev,
int eventID,
virConnectNodeDeviceEventGenericCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
ATTRIBUTE_NONNULL(8);
-virObjectEventPtr
+virObjectEvent *
virNodeDeviceEventLifecycleNew(const char *name,
int type,
int detail);
-virObjectEventPtr
+virObjectEvent *
virNodeDeviceEventUpdateNew(const char *name);
* Returns vHBA name on success, NULL on failure with an error message set
*/
char *
-virNodeDeviceCreateVport(virStorageAdapterFCHostPtr fchost)
+virNodeDeviceCreateVport(virStorageAdapterFCHost *fchost)
{
unsigned int parent_host;
char *name = NULL;
*/
int
virNodeDeviceDeleteVport(virConnectPtr conn,
- virStorageAdapterFCHostPtr fchost)
+ virStorageAdapterFCHost *fchost)
{
char *name = NULL;
char *scsi_host_name = NULL;
const char *nodedev_name);
char *
-virNodeDeviceCreateVport(virStorageAdapterFCHostPtr fchost);
+virNodeDeviceCreateVport(virStorageAdapterFCHost *fchost);
int
virNodeDeviceDeleteVport(virConnectPtr conn,
- virStorageAdapterFCHostPtr fchost);
+ virStorageAdapterFCHost *fchost);
);
typedef struct _virDomainNumaDistance virDomainNumaDistance;
-typedef virDomainNumaDistance *virDomainNumaDistancePtr;
typedef struct _virDomainNumaCache virDomainNumaCache;
-typedef virDomainNumaCache *virDomainNumaCachePtr;
typedef struct _virDomainNumaInterconnect virDomainNumaInterconnect;
-typedef virDomainNumaInterconnect *virDomainNumaInterconnectPtr;
typedef struct _virDomainNumaNode virDomainNumaNode;
-typedef virDomainNumaNode *virDomainNumaNodePtr;
struct _virDomainNuma {
struct {
bool specified;
- virBitmapPtr nodeset;
+ virBitmap *nodeset;
virDomainNumatuneMemMode mode;
virDomainNumatunePlacement placement;
} memory; /* pinning for all the memory */
struct _virDomainNumaNode {
unsigned long long mem; /* memory size in KiB */
- virBitmapPtr cpumask; /* bitmap of vCPUs corresponding to the node */
- virBitmapPtr nodeset; /* host memory nodes where this guest node resides */
+ virBitmap *cpumask; /* bitmap of vCPUs corresponding to the node */
+ virBitmap *nodeset; /* host memory nodes where this guest node resides */
virDomainNumatuneMemMode mode; /* memory mode selection */
virDomainMemoryAccess memAccess; /* shared memory access configuration */
virTristateBool discard; /* discard-data for memory-backend-file */
bool
-virDomainNumatuneNodeSpecified(virDomainNumaPtr numatune,
+virDomainNumatuneNodeSpecified(virDomainNuma *numatune,
int cellid)
{
if (numatune &&
}
static int
-virDomainNumatuneNodeParseXML(virDomainNumaPtr numa,
+virDomainNumatuneNodeParseXML(virDomainNuma *numa,
xmlXPathContextPtr ctxt)
{
char *tmp = NULL;
for (i = 0; i < n; i++) {
int mode = 0;
unsigned int cellid = 0;
- virDomainNumaNodePtr mem_node = NULL;
+ virDomainNumaNode *mem_node = NULL;
xmlNodePtr cur_node = nodes[i];
tmp = virXMLPropString(cur_node, "cellid");
}
int
-virDomainNumatuneParseXML(virDomainNumaPtr numa,
+virDomainNumatuneParseXML(virDomainNuma *numa,
bool placement_static,
xmlXPathContextPtr ctxt)
{
int n = 0;
int placement = -1;
int ret = -1;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
xmlNodePtr node = NULL;
if (virXPathInt("count(./numatune)", ctxt, &n) < 0) {
}
int
-virDomainNumatuneFormatXML(virBufferPtr buf,
- virDomainNumaPtr numatune)
+virDomainNumatuneFormatXML(virBuffer *buf,
+ virDomainNuma *numatune)
{
const char *tmp = NULL;
char *nodeset = NULL;
}
for (i = 0; i < numatune->nmem_nodes; i++) {
- virDomainNumaNodePtr mem_node = &numatune->mem_nodes[i];
+ virDomainNumaNode *mem_node = &numatune->mem_nodes[i];
if (!mem_node->nodeset)
continue;
}
void
-virDomainNumaFree(virDomainNumaPtr numa)
+virDomainNumaFree(virDomainNuma *numa)
{
size_t i = 0;
* Returns: 0 on success (with @mode updated)
* -1 if no mode was defined in XML
*/
-int virDomainNumatuneGetMode(virDomainNumaPtr numatune,
+int virDomainNumatuneGetMode(virDomainNuma *numatune,
int cellid,
virDomainNumatuneMemMode *mode)
{
return 0;
}
-virBitmapPtr
-virDomainNumatuneGetNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+virBitmap *
+virDomainNumatuneGetNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
int cellid)
{
if (!numatune)
}
char *
-virDomainNumatuneFormatNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+virDomainNumatuneFormatNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
int cellid)
{
return virBitmapFormat(virDomainNumatuneGetNodeset(numatune,
int
-virDomainNumatuneMaybeGetNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
- virBitmapPtr *retNodeset,
+virDomainNumatuneMaybeGetNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
+ virBitmap **retNodeset,
int cellid)
{
*retNodeset = NULL;
int
-virDomainNumatuneMaybeFormatNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+virDomainNumatuneMaybeFormatNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
char **mask,
int cellid)
{
- virBitmapPtr nodeset;
+ virBitmap *nodeset;
if (virDomainNumatuneMaybeGetNodeset(numatune, auto_nodeset, &nodeset,
cellid) < 0)
}
int
-virDomainNumatuneSet(virDomainNumaPtr numa,
+virDomainNumatuneSet(virDomainNuma *numa,
bool placement_static,
int placement,
int mode,
- virBitmapPtr nodeset)
+ virBitmap *nodeset)
{
/* No need to do anything in this case */
if (mode == -1 && placement == -1 && !nodeset)
}
static bool
-virDomainNumaNodesEqual(virDomainNumaPtr n1,
- virDomainNumaPtr n2)
+virDomainNumaNodesEqual(virDomainNuma *n1,
+ virDomainNuma *n2)
{
size_t i = 0;
return false;
for (i = 0; i < n1->nmem_nodes; i++) {
- virDomainNumaNodePtr nd1 = &n1->mem_nodes[i];
- virDomainNumaNodePtr nd2 = &n2->mem_nodes[i];
+ virDomainNumaNode *nd1 = &n1->mem_nodes[i];
+ virDomainNumaNode *nd2 = &n2->mem_nodes[i];
if (!nd1->nodeset && !nd2->nodeset)
continue;
}
bool
-virDomainNumaEquals(virDomainNumaPtr n1,
- virDomainNumaPtr n2)
+virDomainNumaEquals(virDomainNuma *n1,
+ virDomainNuma *n2)
{
if (!n1 && !n2)
return true;
}
bool
-virDomainNumatuneHasPlacementAuto(virDomainNumaPtr numatune)
+virDomainNumatuneHasPlacementAuto(virDomainNuma *numatune)
{
if (!numatune)
return false;
}
bool
-virDomainNumatuneHasPerNodeBinding(virDomainNumaPtr numatune)
+virDomainNumatuneHasPerNodeBinding(virDomainNuma *numatune)
{
size_t i = 0;
}
int
-virDomainNumatuneSpecifiedMaxNode(virDomainNumaPtr numatune)
+virDomainNumatuneSpecifiedMaxNode(virDomainNuma *numatune)
{
int ret = -1;
- virBitmapPtr nodemask = NULL;
+ virBitmap *nodemask = NULL;
size_t i;
int bit;
}
bool
-virDomainNumatuneNodesetIsAvailable(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset)
+virDomainNumatuneNodesetIsAvailable(virDomainNuma *numatune,
+ virBitmap *auto_nodeset)
{
size_t i = 0;
- virBitmapPtr b = NULL;
+ virBitmap *b = NULL;
if (!numatune)
return true;
static int
-virDomainNumaDefNodeDistanceParseXML(virDomainNumaPtr def,
+virDomainNumaDefNodeDistanceParseXML(virDomainNuma *def,
xmlXPathContextPtr ctxt,
unsigned int cur_cell)
{
}
for (i = 0; i < sibling; i++) {
- virDomainNumaDistancePtr ldist;
- virDomainNumaDistancePtr rdist;
+ virDomainNumaDistance *ldist;
+ virDomainNumaDistance *rdist;
unsigned int sibling_id, sibling_value;
/* siblings are in order of parsing or explicitly numbered */
static int
-virDomainNumaDefNodeCacheParseXML(virDomainNumaPtr def,
+virDomainNumaDefNodeCacheParseXML(virDomainNuma *def,
xmlXPathContextPtr ctxt,
unsigned int cur_cell)
{
for (i = 0; i < n; i++) {
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainNumaCachePtr cache = &def->mem_nodes[cur_cell].caches[i];
+ virDomainNumaCache *cache = &def->mem_nodes[cur_cell].caches[i];
g_autofree char *tmp = NULL;
unsigned int level;
int associativity;
int
-virDomainNumaDefParseXML(virDomainNumaPtr def,
+virDomainNumaDefParseXML(virDomainNuma *def,
xmlXPathContextPtr ctxt)
{
xmlNodePtr *nodes = NULL;
int
-virDomainNumaDefFormatXML(virBufferPtr buf,
- virDomainNumaPtr def)
+virDomainNumaDefFormatXML(virBuffer *buf,
+ virDomainNuma *def)
{
virDomainMemoryAccess memAccess;
virTristateBool discard;
virBufferAddLit(buf, "<numa>\n");
virBufferAdjustIndent(buf, 2);
for (i = 0; i < ncells; i++) {
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(def, i);
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(def, i);
int ndistances;
size_t ncaches;
virBufferAdjustIndent(buf, 2);
if (ndistances) {
- virDomainNumaDistancePtr distances = def->mem_nodes[i].distances;
+ virDomainNumaDistance *distances = def->mem_nodes[i].distances;
virBufferAddLit(buf, "<distances>\n");
virBufferAdjustIndent(buf, 2);
}
for (j = 0; j < ncaches; j++) {
- virDomainNumaCachePtr cache = &def->mem_nodes[i].caches[j];
+ virDomainNumaCache *cache = &def->mem_nodes[i].caches[j];
virBufferAsprintf(buf, "<cache level='%u'", cache->level);
if (cache->associativity) {
}
for (i = 0; i < def->ninterconnects; i++) {
- virDomainNumaInterconnectPtr l = &def->interconnects[i];
+ virDomainNumaInterconnect *l = &def->interconnects[i];
switch (l->type) {
case VIR_DOMAIN_NUMA_INTERCONNECT_TYPE_LATENCY:
unsigned int
-virDomainNumaGetCPUCountTotal(virDomainNumaPtr numa)
+virDomainNumaGetCPUCountTotal(virDomainNuma *numa)
{
size_t i;
unsigned int ret = 0;
for (i = 0; i < numa->nmem_nodes; i++) {
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(numa, i);
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(numa, i);
if (cpumask)
ret += virBitmapCountBits(cpumask);
}
unsigned int
-virDomainNumaGetMaxCPUID(virDomainNumaPtr numa)
+virDomainNumaGetMaxCPUID(virDomainNuma *numa)
{
size_t i;
unsigned int ret = 0;
for (i = 0; i < numa->nmem_nodes; i++) {
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(numa, i);
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(numa, i);
int bit;
if (cpumask) {
}
-virDomainNumaPtr
+virDomainNuma *
virDomainNumaNew(void)
{
return g_new0(virDomainNuma, 1);
bool
-virDomainNumaCheckABIStability(virDomainNumaPtr src,
- virDomainNumaPtr tgt)
+virDomainNumaCheckABIStability(virDomainNuma *src,
+ virDomainNuma *tgt)
{
size_t i;
size_t j;
size_t
-virDomainNumaGetNodeCount(virDomainNumaPtr numa)
+virDomainNumaGetNodeCount(virDomainNuma *numa)
{
if (!numa)
return 0;
size_t
-virDomainNumaSetNodeCount(virDomainNumaPtr numa, size_t nmem_nodes)
+virDomainNumaSetNodeCount(virDomainNuma *numa, size_t nmem_nodes)
{
if (!nmem_nodes) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
bool
-virDomainNumaNodeDistanceIsUsingDefaults(virDomainNumaPtr numa,
+virDomainNumaNodeDistanceIsUsingDefaults(virDomainNuma *numa,
size_t node,
size_t sibling)
{
bool
-virDomainNumaNodesDistancesAreBeingSet(virDomainNumaPtr numa)
+virDomainNumaNodesDistancesAreBeingSet(virDomainNuma *numa)
{
size_t ncells = virDomainNumaGetNodeCount(numa);
size_t i, j;
size_t
-virDomainNumaGetNodeDistance(virDomainNumaPtr numa,
+virDomainNumaGetNodeDistance(virDomainNuma *numa,
size_t node,
size_t cellid)
{
- virDomainNumaDistancePtr distances = NULL;
+ virDomainNumaDistance *distances = NULL;
if (node < numa->nmem_nodes)
distances = numa->mem_nodes[node].distances;
int
-virDomainNumaSetNodeDistance(virDomainNumaPtr numa,
+virDomainNumaSetNodeDistance(virDomainNuma *numa,
size_t node,
size_t cellid,
unsigned int value)
{
- virDomainNumaDistancePtr distances;
+ virDomainNumaDistance *distances;
if (node >= numa->nmem_nodes) {
virReportError(VIR_ERR_INTERNAL_ERROR,
size_t
-virDomainNumaSetNodeDistanceCount(virDomainNumaPtr numa,
+virDomainNumaSetNodeDistanceCount(virDomainNuma *numa,
size_t node,
size_t ndistances)
{
- virDomainNumaDistancePtr distances;
+ virDomainNumaDistance *distances;
distances = numa->mem_nodes[node].distances;
if (distances) {
}
-virBitmapPtr
-virDomainNumaGetNodeCpumask(virDomainNumaPtr numa,
+virBitmap *
+virDomainNumaGetNodeCpumask(virDomainNuma *numa,
size_t node)
{
return numa->mem_nodes[node].cpumask;
void
-virDomainNumaSetNodeCpumask(virDomainNumaPtr numa,
+virDomainNumaSetNodeCpumask(virDomainNuma *numa,
size_t node,
- virBitmapPtr cpumask)
+ virBitmap *cpumask)
{
numa->mem_nodes[node].cpumask = cpumask;
}
virDomainMemoryAccess
-virDomainNumaGetNodeMemoryAccessMode(virDomainNumaPtr numa,
+virDomainNumaGetNodeMemoryAccessMode(virDomainNuma *numa,
size_t node)
{
return numa->mem_nodes[node].memAccess;
virTristateBool
-virDomainNumaGetNodeDiscard(virDomainNumaPtr numa,
+virDomainNumaGetNodeDiscard(virDomainNuma *numa,
size_t node)
{
return numa->mem_nodes[node].discard;
unsigned long long
-virDomainNumaGetNodeMemorySize(virDomainNumaPtr numa,
+virDomainNumaGetNodeMemorySize(virDomainNuma *numa,
size_t node)
{
return numa->mem_nodes[node].mem;
void
-virDomainNumaSetNodeMemorySize(virDomainNumaPtr numa,
+virDomainNumaSetNodeMemorySize(virDomainNuma *numa,
size_t node,
unsigned long long size)
{
unsigned long long
-virDomainNumaGetMemorySize(virDomainNumaPtr numa)
+virDomainNumaGetMemorySize(virDomainNuma *numa)
{
size_t i;
unsigned long long ret = 0;
int
-virDomainNumaFillCPUsInNode(virDomainNumaPtr numa,
+virDomainNumaFillCPUsInNode(virDomainNuma *numa,
size_t node,
unsigned int maxCpus)
{
virBitmapSetAll(maxCPUsBitmap);
for (i = 0; i < numa->nmem_nodes; i++) {
- virBitmapPtr nodeCpus = virDomainNumaGetNodeCpumask(numa, i);
+ virBitmap *nodeCpus = virDomainNumaGetNodeCpumask(numa, i);
if (i == node || !nodeCpus)
continue;
typedef struct _virDomainNuma virDomainNuma;
-typedef virDomainNuma *virDomainNumaPtr;
typedef enum {
VIR_DOMAIN_NUMATUNE_PLACEMENT_DEFAULT = 0,
VIR_ENUM_DECL(virDomainMemoryLatency);
-virDomainNumaPtr virDomainNumaNew(void);
-void virDomainNumaFree(virDomainNumaPtr numa);
+virDomainNuma *virDomainNumaNew(void);
+void virDomainNumaFree(virDomainNuma *numa);
/*
* XML Parse/Format functions
*/
-int virDomainNumatuneParseXML(virDomainNumaPtr numa,
+int virDomainNumatuneParseXML(virDomainNuma *numa,
bool placement_static,
xmlXPathContextPtr ctxt)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
-int virDomainNumatuneFormatXML(virBufferPtr buf, virDomainNumaPtr numatune)
+int virDomainNumatuneFormatXML(virBuffer *buf, virDomainNuma *numatune)
ATTRIBUTE_NONNULL(1);
/*
* Getters
*/
-int virDomainNumatuneGetMode(virDomainNumaPtr numatune,
+int virDomainNumatuneGetMode(virDomainNuma *numatune,
int cellid,
virDomainNumatuneMemMode *mode);
-virBitmapPtr virDomainNumatuneGetNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+virBitmap *virDomainNumatuneGetNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
int cellid);
-int virDomainNumatuneMaybeGetNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
- virBitmapPtr *retNodeset,
+int virDomainNumatuneMaybeGetNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
+ virBitmap **retNodeset,
int cellid);
-size_t virDomainNumaGetNodeCount(virDomainNumaPtr numa);
+size_t virDomainNumaGetNodeCount(virDomainNuma *numa);
-bool virDomainNumaNodeDistanceIsUsingDefaults(virDomainNumaPtr numa,
+bool virDomainNumaNodeDistanceIsUsingDefaults(virDomainNuma *numa,
size_t node,
size_t sibling)
ATTRIBUTE_NONNULL(1);
-bool virDomainNumaNodesDistancesAreBeingSet(virDomainNumaPtr numa)
+bool virDomainNumaNodesDistancesAreBeingSet(virDomainNuma *numa)
ATTRIBUTE_NONNULL(1);
-size_t virDomainNumaGetNodeDistance(virDomainNumaPtr numa,
+size_t virDomainNumaGetNodeDistance(virDomainNuma *numa,
size_t node,
size_t sibling)
ATTRIBUTE_NONNULL(1);
-virBitmapPtr virDomainNumaGetNodeCpumask(virDomainNumaPtr numa,
+virBitmap *virDomainNumaGetNodeCpumask(virDomainNuma *numa,
size_t node)
ATTRIBUTE_NONNULL(1);
-virDomainMemoryAccess virDomainNumaGetNodeMemoryAccessMode(virDomainNumaPtr numa,
+virDomainMemoryAccess virDomainNumaGetNodeMemoryAccessMode(virDomainNuma *numa,
size_t node)
ATTRIBUTE_NONNULL(1);
-virTristateBool virDomainNumaGetNodeDiscard(virDomainNumaPtr numa,
+virTristateBool virDomainNumaGetNodeDiscard(virDomainNuma *numa,
size_t node)
ATTRIBUTE_NONNULL(1);
-unsigned long long virDomainNumaGetNodeMemorySize(virDomainNumaPtr numa,
+unsigned long long virDomainNumaGetNodeMemorySize(virDomainNuma *numa,
size_t node)
ATTRIBUTE_NONNULL(1);
-unsigned long long virDomainNumaGetMemorySize(virDomainNumaPtr numa)
+unsigned long long virDomainNumaGetMemorySize(virDomainNuma *numa)
ATTRIBUTE_NONNULL(1);
unsigned int
-virDomainNumaGetMaxCPUID(virDomainNumaPtr numa);
+virDomainNumaGetMaxCPUID(virDomainNuma *numa);
/*
* Formatters
*/
-char *virDomainNumatuneFormatNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+char *virDomainNumatuneFormatNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
int cellid);
-int virDomainNumatuneMaybeFormatNodeset(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset,
+int virDomainNumatuneMaybeFormatNodeset(virDomainNuma *numatune,
+ virBitmap *auto_nodeset,
char **mask,
int cellid);
/*
* Setters
*/
-int virDomainNumatuneSet(virDomainNumaPtr numa,
+int virDomainNumatuneSet(virDomainNuma *numa,
bool placement_static,
int placement,
int mode,
- virBitmapPtr nodeset)
+ virBitmap *nodeset)
ATTRIBUTE_NONNULL(1);
-size_t virDomainNumaSetNodeCount(virDomainNumaPtr numa,
+size_t virDomainNumaSetNodeCount(virDomainNuma *numa,
size_t nmem_nodes)
ATTRIBUTE_NONNULL(1);
-void virDomainNumaSetNodeMemorySize(virDomainNumaPtr numa,
+void virDomainNumaSetNodeMemorySize(virDomainNuma *numa,
size_t node,
unsigned long long size)
ATTRIBUTE_NONNULL(1);
-int virDomainNumaSetNodeDistance(virDomainNumaPtr numa,
+int virDomainNumaSetNodeDistance(virDomainNuma *numa,
size_t node,
size_t sibling,
unsigned int value)
ATTRIBUTE_NONNULL(1);
-size_t virDomainNumaSetNodeDistanceCount(virDomainNumaPtr numa,
+size_t virDomainNumaSetNodeDistanceCount(virDomainNuma *numa,
size_t node,
size_t ndistances)
ATTRIBUTE_NONNULL(1);
-void virDomainNumaSetNodeCpumask(virDomainNumaPtr numa,
+void virDomainNumaSetNodeCpumask(virDomainNuma *numa,
size_t node,
- virBitmapPtr cpumask)
+ virBitmap *cpumask)
ATTRIBUTE_NONNULL(1);
/*
* Other accessors
*/
-bool virDomainNumaEquals(virDomainNumaPtr n1,
- virDomainNumaPtr n2);
+bool virDomainNumaEquals(virDomainNuma *n1,
+ virDomainNuma *n2);
-bool virDomainNumaCheckABIStability(virDomainNumaPtr src,
- virDomainNumaPtr tgt);
+bool virDomainNumaCheckABIStability(virDomainNuma *src,
+ virDomainNuma *tgt);
-bool virDomainNumatuneHasPlacementAuto(virDomainNumaPtr numatune);
+bool virDomainNumatuneHasPlacementAuto(virDomainNuma *numatune);
-bool virDomainNumatuneHasPerNodeBinding(virDomainNumaPtr numatune);
+bool virDomainNumatuneHasPerNodeBinding(virDomainNuma *numatune);
-int virDomainNumatuneSpecifiedMaxNode(virDomainNumaPtr numatune);
+int virDomainNumatuneSpecifiedMaxNode(virDomainNuma *numatune);
-bool virDomainNumatuneNodesetIsAvailable(virDomainNumaPtr numatune,
- virBitmapPtr auto_nodeset);
+bool virDomainNumatuneNodesetIsAvailable(virDomainNuma *numatune,
+ virBitmap *auto_nodeset);
-bool virDomainNumatuneNodeSpecified(virDomainNumaPtr numatune,
+bool virDomainNumatuneNodeSpecified(virDomainNuma *numatune,
int cellid);
-int virDomainNumaDefParseXML(virDomainNumaPtr def, xmlXPathContextPtr ctxt);
-int virDomainNumaDefFormatXML(virBufferPtr buf, virDomainNumaPtr def);
+int virDomainNumaDefParseXML(virDomainNuma *def, xmlXPathContextPtr ctxt);
+int virDomainNumaDefFormatXML(virBuffer *buf, virDomainNuma *def);
int virDomainNumaDefValidate(const virDomainNuma *def);
-unsigned int virDomainNumaGetCPUCountTotal(virDomainNumaPtr numa);
+unsigned int virDomainNumaGetCPUCountTotal(virDomainNuma *numa);
-int virDomainNumaFillCPUsInNode(virDomainNumaPtr numa, size_t node,
+int virDomainNumaFillCPUsInNode(virDomainNuma *numa, size_t node,
unsigned int maxCpus);
bool virDomainNumaHasHMAT(const virDomainNuma *numa);
void
-virNWFilterRuleDefFree(virNWFilterRuleDefPtr def)
+virNWFilterRuleDefFree(virNWFilterRuleDef *def)
{
size_t i;
if (!def)
static void
-virNWFilterIncludeDefFree(virNWFilterIncludeDefPtr inc)
+virNWFilterIncludeDefFree(virNWFilterIncludeDef *inc)
{
if (!inc)
return;
static void
-virNWFilterEntryFree(virNWFilterEntryPtr entry)
+virNWFilterEntryFree(virNWFilterEntry *entry)
{
if (!entry)
return;
void
-virNWFilterDefFree(virNWFilterDefPtr def)
+virNWFilterDefFree(virNWFilterDef *def)
{
size_t i;
if (!def)
static int
-virNWFilterRuleDefAddVar(virNWFilterRuleDefPtr nwf,
+virNWFilterRuleDefAddVar(virNWFilterRuleDef *nwf,
nwItemDesc *item,
const char *var)
{
size_t i = 0;
- virNWFilterVarAccessPtr varAccess;
+ virNWFilterVarAccess *varAccess;
varAccess = virNWFilterVarAccessParse(var);
if (varAccess == NULL)
static char *
-virNWFilterRuleDefAddString(virNWFilterRuleDefPtr nwf,
+virNWFilterRuleDefAddString(virNWFilterRuleDef *nwf,
const char *string,
size_t maxstrlen)
{
};
typedef bool (*valueValidator)(enum attrDatatype datatype, union data *valptr,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item);
-typedef bool (*valueFormatter)(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf,
+typedef bool (*valueFormatter)(virBuffer *buf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item);
typedef struct _virXMLAttr2Struct virXMLAttr2Struct;
static bool
checkMacProtocolID(enum attrDatatype datatype,
union data *value,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item G_GNUC_UNUSED)
{
int32_t res = -1;
static bool
-macProtocolIDFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf,
+macProtocolIDFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
const char *str = NULL;
static bool
checkVlanVlanID(enum attrDatatype datatype,
union data *value,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
int32_t res;
static bool
checkVlanProtocolID(enum attrDatatype datatype,
union data *value,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
int32_t res = -1;
static bool
-vlanProtocolIDFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf,
+vlanProtocolIDFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
const char *str = NULL;
static bool
checkMACMask(enum attrDatatype datatype G_GNUC_UNUSED,
union data *macMask,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item G_GNUC_UNUSED)
{
return checkValidMask(macMask->uc, 6);
static bool
arpOpcodeValidator(enum attrDatatype datatype,
union data *value,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
int32_t res = -1;
static bool
-arpOpcodeFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf,
+arpOpcodeFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
const char *str = NULL;
static bool
checkIPProtocolID(enum attrDatatype datatype,
union data *value,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
int32_t res = -1;
static bool
-formatIPProtocolID(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf,
+formatIPProtocolID(virBuffer *buf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
const char *str = NULL;
static bool
dscpValidator(enum attrDatatype datatype,
union data *val,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item G_GNUC_UNUSED)
{
uint8_t dscp = val->ui;
static int
-printStringItems(virBufferPtr buf,
+printStringItems(virBuffer *buf,
const struct int_map *int_map,
int32_t flags,
const char *sep)
void
-virNWFilterPrintStateMatchFlags(virBufferPtr buf,
+virNWFilterPrintStateMatchFlags(virBuffer *buf,
const char *prefix,
int32_t flags,
bool disp_none)
static bool
stateValidator(enum attrDatatype datatype G_GNUC_UNUSED,
union data *val,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
nwItemDesc *item)
{
char *input = val->c;
static bool
-stateFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+stateFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
virNWFilterPrintStateMatchFlags(buf, "", item->u.u16, true);
static bool
tcpFlagsValidator(enum attrDatatype datatype G_GNUC_UNUSED,
union data *val,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
bool rc = false;
static void
-printTCPFlags(virBufferPtr buf,
+printTCPFlags(virBuffer *buf,
uint8_t flags)
{
if (flags == 0)
static bool
-tcpFlagsFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+tcpFlagsFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
printTCPFlags(buf, item->u.tcpFlags.mask);
static bool
ipsetValidator(enum attrDatatype datatype G_GNUC_UNUSED,
union data *val,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
const char *errmsg = NULL;
static bool
-ipsetFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ipsetFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
virBufferAdd(buf, item->u.ipset.setname, -1);
static bool
ipsetFlagsValidator(enum attrDatatype datatype G_GNUC_UNUSED,
union data *val,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
const char *errmsg = NULL;
static bool
-ipsetFlagsFormatter(virBufferPtr buf,
- virNWFilterRuleDefPtr nwf G_GNUC_UNUSED,
+ipsetFlagsFormatter(virBuffer *buf,
+ virNWFilterRuleDef *nwf G_GNUC_UNUSED,
nwItemDesc *item)
{
uint8_t ctr;
static int
virNWFilterRuleDetailsParse(xmlNodePtr node,
- virNWFilterRuleDefPtr nwf,
+ virNWFilterRuleDef *nwf,
const virXMLAttr2Struct *att)
{
int rc = 0, g_rc = 0;
}
-static virNWFilterIncludeDefPtr
+static virNWFilterIncludeDef *
virNWFilterIncludeParse(xmlNodePtr cur)
{
- virNWFilterIncludeDefPtr ret;
+ virNWFilterIncludeDef *ret;
ret = g_new0(virNWFilterIncludeDef, 1);
static void
-virNWFilterRuleDefFixupIPSet(ipHdrDataDefPtr ipHdr)
+virNWFilterRuleDefFixupIPSet(ipHdrDataDef *ipHdr)
{
if (HAS_ENTRY_ITEM(&ipHdr->dataIPSet) &&
!HAS_ENTRY_ITEM(&ipHdr->dataIPSetFlags)) {
* defined that cannot be instantiated.
*/
static int
-virNWFilterRuleValidate(virNWFilterRuleDefPtr rule)
+virNWFilterRuleValidate(virNWFilterRuleDef *rule)
{
int ret = 0;
- portDataDefPtr portData = NULL;
- nwItemDescPtr dataProtocolID = NULL;
+ portDataDef *portData = NULL;
+ nwItemDesc *dataProtocolID = NULL;
const char *protocol = NULL;
switch (rule->prtclType) {
static void
-virNWFilterRuleDefFixup(virNWFilterRuleDefPtr rule)
+virNWFilterRuleDefFixup(virNWFilterRuleDef *rule)
{
#define COPY_NEG_SIGN(A, B) \
(A).flags = ((A).flags & ~NWFILTER_ENTRY_ITEM_FLAG_IS_NEG) | \
}
-static virNWFilterRuleDefPtr
+static virNWFilterRuleDef *
virNWFilterRuleParse(xmlNodePtr node)
{
char *action;
int priority;
xmlNodePtr cur;
- virNWFilterRuleDefPtr ret;
+ virNWFilterRuleDef *ret;
ret = g_new0(virNWFilterRuleDef, 1);
}
-static virNWFilterDefPtr
+static virNWFilterDef *
virNWFilterDefParseXML(xmlXPathContextPtr ctxt)
{
- virNWFilterDefPtr ret;
+ virNWFilterDef *ret;
xmlNodePtr curr = ctxt->node;
char *uuid = NULL;
char *chain = NULL;
char *chain_pri_s = NULL;
- virNWFilterEntryPtr entry;
+ virNWFilterEntry *entry;
int chain_priority;
const char *name_prefix;
}
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseNode(xmlDocPtr xml,
xmlNodePtr root)
{
}
-static virNWFilterDefPtr
+static virNWFilterDef *
virNWFilterDefParse(const char *xmlStr,
const char *filename)
{
- virNWFilterDefPtr def = NULL;
+ virNWFilterDef *def = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilter_definition)")))) {
}
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseString(const char *xmlStr)
{
return virNWFilterDefParse(xmlStr, NULL);
}
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseFile(const char *filename)
{
return virNWFilterDefParse(NULL, filename);
int
virNWFilterSaveConfig(const char *configDir,
- virNWFilterDefPtr def)
+ virNWFilterDef *def)
{
int ret = -1;
char *xml;
int
virNWFilterDeleteDef(const char *configDir,
- virNWFilterDefPtr def)
+ virNWFilterDef *def)
{
int ret = -1;
char *configFile = NULL;
static void
-virNWIPAddressFormat(virBufferPtr buf,
- virSocketAddrPtr ipaddr)
+virNWIPAddressFormat(virBuffer *buf,
+ virSocketAddr *ipaddr)
{
char *output = virSocketAddrFormat(ipaddr);
static void
-virNWFilterRuleDefDetailsFormat(virBufferPtr buf,
+virNWFilterRuleDefDetailsFormat(virBuffer *buf,
const char *type,
const virXMLAttr2Struct *att,
- virNWFilterRuleDefPtr def)
+ virNWFilterRuleDef *def)
{
size_t i = 0, j;
bool typeShown = false;
static int
-virNWFilterRuleDefFormat(virBufferPtr buf,
- virNWFilterRuleDefPtr def)
+virNWFilterRuleDefFormat(virBuffer *buf,
+ virNWFilterRuleDef *def)
{
size_t i;
bool subelement = false;
static int
-virNWFilterEntryFormat(virBufferPtr buf,
- virNWFilterEntryPtr entry)
+virNWFilterEntryFormat(virBuffer *buf,
+ virNWFilterEntry *entry)
{
if (entry->rule)
return virNWFilterRuleDefFormat(buf, entry->rule);
bool
-virNWFilterRuleIsProtocolIPv4(virNWFilterRuleDefPtr rule)
+virNWFilterRuleIsProtocolIPv4(virNWFilterRuleDef *rule)
{
if (rule->prtclType >= VIR_NWFILTER_RULE_PROTOCOL_TCP &&
rule->prtclType <= VIR_NWFILTER_RULE_PROTOCOL_ALL)
bool
-virNWFilterRuleIsProtocolIPv6(virNWFilterRuleDefPtr rule)
+virNWFilterRuleIsProtocolIPv6(virNWFilterRuleDef *rule)
{
if (rule->prtclType >= VIR_NWFILTER_RULE_PROTOCOL_TCPoIPV6 &&
rule->prtclType <= VIR_NWFILTER_RULE_PROTOCOL_ALLoIPV6)
bool
-virNWFilterRuleIsProtocolEthernet(virNWFilterRuleDefPtr rule)
+virNWFilterRuleIsProtocolEthernet(virNWFilterRuleDef *rule)
{
if (rule->prtclType <= VIR_NWFILTER_RULE_PROTOCOL_IPV6)
return true;
typedef struct _nwItemDesc nwItemDesc;
-typedef nwItemDesc *nwItemDescPtr;
struct _nwItemDesc {
virNWFilterEntryItemFlags flags;
- virNWFilterVarAccessPtr varAccess;
+ virNWFilterVarAccess *varAccess;
enum attrDatatype datatype;
union {
virMacAddr macaddr;
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.:-+ "
typedef struct _ethHdrDataDef ethHdrDataDef;
-typedef ethHdrDataDef *ethHdrDataDefPtr;
struct _ethHdrDataDef {
nwItemDesc dataSrcMACAddr;
nwItemDesc dataSrcMACMask;
typedef struct _ethHdrFilterDef ethHdrFilterDef;
-typedef ethHdrFilterDef *ethHdrFilterDefPtr;
struct _ethHdrFilterDef {
ethHdrDataDef ethHdr;
nwItemDesc dataProtocolID;
typedef struct _vlanHdrFilterDef vlanHdrFilterDef;
-typedef vlanHdrFilterDef *vlanHdrFilterDefPtr;
struct _vlanHdrFilterDef {
ethHdrDataDef ethHdr;
nwItemDesc dataVlanID;
typedef struct _stpHdrFilterDef stpHdrFilterDef;
-typedef stpHdrFilterDef *stpHdrFilterDefPtr;
struct _stpHdrFilterDef {
ethHdrDataDef ethHdr;
nwItemDesc dataType;
typedef struct _arpHdrFilterDef arpHdrFilterDef;
-typedef arpHdrFilterDef *arpHdrFilterDefPtr;
struct _arpHdrFilterDef {
ethHdrDataDef ethHdr;
nwItemDesc dataHWType;
typedef struct _ipHdrDataDef ipHdrDataDef;
-typedef ipHdrDataDef *ipHdrDataDefPtr;
struct _ipHdrDataDef {
nwItemDesc dataIPVersion;
nwItemDesc dataSrcIPAddr;
typedef struct _portDataDef portDataDef;
-typedef portDataDef *portDataDefPtr;
struct _portDataDef {
nwItemDesc dataSrcPortStart;
nwItemDesc dataSrcPortEnd;
typedef struct _ipHdrFilterDef ipHdrFilterDef;
-typedef ipHdrFilterDef *ipHdrFilterDefPtr;
struct _ipHdrFilterDef {
ethHdrDataDef ethHdr;
ipHdrDataDef ipHdr;
typedef struct _ipv6HdrFilterDef ipv6HdrFilterDef;
-typedef ipv6HdrFilterDef *ipv6HdrFilterDefPtr;
struct _ipv6HdrFilterDef {
ethHdrDataDef ethHdr;
ipHdrDataDef ipHdr;
typedef struct _icmpHdrFilterDef icmpHdrFilterDef;
-typedef icmpHdrFilterDef *icmpHdrFilterDefPtr;
struct _icmpHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _allHdrFilterDef allHdrFilterDef;
-typedef allHdrFilterDef *allHdrFilterDefPtr;
struct _allHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _igmpHdrFilterDef igmpHdrFilterDef;
-typedef igmpHdrFilterDef *igmpHdrFilterDefPtr;
struct _igmpHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _tcpHdrFilterDef tcpHdrFilterDef;
-typedef tcpHdrFilterDef *tcpHdrFilterDefPtr;
struct _tcpHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _udpHdrFilterDef udpHdrFilterDef;
-typedef udpHdrFilterDef *udpHdrFilterDefPtr;
struct _udpHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _sctpHdrFilterDef sctpHdrFilterDef;
-typedef sctpHdrFilterDef *sctpHdrFilterDefPtr;
struct _sctpHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _espHdrFilterDef espHdrFilterDef;
-typedef espHdrFilterDef *espHdrFilterDefPtr;
struct _espHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _ahHdrFilterDef ahHdrFilterDef;
-typedef ahHdrFilterDef *ahHdrFilterDefPtr;
struct _ahHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
typedef struct _udpliteHdrFilterDef udpliteHdrFilterDef;
-typedef udpliteHdrFilterDef *udpliteHdrFilterDefPtr;
struct _udpliteHdrFilterDef {
nwItemDesc dataSrcMACAddr;
ipHdrDataDef ipHdr;
RULE_FLAG_STATE_INVALID | \
RULE_FLAG_STATE_NONE)
-void virNWFilterPrintStateMatchFlags(virBufferPtr buf, const char *prefix,
+void virNWFilterPrintStateMatchFlags(virBuffer *buf, const char *prefix,
int32_t flags, bool disp_none);
typedef int32_t virNWFilterRulePriority;
typedef struct _virNWFilterRuleDef virNWFilterRuleDef;
-typedef virNWFilterRuleDef *virNWFilterRuleDefPtr;
struct _virNWFilterRuleDef {
virNWFilterRulePriority priority;
virNWFilterRuleFlags flags;
} p;
size_t nVarAccess;
- virNWFilterVarAccessPtr *varAccess;
+ virNWFilterVarAccess **varAccess;
size_t nstrings;
char **strings;
typedef struct _virNWFilterIncludeDef virNWFilterIncludeDef;
-typedef virNWFilterIncludeDef *virNWFilterIncludeDefPtr;
struct _virNWFilterIncludeDef {
char *filterref;
GHashTable *params;
typedef struct _virNWFilterEntry virNWFilterEntry;
-typedef virNWFilterEntry *virNWFilterEntryPtr;
struct _virNWFilterEntry {
virNWFilterRuleDef *rule;
virNWFilterIncludeDef *include;
typedef int32_t virNWFilterChainPriority;
typedef struct _virNWFilterDef virNWFilterDef;
-typedef virNWFilterDef *virNWFilterDefPtr;
-
struct _virNWFilterDef {
char *name;
unsigned char uuid[VIR_UUID_BUFLEN];
virNWFilterChainPriority chainPriority;
size_t nentries;
- virNWFilterEntryPtr *filterEntries;
+ virNWFilterEntry **filterEntries;
};
void
-virNWFilterRuleDefFree(virNWFilterRuleDefPtr def);
+virNWFilterRuleDefFree(virNWFilterRuleDef *def);
void
-virNWFilterDefFree(virNWFilterDefPtr def);
+virNWFilterDefFree(virNWFilterDef *def);
int
virNWFilterTriggerRebuild(void);
int
virNWFilterDeleteDef(const char *configDir,
- virNWFilterDefPtr def);
+ virNWFilterDef *def);
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseNode(xmlDocPtr xml,
xmlNodePtr root);
int
virNWFilterSaveConfig(const char *configDir,
- virNWFilterDefPtr def);
+ virNWFilterDef *def);
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseString(const char *xml);
-virNWFilterDefPtr
+virNWFilterDef *
virNWFilterDefParseFile(const char *filename);
void
virNWFilterPrintTCPFlags(uint8_t flags);
bool
-virNWFilterRuleIsProtocolIPv4(virNWFilterRuleDefPtr rule);
+virNWFilterRuleIsProtocolIPv4(virNWFilterRuleDef *rule);
bool
-virNWFilterRuleIsProtocolIPv6(virNWFilterRuleDefPtr rule);
+virNWFilterRuleIsProtocolIPv6(virNWFilterRuleDef *rule);
bool
-virNWFilterRuleIsProtocolEthernet(virNWFilterRuleDefPtr rule);
+virNWFilterRuleIsProtocolEthernet(virNWFilterRuleDef *rule);
VIR_ENUM_DECL(virNWFilterRuleAction);
{
int ret = -1;
char *addrCopy;
- virNWFilterVarValuePtr val;
+ virNWFilterVarValue *val;
addrCopy = g_strdup(addr);
virNWFilterIPAddrMapDelIPAddr(const char *ifname, const char *ipaddr)
{
int ret = -1;
- virNWFilterVarValuePtr val = NULL;
+ virNWFilterVarValue *val = NULL;
virMutexLock(&ipAddressMapLock);
/* Get the list of IP addresses known to be in use by an interface
*
* This function returns NULL in case no IP address is known to be
- * associated with the interface, a virNWFilterVarValuePtr otherwise
+ * associated with the interface, a virNWFilterVarValue *otherwise
* that then can contain one or multiple entries.
*/
-virNWFilterVarValuePtr
+virNWFilterVarValue *
virNWFilterIPAddrMapGetIPAddr(const char *ifname)
{
- virNWFilterVarValuePtr res;
+ virNWFilterVarValue *res;
virMutexLock(&ipAddressMapLock);
int virNWFilterIPAddrMapAddIPAddr(const char *ifname, char *addr);
int virNWFilterIPAddrMapDelIPAddr(const char *ifname,
const char *ipaddr);
-virNWFilterVarValuePtr virNWFilterIPAddrMapGetIPAddr(const char *ifname);
+virNWFilterVarValue *virNWFilterIPAddrMapGetIPAddr(const char *ifname);
VIR_LOG_INIT("conf.nwfilter_params");
static bool isValidVarValue(const char *value);
-static void virNWFilterVarAccessSetIntIterId(virNWFilterVarAccessPtr,
+static void virNWFilterVarAccessSetIntIterId(virNWFilterVarAccess *,
unsigned int);
static unsigned int virNWFilterVarAccessGetIntIterId(const virNWFilterVarAccess *);
void
-virNWFilterVarValueFree(virNWFilterVarValuePtr val)
+virNWFilterVarValueFree(virNWFilterVarValue *val)
{
size_t i;
g_free(val);
}
-virNWFilterVarValuePtr
+virNWFilterVarValue *
virNWFilterVarValueCopy(const virNWFilterVarValue *val)
{
- virNWFilterVarValuePtr res;
+ virNWFilterVarValue *res;
size_t i;
char *str;
return res;
}
-virNWFilterVarValuePtr
+virNWFilterVarValue *
virNWFilterVarValueCreateSimple(char *value)
{
- virNWFilterVarValuePtr val;
+ virNWFilterVarValue *val;
if (!isValidVarValue(value)) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
return val;
}
-virNWFilterVarValuePtr
+virNWFilterVarValue *
virNWFilterVarValueCreateSimpleCopyValue(const char *value)
{
char *val;
- virNWFilterVarValuePtr ret;
+ virNWFilterVarValue *ret;
val = g_strdup(value);
ret = virNWFilterVarValueCreateSimple(val);
}
int
-virNWFilterVarValueAddValue(virNWFilterVarValuePtr val, char *value)
+virNWFilterVarValueAddValue(virNWFilterVarValue *val, char *value)
{
char *tmp;
int rc = -1;
int
-virNWFilterVarValueAddValueCopy(virNWFilterVarValuePtr val, const char *value)
+virNWFilterVarValueAddValueCopy(virNWFilterVarValue *val, const char *value)
{
char *valdup;
valdup = g_strdup(value);
static int
-virNWFilterVarValueDelNthValue(virNWFilterVarValuePtr val, unsigned int pos)
+virNWFilterVarValueDelNthValue(virNWFilterVarValue *val, unsigned int pos)
{
switch (val->valType) {
case NWFILTER_VALUE_TYPE_SIMPLE:
}
int
-virNWFilterVarValueDelValue(virNWFilterVarValuePtr val, const char *value)
+virNWFilterVarValueDelValue(virNWFilterVarValue *val, const char *value)
{
size_t i;
}
void
-virNWFilterVarCombIterFree(virNWFilterVarCombIterPtr ci)
+virNWFilterVarCombIterFree(virNWFilterVarCombIter *ci)
{
size_t i;
}
static int
-virNWFilterVarCombIterGetIndexByIterId(virNWFilterVarCombIterPtr ci,
+virNWFilterVarCombIterGetIndexByIterId(virNWFilterVarCombIter *ci,
unsigned int iterId)
{
size_t i;
}
static void
-virNWFilterVarCombIterEntryInit(virNWFilterVarCombIterEntryPtr cie,
+virNWFilterVarCombIterEntryInit(virNWFilterVarCombIterEntry *cie,
unsigned int iterId)
{
memset(cie, 0, sizeof(*cie));
}
static int
-virNWFilterVarCombIterAddVariable(virNWFilterVarCombIterEntryPtr cie,
+virNWFilterVarCombIterAddVariable(virNWFilterVarCombIterEntry *cie,
GHashTable *hash,
const virNWFilterVarAccess *varAccess)
{
- virNWFilterVarValuePtr varValue;
+ virNWFilterVarValue *varValue;
unsigned int maxValue = 0, minValue = 0;
const char *varName = virNWFilterVarAccessGetVarName(varAccess);
* skip them since this pair has already been encountered in the 1st iteration
*/
static bool
-virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntryPtr cie,
+virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntry *cie,
GHashTable *hash)
{
size_t i, j;
- virNWFilterVarValuePtr varValue;
- virNWFilterVarValuePtr tmp;
+ virNWFilterVarValue *varValue;
+ virNWFilterVarValue *tmp;
const char *value;
varValue = virHashLookup(hash, cie->varNames[0]);
* which then would cause all combinations of the items of the two lists to
* be created.
*/
-virNWFilterVarCombIterPtr
+virNWFilterVarCombIter *
virNWFilterVarCombIterCreate(GHashTable *hash,
- virNWFilterVarAccessPtr *varAccess,
+ virNWFilterVarAccess **varAccess,
size_t nVarAccess)
{
- virNWFilterVarCombIterPtr res;
+ virNWFilterVarCombIter *res;
size_t i;
unsigned int iterId;
int iterIndex = -1;
return NULL;
}
-virNWFilterVarCombIterPtr
-virNWFilterVarCombIterNext(virNWFilterVarCombIterPtr ci)
+virNWFilterVarCombIter *
+virNWFilterVarCombIterNext(virNWFilterVarCombIter *ci)
{
size_t i;
}
const char *
-virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIterPtr ci,
+virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIter *ci,
const virNWFilterVarAccess *vap)
{
size_t i;
unsigned int iterId;
bool found = false;
const char *res = NULL;
- virNWFilterVarValuePtr value;
+ virNWFilterVarValue *value;
int iterIndex = -1;
const char *varName = virNWFilterVarAccessGetVarName(vap);
addToTable(void *payload, const char *name, void *data)
{
struct addToTableStruct *atts = (struct addToTableStruct *)data;
- virNWFilterVarValuePtr val;
+ virNWFilterVarValue *val;
if (atts->errOccurred)
return 0;
- val = virNWFilterVarValueCopy((virNWFilterVarValuePtr)payload);
+ val = virNWFilterVarValueCopy((virNWFilterVarValue *)payload);
if (!val) {
atts->errOccurred = 1;
return 0;
return (value[strspn(value, VALID_VARVALUE)] == 0) && (strlen(value) != 0);
}
-static virNWFilterVarValuePtr
+static virNWFilterVarValue *
virNWFilterParseVarValue(const char *val)
{
return virNWFilterVarValueCreateSimpleCopyValue(val);
virNWFilterParseParamAttributes(xmlNodePtr cur)
{
char *nam, *val;
- virNWFilterVarValuePtr value;
+ virNWFilterVarValue *value;
GHashTable *table = virHashNew(virNWFilterVarValueHashFree);
if (!table)
int
-virNWFilterFormatParamAttributes(virBufferPtr buf,
+virNWFilterFormatParamAttributes(virBuffer *buf,
GHashTable *table,
const char *filterref)
{
- virHashKeyValuePairPtr items;
+ virHashKeyValuePair *items;
size_t i, j;
int card, numKeys;
}
void
-virNWFilterVarAccessFree(virNWFilterVarAccessPtr varAccess)
+virNWFilterVarAccessFree(virNWFilterVarAccess *varAccess)
{
if (!varAccess)
return;
* Parse a variable access like
* IP, IP[@2], IP[3]
*/
-virNWFilterVarAccessPtr
+virNWFilterVarAccess *
virNWFilterVarAccessParse(const char *varAccess)
{
size_t idx, varNameLen;
- virNWFilterVarAccessPtr dest;
+ virNWFilterVarAccess *dest;
const char *input = varAccess;
dest = g_new0(virNWFilterVarAccess, 1);
}
void
-virNWFilterVarAccessPrint(virNWFilterVarAccessPtr vap, virBufferPtr buf)
+virNWFilterVarAccessPrint(virNWFilterVarAccess *vap, virBuffer *buf)
{
virBufferAdd(buf, vap->varName, -1);
switch (vap->accessType) {
}
static void
-virNWFilterVarAccessSetIntIterId(virNWFilterVarAccessPtr vap,
+virNWFilterVarAccessSetIntIterId(virNWFilterVarAccess *vap,
unsigned int intIterId)
{
vap->u.index.intIterId = intIterId;
const char *varName = virNWFilterVarAccessGetVarName(varAccess);
const char *res;
unsigned int idx;
- virNWFilterVarValuePtr varValue;
+ virNWFilterVarValue *varValue;
varValue = virHashLookup(hash, varName);
if (!varValue)
} virNWFilterVarValueType;
typedef struct _virNWFilterVarValue virNWFilterVarValue;
-typedef virNWFilterVarValue *virNWFilterVarValuePtr;
struct _virNWFilterVarValue {
virNWFilterVarValueType valType;
union {
} u;
};
-virNWFilterVarValuePtr virNWFilterVarValueCreateSimple(char *);
-virNWFilterVarValuePtr virNWFilterVarValueCreateSimpleCopyValue(const char *);
-virNWFilterVarValuePtr virNWFilterVarValueCopy(const virNWFilterVarValue *);
-void virNWFilterVarValueFree(virNWFilterVarValuePtr val);
+virNWFilterVarValue *virNWFilterVarValueCreateSimple(char *);
+virNWFilterVarValue *virNWFilterVarValueCreateSimpleCopyValue(const char *);
+virNWFilterVarValue *virNWFilterVarValueCopy(const virNWFilterVarValue *);
+void virNWFilterVarValueFree(virNWFilterVarValue *val);
void virNWFilterVarValueHashFree(void *payload);
const char *virNWFilterVarValueGetSimple(const virNWFilterVarValue *val);
const char *virNWFilterVarValueGetNthValue(const virNWFilterVarValue *val,
unsigned int virNWFilterVarValueGetCardinality(const virNWFilterVarValue *);
bool virNWFilterVarValueEqual(const virNWFilterVarValue *a,
const virNWFilterVarValue *b);
-int virNWFilterVarValueAddValue(virNWFilterVarValuePtr val, char *value);
-int virNWFilterVarValueAddValueCopy(virNWFilterVarValuePtr val, const char *value);
-int virNWFilterVarValueDelValue(virNWFilterVarValuePtr val, const char *value);
+int virNWFilterVarValueAddValue(virNWFilterVarValue *val, char *value);
+int virNWFilterVarValueAddValueCopy(virNWFilterVarValue *val, const char *value);
+int virNWFilterVarValueDelValue(virNWFilterVarValue *val, const char *value);
GHashTable *virNWFilterParseParamAttributes(xmlNodePtr cur);
-int virNWFilterFormatParamAttributes(virBufferPtr buf,
+int virNWFilterFormatParamAttributes(virBuffer *buf,
GHashTable *table,
const char *filterref);
} virNWFilterVarAccessType;
typedef struct _virNWFilterVarAccess virNWFilterVarAccess;
-typedef virNWFilterVarAccess *virNWFilterVarAccessPtr;
struct _virNWFilterVarAccess {
virNWFilterVarAccessType accessType;
union {
#define VIR_NWFILTER_MAX_ITERID 1000
-void virNWFilterVarAccessFree(virNWFilterVarAccessPtr varAccess);
+void virNWFilterVarAccessFree(virNWFilterVarAccess *varAccess);
bool virNWFilterVarAccessEqual(const virNWFilterVarAccess *a,
const virNWFilterVarAccess *b);
-virNWFilterVarAccessPtr virNWFilterVarAccessParse(const char *varAccess);
-void virNWFilterVarAccessPrint(virNWFilterVarAccessPtr vap,
- virBufferPtr buf);
+virNWFilterVarAccess *virNWFilterVarAccessParse(const char *varAccess);
+void virNWFilterVarAccessPrint(virNWFilterVarAccess *vap,
+ virBuffer *buf);
const char *virNWFilterVarAccessGetVarName(const virNWFilterVarAccess *vap);
virNWFilterVarAccessType virNWFilterVarAccessGetType(
const virNWFilterVarAccess *vap);
GHashTable *hash);
typedef struct _virNWFilterVarCombIterEntry virNWFilterVarCombIterEntry;
-typedef virNWFilterVarCombIterEntry *virNWFilterVarCombIterEntryPtr;
struct _virNWFilterVarCombIterEntry {
unsigned int iterId;
const char **varNames;
};
typedef struct _virNWFilterVarCombIter virNWFilterVarCombIter;
-typedef virNWFilterVarCombIter *virNWFilterVarCombIterPtr;
struct _virNWFilterVarCombIter {
GHashTable *hashTable;
size_t nIter;
- virNWFilterVarCombIterEntryPtr iter;
+ virNWFilterVarCombIterEntry *iter;
};
-virNWFilterVarCombIterPtr virNWFilterVarCombIterCreate(
+virNWFilterVarCombIter *virNWFilterVarCombIterCreate(
GHashTable *hash,
- virNWFilterVarAccessPtr *vars,
+ virNWFilterVarAccess **vars,
size_t nVars);
-void virNWFilterVarCombIterFree(virNWFilterVarCombIterPtr ci);
-virNWFilterVarCombIterPtr virNWFilterVarCombIterNext(
- virNWFilterVarCombIterPtr ci);
-const char *virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIterPtr ci,
+void virNWFilterVarCombIterFree(virNWFilterVarCombIter *ci);
+virNWFilterVarCombIter *virNWFilterVarCombIterNext(
+ virNWFilterVarCombIter *ci);
+const char *virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIter *ci,
const virNWFilterVarAccess *);
struct _virObjectEventCallback {
int callbackID;
- virClassPtr klass;
+ virClass *klass;
int eventID;
virConnectPtr conn;
int remoteID;
bool legacy; /* true if end user does not know callbackID */
};
typedef struct _virObjectEventCallback virObjectEventCallback;
-typedef virObjectEventCallback *virObjectEventCallbackPtr;
struct _virObjectEventCallbackList {
unsigned int nextID;
size_t count;
- virObjectEventCallbackPtr *callbacks;
+ virObjectEventCallback **callbacks;
};
struct _virObjectEventQueue {
size_t count;
- virObjectEventPtr *events;
+ virObjectEvent **events;
};
typedef struct _virObjectEventQueue virObjectEventQueue;
-typedef virObjectEventQueue *virObjectEventQueuePtr;
struct _virObjectEventState {
virObjectLockable parent;
/* The list of domain event callbacks */
- virObjectEventCallbackListPtr callbacks;
+ virObjectEventCallbackList *callbacks;
/* The queue of object events */
- virObjectEventQueuePtr queue;
+ virObjectEventQueue *queue;
/* Timer for flushing events queue */
int timer;
/* Flag if we're in process of dispatching */
bool isDispatching;
};
-static virClassPtr virObjectEventClass;
-static virClassPtr virObjectEventStateClass;
+static virClass *virObjectEventClass;
+static virClass *virObjectEventStateClass;
static void virObjectEventDispose(void *obj);
static void virObjectEventStateDispose(void *obj);
* Return the class object to be used as a parent when creating an
* event subclass.
*/
-virClassPtr
+virClass *
virClassForObjectEvent(void)
{
if (virObjectEventInitialize() < 0)
static void
virObjectEventDispose(void *obj)
{
- virObjectEventPtr event = obj;
+ virObjectEvent *event = obj;
VIR_DEBUG("obj=%p", event);
* Free the memory in the domain event callback
*/
static void
-virObjectEventCallbackFree(virObjectEventCallbackPtr cb)
+virObjectEventCallbackFree(virObjectEventCallback *cb)
{
if (!cb)
return;
* Free the memory in the domain event callback list
*/
static void
-virObjectEventCallbackListFree(virObjectEventCallbackListPtr list)
+virObjectEventCallbackListFree(virObjectEventCallbackList *list)
{
size_t i;
if (!list)
*/
static int
virObjectEventCallbackListCount(virConnectPtr conn,
- virObjectEventCallbackListPtr cbList,
- virClassPtr klass,
+ virObjectEventCallbackList *cbList,
+ virClass *klass,
int eventID,
const char *key,
bool serverFilter)
int ret = 0;
for (i = 0; i < cbList->count; i++) {
- virObjectEventCallbackPtr cb = cbList->callbacks[i];
+ virObjectEventCallback *cb = cbList->callbacks[i];
if (cb->filter)
continue;
* @callback: the callback to remove
* @doFreeCb: Inhibit calling the freecb
*
- * Internal function to remove a callback from a virObjectEventCallbackListPtr
+ * Internal function to remove a callback from a virObjectEventCallbackList *
*/
static int
virObjectEventCallbackListRemoveID(virConnectPtr conn,
- virObjectEventCallbackListPtr cbList,
+ virObjectEventCallbackList *cbList,
int callbackID,
bool doFreeCb)
{
size_t i;
for (i = 0; i < cbList->count; i++) {
- virObjectEventCallbackPtr cb = cbList->callbacks[i];
+ virObjectEventCallback *cb = cbList->callbacks[i];
if (cb->callbackID == callbackID && cb->conn == conn) {
int ret;
static int
virObjectEventCallbackListMarkDeleteID(virConnectPtr conn,
- virObjectEventCallbackListPtr cbList,
+ virObjectEventCallbackList *cbList,
int callbackID)
{
size_t i;
for (i = 0; i < cbList->count; i++) {
- virObjectEventCallbackPtr cb = cbList->callbacks[i];
+ virObjectEventCallback *cb = cbList->callbacks[i];
if (cb->callbackID == callbackID && cb->conn == conn) {
cb->deleted = true;
static int
-virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList)
+virObjectEventCallbackListPurgeMarked(virObjectEventCallbackList *cbList)
{
size_t n;
for (n = 0; n < cbList->count; n++) {
*/
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
virObjectEventCallbackLookup(virConnectPtr conn,
- virObjectEventCallbackListPtr cbList,
+ virObjectEventCallbackList *cbList,
const char *key,
- virClassPtr klass,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback callback,
bool legacy,
*remoteID = -1;
for (i = 0; i < cbList->count; i++) {
- virObjectEventCallbackPtr cb = cbList->callbacks[i];
+ virObjectEventCallback *cb = cbList->callbacks[i];
if (cb->deleted)
continue;
* @callbackID: filled with callback ID
* @serverFilter: true if server supports object filtering
*
- * Internal function to add a callback from a virObjectEventCallbackListPtr
+ * Internal function to add a callback from a virObjectEventCallbackList *
*/
static int
virObjectEventCallbackListAddID(virConnectPtr conn,
- virObjectEventCallbackListPtr cbList,
+ virObjectEventCallbackList *cbList,
const char *key,
virObjectEventCallbackFilter filter,
void *filter_opaque,
- virClassPtr klass,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback callback,
void *opaque,
int *callbackID,
bool serverFilter)
{
- virObjectEventCallbackPtr cb;
+ virObjectEventCallback *cb;
int ret = -1;
int remoteID = -1;
* Removes all elements from the queue
*/
static void
-virObjectEventQueueClear(virObjectEventQueuePtr queue)
+virObjectEventQueueClear(virObjectEventQueue *queue)
{
size_t i;
if (!queue)
* Free the memory in the queue. We process this like a list here
*/
static void
-virObjectEventQueueFree(virObjectEventQueuePtr queue)
+virObjectEventQueueFree(virObjectEventQueue *queue)
{
if (!queue)
return;
g_free(queue);
}
-static virObjectEventQueuePtr
+static virObjectEventQueue *
virObjectEventQueueNew(void)
{
return g_new0(virObjectEventQueue, 1);
/**
* virObjectEventStateDispose:
- * @list: virObjectEventStatePtr to free
+ * @list: virObjectEventState * to free
*
- * Free a virObjectEventStatePtr and its members, and unregister the timer.
+ * Free a virObjectEventState * and its members, and unregister the timer.
*/
static void
virObjectEventStateDispose(void *obj)
{
- virObjectEventStatePtr state = obj;
+ virObjectEventState *state = obj;
VIR_DEBUG("obj=%p", state);
}
-static void virObjectEventStateFlush(virObjectEventStatePtr state);
+static void virObjectEventStateFlush(virObjectEventState *state);
/**
static void
virObjectEventTimer(int timer G_GNUC_UNUSED, void *opaque)
{
- virObjectEventStatePtr state = opaque;
+ virObjectEventState *state = opaque;
virObjectEventStateFlush(state);
}
*
* Allocate a new event state object.
*/
-virObjectEventStatePtr
+virObjectEventState *
virObjectEventStateNew(void)
{
- virObjectEventStatePtr state = NULL;
+ virObjectEventState *state = NULL;
if (virObjectEventInitialize() < 0)
return NULL;
* Create a new event, with the information common to all events.
*/
void *
-virObjectEventNew(virClassPtr klass,
+virObjectEventNew(virClass *klass,
virObjectEventDispatchFunc dispatcher,
int eventID,
int id,
const unsigned char *uuid,
const char *key)
{
- virObjectEventPtr event;
+ virObjectEvent *event;
if (virObjectEventInitialize() < 0)
return NULL;
* Returns: 0 on success, -1 on failure
*/
static int
-virObjectEventQueuePush(virObjectEventQueuePtr evtQueue,
- virObjectEventPtr event)
+virObjectEventQueuePush(virObjectEventQueue *evtQueue,
+ virObjectEvent *event)
{
if (!evtQueue)
return -1;
static bool
-virObjectEventDispatchMatchCallback(virObjectEventPtr event,
- virObjectEventCallbackPtr cb)
+virObjectEventDispatchMatchCallback(virObjectEvent *event,
+ virObjectEventCallback *cb)
{
if (!cb)
return false;
static void
-virObjectEventStateDispatchCallbacks(virObjectEventStatePtr state,
- virObjectEventPtr event,
- virObjectEventCallbackListPtr callbacks)
+virObjectEventStateDispatchCallbacks(virObjectEventState *state,
+ virObjectEvent *event,
+ virObjectEventCallbackList *callbacks)
{
size_t i;
/* Cache this now, since we may be dropping the lock,
size_t cbCount = callbacks->count;
for (i = 0; i < cbCount; i++) {
- virObjectEventCallbackPtr cb = callbacks->callbacks[i];
+ virObjectEventCallback *cb = callbacks->callbacks[i];
if (!virObjectEventDispatchMatchCallback(event, cb))
continue;
static void
-virObjectEventStateQueueDispatch(virObjectEventStatePtr state,
- virObjectEventQueuePtr queue,
- virObjectEventCallbackListPtr callbacks)
+virObjectEventStateQueueDispatch(virObjectEventState *state,
+ virObjectEventQueue *queue,
+ virObjectEventCallbackList *callbacks)
{
size_t i;
* id.
*/
void
-virObjectEventStateQueueRemote(virObjectEventStatePtr state,
- virObjectEventPtr event,
+virObjectEventStateQueueRemote(virObjectEventState *state,
+ virObjectEvent *event,
int remoteID)
{
if (!event)
* call.
*/
void
-virObjectEventStateQueue(virObjectEventStatePtr state,
- virObjectEventPtr event)
+virObjectEventStateQueue(virObjectEventState *state,
+ virObjectEvent *event)
{
virObjectEventStateQueueRemote(state, event, -1);
}
static void
-virObjectEventStateCleanupTimer(virObjectEventStatePtr state, bool clear_queue)
+virObjectEventStateCleanupTimer(virObjectEventState *state, bool clear_queue)
{
/* There are still some callbacks, keep the timer. */
if (state->callbacks->count)
static void
-virObjectEventStateFlush(virObjectEventStatePtr state)
+virObjectEventStateFlush(virObjectEventState *state)
{
virObjectEventQueue tempQueue;
*/
int
virObjectEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
const char *key,
virObjectEventCallbackFilter filter,
void *filter_opaque,
- virClassPtr klass,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback cb,
void *opaque,
*/
int
virObjectEventStateDeregisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
bool doFreeCb)
{
*/
int
virObjectEventStateCallbackID(virConnectPtr conn,
- virObjectEventStatePtr state,
- virClassPtr klass,
+ virObjectEventState *state,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback callback,
int *remoteID)
*/
int
virObjectEventStateEventID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
int *remoteID)
{
int ret = -1;
size_t i;
- virObjectEventCallbackListPtr cbList = state->callbacks;
+ virObjectEventCallbackList *cbList = state->callbacks;
virObjectLock(state);
for (i = 0; i < cbList->count; i++) {
- virObjectEventCallbackPtr cb = cbList->callbacks[i];
+ virObjectEventCallback *cb = cbList->callbacks[i];
if (cb->deleted)
continue;
*/
void
virObjectEventStateSetRemote(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
int remoteID)
{
virObjectLock(state);
for (i = 0; i < state->callbacks->count; i++) {
- virObjectEventCallbackPtr cb = state->callbacks->callbacks[i];
+ virObjectEventCallback *cb = state->callbacks->callbacks[i];
if (cb->deleted)
continue;
* in a call / response rpc
*/
typedef struct _virObjectEvent virObjectEvent;
-typedef virObjectEvent *virObjectEventPtr;
typedef struct _virObjectEventState virObjectEventState;
-typedef virObjectEventState *virObjectEventStatePtr;
-virObjectEventStatePtr
+virObjectEventState *
virObjectEventStateNew(void);
/**
((virConnectObjectEventGenericCallback)(cb))
void
-virObjectEventStateQueue(virObjectEventStatePtr state,
- virObjectEventPtr event)
+virObjectEventStateQueue(virObjectEventState *state,
+ virObjectEvent *event)
ATTRIBUTE_NONNULL(1);
void
-virObjectEventStateQueueRemote(virObjectEventStatePtr state,
- virObjectEventPtr event,
+virObjectEventStateQueueRemote(virObjectEventState *state,
+ virObjectEvent *event,
int remoteID)
ATTRIBUTE_NONNULL(1);
int
virObjectEventStateDeregisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
bool doFreeCb)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
virObjectEventStateEventID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
int *remoteID)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void
virObjectEventStateSetRemote(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
int callbackID,
int remoteID)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
char *key;
};
typedef struct _virObjectMeta virObjectMeta;
-typedef virObjectMeta *virObjectMetaPtr;
typedef struct _virObjectEventCallbackList virObjectEventCallbackList;
-typedef virObjectEventCallbackList *virObjectEventCallbackListPtr;
typedef void
(*virObjectEventDispatchFunc)(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque);
* be sent to @conn.
*/
typedef bool (*virObjectEventCallbackFilter)(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
void *opaque);
-virClassPtr
+virClass *
virClassForObjectEvent(void);
int
virObjectEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
const char *key,
virObjectEventCallbackFilter filter,
void *filter_opaque,
- virClassPtr klass,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback cb,
void *opaque,
int
virObjectEventStateCallbackID(virConnectPtr conn,
- virObjectEventStatePtr state,
- virClassPtr klass,
+ virObjectEventState *state,
+ virClass *klass,
int eventID,
virConnectObjectEventGenericCallback callback,
int *remoteID)
ATTRIBUTE_NONNULL(5);
void *
-virObjectEventNew(virClassPtr klass,
+virObjectEventNew(virClass *klass,
virObjectEventDispatchFunc dispatcher,
int eventID,
int id,
VIR_LOG_INIT("conf.secret_conf");
void
-virSecretDefFree(virSecretDefPtr def)
+virSecretDefFree(virSecretDef *def)
{
if (def == NULL)
return;
static int
virSecretDefParseUsage(xmlXPathContextPtr ctxt,
- virSecretDefPtr def)
+ virSecretDef *def)
{
g_autofree char *type_str = NULL;
int type;
return 0;
}
-static virSecretDefPtr
+static virSecretDef *
secretXMLParseNode(xmlDocPtr xml, xmlNodePtr root)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
return g_steal_pointer(&def);
}
-static virSecretDefPtr
+static virSecretDef *
virSecretDefParse(const char *xmlStr,
const char *filename)
{
xmlDocPtr xml;
- virSecretDefPtr ret = NULL;
+ virSecretDef *ret = NULL;
if ((xml = virXMLParse(filename, xmlStr, _("(definition_of_secret)")))) {
ret = secretXMLParseNode(xml, xmlDocGetRootElement(xml));
return ret;
}
-virSecretDefPtr
+virSecretDef *
virSecretDefParseString(const char *xmlStr)
{
return virSecretDefParse(xmlStr, NULL);
}
-virSecretDefPtr
+virSecretDef *
virSecretDefParseFile(const char *filename)
{
return virSecretDefParse(NULL, filename);
}
static int
-virSecretDefFormatUsage(virBufferPtr buf,
+virSecretDefFormatUsage(virBuffer *buf,
const virSecretDef *def)
{
const char *type;
#include "internal.h"
typedef struct _virSecretDef virSecretDef;
-typedef virSecretDef *virSecretDefPtr;
struct _virSecretDef {
bool isephemeral;
bool isprivate;
char *usage_id; /* May be NULL */
};
-void virSecretDefFree(virSecretDefPtr def);
+void virSecretDefFree(virSecretDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSecretDef, virSecretDefFree);
-virSecretDefPtr virSecretDefParseString(const char *xml);
-virSecretDefPtr virSecretDefParseFile(const char *filename);
+virSecretDef *virSecretDefParseString(const char *xml);
+virSecretDef *virSecretDefParseFile(const char *filename);
char *virSecretDefFormat(const virSecretDef *def);
#define VIR_CONNECT_LIST_SECRETS_FILTERS_EPHEMERAL \
bool dummy;
};
typedef struct _virSecretEvent virSecretEvent;
-typedef virSecretEvent *virSecretEventPtr;
struct _virSecretEventLifecycle {
virSecretEvent parent;
int detail;
};
typedef struct _virSecretEventLifecycle virSecretEventLifecycle;
-typedef virSecretEventLifecycle *virSecretEventLifecyclePtr;
struct _virSecretEventValueChanged {
virSecretEvent parent;
bool dummy;
};
typedef struct _virSecretEventValueChanged virSecretEventValueChanged;
-typedef virSecretEventValueChanged *virSecretEventValueChangedPtr;
-static virClassPtr virSecretEventClass;
-static virClassPtr virSecretEventLifecycleClass;
-static virClassPtr virSecretEventValueChangedClass;
+static virClass *virSecretEventClass;
+static virClass *virSecretEventLifecycleClass;
+static virClass *virSecretEventValueChangedClass;
static void virSecretEventDispose(void *obj);
static void virSecretEventLifecycleDispose(void *obj);
static void virSecretEventValueChangedDispose(void *obj);
static void
virSecretEventDispose(void *obj)
{
- virSecretEventPtr event = obj;
+ virSecretEvent *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virSecretEventLifecycleDispose(void *obj)
{
- virSecretEventLifecyclePtr event = obj;
+ virSecretEventLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virSecretEventValueChangedDispose(void *obj)
{
- virSecretEventValueChangedPtr event = obj;
+ virSecretEventValueChanged *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virSecretEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
switch ((virSecretEventID)event->eventID) {
case VIR_SECRET_EVENT_ID_LIFECYCLE:
{
- virSecretEventLifecyclePtr secretLifecycleEvent;
+ virSecretEventLifecycle *secretLifecycleEvent;
- secretLifecycleEvent = (virSecretEventLifecyclePtr)event;
+ secretLifecycleEvent = (virSecretEventLifecycle *)event;
((virConnectSecretEventLifecycleCallback)cb)(conn, secret,
secretLifecycleEvent->type,
secretLifecycleEvent->detail,
*/
int
virSecretEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virSecretPtr secret,
int eventID,
virConnectSecretEventGenericCallback cb,
*/
int
virSecretEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virSecretPtr secret,
int eventID,
virConnectSecretEventGenericCallback cb,
*
* Create a new secret lifecycle event.
*/
-virObjectEventPtr
+virObjectEvent *
virSecretEventLifecycleNew(const unsigned char *uuid,
int usage_type,
const char *usage_id,
int type,
int detail)
{
- virSecretEventLifecyclePtr event;
+ virSecretEventLifecycle *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virSecretEventsInitialize() < 0)
event->type = type;
event->detail = detail;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
*
* Create a new secret lifecycle event.
*/
-virObjectEventPtr
+virObjectEvent *
virSecretEventValueChangedNew(const unsigned char *uuid,
int usage_type,
const char *usage_id)
{
- virSecretEventValueChangedPtr event;
+ virSecretEventValueChanged *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virSecretEventsInitialize() < 0)
usage_type, usage_id, uuid, uuidstr)))
return NULL;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
int
virSecretEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virSecretPtr secret,
int eventID,
virConnectSecretEventGenericCallback cb,
int
virSecretEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virSecretPtr secret,
int eventID,
virConnectSecretEventGenericCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
ATTRIBUTE_NONNULL(8);
-virObjectEventPtr
+virObjectEvent *
virSecretEventLifecycleNew(const unsigned char *uuid,
int usage_type,
const char *usage_id,
int type,
int detail);
-virObjectEventPtr
+virObjectEvent *
virSecretEventValueChangedNew(const unsigned char *uuid,
int usage_type,
const char *usage_id);
VIR_LOG_INIT("conf.snapshot_conf");
-static virClassPtr virDomainSnapshotDefClass;
+static virClass *virDomainSnapshotDefClass;
static void virDomainSnapshotDefDispose(void *obj);
static int
/* Snapshot Def functions */
static void
-virDomainSnapshotDiskDefClear(virDomainSnapshotDiskDefPtr disk)
+virDomainSnapshotDiskDefClear(virDomainSnapshotDiskDef *disk)
{
VIR_FREE(disk->name);
virObjectUnref(disk->src);
}
void
-virDomainSnapshotDiskDefFree(virDomainSnapshotDiskDefPtr disk)
+virDomainSnapshotDiskDefFree(virDomainSnapshotDiskDef *disk)
{
if (!disk)
return;
/* Allocate a new virDomainSnapshotDef; free with virObjectUnref() */
-virDomainSnapshotDefPtr
+virDomainSnapshotDef *
virDomainSnapshotDefNew(void)
{
if (virDomainSnapshotInitialize() < 0)
static void
virDomainSnapshotDefDispose(void *obj)
{
- virDomainSnapshotDefPtr def = obj;
+ virDomainSnapshotDef *def = obj;
size_t i;
g_free(def->file);
int
virDomainSnapshotDiskDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainSnapshotDiskDefPtr def,
+ virDomainSnapshotDiskDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
int ret = -1;
char *snapshot = NULL;
* If flags does not include
* VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL, then current is ignored.
*/
-static virDomainSnapshotDefPtr
+static virDomainSnapshotDef *
virDomainSnapshotDefParse(xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
bool *current,
unsigned int flags)
{
- virDomainSnapshotDefPtr def = NULL;
- virDomainSnapshotDefPtr ret = NULL;
+ virDomainSnapshotDef *def = NULL;
+ virDomainSnapshotDef *ret = NULL;
xmlNodePtr *nodes = NULL;
xmlNodePtr inactiveDomNode = NULL;
size_t i;
char *memorySnapshot = NULL;
char *memoryFile = NULL;
bool offline = !!(flags & VIR_DOMAIN_SNAPSHOT_PARSE_OFFLINE);
- virSaveCookieCallbacksPtr saveCookie = virDomainXMLOptionGetSaveCookie(xmlopt);
+ virSaveCookieCallbacks *saveCookie = virDomainXMLOptionGetSaveCookie(xmlopt);
int domainflags = VIR_DOMAIN_DEF_PARSE_INACTIVE |
VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE;
return ret;
}
-virDomainSnapshotDefPtr
+virDomainSnapshotDef *
virDomainSnapshotDefParseNode(xmlDocPtr xml,
xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
bool *current,
unsigned int flags)
return virDomainSnapshotDefParse(ctxt, xmlopt, parseOpaque, current, flags);
}
-virDomainSnapshotDefPtr
+virDomainSnapshotDef *
virDomainSnapshotDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
bool *current,
unsigned int flags)
{
- virDomainSnapshotDefPtr ret = NULL;
+ virDomainSnapshotDef *ret = NULL;
xmlDocPtr xml;
int keepBlanksDefault = xmlKeepBlanksDefault(0);
* @other is non-NULL, this may include swapping def->parent.dom from other
* into def. */
int
-virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
+virDomainSnapshotRedefineValidate(virDomainSnapshotDef *def,
const unsigned char *domain_uuid,
- virDomainMomentObjPtr other,
- virDomainXMLOptionPtr xmlopt,
+ virDomainMomentObj *other,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
}
if (other) {
- virDomainSnapshotDefPtr otherdef = virDomainSnapshotObjGetDef(other);
+ virDomainSnapshotDef *otherdef = virDomainSnapshotObjGetDef(other);
if ((otherdef->state == VIR_DOMAIN_SNAPSHOT_RUNNING ||
otherdef->state == VIR_DOMAIN_SNAPSHOT_PAUSED) !=
* success, -1 on error.
*/
static int
-virDomainSnapshotDefAssignExternalNames(virDomainSnapshotDefPtr def)
+virDomainSnapshotDefAssignExternalNames(virDomainSnapshotDef *def)
{
const char *origpath;
char *tmppath;
size_t j;
for (i = 0; i < def->ndisks; i++) {
- virDomainSnapshotDiskDefPtr disk = &def->disks[i];
+ virDomainSnapshotDiskDef *disk = &def->disks[i];
if (disk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL ||
disk->src->path)
* dom->disks. If require_match, also ensure that there is no
* conflicting requests for both internal and external snapshots. */
int
-virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr snapdef,
+virDomainSnapshotAlignDisks(virDomainSnapshotDef *snapdef,
int default_snapshot,
bool require_match)
{
- virDomainDefPtr domdef = snapdef->parent.dom;
+ virDomainDef *domdef = snapdef->parent.dom;
g_autoptr(GHashTable) map = virHashNew(NULL);
- g_autofree virDomainSnapshotDiskDefPtr olddisks = NULL;
+ g_autofree virDomainSnapshotDiskDef *olddisks = NULL;
size_t i;
if (!domdef) {
/* Double check requested disks. */
for (i = 0; i < snapdef->ndisks; i++) {
- virDomainSnapshotDiskDefPtr snapdisk = &snapdef->disks[i];
- virDomainDiskDefPtr domdisk = virDomainDiskByName(domdef, snapdisk->name, false);
+ virDomainSnapshotDiskDef *snapdisk = &snapdef->disks[i];
+ virDomainDiskDef *domdisk = virDomainDiskByName(domdef, snapdisk->name, false);
if (!domdisk) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
snapdef->ndisks = domdef->ndisks;
for (i = 0; i < domdef->ndisks; i++) {
- virDomainDiskDefPtr domdisk = domdef->disks[i];
- virDomainSnapshotDiskDefPtr snapdisk = snapdef->disks + i;
- virDomainSnapshotDiskDefPtr existing;
+ virDomainDiskDef *domdisk = domdef->disks[i];
+ virDomainSnapshotDiskDef *snapdisk = snapdef->disks + i;
+ virDomainSnapshotDiskDef *existing;
/* copy existing disks */
if ((existing = virHashLookup(map, domdisk->dst))) {
static int
-virDomainSnapshotDiskDefFormat(virBufferPtr buf,
- virDomainSnapshotDiskDefPtr disk,
- virDomainXMLOptionPtr xmlopt)
+virDomainSnapshotDiskDefFormat(virBuffer *buf,
+ virDomainSnapshotDiskDef *disk,
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
/* Append XML describing def into buf. Return 0 on success, or -1 on
* failure with buf cleared. */
static int
-virDomainSnapshotDefFormatInternal(virBufferPtr buf,
+virDomainSnapshotDefFormatInternal(virBuffer *buf,
const char *uuidstr,
- virDomainSnapshotDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+ virDomainSnapshotDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
size_t i;
char *
virDomainSnapshotDefFormat(const char *uuidstr,
- virDomainSnapshotDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+ virDomainSnapshotDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool
-virDomainSnapshotDefIsExternal(virDomainSnapshotDefPtr def)
+virDomainSnapshotDefIsExternal(virDomainSnapshotDef *def)
{
size_t i;
}
bool
-virDomainSnapshotIsExternal(virDomainMomentObjPtr snap)
+virDomainSnapshotIsExternal(virDomainMomentObj *snap)
{
- virDomainSnapshotDefPtr def = virDomainSnapshotObjGetDef(snap);
+ virDomainSnapshotDef *def = virDomainSnapshotObjGetDef(snap);
return virDomainSnapshotDefIsExternal(def);
}
int
-virDomainSnapshotRedefinePrep(virDomainObjPtr vm,
- virDomainSnapshotDefPtr *defptr,
- virDomainMomentObjPtr *snap,
- virDomainXMLOptionPtr xmlopt,
+virDomainSnapshotRedefinePrep(virDomainObj *vm,
+ virDomainSnapshotDef **defptr,
+ virDomainMomentObj **snap,
+ virDomainXMLOption *xmlopt,
unsigned int flags)
{
- virDomainSnapshotDefPtr def = *defptr;
- virDomainMomentObjPtr other;
- virDomainSnapshotDefPtr otherdef = NULL;
+ virDomainSnapshotDef *def = *defptr;
+ virDomainMomentObj *other;
+ virDomainSnapshotDef *otherdef = NULL;
bool check_if_stolen;
if (virDomainSnapshotCheckCycles(vm->snapshots, def, vm->def->name) < 0)
/* Stores disk-snapshot information */
typedef struct _virDomainSnapshotDiskDef virDomainSnapshotDiskDef;
-typedef virDomainSnapshotDiskDef *virDomainSnapshotDiskDefPtr;
struct _virDomainSnapshotDiskDef {
char *name; /* name matching the <target dev='...' of the domain */
int snapshot; /* virDomainSnapshotLocation */
/* details of wrapper external file. src is always non-NULL.
* XXX optimize this to allow NULL for internal snapshots? */
- virStorageSourcePtr src;
+ virStorageSource *src;
};
void
-virDomainSnapshotDiskDefFree(virDomainSnapshotDiskDefPtr disk);
+virDomainSnapshotDiskDefFree(virDomainSnapshotDiskDef *disk);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainSnapshotDiskDef, virDomainSnapshotDiskDefFree);
size_t ndisks; /* should not exceed dom->ndisks */
virDomainSnapshotDiskDef *disks;
- virObjectPtr cookie;
+ virObject *cookie;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainSnapshotDef, virObjectUnref);
unsigned int virDomainSnapshotFormatConvertXMLFlags(unsigned int flags);
-virDomainSnapshotDefPtr virDomainSnapshotDefParseString(const char *xmlStr,
- virDomainXMLOptionPtr xmlopt,
- void *parseOpaque,
- bool *current,
- unsigned int flags);
-virDomainSnapshotDefPtr virDomainSnapshotDefParseNode(xmlDocPtr xml,
- xmlNodePtr root,
- virDomainXMLOptionPtr xmlopt,
+virDomainSnapshotDef *virDomainSnapshotDefParseString(const char *xmlStr,
+ virDomainXMLOption *xmlopt,
void *parseOpaque,
bool *current,
unsigned int flags);
-virDomainSnapshotDefPtr virDomainSnapshotDefNew(void);
+virDomainSnapshotDef *virDomainSnapshotDefParseNode(xmlDocPtr xml,
+ xmlNodePtr root,
+ virDomainXMLOption *xmlopt,
+ void *parseOpaque,
+ bool *current,
+ unsigned int flags);
+virDomainSnapshotDef *virDomainSnapshotDefNew(void);
char *virDomainSnapshotDefFormat(const char *uuidstr,
- virDomainSnapshotDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+ virDomainSnapshotDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-int virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr snapshot,
+int virDomainSnapshotAlignDisks(virDomainSnapshotDef *snapshot,
int default_snapshot,
bool require_match);
-bool virDomainSnapshotDefIsExternal(virDomainSnapshotDefPtr def);
-bool virDomainSnapshotIsExternal(virDomainMomentObjPtr snap);
+bool virDomainSnapshotDefIsExternal(virDomainSnapshotDef *def);
+bool virDomainSnapshotIsExternal(virDomainMomentObj *snap);
-int virDomainSnapshotRedefinePrep(virDomainObjPtr vm,
- virDomainSnapshotDefPtr *def,
- virDomainMomentObjPtr *snap,
- virDomainXMLOptionPtr xmlopt,
+int virDomainSnapshotRedefinePrep(virDomainObj *vm,
+ virDomainSnapshotDef **def,
+ virDomainMomentObj **snap,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
-int virDomainSnapshotRedefineValidate(virDomainSnapshotDefPtr def,
+int virDomainSnapshotRedefineValidate(virDomainSnapshotDef *def,
const unsigned char *domain_uuid,
- virDomainMomentObjPtr other,
- virDomainXMLOptionPtr xmlopt,
+ virDomainMomentObj *other,
+ virDomainXMLOption *xmlopt,
unsigned int flags);
VIR_ENUM_DECL(virDomainSnapshotLocation);
int
virDomainSnapshotDiskDefParseXML(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainSnapshotDiskDefPtr def,
+ virDomainSnapshotDiskDef *def,
unsigned int flags,
- virDomainXMLOptionPtr xmlopt);
+ virDomainXMLOption *xmlopt);
);
static void
-virStorageAdapterClearFCHost(virStorageAdapterFCHostPtr fchost)
+virStorageAdapterClearFCHost(virStorageAdapterFCHost *fchost)
{
VIR_FREE(fchost->wwnn);
VIR_FREE(fchost->wwpn);
void
-virStorageAdapterClear(virStorageAdapterPtr adapter)
+virStorageAdapterClear(virStorageAdapter *adapter)
{
if (adapter->type == VIR_STORAGE_ADAPTER_TYPE_FC_HOST)
virStorageAdapterClearFCHost(&adapter->data.fchost);
static int
virStorageAdapterParseXMLFCHost(xmlNodePtr node,
- virStorageAdapterFCHostPtr fchost)
+ virStorageAdapterFCHost *fchost)
{
char *managed = NULL;
static int
virStorageAdapterParseXMLSCSIHost(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageAdapterSCSIHostPtr scsi_host)
+ virStorageAdapterSCSIHost *scsi_host)
{
scsi_host->name = virXMLPropString(node, "name");
if (virXPathNode("./parentaddr", ctxt)) {
static int
virStorageAdapterParseXMLLegacy(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virStorageAdapterPtr adapter)
+ virStorageAdapter *adapter)
{
char *wwnn = virXMLPropString(node, "wwnn");
char *wwpn = virXMLPropString(node, "wwpn");
int
-virStorageAdapterParseXML(virStorageAdapterPtr adapter,
+virStorageAdapterParseXML(virStorageAdapter *adapter,
xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
static int
-virStorageAdapterValidateFCHost(virStorageAdapterFCHostPtr fchost)
+virStorageAdapterValidateFCHost(virStorageAdapterFCHost *fchost)
{
if (!fchost->wwnn || !fchost->wwpn) {
virReportError(VIR_ERR_XML_ERROR, "%s",
static int
-virStorageAdapterValidateSCSIHost(virStorageAdapterSCSIHostPtr scsi_host)
+virStorageAdapterValidateSCSIHost(virStorageAdapterSCSIHost *scsi_host)
{
if (!scsi_host->name && !scsi_host->has_parent) {
virReportError(VIR_ERR_XML_ERROR, "%s",
int
-virStorageAdapterValidate(virStorageAdapterPtr adapter)
+virStorageAdapterValidate(virStorageAdapter *adapter)
{
if (!adapter->type) {
virReportError(VIR_ERR_XML_ERROR, "%s",
static void
-virStorageAdapterFormatFCHost(virBufferPtr buf,
- virStorageAdapterFCHostPtr fchost)
+virStorageAdapterFormatFCHost(virBuffer *buf,
+ virStorageAdapterFCHost *fchost)
{
virBufferEscapeString(buf, " parent='%s'", fchost->parent);
virBufferEscapeString(buf, " parent_wwnn='%s'", fchost->parent_wwnn);
static void
-virStorageAdapterFormatSCSIHost(virBufferPtr buf,
- virStorageAdapterSCSIHostPtr scsi_host)
+virStorageAdapterFormatSCSIHost(virBuffer *buf,
+ virStorageAdapterSCSIHost *scsi_host)
{
if (scsi_host->name) {
virBufferAsprintf(buf, " name='%s'/>\n", scsi_host->name);
void
-virStorageAdapterFormat(virBufferPtr buf,
- virStorageAdapterPtr adapter)
+virStorageAdapterFormat(virBuffer *buf,
+ virStorageAdapter *adapter)
{
virBufferAsprintf(buf, "<adapter type='%s'",
virStorageAdapterTypeToString(adapter->type));
VIR_ENUM_DECL(virStorageAdapter);
typedef struct _virStorageAdapterSCSIHost virStorageAdapterSCSIHost;
-typedef virStorageAdapterSCSIHost *virStorageAdapterSCSIHostPtr;
struct _virStorageAdapterSCSIHost {
char *name;
virPCIDeviceAddress parentaddr; /* host address */
};
typedef struct _virStorageAdapterFCHost virStorageAdapterFCHost;
-typedef virStorageAdapterFCHost *virStorageAdapterFCHostPtr;
struct _virStorageAdapterFCHost {
char *parent;
char *parent_wwnn;
};
typedef struct _virStorageAdapter virStorageAdapter;
-typedef virStorageAdapter *virStorageAdapterPtr;
struct _virStorageAdapter {
int type; /* virStorageAdapterType */
void
-virStorageAdapterClear(virStorageAdapterPtr adapter);
+virStorageAdapterClear(virStorageAdapter *adapter);
int
-virStorageAdapterParseXML(virStorageAdapterPtr adapter,
+virStorageAdapterParseXML(virStorageAdapter *adapter,
xmlNodePtr node,
xmlXPathContextPtr ctxt);
int
-virStorageAdapterValidate(virStorageAdapterPtr adapter);
+virStorageAdapterValidate(virStorageAdapter *adapter);
void
-virStorageAdapterFormat(virBufferPtr buf,
- virStorageAdapterPtr adapter);
+virStorageAdapterFormat(virBuffer *buf,
+ virStorageAdapter *adapter);
VIR_LOG_INIT("conf.storage_capabilities");
-static virClassPtr virStoragePoolCapsClass;
+static virClass *virStoragePoolCapsClass;
static void
virStoragePoolCapsDispose(void *obj)
{
- virStoragePoolCapsPtr caps = obj;
+ virStoragePoolCaps *caps = obj;
VIR_DEBUG("obj=%p", caps);
virObjectUnref(caps->driverCaps);
VIR_ONCE_GLOBAL_INIT(virStoragePoolCaps);
-virStoragePoolCapsPtr
-virStoragePoolCapsNew(virCapsPtr driverCaps)
+virStoragePoolCaps *
+virStoragePoolCapsNew(virCaps *driverCaps)
{
- virStoragePoolCapsPtr caps = NULL;
+ virStoragePoolCaps *caps = NULL;
if (virStoragePoolCapsInitialize() < 0)
return NULL;
static bool
-virStoragePoolCapsIsLoaded(virCapsPtr driverCaps,
+virStoragePoolCapsIsLoaded(virCaps *driverCaps,
int poolType)
{
size_t i;
static int
-virStoragePoolCapsFormatPool(virBufferPtr buf,
+virStoragePoolCapsFormatPool(virBuffer *buf,
int poolType,
const virStoragePoolCaps *caps)
{
#include "internal.h"
typedef struct _virStoragePoolCaps virStoragePoolCaps;
-typedef virStoragePoolCaps *virStoragePoolCapsPtr;
struct _virStoragePoolCaps {
virObjectLockable parent;
- virCapsPtr driverCaps;
+ virCaps *driverCaps;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStoragePoolCaps, virObjectUnref);
-virStoragePoolCapsPtr
-virStoragePoolCapsNew(virCapsPtr driverCaps);
+virStoragePoolCaps *
+virStoragePoolCapsNew(virCaps *driverCaps);
char *
virStoragePoolCapsFormat(const virStoragePoolCaps *caps);
typedef int (*virStoragePoolFormatFromString)(const char *format);
typedef struct _virStorageVolOptions virStorageVolOptions;
-typedef virStorageVolOptions *virStorageVolOptionsPtr;
struct _virStorageVolOptions {
int defaultFormat;
int lastFormat;
};
typedef struct _virStoragePoolOptions virStoragePoolOptions;
-typedef virStoragePoolOptions *virStoragePoolOptionsPtr;
struct _virStoragePoolOptions {
unsigned int flags;
int defaultFormat;
};
typedef struct _virStoragePoolTypeInfo virStoragePoolTypeInfo;
-typedef virStoragePoolTypeInfo *virStoragePoolTypeInfoPtr;
struct _virStoragePoolTypeInfo {
int poolType;
virStoragePoolOptions poolOptions;
};
-static virStoragePoolTypeInfoPtr
+static virStoragePoolTypeInfo *
virStoragePoolTypeInfoLookup(int type)
{
size_t i;
}
-static virStoragePoolOptionsPtr
+static virStoragePoolOptions *
virStoragePoolOptionsForPoolType(int type)
{
- virStoragePoolTypeInfoPtr backend = virStoragePoolTypeInfoLookup(type);
+ virStoragePoolTypeInfo *backend = virStoragePoolTypeInfoLookup(type);
if (backend == NULL)
return NULL;
return &backend->poolOptions;
*/
int
virStoragePoolOptionsPoolTypeSetXMLNamespace(int type,
- virXMLNamespacePtr ns)
+ virXMLNamespace *ns)
{
- virStoragePoolTypeInfoPtr backend = virStoragePoolTypeInfoLookup(type);
+ virStoragePoolTypeInfo *backend = virStoragePoolTypeInfoLookup(type);
if (!backend)
return -1;
}
-static virStorageVolOptionsPtr
+static virStorageVolOptions *
virStorageVolOptionsForPoolType(int type)
{
- virStoragePoolTypeInfoPtr backend = virStoragePoolTypeInfoLookup(type);
+ virStoragePoolTypeInfo *backend = virStoragePoolTypeInfoLookup(type);
if (backend == NULL)
return NULL;
return &backend->volOptions;
int
-virStoragePoolOptionsFormatPool(virBufferPtr buf,
+virStoragePoolOptionsFormatPool(virBuffer *buf,
int type)
{
- virStoragePoolOptionsPtr poolOptions;
+ virStoragePoolOptions *poolOptions;
if (!(poolOptions = virStoragePoolOptionsForPoolType(type)))
return -1;
int
-virStoragePoolOptionsFormatVolume(virBufferPtr buf,
+virStoragePoolOptionsFormatVolume(virBuffer *buf,
int type)
{
size_t i;
- virStorageVolOptionsPtr volOptions;
+ virStorageVolOptions *volOptions;
if (!(volOptions = virStorageVolOptionsForPoolType(type)))
return -1;
void
-virStorageVolDefFree(virStorageVolDefPtr def)
+virStorageVolDefFree(virStorageVolDef *def)
{
size_t i;
void
-virStoragePoolSourceDeviceClear(virStoragePoolSourceDevicePtr dev)
+virStoragePoolSourceDeviceClear(virStoragePoolSourceDevice *dev)
{
VIR_FREE(dev->freeExtents);
VIR_FREE(dev->path);
void
-virStoragePoolSourceClear(virStoragePoolSourcePtr source)
+virStoragePoolSourceClear(virStoragePoolSource *source)
{
size_t i;
void
-virStoragePoolSourceFree(virStoragePoolSourcePtr source)
+virStoragePoolSourceFree(virStoragePoolSource *source)
{
virStoragePoolSourceClear(source);
g_free(source);
void
-virStoragePoolDefFree(virStoragePoolDefPtr def)
+virStoragePoolDefFree(virStoragePoolDef *def)
{
if (!def)
return;
static int
virStoragePoolDefParseSource(xmlXPathContextPtr ctxt,
- virStoragePoolSourcePtr source,
+ virStoragePoolSource *source,
int pool_type,
xmlNodePtr node)
{
xmlNodePtr adapternode;
int nsource;
size_t i;
- virStoragePoolOptionsPtr options;
+ virStoragePoolOptions *options;
int n;
g_autoptr(virStorageAuthDef) authdef = NULL;
g_autofree char *port = NULL;
}
-virStoragePoolSourcePtr
+virStoragePoolSource *
virStoragePoolDefParseSourceString(const char *srcSpec,
int pool_type)
{
static int
virStorageDefParsePerms(xmlXPathContextPtr ctxt,
- virStoragePermsPtr perms,
+ virStoragePerms *perms,
const char *permxpath)
{
long long val;
static int
virStoragePoolDefRefreshParse(xmlXPathContextPtr ctxt,
- virStoragePoolDefPtr def)
+ virStoragePoolDef *def)
{
- g_autofree virStoragePoolDefRefreshPtr refresh = NULL;
+ g_autofree virStoragePoolDefRefresh *refresh = NULL;
g_autofree char *allocation = NULL;
int tmp;
static void
-virStoragePoolDefRefreshFormat(virBufferPtr buf,
- virStoragePoolDefRefreshPtr refresh)
+virStoragePoolDefRefreshFormat(virBuffer *buf,
+ virStoragePoolDefRefresh *refresh)
{
if (!refresh)
return;
static int
-virStoragePoolDefParseFeatures(virStoragePoolDefPtr def,
+virStoragePoolDefParseFeatures(virStoragePoolDef *def,
xmlXPathContextPtr ctxt)
{
g_autofree char *cow = virXPathString("string(./features/cow/@state)", ctxt);
}
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseXML(xmlXPathContextPtr ctxt)
{
- virStoragePoolOptionsPtr options;
+ virStoragePoolOptions *options;
xmlNodePtr source_node;
g_autoptr(virStoragePoolDef) def = NULL;
g_autofree char *type = NULL;
}
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseNode(xmlDocPtr xml,
xmlNodePtr root)
{
}
-static virStoragePoolDefPtr
+static virStoragePoolDef *
virStoragePoolDefParse(const char *xmlStr,
const char *filename)
{
- virStoragePoolDefPtr ret = NULL;
+ virStoragePoolDef *ret = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(storage_pool_definition)")))) {
}
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseString(const char *xmlStr)
{
return virStoragePoolDefParse(xmlStr, NULL);
}
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseFile(const char *filename)
{
return virStoragePoolDefParse(NULL, filename);
static int
-virStoragePoolSourceFormat(virBufferPtr buf,
- virStoragePoolOptionsPtr options,
- virStoragePoolSourcePtr src)
+virStoragePoolSourceFormat(virBuffer *buf,
+ virStoragePoolOptions *options,
+ virStoragePoolSource *src)
{
size_t i, j;
static void
-virStoragePoolDefFormatFeatures(virBufferPtr buf,
- virStoragePoolDefPtr def)
+virStoragePoolDefFormatFeatures(virBuffer *buf,
+ virStoragePoolDef *def)
{
if (def->features.cow == VIR_TRISTATE_BOOL_ABSENT)
return;
static int
-virStoragePoolDefFormatBuf(virBufferPtr buf,
- virStoragePoolDefPtr def)
+virStoragePoolDefFormatBuf(virBuffer *buf,
+ virStoragePoolDef *def)
{
- virStoragePoolOptionsPtr options;
+ virStoragePoolOptions *options;
char uuid[VIR_UUID_STRING_BUFLEN];
const char *type;
char *
-virStoragePoolDefFormat(virStoragePoolDefPtr def)
+virStoragePoolDefFormat(virStoragePoolDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
-static virStorageVolDefPtr
-virStorageVolDefParseXML(virStoragePoolDefPtr pool,
+static virStorageVolDef *
+virStorageVolDefParseXML(virStoragePoolDef *pool,
xmlXPathContextPtr ctxt,
unsigned int flags)
{
- virStorageVolOptionsPtr options;
+ virStorageVolOptions *options;
xmlNodePtr node;
size_t i;
int n;
}
-virStorageVolDefPtr
-virStorageVolDefParseNode(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseNode(virStoragePoolDef *pool,
xmlDocPtr xml,
xmlNodePtr root,
unsigned int flags)
}
-static virStorageVolDefPtr
-virStorageVolDefParse(virStoragePoolDefPtr pool,
+static virStorageVolDef *
+virStorageVolDefParse(virStoragePoolDef *pool,
const char *xmlStr,
const char *filename,
unsigned int flags)
{
- virStorageVolDefPtr ret = NULL;
+ virStorageVolDef *ret = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(storage_volume_definition)")))) {
}
-virStorageVolDefPtr
-virStorageVolDefParseString(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseString(virStoragePoolDef *pool,
const char *xmlStr,
unsigned int flags)
{
}
-virStorageVolDefPtr
-virStorageVolDefParseFile(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseFile(virStoragePoolDef *pool,
const char *filename,
unsigned int flags)
{
static void
-virStorageVolTimestampFormat(virBufferPtr buf, const char *name,
+virStorageVolTimestampFormat(virBuffer *buf, const char *name,
struct timespec *ts)
{
if (ts->tv_nsec < 0)
static int
-virStorageVolTargetDefFormat(virStorageVolOptionsPtr options,
- virBufferPtr buf,
- virStorageSourcePtr def,
+virStorageVolTargetDefFormat(virStorageVolOptions *options,
+ virBuffer *buf,
+ virStorageSource *def,
const char *type)
{
virBufferAsprintf(buf, "<%s>\n", type);
static void
-virStorageVolDefFormatSourceExtents(virBufferPtr buf,
- virStorageVolDefPtr def)
+virStorageVolDefFormatSourceExtents(virBuffer *buf,
+ virStorageVolDef *def)
{
size_t i;
const char *thispath = NULL;
char *
-virStorageVolDefFormat(virStoragePoolDefPtr pool,
- virStorageVolDefPtr def)
+virStorageVolDefFormat(virStoragePoolDef *pool,
+ virStorageVolDef *def)
{
- virStorageVolOptionsPtr options;
+ virStorageVolOptions *options;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) sourceChildBuf = VIR_BUFFER_INITIALIZER;
static int
virStoragePoolSaveXML(const char *path,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
const char *xml)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
int
virStoragePoolSaveState(const char *stateFile,
- virStoragePoolDefPtr def)
+ virStoragePoolDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autofree char *xml = NULL;
int
virStoragePoolSaveConfig(const char *configFile,
- virStoragePoolDefPtr def)
+ virStoragePoolDef *def)
{
g_autofree char *xml = NULL;
}
-virStoragePoolSourcePtr
-virStoragePoolSourceListNewSource(virStoragePoolSourceListPtr list)
+virStoragePoolSource *
+virStoragePoolSourceListNewSource(virStoragePoolSourceList *list)
{
- virStoragePoolSourcePtr source;
+ virStoragePoolSource *source;
VIR_REALLOC_N(list->sources, list->nsources + 1);
char *
-virStoragePoolSourceListFormat(virStoragePoolSourceListPtr def)
+virStoragePoolSourceListFormat(virStoragePoolSourceList *def)
{
- virStoragePoolOptionsPtr options;
+ virStoragePoolOptions *options;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *type;
size_t i;
int
virStoragePoolOptionsPoolTypeSetXMLNamespace(int type,
- virXMLNamespacePtr ns);
+ virXMLNamespace *ns);
int
-virStoragePoolOptionsFormatPool(virBufferPtr buf,
+virStoragePoolOptionsFormatPool(virBuffer *buf,
int type);
int
-virStoragePoolOptionsFormatVolume(virBufferPtr buf,
+virStoragePoolOptionsFormatVolume(virBuffer *buf,
int type);
/*
* How the volume's data is stored on underlying
* devices in LVM case.
*/
typedef struct _virStorageVolSourceExtent virStorageVolSourceExtent;
-typedef virStorageVolSourceExtent *virStorageVolSourceExtentPtr;
struct _virStorageVolSourceExtent {
char *path;
unsigned long long start;
};
typedef struct _virStorageVolSource virStorageVolSource;
-typedef virStorageVolSource *virStorageVolSourcePtr;
struct _virStorageVolSource {
size_t nextent;
- virStorageVolSourceExtentPtr extents;
+ virStorageVolSourceExtent *extents;
int partType; /* virStorageVolTypeDisk, only used by disk
* backend for partition type creation */
VIR_ENUM_DECL(virStorageVolDefRefreshAllocation);
typedef struct _virStorageVolDef virStorageVolDef;
-typedef virStorageVolDef *virStorageVolDefPtr;
struct _virStorageVolDef {
char *name;
char *key;
};
typedef struct _virStorageVolDefList virStorageVolDefList;
-typedef virStorageVolDefList *virStorageVolDefListPtr;
VIR_ENUM_DECL(virStorageVol);
* For remote pools, info on how to reach the host
*/
typedef struct _virStoragePoolSourceHost virStoragePoolSourceHost;
-typedef virStoragePoolSourceHost *virStoragePoolSourceHostPtr;
struct _virStoragePoolSourceHost {
char *name;
int port;
* Available extents on the underlying storage
*/
typedef struct _virStoragePoolSourceDeviceExtent virStoragePoolSourceDeviceExtent;
-typedef virStoragePoolSourceDeviceExtent *virStoragePoolSourceDeviceExtentPtr;
struct _virStoragePoolSourceDeviceExtent {
unsigned long long start;
unsigned long long end;
* allow us to track free space on underlying devices.
*/
typedef struct _virStoragePoolSourceDevice virStoragePoolSourceDevice;
-typedef virStoragePoolSourceDevice *virStoragePoolSourceDevicePtr;
struct _virStoragePoolSourceDevice {
int nfreeExtent;
- virStoragePoolSourceDeviceExtentPtr freeExtents;
+ virStoragePoolSourceDeviceExtent *freeExtents;
char *path;
int format; /* Pool specific source format */
int part_separator; /* enum virTristateSwitch */
};
typedef struct _virStoragePoolFeatures virStoragePoolFeatures;
-typedef virStoragePoolFeatures *virStoragePoolFeaturesPtr;
struct _virStoragePoolFeatures {
virTristateBool cow;
};
typedef struct _virStoragePoolSource virStoragePoolSource;
-typedef virStoragePoolSource *virStoragePoolSourcePtr;
struct _virStoragePoolSource {
/* An optional (maybe multiple) host(s) */
size_t nhost;
- virStoragePoolSourceHostPtr hosts;
+ virStoragePoolSourceHost *hosts;
/* And either one or more devices ... */
size_t ndevice;
- virStoragePoolSourceDevicePtr devices;
+ virStoragePoolSourceDevice *devices;
/* Or a directory */
char *dir;
virStorageSourceInitiatorDef initiator;
/* Authentication information */
- virStorageAuthDefPtr auth;
+ virStorageAuthDef *auth;
/* Vendor of the source */
char *vendor;
};
typedef struct _virStoragePoolTarget virStoragePoolTarget;
-typedef virStoragePoolTarget *virStoragePoolTargetPtr;
struct _virStoragePoolTarget {
char *path; /* Optional local filesystem mapping */
virStoragePerms perms; /* Default permissions for volumes */
typedef struct _virStorageVolDefRefresh virStorageVolDefRefresh;
-typedef virStorageVolDefRefresh *virStorageVolDefRefreshPtr;
struct _virStorageVolDefRefresh {
int allocation; /* virStorageVolDefRefreshAllocation */
};
typedef struct _virStoragePoolDefRefresh virStoragePoolDefRefresh;
-typedef virStoragePoolDefRefresh *virStoragePoolDefRefreshPtr;
struct _virStoragePoolDefRefresh {
virStorageVolDefRefresh volume;
};
typedef struct _virStoragePoolDef virStoragePoolDef;
-typedef virStoragePoolDef *virStoragePoolDefPtr;
struct _virStoragePoolDef {
char *name;
unsigned char uuid[VIR_UUID_BUFLEN];
int type; /* virStoragePoolType */
- virStoragePoolDefRefreshPtr refresh;
+ virStoragePoolDefRefresh *refresh;
unsigned long long allocation; /* bytes */
unsigned long long capacity; /* bytes */
};
typedef struct _virStoragePoolSourceList virStoragePoolSourceList;
-typedef virStoragePoolSourceList *virStoragePoolSourceListPtr;
struct _virStoragePoolSourceList {
int type;
unsigned int nsources;
- virStoragePoolSourcePtr sources;
+ virStoragePoolSource *sources;
};
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseXML(xmlXPathContextPtr ctxt);
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseString(const char *xml);
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseFile(const char *filename);
-virStoragePoolDefPtr
+virStoragePoolDef *
virStoragePoolDefParseNode(xmlDocPtr xml,
xmlNodePtr root);
char *
-virStoragePoolDefFormat(virStoragePoolDefPtr def);
+virStoragePoolDefFormat(virStoragePoolDef *def);
typedef enum {
/* do not require volume capacity at all */
VIR_VOL_XML_PARSE_OPT_CAPACITY = 1 << 1,
} virStorageVolDefParseFlags;
-virStorageVolDefPtr
-virStorageVolDefParseString(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseString(virStoragePoolDef *pool,
const char *xml,
unsigned int flags);
-virStorageVolDefPtr
-virStorageVolDefParseFile(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseFile(virStoragePoolDef *pool,
const char *filename,
unsigned int flags);
-virStorageVolDefPtr
-virStorageVolDefParseNode(virStoragePoolDefPtr pool,
+virStorageVolDef *
+virStorageVolDefParseNode(virStoragePoolDef *pool,
xmlDocPtr xml,
xmlNodePtr root,
unsigned int flags);
char *
-virStorageVolDefFormat(virStoragePoolDefPtr pool,
- virStorageVolDefPtr def);
+virStorageVolDefFormat(virStoragePoolDef *pool,
+ virStorageVolDef *def);
int
virStoragePoolSaveState(const char *stateFile,
- virStoragePoolDefPtr def);
+ virStoragePoolDef *def);
int
virStoragePoolSaveConfig(const char *configFile,
- virStoragePoolDefPtr def);
+ virStoragePoolDef *def);
void
-virStorageVolDefFree(virStorageVolDefPtr def);
+virStorageVolDefFree(virStorageVolDef *def);
void
-virStoragePoolSourceClear(virStoragePoolSourcePtr source);
+virStoragePoolSourceClear(virStoragePoolSource *source);
void
-virStoragePoolSourceDeviceClear(virStoragePoolSourceDevicePtr dev);
+virStoragePoolSourceDeviceClear(virStoragePoolSourceDevice *dev);
void
-virStoragePoolSourceFree(virStoragePoolSourcePtr source);
+virStoragePoolSourceFree(virStoragePoolSource *source);
void
-virStoragePoolDefFree(virStoragePoolDefPtr def);
+virStoragePoolDefFree(virStoragePoolDef *def);
-virStoragePoolSourcePtr
+virStoragePoolSource *
virStoragePoolDefParseSourceString(const char *srcSpec,
int pool_type);
-virStoragePoolSourcePtr
-virStoragePoolSourceListNewSource(virStoragePoolSourceListPtr list);
+virStoragePoolSource *
+virStoragePoolSourceListNewSource(virStoragePoolSourceList *list);
char *
-virStoragePoolSourceListFormat(virStoragePoolSourceListPtr def);
+virStoragePoolSourceListFormat(virStoragePoolSourceList *def);
typedef enum {
VIR_STORAGE_POOL_FS_AUTO = 0,
);
static void
-virStorageEncryptionInfoDefClear(virStorageEncryptionInfoDefPtr def)
+virStorageEncryptionInfoDefClear(virStorageEncryptionInfoDef *def)
{
VIR_FREE(def->cipher_name);
VIR_FREE(def->cipher_mode);
static void
-virStorageEncryptionSecretFree(virStorageEncryptionSecretPtr secret)
+virStorageEncryptionSecretFree(virStorageEncryptionSecret *secret)
{
if (!secret)
return;
}
void
-virStorageEncryptionFree(virStorageEncryptionPtr enc)
+virStorageEncryptionFree(virStorageEncryption *enc)
{
size_t i;
g_free(enc);
}
-static virStorageEncryptionSecretPtr
+static virStorageEncryptionSecret *
virStorageEncryptionSecretCopy(const virStorageEncryptionSecret *src)
{
- virStorageEncryptionSecretPtr ret = g_new0(virStorageEncryptionSecret, 1);
+ virStorageEncryptionSecret *ret = g_new0(virStorageEncryptionSecret, 1);
ret->type = src->type;
virSecretLookupDefCopy(&ret->seclookupdef, &src->seclookupdef);
static int
virStorageEncryptionInfoDefCopy(const virStorageEncryptionInfoDef *src,
- virStorageEncryptionInfoDefPtr dst)
+ virStorageEncryptionInfoDef *dst)
{
dst->cipher_size = src->cipher_size;
dst->cipher_name = g_strdup(src->cipher_name);
}
-virStorageEncryptionPtr
+virStorageEncryption *
virStorageEncryptionCopy(const virStorageEncryption *src)
{
- virStorageEncryptionPtr ret;
+ virStorageEncryption *ret;
size_t i;
ret = g_new0(virStorageEncryption, 1);
- ret->secrets = g_new0(virStorageEncryptionSecretPtr, src->nsecrets);
+ ret->secrets = g_new0(virStorageEncryptionSecret *, src->nsecrets);
ret->nsecrets = src->nsecrets;
ret->format = src->format;
return NULL;
}
-static virStorageEncryptionSecretPtr
+static virStorageEncryptionSecret *
virStorageEncryptionSecretParse(xmlXPathContextPtr ctxt,
xmlNodePtr node)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virStorageEncryptionSecretPtr ret;
+ virStorageEncryptionSecret *ret;
g_autofree char *type_str = NULL;
ret = g_new0(virStorageEncryptionSecret, 1);
static int
virStorageEncryptionInfoParseCipher(xmlNodePtr info_node,
- virStorageEncryptionInfoDefPtr info)
+ virStorageEncryptionInfoDef *info)
{
g_autofree char *size_str = NULL;
static int
virStorageEncryptionInfoParseIvgen(xmlNodePtr info_node,
- virStorageEncryptionInfoDefPtr info)
+ virStorageEncryptionInfoDef *info)
{
if (!(info->ivgen_name = virXMLPropString(info_node, "name"))) {
virReportError(VIR_ERR_XML_ERROR, "%s",
}
-virStorageEncryptionPtr
+virStorageEncryption *
virStorageEncryptionParseNode(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
xmlNodePtr *nodes = NULL;
- virStorageEncryptionPtr encdef = NULL;
- virStorageEncryptionPtr ret = NULL;
+ virStorageEncryption *encdef = NULL;
+ virStorageEncryption *ret = NULL;
g_autofree char *format_str = NULL;
int n;
size_t i;
goto cleanup;
if (n > 0) {
- encdef->secrets = g_new0(virStorageEncryptionSecretPtr, n);
+ encdef->secrets = g_new0(virStorageEncryptionSecret *, n);
encdef->nsecrets = n;
for (i = 0; i < n; i++) {
static int
-virStorageEncryptionSecretFormat(virBufferPtr buf,
- virStorageEncryptionSecretPtr secret)
+virStorageEncryptionSecretFormat(virBuffer *buf,
+ virStorageEncryptionSecret *secret)
{
const char *type;
static void
-virStorageEncryptionInfoDefFormat(virBufferPtr buf,
+virStorageEncryptionInfoDefFormat(virBuffer *buf,
const virStorageEncryptionInfoDef *enc)
{
virBufferEscapeString(buf, "<cipher name='%s'", enc->cipher_name);
int
-virStorageEncryptionFormat(virBufferPtr buf,
- virStorageEncryptionPtr enc)
+virStorageEncryptionFormat(virBuffer *buf,
+ virStorageEncryption *enc)
{
const char *format;
size_t i;
VIR_ENUM_DECL(virStorageEncryptionSecret);
typedef struct _virStorageEncryptionSecret virStorageEncryptionSecret;
-typedef virStorageEncryptionSecret *virStorageEncryptionSecretPtr;
struct _virStorageEncryptionSecret {
int type; /* virStorageEncryptionSecretType */
virSecretLookupTypeDef seclookupdef;
/* It's possible to dictate the cipher and if necessary iv */
typedef struct _virStorageEncryptionInfoDef virStorageEncryptionInfoDef;
-typedef virStorageEncryptionInfoDef *virStorageEncryptionInfoDefPtr;
struct _virStorageEncryptionInfoDef {
unsigned int cipher_size;
char *cipher_name;
VIR_ENUM_DECL(virStorageEncryptionFormat);
typedef struct _virStorageEncryption virStorageEncryption;
-typedef virStorageEncryption *virStorageEncryptionPtr;
struct _virStorageEncryption {
int format; /* virStorageEncryptionFormatType */
int payload_offset;
size_t nsecrets;
- virStorageEncryptionSecretPtr *secrets;
+ virStorageEncryptionSecret **secrets;
virStorageEncryptionInfoDef encinfo;
};
-virStorageEncryptionPtr virStorageEncryptionCopy(const virStorageEncryption *src)
+virStorageEncryption *virStorageEncryptionCopy(const virStorageEncryption *src)
ATTRIBUTE_NONNULL(1);
-void virStorageEncryptionFree(virStorageEncryptionPtr enc);
+void virStorageEncryptionFree(virStorageEncryption *enc);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageEncryption, virStorageEncryptionFree);
-virStorageEncryptionPtr virStorageEncryptionParseNode(xmlNodePtr node,
+virStorageEncryption *virStorageEncryptionParseNode(xmlNodePtr node,
xmlXPathContextPtr ctxt);
-int virStorageEncryptionFormat(virBufferPtr buf,
- virStorageEncryptionPtr enc);
+int virStorageEncryptionFormat(virBuffer *buf,
+ virStorageEncryption *enc);
/* A helper for VIR_STORAGE_ENCRYPTION_FORMAT_QCOW */
enum {
bool dummy;
};
typedef struct _virStoragePoolEvent virStoragePoolEvent;
-typedef virStoragePoolEvent *virStoragePoolEventPtr;
struct _virStoragePoolEventLifecycle {
virStoragePoolEvent parent;
int detail;
};
typedef struct _virStoragePoolEventLifecycle virStoragePoolEventLifecycle;
-typedef virStoragePoolEventLifecycle *virStoragePoolEventLifecyclePtr;
struct _virStoragePoolEventRefresh {
virStoragePoolEvent parent;
bool dummy;
};
typedef struct _virStoragePoolEventRefresh virStoragePoolEventRefresh;
-typedef virStoragePoolEventRefresh *virStoragePoolEventRefreshPtr;
-static virClassPtr virStoragePoolEventClass;
-static virClassPtr virStoragePoolEventLifecycleClass;
-static virClassPtr virStoragePoolEventRefreshClass;
+static virClass *virStoragePoolEventClass;
+static virClass *virStoragePoolEventLifecycleClass;
+static virClass *virStoragePoolEventRefreshClass;
static void virStoragePoolEventDispose(void *obj);
static void virStoragePoolEventLifecycleDispose(void *obj);
static void virStoragePoolEventRefreshDispose(void *obj);
static void
virStoragePoolEventDispose(void *obj)
{
- virStoragePoolEventPtr event = obj;
+ virStoragePoolEvent *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virStoragePoolEventLifecycleDispose(void *obj)
{
- virStoragePoolEventLifecyclePtr event = obj;
+ virStoragePoolEventLifecycle *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virStoragePoolEventRefreshDispose(void *obj)
{
- virStoragePoolEventRefreshPtr event = obj;
+ virStoragePoolEventRefresh *event = obj;
VIR_DEBUG("obj=%p", event);
}
static void
virStoragePoolEventDispatchDefaultFunc(virConnectPtr conn,
- virObjectEventPtr event,
+ virObjectEvent *event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
switch ((virStoragePoolEventID)event->eventID) {
case VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE:
{
- virStoragePoolEventLifecyclePtr storagePoolLifecycleEvent;
+ virStoragePoolEventLifecycle *storagePoolLifecycleEvent;
- storagePoolLifecycleEvent = (virStoragePoolEventLifecyclePtr)event;
+ storagePoolLifecycleEvent = (virStoragePoolEventLifecycle *)event;
((virConnectStoragePoolEventLifecycleCallback)cb)(conn, pool,
storagePoolLifecycleEvent->type,
storagePoolLifecycleEvent->detail,
*/
int
virStoragePoolEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virStoragePoolPtr pool,
int eventID,
virConnectStoragePoolEventGenericCallback cb,
*/
int
virStoragePoolEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virStoragePoolPtr pool,
int eventID,
virConnectStoragePoolEventGenericCallback cb,
*
* Create a new storage pool lifecycle event.
*/
-virObjectEventPtr
+virObjectEvent *
virStoragePoolEventLifecycleNew(const char *name,
const unsigned char *uuid,
int type,
int detail)
{
- virStoragePoolEventLifecyclePtr event;
+ virStoragePoolEventLifecycle *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virStoragePoolEventsInitialize() < 0)
event->type = type;
event->detail = detail;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
*
* Create a new storage pool refresh event.
*/
-virObjectEventPtr
+virObjectEvent *
virStoragePoolEventRefreshNew(const char *name,
const unsigned char *uuid)
{
- virStoragePoolEventRefreshPtr event;
+ virStoragePoolEventRefresh *event;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virStoragePoolEventsInitialize() < 0)
0, name, uuid, uuidstr)))
return NULL;
- return (virObjectEventPtr)event;
+ return (virObjectEvent *)event;
}
int
virStoragePoolEventStateRegisterID(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virStoragePoolPtr pool,
int eventID,
virConnectStoragePoolEventGenericCallback cb,
int
virStoragePoolEventStateRegisterClient(virConnectPtr conn,
- virObjectEventStatePtr state,
+ virObjectEventState *state,
virStoragePoolPtr pool,
int eventID,
virConnectStoragePoolEventGenericCallback cb,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
ATTRIBUTE_NONNULL(8);
-virObjectEventPtr
+virObjectEvent *
virStoragePoolEventLifecycleNew(const char *name,
const unsigned char *uuid,
int type,
int detail);
-virObjectEventPtr
+virObjectEvent *
virStoragePoolEventRefreshNew(const char *name,
const unsigned char *uuid);
VIR_LOG_INIT("conf.storage_source_conf");
-static virClassPtr virStorageSourceClass;
+static virClass *virStorageSourceClass;
VIR_ENUM_IMPL(virStorage,
void
-virStorageNetHostDefClear(virStorageNetHostDefPtr def)
+virStorageNetHostDefClear(virStorageNetHostDef *def)
{
if (!def)
return;
void
virStorageNetHostDefFree(size_t nhosts,
- virStorageNetHostDefPtr hosts)
+ virStorageNetHostDef *hosts)
{
size_t i;
static void
-virStoragePermsFree(virStoragePermsPtr def)
+virStoragePermsFree(virStoragePerms *def)
{
if (!def)
return;
}
-virStorageNetHostDefPtr
+virStorageNetHostDef *
virStorageNetHostDefCopy(size_t nhosts,
- virStorageNetHostDefPtr hosts)
+ virStorageNetHostDef *hosts)
{
- virStorageNetHostDefPtr ret = NULL;
+ virStorageNetHostDef *ret = NULL;
size_t i;
ret = g_new0(virStorageNetHostDef, nhosts);
for (i = 0; i < nhosts; i++) {
- virStorageNetHostDefPtr src = &hosts[i];
- virStorageNetHostDefPtr dst = &ret[i];
+ virStorageNetHostDef *src = &hosts[i];
+ virStorageNetHostDef *dst = &ret[i];
dst->transport = src->transport;
dst->port = src->port;
void
-virStorageAuthDefFree(virStorageAuthDefPtr authdef)
+virStorageAuthDefFree(virStorageAuthDef *authdef)
{
if (!authdef)
return;
}
-virStorageAuthDefPtr
+virStorageAuthDef *
virStorageAuthDefCopy(const virStorageAuthDef *src)
{
g_autoptr(virStorageAuthDef) authdef = NULL;
}
-virStorageAuthDefPtr
+virStorageAuthDef *
virStorageAuthDefParse(xmlNodePtr node,
xmlXPathContextPtr ctxt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virStorageAuthDefPtr ret = NULL;
+ virStorageAuthDef *ret = NULL;
xmlNodePtr secretnode = NULL;
g_autoptr(virStorageAuthDef) authdef = NULL;
g_autofree char *authtype = NULL;
void
-virStorageAuthDefFormat(virBufferPtr buf,
- virStorageAuthDefPtr authdef)
+virStorageAuthDefFormat(virBuffer *buf,
+ virStorageAuthDef *authdef)
{
if (authdef->authType == VIR_STORAGE_AUTH_TYPE_NONE) {
virBufferEscapeString(buf, "<auth username='%s'>\n", authdef->username);
void
-virStoragePRDefFree(virStoragePRDefPtr prd)
+virStoragePRDefFree(virStoragePRDef *prd)
{
if (!prd)
return;
}
-virStoragePRDefPtr
+virStoragePRDef *
virStoragePRDefParseXML(xmlXPathContextPtr ctxt)
{
- virStoragePRDefPtr prd;
- virStoragePRDefPtr ret = NULL;
+ virStoragePRDef *prd;
+ virStoragePRDef *ret = NULL;
g_autofree char *managed = NULL;
g_autofree char *type = NULL;
g_autofree char *path = NULL;
void
-virStoragePRDefFormat(virBufferPtr buf,
- virStoragePRDefPtr prd,
+virStoragePRDefFormat(virBuffer *buf,
+ virStoragePRDef *prd,
bool migratable)
{
virBufferAsprintf(buf, "<reservations managed='%s'",
bool
-virStoragePRDefIsEqual(virStoragePRDefPtr a,
- virStoragePRDefPtr b)
+virStoragePRDefIsEqual(virStoragePRDef *a,
+ virStoragePRDef *b)
{
if (!a && !b)
return true;
bool
-virStoragePRDefIsManaged(virStoragePRDefPtr prd)
+virStoragePRDefIsManaged(virStoragePRDef *prd)
{
return prd && prd->managed == VIR_TRISTATE_BOOL_YES;
}
bool
-virStorageSourceChainHasManagedPR(virStorageSourcePtr src)
+virStorageSourceChainHasManagedPR(virStorageSource *src)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
if (virStoragePRDefIsManaged(n->pr))
}
-static virStoragePRDefPtr
-virStoragePRDefCopy(virStoragePRDefPtr src)
+static virStoragePRDef *
+virStoragePRDefCopy(virStoragePRDef *src)
{
- virStoragePRDefPtr copy = NULL;
- virStoragePRDefPtr ret = NULL;
+ virStoragePRDef *copy = NULL;
+ virStoragePRDef *ret = NULL;
copy = g_new0(virStoragePRDef, 1);
}
-static virStorageSourceNVMeDefPtr
+static virStorageSourceNVMeDef *
virStorageSourceNVMeDefCopy(const virStorageSourceNVMeDef *src)
{
- virStorageSourceNVMeDefPtr ret = NULL;
+ virStorageSourceNVMeDef *ret = NULL;
ret = g_new0(virStorageSourceNVMeDef, 1);
void
-virStorageSourceNVMeDefFree(virStorageSourceNVMeDefPtr def)
+virStorageSourceNVMeDefFree(virStorageSourceNVMeDef *def)
{
if (!def)
return;
}
-virSecurityDeviceLabelDefPtr
-virStorageSourceGetSecurityLabelDef(virStorageSourcePtr src,
+virSecurityDeviceLabelDef *
+virStorageSourceGetSecurityLabelDef(virStorageSource *src,
const char *model)
{
size_t i;
static void
-virStorageSourceSeclabelsClear(virStorageSourcePtr def)
+virStorageSourceSeclabelsClear(virStorageSource *def)
{
size_t i;
static int
-virStorageSourceSeclabelsCopy(virStorageSourcePtr to,
+virStorageSourceSeclabelsCopy(virStorageSource *to,
const virStorageSource *from)
{
size_t i;
if (from->nseclabels == 0)
return 0;
- to->seclabels = g_new0(virSecurityDeviceLabelDefPtr, from->nseclabels);
+ to->seclabels = g_new0(virSecurityDeviceLabelDef *, from->nseclabels);
to->nseclabels = from->nseclabels;
for (i = 0; i < to->nseclabels; i++) {
void
-virStorageNetCookieDefFree(virStorageNetCookieDefPtr def)
+virStorageNetCookieDefFree(virStorageNetCookieDef *def)
{
if (!def)
return;
static void
-virStorageSourceNetCookiesClear(virStorageSourcePtr src)
+virStorageSourceNetCookiesClear(virStorageSource *src)
{
size_t i;
static void
-virStorageSourceNetCookiesCopy(virStorageSourcePtr to,
+virStorageSourceNetCookiesCopy(virStorageSource *to,
const virStorageSource *from)
{
size_t i;
if (from->ncookies == 0)
return;
- to->cookies = g_new0(virStorageNetCookieDefPtr, from->ncookies);
+ to->cookies = g_new0(virStorageNetCookieDef *, from->ncookies);
to->ncookies = from->ncookies;
for (i = 0; i < from->ncookies; i++) {
"()<>@:/[]?={}";
static int
-virStorageSourceNetCookieValidate(virStorageNetCookieDefPtr def)
+virStorageSourceNetCookieValidate(virStorageNetCookieDef *def)
{
g_autofree char *val = g_strdup(def->value);
const char *checkval = val;
int
-virStorageSourceNetCookiesValidate(virStorageSourcePtr src)
+virStorageSourceNetCookiesValidate(virStorageSource *src)
{
size_t i;
size_t j;
}
-static virStorageTimestampsPtr
+static virStorageTimestamps *
virStorageTimestampsCopy(const virStorageTimestamps *src)
{
- virStorageTimestampsPtr ret;
+ virStorageTimestamps *ret;
ret = g_new0(virStorageTimestamps, 1);
}
-static virStoragePermsPtr
+static virStoragePerms *
virStoragePermsCopy(const virStoragePerms *src)
{
- virStoragePermsPtr ret;
+ virStoragePerms *ret;
ret = g_new0(virStoragePerms, 1);
}
-static virStorageSourcePoolDefPtr
+static virStorageSourcePoolDef *
virStorageSourcePoolDefCopy(const virStorageSourcePoolDef *src)
{
- virStorageSourcePoolDefPtr ret;
+ virStorageSourcePoolDef *ret;
ret = g_new0(virStorageSourcePoolDef, 1);
}
-static virStorageSourceSlicePtr
+static virStorageSourceSlice *
virStorageSourceSliceCopy(const virStorageSourceSlice *src)
{
- virStorageSourceSlicePtr ret = g_new0(virStorageSourceSlice, 1);
+ virStorageSourceSlice *ret = g_new0(virStorageSourceSlice, 1);
ret->offset = src->offset;
ret->size = src->size;
static void
-virStorageSourceSliceFree(virStorageSourceSlicePtr slice)
+virStorageSourceSliceFree(virStorageSourceSlice *slice)
{
if (!slice)
return;
/**
- * virStorageSourcePtr:
+ * virStorageSource *:
*
* Deep-copies a virStorageSource structure. If @backing chain is true
* then also copies the backing chain recursively, otherwise just
* storage driver access structure and thus the struct needs to be initialized
* separately.
*/
-virStorageSourcePtr
+virStorageSource *
virStorageSourceCopy(const virStorageSource *src,
bool backingChain)
{
* This does not compare any other configuration option
*/
bool
-virStorageSourceIsSameLocation(virStorageSourcePtr a,
- virStorageSourcePtr b)
+virStorageSourceIsSameLocation(virStorageSource *a,
+ virStorageSource *b)
{
size_t i;
* Returns 0 on success, -1 on error.
*/
int
-virStorageSourceInitChainElement(virStorageSourcePtr newelem,
- virStorageSourcePtr old,
+virStorageSourceInitChainElement(virStorageSource *newelem,
+ virStorageSource *old,
bool transferLabels)
{
if (transferLabels &&
void
-virStorageSourcePoolDefFree(virStorageSourcePoolDefPtr def)
+virStorageSourcePoolDefFree(virStorageSourcePoolDef *def)
{
if (!def)
return;
* (such as an empty cdrom drive).
*/
bool
-virStorageSourceIsEmpty(virStorageSourcePtr src)
+virStorageSourceIsEmpty(virStorageSource *src)
{
if (virStorageSourceIsLocalStorage(src) && !src->path)
return true;
* Clears information about backing store of the current storage file.
*/
void
-virStorageSourceBackingStoreClear(virStorageSourcePtr def)
+virStorageSourceBackingStoreClear(virStorageSource *def)
{
if (!def)
return;
void
-virStorageSourceClear(virStorageSourcePtr def)
+virStorageSourceClear(virStorageSource *def)
{
if (!def)
return;
static void
virStorageSourceDispose(void *obj)
{
- virStorageSourcePtr src = obj;
+ virStorageSource *src = obj;
virStorageSourceClear(src);
}
VIR_ONCE_GLOBAL_INIT(virStorageSource);
-virStorageSourcePtr
+virStorageSource *
virStorageSourceNew(void)
{
- virStorageSourcePtr ret;
+ virStorageSource *ret;
if (virStorageSourceInitialize() < 0)
abort();
* Returns true if given storage source definition is a relative path.
*/
bool
-virStorageSourceIsRelative(virStorageSourcePtr src)
+virStorageSourceIsRelative(virStorageSource *src)
{
virStorageType actual_type = virStorageSourceGetActualType(src);
void
-virStorageSourceNetworkAssignDefaultPorts(virStorageSourcePtr src)
+virStorageSourceNetworkAssignDefaultPorts(virStorageSource *src)
{
size_t i;
int
virStorageSourcePrivateDataParseRelPath(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
src->relPath = virXPathString("string(./relPath)", ctxt);
return 0;
int
-virStorageSourcePrivateDataFormatRelPath(virStorageSourcePtr src,
- virBufferPtr buf)
+virStorageSourcePrivateDataFormatRelPath(virStorageSource *src,
+ virBuffer *buf)
{
if (src->relPath)
virBufferEscapeString(buf, "<relPath>%s</relPath>\n", src->relPath);
void
virStorageSourceInitiatorParseXML(xmlXPathContextPtr ctxt,
- virStorageSourceInitiatorDefPtr initiator)
+ virStorageSourceInitiatorDef *initiator)
{
initiator->iqn = virXPathString("string(./initiator/iqn/@name)", ctxt);
}
void
-virStorageSourceInitiatorFormatXML(virStorageSourceInitiatorDefPtr initiator,
- virBufferPtr buf)
+virStorageSourceInitiatorFormatXML(virStorageSourceInitiatorDef *initiator,
+ virBuffer *buf)
{
if (!initiator->iqn)
return;
int
-virStorageSourceInitiatorCopy(virStorageSourceInitiatorDefPtr dest,
+virStorageSourceInitiatorCopy(virStorageSourceInitiatorDef *dest,
const virStorageSourceInitiatorDef *src)
{
dest->iqn = g_strdup(src->iqn);
void
-virStorageSourceInitiatorClear(virStorageSourceInitiatorDefPtr initiator)
+virStorageSourceInitiatorClear(virStorageSourceInitiatorDef *initiator)
{
VIR_FREE(initiator->iqn);
}
typedef struct _virStoragePerms virStoragePerms;
-typedef virStoragePerms *virStoragePermsPtr;
struct _virStoragePerms {
mode_t mode;
uid_t uid;
typedef struct _virStorageTimestamps virStorageTimestamps;
-typedef virStorageTimestamps *virStorageTimestampsPtr;
struct _virStorageTimestamps {
struct timespec atime;
struct timespec btime; /* birth time unknown if btime.tv_nsec == -1 */
typedef struct _virStorageNetHostDef virStorageNetHostDef;
-typedef virStorageNetHostDef *virStorageNetHostDefPtr;
struct _virStorageNetHostDef {
char *name;
unsigned int port;
typedef struct _virStorageNetCookieDef virStorageNetCookieDef;
-typedef virStorageNetCookieDef *virStorageNetCookieDefPtr;
struct _virStorageNetCookieDef {
char *name;
char *value;
void
-virStorageNetCookieDefFree(virStorageNetCookieDefPtr def);
+virStorageNetCookieDefFree(virStorageNetCookieDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageNetCookieDef, virStorageNetCookieDefFree);
typedef struct _virStorageSourcePoolDef virStorageSourcePoolDef;
-typedef virStorageSourcePoolDef *virStorageSourcePoolDefPtr;
struct _virStorageSourcePoolDef {
char *pool; /* pool name */
char *volume; /* volume name */
typedef struct _virStorageAuthDef virStorageAuthDef;
-typedef virStorageAuthDef *virStorageAuthDefPtr;
struct _virStorageAuthDef {
char *username;
char *secrettype; /* <secret type='%s' for disk source */
typedef struct _virStoragePRDef virStoragePRDef;
-typedef virStoragePRDef *virStoragePRDefPtr;
struct _virStoragePRDef {
int managed; /* enum virTristateBool */
char *path;
typedef struct _virStorageSourceInitiatorDef virStorageSourceInitiatorDef;
-typedef virStorageSourceInitiatorDef *virStorageSourceInitiatorDefPtr;
struct _virStorageSourceInitiatorDef {
char *iqn; /* Initiator IQN */
};
typedef struct _virStorageSourceNVMeDef virStorageSourceNVMeDef;
-typedef virStorageSourceNVMeDef *virStorageSourceNVMeDefPtr;
struct _virStorageSourceNVMeDef {
unsigned long long namespc;
int managed; /* enum virTristateBool */
typedef struct _virStorageSourceSlice virStorageSourceSlice;
-typedef virStorageSourceSlice *virStorageSourceSlicePtr;
struct _virStorageSourceSlice {
unsigned long long offset;
unsigned long long size;
typedef struct _virStorageSource virStorageSource;
-typedef virStorageSource *virStorageSourcePtr;
/* Stores information related to a host resource. In the case of backing
* chains, multiple source disks join to form a single guest view.
the source definition */
char *query; /* query string for HTTP based protocols */
size_t nhosts;
- virStorageNetHostDefPtr hosts;
+ virStorageNetHostDef *hosts;
size_t ncookies;
- virStorageNetCookieDefPtr *cookies;
- virStorageSourcePoolDefPtr srcpool;
- virStorageAuthDefPtr auth;
- virStorageEncryptionPtr encryption;
- virStoragePRDefPtr pr;
+ virStorageNetCookieDef **cookies;
+ virStorageSourcePoolDef *srcpool;
+ virStorageAuthDef *auth;
+ virStorageEncryption *encryption;
+ virStoragePRDef *pr;
virTristateBool sslverify;
/* both values below have 0 as default value */
unsigned long long readahead; /* size of the readahead buffer in bytes */
unsigned long long timeout; /* connection timeout in seconds */
- virStorageSourceNVMeDefPtr nvme; /* type == VIR_STORAGE_TYPE_NVME */
+ virStorageSourceNVMeDef *nvme; /* type == VIR_STORAGE_TYPE_NVME */
- virDomainChrSourceDefPtr vhostuser; /* type == VIR_STORAGE_TYPE_VHOST_USER */
+ virDomainChrSourceDef *vhostuser; /* type == VIR_STORAGE_TYPE_VHOST_USER */
virStorageSourceInitiatorDef initiator;
- virObjectPtr privateData;
+ virObject *privateData;
int format; /* virStorageFileFormat in domain backing chains, but
* pool-specific enum for storage volumes */
- virBitmapPtr features;
+ virBitmap *features;
char *compat;
bool nocow;
bool sparse;
- virStorageSourceSlicePtr sliceStorage;
+ virStorageSourceSlice *sliceStorage;
- virStoragePermsPtr perms;
- virStorageTimestampsPtr timestamps;
+ virStoragePerms *perms;
+ virStorageTimestamps *timestamps;
unsigned long long capacity; /* in bytes, 0 if unknown */
unsigned long long allocation; /* in bytes, 0 if unknown */
unsigned long long physical; /* in bytes, 0 if unknown */
unsigned long long metadataCacheMaxSize; /* size of the metadata cache in bytes */
size_t nseclabels;
- virSecurityDeviceLabelDefPtr *seclabels;
+ virSecurityDeviceLabelDef **seclabels;
/* Don't ever write to the image */
bool readonly;
bool shared;
/* backing chain of the storage source */
- virStorageSourcePtr backingStore;
+ virStorageSource *backingStore;
/* metadata for storage driver access to remote and local volumes */
void *drv;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageSource, virObjectUnref);
void
-virStorageAuthDefFree(virStorageAuthDefPtr def);
+virStorageAuthDefFree(virStorageAuthDef *def);
-virStorageAuthDefPtr
+virStorageAuthDef *
virStorageAuthDefCopy(const virStorageAuthDef *src);
-virStorageAuthDefPtr
+virStorageAuthDef *
virStorageAuthDefParse(xmlNodePtr node,
xmlXPathContextPtr ctxt);
void
-virStorageAuthDefFormat(virBufferPtr buf,
- virStorageAuthDefPtr authdef);
+virStorageAuthDefFormat(virBuffer *buf,
+ virStorageAuthDef *authdef);
void
-virStoragePRDefFree(virStoragePRDefPtr prd);
+virStoragePRDefFree(virStoragePRDef *prd);
-virStoragePRDefPtr
+virStoragePRDef *
virStoragePRDefParseXML(xmlXPathContextPtr ctxt);
void
-virStoragePRDefFormat(virBufferPtr buf,
- virStoragePRDefPtr prd,
+virStoragePRDefFormat(virBuffer *buf,
+ virStoragePRDef *prd,
bool migratable);
bool
-virStoragePRDefIsEqual(virStoragePRDefPtr a,
- virStoragePRDefPtr b);
+virStoragePRDefIsEqual(virStoragePRDef *a,
+ virStoragePRDef *b);
bool
-virStoragePRDefIsManaged(virStoragePRDefPtr prd);
+virStoragePRDefIsManaged(virStoragePRDef *prd);
bool
-virStorageSourceChainHasManagedPR(virStorageSourcePtr src);
+virStorageSourceChainHasManagedPR(virStorageSource *src);
void
-virStorageSourceNVMeDefFree(virStorageSourceNVMeDefPtr def);
+virStorageSourceNVMeDefFree(virStorageSourceNVMeDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageSourceNVMeDef, virStorageSourceNVMeDefFree);
bool
virStorageSourceChainHasNVMe(const virStorageSource *src);
-virSecurityDeviceLabelDefPtr
-virStorageSourceGetSecurityLabelDef(virStorageSourcePtr src,
+virSecurityDeviceLabelDef *
+virStorageSourceGetSecurityLabelDef(virStorageSource *src,
const char *model);
void
-virStorageNetHostDefClear(virStorageNetHostDefPtr def);
+virStorageNetHostDefClear(virStorageNetHostDef *def);
void
virStorageNetHostDefFree(size_t nhosts,
- virStorageNetHostDefPtr hosts);
+ virStorageNetHostDef *hosts);
-virStorageNetHostDefPtr
+virStorageNetHostDef *
virStorageNetHostDefCopy(size_t nhosts,
- virStorageNetHostDefPtr hosts);
+ virStorageNetHostDef *hosts);
int
-virStorageSourceInitChainElement(virStorageSourcePtr newelem,
- virStorageSourcePtr old,
+virStorageSourceInitChainElement(virStorageSource *newelem,
+ virStorageSource *old,
bool force);
void
-virStorageSourcePoolDefFree(virStorageSourcePoolDefPtr def);
+virStorageSourcePoolDefFree(virStorageSourcePoolDef *def);
void
-virStorageSourceClear(virStorageSourcePtr def);
+virStorageSourceClear(virStorageSource *def);
int
virStorageSourceGetActualType(const virStorageSource *def);
virStorageSourceIsLocalStorage(const virStorageSource *src);
bool
-virStorageSourceIsEmpty(virStorageSourcePtr src);
+virStorageSourceIsEmpty(virStorageSource *src);
bool
virStorageSourceIsBlockLocal(const virStorageSource *src);
-virStorageSourcePtr
+virStorageSource *
virStorageSourceNew(void);
void
-virStorageSourceBackingStoreClear(virStorageSourcePtr def);
+virStorageSourceBackingStoreClear(virStorageSource *def);
int
-virStorageSourceNetCookiesValidate(virStorageSourcePtr src);
+virStorageSourceNetCookiesValidate(virStorageSource *src);
-virStorageSourcePtr
+virStorageSource *
virStorageSourceCopy(const virStorageSource *src,
bool backingChain)
ATTRIBUTE_NONNULL(1);
bool
-virStorageSourceIsSameLocation(virStorageSourcePtr a,
- virStorageSourcePtr b)
+virStorageSourceIsSameLocation(virStorageSource *a,
+ virStorageSource *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
bool
-virStorageSourceIsRelative(virStorageSourcePtr src);
+virStorageSourceIsRelative(virStorageSource *src);
void
-virStorageSourceNetworkAssignDefaultPorts(virStorageSourcePtr src)
+virStorageSourceNetworkAssignDefaultPorts(virStorageSource *src)
ATTRIBUTE_NONNULL(1);
bool
int
virStorageSourcePrivateDataParseRelPath(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src);
+ virStorageSource *src);
int
-virStorageSourcePrivateDataFormatRelPath(virStorageSourcePtr src,
- virBufferPtr buf);
+virStorageSourcePrivateDataFormatRelPath(virStorageSource *src,
+ virBuffer *buf);
void
virStorageSourceInitiatorParseXML(xmlXPathContextPtr ctxt,
- virStorageSourceInitiatorDefPtr initiator);
+ virStorageSourceInitiatorDef *initiator);
void
-virStorageSourceInitiatorFormatXML(virStorageSourceInitiatorDefPtr initiator,
- virBufferPtr buf);
+virStorageSourceInitiatorFormatXML(virStorageSourceInitiatorDef *initiator,
+ virBuffer *buf);
int
-virStorageSourceInitiatorCopy(virStorageSourceInitiatorDefPtr dest,
+virStorageSourceInitiatorCopy(virStorageSourceInitiatorDef *dest,
const virStorageSourceInitiatorDef *src);
void
-virStorageSourceInitiatorClear(virStorageSourceInitiatorDefPtr initiator);
+virStorageSourceInitiatorClear(virStorageSourceInitiatorDef *initiator);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virStorageAuthDef, virStorageAuthDefFree);
};
typedef struct _virChrdevStreamInfo virChrdevStreamInfo;
-typedef virChrdevStreamInfo *virChrdevStreamInfoPtr;
struct _virChrdevStreamInfo {
- virChrdevsPtr devs;
+ virChrdevs *devs;
char *path;
};
*/
static void virChrdevFDStreamCloseCbFree(void *opaque)
{
- virChrdevStreamInfoPtr priv = opaque;
+ virChrdevStreamInfo *priv = opaque;
g_free(priv->path);
g_free(priv);
static void virChrdevFDStreamCloseCb(virStreamPtr st G_GNUC_UNUSED,
void *opaque)
{
- virChrdevStreamInfoPtr priv = opaque;
+ virChrdevStreamInfo *priv = opaque;
virMutexLock(&priv->devs->lock);
/* remove entry from hash */
*
* Returns pointer to the allocated structure or NULL on error
*/
-virChrdevsPtr virChrdevAlloc(void)
+virChrdevs *virChrdevAlloc(void)
{
- virChrdevsPtr devs;
+ virChrdevs *devs;
devs = g_new0(virChrdevs, 1);
if (virMutexInit(&devs->lock) < 0) {
*
* @devs Pointer to the private structure.
*/
-void virChrdevFree(virChrdevsPtr devs)
+void virChrdevFree(virChrdevs *devs)
{
if (!devs)
return;
* corresponding lock file is created (if configured). Returns -1 on
* error and 1 if the device stream is open and busy.
*/
-int virChrdevOpen(virChrdevsPtr devs,
- virDomainChrSourceDefPtr source,
+int virChrdevOpen(virChrdevs *devs,
+ virDomainChrSourceDef *source,
virStreamPtr st,
bool force)
{
- virChrdevStreamInfoPtr cbdata = NULL;
+ virChrdevStreamInfo *cbdata = NULL;
virChrdevHashEntry *ent;
char *path;
int ret;
#include "domain_conf.h"
typedef struct _virChrdevs virChrdevs;
-typedef virChrdevs *virChrdevsPtr;
-virChrdevsPtr virChrdevAlloc(void);
-void virChrdevFree(virChrdevsPtr devs);
+virChrdevs *virChrdevAlloc(void);
+void virChrdevFree(virChrdevs *devs);
-int virChrdevOpen(virChrdevsPtr devs, virDomainChrSourceDefPtr source,
+int virChrdevOpen(virChrdevs *devs, virDomainChrSourceDef *source,
virStreamPtr st, bool force);
/* forward declarations of various types required in src/conf */
typedef struct _virBlkioDevice virBlkioDevice;
-typedef virBlkioDevice *virBlkioDevicePtr;
typedef struct _virCaps virCaps;
-typedef virCaps *virCapsPtr;
typedef struct _virCapsDomainData virCapsDomainData;
-typedef virCapsDomainData *virCapsDomainDataPtr;
typedef struct _virCapsGuest virCapsGuest;
-typedef virCapsGuest *virCapsGuestPtr;
typedef struct _virCapsGuestArch virCapsGuestArch;
-typedef virCapsGuestArch *virCapsGuestArchPtr;
typedef struct _virCapsGuestDomain virCapsGuestDomain;
-typedef virCapsGuestDomain *virCapsGuestDomainPtr;
typedef struct _virCapsGuestDomainInfo virCapsGuestDomainInfo;
-typedef virCapsGuestDomainInfo *virCapsGuestDomainInfoPtr;
typedef struct _virCapsGuestFeature virCapsGuestFeature;
-typedef virCapsGuestFeature *virCapsGuestFeaturePtr;
typedef struct _virCapsGuestMachine virCapsGuestMachine;
-typedef virCapsGuestMachine *virCapsGuestMachinePtr;
typedef struct _virCapsHost virCapsHost;
-typedef virCapsHost *virCapsHostPtr;
typedef struct _virCapsHostCache virCapsHostCache;
-typedef virCapsHostCache *virCapsHostCachePtr;
typedef struct _virCapsHostCacheBank virCapsHostCacheBank;
-typedef virCapsHostCacheBank *virCapsHostCacheBankPtr;
typedef struct _virCapsHostMemBW virCapsHostMemBW;
-typedef virCapsHostMemBW *virCapsHostMemBWPtr;
typedef struct _virCapsHostMemBWNode virCapsHostMemBWNode;
-typedef virCapsHostMemBWNode *virCapsHostMemBWNodePtr;
typedef struct _virCapsHostNUMA virCapsHostNUMA;
-typedef virCapsHostNUMA *virCapsHostNUMAPtr;
typedef struct _virCapsHostNUMACell virCapsHostNUMACell;
-typedef virCapsHostNUMACell *virCapsHostNUMACellPtr;
typedef struct _virCapsHostNUMACellCPU virCapsHostNUMACellCPU;
-typedef virCapsHostNUMACellCPU *virCapsHostNUMACellCPUPtr;
typedef struct _virCapsHostNUMACellPageInfo virCapsHostNUMACellPageInfo;
-typedef virCapsHostNUMACellPageInfo *virCapsHostNUMACellPageInfoPtr;
typedef struct _virCapsHostNUMACellSiblingInfo virCapsHostNUMACellSiblingInfo;
-typedef virCapsHostNUMACellSiblingInfo *virCapsHostNUMACellSiblingInfoPtr;
typedef struct _virCapsHostSecModel virCapsHostSecModel;
-typedef virCapsHostSecModel *virCapsHostSecModelPtr;
typedef struct _virCapsHostSecModelLabel virCapsHostSecModelLabel;
-typedef virCapsHostSecModelLabel *virCapsHostSecModelLabelPtr;
typedef struct _virCapsStoragePool virCapsStoragePool;
-typedef virCapsStoragePool *virCapsStoragePoolPtr;
typedef struct _virDomainABIStability virDomainABIStability;
-typedef virDomainABIStability *virDomainABIStabilityPtr;
typedef struct _virDomainActualNetDef virDomainActualNetDef;
-typedef virDomainActualNetDef *virDomainActualNetDefPtr;
typedef struct _virDomainBackupDef virDomainBackupDef;
-typedef virDomainBackupDef *virDomainBackupDefPtr;
typedef struct _virDomainBIOSDef virDomainBIOSDef;
-typedef virDomainBIOSDef *virDomainBIOSDefPtr;
typedef struct _virDomainBlkiotune virDomainBlkiotune;
-typedef virDomainBlkiotune *virDomainBlkiotunePtr;
typedef struct _virDomainBlockIoTuneInfo virDomainBlockIoTuneInfo;
-typedef virDomainBlockIoTuneInfo *virDomainBlockIoTuneInfoPtr;
typedef struct _virDomainCheckpointDef virDomainCheckpointDef;
-typedef virDomainCheckpointDef *virDomainCheckpointDefPtr;
typedef struct _virDomainCheckpointObj virDomainCheckpointObj;
-typedef virDomainCheckpointObj *virDomainCheckpointObjPtr;
typedef struct _virDomainCheckpointObjList virDomainCheckpointObjList;
-typedef virDomainCheckpointObjList *virDomainCheckpointObjListPtr;
typedef struct _virDomainChrDef virDomainChrDef;
-typedef virDomainChrDef *virDomainChrDefPtr;
typedef struct _virDomainChrSourceDef virDomainChrSourceDef;
-typedef virDomainChrSourceDef *virDomainChrSourceDefPtr;
typedef struct _virDomainChrSourceReconnectDef virDomainChrSourceReconnectDef;
-typedef virDomainChrSourceReconnectDef *virDomainChrSourceReconnectDefPtr;
typedef struct _virDomainClockDef virDomainClockDef;
-typedef virDomainClockDef *virDomainClockDefPtr;
typedef struct _virDomainControllerDef virDomainControllerDef;
-typedef virDomainControllerDef *virDomainControllerDefPtr;
typedef struct _virDomainCputune virDomainCputune;
-typedef virDomainCputune *virDomainCputunePtr;
typedef struct _virDomainDef virDomainDef;
-typedef virDomainDef *virDomainDefPtr;
typedef struct _virDomainDefParserConfig virDomainDefParserConfig;
-typedef virDomainDefParserConfig *virDomainDefParserConfigPtr;
typedef struct _virDomainDeviceDef virDomainDeviceDef;
-typedef virDomainDeviceDef *virDomainDeviceDefPtr;
typedef struct _virDomainDiskDef virDomainDiskDef;
-typedef virDomainDiskDef *virDomainDiskDefPtr;
typedef struct _virDomainFSDef virDomainFSDef;
-typedef virDomainFSDef *virDomainFSDefPtr;
typedef struct _virDomainGraphicsAuthDef virDomainGraphicsAuthDef;
-typedef virDomainGraphicsAuthDef *virDomainGraphicsAuthDefPtr;
typedef struct _virDomainGraphicsDef virDomainGraphicsDef;
-typedef virDomainGraphicsDef *virDomainGraphicsDefPtr;
typedef struct _virDomainGraphicsListenDef virDomainGraphicsListenDef;
-typedef virDomainGraphicsListenDef *virDomainGraphicsListenDefPtr;
typedef struct _virDomainHostdevCaps virDomainHostdevCaps;
-typedef virDomainHostdevCaps *virDomainHostdevCapsPtr;
typedef struct _virDomainHostdevDef virDomainHostdevDef;
-typedef virDomainHostdevDef *virDomainHostdevDefPtr;
typedef struct _virDomainHostdevOrigStates virDomainHostdevOrigStates;
-typedef virDomainHostdevOrigStates *virDomainHostdevOrigStatesPtr;
typedef struct _virDomainHostdevSubsys virDomainHostdevSubsys;
-typedef virDomainHostdevSubsys *virDomainHostdevSubsysPtr;
typedef struct _virDomainHostdevSubsysMediatedDev virDomainHostdevSubsysMediatedDev;
-typedef virDomainHostdevSubsysMediatedDev *virDomainHostdevSubsysMediatedDevPtr;
typedef struct _virDomainHostdevSubsysPCI virDomainHostdevSubsysPCI;
-typedef virDomainHostdevSubsysPCI *virDomainHostdevSubsysPCIPtr;
typedef struct _virDomainHostdevSubsysSCSI virDomainHostdevSubsysSCSI;
-typedef virDomainHostdevSubsysSCSI *virDomainHostdevSubsysSCSIPtr;
typedef struct _virDomainHostdevSubsysSCSIHost virDomainHostdevSubsysSCSIHost;
-typedef virDomainHostdevSubsysSCSIHost *virDomainHostdevSubsysSCSIHostPtr;
typedef struct _virDomainHostdevSubsysSCSIVHost virDomainHostdevSubsysSCSIVHost;
-typedef virDomainHostdevSubsysSCSIVHost *virDomainHostdevSubsysSCSIVHostPtr;
typedef struct _virDomainHostdevSubsysSCSIiSCSI virDomainHostdevSubsysSCSIiSCSI;
-typedef virDomainHostdevSubsysSCSIiSCSI *virDomainHostdevSubsysSCSIiSCSIPtr;
typedef struct _virDomainHostdevSubsysUSB virDomainHostdevSubsysUSB;
-typedef virDomainHostdevSubsysUSB *virDomainHostdevSubsysUSBPtr;
typedef struct _virDomainHubDef virDomainHubDef;
-typedef virDomainHubDef *virDomainHubDefPtr;
typedef struct _virDomainHugePage virDomainHugePage;
-typedef virDomainHugePage *virDomainHugePagePtr;
typedef struct _virDomainIOMMUDef virDomainIOMMUDef;
-typedef virDomainIOMMUDef *virDomainIOMMUDefPtr;
typedef struct _virDomainIOThreadIDDef virDomainIOThreadIDDef;
-typedef virDomainIOThreadIDDef *virDomainIOThreadIDDefPtr;
typedef struct _virDomainIdMapDef virDomainIdMapDef;
-typedef virDomainIdMapDef *virDomainIdMapDefPtr;
typedef struct _virDomainIdMapEntry virDomainIdMapEntry;
-typedef virDomainIdMapEntry *virDomainIdMapEntryPtr;
typedef struct _virDomainInputDef virDomainInputDef;
-typedef virDomainInputDef *virDomainInputDefPtr;
typedef struct _virDomainKeyWrapDef virDomainKeyWrapDef;
-typedef virDomainKeyWrapDef *virDomainKeyWrapDefPtr;
typedef struct _virDomainLeaseDef virDomainLeaseDef;
-typedef virDomainLeaseDef *virDomainLeaseDefPtr;
typedef struct _virDomainLoaderDef virDomainLoaderDef;
-typedef virDomainLoaderDef *virDomainLoaderDefPtr;
typedef struct _virDomainMemballoonDef virDomainMemballoonDef;
-typedef virDomainMemballoonDef *virDomainMemballoonDefPtr;
typedef struct _virDomainMemoryDef virDomainMemoryDef;
-typedef virDomainMemoryDef *virDomainMemoryDefPtr;
typedef struct _virDomainMemtune virDomainMemtune;
-typedef virDomainMemtune *virDomainMemtunePtr;
typedef struct _virDomainMomentDef virDomainMomentDef;
-typedef virDomainMomentDef *virDomainMomentDefPtr;
typedef struct _virDomainMomentObj virDomainMomentObj;
-typedef virDomainMomentObj *virDomainMomentObjPtr;
typedef struct _virDomainMomentObjList virDomainMomentObjList;
-typedef virDomainMomentObjList *virDomainMomentObjListPtr;
typedef struct _virDomainNVRAMDef virDomainNVRAMDef;
-typedef virDomainNVRAMDef *virDomainNVRAMDefPtr;
typedef struct _virDomainNetDef virDomainNetDef;
-typedef virDomainNetDef *virDomainNetDefPtr;
typedef struct _virDomainNetTeamingInfo virDomainNetTeamingInfo;
-typedef virDomainNetTeamingInfo *virDomainNetTeamingInfoPtr;
typedef struct _virDomainOSDef virDomainOSDef;
-typedef virDomainOSDef *virDomainOSDefPtr;
typedef struct _virDomainOSEnv virDomainOSEnv;
-typedef virDomainOSEnv *virDomainOSEnvPtr;
typedef struct _virDomainObj virDomainObj;
-typedef virDomainObj *virDomainObjPtr;
typedef struct _virDomainPCIControllerOpts virDomainPCIControllerOpts;
-typedef virDomainPCIControllerOpts *virDomainPCIControllerOptsPtr;
typedef struct _virDomainPanicDef virDomainPanicDef;
-typedef virDomainPanicDef *virDomainPanicDefPtr;
typedef struct _virDomainPerfDef virDomainPerfDef;
-typedef virDomainPerfDef *virDomainPerfDefPtr;
typedef struct _virDomainPowerManagement virDomainPowerManagement;
-typedef virDomainPowerManagement *virDomainPowerManagementPtr;
typedef struct _virDomainRNGDef virDomainRNGDef;
-typedef virDomainRNGDef *virDomainRNGDefPtr;
typedef struct _virDomainRedirFilterDef virDomainRedirFilterDef;
-typedef virDomainRedirFilterDef *virDomainRedirFilterDefPtr;
typedef struct _virDomainRedirFilterUSBDevDef virDomainRedirFilterUSBDevDef;
-typedef virDomainRedirFilterUSBDevDef *virDomainRedirFilterUSBDevDefPtr;
typedef struct _virDomainRedirdevDef virDomainRedirdevDef;
-typedef virDomainRedirdevDef *virDomainRedirdevDefPtr;
typedef struct _virDomainResctrlDef virDomainResctrlDef;
-typedef virDomainResctrlDef *virDomainResctrlDefPtr;
typedef struct _virDomainResctrlMonDef virDomainResctrlMonDef;
-typedef virDomainResctrlMonDef *virDomainResctrlMonDefPtr;
typedef struct _virDomainResourceDef virDomainResourceDef;
-typedef virDomainResourceDef *virDomainResourceDefPtr;
typedef struct _virDomainSEVDef virDomainSEVDef;
-typedef virDomainSEVDef *virDomainSEVDefPtr;
typedef struct _virDomainShmemDef virDomainShmemDef;
-typedef virDomainShmemDef *virDomainShmemDefPtr;
typedef struct _virDomainSmartcardDef virDomainSmartcardDef;
-typedef virDomainSmartcardDef *virDomainSmartcardDefPtr;
typedef struct _virDomainSnapshotDef virDomainSnapshotDef;
-typedef virDomainSnapshotDef *virDomainSnapshotDefPtr;
typedef struct _virDomainSnapshotObjList virDomainSnapshotObjList;
-typedef virDomainSnapshotObjList *virDomainSnapshotObjListPtr;
typedef struct _virDomainSoundCodecDef virDomainSoundCodecDef;
-typedef virDomainSoundCodecDef *virDomainSoundCodecDefPtr;
typedef struct _virDomainSoundDef virDomainSoundDef;
-typedef virDomainSoundDef *virDomainSoundDefPtr;
typedef struct _virDomainAudioDef virDomainAudioDef;
-typedef virDomainAudioDef *virDomainAudioDefPtr;
typedef struct _virDomainTPMDef virDomainTPMDef;
-typedef virDomainTPMDef *virDomainTPMDefPtr;
typedef struct _virDomainThreadSchedParam virDomainThreadSchedParam;
-typedef virDomainThreadSchedParam *virDomainThreadSchedParamPtr;
typedef struct _virDomainTimerCatchupDef virDomainTimerCatchupDef;
-typedef virDomainTimerCatchupDef *virDomainTimerCatchupDefPtr;
typedef struct _virDomainTimerDef virDomainTimerDef;
-typedef virDomainTimerDef *virDomainTimerDefPtr;
typedef struct _virDomainUSBControllerOpts virDomainUSBControllerOpts;
-typedef virDomainUSBControllerOpts *virDomainUSBControllerOptsPtr;
typedef struct _virDomainVcpuDef virDomainVcpuDef;
-typedef virDomainVcpuDef *virDomainVcpuDefPtr;
typedef struct _virDomainVideoAccelDef virDomainVideoAccelDef;
-typedef virDomainVideoAccelDef *virDomainVideoAccelDefPtr;
typedef struct _virDomainVideoResolutionDef virDomainVideoResolutionDef;
-typedef virDomainVideoResolutionDef *virDomainVideoResolutionDefPtr;
typedef struct _virDomainVideoDef virDomainVideoDef;
-typedef virDomainVideoDef *virDomainVideoDefPtr;
typedef struct _virDomainVideoDriverDef virDomainVideoDriverDef;
-typedef virDomainVideoDriverDef *virDomainVideoDriverDefPtr;
typedef struct _virDomainVirtioOptions virDomainVirtioOptions;
-typedef virDomainVirtioOptions *virDomainVirtioOptionsPtr;
typedef struct _virDomainVirtioSerialOpts virDomainVirtioSerialOpts;
-typedef virDomainVirtioSerialOpts *virDomainVirtioSerialOptsPtr;
typedef struct _virDomainVsockDef virDomainVsockDef;
-typedef virDomainVsockDef *virDomainVsockDefPtr;
typedef struct _virDomainWatchdogDef virDomainWatchdogDef;
-typedef virDomainWatchdogDef *virDomainWatchdogDefPtr;
typedef struct _virDomainXMLOption virDomainXMLOption;
-typedef virDomainXMLOption *virDomainXMLOptionPtr;
typedef struct _virDomainXMLPrivateDataCallbacks virDomainXMLPrivateDataCallbacks;
-typedef virDomainXMLPrivateDataCallbacks *virDomainXMLPrivateDataCallbacksPtr;
typedef struct _virDomainXenbusControllerOpts virDomainXenbusControllerOpts;
-typedef virDomainXenbusControllerOpts *virDomainXenbusControllerOptsPtr;
VIR_LOG_INIT("conf.virdomaincheckpointobjlist");
struct _virDomainCheckpointObjList {
- virDomainMomentObjListPtr base;
+ virDomainMomentObjList *base;
};
-virDomainMomentObjPtr
-virDomainCheckpointAssignDef(virDomainCheckpointObjListPtr checkpoints,
- virDomainCheckpointDefPtr def)
+virDomainMomentObj *
+virDomainCheckpointAssignDef(virDomainCheckpointObjList *checkpoints,
+ virDomainCheckpointDef *def)
{
return virDomainMomentAssignDef(checkpoints->base, &def->parent);
}
static bool
-virDomainCheckpointFilter(virDomainMomentObjPtr obj G_GNUC_UNUSED,
+virDomainCheckpointFilter(virDomainMomentObj *obj G_GNUC_UNUSED,
unsigned int flags)
{
/* For now, we have no further filters than what the common code handles. */
}
-virDomainCheckpointObjListPtr
+virDomainCheckpointObjList *
virDomainCheckpointObjListNew(void)
{
- virDomainCheckpointObjListPtr checkpoints;
+ virDomainCheckpointObjList *checkpoints;
checkpoints = g_new0(virDomainCheckpointObjList, 1);
checkpoints->base = virDomainMomentObjListNew();
void
-virDomainCheckpointObjListFree(virDomainCheckpointObjListPtr checkpoints)
+virDomainCheckpointObjListFree(virDomainCheckpointObjList *checkpoints)
{
if (!checkpoints)
return;
static int
-virDomainCheckpointObjListGetNames(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr from,
+virDomainCheckpointObjListGetNames(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *from,
char **const names,
int maxnames,
unsigned int flags)
}
-virDomainMomentObjPtr
-virDomainCheckpointFindByName(virDomainCheckpointObjListPtr checkpoints,
+virDomainMomentObj *
+virDomainCheckpointFindByName(virDomainCheckpointObjList *checkpoints,
const char *name)
{
return virDomainMomentFindByName(checkpoints->base, name);
/* Return the current checkpoint, or NULL */
-virDomainMomentObjPtr
-virDomainCheckpointGetCurrent(virDomainCheckpointObjListPtr checkpoints)
+virDomainMomentObj *
+virDomainCheckpointGetCurrent(virDomainCheckpointObjList *checkpoints)
{
return virDomainMomentGetCurrent(checkpoints->base);
}
/* Return the current checkpoint's name, or NULL */
const char *
-virDomainCheckpointGetCurrentName(virDomainCheckpointObjListPtr checkpoints)
+virDomainCheckpointGetCurrentName(virDomainCheckpointObjList *checkpoints)
{
return virDomainMomentGetCurrentName(checkpoints->base);
}
/* Update the current checkpoint, using NULL if no current remains */
void
-virDomainCheckpointSetCurrent(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr checkpoint)
+virDomainCheckpointSetCurrent(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *checkpoint)
{
virDomainMomentSetCurrent(checkpoints->base, checkpoint);
}
/* Remove checkpoint from the list; return true if it was current */
bool
-virDomainCheckpointObjListRemove(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr checkpoint)
+virDomainCheckpointObjListRemove(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *checkpoint)
{
return virDomainMomentObjListRemove(checkpoints->base, checkpoint);
}
/* Remove all checkpoints tracked in the list */
void
-virDomainCheckpointObjListRemoveAll(virDomainCheckpointObjListPtr checkpoints)
+virDomainCheckpointObjListRemoveAll(virDomainCheckpointObjList *checkpoints)
{
return virDomainMomentObjListRemoveAll(checkpoints->base);
}
int
-virDomainCheckpointForEach(virDomainCheckpointObjListPtr checkpoints,
+virDomainCheckpointForEach(virDomainCheckpointObjList *checkpoints,
virHashIterator iter,
void *data)
{
/* Populate parent link of a given checkpoint. */
void
-virDomainCheckpointLinkParent(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr chk)
+virDomainCheckpointLinkParent(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *chk)
{
return virDomainMomentLinkParent(checkpoints->base, chk);
}
* was requested. Set leaf to the end of the chain, if there is
* exactly one such leaf. */
int
-virDomainCheckpointUpdateRelations(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr *leaf)
+virDomainCheckpointUpdateRelations(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj **leaf)
{
int ret = virDomainMomentUpdateRelations(checkpoints->base);
int
-virDomainCheckpointCheckCycles(virDomainCheckpointObjListPtr checkpoints,
- virDomainCheckpointDefPtr def,
+virDomainCheckpointCheckCycles(virDomainCheckpointObjList *checkpoints,
+ virDomainCheckpointDef *def,
const char *domname)
{
return virDomainMomentCheckCycles(checkpoints->base, &def->parent, domname);
int
-virDomainListCheckpoints(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr from,
+virDomainListCheckpoints(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *from,
virDomainPtr dom,
virDomainCheckpointPtr **chks,
unsigned int flags)
#include "virdomainmomentobjlist.h"
#include "virbuffer.h"
-virDomainCheckpointObjListPtr
+virDomainCheckpointObjList *
virDomainCheckpointObjListNew(void);
void
-virDomainCheckpointObjListFree(virDomainCheckpointObjListPtr checkpoints);
+virDomainCheckpointObjListFree(virDomainCheckpointObjList *checkpoints);
-virDomainMomentObjPtr
-virDomainCheckpointAssignDef(virDomainCheckpointObjListPtr checkpoints,
- virDomainCheckpointDefPtr def);
+virDomainMomentObj *
+virDomainCheckpointAssignDef(virDomainCheckpointObjList *checkpoints,
+ virDomainCheckpointDef *def);
-virDomainMomentObjPtr
-virDomainCheckpointFindByName(virDomainCheckpointObjListPtr checkpoints,
+virDomainMomentObj *
+virDomainCheckpointFindByName(virDomainCheckpointObjList *checkpoints,
const char *name);
-virDomainMomentObjPtr
-virDomainCheckpointGetCurrent(virDomainCheckpointObjListPtr checkpoints);
+virDomainMomentObj *
+virDomainCheckpointGetCurrent(virDomainCheckpointObjList *checkpoints);
const char *
-virDomainCheckpointGetCurrentName(virDomainCheckpointObjListPtr checkpoints);
+virDomainCheckpointGetCurrentName(virDomainCheckpointObjList *checkpoints);
void
-virDomainCheckpointSetCurrent(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr checkpoint);
+virDomainCheckpointSetCurrent(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *checkpoint);
bool
-virDomainCheckpointObjListRemove(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr checkpoint);
+virDomainCheckpointObjListRemove(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *checkpoint);
void
-virDomainCheckpointObjListRemoveAll(virDomainCheckpointObjListPtr checkpoints);
+virDomainCheckpointObjListRemoveAll(virDomainCheckpointObjList *checkpoints);
int
-virDomainCheckpointForEach(virDomainCheckpointObjListPtr checkpoints,
+virDomainCheckpointForEach(virDomainCheckpointObjList *checkpoints,
virHashIterator iter,
void *data);
void
-virDomainCheckpointLinkParent(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr chk);
+virDomainCheckpointLinkParent(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *chk);
int
-virDomainCheckpointUpdateRelations(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr *leaf);
+virDomainCheckpointUpdateRelations(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj **leaf);
int
-virDomainCheckpointCheckCycles(virDomainCheckpointObjListPtr checkpoints,
- virDomainCheckpointDefPtr def,
+virDomainCheckpointCheckCycles(virDomainCheckpointObjList *checkpoints,
+ virDomainCheckpointDef *def,
const char *domname);
#define VIR_DOMAIN_CHECKPOINT_FILTERS_LEAVES \
(VIR_DOMAIN_CHECKPOINT_FILTERS_LEAVES)
int
-virDomainListCheckpoints(virDomainCheckpointObjListPtr checkpoints,
- virDomainMomentObjPtr from,
+virDomainListCheckpoints(virDomainCheckpointObjList *checkpoints,
+ virDomainMomentObj *from,
virDomainPtr dom,
virDomainCheckpointPtr **objs,
unsigned int flags);
-static inline virDomainCheckpointDefPtr
-virDomainCheckpointObjGetDef(virDomainMomentObjPtr obj)
+static inline virDomainCheckpointDef *
+virDomainCheckpointObjGetDef(virDomainMomentObj *obj)
{
- return (virDomainCheckpointDefPtr) obj->def;
+ return (virDomainCheckpointDef *) obj->def;
}
GHashTable *objs;
virDomainMomentObj metaroot; /* Special parent of all root moments */
- virDomainMomentObjPtr current; /* The current moment, if any */
+ virDomainMomentObj *current; /* The current moment, if any */
};
* other entries in moments. Return the number of children
* visited. No particular ordering is guaranteed. */
int
-virDomainMomentForEachChild(virDomainMomentObjPtr moment,
+virDomainMomentForEachChild(virDomainMomentObj *moment,
virHashIterator iter,
void *data)
{
- virDomainMomentObjPtr child = moment->first_child;
+ virDomainMomentObj *child = moment->first_child;
while (child) {
- virDomainMomentObjPtr next = child->sibling;
+ virDomainMomentObj *next = child->sibling;
(iter)(child, child->def->name, data);
child = next;
}
const char *name,
void *data)
{
- virDomainMomentObjPtr obj = payload;
+ virDomainMomentObj *obj = payload;
struct moment_act_on_descendant *curr = data;
virDomainMomentObj tmp = *obj;
* visited. The visit is guaranteed to be topological, but no
* particular order between siblings is guaranteed. */
int
-virDomainMomentForEachDescendant(virDomainMomentObjPtr moment,
+virDomainMomentForEachDescendant(virDomainMomentObj *moment,
virHashIterator iter,
void *data)
{
* of a parent, it is faster to just 0 the count rather than calling
* this function on each child. */
void
-virDomainMomentDropParent(virDomainMomentObjPtr moment)
+virDomainMomentDropParent(virDomainMomentObj *moment)
{
- virDomainMomentObjPtr prev = NULL;
- virDomainMomentObjPtr curr = NULL;
+ virDomainMomentObj *prev = NULL;
+ virDomainMomentObj *curr = NULL;
moment->parent->nchildren--;
curr = moment->parent->first_child;
/* Update @moment to no longer have children. */
void
-virDomainMomentDropChildren(virDomainMomentObjPtr moment)
+virDomainMomentDropChildren(virDomainMomentObj *moment)
{
moment->nchildren = 0;
moment->first_child = NULL;
/* Add @moment to @parent's list of children. */
static void
-virDomainMomentSetParent(virDomainMomentObjPtr moment,
- virDomainMomentObjPtr parent)
+virDomainMomentSetParent(virDomainMomentObj *moment,
+ virDomainMomentObj *parent)
{
moment->parent = parent;
parent->nchildren++;
* (for a new root) or set to an existing moment already in the
* list. */
void
-virDomainMomentLinkParent(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment)
+virDomainMomentLinkParent(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment)
{
- virDomainMomentObjPtr parent;
+ virDomainMomentObj *parent;
parent = virDomainMomentFindByName(moments, moment->def->parent_name);
if (!parent) {
/* Take all children of @from and convert them into children of @to. */
void
-virDomainMomentMoveChildren(virDomainMomentObjPtr from,
- virDomainMomentObjPtr to)
+virDomainMomentMoveChildren(virDomainMomentObj *from,
+ virDomainMomentObj *to)
{
- virDomainMomentObjPtr child = from->first_child;
+ virDomainMomentObj *child = from->first_child;
if (!from->nchildren)
return;
}
-static virDomainMomentObjPtr
+static virDomainMomentObj *
virDomainMomentObjNew(void)
{
- virDomainMomentObjPtr moment;
+ virDomainMomentObj *moment;
moment = g_new0(virDomainMomentObj, 1);
static void
-virDomainMomentObjFree(virDomainMomentObjPtr moment)
+virDomainMomentObjFree(virDomainMomentObj *moment)
{
if (!moment)
return;
/* Add def to the list and return a matching object, or NULL on error */
-virDomainMomentObjPtr
-virDomainMomentAssignDef(virDomainMomentObjListPtr moments,
- virDomainMomentDefPtr def)
+virDomainMomentObj *
+virDomainMomentAssignDef(virDomainMomentObjList *moments,
+ virDomainMomentDef *def)
{
- virDomainMomentObjPtr moment;
+ virDomainMomentObj *moment;
if (virHashLookup(moments->objs, def->name) != NULL) {
virReportError(VIR_ERR_OPERATION_FAILED,
static void
virDomainMomentObjListDataFree(void *payload)
{
- virDomainMomentObjPtr obj = payload;
+ virDomainMomentObj *obj = payload;
virDomainMomentObjFree(obj);
}
-virDomainMomentObjListPtr
+virDomainMomentObjList *
virDomainMomentObjListNew(void)
{
- virDomainMomentObjListPtr moments;
+ virDomainMomentObjList *moments;
moments = g_new0(virDomainMomentObjList, 1);
moments->objs = virHashNew(virDomainMomentObjListDataFree);
}
void
-virDomainMomentObjListFree(virDomainMomentObjListPtr moments)
+virDomainMomentObjListFree(virDomainMomentObjList *moments)
{
if (!moments)
return;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virDomainMomentObjPtr obj = payload;
+ virDomainMomentObj *obj = payload;
struct virDomainMomentNameData *data = opaque;
if (data->error)
int
-virDomainMomentObjListGetNames(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr from,
+virDomainMomentObjListGetNames(virDomainMomentObjList *moments,
+ virDomainMomentObj *from,
char **const names,
int maxnames,
unsigned int flags,
}
-virDomainMomentObjPtr
-virDomainMomentFindByName(virDomainMomentObjListPtr moments,
+virDomainMomentObj *
+virDomainMomentFindByName(virDomainMomentObjList *moments,
const char *name)
{
if (name)
/* Return the current moment, or NULL */
-virDomainMomentObjPtr
-virDomainMomentGetCurrent(virDomainMomentObjListPtr moments)
+virDomainMomentObj *
+virDomainMomentGetCurrent(virDomainMomentObjList *moments)
{
return moments->current;
}
/* Return the current moment's name, or NULL */
const char *
-virDomainMomentGetCurrentName(virDomainMomentObjListPtr moments)
+virDomainMomentGetCurrentName(virDomainMomentObjList *moments)
{
if (moments->current)
return moments->current->def->name;
/* Update the current moment, using NULL if no current remains */
void
-virDomainMomentSetCurrent(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment)
+virDomainMomentSetCurrent(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment)
{
moments->current = moment;
}
/* Return the number of moments in the list */
int
-virDomainMomentObjListSize(virDomainMomentObjListPtr moments)
+virDomainMomentObjListSize(virDomainMomentObjList *moments)
{
return virHashSize(moments->objs);
}
/* Remove moment from the list; return true if it was current */
bool
-virDomainMomentObjListRemove(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment)
+virDomainMomentObjListRemove(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment)
{
bool ret = moments->current == moment;
/* Remove all moments tracked in the list */
void
-virDomainMomentObjListRemoveAll(virDomainMomentObjListPtr moments)
+virDomainMomentObjListRemoveAll(virDomainMomentObjList *moments)
{
virHashRemoveAll(moments->objs);
virDomainMomentDropChildren(&moments->metaroot);
/* Call iter on each member of the list, in unspecified order */
int
-virDomainMomentForEach(virDomainMomentObjListPtr moments,
+virDomainMomentForEach(virDomainMomentObjList *moments,
virHashIterator iter,
void *data)
{
* indicator gets set if a parent is missing or a requested parent would
* cause a circular parent chain. */
struct moment_set_relation {
- virDomainMomentObjListPtr moments;
+ virDomainMomentObjList *moments;
int err;
};
static int
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr obj = payload;
+ virDomainMomentObj *obj = payload;
struct moment_set_relation *curr = data;
- virDomainMomentObjPtr tmp;
- virDomainMomentObjPtr parent;
+ virDomainMomentObj *tmp;
+ virDomainMomentObj *parent;
parent = virDomainMomentFindByName(curr->moments, obj->def->parent_name);
if (!parent) {
* success, -1 if a parent is missing or if a circular relationship
* was requested. */
int
-virDomainMomentUpdateRelations(virDomainMomentObjListPtr moments)
+virDomainMomentUpdateRelations(virDomainMomentObjList *moments)
{
struct moment_set_relation act = { moments, 0 };
* on success, or report an error on behalf of domname before
* returning -1. */
int
-virDomainMomentCheckCycles(virDomainMomentObjListPtr list,
- virDomainMomentDefPtr def,
+virDomainMomentCheckCycles(virDomainMomentObjList *list,
+ virDomainMomentDef *def,
const char *domname)
{
- virDomainMomentObjPtr other;
+ virDomainMomentObj *other;
if (def->parent_name) {
if (STREQ(def->name, def->parent_name)) {
}
/* If there is exactly one leaf node, return that node. */
-virDomainMomentObjPtr
-virDomainMomentFindLeaf(virDomainMomentObjListPtr list)
+virDomainMomentObj *
+virDomainMomentFindLeaf(virDomainMomentObjList *list)
{
- virDomainMomentObjPtr moment = &list->metaroot;
+ virDomainMomentObj *moment = &list->metaroot;
if (moment->nchildren != 1)
return NULL;
#include "virhash.h"
/* Filter that returns true if a given moment matches the filter flags */
-typedef bool (*virDomainMomentObjListFilter)(virDomainMomentObjPtr obj,
+typedef bool (*virDomainMomentObjListFilter)(virDomainMomentObj *obj,
unsigned int flags);
/* Struct that allows tracing hierarchical relationships between
* a linked list. */
struct _virDomainMomentObj {
/* Public field */
- virDomainMomentDefPtr def; /* non-NULL except for metaroot */
+ virDomainMomentDef *def; /* non-NULL except for metaroot */
/* Private fields, use accessors instead */
- virDomainMomentObjPtr parent; /* non-NULL except for metaroot, before
+ virDomainMomentObj *parent; /* non-NULL except for metaroot, before
virDomainMomentUpdateRelations, or
after virDomainMomentDropParent */
- virDomainMomentObjPtr sibling; /* NULL if last child of parent */
+ virDomainMomentObj *sibling; /* NULL if last child of parent */
size_t nchildren;
- virDomainMomentObjPtr first_child; /* NULL if no children */
+ virDomainMomentObj *first_child; /* NULL if no children */
};
-int virDomainMomentForEachChild(virDomainMomentObjPtr moment,
+int virDomainMomentForEachChild(virDomainMomentObj *moment,
virHashIterator iter,
void *data);
-int virDomainMomentForEachDescendant(virDomainMomentObjPtr moment,
+int virDomainMomentForEachDescendant(virDomainMomentObj *moment,
virHashIterator iter,
void *data);
-void virDomainMomentDropParent(virDomainMomentObjPtr moment);
-void virDomainMomentDropChildren(virDomainMomentObjPtr moment);
-void virDomainMomentMoveChildren(virDomainMomentObjPtr from,
- virDomainMomentObjPtr to);
-void virDomainMomentLinkParent(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment);
+void virDomainMomentDropParent(virDomainMomentObj *moment);
+void virDomainMomentDropChildren(virDomainMomentObj *moment);
+void virDomainMomentMoveChildren(virDomainMomentObj *from,
+ virDomainMomentObj *to);
+void virDomainMomentLinkParent(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment);
-virDomainMomentObjListPtr virDomainMomentObjListNew(void);
-void virDomainMomentObjListFree(virDomainMomentObjListPtr moments);
+virDomainMomentObjList *virDomainMomentObjListNew(void);
+void virDomainMomentObjListFree(virDomainMomentObjList *moments);
-virDomainMomentObjPtr virDomainMomentAssignDef(virDomainMomentObjListPtr moments,
- virDomainMomentDefPtr def);
+virDomainMomentObj *virDomainMomentAssignDef(virDomainMomentObjList *moments,
+ virDomainMomentDef *def);
/* Various enum bits that map to public API filters. Note that the
* values of the internal bits are not the same as the public ones for
VIR_DOMAIN_MOMENT_FILTERS_METADATA | \
VIR_DOMAIN_MOMENT_FILTERS_LEAVES)
-int virDomainMomentObjListGetNames(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr from,
+int virDomainMomentObjListGetNames(virDomainMomentObjList *moments,
+ virDomainMomentObj *from,
char **const names,
int maxnames,
unsigned int moment_flags,
virDomainMomentObjListFilter filter,
unsigned int filter_flags);
-virDomainMomentObjPtr virDomainMomentFindByName(virDomainMomentObjListPtr moments,
+virDomainMomentObj *virDomainMomentFindByName(virDomainMomentObjList *moments,
const char *name);
-int virDomainMomentObjListSize(virDomainMomentObjListPtr moments);
-virDomainMomentObjPtr virDomainMomentGetCurrent(virDomainMomentObjListPtr moments);
-const char *virDomainMomentGetCurrentName(virDomainMomentObjListPtr moments);
-void virDomainMomentSetCurrent(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment);
-bool virDomainMomentObjListRemove(virDomainMomentObjListPtr moments,
- virDomainMomentObjPtr moment);
-void virDomainMomentObjListRemoveAll(virDomainMomentObjListPtr moments);
-int virDomainMomentForEach(virDomainMomentObjListPtr moments,
+int virDomainMomentObjListSize(virDomainMomentObjList *moments);
+virDomainMomentObj *virDomainMomentGetCurrent(virDomainMomentObjList *moments);
+const char *virDomainMomentGetCurrentName(virDomainMomentObjList *moments);
+void virDomainMomentSetCurrent(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment);
+bool virDomainMomentObjListRemove(virDomainMomentObjList *moments,
+ virDomainMomentObj *moment);
+void virDomainMomentObjListRemoveAll(virDomainMomentObjList *moments);
+int virDomainMomentForEach(virDomainMomentObjList *moments,
virHashIterator iter,
void *data);
-int virDomainMomentUpdateRelations(virDomainMomentObjListPtr moments);
-int virDomainMomentCheckCycles(virDomainMomentObjListPtr list,
- virDomainMomentDefPtr def,
+int virDomainMomentUpdateRelations(virDomainMomentObjList *moments);
+int virDomainMomentCheckCycles(virDomainMomentObjList *list,
+ virDomainMomentDef *def,
const char *domname);
-virDomainMomentObjPtr virDomainMomentFindLeaf(virDomainMomentObjListPtr list);
+virDomainMomentObj *virDomainMomentFindLeaf(virDomainMomentObjList *list);
VIR_LOG_INIT("conf.virdomainobjlist");
-static virClassPtr virDomainObjListClass;
+static virClass *virDomainObjListClass;
static void virDomainObjListDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virDomainObjList);
-virDomainObjListPtr virDomainObjListNew(void)
+virDomainObjList *virDomainObjListNew(void)
{
- virDomainObjListPtr doms;
+ virDomainObjList *doms;
if (virDomainObjListInitialize() < 0)
return NULL;
static void virDomainObjListDispose(void *obj)
{
- virDomainObjListPtr doms = obj;
+ virDomainObjList *doms = obj;
virHashFree(doms->objs);
virHashFree(doms->objsName);
const char *name G_GNUC_UNUSED,
const void *data)
{
- virDomainObjPtr obj = (virDomainObjPtr)payload;
+ virDomainObj *obj = (virDomainObj *)payload;
const int *id = data;
int want = 0;
}
-virDomainObjPtr
-virDomainObjListFindByID(virDomainObjListPtr doms,
+virDomainObj *
+virDomainObjListFindByID(virDomainObjList *doms,
int id)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
virObjectRWLockRead(doms);
obj = virHashSearch(doms->objs, virDomainObjListSearchID, &id, NULL);
}
-static virDomainObjPtr
-virDomainObjListFindByUUIDLocked(virDomainObjListPtr doms,
+static virDomainObj *
+virDomainObjListFindByUUIDLocked(virDomainObjList *doms,
const unsigned char *uuid)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDomainObjPtr obj;
+ virDomainObj *obj;
virUUIDFormat(uuid, uuidstr);
obj = virHashLookup(doms->objs, uuidstr);
* locked and ref counted domain object if found. Caller is
* expected to use the virDomainObjEndAPI when done with the object.
*/
-virDomainObjPtr
-virDomainObjListFindByUUID(virDomainObjListPtr doms,
+virDomainObj *
+virDomainObjListFindByUUID(virDomainObjList *doms,
const unsigned char *uuid)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
virObjectRWLockRead(doms);
obj = virDomainObjListFindByUUIDLocked(doms, uuid);
}
-static virDomainObjPtr
-virDomainObjListFindByNameLocked(virDomainObjListPtr doms,
+static virDomainObj *
+virDomainObjListFindByNameLocked(virDomainObjList *doms,
const char *name)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
obj = virHashLookup(doms->objsName, name);
if (obj) {
* locked and ref counted domain object if found. Caller is expected
* to use the virDomainObjEndAPI when done with the object.
*/
-virDomainObjPtr
-virDomainObjListFindByName(virDomainObjListPtr doms,
+virDomainObj *
+virDomainObjListFindByName(virDomainObjList *doms,
const char *name)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
virObjectRWLockRead(doms);
obj = virDomainObjListFindByNameLocked(doms, name);
* -1 on failure with 1 reference and locked
*/
static int
-virDomainObjListAddObjLocked(virDomainObjListPtr doms,
- virDomainObjPtr vm)
+virDomainObjListAddObjLocked(virDomainObjList *doms,
+ virDomainObj *vm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* counted. The caller is expected to use virDomainObjEndAPI
* when it completes usage.
*/
-static virDomainObjPtr
-virDomainObjListAddLocked(virDomainObjListPtr doms,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
+static virDomainObj *
+virDomainObjListAddLocked(virDomainObjList *doms,
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt,
unsigned int flags,
- virDomainDefPtr *oldDef)
+ virDomainDef **oldDef)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (oldDef)
}
-virDomainObjPtr virDomainObjListAdd(virDomainObjListPtr doms,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- unsigned int flags,
- virDomainDefPtr *oldDef)
+virDomainObj *
+virDomainObjListAdd(virDomainObjList *doms,
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ unsigned int flags,
+ virDomainDef **oldDef)
{
- virDomainObjPtr ret;
+ virDomainObj *ret;
virObjectRWLockWrite(doms);
ret = virDomainObjListAddLocked(doms, def, xmlopt, flags, oldDef);
* virDomainObjListForEach
*/
void
-virDomainObjListRemoveLocked(virDomainObjListPtr doms,
- virDomainObjPtr dom)
+virDomainObjListRemoveLocked(virDomainObjList *doms,
+ virDomainObj *dom)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* tables and returned with lock and refcnt that was present upon entry.
*/
void
-virDomainObjListRemove(virDomainObjListPtr doms,
- virDomainObjPtr dom)
+virDomainObjListRemove(virDomainObjList *doms,
+ virDomainObj *dom)
{
dom->removing = true;
virObjectRef(dom);
* consistency must not rely on this lock solely.
*/
int
-virDomainObjListRename(virDomainObjListPtr doms,
- virDomainObjPtr dom,
+virDomainObjListRename(virDomainObjList *doms,
+ virDomainObj *dom,
const char *new_name,
unsigned int flags,
virDomainObjListRenameCallback callback,
}
-static virDomainObjPtr
-virDomainObjListLoadConfig(virDomainObjListPtr doms,
- virDomainXMLOptionPtr xmlopt,
+static virDomainObj *
+virDomainObjListLoadConfig(virDomainObjList *doms,
+ virDomainXMLOption *xmlopt,
const char *configDir,
const char *autostartDir,
const char *name,
void *opaque)
{
char *configFile = NULL, *autostartLink = NULL;
- virDomainDefPtr def = NULL;
- virDomainObjPtr dom;
+ virDomainDef *def = NULL;
+ virDomainObj *dom;
int autostart;
- virDomainDefPtr oldDef = NULL;
+ virDomainDef *oldDef = NULL;
if ((configFile = virDomainConfigFile(configDir, name)) == NULL)
goto error;
}
-static virDomainObjPtr
-virDomainObjListLoadStatus(virDomainObjListPtr doms,
+static virDomainObj *
+virDomainObjListLoadStatus(virDomainObjList *doms,
const char *statusDir,
const char *name,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
virDomainLoadConfigNotify notify,
void *opaque)
{
char *statusFile = NULL;
- virDomainObjPtr obj = NULL;
+ virDomainObj *obj = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if ((statusFile = virDomainConfigFile(statusDir, name)) == NULL)
int
-virDomainObjListLoadAllConfigs(virDomainObjListPtr doms,
+virDomainObjListLoadAllConfigs(virDomainObjList *doms,
const char *configDir,
const char *autostartDir,
bool liveStatus,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
virDomainLoadConfigNotify notify,
void *opaque)
{
virObjectRWLockWrite(doms);
while ((ret = virDirRead(dir, &entry, configDir)) > 0) {
- virDomainObjPtr dom;
+ virDomainObj *dom;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virDomainObjPtr obj = payload;
+ virDomainObj *obj = payload;
struct virDomainObjListData *data = opaque;
virObjectLock(obj);
if (data->filter &&
int
-virDomainObjListNumOfDomains(virDomainObjListPtr doms,
+virDomainObjListNumOfDomains(virDomainObjList *doms,
bool active,
virDomainObjListACLFilter filter,
virConnectPtr conn)
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virDomainObjPtr obj = payload;
+ virDomainObj *obj = payload;
struct virDomainIDData *data = opaque;
virObjectLock(obj);
if (data->filter &&
int
-virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
+virDomainObjListGetActiveIDs(virDomainObjList *doms,
int *ids,
int maxids,
virDomainObjListACLFilter filter,
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virDomainObjPtr obj = payload;
+ virDomainObj *obj = payload;
struct virDomainNameData *data = opaque;
if (data->oom)
int
-virDomainObjListGetInactiveNames(virDomainObjListPtr doms,
+virDomainObjListGetInactiveNames(virDomainObjList *doms,
char **const names,
int maxnames,
virDomainObjListACLFilter filter,
* -1 otherwise.
*/
int
-virDomainObjListForEach(virDomainObjListPtr doms,
+virDomainObjListForEach(virDomainObjList *doms,
bool modify,
virDomainObjListIterator callback,
void *opaque)
#define MATCH(FLAG) (filter & (FLAG))
static bool
-virDomainObjMatchFilter(virDomainObjPtr vm,
+virDomainObjMatchFilter(virDomainObj *vm,
unsigned int filter)
{
/* filter by active state */
struct virDomainListData {
- virDomainObjPtr *vms;
+ virDomainObj **vms;
size_t nvms;
};
static void
-virDomainObjListFilter(virDomainObjPtr **list,
+virDomainObjListFilter(virDomainObj ***list,
size_t *nvms,
virConnectPtr conn,
virDomainObjListACLFilter filter,
size_t i = 0;
while (i < *nvms) {
- virDomainObjPtr vm = (*list)[i];
+ virDomainObj *vm = (*list)[i];
virObjectLock(vm);
int
-virDomainObjListCollect(virDomainObjListPtr domlist,
+virDomainObjListCollect(virDomainObjList *domlist,
virConnectPtr conn,
- virDomainObjPtr **vms,
+ virDomainObj ***vms,
size_t *nvms,
virDomainObjListACLFilter filter,
unsigned int flags)
virObjectRWLockRead(domlist);
sa_assert(domlist->objs);
- data.vms = g_new0(virDomainObjPtr, virHashSize(domlist->objs));
+ data.vms = g_new0(virDomainObj *, virHashSize(domlist->objs));
virHashForEach(domlist->objs, virDomainObjListCollectIterator, &data);
virObjectRWUnlock(domlist);
int
-virDomainObjListConvert(virDomainObjListPtr domlist,
+virDomainObjListConvert(virDomainObjList *domlist,
virConnectPtr conn,
virDomainPtr *doms,
size_t ndoms,
- virDomainObjPtr **vms,
+ virDomainObj ***vms,
size_t *nvms,
virDomainObjListACLFilter filter,
unsigned int flags,
bool skip_missing)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDomainObjPtr vm;
+ virDomainObj *vm;
size_t i;
*nvms = 0;
int
-virDomainObjListExport(virDomainObjListPtr domlist,
+virDomainObjListExport(virDomainObjList *domlist,
virConnectPtr conn,
virDomainPtr **domains,
virDomainObjListACLFilter filter,
unsigned int flags)
{
- virDomainObjPtr *vms = NULL;
+ virDomainObj **vms = NULL;
virDomainPtr *doms = NULL;
size_t nvms = 0;
size_t i;
doms = g_new0(virDomainPtr, nvms + 1);
for (i = 0; i < nvms; i++) {
- virDomainObjPtr vm = vms[i];
+ virDomainObj *vm = vms[i];
virObjectLock(vm);
doms[i] = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
#include "domain_conf.h"
typedef struct _virDomainObjList virDomainObjList;
-typedef virDomainObjList *virDomainObjListPtr;
-virDomainObjListPtr virDomainObjListNew(void);
+virDomainObjList *virDomainObjListNew(void);
-virDomainObjPtr virDomainObjListFindByID(virDomainObjListPtr doms,
+virDomainObj *virDomainObjListFindByID(virDomainObjList *doms,
int id);
-virDomainObjPtr virDomainObjListFindByUUID(virDomainObjListPtr doms,
+virDomainObj *virDomainObjListFindByUUID(virDomainObjList *doms,
const unsigned char *uuid);
-virDomainObjPtr virDomainObjListFindByName(virDomainObjListPtr doms,
+virDomainObj *virDomainObjListFindByName(virDomainObjList *doms,
const char *name);
enum {
VIR_DOMAIN_OBJ_LIST_ADD_LIVE = (1 << 0),
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1),
};
-virDomainObjPtr virDomainObjListAdd(virDomainObjListPtr doms,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt,
- unsigned int flags,
- virDomainDefPtr *oldDef);
+virDomainObj *virDomainObjListAdd(virDomainObjList *doms,
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt,
+ unsigned int flags,
+ virDomainDef **oldDef);
-typedef int (*virDomainObjListRenameCallback)(virDomainObjPtr dom,
+typedef int (*virDomainObjListRenameCallback)(virDomainObj *dom,
const char *new_name,
unsigned int flags,
void *opaque);
-int virDomainObjListRename(virDomainObjListPtr doms,
- virDomainObjPtr dom,
+int virDomainObjListRename(virDomainObjList *doms,
+ virDomainObj *dom,
const char *new_name,
unsigned int flags,
virDomainObjListRenameCallback callback,
void *opaque);
-void virDomainObjListRemove(virDomainObjListPtr doms,
- virDomainObjPtr dom);
-void virDomainObjListRemoveLocked(virDomainObjListPtr doms,
- virDomainObjPtr dom);
+void virDomainObjListRemove(virDomainObjList *doms,
+ virDomainObj *dom);
+void virDomainObjListRemoveLocked(virDomainObjList *doms,
+ virDomainObj *dom);
-int virDomainObjListLoadAllConfigs(virDomainObjListPtr doms,
+int virDomainObjListLoadAllConfigs(virDomainObjList *doms,
const char *configDir,
const char *autostartDir,
bool liveStatus,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
virDomainLoadConfigNotify notify,
void *opaque);
-int virDomainObjListNumOfDomains(virDomainObjListPtr doms,
+int virDomainObjListNumOfDomains(virDomainObjList *doms,
bool active,
virDomainObjListACLFilter filter,
virConnectPtr conn);
-int virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
+int virDomainObjListGetActiveIDs(virDomainObjList *doms,
int *ids,
int maxids,
virDomainObjListACLFilter filter,
virConnectPtr conn);
-int virDomainObjListGetInactiveNames(virDomainObjListPtr doms,
+int virDomainObjListGetInactiveNames(virDomainObjList *doms,
char **const names,
int maxnames,
virDomainObjListACLFilter filter,
virConnectPtr conn);
-typedef int (*virDomainObjListIterator)(virDomainObjPtr dom,
+typedef int (*virDomainObjListIterator)(virDomainObj *dom,
void *opaque);
-int virDomainObjListForEach(virDomainObjListPtr doms,
+int virDomainObjListForEach(virDomainObjList *doms,
bool modify,
virDomainObjListIterator callback,
void *opaque);
VIR_CONNECT_LIST_DOMAINS_FILTERS_SNAPSHOT | \
VIR_CONNECT_LIST_DOMAINS_FILTERS_CHECKPOINT)
-int virDomainObjListCollect(virDomainObjListPtr doms,
+int virDomainObjListCollect(virDomainObjList *doms,
virConnectPtr conn,
- virDomainObjPtr **vms,
+ virDomainObj ***vms,
size_t *nvms,
virDomainObjListACLFilter filter,
unsigned int flags);
-int virDomainObjListExport(virDomainObjListPtr doms,
+int virDomainObjListExport(virDomainObjList *doms,
virConnectPtr conn,
virDomainPtr **domains,
virDomainObjListACLFilter filter,
unsigned int flags);
-int virDomainObjListConvert(virDomainObjListPtr domlist,
+int virDomainObjListConvert(virDomainObjList *domlist,
virConnectPtr conn,
virDomainPtr *doms,
size_t ndoms,
- virDomainObjPtr **vms,
+ virDomainObj ***vms,
size_t *nvms,
virDomainObjListACLFilter filter,
unsigned int flags,
VIR_LOG_INIT("conf.virdomainsnapshotobjlist");
struct _virDomainSnapshotObjList {
- virDomainMomentObjListPtr base;
+ virDomainMomentObjList *base;
};
-virDomainMomentObjPtr
-virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots,
- virDomainSnapshotDefPtr def)
+virDomainMomentObj *
+virDomainSnapshotAssignDef(virDomainSnapshotObjList *snapshots,
+ virDomainSnapshotDef *def)
{
return virDomainMomentAssignDef(snapshots->base, &def->parent);
}
static bool
-virDomainSnapshotFilter(virDomainMomentObjPtr obj,
+virDomainSnapshotFilter(virDomainMomentObj *obj,
unsigned int flags)
{
- virDomainSnapshotDefPtr def = virDomainSnapshotObjGetDef(obj);
+ virDomainSnapshotDef *def = virDomainSnapshotObjGetDef(obj);
/* Caller has already sanitized flags and performed filtering on
* DESCENDANTS and LEAVES. */
}
-virDomainSnapshotObjListPtr
+virDomainSnapshotObjList *
virDomainSnapshotObjListNew(void)
{
- virDomainSnapshotObjListPtr snapshots;
+ virDomainSnapshotObjList *snapshots;
snapshots = g_new0(virDomainSnapshotObjList, 1);
snapshots->base = virDomainMomentObjListNew();
void
-virDomainSnapshotObjListFree(virDomainSnapshotObjListPtr snapshots)
+virDomainSnapshotObjListFree(virDomainSnapshotObjList *snapshots)
{
if (!snapshots)
return;
int
-virDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+virDomainSnapshotObjListGetNames(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
char **const names,
int maxnames,
unsigned int flags)
int
-virDomainSnapshotObjListNum(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+virDomainSnapshotObjListNum(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
unsigned int flags)
{
return virDomainSnapshotObjListGetNames(snapshots, from, NULL, 0, flags);
}
-virDomainMomentObjPtr
-virDomainSnapshotFindByName(virDomainSnapshotObjListPtr snapshots,
+virDomainMomentObj *
+virDomainSnapshotFindByName(virDomainSnapshotObjList *snapshots,
const char *name)
{
return virDomainMomentFindByName(snapshots->base, name);
/* Return the current snapshot, or NULL */
-virDomainMomentObjPtr
-virDomainSnapshotGetCurrent(virDomainSnapshotObjListPtr snapshots)
+virDomainMomentObj *
+virDomainSnapshotGetCurrent(virDomainSnapshotObjList *snapshots)
{
return virDomainMomentGetCurrent(snapshots->base);
}
/* Return the current snapshot's name, or NULL */
const char *
-virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots)
+virDomainSnapshotGetCurrentName(virDomainSnapshotObjList *snapshots)
{
return virDomainMomentGetCurrentName(snapshots->base);
}
/* Update the current snapshot, using NULL if no current remains */
void
-virDomainSnapshotSetCurrent(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr snapshot)
+virDomainSnapshotSetCurrent(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *snapshot)
{
virDomainMomentSetCurrent(snapshots->base, snapshot);
}
/* Remove snapshot from the list; return true if it was current */
bool
-virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr snapshot)
+virDomainSnapshotObjListRemove(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *snapshot)
{
return virDomainMomentObjListRemove(snapshots->base, snapshot);
}
/* Remove all snapshots tracked in the list */
void
-virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjListPtr snapshots)
+virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjList *snapshots)
{
return virDomainMomentObjListRemoveAll(snapshots->base);
}
int
-virDomainSnapshotForEach(virDomainSnapshotObjListPtr snapshots,
+virDomainSnapshotForEach(virDomainSnapshotObjList *snapshots,
virHashIterator iter,
void *data)
{
/* Populate parent link of a given snapshot. */
void
-virDomainSnapshotLinkParent(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr snap)
+virDomainSnapshotLinkParent(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *snap)
{
return virDomainMomentLinkParent(snapshots->base, snap);
}
* success, -1 if a parent is missing or if a circular relationship
* was requested. */
int
-virDomainSnapshotUpdateRelations(virDomainSnapshotObjListPtr snapshots)
+virDomainSnapshotUpdateRelations(virDomainSnapshotObjList *snapshots)
{
return virDomainMomentUpdateRelations(snapshots->base);
}
int
-virDomainSnapshotCheckCycles(virDomainSnapshotObjListPtr snapshots,
- virDomainSnapshotDefPtr def,
+virDomainSnapshotCheckCycles(virDomainSnapshotObjList *snapshots,
+ virDomainSnapshotDef *def,
const char *domname)
{
return virDomainMomentCheckCycles(snapshots->base, &def->parent, domname);
int
-virDomainListSnapshots(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+virDomainListSnapshots(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
virDomainPtr dom,
virDomainSnapshotPtr **snaps,
unsigned int flags)
#include "virdomainmomentobjlist.h"
#include "virbuffer.h"
-virDomainSnapshotObjListPtr virDomainSnapshotObjListNew(void);
-void virDomainSnapshotObjListFree(virDomainSnapshotObjListPtr snapshots);
+virDomainSnapshotObjList *virDomainSnapshotObjListNew(void);
+void virDomainSnapshotObjListFree(virDomainSnapshotObjList *snapshots);
-virDomainMomentObjPtr virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots,
- virDomainSnapshotDefPtr def);
+virDomainMomentObj *virDomainSnapshotAssignDef(virDomainSnapshotObjList *snapshots,
+ virDomainSnapshotDef *def);
-int virDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+int virDomainSnapshotObjListGetNames(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
char **const names, int maxnames,
unsigned int flags);
-int virDomainSnapshotObjListNum(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+int virDomainSnapshotObjListNum(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
unsigned int flags);
-virDomainMomentObjPtr virDomainSnapshotFindByName(virDomainSnapshotObjListPtr snapshots,
+virDomainMomentObj *virDomainSnapshotFindByName(virDomainSnapshotObjList *snapshots,
const char *name);
-virDomainMomentObjPtr virDomainSnapshotGetCurrent(virDomainSnapshotObjListPtr snapshots);
-const char *virDomainSnapshotGetCurrentName(virDomainSnapshotObjListPtr snapshots);
-void virDomainSnapshotSetCurrent(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr snapshot);
-bool virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr snapshot);
-void virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjListPtr snapshots);
-int virDomainSnapshotForEach(virDomainSnapshotObjListPtr snapshots,
+virDomainMomentObj *virDomainSnapshotGetCurrent(virDomainSnapshotObjList *snapshots);
+const char *virDomainSnapshotGetCurrentName(virDomainSnapshotObjList *snapshots);
+void virDomainSnapshotSetCurrent(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *snapshot);
+bool virDomainSnapshotObjListRemove(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *snapshot);
+void virDomainSnapshotObjListRemoveAll(virDomainSnapshotObjList *snapshots);
+int virDomainSnapshotForEach(virDomainSnapshotObjList *snapshots,
virHashIterator iter,
void *data);
-void virDomainSnapshotLinkParent(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr moment);
-int virDomainSnapshotUpdateRelations(virDomainSnapshotObjListPtr snapshots);
-int virDomainSnapshotCheckCycles(virDomainSnapshotObjListPtr snapshots,
- virDomainSnapshotDefPtr def,
+void virDomainSnapshotLinkParent(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *moment);
+int virDomainSnapshotUpdateRelations(virDomainSnapshotObjList *snapshots);
+int virDomainSnapshotCheckCycles(virDomainSnapshotObjList *snapshots,
+ virDomainSnapshotDef *def,
const char *domname);
#define VIR_DOMAIN_SNAPSHOT_FILTERS_METADATA \
VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS | \
VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION)
-int virDomainListSnapshots(virDomainSnapshotObjListPtr snapshots,
- virDomainMomentObjPtr from,
+int virDomainListSnapshots(virDomainSnapshotObjList *snapshots,
+ virDomainMomentObj *from,
virDomainPtr dom,
virDomainSnapshotPtr **snaps,
unsigned int flags);
/* Access the snapshot-specific definition from a given list member. */
-static inline virDomainSnapshotDefPtr
-virDomainSnapshotObjGetDef(virDomainMomentObjPtr obj)
+static inline virDomainSnapshotDef *
+virDomainSnapshotObjGetDef(virDomainMomentObj *obj)
{
- return (virDomainSnapshotDefPtr) obj->def;
+ return (virDomainSnapshotDef *) obj->def;
}
virObjectLockable parent;
bool active; /* true if interface is active (up) */
- virInterfaceDefPtr def; /* The interface definition */
+ virInterfaceDef *def; /* The interface definition */
};
struct _virInterfaceObjList {
/* virInterfaceObj manipulation */
-static virClassPtr virInterfaceObjClass;
-static virClassPtr virInterfaceObjListClass;
+static virClass *virInterfaceObjClass;
+static virClass *virInterfaceObjListClass;
static void virInterfaceObjDispose(void *obj);
static void virInterfaceObjListDispose(void *obj);
static void
virInterfaceObjDispose(void *opaque)
{
- virInterfaceObjPtr obj = opaque;
+ virInterfaceObj *obj = opaque;
virInterfaceDefFree(obj->def);
}
-static virInterfaceObjPtr
+static virInterfaceObj *
virInterfaceObjNew(void)
{
- virInterfaceObjPtr obj;
+ virInterfaceObj *obj;
if (virInterfaceObjInitialize() < 0)
return NULL;
void
-virInterfaceObjEndAPI(virInterfaceObjPtr *obj)
+virInterfaceObjEndAPI(virInterfaceObj **obj)
{
if (!*obj)
return;
}
-virInterfaceDefPtr
-virInterfaceObjGetDef(virInterfaceObjPtr obj)
+virInterfaceDef *
+virInterfaceObjGetDef(virInterfaceObj *obj)
{
return obj->def;
}
bool
-virInterfaceObjIsActive(virInterfaceObjPtr obj)
+virInterfaceObjIsActive(virInterfaceObj *obj)
{
return obj->active;
}
void
-virInterfaceObjSetActive(virInterfaceObjPtr obj,
+virInterfaceObjSetActive(virInterfaceObj *obj,
bool active)
{
obj->active = active;
/* virInterfaceObjList manipulation */
-virInterfaceObjListPtr
+virInterfaceObjList *
virInterfaceObjListNew(void)
{
- virInterfaceObjListPtr interfaces;
+ virInterfaceObjList *interfaces;
if (virInterfaceObjInitialize() < 0)
return NULL;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virInterfaceObjPtr obj = payload;
+ virInterfaceObj *obj = payload;
struct _virInterfaceObjFindMACData *data = opaque;
if (data->error)
int
-virInterfaceObjListFindByMACString(virInterfaceObjListPtr interfaces,
+virInterfaceObjListFindByMACString(virInterfaceObjList *interfaces,
const char *mac,
char **const matches,
int maxmatches)
}
-static virInterfaceObjPtr
-virInterfaceObjListFindByNameLocked(virInterfaceObjListPtr interfaces,
+static virInterfaceObj *
+virInterfaceObjListFindByNameLocked(virInterfaceObjList *interfaces,
const char *name)
{
return virObjectRef(virHashLookup(interfaces->objsName, name));
}
-virInterfaceObjPtr
-virInterfaceObjListFindByName(virInterfaceObjListPtr interfaces,
+virInterfaceObj *
+virInterfaceObjListFindByName(virInterfaceObjList *interfaces,
const char *name)
{
- virInterfaceObjPtr obj;
+ virInterfaceObj *obj;
virObjectRWLockRead(interfaces);
obj = virInterfaceObjListFindByNameLocked(interfaces, name);
virObjectRWUnlock(interfaces);
#define MATCH(FLAG) (flags & (FLAG))
static bool
-virInterfaceObjMatch(virInterfaceObjPtr obj,
+virInterfaceObjMatch(virInterfaceObj *obj,
unsigned int flags)
{
/* filter by active state */
typedef struct _virInterfaceObjListExportData virInterfaceObjListExportData;
-typedef virInterfaceObjListExportData *virInterfaceObjListExportDataPtr;
struct _virInterfaceObjListExportData {
virConnectPtr conn;
virInterfacePtr *ifaces;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virInterfaceObjListExportDataPtr data = opaque;
- virInterfaceObjPtr obj = payload;
+ virInterfaceObjListExportData *data = opaque;
+ virInterfaceObj *obj = payload;
virInterfacePtr iface = NULL;
if (data->error)
int
virInterfaceObjListExport(virConnectPtr conn,
- virInterfaceObjListPtr ifaceobjs,
+ virInterfaceObjList *ifaceobjs,
virInterfacePtr **ifaces,
virInterfaceObjListFilter filter,
unsigned int flags)
void
virInterfaceObjListDispose(void *obj)
{
- virInterfaceObjListPtr interfaces = obj;
+ virInterfaceObjList *interfaces = obj;
virHashFree(interfaces->objsName);
}
struct _virInterfaceObjListCloneData {
bool error;
- virInterfaceObjListPtr dest;
+ virInterfaceObjList *dest;
};
static int
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virInterfaceObjPtr srcObj = payload;
+ virInterfaceObj *srcObj = payload;
struct _virInterfaceObjListCloneData *data = opaque;
char *xml = NULL;
- virInterfaceDefPtr backup = NULL;
- virInterfaceObjPtr obj;
+ virInterfaceDef *backup = NULL;
+ virInterfaceObj *obj;
if (data->error)
return 0;
}
-virInterfaceObjListPtr
-virInterfaceObjListClone(virInterfaceObjListPtr interfaces)
+virInterfaceObjList *
+virInterfaceObjListClone(virInterfaceObjList *interfaces)
{
struct _virInterfaceObjListCloneData data = { .error = false,
.dest = NULL };
}
-virInterfaceObjPtr
-virInterfaceObjListAssignDef(virInterfaceObjListPtr interfaces,
- virInterfaceDefPtr def)
+virInterfaceObj *
+virInterfaceObjListAssignDef(virInterfaceObjList *interfaces,
+ virInterfaceDef *def)
{
- virInterfaceObjPtr obj;
+ virInterfaceObj *obj;
virObjectRWLockWrite(interfaces);
if ((obj = virInterfaceObjListFindByNameLocked(interfaces, def->name))) {
void
-virInterfaceObjListRemove(virInterfaceObjListPtr interfaces,
- virInterfaceObjPtr obj)
+virInterfaceObjListRemove(virInterfaceObjList *interfaces,
+ virInterfaceObj *obj)
{
if (!obj)
return;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virInterfaceObjPtr obj = payload;
+ virInterfaceObj *obj = payload;
struct _virInterfaceObjNumOfInterfacesData *data = opaque;
virObjectLock(obj);
int
-virInterfaceObjListNumOfInterfaces(virInterfaceObjListPtr interfaces,
+virInterfaceObjListNumOfInterfaces(virInterfaceObjList *interfaces,
bool wantActive)
{
struct _virInterfaceObjNumOfInterfacesData data = {
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virInterfaceObjPtr obj = payload;
+ virInterfaceObj *obj = payload;
struct _virInterfaceObjGetNamesData *data = opaque;
if (data->error)
int
-virInterfaceObjListGetNames(virInterfaceObjListPtr interfaces,
+virInterfaceObjListGetNames(virInterfaceObjList *interfaces,
bool wantActive,
char **const names,
int maxnames)
#include "internal.h"
typedef struct _virInterfaceObj virInterfaceObj;
-typedef virInterfaceObj *virInterfaceObjPtr;
typedef struct _virInterfaceObjList virInterfaceObjList;
-typedef virInterfaceObjList *virInterfaceObjListPtr;
void
-virInterfaceObjEndAPI(virInterfaceObjPtr *obj);
+virInterfaceObjEndAPI(virInterfaceObj **obj);
-virInterfaceDefPtr
-virInterfaceObjGetDef(virInterfaceObjPtr obj);
+virInterfaceDef *
+virInterfaceObjGetDef(virInterfaceObj *obj);
bool
-virInterfaceObjIsActive(virInterfaceObjPtr obj);
+virInterfaceObjIsActive(virInterfaceObj *obj);
void
-virInterfaceObjSetActive(virInterfaceObjPtr obj,
+virInterfaceObjSetActive(virInterfaceObj *obj,
bool active);
-virInterfaceObjListPtr
+virInterfaceObjList *
virInterfaceObjListNew(void);
int
-virInterfaceObjListFindByMACString(virInterfaceObjListPtr interfaces,
+virInterfaceObjListFindByMACString(virInterfaceObjList *interfaces,
const char *mac,
char **const matches,
int maxmatches);
-virInterfaceObjPtr
-virInterfaceObjListFindByName(virInterfaceObjListPtr interfaces,
+virInterfaceObj *
+virInterfaceObjListFindByName(virInterfaceObjList *interfaces,
const char *name);
void
-virInterfaceObjFree(virInterfaceObjPtr obj);
+virInterfaceObjFree(virInterfaceObj *obj);
-virInterfaceObjListPtr
-virInterfaceObjListClone(virInterfaceObjListPtr interfaces);
+virInterfaceObjList *
+virInterfaceObjListClone(virInterfaceObjList *interfaces);
-virInterfaceObjPtr
-virInterfaceObjListAssignDef(virInterfaceObjListPtr interfaces,
- virInterfaceDefPtr def);
+virInterfaceObj *
+virInterfaceObjListAssignDef(virInterfaceObjList *interfaces,
+ virInterfaceDef *def);
void
-virInterfaceObjListRemove(virInterfaceObjListPtr interfaces,
- virInterfaceObjPtr obj);
+virInterfaceObjListRemove(virInterfaceObjList *interfaces,
+ virInterfaceObj *obj);
typedef bool
(*virInterfaceObjListFilter)(virConnectPtr conn,
- virInterfaceDefPtr def);
+ virInterfaceDef *def);
int
-virInterfaceObjListNumOfInterfaces(virInterfaceObjListPtr interfaces,
+virInterfaceObjListNumOfInterfaces(virInterfaceObjList *interfaces,
bool wantActive);
int
-virInterfaceObjListGetNames(virInterfaceObjListPtr interfaces,
+virInterfaceObjListGetNames(virInterfaceObjList *interfaces,
bool wantActive,
char **const names,
int maxnames);
int
virInterfaceObjListExport(virConnectPtr conn,
- virInterfaceObjListPtr ifaceobjs,
+ virInterfaceObjList *ifaceobjs,
virInterfacePtr **ifaces,
virInterfaceObjListFilter filter,
unsigned int flags);
bool autostart;
bool persistent;
- virNetworkDefPtr def; /* The current definition */
- virNetworkDefPtr newDef; /* New definition to activate at shutdown */
+ virNetworkDef *def; /* The current definition */
+ virNetworkDef *newDef; /* New definition to activate at shutdown */
- virBitmapPtr classIdMap; /* bitmap of class IDs for QoS */
+ virBitmap *classIdMap; /* bitmap of class IDs for QoS */
unsigned long long floor_sum; /* sum of all 'floor'-s of attached NICs */
unsigned int taint;
/* Immutable pointer, self locking APIs */
- virMacMapPtr macmap;
+ virMacMap *macmap;
- GHashTable *ports; /* uuid -> virNetworkPortDefPtr */
+ GHashTable *ports; /* uuid -> virNetworkPortDef **/
};
struct _virNetworkObjList {
GHashTable *objs;
};
-static virClassPtr virNetworkObjClass;
-static virClassPtr virNetworkObjListClass;
+static virClass *virNetworkObjClass;
+static virClass *virNetworkObjListClass;
static void virNetworkObjDispose(void *obj);
static void virNetworkObjListDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virNetworkObj);
static int
-virNetworkObjLoadAllPorts(virNetworkObjPtr net,
+virNetworkObjLoadAllPorts(virNetworkObj *net,
const char *stateDir);
virNetworkPortDefFree(val);
}
-virNetworkObjPtr
+virNetworkObj *
virNetworkObjNew(void)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
if (virNetworkObjInitialize() < 0)
return NULL;
void
-virNetworkObjEndAPI(virNetworkObjPtr *obj)
+virNetworkObjEndAPI(virNetworkObj **obj)
{
if (!*obj)
return;
}
-virNetworkDefPtr
-virNetworkObjGetDef(virNetworkObjPtr obj)
+virNetworkDef *
+virNetworkObjGetDef(virNetworkObj *obj)
{
return obj->def;
}
void
-virNetworkObjSetDef(virNetworkObjPtr obj,
- virNetworkDefPtr def)
+virNetworkObjSetDef(virNetworkObj *obj,
+ virNetworkDef *def)
{
obj->def = def;
}
-virNetworkDefPtr
-virNetworkObjGetNewDef(virNetworkObjPtr obj)
+virNetworkDef *
+virNetworkObjGetNewDef(virNetworkObj *obj)
{
return obj->newDef;
}
bool
-virNetworkObjIsActive(virNetworkObjPtr obj)
+virNetworkObjIsActive(virNetworkObj *obj)
{
return obj->active;
}
void
-virNetworkObjSetActive(virNetworkObjPtr obj,
+virNetworkObjSetActive(virNetworkObj *obj,
bool active)
{
obj->active = active;
bool
-virNetworkObjIsPersistent(virNetworkObjPtr obj)
+virNetworkObjIsPersistent(virNetworkObj *obj)
{
return obj->persistent;
}
bool
-virNetworkObjIsAutostart(virNetworkObjPtr obj)
+virNetworkObjIsAutostart(virNetworkObj *obj)
{
return obj->autostart;
}
void
-virNetworkObjSetAutostart(virNetworkObjPtr obj,
+virNetworkObjSetAutostart(virNetworkObj *obj,
bool autostart)
{
obj->autostart = autostart;
pid_t
-virNetworkObjGetDnsmasqPid(virNetworkObjPtr obj)
+virNetworkObjGetDnsmasqPid(virNetworkObj *obj)
{
return obj->dnsmasqPid;
}
void
-virNetworkObjSetDnsmasqPid(virNetworkObjPtr obj,
+virNetworkObjSetDnsmasqPid(virNetworkObj *obj,
pid_t dnsmasqPid)
{
obj->dnsmasqPid = dnsmasqPid;
pid_t
-virNetworkObjGetRadvdPid(virNetworkObjPtr obj)
+virNetworkObjGetRadvdPid(virNetworkObj *obj)
{
return obj->radvdPid;
}
void
-virNetworkObjSetRadvdPid(virNetworkObjPtr obj,
+virNetworkObjSetRadvdPid(virNetworkObj *obj,
pid_t radvdPid)
{
obj->radvdPid = radvdPid;
}
-virBitmapPtr
-virNetworkObjGetClassIdMap(virNetworkObjPtr obj)
+virBitmap *
+virNetworkObjGetClassIdMap(virNetworkObj *obj)
{
return obj->classIdMap;
}
-virMacMapPtr
-virNetworkObjGetMacMap(virNetworkObjPtr obj)
+virMacMap *
+virNetworkObjGetMacMap(virNetworkObj *obj)
{
return obj->macmap;
}
unsigned long long
-virNetworkObjGetFloorSum(virNetworkObjPtr obj)
+virNetworkObjGetFloorSum(virNetworkObj *obj)
{
return obj->floor_sum;
}
void
-virNetworkObjSetFloorSum(virNetworkObjPtr obj,
+virNetworkObjSetFloorSum(virNetworkObj *obj,
unsigned long long floor_sum)
{
obj->floor_sum = floor_sum;
void
-virNetworkObjSetMacMap(virNetworkObjPtr obj,
- virMacMapPtr macmap)
+virNetworkObjSetMacMap(virNetworkObj *obj,
+ virMacMap *macmap)
{
obj->macmap = macmap;
}
void
-virNetworkObjUnrefMacMap(virNetworkObjPtr obj)
+virNetworkObjUnrefMacMap(virNetworkObj *obj)
{
virObjectUnref(obj->macmap);
obj->macmap = NULL;
int
-virNetworkObjMacMgrAdd(virNetworkObjPtr obj,
+virNetworkObjMacMgrAdd(virNetworkObj *obj,
const char *dnsmasqStateDir,
const char *domain,
const virMacAddr *mac)
int
-virNetworkObjMacMgrDel(virNetworkObjPtr obj,
+virNetworkObjMacMgrDel(virNetworkObj *obj,
const char *dnsmasqStateDir,
const char *domain,
const virMacAddr *mac)
}
-virNetworkObjListPtr
+virNetworkObjList *
virNetworkObjListNew(void)
{
- virNetworkObjListPtr nets;
+ virNetworkObjList *nets;
if (virNetworkObjInitialize() < 0)
return NULL;
}
-static virNetworkObjPtr
-virNetworkObjFindByUUIDLocked(virNetworkObjListPtr nets,
+static virNetworkObj *
+virNetworkObjFindByUUIDLocked(virNetworkObjList *nets,
const unsigned char *uuid)
{
- virNetworkObjPtr obj = NULL;
+ virNetworkObj *obj = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(uuid, uuidstr);
*
* Returns: locked and ref'd network object.
*/
-virNetworkObjPtr
-virNetworkObjFindByUUID(virNetworkObjListPtr nets,
+virNetworkObj *
+virNetworkObjFindByUUID(virNetworkObjList *nets,
const unsigned char *uuid)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
virObjectRWLockRead(nets);
obj = virNetworkObjFindByUUIDLocked(nets, uuid);
const char *name G_GNUC_UNUSED,
const void *data)
{
- virNetworkObjPtr obj = (virNetworkObjPtr) payload;
+ virNetworkObj *obj = (virNetworkObj *) payload;
int want = 0;
virObjectLock(obj);
}
-static virNetworkObjPtr
-virNetworkObjFindByNameLocked(virNetworkObjListPtr nets,
+static virNetworkObj *
+virNetworkObjFindByNameLocked(virNetworkObjList *nets,
const char *name)
{
- virNetworkObjPtr obj = NULL;
+ virNetworkObj *obj = NULL;
obj = virHashSearch(nets->objs, virNetworkObjSearchName, name, NULL);
if (obj)
*
* Returns: locked and ref'd network object.
*/
-virNetworkObjPtr
-virNetworkObjFindByName(virNetworkObjListPtr nets,
+virNetworkObj *
+virNetworkObjFindByName(virNetworkObjList *nets,
const char *name)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
virObjectRWLockRead(nets);
obj = virNetworkObjFindByNameLocked(nets, name);
bool
-virNetworkObjTaint(virNetworkObjPtr obj,
+virNetworkObjTaint(virNetworkObj *obj,
virNetworkTaintFlags taint)
{
unsigned int flag = (1 << taint);
static void
virNetworkObjDispose(void *opaque)
{
- virNetworkObjPtr obj = opaque;
+ virNetworkObj *obj = opaque;
virHashFree(obj->ports);
virNetworkDefFree(obj->def);
static void
virNetworkObjListDispose(void *opaque)
{
- virNetworkObjListPtr nets = opaque;
+ virNetworkObjList *nets = opaque;
virHashFree(nets->objs);
}
*
*/
void
-virNetworkObjUpdateAssignDef(virNetworkObjPtr obj,
- virNetworkDefPtr def,
+virNetworkObjUpdateAssignDef(virNetworkObj *obj,
+ virNetworkDef *def,
bool live)
{
if (live) {
*
* If flags is zero, network is considered as inactive and persistent.
*/
-static virNetworkObjPtr
-virNetworkObjAssignDefLocked(virNetworkObjListPtr nets,
- virNetworkDefPtr def,
+static virNetworkObj *
+virNetworkObjAssignDefLocked(virNetworkObjList *nets,
+ virNetworkDef *def,
unsigned int flags)
{
- virNetworkObjPtr obj;
- virNetworkObjPtr ret = NULL;
+ virNetworkObj *obj;
+ virNetworkObj *ret = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
/* See if a network with matching UUID already exists */
*
* Look at virNetworkObjAssignDefLocked() for @flags description.
*
- * Returns NULL on error, virNetworkObjPtr on success.
+ * Returns NULL on error, virNetworkObj *on success.
*/
-virNetworkObjPtr
-virNetworkObjAssignDef(virNetworkObjListPtr nets,
- virNetworkDefPtr def,
+virNetworkObj *
+virNetworkObjAssignDef(virNetworkObjList *nets,
+ virNetworkDef *def,
unsigned int flags)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
virObjectRWLockWrite(nets);
obj = virNetworkObjAssignDefLocked(nets, def, flags);
* Returns 0 on success, -1 on failure
*/
int
-virNetworkObjSetDefTransient(virNetworkObjPtr obj,
+virNetworkObjSetDefTransient(virNetworkObj *obj,
bool live,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
if (!virNetworkObjIsActive(obj) && !live)
return 0;
* This *undoes* what virNetworkObjSetDefTransient did.
*/
void
-virNetworkObjUnsetDefTransient(virNetworkObjPtr obj)
+virNetworkObjUnsetDefTransient(virNetworkObj *obj)
{
if (obj->newDef) {
virNetworkDefFree(obj->def);
* Return the persistent network configuration. If network is transient,
* return the running config.
*
- * Returns NULL on error, virNetworkDefPtr on success.
+ * Returns NULL on error, virNetworkDef *on success.
*/
-virNetworkDefPtr
-virNetworkObjGetPersistentDef(virNetworkObjPtr obj)
+virNetworkDef *
+virNetworkObjGetPersistentDef(virNetworkObj *obj)
{
if (obj->newDef)
return obj->newDef;
* Returns -1 on error, 0 on success
*/
int
-virNetworkObjReplacePersistentDef(virNetworkObjPtr obj,
- virNetworkDefPtr def)
+virNetworkObjReplacePersistentDef(virNetworkObj *obj,
+ virNetworkDef *def)
{
if (virNetworkObjIsActive(obj)) {
virNetworkDefFree(obj->newDef);
* Returns 0 on success, -1 on error.
*/
static int
-virNetworkObjConfigChangeSetup(virNetworkObjPtr obj,
- virNetworkXMLOptionPtr xmlopt,
+virNetworkObjConfigChangeSetup(virNetworkObj *obj,
+ virNetworkXMLOption *xmlopt,
unsigned int flags)
{
bool isActive;
void
-virNetworkObjRemoveInactive(virNetworkObjListPtr nets,
- virNetworkObjPtr obj)
+virNetworkObjRemoveInactive(virNetworkObjList *nets,
+ virNetworkObj *obj)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
static char *
-virNetworkObjFormat(virNetworkObjPtr obj,
- virNetworkXMLOptionPtr xmlopt,
+virNetworkObjFormat(virNetworkObj *obj,
+ virNetworkXMLOption *xmlopt,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int
virNetworkObjSaveStatus(const char *statusDir,
- virNetworkObjPtr obj,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkObj *obj,
+ virNetworkXMLOption *xmlopt)
{
int ret = -1;
int flags = 0;
}
-static virNetworkObjPtr
-virNetworkLoadState(virNetworkObjListPtr nets,
+static virNetworkObj *
+virNetworkLoadState(virNetworkObjList *nets,
const char *stateDir,
const char *name,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
char *configFile = NULL;
- virNetworkDefPtr def = NULL;
- virNetworkObjPtr obj = NULL;
+ virNetworkDef *def = NULL;
+ virNetworkObj *obj = NULL;
xmlDocPtr xml = NULL;
xmlNodePtr node = NULL, *nodes = NULL;
xmlXPathContextPtr ctxt = NULL;
- virBitmapPtr classIdMap = NULL;
+ virBitmap *classIdMap = NULL;
unsigned long long floor_sum_val = 0;
unsigned int taint = 0;
int n;
}
-static virNetworkObjPtr
-virNetworkLoadConfig(virNetworkObjListPtr nets,
+static virNetworkObj *
+virNetworkLoadConfig(virNetworkObjList *nets,
const char *configDir,
const char *autostartDir,
const char *name,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
char *configFile = NULL, *autostartLink = NULL;
- virNetworkDefPtr def = NULL;
- virNetworkObjPtr obj;
+ virNetworkDef *def = NULL;
+ virNetworkObj *obj;
bool saveConfig = false;
int autostart;
int
-virNetworkObjLoadAllState(virNetworkObjListPtr nets,
+virNetworkObjLoadAllState(virNetworkObjList *nets,
const char *stateDir,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
g_autoptr(DIR) dir = NULL;
struct dirent *entry;
return rc;
while ((ret = virDirRead(dir, &entry, stateDir)) > 0) {
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
int
-virNetworkObjLoadAllConfigs(virNetworkObjListPtr nets,
+virNetworkObjLoadAllConfigs(virNetworkObjList *nets,
const char *configDir,
const char *autostartDir,
- virNetworkXMLOptionPtr xmlopt)
+ virNetworkXMLOption *xmlopt)
{
g_autoptr(DIR) dir = NULL;
struct dirent *entry;
return rc;
while ((ret = virDirRead(dir, &entry, configDir)) > 0) {
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
int
virNetworkObjDeleteConfig(const char *configDir,
const char *autostartDir,
- virNetworkObjPtr obj)
+ virNetworkObj *obj)
{
char *configFile = NULL;
char *autostartLink = NULL;
const void *opaque)
{
int ret;
- virNetworkObjPtr obj = (virNetworkObjPtr) payload;
+ virNetworkObj *obj = (virNetworkObj *) payload;
const struct virNetworkObjBridgeInUseHelperData *data = opaque;
virObjectLock(obj);
bool
-virNetworkObjBridgeInUse(virNetworkObjListPtr nets,
+virNetworkObjBridgeInUse(virNetworkObjList *nets,
const char *bridge,
const char *skipname)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
struct virNetworkObjBridgeInUseHelperData data = {bridge, skipname};
virObjectRWLockRead(nets);
* Returns: -1 on error, 0 on success.
*/
int
-virNetworkObjUpdate(virNetworkObjPtr obj,
+virNetworkObjUpdate(virNetworkObj *obj,
unsigned int command, /* virNetworkUpdateCommand */
unsigned int section, /* virNetworkUpdateSection */
int parentIndex,
const char *xml,
- virNetworkXMLOptionPtr xmlopt,
+ virNetworkXMLOption *xmlopt,
unsigned int flags) /* virNetworkUpdateFlags */
{
int ret = -1;
- virNetworkDefPtr livedef = NULL;
- virNetworkDefPtr configdef = NULL;
+ virNetworkDef *livedef = NULL;
+ virNetworkDef *configdef = NULL;
/* normalize config data, and check for common invalid requests. */
if (virNetworkObjConfigChangeSetup(obj, xmlopt, flags) < 0)
goto cleanup;
if (flags & VIR_NETWORK_UPDATE_AFFECT_LIVE) {
- virNetworkDefPtr checkdef;
+ virNetworkDef *checkdef;
/* work on a copy of the def */
if (!(livedef = virNetworkDefCopy(obj->def, xmlopt, 0)))
}
if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) {
- virNetworkDefPtr checkdef;
+ virNetworkDef *checkdef;
/* work on a copy of the def */
if (!(configdef = virNetworkDefCopy(virNetworkObjGetPersistentDef(obj),
#define MATCH(FLAG) (flags & (FLAG))
static bool
-virNetworkObjMatch(virNetworkObjPtr obj,
+virNetworkObjMatch(virNetworkObj *obj,
unsigned int flags)
{
/* filter by active state */
typedef struct _virNetworkObjListExportData virNetworkObjListExportData;
-typedef virNetworkObjListExportData *virNetworkObjListExportDataPtr;
struct _virNetworkObjListExportData {
virConnectPtr conn;
virNetworkPtr *nets;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNetworkObjListExportDataPtr data = opaque;
- virNetworkObjPtr obj = payload;
+ virNetworkObjListExportData *data = opaque;
+ virNetworkObj *obj = payload;
virNetworkPtr net = NULL;
if (data->error)
int
virNetworkObjListExport(virConnectPtr conn,
- virNetworkObjListPtr netobjs,
+ virNetworkObjList *netobjs,
virNetworkPtr **nets,
virNetworkObjListFilter filter,
unsigned int flags)
* Returns: 0 on success, -1 otherwise.
*/
int
-virNetworkObjListForEach(virNetworkObjListPtr nets,
+virNetworkObjListForEach(virNetworkObjList *nets,
virNetworkObjListIterator callback,
void *opaque)
{
void *opaque)
{
struct virNetworkObjListGetHelperData *data = opaque;
- virNetworkObjPtr obj = payload;
+ virNetworkObj *obj = payload;
if (data->error)
return 0;
int
-virNetworkObjListGetNames(virNetworkObjListPtr nets,
+virNetworkObjListGetNames(virNetworkObjList *nets,
bool active,
char **names,
int maxnames,
int
-virNetworkObjListNumOfNetworks(virNetworkObjListPtr nets,
+virNetworkObjListNumOfNetworks(virNetworkObjList *nets,
bool active,
virNetworkObjListFilter filter,
virConnectPtr conn)
const void *opaque)
{
const struct virNetworkObjListPruneHelperData *data = opaque;
- virNetworkObjPtr obj = (virNetworkObjPtr) payload;
+ virNetworkObj *obj = (virNetworkObj *) payload;
int want = 0;
virObjectLock(obj);
* ones from it.
*/
void
-virNetworkObjListPrune(virNetworkObjListPtr nets,
+virNetworkObjListPrune(virNetworkObjList *nets,
unsigned int flags)
{
struct virNetworkObjListPruneHelperData data = {flags};
char *
-virNetworkObjGetPortStatusDir(virNetworkObjPtr net,
+virNetworkObjGetPortStatusDir(virNetworkObj *net,
const char *stateDir)
{
char *ret;
}
int
-virNetworkObjAddPort(virNetworkObjPtr net,
- virNetworkPortDefPtr portdef,
+virNetworkObjAddPort(virNetworkObj *net,
+ virNetworkPortDef *portdef,
const char *stateDir)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
-virNetworkPortDefPtr
-virNetworkObjLookupPort(virNetworkObjPtr net,
+virNetworkPortDef *
+virNetworkObjLookupPort(virNetworkObj *net,
const unsigned char *uuid)
{
- virNetworkPortDefPtr ret = NULL;
+ virNetworkPortDef *ret = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(uuid, uuidstr);
int
-virNetworkObjDeletePort(virNetworkObjPtr net,
+virNetworkObjDeletePort(virNetworkObj *net,
const unsigned char *uuid,
const char *stateDir)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
g_autofree char *dir = NULL;
- virNetworkPortDefPtr portdef;
+ virNetworkPortDef *portdef;
virUUIDFormat(uuid, uuidstr);
int
-virNetworkObjDeleteAllPorts(virNetworkObjPtr net,
+virNetworkObjDeleteAllPorts(virNetworkObj *net,
const char *stateDir)
{
g_autofree char *dir = NULL;
typedef struct _virNetworkObjPortListExportData virNetworkObjPortListExportData;
-typedef virNetworkObjPortListExportData *virNetworkObjPortListExportDataPtr;
struct _virNetworkObjPortListExportData {
virNetworkPtr net;
- virNetworkDefPtr def;
+ virNetworkDef *def;
virNetworkPortPtr *ports;
virNetworkPortListFilter filter;
int nports;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNetworkObjPortListExportDataPtr data = opaque;
- virNetworkPortDefPtr def = payload;
+ virNetworkObjPortListExportData *data = opaque;
+ virNetworkPortDef *def = payload;
virNetworkPortPtr port;
if (data->error)
int
virNetworkObjPortListExport(virNetworkPtr net,
- virNetworkObjPtr obj,
+ virNetworkObj *obj,
virNetworkPortPtr **ports,
virNetworkPortListFilter filter)
{
}
int
-virNetworkObjPortForEach(virNetworkObjPtr obj,
+virNetworkObjPortForEach(virNetworkObj *obj,
virNetworkPortListIter iter,
void *opaque)
{
static int
-virNetworkObjLoadAllPorts(virNetworkObjPtr net,
+virNetworkObjLoadAllPorts(virNetworkObj *net,
const char *stateDir)
{
g_autofree char *dir = NULL;
#include "virnetworkportdef.h"
typedef struct _virNetworkObj virNetworkObj;
-typedef virNetworkObj *virNetworkObjPtr;
-virNetworkObjPtr
+virNetworkObj *
virNetworkObjNew(void);
-virNetworkDefPtr
-virNetworkObjGetDef(virNetworkObjPtr obj);
+virNetworkDef *
+virNetworkObjGetDef(virNetworkObj *obj);
void
-virNetworkObjSetDef(virNetworkObjPtr obj,
- virNetworkDefPtr def);
+virNetworkObjSetDef(virNetworkObj *obj,
+ virNetworkDef *def);
-virNetworkDefPtr
-virNetworkObjGetNewDef(virNetworkObjPtr obj);
+virNetworkDef *
+virNetworkObjGetNewDef(virNetworkObj *obj);
bool
-virNetworkObjIsActive(virNetworkObjPtr obj);
+virNetworkObjIsActive(virNetworkObj *obj);
void
-virNetworkObjSetActive(virNetworkObjPtr obj,
+virNetworkObjSetActive(virNetworkObj *obj,
bool active);
bool
-virNetworkObjIsPersistent(virNetworkObjPtr obj);
+virNetworkObjIsPersistent(virNetworkObj *obj);
bool
-virNetworkObjIsAutostart(virNetworkObjPtr obj);
+virNetworkObjIsAutostart(virNetworkObj *obj);
void
-virNetworkObjSetAutostart(virNetworkObjPtr obj,
+virNetworkObjSetAutostart(virNetworkObj *obj,
bool autostart);
-virMacMapPtr
-virNetworkObjGetMacMap(virNetworkObjPtr obj);
+virMacMap *
+virNetworkObjGetMacMap(virNetworkObj *obj);
pid_t
-virNetworkObjGetDnsmasqPid(virNetworkObjPtr obj);
+virNetworkObjGetDnsmasqPid(virNetworkObj *obj);
void
-virNetworkObjSetDnsmasqPid(virNetworkObjPtr obj,
+virNetworkObjSetDnsmasqPid(virNetworkObj *obj,
pid_t dnsmasqPid);
pid_t
-virNetworkObjGetRadvdPid(virNetworkObjPtr obj);
+virNetworkObjGetRadvdPid(virNetworkObj *obj);
void
-virNetworkObjSetRadvdPid(virNetworkObjPtr obj,
+virNetworkObjSetRadvdPid(virNetworkObj *obj,
pid_t radvdPid);
-virBitmapPtr
-virNetworkObjGetClassIdMap(virNetworkObjPtr obj);
+virBitmap *
+virNetworkObjGetClassIdMap(virNetworkObj *obj);
unsigned long long
-virNetworkObjGetFloorSum(virNetworkObjPtr obj);
+virNetworkObjGetFloorSum(virNetworkObj *obj);
void
-virNetworkObjSetFloorSum(virNetworkObjPtr obj,
+virNetworkObjSetFloorSum(virNetworkObj *obj,
unsigned long long floor_sum);
void
-virNetworkObjSetMacMap(virNetworkObjPtr obj,
- virMacMapPtr macmap);
+virNetworkObjSetMacMap(virNetworkObj *obj,
+ virMacMap *macmap);
void
-virNetworkObjUnrefMacMap(virNetworkObjPtr obj);
+virNetworkObjUnrefMacMap(virNetworkObj *obj);
int
-virNetworkObjMacMgrAdd(virNetworkObjPtr obj,
+virNetworkObjMacMgrAdd(virNetworkObj *obj,
const char *dnsmasqStateDir,
const char *domain,
const virMacAddr *mac);
int
-virNetworkObjMacMgrDel(virNetworkObjPtr obj,
+virNetworkObjMacMgrDel(virNetworkObj *obj,
const char *dnsmasqStateDir,
const char *domain,
const virMacAddr *mac);
void
-virNetworkObjEndAPI(virNetworkObjPtr *net);
+virNetworkObjEndAPI(virNetworkObj **net);
typedef struct _virNetworkObjList virNetworkObjList;
-typedef virNetworkObjList *virNetworkObjListPtr;
-virNetworkObjListPtr
+virNetworkObjList *
virNetworkObjListNew(void);
-virNetworkObjPtr
-virNetworkObjFindByUUID(virNetworkObjListPtr nets,
+virNetworkObj *
+virNetworkObjFindByUUID(virNetworkObjList *nets,
const unsigned char *uuid);
-virNetworkObjPtr
-virNetworkObjFindByName(virNetworkObjListPtr nets,
+virNetworkObj *
+virNetworkObjFindByName(virNetworkObjList *nets,
const char *name);
bool
-virNetworkObjTaint(virNetworkObjPtr obj,
+virNetworkObjTaint(virNetworkObj *obj,
virNetworkTaintFlags taint);
typedef bool
(*virNetworkObjListFilter)(virConnectPtr conn,
- virNetworkDefPtr def);
+ virNetworkDef *def);
-virNetworkObjPtr
-virNetworkObjAssignDef(virNetworkObjListPtr nets,
- virNetworkDefPtr def,
+virNetworkObj *
+virNetworkObjAssignDef(virNetworkObjList *nets,
+ virNetworkDef *def,
unsigned int flags);
void
-virNetworkObjUpdateAssignDef(virNetworkObjPtr network,
- virNetworkDefPtr def,
+virNetworkObjUpdateAssignDef(virNetworkObj *network,
+ virNetworkDef *def,
bool live);
int
-virNetworkObjSetDefTransient(virNetworkObjPtr network,
+virNetworkObjSetDefTransient(virNetworkObj *network,
bool live,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
void
-virNetworkObjUnsetDefTransient(virNetworkObjPtr network);
+virNetworkObjUnsetDefTransient(virNetworkObj *network);
-virNetworkDefPtr
-virNetworkObjGetPersistentDef(virNetworkObjPtr network);
+virNetworkDef *
+virNetworkObjGetPersistentDef(virNetworkObj *network);
int
-virNetworkObjReplacePersistentDef(virNetworkObjPtr network,
- virNetworkDefPtr def);
+virNetworkObjReplacePersistentDef(virNetworkObj *network,
+ virNetworkDef *def);
void
-virNetworkObjRemoveInactive(virNetworkObjListPtr nets,
- virNetworkObjPtr net);
+virNetworkObjRemoveInactive(virNetworkObjList *nets,
+ virNetworkObj *net);
int
-virNetworkObjAddPort(virNetworkObjPtr net,
- virNetworkPortDefPtr portdef,
+virNetworkObjAddPort(virNetworkObj *net,
+ virNetworkPortDef *portdef,
const char *stateDir);
char *
-virNetworkObjGetPortStatusDir(virNetworkObjPtr net,
+virNetworkObjGetPortStatusDir(virNetworkObj *net,
const char *stateDir);
-virNetworkPortDefPtr
-virNetworkObjLookupPort(virNetworkObjPtr net,
+virNetworkPortDef *
+virNetworkObjLookupPort(virNetworkObj *net,
const unsigned char *uuid);
int
-virNetworkObjDeletePort(virNetworkObjPtr net,
+virNetworkObjDeletePort(virNetworkObj *net,
const unsigned char *uuid,
const char *stateDir);
int
-virNetworkObjDeleteAllPorts(virNetworkObjPtr net,
+virNetworkObjDeleteAllPorts(virNetworkObj *net,
const char *stateDir);
typedef bool
(*virNetworkPortListFilter)(virConnectPtr conn,
- virNetworkDefPtr def,
- virNetworkPortDefPtr portdef);
+ virNetworkDef *def,
+ virNetworkPortDef *portdef);
int
virNetworkObjPortListExport(virNetworkPtr net,
- virNetworkObjPtr obj,
+ virNetworkObj *obj,
virNetworkPortPtr **ports,
virNetworkPortListFilter filter);
typedef bool
-(*virNetworkPortListIter)(virNetworkPortDefPtr portdef,
+(*virNetworkPortListIter)(virNetworkPortDef *portdef,
void *opaque);
int
-virNetworkObjPortForEach(virNetworkObjPtr obj,
+virNetworkObjPortForEach(virNetworkObj *obj,
virNetworkPortListIter iter,
void *opaque);
int
virNetworkObjSaveStatus(const char *statusDir,
- virNetworkObjPtr net,
- virNetworkXMLOptionPtr xmlopt) G_GNUC_WARN_UNUSED_RESULT;
+ virNetworkObj *net,
+ virNetworkXMLOption *xmlopt) G_GNUC_WARN_UNUSED_RESULT;
int
-virNetworkObjLoadAllConfigs(virNetworkObjListPtr nets,
+virNetworkObjLoadAllConfigs(virNetworkObjList *nets,
const char *configDir,
const char *autostartDir,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
int
-virNetworkObjLoadAllState(virNetworkObjListPtr nets,
+virNetworkObjLoadAllState(virNetworkObjList *nets,
const char *stateDir,
- virNetworkXMLOptionPtr xmlopt);
+ virNetworkXMLOption *xmlopt);
int
virNetworkObjDeleteConfig(const char *configDir,
const char *autostartDir,
- virNetworkObjPtr net);
+ virNetworkObj *net);
bool
-virNetworkObjBridgeInUse(virNetworkObjListPtr nets,
+virNetworkObjBridgeInUse(virNetworkObjList *nets,
const char *bridge,
const char *skipname);
int
-virNetworkObjUpdate(virNetworkObjPtr obj,
+virNetworkObjUpdate(virNetworkObj *obj,
unsigned int command, /* virNetworkUpdateCommand */
unsigned int section, /* virNetworkUpdateSection */
int parentIndex,
const char *xml,
- virNetworkXMLOptionPtr xmlopt,
+ virNetworkXMLOption *xmlopt,
unsigned int flags); /* virNetworkUpdateFlags */
int
virNetworkObjListExport(virConnectPtr conn,
- virNetworkObjListPtr netobjs,
+ virNetworkObjList *netobjs,
virNetworkPtr **nets,
virNetworkObjListFilter filter,
unsigned int flags);
typedef int
-(*virNetworkObjListIterator)(virNetworkObjPtr net,
+(*virNetworkObjListIterator)(virNetworkObj *net,
void *opaque);
int
-virNetworkObjListForEach(virNetworkObjListPtr nets,
+virNetworkObjListForEach(virNetworkObjList *nets,
virNetworkObjListIterator callback,
void *opaque);
int
-virNetworkObjListGetNames(virNetworkObjListPtr nets,
+virNetworkObjListGetNames(virNetworkObjList *nets,
bool active,
char **names,
int maxnames,
virConnectPtr conn);
int
-virNetworkObjListNumOfNetworks(virNetworkObjListPtr nets,
+virNetworkObjListNumOfNetworks(virNetworkObjList *nets,
bool active,
virNetworkObjListFilter filter,
virConnectPtr conn);
void
-virNetworkObjListPrune(virNetworkObjListPtr nets,
+virNetworkObjListPrune(virNetworkObjList *nets,
unsigned int flags);
"none", "network", "bridge", "direct", "hostdev-pci");
void
-virNetworkPortDefFree(virNetworkPortDefPtr def)
+virNetworkPortDefFree(virNetworkPortDef *def)
{
if (!def)
return;
-static virNetworkPortDefPtr
+static virNetworkPortDef *
virNetworkPortDefParseXML(xmlXPathContextPtr ctxt)
{
g_autoptr(virNetworkPortDef) def = NULL;
}
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseNode(xmlDocPtr xml,
xmlNodePtr root)
{
xmlXPathContextPtr ctxt = NULL;
- virNetworkPortDefPtr def = NULL;
+ virNetworkPortDef *def = NULL;
if (STRNEQ((const char *)root->name, "networkport")) {
virReportError(VIR_ERR_XML_ERROR,
}
-static virNetworkPortDefPtr
+static virNetworkPortDef *
virNetworkPortDefParse(const char *xmlStr,
const char *filename)
{
- virNetworkPortDefPtr def = NULL;
+ virNetworkPortDef *def = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(networkport_definition)")))) {
}
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseString(const char *xmlStr)
{
return virNetworkPortDefParse(xmlStr, NULL);
}
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseFile(const char *filename)
{
return virNetworkPortDefParse(NULL, filename);
int
-virNetworkPortDefFormatBuf(virBufferPtr buf,
+virNetworkPortDefFormatBuf(virBuffer *buf,
const virNetworkPortDef *def)
{
char uuid[VIR_UUID_STRING_BUFLEN];
#include "virxml.h"
typedef struct _virNetworkPortDef virNetworkPortDef;
-typedef virNetworkPortDef *virNetworkPortDefPtr;
typedef enum {
VIR_NETWORK_PORT_PLUG_TYPE_NONE,
char *group;
virMacAddr mac;
- virNetDevVPortProfilePtr virtPortProfile;
- virNetDevBandwidthPtr bandwidth;
+ virNetDevVPortProfile *virtPortProfile;
+ virNetDevBandwidth *bandwidth;
unsigned int class_id; /* class ID for bandwidth 'floor' */
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
void
-virNetworkPortDefFree(virNetworkPortDefPtr port);
+virNetworkPortDefFree(virNetworkPortDef *port);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetworkPortDef, virNetworkPortDefFree);
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseNode(xmlDocPtr xml,
xmlNodePtr root);
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseString(const char *xml);
-virNetworkPortDefPtr
+virNetworkPortDef *
virNetworkPortDefParseFile(const char *filename);
char *
virNetworkPortDefFormat(const virNetworkPortDef *def);
int
-virNetworkPortDefFormatBuf(virBufferPtr buf,
+virNetworkPortDefFormatBuf(virBuffer *buf,
const virNetworkPortDef *def);
int
struct _virNodeDeviceObj {
virObjectLockable parent;
- virNodeDeviceDefPtr def; /* device definition */
+ virNodeDeviceDef *def; /* device definition */
bool skipUpdateCaps; /* whether to skip checking host caps,
used by testdriver */
bool active;
};
-static virClassPtr virNodeDeviceObjClass;
-static virClassPtr virNodeDeviceObjListClass;
+static virClass *virNodeDeviceObjClass;
+static virClass *virNodeDeviceObjListClass;
static void virNodeDeviceObjDispose(void *opaque);
static void virNodeDeviceObjListDispose(void *opaque);
static bool virNodeDeviceObjHasCap(const virNodeDeviceObj *obj, int type);
static void
virNodeDeviceObjDispose(void *opaque)
{
- virNodeDeviceObjPtr obj = opaque;
+ virNodeDeviceObj *obj = opaque;
virNodeDeviceDefFree(obj->def);
}
-static virNodeDeviceObjPtr
+static virNodeDeviceObj *
virNodeDeviceObjNew(void)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
if (virNodeDeviceObjInitialize() < 0)
return NULL;
void
-virNodeDeviceObjEndAPI(virNodeDeviceObjPtr *obj)
+virNodeDeviceObjEndAPI(virNodeDeviceObj **obj)
{
if (!*obj)
return;
}
-virNodeDeviceDefPtr
-virNodeDeviceObjGetDef(virNodeDeviceObjPtr obj)
+virNodeDeviceDef *
+virNodeDeviceObjGetDef(virNodeDeviceObj *obj)
{
return obj->def;
}
* Returns:
* Pointer to the caps or NULL if not found
*/
-static virNodeDevCapsDefPtr
+static virNodeDevCapsDef *
virNodeDeviceFindFCCapDef(const virNodeDeviceObj *obj)
{
- virNodeDevCapsDefPtr caps = obj->def->caps;
+ virNodeDevCapsDef *caps = obj->def->caps;
while (caps) {
if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST &&
* Returns:
* Pointer to the caps or NULL if not found
*/
-static virNodeDevCapsDefPtr
+static virNodeDevCapsDef *
virNodeDeviceFindVPORTCapDef(const virNodeDeviceObj *obj)
{
- virNodeDevCapsDefPtr caps = obj->def->caps;
+ virNodeDevCapsDef *caps = obj->def->caps;
while (caps) {
if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST &&
}
-static virNodeDeviceObjPtr
-virNodeDeviceObjListSearch(virNodeDeviceObjListPtr devs,
+static virNodeDeviceObj *
+virNodeDeviceObjListSearch(virNodeDeviceObjList *devs,
virHashSearcher callback,
const void *data)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
virObjectRWLockRead(devs);
obj = virHashSearch(devs->objs, callback, data, NULL);
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
const char *sysfs_path = opaque;
int want = 0;
}
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindBySysfsPath(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindBySysfsPath(virNodeDeviceObjList *devs,
const char *sysfs_path)
{
return virNodeDeviceObjListSearch(devs,
}
-static virNodeDeviceObjPtr
-virNodeDeviceObjListFindByNameLocked(virNodeDeviceObjListPtr devs,
+static virNodeDeviceObj *
+virNodeDeviceObjListFindByNameLocked(virNodeDeviceObjList *devs,
const char *name)
{
return virObjectRef(virHashLookup(devs->objs, name));
}
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindByName(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindByName(virNodeDeviceObjList *devs,
const char *name)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
virObjectRWLockRead(devs);
obj = virNodeDeviceObjListFindByNameLocked(devs, name);
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
struct virNodeDeviceObjListFindByWWNsData *data =
(struct virNodeDeviceObjListFindByWWNsData *) opaque;
- virNodeDevCapsDefPtr cap;
+ virNodeDevCapsDef *cap;
int want = 0;
virObjectLock(obj);
}
-static virNodeDeviceObjPtr
-virNodeDeviceObjListFindByWWNs(virNodeDeviceObjListPtr devs,
+static virNodeDeviceObj *
+virNodeDeviceObjListFindByWWNs(virNodeDeviceObjList *devs,
const char *parent_wwnn,
const char *parent_wwpn)
{
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
const char *matchstr = opaque;
- virNodeDevCapsDefPtr cap;
+ virNodeDevCapsDef *cap;
int want = 0;
virObjectLock(obj);
}
-static virNodeDeviceObjPtr
-virNodeDeviceObjListFindByFabricWWN(virNodeDeviceObjListPtr devs,
+static virNodeDeviceObj *
+virNodeDeviceObjListFindByFabricWWN(virNodeDeviceObjList *devs,
const char *parent_fabric_wwn)
{
return virNodeDeviceObjListSearch(devs,
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
const char *matchstr = opaque;
int want = 0;
}
-static virNodeDeviceObjPtr
-virNodeDeviceObjListFindByCap(virNodeDeviceObjListPtr devs,
+static virNodeDeviceObj *
+virNodeDeviceObjListFindByCap(virNodeDeviceObjList *devs,
const char *cap)
{
return virNodeDeviceObjListSearch(devs,
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
struct virNodeDeviceObjListFindSCSIHostByWWNsData *data =
(struct virNodeDeviceObjListFindSCSIHostByWWNsData *) opaque;
- virNodeDevCapsDefPtr cap;
+ virNodeDevCapsDef *cap;
int want = 0;
virObjectLock(obj);
}
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindSCSIHostByWWNs(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindSCSIHostByWWNs(virNodeDeviceObjList *devs,
const char *wwnn,
const char *wwpn)
{
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virNodeDeviceObjPtr obj = (virNodeDeviceObjPtr) payload;
+ virNodeDeviceObj *obj = (virNodeDeviceObj *) payload;
const char *uuid = (const char *) opaque;
- virNodeDevCapsDefPtr cap;
+ virNodeDevCapsDef *cap;
int want = 0;
virObjectLock(obj);
}
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindMediatedDeviceByUUID(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindMediatedDeviceByUUID(virNodeDeviceObjList *devs,
const char *uuid)
{
return virNodeDeviceObjListSearch(devs,
static void
virNodeDeviceObjListDispose(void *obj)
{
- virNodeDeviceObjListPtr devs = obj;
+ virNodeDeviceObjList *devs = obj;
virHashFree(devs->objs);
}
-virNodeDeviceObjListPtr
+virNodeDeviceObjList *
virNodeDeviceObjListNew(void)
{
- virNodeDeviceObjListPtr devs;
+ virNodeDeviceObjList *devs;
if (virNodeDeviceObjInitialize() < 0)
return NULL;
void
-virNodeDeviceObjListFree(virNodeDeviceObjListPtr devs)
+virNodeDeviceObjListFree(virNodeDeviceObjList *devs)
{
virObjectUnref(devs);
}
-virNodeDeviceObjPtr
-virNodeDeviceObjListAssignDef(virNodeDeviceObjListPtr devs,
- virNodeDeviceDefPtr def)
+virNodeDeviceObj *
+virNodeDeviceObjListAssignDef(virNodeDeviceObjList *devs,
+ virNodeDeviceDef *def)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
virObjectRWLockWrite(devs);
void
-virNodeDeviceObjListRemove(virNodeDeviceObjListPtr devs,
- virNodeDeviceObjPtr obj)
+virNodeDeviceObjListRemove(virNodeDeviceObjList *devs,
+ virNodeDeviceObj *obj)
{
if (!obj)
return;
* parent_host value on success (>= 0), -1 otherwise.
*/
static int
-virNodeDeviceFindFCParentHost(virNodeDeviceObjPtr obj)
+virNodeDeviceFindFCParentHost(virNodeDeviceObj *obj)
{
- virNodeDevCapsDefPtr cap = virNodeDeviceFindVPORTCapDef(obj);
+ virNodeDevCapsDef *cap = virNodeDeviceFindVPORTCapDef(obj);
if (!cap) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static int
-virNodeDeviceObjListGetParentHostByParent(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListGetParentHostByParent(virNodeDeviceObjList *devs,
const char *dev_name,
const char *parent_name)
{
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
int ret;
if (!(obj = virNodeDeviceObjListFindByName(devs, parent_name))) {
static int
-virNodeDeviceObjListGetParentHostByWWNs(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListGetParentHostByWWNs(virNodeDeviceObjList *devs,
const char *dev_name,
const char *parent_wwnn,
const char *parent_wwpn)
{
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
int ret;
if (!(obj = virNodeDeviceObjListFindByWWNs(devs, parent_wwnn,
static int
-virNodeDeviceObjListGetParentHostByFabricWWN(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListGetParentHostByFabricWWN(virNodeDeviceObjList *devs,
const char *dev_name,
const char *parent_fabric_wwn)
{
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
int ret;
if (!(obj = virNodeDeviceObjListFindByFabricWWN(devs, parent_fabric_wwn))) {
static int
-virNodeDeviceObjListFindVportParentHost(virNodeDeviceObjListPtr devs)
+virNodeDeviceObjListFindVportParentHost(virNodeDeviceObjList *devs)
{
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
const char *cap = virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS);
int ret;
int
-virNodeDeviceObjListGetParentHost(virNodeDeviceObjListPtr devs,
- virNodeDeviceDefPtr def)
+virNodeDeviceObjListGetParentHost(virNodeDeviceObjList *devs,
+ virNodeDeviceDef *def)
{
int parent_host = -1;
virNodeDeviceObjHasCap(const virNodeDeviceObj *obj,
int type)
{
- virNodeDevCapsDefPtr cap = NULL;
+ virNodeDevCapsDef *cap = NULL;
for (cap = obj->def->caps; cap; cap = cap->next) {
if (type == cap->data.type)
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNodeDeviceObjPtr obj = payload;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj = payload;
+ virNodeDeviceDef *def;
struct virNodeDeviceCountData *data = opaque;
virNodeDeviceObjListFilter filter = data->filter;
int
-virNodeDeviceObjListNumOfDevices(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListNumOfDevices(virNodeDeviceObjList *devs,
virConnectPtr conn,
const char *cap,
virNodeDeviceObjListFilter filter)
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNodeDeviceObjPtr obj = payload;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj = payload;
+ virNodeDeviceDef *def;
struct virNodeDeviceGetNamesData *data = opaque;
virNodeDeviceObjListFilter filter = data->filter;
int
-virNodeDeviceObjListGetNames(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListGetNames(virNodeDeviceObjList *devs,
virConnectPtr conn,
virNodeDeviceObjListFilter filter,
const char *cap,
#define MATCH(FLAG) (flags & (FLAG))
static bool
-virNodeDeviceObjMatch(virNodeDeviceObjPtr obj,
+virNodeDeviceObjMatch(virNodeDeviceObj *obj,
unsigned int flags)
{
/* Refresh the capabilities first, e.g. due to a driver change */
typedef struct _virNodeDeviceObjListExportData virNodeDeviceObjListExportData;
-typedef virNodeDeviceObjListExportData *virNodeDeviceObjListExportDataPtr;
struct _virNodeDeviceObjListExportData {
virConnectPtr conn;
virNodeDeviceObjListFilter filter;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNodeDeviceObjPtr obj = payload;
- virNodeDeviceDefPtr def;
- virNodeDeviceObjListExportDataPtr data = opaque;
+ virNodeDeviceObj *obj = payload;
+ virNodeDeviceDef *def;
+ virNodeDeviceObjListExportData *data = opaque;
virNodeDevicePtr device = NULL;
if (data->error)
int
virNodeDeviceObjListExport(virConnectPtr conn,
- virNodeDeviceObjListPtr devs,
+ virNodeDeviceObjList *devs,
virNodeDevicePtr **devices,
virNodeDeviceObjListFilter filter,
unsigned int flags)
void
-virNodeDeviceObjSetSkipUpdateCaps(virNodeDeviceObjPtr obj,
+virNodeDeviceObjSetSkipUpdateCaps(virNodeDeviceObj *obj,
bool skipUpdateCaps)
{
obj->skipUpdateCaps = skipUpdateCaps;
typedef struct _virNodeDeviceObj virNodeDeviceObj;
-typedef virNodeDeviceObj *virNodeDeviceObjPtr;
typedef struct _virNodeDeviceObjList virNodeDeviceObjList;
-typedef virNodeDeviceObjList *virNodeDeviceObjListPtr;
typedef struct _virNodeDeviceDriverState virNodeDeviceDriverState;
-typedef virNodeDeviceDriverState *virNodeDeviceDriverStatePtr;
struct _virNodeDeviceDriverState {
virMutex lock;
virCond initCond;
char *stateDir;
- virNodeDeviceObjListPtr devs; /* currently-known devices */
+ virNodeDeviceObjList *devs; /* currently-known devices */
void *privateData; /* driver-specific private data */
bool privileged; /* whether we run in privileged mode */
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr nodeDeviceEventState;
+ virObjectEventState *nodeDeviceEventState;
};
void
-virNodeDeviceObjEndAPI(virNodeDeviceObjPtr *obj);
+virNodeDeviceObjEndAPI(virNodeDeviceObj **obj);
-virNodeDeviceDefPtr
-virNodeDeviceObjGetDef(virNodeDeviceObjPtr obj);
+virNodeDeviceDef *
+virNodeDeviceObjGetDef(virNodeDeviceObj *obj);
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindByName(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindByName(virNodeDeviceObjList *devs,
const char *name);
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindBySysfsPath(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindBySysfsPath(virNodeDeviceObjList *devs,
const char *sysfs_path)
ATTRIBUTE_NONNULL(2);
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindSCSIHostByWWNs(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindSCSIHostByWWNs(virNodeDeviceObjList *devs,
const char *wwnn,
const char *wwpn);
-virNodeDeviceObjPtr
-virNodeDeviceObjListAssignDef(virNodeDeviceObjListPtr devs,
- virNodeDeviceDefPtr def);
+virNodeDeviceObj *
+virNodeDeviceObjListAssignDef(virNodeDeviceObjList *devs,
+ virNodeDeviceDef *def);
void
-virNodeDeviceObjListRemove(virNodeDeviceObjListPtr devs,
- virNodeDeviceObjPtr dev);
+virNodeDeviceObjListRemove(virNodeDeviceObjList *devs,
+ virNodeDeviceObj *dev);
void
virNodeDeviceObjListRemoveLocked(virNodeDeviceObjList *devs,
virNodeDeviceObj *dev);
int
-virNodeDeviceObjListGetParentHost(virNodeDeviceObjListPtr devs,
- virNodeDeviceDefPtr def);
+virNodeDeviceObjListGetParentHost(virNodeDeviceObjList *devs,
+ virNodeDeviceDef *def);
-virNodeDeviceObjListPtr
+virNodeDeviceObjList *
virNodeDeviceObjListNew(void);
void
-virNodeDeviceObjListFree(virNodeDeviceObjListPtr devs);
+virNodeDeviceObjListFree(virNodeDeviceObjList *devs);
typedef bool
(*virNodeDeviceObjListFilter)(virConnectPtr conn,
- virNodeDeviceDefPtr def);
+ virNodeDeviceDef *def);
int
-virNodeDeviceObjListNumOfDevices(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListNumOfDevices(virNodeDeviceObjList *devs,
virConnectPtr conn,
const char *cap,
virNodeDeviceObjListFilter filter);
int
-virNodeDeviceObjListGetNames(virNodeDeviceObjListPtr devs,
+virNodeDeviceObjListGetNames(virNodeDeviceObjList *devs,
virConnectPtr conn,
virNodeDeviceObjListFilter filter,
const char *cap,
int
virNodeDeviceObjListExport(virConnectPtr conn,
- virNodeDeviceObjListPtr devobjs,
+ virNodeDeviceObjList *devobjs,
virNodeDevicePtr **devices,
virNodeDeviceObjListFilter filter,
unsigned int flags);
void
-virNodeDeviceObjSetSkipUpdateCaps(virNodeDeviceObjPtr obj,
+virNodeDeviceObjSetSkipUpdateCaps(virNodeDeviceObj *obj,
bool skipUpdateCaps);
-virNodeDeviceObjPtr
-virNodeDeviceObjListFindMediatedDeviceByUUID(virNodeDeviceObjListPtr devs,
+virNodeDeviceObj *
+virNodeDeviceObjListFindMediatedDeviceByUUID(virNodeDeviceObjList *devs,
const char *uuid);
bool
#define VIR_FROM_THIS VIR_FROM_NWFILTER
void
-virNWFilterBindingDefFree(virNWFilterBindingDefPtr def)
+virNWFilterBindingDefFree(virNWFilterBindingDef *def)
{
if (!def)
return;
}
-virNWFilterBindingDefPtr
-virNWFilterBindingDefCopy(virNWFilterBindingDefPtr src)
+virNWFilterBindingDef *
+virNWFilterBindingDefCopy(virNWFilterBindingDef *src)
{
- virNWFilterBindingDefPtr ret;
+ virNWFilterBindingDef *ret;
ret = g_new0(virNWFilterBindingDef, 1);
}
-static virNWFilterBindingDefPtr
+static virNWFilterBindingDef *
virNWFilterBindingDefParseXML(xmlXPathContextPtr ctxt)
{
- virNWFilterBindingDefPtr ret;
+ virNWFilterBindingDef *ret;
char *uuid = NULL;
char *mac = NULL;
xmlNodePtr node;
}
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseNode(xmlDocPtr xml,
xmlNodePtr root)
{
xmlXPathContextPtr ctxt = NULL;
- virNWFilterBindingDefPtr def = NULL;
+ virNWFilterBindingDef *def = NULL;
if (STRNEQ((const char *)root->name, "filterbinding")) {
virReportError(VIR_ERR_XML_ERROR,
}
-static virNWFilterBindingDefPtr
+static virNWFilterBindingDef *
virNWFilterBindingDefParse(const char *xmlStr,
const char *filename)
{
- virNWFilterBindingDefPtr def = NULL;
+ virNWFilterBindingDef *def = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilterbinding_definition)")))) {
}
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseString(const char *xmlStr)
{
return virNWFilterBindingDefParse(xmlStr, NULL);
}
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseFile(const char *filename)
{
return virNWFilterBindingDefParse(NULL, filename);
int
-virNWFilterBindingDefFormatBuf(virBufferPtr buf,
+virNWFilterBindingDefFormatBuf(virBuffer *buf,
const virNWFilterBindingDef *def)
{
char uuid[VIR_UUID_STRING_BUFLEN];
#include "virxml.h"
typedef struct _virNWFilterBindingDef virNWFilterBindingDef;
-typedef virNWFilterBindingDef *virNWFilterBindingDefPtr;
-
struct _virNWFilterBindingDef {
char *ownername;
unsigned char owneruuid[VIR_UUID_BUFLEN];
void
-virNWFilterBindingDefFree(virNWFilterBindingDefPtr binding);
-virNWFilterBindingDefPtr
-virNWFilterBindingDefCopy(virNWFilterBindingDefPtr src);
+virNWFilterBindingDefFree(virNWFilterBindingDef *binding);
+virNWFilterBindingDef *
+virNWFilterBindingDefCopy(virNWFilterBindingDef *src);
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseNode(xmlDocPtr xml,
xmlNodePtr root);
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseString(const char *xml);
-virNWFilterBindingDefPtr
+virNWFilterBindingDef *
virNWFilterBindingDefParseFile(const char *filename);
char *
virNWFilterBindingDefFormat(const virNWFilterBindingDef *def);
int
-virNWFilterBindingDefFormatBuf(virBufferPtr buf,
+virNWFilterBindingDefFormatBuf(virBuffer *buf,
const virNWFilterBindingDef *def);
virObjectLockable parent;
bool removing;
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingDef *def;
};
-static virClassPtr virNWFilterBindingObjClass;
+static virClass *virNWFilterBindingObjClass;
static void virNWFilterBindingObjDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(virNWFilterBindingObj);
-virNWFilterBindingObjPtr
+virNWFilterBindingObj *
virNWFilterBindingObjNew(void)
{
if (virNWFilterBindingObjInitialize() < 0)
static void
virNWFilterBindingObjDispose(void *obj)
{
- virNWFilterBindingObjPtr bobj = obj;
+ virNWFilterBindingObj *bobj = obj;
virNWFilterBindingDefFree(bobj->def);
}
-virNWFilterBindingDefPtr
-virNWFilterBindingObjGetDef(virNWFilterBindingObjPtr obj)
+virNWFilterBindingDef *
+virNWFilterBindingObjGetDef(virNWFilterBindingObj *obj)
{
return obj->def;
}
void
-virNWFilterBindingObjSetDef(virNWFilterBindingObjPtr obj,
- virNWFilterBindingDefPtr def)
+virNWFilterBindingObjSetDef(virNWFilterBindingObj *obj,
+ virNWFilterBindingDef *def)
{
virNWFilterBindingDefFree(obj->def);
obj->def = def;
}
-virNWFilterBindingDefPtr
-virNWFilterBindingObjStealDef(virNWFilterBindingObjPtr obj)
+virNWFilterBindingDef *
+virNWFilterBindingObjStealDef(virNWFilterBindingObj *obj)
{
return g_steal_pointer(&obj->def);
}
bool
-virNWFilterBindingObjGetRemoving(virNWFilterBindingObjPtr obj)
+virNWFilterBindingObjGetRemoving(virNWFilterBindingObj *obj)
{
return obj->removing;
}
void
-virNWFilterBindingObjSetRemoving(virNWFilterBindingObjPtr obj,
+virNWFilterBindingObjSetRemoving(virNWFilterBindingObj *obj,
bool removing)
{
obj->removing = removing;
* the object, the pointer is cleared.
*/
void
-virNWFilterBindingObjEndAPI(virNWFilterBindingObjPtr *obj)
+virNWFilterBindingObjEndAPI(virNWFilterBindingObj **obj)
{
if (!*obj)
return;
}
-static virNWFilterBindingObjPtr
+static virNWFilterBindingObj *
virNWFilterBindingObjParseXML(xmlDocPtr doc,
xmlXPathContextPtr ctxt)
{
- virNWFilterBindingObjPtr ret;
+ virNWFilterBindingObj *ret;
xmlNodePtr node;
if (!(ret = virNWFilterBindingObjNew()))
}
-static virNWFilterBindingObjPtr
+static virNWFilterBindingObj *
virNWFilterBindingObjParseNode(xmlDocPtr doc,
xmlNodePtr root)
{
xmlXPathContextPtr ctxt = NULL;
- virNWFilterBindingObjPtr obj = NULL;
+ virNWFilterBindingObj *obj = NULL;
if (STRNEQ((const char *)root->name, "filterbindingstatus")) {
virReportError(VIR_ERR_XML_ERROR,
}
-static virNWFilterBindingObjPtr
+static virNWFilterBindingObj *
virNWFilterBindingObjParse(const char *xmlStr,
const char *filename)
{
- virNWFilterBindingObjPtr obj = NULL;
+ virNWFilterBindingObj *obj = NULL;
xmlDocPtr xml;
if ((xml = virXMLParse(filename, xmlStr, _("(nwfilterbinding_status)")))) {
}
-virNWFilterBindingObjPtr
+virNWFilterBindingObj *
virNWFilterBindingObjParseFile(const char *filename)
{
return virNWFilterBindingObjParse(NULL, filename);
#include "virobject.h"
typedef struct _virNWFilterBindingObj virNWFilterBindingObj;
-typedef virNWFilterBindingObj *virNWFilterBindingObjPtr;
-virNWFilterBindingObjPtr
+virNWFilterBindingObj *
virNWFilterBindingObjNew(void);
-virNWFilterBindingDefPtr
-virNWFilterBindingObjGetDef(virNWFilterBindingObjPtr obj);
+virNWFilterBindingDef *
+virNWFilterBindingObjGetDef(virNWFilterBindingObj *obj);
void
-virNWFilterBindingObjSetDef(virNWFilterBindingObjPtr obj,
- virNWFilterBindingDefPtr def);
+virNWFilterBindingObjSetDef(virNWFilterBindingObj *obj,
+ virNWFilterBindingDef *def);
-virNWFilterBindingDefPtr
-virNWFilterBindingObjStealDef(virNWFilterBindingObjPtr obj);
+virNWFilterBindingDef *
+virNWFilterBindingObjStealDef(virNWFilterBindingObj *obj);
bool
-virNWFilterBindingObjGetRemoving(virNWFilterBindingObjPtr obj);
+virNWFilterBindingObjGetRemoving(virNWFilterBindingObj *obj);
void
-virNWFilterBindingObjSetRemoving(virNWFilterBindingObjPtr obj,
+virNWFilterBindingObjSetRemoving(virNWFilterBindingObj *obj,
bool removing);
void
-virNWFilterBindingObjEndAPI(virNWFilterBindingObjPtr *obj);
+virNWFilterBindingObjEndAPI(virNWFilterBindingObj **obj);
char *
virNWFilterBindingObjConfigFile(const char *dir,
virNWFilterBindingObjDelete(const virNWFilterBindingObj *obj,
const char *statusDir);
-virNWFilterBindingObjPtr
+virNWFilterBindingObj *
virNWFilterBindingObjParseFile(const char *filename);
char *
VIR_LOG_INIT("conf.virnwfilterbindingobjlist");
-static virClassPtr virNWFilterBindingObjListClass;
+static virClass *virNWFilterBindingObjListClass;
static void virNWFilterBindingObjListDispose(void *obj);
struct _virNWFilterBindingObjList {
VIR_ONCE_GLOBAL_INIT(virNWFilterBindingObjList);
-virNWFilterBindingObjListPtr
+virNWFilterBindingObjList *
virNWFilterBindingObjListNew(void)
{
- virNWFilterBindingObjListPtr bindings;
+ virNWFilterBindingObjList *bindings;
if (virNWFilterBindingObjListInitialize() < 0)
return NULL;
static void
virNWFilterBindingObjListDispose(void *obj)
{
- virNWFilterBindingObjListPtr bindings = obj;
+ virNWFilterBindingObjList *bindings = obj;
virHashFree(bindings->objs);
}
-static virNWFilterBindingObjPtr
-virNWFilterBindingObjListFindByPortDevLocked(virNWFilterBindingObjListPtr bindings,
+static virNWFilterBindingObj *
+virNWFilterBindingObjListFindByPortDevLocked(virNWFilterBindingObjList *bindings,
const char *name)
{
- virNWFilterBindingObjPtr obj;
+ virNWFilterBindingObj *obj;
obj = virHashLookup(bindings->objs, name);
if (obj) {
* locked and ref counted binding object if found. Caller is expected
* to use the virNWFilterBindingObjEndAPI when done with the object.
*/
-virNWFilterBindingObjPtr
-virNWFilterBindingObjListFindByPortDev(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObj *
+virNWFilterBindingObjListFindByPortDev(virNWFilterBindingObjList *bindings,
const char *name)
{
- virNWFilterBindingObjPtr obj;
+ virNWFilterBindingObj *obj;
virObjectRWLockRead(bindings);
obj = virNWFilterBindingObjListFindByPortDevLocked(bindings, name);
* -1 on failure with 1 reference and locked
*/
static int
-virNWFilterBindingObjListAddObjLocked(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingObjPtr binding)
+virNWFilterBindingObjListAddObjLocked(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingObj *binding)
{
- virNWFilterBindingDefPtr def = virNWFilterBindingObjGetDef(binding);
+ virNWFilterBindingDef *def = virNWFilterBindingObjGetDef(binding);
if (virHashAddEntry(bindings->objs, def->portdevname, binding) < 0)
return -1;
virObjectRef(binding);
* counted. The caller is expected to use virNWFilterBindingObjEndAPI
* when it completes usage.
*/
-static virNWFilterBindingObjPtr
-virNWFilterBindingObjListAddLocked(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingDefPtr def)
+static virNWFilterBindingObj *
+virNWFilterBindingObjListAddLocked(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingDef *def)
{
- virNWFilterBindingObjPtr binding;
+ virNWFilterBindingObj *binding;
bool stealDef = false;
/* See if a binding with matching portdev already exists */
}
-virNWFilterBindingObjPtr
-virNWFilterBindingObjListAdd(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingDefPtr def)
+virNWFilterBindingObj *
+virNWFilterBindingObjListAdd(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingDef *def)
{
- virNWFilterBindingObjPtr ret;
+ virNWFilterBindingObj *ret;
virObjectRWLockWrite(bindings);
ret = virNWFilterBindingObjListAddLocked(bindings, def);
* virNWFilterBindingObjListForEach
*/
static void
-virNWFilterBindingObjListRemoveLocked(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingObjPtr binding)
+virNWFilterBindingObjListRemoveLocked(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingObj *binding)
{
- virNWFilterBindingDefPtr def = virNWFilterBindingObjGetDef(binding);
+ virNWFilterBindingDef *def = virNWFilterBindingObjGetDef(binding);
virHashRemoveEntry(bindings->objs, def->portdevname);
}
* tables and returned with lock and refcnt that was present upon entry.
*/
void
-virNWFilterBindingObjListRemove(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingObjPtr binding)
+virNWFilterBindingObjListRemove(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingObj *binding)
{
virNWFilterBindingObjSetRemoving(binding, true);
virObjectRef(binding);
}
-static virNWFilterBindingObjPtr
-virNWFilterBindingObjListLoadStatus(virNWFilterBindingObjListPtr bindings,
+static virNWFilterBindingObj *
+virNWFilterBindingObjListLoadStatus(virNWFilterBindingObjList *bindings,
const char *statusDir,
const char *name)
{
char *statusFile = NULL;
- virNWFilterBindingObjPtr obj = NULL;
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingObj *obj = NULL;
+ virNWFilterBindingDef *def;
if ((statusFile = virNWFilterBindingObjConfigFile(statusDir, name)) == NULL)
goto error;
int
-virNWFilterBindingObjListLoadAllConfigs(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListLoadAllConfigs(virNWFilterBindingObjList *bindings,
const char *configDir)
{
g_autoptr(DIR) dir = NULL;
virObjectRWLockWrite(bindings);
while ((ret = virDirRead(dir, &entry, configDir)) > 0) {
- virNWFilterBindingObjPtr binding;
+ virNWFilterBindingObj *binding;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
int
-virNWFilterBindingObjListForEach(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListForEach(virNWFilterBindingObjList *bindings,
virNWFilterBindingObjListIterator callback,
void *opaque)
{
struct virNWFilterBindingListData {
- virNWFilterBindingObjPtr *bindings;
+ virNWFilterBindingObj **bindings;
size_t nbindings;
};
static void
-virNWFilterBindingObjListFilter(virNWFilterBindingObjPtr **list,
+virNWFilterBindingObjListFilter(virNWFilterBindingObj ***list,
size_t *nbindings,
virConnectPtr conn,
virNWFilterBindingObjListACLFilter filter)
size_t i = 0;
while (i < *nbindings) {
- virNWFilterBindingObjPtr binding = (*list)[i];
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingObj *binding = (*list)[i];
+ virNWFilterBindingDef *def;
virObjectLock(binding);
static int
-virNWFilterBindingObjListCollect(virNWFilterBindingObjListPtr domlist,
+virNWFilterBindingObjListCollect(virNWFilterBindingObjList *domlist,
virConnectPtr conn,
- virNWFilterBindingObjPtr **bindings,
+ virNWFilterBindingObj ***bindings,
size_t *nbindings,
virNWFilterBindingObjListACLFilter filter)
{
virObjectRWLockRead(domlist);
sa_assert(domlist->objs);
- data.bindings = g_new0(virNWFilterBindingObjPtr, virHashSize(domlist->objs));
+ data.bindings = g_new0(virNWFilterBindingObj *, virHashSize(domlist->objs));
virHashForEach(domlist->objs, virNWFilterBindingObjListCollectIterator, &data);
virObjectRWUnlock(domlist);
int
-virNWFilterBindingObjListExport(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListExport(virNWFilterBindingObjList *bindings,
virConnectPtr conn,
virNWFilterBindingPtr **bindinglist,
virNWFilterBindingObjListACLFilter filter)
{
- virNWFilterBindingObjPtr *bindingobjs = NULL;
+ virNWFilterBindingObj **bindingobjs = NULL;
size_t nbindings = 0;
size_t i;
int ret = -1;
*bindinglist = g_new0(virNWFilterBindingPtr, nbindings + 1);
for (i = 0; i < nbindings; i++) {
- virNWFilterBindingObjPtr binding = bindingobjs[i];
- virNWFilterBindingDefPtr def = virNWFilterBindingObjGetDef(binding);
+ virNWFilterBindingObj *binding = bindingobjs[i];
+ virNWFilterBindingDef *def = virNWFilterBindingObjGetDef(binding);
virObjectLock(binding);
(*bindinglist)[i] = virGetNWFilterBinding(conn, def->portdevname,
#include "virnwfilterbindingobj.h"
typedef struct _virNWFilterBindingObjList virNWFilterBindingObjList;
-typedef virNWFilterBindingObjList *virNWFilterBindingObjListPtr;
-virNWFilterBindingObjListPtr
+virNWFilterBindingObjList *
virNWFilterBindingObjListNew(void);
-virNWFilterBindingObjPtr
-virNWFilterBindingObjListFindByPortDev(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObj *
+virNWFilterBindingObjListFindByPortDev(virNWFilterBindingObjList *bindings,
const char *name);
-virNWFilterBindingObjPtr
-virNWFilterBindingObjListAdd(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingDefPtr def);
+virNWFilterBindingObj *
+virNWFilterBindingObjListAdd(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingDef *def);
void
-virNWFilterBindingObjListRemove(virNWFilterBindingObjListPtr bindings,
- virNWFilterBindingObjPtr binding);
+virNWFilterBindingObjListRemove(virNWFilterBindingObjList *bindings,
+ virNWFilterBindingObj *binding);
int
-virNWFilterBindingObjListLoadAllConfigs(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListLoadAllConfigs(virNWFilterBindingObjList *bindings,
const char *configDir);
-typedef int (*virNWFilterBindingObjListIterator)(virNWFilterBindingObjPtr binding,
+typedef int (*virNWFilterBindingObjListIterator)(virNWFilterBindingObj *binding,
void *opaque);
int
-virNWFilterBindingObjListForEach(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListForEach(virNWFilterBindingObjList *bindings,
virNWFilterBindingObjListIterator callback,
void *opaque);
typedef bool (*virNWFilterBindingObjListACLFilter)(virConnectPtr conn,
- virNWFilterBindingDefPtr def);
+ virNWFilterBindingDef *def);
int
-virNWFilterBindingObjListExport(virNWFilterBindingObjListPtr bindings,
+virNWFilterBindingObjListExport(virNWFilterBindingObjList *bindings,
virConnectPtr conn,
virNWFilterBindingPtr **bindinglist,
virNWFilterBindingObjListACLFilter filter);
bool wantRemoved;
- virNWFilterDefPtr def;
- virNWFilterDefPtr newDef;
+ virNWFilterDef *def;
+ virNWFilterDef *newDef;
};
struct _virNWFilterObjList {
size_t count;
- virNWFilterObjPtr *objs;
+ virNWFilterObj **objs;
};
-static virNWFilterObjPtr
+static virNWFilterObj *
virNWFilterObjNew(void)
{
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
obj = g_new0(virNWFilterObj, 1);
}
-virNWFilterDefPtr
-virNWFilterObjGetDef(virNWFilterObjPtr obj)
+virNWFilterDef *
+virNWFilterObjGetDef(virNWFilterObj *obj)
{
return obj->def;
}
-virNWFilterDefPtr
-virNWFilterObjGetNewDef(virNWFilterObjPtr obj)
+virNWFilterDef *
+virNWFilterObjGetNewDef(virNWFilterObj *obj)
{
return obj->newDef;
}
bool
-virNWFilterObjWantRemoved(virNWFilterObjPtr obj)
+virNWFilterObjWantRemoved(virNWFilterObj *obj)
{
return obj->wantRemoved;
}
static void
-virNWFilterObjFree(virNWFilterObjPtr obj)
+virNWFilterObjFree(virNWFilterObj *obj)
{
if (!obj)
return;
void
-virNWFilterObjListFree(virNWFilterObjListPtr nwfilters)
+virNWFilterObjListFree(virNWFilterObjList *nwfilters)
{
size_t i;
for (i = 0; i < nwfilters->count; i++)
}
-virNWFilterObjListPtr
+virNWFilterObjList *
virNWFilterObjListNew(void)
{
- virNWFilterObjListPtr nwfilters;
+ virNWFilterObjList *nwfilters;
nwfilters = g_new0(virNWFilterObjList, 1);
return nwfilters;
void
-virNWFilterObjListRemove(virNWFilterObjListPtr nwfilters,
- virNWFilterObjPtr obj)
+virNWFilterObjListRemove(virNWFilterObjList *nwfilters,
+ virNWFilterObj *obj)
{
size_t i;
}
-virNWFilterObjPtr
-virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindByUUID(virNWFilterObjList *nwfilters,
const unsigned char *uuid)
{
size_t i;
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
for (i = 0; i < nwfilters->count; i++) {
obj = nwfilters->objs[i];
}
-virNWFilterObjPtr
-virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindByName(virNWFilterObjList *nwfilters,
const char *name)
{
size_t i;
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
for (i = 0; i < nwfilters->count; i++) {
obj = nwfilters->objs[i];
}
-virNWFilterObjPtr
-virNWFilterObjListFindInstantiateFilter(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindInstantiateFilter(virNWFilterObjList *nwfilters,
const char *filtername)
{
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
if (!(obj = virNWFilterObjListFindByName(nwfilters, filtername))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static int
-_virNWFilterObjListDefLoopDetect(virNWFilterObjListPtr nwfilters,
- virNWFilterDefPtr def,
+_virNWFilterObjListDefLoopDetect(virNWFilterObjList *nwfilters,
+ virNWFilterDef *def,
const char *filtername)
{
int rc = 0;
size_t i;
- virNWFilterEntryPtr entry;
- virNWFilterObjPtr obj;
+ virNWFilterEntry *entry;
+ virNWFilterObj *obj;
if (!def)
return 0;
* Returns 0 in case no loop was detected, -1 otherwise.
*/
static int
-virNWFilterObjListDefLoopDetect(virNWFilterObjListPtr nwfilters,
- virNWFilterDefPtr def)
+virNWFilterObjListDefLoopDetect(virNWFilterObjList *nwfilters,
+ virNWFilterDef *def)
{
return _virNWFilterObjListDefLoopDetect(nwfilters, def, def->name);
}
int
-virNWFilterObjTestUnassignDef(virNWFilterObjPtr obj)
+virNWFilterObjTestUnassignDef(virNWFilterObj *obj)
{
int rc = 0;
static bool
virNWFilterDefEqual(const virNWFilterDef *def1,
- virNWFilterDefPtr def2)
+ virNWFilterDef *def2)
{
bool ret = false;
char *xml1 = NULL;
}
-virNWFilterObjPtr
-virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
- virNWFilterDefPtr def)
+virNWFilterObj *
+virNWFilterObjListAssignDef(virNWFilterObjList *nwfilters,
+ virNWFilterDef *def)
{
- virNWFilterObjPtr obj;
- virNWFilterDefPtr objdef;
+ virNWFilterObj *obj;
+ virNWFilterDef *objdef;
if ((obj = virNWFilterObjListFindByUUID(nwfilters, def->uuid))) {
objdef = obj->def;
int
-virNWFilterObjListNumOfNWFilters(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListNumOfNWFilters(virNWFilterObjList *nwfilters,
virConnectPtr conn,
virNWFilterObjListFilter filter)
{
int nfilters = 0;
for (i = 0; i < nwfilters->count; i++) {
- virNWFilterObjPtr obj = nwfilters->objs[i];
+ virNWFilterObj *obj = nwfilters->objs[i];
virNWFilterObjLock(obj);
if (!filter || filter(conn, obj->def))
nfilters++;
int
-virNWFilterObjListGetNames(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListGetNames(virNWFilterObjList *nwfilters,
virConnectPtr conn,
virNWFilterObjListFilter filter,
char **const names,
{
int nnames = 0;
size_t i;
- virNWFilterDefPtr def;
+ virNWFilterDef *def;
for (i = 0; i < nwfilters->count && nnames < maxnames; i++) {
- virNWFilterObjPtr obj = nwfilters->objs[i];
+ virNWFilterObj *obj = nwfilters->objs[i];
virNWFilterObjLock(obj);
def = obj->def;
if (!filter || filter(conn, def)) {
int
virNWFilterObjListExport(virConnectPtr conn,
- virNWFilterObjListPtr nwfilters,
+ virNWFilterObjList *nwfilters,
virNWFilterPtr **filters,
virNWFilterObjListFilter filter)
{
virNWFilterPtr *tmp_filters = NULL;
int nfilters = 0;
virNWFilterPtr nwfilter = NULL;
- virNWFilterObjPtr obj = NULL;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj = NULL;
+ virNWFilterDef *def;
size_t i;
int ret = -1;
}
-static virNWFilterObjPtr
-virNWFilterObjListLoadConfig(virNWFilterObjListPtr nwfilters,
+static virNWFilterObj *
+virNWFilterObjListLoadConfig(virNWFilterObjList *nwfilters,
const char *configDir,
const char *name)
{
- virNWFilterDefPtr def = NULL;
- virNWFilterObjPtr obj;
+ virNWFilterDef *def = NULL;
+ virNWFilterObj *obj;
char *configFile = NULL;
if (!(configFile = virFileBuildPath(configDir, name, ".xml")))
int
-virNWFilterObjListLoadAllConfigs(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListLoadAllConfigs(virNWFilterObjList *nwfilters,
const char *configDir)
{
g_autoptr(DIR) dir = NULL;
return rc;
while ((ret = virDirRead(dir, &entry, configDir)) > 0) {
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
void
-virNWFilterObjLock(virNWFilterObjPtr obj)
+virNWFilterObjLock(virNWFilterObj *obj)
{
virMutexLock(&obj->lock);
}
void
-virNWFilterObjUnlock(virNWFilterObjPtr obj)
+virNWFilterObjUnlock(virNWFilterObj *obj)
{
virMutexUnlock(&obj->lock);
}
#include "virnwfilterbindingobjlist.h"
typedef struct _virNWFilterObj virNWFilterObj;
-typedef virNWFilterObj *virNWFilterObjPtr;
typedef struct _virNWFilterObjList virNWFilterObjList;
-typedef virNWFilterObjList *virNWFilterObjListPtr;
typedef struct _virNWFilterDriverState virNWFilterDriverState;
-typedef virNWFilterDriverState *virNWFilterDriverStatePtr;
struct _virNWFilterDriverState {
virMutex lock;
bool privileged;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
- virNWFilterObjListPtr nwfilters;
+ virNWFilterObjList *nwfilters;
- virNWFilterBindingObjListPtr bindings;
+ virNWFilterBindingObjList *bindings;
char *stateDir;
char *configDir;
char *bindingDir;
};
-virNWFilterDefPtr
-virNWFilterObjGetDef(virNWFilterObjPtr obj);
+virNWFilterDef *
+virNWFilterObjGetDef(virNWFilterObj *obj);
-virNWFilterDefPtr
-virNWFilterObjGetNewDef(virNWFilterObjPtr obj);
+virNWFilterDef *
+virNWFilterObjGetNewDef(virNWFilterObj *obj);
bool
-virNWFilterObjWantRemoved(virNWFilterObjPtr obj);
+virNWFilterObjWantRemoved(virNWFilterObj *obj);
-virNWFilterObjListPtr
+virNWFilterObjList *
virNWFilterObjListNew(void);
void
-virNWFilterObjListFree(virNWFilterObjListPtr nwfilters);
+virNWFilterObjListFree(virNWFilterObjList *nwfilters);
void
-virNWFilterObjListRemove(virNWFilterObjListPtr nwfilters,
- virNWFilterObjPtr obj);
+virNWFilterObjListRemove(virNWFilterObjList *nwfilters,
+ virNWFilterObj *obj);
-virNWFilterObjPtr
-virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindByUUID(virNWFilterObjList *nwfilters,
const unsigned char *uuid);
-virNWFilterObjPtr
-virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindByName(virNWFilterObjList *nwfilters,
const char *name);
-virNWFilterObjPtr
-virNWFilterObjListFindInstantiateFilter(virNWFilterObjListPtr nwfilters,
+virNWFilterObj *
+virNWFilterObjListFindInstantiateFilter(virNWFilterObjList *nwfilters,
const char *filtername);
-virNWFilterObjPtr
-virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
- virNWFilterDefPtr def);
+virNWFilterObj *
+virNWFilterObjListAssignDef(virNWFilterObjList *nwfilters,
+ virNWFilterDef *def);
int
-virNWFilterObjTestUnassignDef(virNWFilterObjPtr obj);
+virNWFilterObjTestUnassignDef(virNWFilterObj *obj);
typedef bool
(*virNWFilterObjListFilter)(virConnectPtr conn,
- virNWFilterDefPtr def);
+ virNWFilterDef *def);
int
-virNWFilterObjListNumOfNWFilters(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListNumOfNWFilters(virNWFilterObjList *nwfilters,
virConnectPtr conn,
virNWFilterObjListFilter filter);
int
-virNWFilterObjListGetNames(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListGetNames(virNWFilterObjList *nwfilters,
virConnectPtr conn,
virNWFilterObjListFilter filter,
char **const names,
int
virNWFilterObjListExport(virConnectPtr conn,
- virNWFilterObjListPtr nwfilters,
+ virNWFilterObjList *nwfilters,
virNWFilterPtr **filters,
virNWFilterObjListFilter filter);
int
-virNWFilterObjListLoadAllConfigs(virNWFilterObjListPtr nwfilters,
+virNWFilterObjListLoadAllConfigs(virNWFilterObjList *nwfilters,
const char *configDir);
void
-virNWFilterObjLock(virNWFilterObjPtr obj);
+virNWFilterObjLock(virNWFilterObj *obj);
void
-virNWFilterObjUnlock(virNWFilterObjPtr obj);
+virNWFilterObjUnlock(virNWFilterObj *obj);
static int
virSaveCookieParseNode(xmlXPathContextPtr ctxt,
- virObjectPtr *obj,
- virSaveCookieCallbacksPtr saveCookie)
+ virObject **obj,
+ virSaveCookieCallbacks *saveCookie)
{
*obj = NULL;
int
virSaveCookieParse(xmlXPathContextPtr ctxt,
- virObjectPtr *obj,
- virSaveCookieCallbacksPtr saveCookie)
+ virObject **obj,
+ virSaveCookieCallbacks *saveCookie)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int ret = -1;
int
virSaveCookieParseString(const char *xml,
- virObjectPtr *obj,
- virSaveCookieCallbacksPtr saveCookie)
+ virObject **obj,
+ virSaveCookieCallbacks *saveCookie)
{
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
int
-virSaveCookieFormatBuf(virBufferPtr buf,
- virObjectPtr obj,
- virSaveCookieCallbacksPtr saveCookie)
+virSaveCookieFormatBuf(virBuffer *buf,
+ virObject *obj,
+ virSaveCookieCallbacks *saveCookie)
{
if (!obj || !saveCookie || !saveCookie->format)
return 0;
char *
-virSaveCookieFormat(virObjectPtr obj,
- virSaveCookieCallbacksPtr saveCookie)
+virSaveCookieFormat(virObject *obj,
+ virSaveCookieCallbacks *saveCookie)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
typedef int (*virSaveCookieParseFunc)(xmlXPathContextPtr ctxt,
- virObjectPtr *obj);
-typedef int (*virSaveCookieFormatFunc)(virBufferPtr buf,
- virObjectPtr obj);
+ virObject **obj);
+typedef int (*virSaveCookieFormatFunc)(virBuffer *buf,
+ virObject *obj);
typedef struct _virSaveCookieCallbacks virSaveCookieCallbacks;
-typedef virSaveCookieCallbacks *virSaveCookieCallbacksPtr;
struct _virSaveCookieCallbacks {
virSaveCookieParseFunc parse;
virSaveCookieFormatFunc format;
int
virSaveCookieParse(xmlXPathContextPtr ctxt,
- virObjectPtr *obj,
- virSaveCookieCallbacksPtr saveCookie);
+ virObject **obj,
+ virSaveCookieCallbacks *saveCookie);
int
virSaveCookieParseString(const char *xml,
- virObjectPtr *obj,
- virSaveCookieCallbacksPtr saveCookie);
+ virObject **obj,
+ virSaveCookieCallbacks *saveCookie);
int
-virSaveCookieFormatBuf(virBufferPtr buf,
- virObjectPtr obj,
- virSaveCookieCallbacksPtr saveCookie);
+virSaveCookieFormatBuf(virBuffer *buf,
+ virObject *obj,
+ virSaveCookieCallbacks *saveCookie);
char *
-virSaveCookieFormat(virObjectPtr obj,
- virSaveCookieCallbacksPtr saveCookie);
+virSaveCookieFormat(virObject *obj,
+ virSaveCookieCallbacks *saveCookie);
virObjectLockable parent;
char *configFile;
char *base64File;
- virSecretDefPtr def;
+ virSecretDef *def;
unsigned char *value; /* May be NULL */
size_t value_size;
};
-static virClassPtr virSecretObjClass;
-static virClassPtr virSecretObjListClass;
+static virClass *virSecretObjClass;
+static virClass *virSecretObjListClass;
static void virSecretObjDispose(void *obj);
static void virSecretObjListDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virSecretObj);
-static virSecretObjPtr
+static virSecretObj *
virSecretObjNew(void)
{
- virSecretObjPtr obj;
+ virSecretObj *obj;
if (virSecretObjInitialize() < 0)
return NULL;
void
-virSecretObjEndAPI(virSecretObjPtr *obj)
+virSecretObjEndAPI(virSecretObj **obj)
{
if (!*obj)
return;
}
-virSecretObjListPtr
+virSecretObjList *
virSecretObjListNew(void)
{
- virSecretObjListPtr secrets;
+ virSecretObjList *secrets;
if (virSecretObjInitialize() < 0)
return NULL;
static void
virSecretObjDispose(void *opaque)
{
- virSecretObjPtr obj = opaque;
+ virSecretObj *obj = opaque;
virSecretDefFree(obj->def);
if (obj->value) {
static void
virSecretObjListDispose(void *obj)
{
- virSecretObjListPtr secrets = obj;
+ virSecretObjList *secrets = obj;
virHashFree(secrets->objs);
}
*
* Returns: not locked, but ref'd secret object.
*/
-static virSecretObjPtr
-virSecretObjListFindByUUIDLocked(virSecretObjListPtr secrets,
+static virSecretObj *
+virSecretObjListFindByUUIDLocked(virSecretObjList *secrets,
const char *uuidstr)
{
return virObjectRef(virHashLookup(secrets->objs, uuidstr));
*
* Returns: locked and ref'd secret object.
*/
-virSecretObjPtr
-virSecretObjListFindByUUID(virSecretObjListPtr secrets,
+virSecretObj *
+virSecretObjListFindByUUID(virSecretObjList *secrets,
const char *uuidstr)
{
- virSecretObjPtr obj;
+ virSecretObj *obj;
virObjectRWLockRead(secrets);
obj = virSecretObjListFindByUUIDLocked(secrets, uuidstr);
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virSecretObjPtr obj = (virSecretObjPtr) payload;
- virSecretDefPtr def;
+ virSecretObj *obj = (virSecretObj *) payload;
+ virSecretDef *def;
struct virSecretSearchData *data = (struct virSecretSearchData *) opaque;
int found = 0;
*
* Returns: not locked, but ref'd secret object.
*/
-static virSecretObjPtr
-virSecretObjListFindByUsageLocked(virSecretObjListPtr secrets,
+static virSecretObj *
+virSecretObjListFindByUsageLocked(virSecretObjList *secrets,
int usageType,
const char *usageID)
{
- virSecretObjPtr obj = NULL;
+ virSecretObj *obj = NULL;
struct virSecretSearchData data = { .usageType = usageType,
.usageID = usageID };
*
* Returns: locked and ref'd secret object.
*/
-virSecretObjPtr
-virSecretObjListFindByUsage(virSecretObjListPtr secrets,
+virSecretObj *
+virSecretObjListFindByUsage(virSecretObjList *secrets,
int usageType,
const char *usageID)
{
- virSecretObjPtr obj;
+ virSecretObj *obj;
virObjectRWLockRead(secrets);
obj = virSecretObjListFindByUsageLocked(secrets, usageType, usageID);
* ensure no one else is either waiting for @secret or still using it.
*/
void
-virSecretObjListRemove(virSecretObjListPtr secrets,
- virSecretObjPtr obj)
+virSecretObjListRemove(virSecretObjList *secrets,
+ virSecretObj *obj)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virSecretDefPtr def;
+ virSecretDef *def;
if (!obj)
return;
*
* Returns: locked and ref'd secret or NULL if failure to add
*/
-virSecretObjPtr
-virSecretObjListAdd(virSecretObjListPtr secrets,
- virSecretDefPtr newdef,
+virSecretObj *
+virSecretObjListAdd(virSecretObjList *secrets,
+ virSecretDef *newdef,
const char *configDir,
- virSecretDefPtr *oldDef)
+ virSecretDef **oldDef)
{
- virSecretObjPtr obj;
- virSecretDefPtr objdef;
- virSecretObjPtr ret = NULL;
+ virSecretObj *obj;
+ virSecretDef *objdef;
+ virSecretObj *ret = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virObjectRWLockWrite(secrets);
void *opaque)
{
struct virSecretCountData *data = opaque;
- virSecretObjPtr obj = payload;
- virSecretDefPtr def;
+ virSecretObj *obj = payload;
+ virSecretDef *def;
virObjectLock(obj);
def = obj->def;
void *opaque)
{
struct virSecretListData *data = opaque;
- virSecretObjPtr obj = payload;
- virSecretDefPtr def;
+ virSecretObj *obj = payload;
+ virSecretDef *def;
if (data->error)
return 0;
int
-virSecretObjListNumOfSecrets(virSecretObjListPtr secrets,
+virSecretObjListNumOfSecrets(virSecretObjList *secrets,
virSecretObjListACLFilter filter,
virConnectPtr conn)
{
#define MATCH(FLAG) (flags & (FLAG))
static bool
-virSecretObjMatch(virSecretObjPtr obj,
+virSecretObjMatch(virSecretObj *obj,
unsigned int flags)
{
- virSecretDefPtr def = obj->def;
+ virSecretDef *def = obj->def;
/* filter by whether it's ephemeral */
if (MATCH(VIR_CONNECT_LIST_SECRETS_FILTERS_EPHEMERAL) &&
typedef struct _virSecretObjListExportData virSecretObjListExportData;
-typedef virSecretObjListExportData *virSecretObjListExportDataPtr;
struct _virSecretObjListExportData {
virConnectPtr conn;
virSecretPtr *secrets;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virSecretObjListExportDataPtr data = opaque;
- virSecretObjPtr obj = payload;
- virSecretDefPtr def;
+ virSecretObjListExportData *data = opaque;
+ virSecretObj *obj = payload;
+ virSecretDef *def;
virSecretPtr secret = NULL;
if (data->error)
int
virSecretObjListExport(virConnectPtr conn,
- virSecretObjListPtr secretobjs,
+ virSecretObjList *secretobjs,
virSecretPtr **secrets,
virSecretObjListACLFilter filter,
unsigned int flags)
int
-virSecretObjListGetUUIDs(virSecretObjListPtr secrets,
+virSecretObjListGetUUIDs(virSecretObjList *secrets,
char **uuids,
int maxuuids,
virSecretObjListACLFilter filter,
int
-virSecretObjDeleteConfig(virSecretObjPtr obj)
+virSecretObjDeleteConfig(virSecretObj *obj)
{
- virSecretDefPtr def = obj->def;
+ virSecretDef *def = obj->def;
if (!def->isephemeral &&
unlink(obj->configFile) < 0 && errno != ENOENT) {
void
-virSecretObjDeleteData(virSecretObjPtr obj)
+virSecretObjDeleteData(virSecretObj *obj)
{
/* The configFile will already be removed, so secret won't be
* loaded again if this fails */
/* Permanent secret storage */
-/* Secrets are stored in virSecretDriverStatePtr->configDir. Each secret
+/* Secrets are stored in virSecretDriverState *->configDir. Each secret
has virSecretDef stored as XML in "$basename.xml". If a value of the
secret is defined, it is stored as base64 (with no formatting) in
"$basename.base64". "$basename" is in both cases the base64-encoded UUID. */
int
-virSecretObjSaveConfig(virSecretObjPtr obj)
+virSecretObjSaveConfig(virSecretObj *obj)
{
g_autofree char *xml = NULL;
int
-virSecretObjSaveData(virSecretObjPtr obj)
+virSecretObjSaveData(virSecretObj *obj)
{
g_autofree char *base64 = NULL;
}
-virSecretDefPtr
-virSecretObjGetDef(virSecretObjPtr obj)
+virSecretDef *
+virSecretObjGetDef(virSecretObj *obj)
{
return obj->def;
}
void
-virSecretObjSetDef(virSecretObjPtr obj,
- virSecretDefPtr def)
+virSecretObjSetDef(virSecretObj *obj,
+ virSecretDef *def)
{
obj->def = def;
}
unsigned char *
-virSecretObjGetValue(virSecretObjPtr obj)
+virSecretObjGetValue(virSecretObj *obj)
{
- virSecretDefPtr def = obj->def;
+ virSecretDef *def = obj->def;
unsigned char *ret = NULL;
if (!obj->value) {
int
-virSecretObjSetValue(virSecretObjPtr obj,
+virSecretObjSetValue(virSecretObj *obj,
const unsigned char *value,
size_t value_size)
{
- virSecretDefPtr def = obj->def;
+ virSecretDef *def = obj->def;
g_autofree unsigned char *old_value = NULL;
g_autofree unsigned char *new_value = NULL;
size_t old_value_size;
size_t
-virSecretObjGetValueSize(virSecretObjPtr obj)
+virSecretObjGetValueSize(virSecretObj *obj)
{
return obj->value_size;
}
void
-virSecretObjSetValueSize(virSecretObjPtr obj,
+virSecretObjSetValueSize(virSecretObj *obj,
size_t value_size)
{
obj->value_size = value_size;
static int
-virSecretLoadValidateUUID(virSecretDefPtr def,
+virSecretLoadValidateUUID(virSecretDef *def,
const char *file)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
static int
-virSecretLoadValue(virSecretObjPtr obj)
+virSecretLoadValue(virSecretObj *obj)
{
int ret = -1, fd = -1;
struct stat st;
}
-static virSecretObjPtr
-virSecretLoad(virSecretObjListPtr secrets,
+static virSecretObj *
+virSecretLoad(virSecretObjList *secrets,
const char *file,
const char *path,
const char *configDir)
{
- virSecretDefPtr def = NULL;
- virSecretObjPtr obj = NULL;
+ virSecretDef *def = NULL;
+ virSecretObj *obj = NULL;
if (!(def = virSecretDefParseFile(path)))
goto cleanup;
int
-virSecretLoadAllConfigs(virSecretObjListPtr secrets,
+virSecretLoadAllConfigs(virSecretObjList *secrets,
const char *configDir)
{
g_autoptr(DIR) dir = NULL;
* loop (if any). It's better to keep the secrets we managed to find. */
while (virDirRead(dir, &de, NULL) > 0) {
char *path;
- virSecretObjPtr obj;
+ virSecretObj *obj;
if (!virStringHasSuffix(de->d_name, ".xml"))
continue;
#include "virobject.h"
typedef struct _virSecretObj virSecretObj;
-typedef virSecretObj *virSecretObjPtr;
void
-virSecretObjEndAPI(virSecretObjPtr *obj);
+virSecretObjEndAPI(virSecretObj **obj);
typedef struct _virSecretObjList virSecretObjList;
-typedef virSecretObjList *virSecretObjListPtr;
-virSecretObjListPtr
+virSecretObjList *
virSecretObjListNew(void);
-virSecretObjPtr
-virSecretObjListFindByUUID(virSecretObjListPtr secrets,
+virSecretObj *
+virSecretObjListFindByUUID(virSecretObjList *secrets,
const char *uuidstr);
-virSecretObjPtr
-virSecretObjListFindByUsage(virSecretObjListPtr secrets,
+virSecretObj *
+virSecretObjListFindByUsage(virSecretObjList *secrets,
int usageType,
const char *usageID);
void
-virSecretObjListRemove(virSecretObjListPtr secrets,
- virSecretObjPtr obj);
+virSecretObjListRemove(virSecretObjList *secrets,
+ virSecretObj *obj);
-virSecretObjPtr
-virSecretObjListAdd(virSecretObjListPtr secrets,
- virSecretDefPtr newdef,
+virSecretObj *
+virSecretObjListAdd(virSecretObjList *secrets,
+ virSecretDef *newdef,
const char *configDir,
- virSecretDefPtr *oldDef);
+ virSecretDef **oldDef);
typedef bool
(*virSecretObjListACLFilter)(virConnectPtr conn,
- virSecretDefPtr def);
+ virSecretDef *def);
int
-virSecretObjListNumOfSecrets(virSecretObjListPtr secrets,
+virSecretObjListNumOfSecrets(virSecretObjList *secrets,
virSecretObjListACLFilter filter,
virConnectPtr conn);
int
virSecretObjListExport(virConnectPtr conn,
- virSecretObjListPtr secretobjs,
+ virSecretObjList *secretobjs,
virSecretPtr **secrets,
virSecretObjListACLFilter filter,
unsigned int flags);
int
-virSecretObjListGetUUIDs(virSecretObjListPtr secrets,
+virSecretObjListGetUUIDs(virSecretObjList *secrets,
char **uuids,
int maxuuids,
virSecretObjListACLFilter filter,
virConnectPtr conn);
int
-virSecretObjDeleteConfig(virSecretObjPtr obj);
+virSecretObjDeleteConfig(virSecretObj *obj);
void
-virSecretObjDeleteData(virSecretObjPtr obj);
+virSecretObjDeleteData(virSecretObj *obj);
int
-virSecretObjSaveConfig(virSecretObjPtr obj);
+virSecretObjSaveConfig(virSecretObj *obj);
int
-virSecretObjSaveData(virSecretObjPtr obj);
+virSecretObjSaveData(virSecretObj *obj);
-virSecretDefPtr
-virSecretObjGetDef(virSecretObjPtr obj);
+virSecretDef *
+virSecretObjGetDef(virSecretObj *obj);
void
-virSecretObjSetDef(virSecretObjPtr obj,
- virSecretDefPtr def);
+virSecretObjSetDef(virSecretObj *obj,
+ virSecretDef *def);
unsigned char *
-virSecretObjGetValue(virSecretObjPtr obj);
+virSecretObjGetValue(virSecretObj *obj);
int
-virSecretObjSetValue(virSecretObjPtr obj,
+virSecretObjSetValue(virSecretObj *obj,
const unsigned char *value,
size_t value_size);
size_t
-virSecretObjGetValueSize(virSecretObjPtr obj);
+virSecretObjGetValueSize(virSecretObj *obj);
void
-virSecretObjSetValueSize(virSecretObjPtr obj,
+virSecretObjSetValueSize(virSecretObj *obj,
size_t value_size);
int
-virSecretLoadAllConfigs(virSecretObjListPtr secrets,
+virSecretLoadAllConfigs(virSecretObjList *secrets,
const char *configDir);
VIR_LOG_INIT("conf.virstorageobj");
-static virClassPtr virStoragePoolObjClass;
-static virClassPtr virStoragePoolObjListClass;
-static virClassPtr virStorageVolObjClass;
-static virClassPtr virStorageVolObjListClass;
+static virClass *virStoragePoolObjClass;
+static virClass *virStoragePoolObjListClass;
+static virClass *virStorageVolObjClass;
+static virClass *virStorageVolObjListClass;
static void
virStoragePoolObjDispose(void *opaque);
typedef struct _virStorageVolObj virStorageVolObj;
-typedef virStorageVolObj *virStorageVolObjPtr;
struct _virStorageVolObj {
virObjectLockable parent;
- virStorageVolDefPtr voldef;
+ virStorageVolDef *voldef;
};
typedef struct _virStorageVolObjList virStorageVolObjList;
-typedef virStorageVolObjList *virStorageVolObjListPtr;
struct _virStorageVolObjList {
virObjectRWLockable parent;
bool autostart;
unsigned int asyncjobs;
- virStoragePoolDefPtr def;
- virStoragePoolDefPtr newDef;
+ virStoragePoolDef *def;
+ virStoragePoolDef *newDef;
- virStorageVolObjListPtr volumes;
+ virStorageVolObjList *volumes;
};
struct _virStoragePoolObjList {
VIR_ONCE_GLOBAL_INIT(virStorageVolObj);
-static virStorageVolObjPtr
+static virStorageVolObj *
virStorageVolObjNew(void)
{
- virStorageVolObjPtr obj;
+ virStorageVolObj *obj;
if (virStorageVolObjInitialize() < 0)
return NULL;
static void
-virStorageVolObjEndAPI(virStorageVolObjPtr *obj)
+virStorageVolObjEndAPI(virStorageVolObj **obj)
{
if (!*obj)
return;
static void
virStorageVolObjDispose(void *opaque)
{
- virStorageVolObjPtr obj = opaque;
+ virStorageVolObj *obj = opaque;
virStorageVolDefFree(obj->voldef);
}
-static virStorageVolObjListPtr
+static virStorageVolObjList *
virStorageVolObjListNew(void)
{
- virStorageVolObjListPtr vols;
+ virStorageVolObjList *vols;
if (virStorageVolObjInitialize() < 0)
return NULL;
static void
virStorageVolObjListDispose(void *opaque)
{
- virStorageVolObjListPtr vols = opaque;
+ virStorageVolObjList *vols = opaque;
virHashFree(vols->objsKey);
virHashFree(vols->objsName);
VIR_ONCE_GLOBAL_INIT(virStoragePoolObj);
-virStoragePoolObjPtr
+virStoragePoolObj *
virStoragePoolObjNew(void)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (virStoragePoolObjInitialize() < 0)
return NULL;
void
-virStoragePoolObjEndAPI(virStoragePoolObjPtr *obj)
+virStoragePoolObjEndAPI(virStoragePoolObj **obj)
{
if (!*obj)
return;
}
-virStoragePoolDefPtr
-virStoragePoolObjGetDef(virStoragePoolObjPtr obj)
+virStoragePoolDef *
+virStoragePoolObjGetDef(virStoragePoolObj *obj)
{
return obj->def;
}
void
-virStoragePoolObjSetDef(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+virStoragePoolObjSetDef(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
virStoragePoolDefFree(obj->def);
obj->def = def;
}
-virStoragePoolDefPtr
-virStoragePoolObjGetNewDef(virStoragePoolObjPtr obj)
+virStoragePoolDef *
+virStoragePoolObjGetNewDef(virStoragePoolObj *obj)
{
return obj->newDef;
}
void
-virStoragePoolObjDefUseNewDef(virStoragePoolObjPtr obj)
+virStoragePoolObjDefUseNewDef(virStoragePoolObj *obj)
{
virStoragePoolDefFree(obj->def);
obj->def = g_steal_pointer(&obj->newDef);
const char *
-virStoragePoolObjGetConfigFile(virStoragePoolObjPtr obj)
+virStoragePoolObjGetConfigFile(virStoragePoolObj *obj)
{
return obj->configFile;
}
void
-virStoragePoolObjSetConfigFile(virStoragePoolObjPtr obj,
+virStoragePoolObjSetConfigFile(virStoragePoolObj *obj,
char *configFile)
{
VIR_FREE(obj->configFile);
const char *
-virStoragePoolObjGetAutostartLink(virStoragePoolObjPtr obj)
+virStoragePoolObjGetAutostartLink(virStoragePoolObj *obj)
{
return obj->autostartLink;
}
bool
-virStoragePoolObjIsActive(virStoragePoolObjPtr obj)
+virStoragePoolObjIsActive(virStoragePoolObj *obj)
{
return obj->active;
}
void
-virStoragePoolObjSetActive(virStoragePoolObjPtr obj,
+virStoragePoolObjSetActive(virStoragePoolObj *obj,
bool active)
{
obj->active = active;
void
-virStoragePoolObjSetStarting(virStoragePoolObjPtr obj,
+virStoragePoolObjSetStarting(virStoragePoolObj *obj,
bool starting)
{
obj->starting = starting;
bool
-virStoragePoolObjIsStarting(virStoragePoolObjPtr obj)
+virStoragePoolObjIsStarting(virStoragePoolObj *obj)
{
return obj->starting;
}
bool
-virStoragePoolObjIsAutostart(virStoragePoolObjPtr obj)
+virStoragePoolObjIsAutostart(virStoragePoolObj *obj)
{
if (!obj->configFile)
return false;
void
-virStoragePoolObjSetAutostart(virStoragePoolObjPtr obj,
+virStoragePoolObjSetAutostart(virStoragePoolObj *obj,
bool autostart)
{
obj->autostart = autostart;
unsigned int
-virStoragePoolObjGetAsyncjobs(virStoragePoolObjPtr obj)
+virStoragePoolObjGetAsyncjobs(virStoragePoolObj *obj)
{
return obj->asyncjobs;
}
void
-virStoragePoolObjIncrAsyncjobs(virStoragePoolObjPtr obj)
+virStoragePoolObjIncrAsyncjobs(virStoragePoolObj *obj)
{
obj->asyncjobs++;
}
void
-virStoragePoolObjDecrAsyncjobs(virStoragePoolObjPtr obj)
+virStoragePoolObjDecrAsyncjobs(virStoragePoolObj *obj)
{
obj->asyncjobs--;
}
void
virStoragePoolObjDispose(void *opaque)
{
- virStoragePoolObjPtr obj = opaque;
+ virStoragePoolObj *obj = opaque;
virStoragePoolObjClearVols(obj);
virObjectUnref(obj->volumes);
void
virStoragePoolObjListDispose(void *opaque)
{
- virStoragePoolObjListPtr pools = opaque;
+ virStoragePoolObjList *pools = opaque;
virHashFree(pools->objs);
virHashFree(pools->objsName);
}
-virStoragePoolObjListPtr
+virStoragePoolObjList *
virStoragePoolObjListNew(void)
{
- virStoragePoolObjListPtr pools;
+ virStoragePoolObjList *pools;
if (virStoragePoolObjInitialize() < 0)
return NULL;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStoragePoolObjPtr obj = payload;
+ virStoragePoolObj *obj = payload;
struct _virStoragePoolObjListForEachData *data = opaque;
/* Grab a reference so that we don't rely only on references grabbed by
* AutoStart, or Reload) this is OK.
*/
void
-virStoragePoolObjListForEach(virStoragePoolObjListPtr pools,
+virStoragePoolObjListForEach(virStoragePoolObjList *pools,
virStoragePoolObjListIterator iter,
const void *opaque)
{
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virStoragePoolObjPtr obj = (virStoragePoolObjPtr) payload;
+ virStoragePoolObj *obj = (virStoragePoolObj *) payload;
struct _virStoragePoolObjListSearchData *data =
(struct _virStoragePoolObjListSearchData *)opaque;
*
* Returns a locked and reffed object when found and NULL when not found
*/
-virStoragePoolObjPtr
-virStoragePoolObjListSearch(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjListSearch(virStoragePoolObjList *pools,
virStoragePoolObjListSearcher searcher,
const void *opaque)
{
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolObj *obj = NULL;
struct _virStoragePoolObjListSearchData data = { .searcher = searcher,
.opaque = opaque };
void
-virStoragePoolObjRemove(virStoragePoolObjListPtr pools,
- virStoragePoolObjPtr obj)
+virStoragePoolObjRemove(virStoragePoolObjList *pools,
+ virStoragePoolObj *obj)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
-static virStoragePoolObjPtr
-virStoragePoolObjFindByUUIDLocked(virStoragePoolObjListPtr pools,
+static virStoragePoolObj *
+virStoragePoolObjFindByUUIDLocked(virStoragePoolObjList *pools,
const unsigned char *uuid)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
*
* Returns: Locked and reffed storage pool object or NULL if not found
*/
-virStoragePoolObjPtr
-virStoragePoolObjFindByUUID(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjFindByUUID(virStoragePoolObjList *pools,
const unsigned char *uuid)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
virObjectRWLockRead(pools);
obj = virStoragePoolObjFindByUUIDLocked(pools, uuid);
}
-static virStoragePoolObjPtr
-virStoragePoolObjFindByNameLocked(virStoragePoolObjListPtr pools,
+static virStoragePoolObj *
+virStoragePoolObjFindByNameLocked(virStoragePoolObjList *pools,
const char *name)
{
return virObjectRef(virHashLookup(pools->objsName, name));
*
* Returns: Locked and reffed storage pool object or NULL if not found
*/
-virStoragePoolObjPtr
-virStoragePoolObjFindByName(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjFindByName(virStoragePoolObjList *pools,
const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
virObjectRWLockRead(pools);
obj = virStoragePoolObjFindByNameLocked(pools, name);
}
-static virStoragePoolObjPtr
-virStoragePoolSourceFindDuplicateDevices(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+static virStoragePoolObj *
+virStoragePoolSourceFindDuplicateDevices(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
size_t i, j;
void
-virStoragePoolObjClearVols(virStoragePoolObjPtr obj)
+virStoragePoolObjClearVols(virStoragePoolObj *obj)
{
if (!obj->volumes)
return;
int
-virStoragePoolObjAddVol(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef)
+virStoragePoolObjAddVol(virStoragePoolObj *obj,
+ virStorageVolDef *voldef)
{
- virStorageVolObjPtr volobj = NULL;
- virStorageVolObjListPtr volumes = obj->volumes;
+ virStorageVolObj *volobj = NULL;
+ virStorageVolObjList *volumes = obj->volumes;
virObjectRWLockWrite(volumes);
void
-virStoragePoolObjRemoveVol(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef)
+virStoragePoolObjRemoveVol(virStoragePoolObj *obj,
+ virStorageVolDef *voldef)
{
- virStorageVolObjListPtr volumes = obj->volumes;
- virStorageVolObjPtr volobj;
+ virStorageVolObjList *volumes = obj->volumes;
+ virStorageVolObj *volobj;
virObjectRWLockWrite(volumes);
volobj = virHashLookup(volumes->objsName, voldef->name);
size_t
-virStoragePoolObjGetVolumesCount(virStoragePoolObjPtr obj)
+virStoragePoolObjGetVolumesCount(virStoragePoolObj *obj)
{
size_t nbElems;
void *opaque)
{
int ret = 0;
- virStorageVolObjPtr volobj = payload;
+ virStorageVolObj *volobj = payload;
struct _virStoragePoolObjForEachVolData *data = opaque;
virObjectLock(volobj);
int
-virStoragePoolObjForEachVolume(virStoragePoolObjPtr obj,
+virStoragePoolObjForEachVolume(virStoragePoolObj *obj,
virStorageVolObjListIterator iter,
const void *opaque)
{
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virStorageVolObjPtr volobj = (virStorageVolObjPtr) payload;
+ virStorageVolObj *volobj = (virStorageVolObj *) payload;
struct _virStoragePoolObjSearchVolData *data =
(struct _virStoragePoolObjSearchVolData *) opaque;
int found = 0;
}
-virStorageVolDefPtr
-virStoragePoolObjSearchVolume(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStoragePoolObjSearchVolume(virStoragePoolObj *obj,
virStorageVolObjListSearcher iter,
const void *opaque)
{
- virStorageVolObjPtr volobj;
+ virStorageVolObj *volobj;
struct _virStoragePoolObjSearchVolData data = {
.iter = iter, .opaque = opaque };
}
-virStorageVolDefPtr
-virStorageVolDefFindByKey(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByKey(virStoragePoolObj *obj,
const char *key)
{
- virStorageVolObjPtr volobj;
+ virStorageVolObj *volobj;
virObjectRWLockRead(obj->volumes);
volobj = virHashLookup(obj->volumes->objsKey, key);
}
-virStorageVolDefPtr
-virStorageVolDefFindByPath(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByPath(virStoragePoolObj *obj,
const char *path)
{
- virStorageVolObjPtr volobj;
+ virStorageVolObj *volobj;
virObjectRWLockRead(obj->volumes);
volobj = virHashLookup(obj->volumes->objsPath, path);
}
-virStorageVolDefPtr
-virStorageVolDefFindByName(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByName(virStoragePoolObj *obj,
const char *name)
{
- virStorageVolObjPtr volobj;
+ virStorageVolObj *volobj;
virObjectRWLockRead(obj->volumes);
volobj = virHashLookup(obj->volumes->objsName, name);
struct _virStorageVolObjCountData {
virConnectPtr conn;
virStoragePoolVolumeACLFilter filter;
- virStoragePoolDefPtr pooldef;
+ virStoragePoolDef *pooldef;
int count;
};
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStorageVolObjPtr volobj = payload;
+ virStorageVolObj *volobj = payload;
struct _virStorageVolObjCountData *data = opaque;
virObjectLock(volobj);
int
-virStoragePoolObjNumOfVolumes(virStoragePoolObjPtr obj,
+virStoragePoolObjNumOfVolumes(virStoragePoolObj *obj,
virConnectPtr conn,
virStoragePoolVolumeACLFilter filter)
{
- virStorageVolObjListPtr volumes = obj->volumes;
+ virStorageVolObjList *volumes = obj->volumes;
struct _virStorageVolObjCountData data = {
.conn = conn, .filter = filter, .pooldef = obj->def, .count = 0 };
struct _virStorageVolObjNameData {
virConnectPtr conn;
virStoragePoolVolumeACLFilter filter;
- virStoragePoolDefPtr pooldef;
+ virStoragePoolDef *pooldef;
bool error;
int nnames;
int maxnames;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStorageVolObjPtr volobj = payload;
+ virStorageVolObj *volobj = payload;
struct _virStorageVolObjNameData *data = opaque;
if (data->error)
int
-virStoragePoolObjVolumeGetNames(virStoragePoolObjPtr obj,
+virStoragePoolObjVolumeGetNames(virStoragePoolObj *obj,
virConnectPtr conn,
virStoragePoolVolumeACLFilter filter,
char **const names,
int maxnames)
{
- virStorageVolObjListPtr volumes = obj->volumes;
+ virStorageVolObjList *volumes = obj->volumes;
struct _virStorageVolObjNameData data = {
.conn = conn, .filter = filter, .pooldef = obj->def, .error = false,
.nnames = 0, .maxnames = maxnames, .names = names };
typedef struct _virStoragePoolObjVolumeListExportData virStoragePoolObjVolumeListExportData;
-typedef virStoragePoolObjVolumeListExportData *virStoragePoolObjVolumeListExportDataPtr;
struct _virStoragePoolObjVolumeListExportData {
virConnectPtr conn;
virStoragePoolVolumeACLFilter filter;
- virStoragePoolDefPtr pooldef;
+ virStoragePoolDef *pooldef;
bool error;
int nvols;
virStorageVolPtr *vols;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStorageVolObjPtr volobj = payload;
- virStoragePoolObjVolumeListExportDataPtr data = opaque;
+ virStorageVolObj *volobj = payload;
+ virStoragePoolObjVolumeListExportData *data = opaque;
virStorageVolPtr vol = NULL;
if (data->error)
int
virStoragePoolObjVolumeListExport(virConnectPtr conn,
- virStoragePoolObjPtr obj,
+ virStoragePoolObj *obj,
virStorageVolPtr **vols,
virStoragePoolVolumeACLFilter filter)
{
- virStorageVolObjListPtr volumes = obj->volumes;
+ virStorageVolObjList *volumes = obj->volumes;
virStoragePoolObjVolumeListExportData data = {
.conn = conn, .filter = filter, .pooldef = obj->def, .error = false,
.nvols = 0, .vols = NULL };
/*
* virStoragePoolObjIsDuplicate:
- * @doms : virStoragePoolObjListPtr to search
- * @def : virStoragePoolDefPtr definition of pool to lookup
+ * @doms : virStoragePoolObjList * to search
+ * @def : virStoragePoolDef * definition of pool to lookup
* @check_active: If true, ensure that pool is not active
* @objRet: returned pool object
*
* 1 if pool is a duplicate (name and UUID match)
*/
static int
-virStoragePoolObjIsDuplicate(virStoragePoolObjListPtr pools,
- virStoragePoolDefPtr def,
+virStoragePoolObjIsDuplicate(virStoragePoolObjList *pools,
+ virStoragePoolDef *def,
bool check_active,
- virStoragePoolObjPtr *objRet)
+ virStoragePoolObj **objRet)
{
int ret = -1;
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolObj *obj = NULL;
/* See if a Pool with matching UUID already exists */
obj = virStoragePoolObjFindByUUIDLocked(pools, def->uuid);
static int
-getSCSIHostNumber(virStorageAdapterSCSIHostPtr scsi_host,
+getSCSIHostNumber(virStorageAdapterSCSIHost *scsi_host,
unsigned int *hostnum)
{
int ret = -1;
char *name = NULL;
if (scsi_host->has_parent) {
- virPCIDeviceAddressPtr addr = &scsi_host->parentaddr;
+ virPCIDeviceAddress *addr = &scsi_host->parentaddr;
unsigned int unique_id = scsi_host->unique_id;
if (!(name = virSCSIHostGetNameByParentaddr(addr->domain,
* fc_adapter host# and the scsi_host host#
*/
static bool
-matchFCHostToSCSIHost(virStorageAdapterFCHostPtr fchost,
+matchFCHostToSCSIHost(virStorageAdapterFCHost *fchost,
unsigned int scsi_hostnum)
{
virConnectPtr conn = NULL;
static bool
-matchSCSIAdapterParent(virStorageAdapterSCSIHostPtr pool_scsi_host,
- virStorageAdapterSCSIHostPtr def_scsi_host)
+matchSCSIAdapterParent(virStorageAdapterSCSIHost *pool_scsi_host,
+ virStorageAdapterSCSIHost *def_scsi_host)
{
- virPCIDeviceAddressPtr pooladdr = &pool_scsi_host->parentaddr;
- virPCIDeviceAddressPtr defaddr = &def_scsi_host->parentaddr;
+ virPCIDeviceAddress *pooladdr = &pool_scsi_host->parentaddr;
+ virPCIDeviceAddress *defaddr = &def_scsi_host->parentaddr;
if (pooladdr->domain == defaddr->domain &&
pooladdr->bus == defaddr->bus &&
static bool
-virStoragePoolSourceMatchSingleHost(virStoragePoolSourcePtr poolsrc,
- virStoragePoolSourcePtr defsrc)
+virStoragePoolSourceMatchSingleHost(virStoragePoolSource *poolsrc,
+ virStoragePoolSource *defsrc)
{
if (poolsrc->nhost != 1 && defsrc->nhost != 1)
return false;
static bool
-virStoragePoolSourceISCSIMatch(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+virStoragePoolSourceISCSIMatch(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
- virStoragePoolSourcePtr poolsrc = &obj->def->source;
- virStoragePoolSourcePtr defsrc = &def->source;
+ virStoragePoolSource *poolsrc = &obj->def->source;
+ virStoragePoolSource *defsrc = &def->source;
/* NB: Do not check the source host name */
if (STRNEQ_NULLABLE(poolsrc->initiator.iqn, defsrc->initiator.iqn))
}
-static virStoragePoolObjPtr
-virStoragePoolObjSourceMatchTypeDIR(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+static virStoragePoolObj *
+virStoragePoolObjSourceMatchTypeDIR(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
if (obj->def->type == VIR_STORAGE_POOL_DIR) {
if (STREQ(obj->def->target.path, def->target.path))
}
-static virStoragePoolObjPtr
-virStoragePoolObjSourceMatchTypeISCSI(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+static virStoragePoolObj *
+virStoragePoolObjSourceMatchTypeISCSI(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
- virStorageAdapterPtr pool_adapter = &obj->def->source.adapter;
- virStorageAdapterPtr def_adapter = &def->source.adapter;
- virStorageAdapterSCSIHostPtr pool_scsi_host;
- virStorageAdapterSCSIHostPtr def_scsi_host;
- virStorageAdapterFCHostPtr pool_fchost;
- virStorageAdapterFCHostPtr def_fchost;
+ virStorageAdapter *pool_adapter = &obj->def->source.adapter;
+ virStorageAdapter *def_adapter = &def->source.adapter;
+ virStorageAdapterSCSIHost *pool_scsi_host;
+ virStorageAdapterSCSIHost *def_scsi_host;
+ virStorageAdapterFCHost *pool_fchost;
+ virStorageAdapterFCHost *def_fchost;
unsigned int pool_hostnum;
unsigned int def_hostnum;
unsigned int scsi_hostnum;
}
-static virStoragePoolObjPtr
-virStoragePoolObjSourceMatchTypeDEVICE(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+static virStoragePoolObj *
+virStoragePoolObjSourceMatchTypeDEVICE(virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
- virStoragePoolObjPtr matchobj = NULL;
+ virStoragePoolObj *matchobj = NULL;
if (obj->def->type == VIR_STORAGE_POOL_ISCSI) {
if (def->type != VIR_STORAGE_POOL_ISCSI)
struct _virStoragePoolObjFindDuplicateData {
- virStoragePoolDefPtr def;
+ virStoragePoolDef *def;
};
static int
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virStoragePoolObjPtr obj = (virStoragePoolObjPtr) payload;
+ virStoragePoolObj *obj = (virStoragePoolObj *) payload;
struct _virStoragePoolObjFindDuplicateData *data =
(struct _virStoragePoolObjFindDuplicateData *) opaque;
static int
-virStoragePoolObjSourceFindDuplicate(virStoragePoolObjListPtr pools,
- virStoragePoolDefPtr def)
+virStoragePoolObjSourceFindDuplicate(virStoragePoolObjList *pools,
+ virStoragePoolDef *def)
{
struct _virStoragePoolObjFindDuplicateData data = {.def = def};
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolObj *obj = NULL;
obj = virHashSearch(pools->objs, virStoragePoolObjSourceFindDuplicateCb,
&data, NULL);
static void
-virStoragePoolObjAssignDef(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def,
+virStoragePoolObjAssignDef(virStoragePoolObj *obj,
+ virStoragePoolDef *def,
unsigned int flags)
{
if (virStoragePoolObjIsActive(obj) ||
*
* Returns locked and reffed object pointer or NULL on error
*/
-virStoragePoolObjPtr
-virStoragePoolObjListAdd(virStoragePoolObjListPtr pools,
- virStoragePoolDefPtr def,
+virStoragePoolObj *
+virStoragePoolObjListAdd(virStoragePoolObjList *pools,
+ virStoragePoolDef *def,
unsigned int flags)
{
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolObj *obj = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
int rc;
}
-static virStoragePoolObjPtr
-virStoragePoolObjLoad(virStoragePoolObjListPtr pools,
+static virStoragePoolObj *
+virStoragePoolObjLoad(virStoragePoolObjList *pools,
const char *file,
const char *path,
const char *autostartLink)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
g_autoptr(virStoragePoolDef) def = NULL;
if (!(def = virStoragePoolDefParseFile(path)))
}
-static virStoragePoolObjPtr
-virStoragePoolObjLoadState(virStoragePoolObjListPtr pools,
+static virStoragePoolObj *
+virStoragePoolObjLoadState(virStoragePoolObjList *pools,
const char *stateDir,
const char *name)
{
char *stateFile = NULL;
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolObj *obj = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr node = NULL;
int
-virStoragePoolObjLoadAllState(virStoragePoolObjListPtr pools,
+virStoragePoolObjLoadAllState(virStoragePoolObjList *pools,
const char *stateDir)
{
g_autoptr(DIR) dir = NULL;
return rc;
while ((ret = virDirRead(dir, &entry, stateDir)) > 0) {
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (!virStringStripSuffix(entry->d_name, ".xml"))
continue;
int
-virStoragePoolObjLoadAllConfigs(virStoragePoolObjListPtr pools,
+virStoragePoolObjLoadAllConfigs(virStoragePoolObjList *pools,
const char *configDir,
const char *autostartDir)
{
while ((ret = virDirRead(dir, &entry, configDir)) > 0) {
char *path;
char *autostartLink;
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (!virStringHasSuffix(entry->d_name, ".xml"))
continue;
int
-virStoragePoolObjSaveDef(virStorageDriverStatePtr driver,
- virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def)
+virStoragePoolObjSaveDef(virStorageDriverState *driver,
+ virStoragePoolObj *obj,
+ virStoragePoolDef *def)
{
if (!obj->configFile) {
if (g_mkdir_with_parents(driver->configDir, 0777) < 0) {
int
-virStoragePoolObjDeleteDef(virStoragePoolObjPtr obj)
+virStoragePoolObjDeleteDef(virStoragePoolObj *obj)
{
if (!obj->configFile) {
virReportError(VIR_ERR_INTERNAL_ERROR,
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStoragePoolObjPtr obj = payload;
+ virStoragePoolObj *obj = payload;
struct _virStoragePoolCountData *data = opaque;
virObjectLock(obj);
int
-virStoragePoolObjNumOfStoragePools(virStoragePoolObjListPtr pools,
+virStoragePoolObjNumOfStoragePools(virStoragePoolObjList *pools,
virConnectPtr conn,
bool wantActive,
virStoragePoolObjListACLFilter filter)
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStoragePoolObjPtr obj = payload;
+ virStoragePoolObj *obj = payload;
struct _virStoragePoolNameData *data = opaque;
if (data->error)
int
-virStoragePoolObjGetNames(virStoragePoolObjListPtr pools,
+virStoragePoolObjGetNames(virStoragePoolObjList *pools,
virConnectPtr conn,
bool wantActive,
virStoragePoolObjListACLFilter filter,
#define MATCH(FLAG) (flags & (FLAG))
static bool
-virStoragePoolObjMatch(virStoragePoolObjPtr obj,
+virStoragePoolObjMatch(virStoragePoolObj *obj,
unsigned int flags)
{
/* filter by active state */
typedef struct _virStoragePoolObjListExportData virStoragePoolObjListExportData;
-typedef virStoragePoolObjListExportData *virStoragePoolObjListExportDataPtr;
struct _virStoragePoolObjListExportData {
virConnectPtr conn;
virStoragePoolObjListACLFilter filter;
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virStoragePoolObjPtr obj = payload;
- virStoragePoolObjListExportDataPtr data = opaque;
+ virStoragePoolObj *obj = payload;
+ virStoragePoolObjListExportData *data = opaque;
virStoragePoolPtr pool = NULL;
if (data->error)
int
virStoragePoolObjListExport(virConnectPtr conn,
- virStoragePoolObjListPtr poolobjs,
+ virStoragePoolObjList *poolobjs,
virStoragePoolPtr **pools,
virStoragePoolObjListFilter filter,
unsigned int flags)
#include "capabilities.h"
typedef struct _virStoragePoolObj virStoragePoolObj;
-typedef virStoragePoolObj *virStoragePoolObjPtr;
typedef struct _virStoragePoolObjList virStoragePoolObjList;
-typedef virStoragePoolObjList *virStoragePoolObjListPtr;
typedef struct _virStorageDriverState virStorageDriverState;
-typedef virStorageDriverState *virStorageDriverStatePtr;
-
struct _virStorageDriverState {
virMutex lock;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
- virStoragePoolObjListPtr pools;
+ virStoragePoolObjList *pools;
char *configDir;
char *autostartDir;
bool privileged;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr storageEventState;
+ virObjectEventState *storageEventState;
/* Immutable pointer, read only after initialized */
- virCapsPtr caps;
+ virCaps *caps;
};
typedef bool
(*virStoragePoolObjListFilter)(virConnectPtr conn,
- virStoragePoolDefPtr def);
+ virStoragePoolDef *def);
-virStoragePoolObjPtr
+virStoragePoolObj *
virStoragePoolObjNew(void);
void
-virStoragePoolObjEndAPI(virStoragePoolObjPtr *obj);
+virStoragePoolObjEndAPI(virStoragePoolObj **obj);
-virStoragePoolDefPtr
-virStoragePoolObjGetDef(virStoragePoolObjPtr obj);
+virStoragePoolDef *
+virStoragePoolObjGetDef(virStoragePoolObj *obj);
void
-virStoragePoolObjSetDef(virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def);
+virStoragePoolObjSetDef(virStoragePoolObj *obj,
+ virStoragePoolDef *def);
-virStoragePoolDefPtr
-virStoragePoolObjGetNewDef(virStoragePoolObjPtr obj);
+virStoragePoolDef *
+virStoragePoolObjGetNewDef(virStoragePoolObj *obj);
void
-virStoragePoolObjDefUseNewDef(virStoragePoolObjPtr obj);
+virStoragePoolObjDefUseNewDef(virStoragePoolObj *obj);
const char *
-virStoragePoolObjGetConfigFile(virStoragePoolObjPtr obj);
+virStoragePoolObjGetConfigFile(virStoragePoolObj *obj);
void
-virStoragePoolObjSetConfigFile(virStoragePoolObjPtr obj,
+virStoragePoolObjSetConfigFile(virStoragePoolObj *obj,
char *configFile);
const char *
-virStoragePoolObjGetAutostartLink(virStoragePoolObjPtr obj);
+virStoragePoolObjGetAutostartLink(virStoragePoolObj *obj);
bool
-virStoragePoolObjIsActive(virStoragePoolObjPtr obj);
+virStoragePoolObjIsActive(virStoragePoolObj *obj);
void
-virStoragePoolObjSetActive(virStoragePoolObjPtr obj,
+virStoragePoolObjSetActive(virStoragePoolObj *obj,
bool active);
void
-virStoragePoolObjSetStarting(virStoragePoolObjPtr obj,
+virStoragePoolObjSetStarting(virStoragePoolObj *obj,
bool starting);
bool
-virStoragePoolObjIsStarting(virStoragePoolObjPtr obj);
+virStoragePoolObjIsStarting(virStoragePoolObj *obj);
bool
-virStoragePoolObjIsAutostart(virStoragePoolObjPtr obj);
+virStoragePoolObjIsAutostart(virStoragePoolObj *obj);
void
-virStoragePoolObjSetAutostart(virStoragePoolObjPtr obj,
+virStoragePoolObjSetAutostart(virStoragePoolObj *obj,
bool autostart);
unsigned int
-virStoragePoolObjGetAsyncjobs(virStoragePoolObjPtr obj);
+virStoragePoolObjGetAsyncjobs(virStoragePoolObj *obj);
void
-virStoragePoolObjIncrAsyncjobs(virStoragePoolObjPtr obj);
+virStoragePoolObjIncrAsyncjobs(virStoragePoolObj *obj);
void
-virStoragePoolObjDecrAsyncjobs(virStoragePoolObjPtr obj);
+virStoragePoolObjDecrAsyncjobs(virStoragePoolObj *obj);
int
-virStoragePoolObjLoadAllConfigs(virStoragePoolObjListPtr pools,
+virStoragePoolObjLoadAllConfigs(virStoragePoolObjList *pools,
const char *configDir,
const char *autostartDir);
int
-virStoragePoolObjLoadAllState(virStoragePoolObjListPtr pools,
+virStoragePoolObjLoadAllState(virStoragePoolObjList *pools,
const char *stateDir);
-virStoragePoolObjPtr
-virStoragePoolObjFindByUUID(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjFindByUUID(virStoragePoolObjList *pools,
const unsigned char *uuid);
-virStoragePoolObjPtr
-virStoragePoolObjFindByName(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjFindByName(virStoragePoolObjList *pools,
const char *name);
int
-virStoragePoolObjAddVol(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef);
+virStoragePoolObjAddVol(virStoragePoolObj *obj,
+ virStorageVolDef *voldef);
void
-virStoragePoolObjRemoveVol(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef);
+virStoragePoolObjRemoveVol(virStoragePoolObj *obj,
+ virStorageVolDef *voldef);
size_t
-virStoragePoolObjGetVolumesCount(virStoragePoolObjPtr obj);
+virStoragePoolObjGetVolumesCount(virStoragePoolObj *obj);
typedef int
-(*virStorageVolObjListIterator)(virStorageVolDefPtr voldef,
+(*virStorageVolObjListIterator)(virStorageVolDef *voldef,
const void *opaque);
int
-virStoragePoolObjForEachVolume(virStoragePoolObjPtr obj,
+virStoragePoolObjForEachVolume(virStoragePoolObj *obj,
virStorageVolObjListIterator iter,
const void *opaque);
typedef bool
-(*virStorageVolObjListSearcher)(virStorageVolDefPtr voldef,
+(*virStorageVolObjListSearcher)(virStorageVolDef *voldef,
const void *opaque);
-virStorageVolDefPtr
-virStoragePoolObjSearchVolume(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStoragePoolObjSearchVolume(virStoragePoolObj *obj,
virStorageVolObjListSearcher iter,
const void *opaque);
-virStorageVolDefPtr
-virStorageVolDefFindByKey(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByKey(virStoragePoolObj *obj,
const char *key);
-virStorageVolDefPtr
-virStorageVolDefFindByPath(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByPath(virStoragePoolObj *obj,
const char *path);
-virStorageVolDefPtr
-virStorageVolDefFindByName(virStoragePoolObjPtr obj,
+virStorageVolDef *
+virStorageVolDefFindByName(virStoragePoolObj *obj,
const char *name);
void
-virStoragePoolObjClearVols(virStoragePoolObjPtr obj);
+virStoragePoolObjClearVols(virStoragePoolObj *obj);
typedef bool
(*virStoragePoolVolumeACLFilter)(virConnectPtr conn,
- virStoragePoolDefPtr pool,
- virStorageVolDefPtr def);
+ virStoragePoolDef *pool,
+ virStorageVolDef *def);
int
-virStoragePoolObjNumOfVolumes(virStoragePoolObjPtr obj,
+virStoragePoolObjNumOfVolumes(virStoragePoolObj *obj,
virConnectPtr conn,
virStoragePoolVolumeACLFilter filter);
int
-virStoragePoolObjVolumeGetNames(virStoragePoolObjPtr obj,
+virStoragePoolObjVolumeGetNames(virStoragePoolObj *obj,
virConnectPtr conn,
virStoragePoolVolumeACLFilter filter,
char **const names,
int
virStoragePoolObjVolumeListExport(virConnectPtr conn,
- virStoragePoolObjPtr obj,
+ virStoragePoolObj *obj,
virStorageVolPtr **vols,
virStoragePoolVolumeACLFilter filter);
VIR_STORAGE_POOL_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1),
} virStoragePoolObjListFlags;
-virStoragePoolObjPtr
-virStoragePoolObjListAdd(virStoragePoolObjListPtr pools,
- virStoragePoolDefPtr def,
+virStoragePoolObj *
+virStoragePoolObjListAdd(virStoragePoolObjList *pools,
+ virStoragePoolDef *def,
unsigned int flags);
int
-virStoragePoolObjSaveDef(virStorageDriverStatePtr driver,
- virStoragePoolObjPtr obj,
- virStoragePoolDefPtr def);
+virStoragePoolObjSaveDef(virStorageDriverState *driver,
+ virStoragePoolObj *obj,
+ virStoragePoolDef *def);
int
-virStoragePoolObjDeleteDef(virStoragePoolObjPtr obj);
+virStoragePoolObjDeleteDef(virStoragePoolObj *obj);
typedef bool (*virStoragePoolObjListACLFilter)(virConnectPtr conn,
- virStoragePoolDefPtr def);
+ virStoragePoolDef *def);
int
-virStoragePoolObjNumOfStoragePools(virStoragePoolObjListPtr pools,
+virStoragePoolObjNumOfStoragePools(virStoragePoolObjList *pools,
virConnectPtr conn,
bool wantActive,
virStoragePoolObjListACLFilter filter);
int
-virStoragePoolObjGetNames(virStoragePoolObjListPtr pools,
+virStoragePoolObjGetNames(virStoragePoolObjList *pools,
virConnectPtr conn,
bool wantActive,
virStoragePoolObjListACLFilter filter,
int maxnames);
void
-virStoragePoolObjFree(virStoragePoolObjPtr obj);
+virStoragePoolObjFree(virStoragePoolObj *obj);
typedef void
-(*virStoragePoolObjListIterator)(virStoragePoolObjPtr obj,
+(*virStoragePoolObjListIterator)(virStoragePoolObj *obj,
const void *opaque);
void
-virStoragePoolObjListForEach(virStoragePoolObjListPtr pools,
+virStoragePoolObjListForEach(virStoragePoolObjList *pools,
virStoragePoolObjListIterator iter,
const void *opaque);
typedef bool
-(*virStoragePoolObjListSearcher)(virStoragePoolObjPtr obj,
+(*virStoragePoolObjListSearcher)(virStoragePoolObj *obj,
const void *opaque);
-virStoragePoolObjPtr
-virStoragePoolObjListSearch(virStoragePoolObjListPtr pools,
+virStoragePoolObj *
+virStoragePoolObjListSearch(virStoragePoolObjList *pools,
virStoragePoolObjListSearcher searcher,
const void *opaque);
-virStoragePoolObjListPtr
+virStoragePoolObjList *
virStoragePoolObjListNew(void);
void
-virStoragePoolObjRemove(virStoragePoolObjListPtr pools,
- virStoragePoolObjPtr obj);
+virStoragePoolObjRemove(virStoragePoolObjList *pools,
+ virStoragePoolObj *obj);
int
virStoragePoolObjListExport(virConnectPtr conn,
- virStoragePoolObjListPtr poolobjs,
+ virStoragePoolObjList *poolobjs,
virStoragePoolPtr **pools,
virStoragePoolObjListFilter filter,
unsigned int flags);
*/
virCPUCompareResult
virCPUCompareXML(virArch arch,
- virCPUDefPtr host,
+ virCPUDef *host,
const char *xml,
bool failIncompatible,
bool validateXML)
*/
virCPUCompareResult
virCPUCompare(virArch arch,
- virCPUDefPtr host,
- virCPUDefPtr cpu,
+ virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible)
{
struct cpuArchDriver *driver;
* Returns 0 on success, -1 on error.
*/
int
-cpuDecode(virCPUDefPtr cpu,
+cpuDecode(virCPUDef *cpu,
const virCPUData *data,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
struct cpuArchDriver *driver;
int
cpuEncode(virArch arch,
const virCPUDef *cpu,
- virCPUDataPtr *forced,
- virCPUDataPtr *required,
- virCPUDataPtr *optional,
- virCPUDataPtr *disabled,
- virCPUDataPtr *forbidden,
- virCPUDataPtr *vendor)
+ virCPUData **forced,
+ virCPUData **required,
+ virCPUData **optional,
+ virCPUData **disabled,
+ virCPUData **forbidden,
+ virCPUData **vendor)
{
struct cpuArchDriver *driver;
*
* Returns an allocated memory for virCPUData or NULL on error.
*/
-virCPUDataPtr
+virCPUData *
virCPUDataNew(virArch arch)
{
- virCPUDataPtr data;
+ virCPUData *data;
data = g_new0(virCPUData, 1);
data->arch = arch;
* Returns nothing.
*/
void
-virCPUDataFree(virCPUDataPtr data)
+virCPUDataFree(virCPUData *data)
{
struct cpuArchDriver *driver;
*
* Returns host CPU definition or NULL on error.
*/
-virCPUDefPtr
+virCPUDef *
virCPUGetHost(virArch arch,
virCPUType type,
virNodeInfoPtr nodeInfo,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
struct cpuArchDriver *driver;
g_autoptr(virCPUDef) cpu = NULL;
}
-virCPUDefPtr
+virCPUDef *
virCPUProbeHost(virArch arch)
{
virNodeInfo nodeinfo;
*
* Returns baseline CPU definition or NULL on error.
*/
-virCPUDefPtr
+virCPUDef *
virCPUBaseline(virArch arch,
- virCPUDefPtr *cpus,
+ virCPUDef **cpus,
unsigned int ncpus,
- virDomainCapsCPUModelsPtr models,
+ virDomainCapsCPUModels *models,
const char **features,
bool migratable)
{
*/
int
virCPUUpdate(virArch arch,
- virCPUDefPtr guest,
+ virCPUDef *guest,
const virCPUDef *host)
{
struct cpuArchDriver *driver;
*/
int
virCPUUpdateLive(virArch arch,
- virCPUDefPtr cpu,
- virCPUDataPtr dataEnabled,
- virCPUDataPtr dataDisabled)
+ virCPUDef *cpu,
+ virCPUData *dataEnabled,
+ virCPUData *dataDisabled)
{
struct cpuArchDriver *driver;
* Returns 0 on success or -1 on error.
*/
int
-virCPUCheckForbiddenFeatures(virCPUDefPtr guest, const virCPUDef *host)
+virCPUCheckForbiddenFeatures(virCPUDef *guest, const virCPUDef *host)
{
size_t i;
for (i = 0; i < guest->nfeatures; ++i) {
- virCPUFeatureDefPtr feature;
+ virCPUFeatureDef *feature;
if (guest->features[i].policy != VIR_CPU_FEATURE_FORBID)
continue;
*
* Returns internal CPU data structure parsed from the XML or NULL on error.
*/
-virCPUDataPtr
+virCPUData *
virCPUDataParse(const char *xmlStr)
{
struct cpuArchDriver *driver;
g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
- virCPUDataPtr data = NULL;
+ virCPUData *data = NULL;
g_autofree char *arch = NULL;
VIR_DEBUG("xmlStr=%s", xmlStr);
*/
bool
virCPUModelIsAllowed(const char *model,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
if (!models)
return true;
*/
int
virCPUTranslate(virArch arch,
- virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+ virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
{
struct cpuArchDriver *driver;
*/
int
virCPUConvertLegacy(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
{
struct cpuArchDriver *driver;
*/
int
virCPUExpandFeatures(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
{
struct cpuArchDriver *driver;
*
* Returns the copy of the CPU or NULL on error.
*/
-virCPUDefPtr
+virCPUDef *
virCPUCopyMigratable(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
{
struct cpuArchDriver *driver;
*/
int
virCPUValidateFeatures(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
{
struct cpuArchDriver *driver;
* Returns 0 on success, -1 on error.
*/
int
-virCPUDataAddFeature(virCPUDataPtr cpuData,
+virCPUDataAddFeature(virCPUData *cpuData,
const char *name)
{
struct cpuArchDriver *driver;
typedef struct _virCPUData virCPUData;
-typedef virCPUData *virCPUDataPtr;
struct _virCPUData {
virArch arch;
union {
typedef virCPUCompareResult
-(*virCPUArchCompare)(virCPUDefPtr host,
- virCPUDefPtr cpu,
+(*virCPUArchCompare)(virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible);
typedef int
-(*cpuArchDecode) (virCPUDefPtr cpu,
+(*cpuArchDecode) (virCPUDef *cpu,
const virCPUData *data,
- virDomainCapsCPUModelsPtr models);
+ virDomainCapsCPUModels *models);
typedef int
(*cpuArchEncode) (virArch arch,
const virCPUDef *cpu,
- virCPUDataPtr *forced,
- virCPUDataPtr *required,
- virCPUDataPtr *optional,
- virCPUDataPtr *disabled,
- virCPUDataPtr *forbidden,
- virCPUDataPtr *vendor);
+ virCPUData **forced,
+ virCPUData **required,
+ virCPUData **optional,
+ virCPUData **disabled,
+ virCPUData **forbidden,
+ virCPUData **vendor);
typedef void
-(*cpuArchDataFree) (virCPUDataPtr data);
+(*cpuArchDataFree) (virCPUData *data);
typedef int
-(*virCPUArchGetHost)(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models);
+(*virCPUArchGetHost)(virCPUDef *cpu,
+ virDomainCapsCPUModels *models);
-typedef virCPUDefPtr
-(*virCPUArchBaseline)(virCPUDefPtr *cpus,
+typedef virCPUDef *
+(*virCPUArchBaseline)(virCPUDef **cpus,
unsigned int ncpus,
- virDomainCapsCPUModelsPtr models,
+ virDomainCapsCPUModels *models,
const char **features,
bool migratable);
typedef int
-(*virCPUArchUpdate)(virCPUDefPtr guest,
+(*virCPUArchUpdate)(virCPUDef *guest,
const virCPUDef *host,
bool relative);
typedef int
-(*virCPUArchUpdateLive)(virCPUDefPtr cpu,
- virCPUDataPtr dataEnabled,
- virCPUDataPtr dataDisabled);
+(*virCPUArchUpdateLive)(virCPUDef *cpu,
+ virCPUData *dataEnabled,
+ virCPUData *dataDisabled);
typedef int
(*virCPUArchCheckFeature)(const virCPUDef *cpu,
typedef char *
(*virCPUArchDataFormat)(const virCPUData *data);
-typedef virCPUDataPtr
+typedef virCPUData *
(*virCPUArchDataParse)(xmlXPathContextPtr ctxt);
typedef int
(*virCPUArchGetModels)(char ***models);
typedef int
-(*virCPUArchTranslate)(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models);
+(*virCPUArchTranslate)(virCPUDef *cpu,
+ virDomainCapsCPUModels *models);
typedef int
-(*virCPUArchConvertLegacy)(virCPUDefPtr cpu);
+(*virCPUArchConvertLegacy)(virCPUDef *cpu);
typedef int
-(*virCPUArchExpandFeatures)(virCPUDefPtr cpu);
+(*virCPUArchExpandFeatures)(virCPUDef *cpu);
-typedef virCPUDefPtr
-(*virCPUArchCopyMigratable)(virCPUDefPtr cpu);
+typedef virCPUDef *
+(*virCPUArchCopyMigratable)(virCPUDef *cpu);
typedef int
-(*virCPUArchValidateFeatures)(virCPUDefPtr cpu);
+(*virCPUArchValidateFeatures)(virCPUDef *cpu);
typedef int
-(*virCPUArchDataAddFeature)(virCPUDataPtr cpuData,
+(*virCPUArchDataAddFeature)(virCPUData *cpuData,
const char *name);
struct cpuArchDriver {
virCPUCompareResult
virCPUCompareXML(virArch arch,
- virCPUDefPtr host,
+ virCPUDef *host,
const char *xml,
bool failIncompatible,
bool validateXML);
virCPUCompareResult
virCPUCompare(virArch arch,
- virCPUDefPtr host,
- virCPUDefPtr cpu,
+ virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible)
ATTRIBUTE_NONNULL(3);
int
-cpuDecode (virCPUDefPtr cpu,
+cpuDecode (virCPUDef *cpu,
const virCPUData *data,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
cpuEncode (virArch arch,
const virCPUDef *cpu,
- virCPUDataPtr *forced,
- virCPUDataPtr *required,
- virCPUDataPtr *optional,
- virCPUDataPtr *disabled,
- virCPUDataPtr *forbidden,
- virCPUDataPtr *vendor)
+ virCPUData **forced,
+ virCPUData **required,
+ virCPUData **optional,
+ virCPUData **disabled,
+ virCPUData **forbidden,
+ virCPUData **vendor)
ATTRIBUTE_NONNULL(2);
-virCPUDataPtr
+virCPUData *
virCPUDataNew(virArch arch);
void
-virCPUDataFree(virCPUDataPtr data);
+virCPUDataFree(virCPUData *data);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUData, virCPUDataFree);
bool
virCPUGetHostIsSupported(virArch arch);
-virCPUDefPtr
+virCPUDef *
virCPUGetHost(virArch arch,
virCPUType type,
virNodeInfoPtr nodeInfo,
- virDomainCapsCPUModelsPtr models);
+ virDomainCapsCPUModels *models);
-virCPUDefPtr
+virCPUDef *
virCPUProbeHost(virArch arch) G_GNUC_NO_INLINE;
-virCPUDefPtr
+virCPUDef *
virCPUBaseline(virArch arch,
- virCPUDefPtr *cpus,
+ virCPUDef **cpus,
unsigned int ncpus,
- virDomainCapsCPUModelsPtr models,
+ virDomainCapsCPUModels *models,
const char **features,
bool migratable);
int
virCPUUpdate(virArch arch,
- virCPUDefPtr guest,
+ virCPUDef *guest,
const virCPUDef *host)
ATTRIBUTE_NONNULL(2);
int
virCPUUpdateLive(virArch arch,
- virCPUDefPtr cpu,
- virCPUDataPtr dataEnabled,
- virCPUDataPtr dataDisabled)
+ virCPUDef *cpu,
+ virCPUData *dataEnabled,
+ virCPUData *dataDisabled)
ATTRIBUTE_NONNULL(2);
int
int
-virCPUCheckForbiddenFeatures(virCPUDefPtr guest,
+virCPUCheckForbiddenFeatures(virCPUDef *guest,
const virCPUDef *host)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
bool
virCPUModelIsAllowed(const char *model,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
ATTRIBUTE_NONNULL(1);
int
int
virCPUTranslate(virArch arch,
- virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+ virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
ATTRIBUTE_NONNULL(2);
int
virCPUConvertLegacy(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
ATTRIBUTE_NONNULL(2);
int
virCPUExpandFeatures(virArch arch,
- virCPUDefPtr cpu);
+ virCPUDef *cpu);
-virCPUDefPtr
+virCPUDef *
virCPUCopyMigratable(virArch arch,
- virCPUDefPtr cpu);
+ virCPUDef *cpu);
int
virCPUValidateFeatures(virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
ATTRIBUTE_NONNULL(2);
int
-virCPUDataAddFeature(virCPUDataPtr cpuData,
+virCPUDataAddFeature(virCPUData *cpuData,
const char *name);
bool
*/
char *virCPUDataFormat(const virCPUData *data)
ATTRIBUTE_NONNULL(1);
-virCPUDataPtr virCPUDataParse(const char *xmlStr)
+virCPUData *virCPUDataParse(const char *xmlStr)
ATTRIBUTE_NONNULL(1);
};
typedef struct _virCPUarmVendor virCPUarmVendor;
-typedef virCPUarmVendor *virCPUarmVendorPtr;
struct _virCPUarmVendor {
char *name;
unsigned long value;
};
typedef struct _virCPUarmModel virCPUarmModel;
-typedef virCPUarmModel *virCPUarmModelPtr;
struct _virCPUarmModel {
char *name;
- virCPUarmVendorPtr vendor;
+ virCPUarmVendor *vendor;
virCPUarmData data;
};
typedef struct _virCPUarmFeature virCPUarmFeature;
-typedef virCPUarmFeature *virCPUarmFeaturePtr;
struct _virCPUarmFeature {
char *name;
};
-static virCPUarmFeaturePtr
+static virCPUarmFeature *
virCPUarmFeatureNew(void)
{
return g_new0(virCPUarmFeature, 1);
}
static void
-virCPUarmFeatureFree(virCPUarmFeaturePtr feature)
+virCPUarmFeatureFree(virCPUarmFeature *feature)
{
if (!feature)
return;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUarmFeature, virCPUarmFeatureFree);
typedef struct _virCPUarmMap virCPUarmMap;
-typedef virCPUarmMap *virCPUarmMapPtr;
struct _virCPUarmMap {
size_t nvendors;
- virCPUarmVendorPtr *vendors;
+ virCPUarmVendor **vendors;
size_t nmodels;
- virCPUarmModelPtr *models;
+ virCPUarmModel **models;
GPtrArray *features;
};
-static virCPUarmMapPtr
+static virCPUarmMap *
virCPUarmMapNew(void)
{
- virCPUarmMapPtr map;
+ virCPUarmMap *map;
map = g_new0(virCPUarmMap, 1);
}
static void
-virCPUarmDataFree(virCPUDataPtr cpuData)
+virCPUarmDataFree(virCPUData *cpuData)
{
if (!cpuData)
return;
}
static void
-virCPUarmModelFree(virCPUarmModelPtr model)
+virCPUarmModelFree(virCPUarmModel *model)
{
if (!model)
return;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUarmModel, virCPUarmModelFree);
static void
-virCPUarmVendorFree(virCPUarmVendorPtr vendor)
+virCPUarmVendorFree(virCPUarmVendor *vendor)
{
if (!vendor)
return;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUarmVendor, virCPUarmVendorFree);
static void
-virCPUarmMapFree(virCPUarmMapPtr map)
+virCPUarmMapFree(virCPUarmMap *map)
{
size_t i;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUarmMap, virCPUarmMapFree);
-static virCPUarmFeaturePtr
-virCPUarmMapFeatureFind(virCPUarmMapPtr map,
+static virCPUarmFeature *
+virCPUarmMapFeatureFind(virCPUarmMap *map,
const char *name)
{
size_t i;
for (i = 0; i < map->features->len; i++) {
- virCPUarmFeaturePtr feature = g_ptr_array_index(map->features, i);
+ virCPUarmFeature *feature = g_ptr_array_index(map->features, i);
if (STREQ(feature->name, name))
return feature;
void *data)
{
g_autoptr(virCPUarmFeature) feature = NULL;
- virCPUarmMapPtr map = data;
+ virCPUarmMap *map = data;
if (virCPUarmMapFeatureFind(map, name)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return 0;
}
-static virCPUarmVendorPtr
-virCPUarmVendorFindByID(virCPUarmMapPtr map,
+static virCPUarmVendor *
+virCPUarmVendorFindByID(virCPUarmMap *map,
unsigned long vendor_id)
{
size_t i;
}
-static virCPUarmVendorPtr
-virCPUarmVendorFindByName(virCPUarmMapPtr map,
+static virCPUarmVendor *
+virCPUarmVendorFindByName(virCPUarmMap *map,
const char *name)
{
size_t i;
const char *name,
void *data)
{
- virCPUarmMapPtr map = data;
+ virCPUarmMap *map = data;
g_autoptr(virCPUarmVendor) vendor = NULL;
vendor = g_new0(virCPUarmVendor, 1);
return 0;
}
-static virCPUarmModelPtr
-virCPUarmModelFind(virCPUarmMapPtr map,
+static virCPUarmModel *
+virCPUarmModelFind(virCPUarmMap *map,
const char *name)
{
size_t i;
}
#if defined(__aarch64__)
-static virCPUarmModelPtr
-virCPUarmModelFindByPVR(virCPUarmMapPtr map,
+static virCPUarmModel *
+virCPUarmModelFindByPVR(virCPUarmMap *map,
unsigned long pvr)
{
size_t i;
const char *name,
void *data)
{
- virCPUarmMapPtr map = data;
+ virCPUarmMap *map = data;
g_autoptr(virCPUarmModel) model = NULL;
g_autofree char *vendor = NULL;
return 0;
}
-static virCPUarmMapPtr
+static virCPUarmMap *
virCPUarmLoadMap(void)
{
g_autoptr(virCPUarmMap) map = NULL;
return g_steal_pointer(&map);
}
-static virCPUarmMapPtr cpuMap;
+static virCPUarmMap *cpuMap;
int virCPUarmDriverOnceInit(void);
VIR_ONCE_GLOBAL_INIT(virCPUarmDriver);
return 0;
}
-static virCPUarmMapPtr
+static virCPUarmMap *
virCPUarmGetMap(void)
{
if (virCPUarmDriverInitialize() < 0)
}
static int
-virCPUarmUpdate(virCPUDefPtr guest,
+virCPUarmUpdate(virCPUDef *guest,
const virCPUDef *host,
bool relative)
{
}
-static virCPUDefPtr
-virCPUarmBaseline(virCPUDefPtr *cpus,
+static virCPUDef *
+virCPUarmBaseline(virCPUDef **cpus,
unsigned int ncpus G_GNUC_UNUSED,
- virDomainCapsCPUModelsPtr models G_GNUC_UNUSED,
+ virDomainCapsCPUModels *models G_GNUC_UNUSED,
const char **features G_GNUC_UNUSED,
bool migratable G_GNUC_UNUSED)
{
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
cpu = virCPUDefNew();
}
static virCPUCompareResult
-virCPUarmCompare(virCPUDefPtr host,
- virCPUDefPtr cpu,
+virCPUarmCompare(virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible)
{
/* Only support host to host CPU compare for ARM */
}
static int
-virCPUarmValidateFeatures(virCPUDefPtr cpu)
+virCPUarmValidateFeatures(virCPUDef *cpu)
{
- virCPUarmMapPtr map;
+ virCPUarmMap *map;
size_t i;
if (!(map = virCPUarmGetMap()))
return -1;
for (i = 0; i < cpu->nfeatures; i++) {
- virCPUFeatureDefPtr feature = &cpu->features[i];
+ virCPUFeatureDef *feature = &cpu->features[i];
if (!virCPUarmMapFeatureFind(map, feature->name)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
static int
-virCPUarmDecode(virCPUDefPtr cpu,
+virCPUarmDecode(virCPUDef *cpu,
const virCPUarmData *cpuData,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
size_t i;
- virCPUarmMapPtr map;
- virCPUarmModelPtr model;
- virCPUarmVendorPtr vendor = NULL;
+ virCPUarmMap *map;
+ virCPUarmModel *model;
+ virCPUarmVendor *vendor = NULL;
if (!cpuData || !(map = virCPUarmGetMap()))
return -1;
}
static int
-virCPUarmGetHost(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+virCPUarmGetHost(virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
{
g_autoptr(virCPUData) cpuData = NULL;
static const virArch archs[] = { VIR_ARCH_PPC64, VIR_ARCH_PPC64LE };
typedef struct _ppc64_vendor virCPUppc64Vendor;
-typedef struct _ppc64_vendor *virCPUppc64VendorPtr;
struct _ppc64_vendor {
char *name;
};
typedef struct _ppc64_model virCPUppc64Model;
-typedef struct _ppc64_model *virCPUppc64ModelPtr;
struct _ppc64_model {
char *name;
const virCPUppc64Vendor *vendor;
};
typedef struct _ppc64_map virCPUppc64Map;
-typedef struct _ppc64_map *virCPUppc64MapPtr;
struct _ppc64_map {
size_t nvendors;
- virCPUppc64VendorPtr *vendors;
+ struct _ppc64_vendor **vendors;
size_t nmodels;
- virCPUppc64ModelPtr *models;
+ struct _ppc64_model **models;
};
/* Convert a legacy CPU definition by transforming
* POWER7+_v2.1 => POWER7
* POWER8_v1.0 => POWER8 */
static int
-virCPUppc64ConvertLegacy(virCPUDefPtr cpu)
+virCPUppc64ConvertLegacy(virCPUDef *cpu)
{
if (cpu->model &&
(STREQ(cpu->model, "POWER7_v2.1") ||
}
static void
-ppc64VendorFree(virCPUppc64VendorPtr vendor)
+ppc64VendorFree(struct _ppc64_vendor *vendor)
{
if (!vendor)
return;
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUppc64Vendor, ppc64VendorFree);
-static virCPUppc64VendorPtr
+static struct _ppc64_vendor *
ppc64VendorFind(const virCPUppc64Map *map,
const char *name)
{
}
static void
-ppc64ModelFree(virCPUppc64ModelPtr model)
+ppc64ModelFree(struct _ppc64_model *model)
{
if (!model)
return;
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUppc64Model, ppc64ModelFree);
-static virCPUppc64ModelPtr
+static struct _ppc64_model *
ppc64ModelCopy(const virCPUppc64Model *model)
{
g_autoptr(virCPUppc64Model) copy = NULL;
return g_steal_pointer(©);
}
-static virCPUppc64ModelPtr
+static struct _ppc64_model *
ppc64ModelFind(const virCPUppc64Map *map,
const char *name)
{
return NULL;
}
-static virCPUppc64ModelPtr
+static struct _ppc64_model *
ppc64ModelFindPVR(const virCPUppc64Map *map,
uint32_t pvr)
{
size_t j;
for (i = 0; i < map->nmodels; i++) {
- virCPUppc64ModelPtr model = map->models[i];
+ struct _ppc64_model *model = map->models[i];
for (j = 0; j < model->data.len; j++) {
if ((pvr & model->data.pvr[j].mask) == model->data.pvr[j].value)
return model;
return NULL;
}
-static virCPUppc64ModelPtr
+static struct _ppc64_model *
ppc64ModelFromCPU(const virCPUDef *cpu,
const virCPUppc64Map *map)
{
- virCPUppc64ModelPtr model;
+ struct _ppc64_model *model;
if (!cpu->model) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
}
static void
-ppc64MapFree(virCPUppc64MapPtr map)
+ppc64MapFree(struct _ppc64_map *map)
{
size_t i;
const char *name,
void *data)
{
- virCPUppc64MapPtr map = data;
+ struct _ppc64_map *map = data;
g_autoptr(virCPUppc64Vendor) vendor = NULL;
vendor = g_new0(virCPUppc64Vendor, 1);
const char *name,
void *data)
{
- virCPUppc64MapPtr map = data;
+ struct _ppc64_map *map = data;
g_autoptr(virCPUppc64Model) model = NULL;
g_autofree xmlNodePtr *nodes = NULL;
g_autofree char *vendor = NULL;
}
-static virCPUppc64MapPtr
+static struct _ppc64_map *
ppc64LoadMap(void)
{
g_autoptr(virCPUppc64Map) map = NULL;
return g_steal_pointer(&map);
}
-static virCPUDataPtr
+static virCPUData *
ppc64MakeCPUData(virArch arch,
virCPUppc64Data *data)
{
}
static virCPUCompareResult
-ppc64Compute(virCPUDefPtr host,
+ppc64Compute(virCPUDef *host,
const virCPUDef *other,
- virCPUDataPtr *guestData,
+ virCPUData **guestData,
char **message)
{
g_autoptr(virCPUppc64Map) map = NULL;
}
static virCPUCompareResult
-virCPUppc64Compare(virCPUDefPtr host,
- virCPUDefPtr cpu,
+virCPUppc64Compare(virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible)
{
virCPUCompareResult ret;
}
static int
-ppc64DriverDecode(virCPUDefPtr cpu,
+ppc64DriverDecode(virCPUDef *cpu,
const virCPUData *data,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
g_autoptr(virCPUppc64Map) map = NULL;
const virCPUppc64Model *model;
}
static void
-virCPUppc64DataFree(virCPUDataPtr data)
+virCPUppc64DataFree(virCPUData *data)
{
if (!data)
return;
static int
-virCPUppc64GetHost(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+virCPUppc64GetHost(virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
{
g_autoptr(virCPUData) cpuData = NULL;
virCPUppc64Data *data;
static int
-virCPUppc64Update(virCPUDefPtr guest,
+virCPUppc64Update(virCPUDef *guest,
const virCPUDef *host G_GNUC_UNUSED,
bool relative G_GNUC_UNUSED)
{
return 0;
}
-static virCPUDefPtr
-virCPUppc64Baseline(virCPUDefPtr *cpus,
+static virCPUDef *
+virCPUppc64Baseline(virCPUDef **cpus,
unsigned int ncpus,
- virDomainCapsCPUModelsPtr models G_GNUC_UNUSED,
+ virDomainCapsCPUModels *models G_GNUC_UNUSED,
const char **features G_GNUC_UNUSED,
bool migratable G_GNUC_UNUSED)
{
static const virArch archs[] = { VIR_ARCH_S390, VIR_ARCH_S390X };
static virCPUCompareResult
-virCPUs390Compare(virCPUDefPtr host G_GNUC_UNUSED,
- virCPUDefPtr cpu G_GNUC_UNUSED,
+virCPUs390Compare(virCPUDef *host G_GNUC_UNUSED,
+ virCPUDef *cpu G_GNUC_UNUSED,
bool failMessages G_GNUC_UNUSED)
{
/* s390 relies on QEMU to perform all runability checking. Return
}
static int
-virCPUs390Update(virCPUDefPtr guest,
+virCPUs390Update(virCPUDef *guest,
const virCPUDef *host,
bool relative)
{
static int
-virCPUs390ValidateFeatures(virCPUDefPtr cpu)
+virCPUs390ValidateFeatures(virCPUDef *cpu)
{
size_t i;
static const virArch archs[] = { VIR_ARCH_I686, VIR_ARCH_X86_64 };
typedef struct _virCPUx86Vendor virCPUx86Vendor;
-typedef virCPUx86Vendor *virCPUx86VendorPtr;
struct _virCPUx86Vendor {
char *name;
virCPUx86DataItem data;
};
typedef struct _virCPUx86Feature virCPUx86Feature;
-typedef virCPUx86Feature *virCPUx86FeaturePtr;
struct _virCPUx86Feature {
char *name;
virCPUx86Data data;
struct _virCPUx86Signature {
unsigned int family;
unsigned int model;
- virBitmapPtr stepping;
+ virBitmap *stepping;
};
typedef struct _virCPUx86Signatures virCPUx86Signatures;
-typedef virCPUx86Signatures *virCPUx86SignaturesPtr;
struct _virCPUx86Signatures {
size_t count;
virCPUx86Signature *items;
};
typedef struct _virCPUx86Model virCPUx86Model;
-typedef virCPUx86Model *virCPUx86ModelPtr;
struct _virCPUx86Model {
char *name;
bool decodeHost;
bool decodeGuest;
- virCPUx86VendorPtr vendor;
- virCPUx86SignaturesPtr signatures;
+ virCPUx86Vendor *vendor;
+ virCPUx86Signatures *signatures;
virCPUx86Data data;
GStrv removedFeatures;
};
typedef struct _virCPUx86Map virCPUx86Map;
-typedef virCPUx86Map *virCPUx86MapPtr;
struct _virCPUx86Map {
size_t nvendors;
- virCPUx86VendorPtr *vendors;
+ virCPUx86Vendor **vendors;
size_t nfeatures;
- virCPUx86FeaturePtr *features;
+ virCPUx86Feature **features;
size_t nmodels;
- virCPUx86ModelPtr *models;
+ virCPUx86Model **models;
size_t nblockers;
- virCPUx86FeaturePtr *migrate_blockers;
+ virCPUx86Feature **migrate_blockers;
};
-static virCPUx86MapPtr cpuMap;
+static virCPUx86Map *cpuMap;
int virCPUx86DriverOnceInit(void);
VIR_ONCE_GLOBAL_INIT(virCPUx86Driver);
typedef struct _virCPUx86DataIterator virCPUx86DataIterator;
-typedef virCPUx86DataIterator *virCPUx86DataIteratorPtr;
struct _virCPUx86DataIterator {
const virCPUx86Data *data;
int pos;
static void
-virCPUx86DataIteratorInit(virCPUx86DataIteratorPtr iterator,
+virCPUx86DataIteratorInit(virCPUx86DataIterator *iterator,
const virCPUx86Data *data)
{
virCPUx86DataIterator iter = { data, -1 };
static void
-virCPUx86DataItemSetBits(virCPUx86DataItemPtr item,
+virCPUx86DataItemSetBits(virCPUx86DataItem *item,
const virCPUx86DataItem *mask)
{
- virCPUx86CPUIDPtr cpuid;
+ virCPUx86CPUID *cpuid;
const virCPUx86CPUID *cpuidMask;
- virCPUx86MSRPtr msr;
+ virCPUx86MSR *msr;
const virCPUx86MSR *msrMask;
if (!mask)
static void
-virCPUx86DataItemClearBits(virCPUx86DataItemPtr item,
+virCPUx86DataItemClearBits(virCPUx86DataItem *item,
const virCPUx86DataItem *mask)
{
- virCPUx86CPUIDPtr cpuid;
+ virCPUx86CPUID *cpuid;
const virCPUx86CPUID *cpuidMask;
- virCPUx86MSRPtr msr;
+ virCPUx86MSR *msr;
const virCPUx86MSR *msrMask;
if (!mask)
static void
-virCPUx86DataItemAndBits(virCPUx86DataItemPtr item,
+virCPUx86DataItemAndBits(virCPUx86DataItem *item,
const virCPUx86DataItem *mask)
{
- virCPUx86CPUIDPtr cpuid;
+ virCPUx86CPUID *cpuid;
const virCPUx86CPUID *cpuidMask;
- virCPUx86MSRPtr msr;
+ virCPUx86MSR *msr;
const virCPUx86MSR *msrMask;
if (!mask)
}
-static virCPUx86FeaturePtr
-x86FeatureFind(virCPUx86MapPtr map,
+static virCPUx86Feature *
+x86FeatureFind(virCPUx86Map *map,
const char *name)
{
size_t i;
}
-static virCPUx86FeaturePtr
+static virCPUx86Feature *
x86FeatureFindInternal(const char *name)
{
size_t i;
static int
virCPUx86DataSorter(const void *a, const void *b)
{
- virCPUx86DataItemPtr da = (virCPUx86DataItemPtr) a;
- virCPUx86DataItemPtr db = (virCPUx86DataItemPtr) b;
+ virCPUx86DataItem *da = (virCPUx86DataItem *) a;
+ virCPUx86DataItem *db = (virCPUx86DataItem *) b;
if (da->type > db->type)
return 1;
/* skips all zero CPUID leaves */
-static virCPUx86DataItemPtr
-virCPUx86DataNext(virCPUx86DataIteratorPtr iterator)
+static virCPUx86DataItem *
+virCPUx86DataNext(virCPUx86DataIterator *iterator)
{
const virCPUx86Data *data = iterator->data;
virCPUx86DataItem zero = { 0 };
return NULL;
while (++iterator->pos < data->len) {
- virCPUx86DataItemPtr item = data->items + iterator->pos;
+ virCPUx86DataItem *item = data->items + iterator->pos;
if (!virCPUx86DataItemMatch(item, &zero))
return item;
}
-static virCPUx86DataItemPtr
+static virCPUx86DataItem *
virCPUx86DataGet(const virCPUx86Data *data,
const virCPUx86DataItem *item)
{
size_t i;
for (i = 0; i < data->len; i++) {
- virCPUx86DataItemPtr di = data->items + i;
+ virCPUx86DataItem *di = data->items + i;
if (virCPUx86DataItemCmp(di, item) == 0)
return di;
}
static void
-virCPUx86DataFree(virCPUDataPtr data)
+virCPUx86DataFree(virCPUData *data)
{
if (!data)
return;
virCPUx86DataAddItem(virCPUx86Data *data,
const virCPUx86DataItem *item)
{
- virCPUx86DataItemPtr existing;
+ virCPUx86DataItem *existing;
if ((existing = virCPUx86DataGet(data, item))) {
virCPUx86DataItemSetBits(existing, item);
} else {
if (VIR_APPEND_ELEMENT_COPY(data->items, data->len,
- *((virCPUx86DataItemPtr)item)) < 0)
+ *((virCPUx86DataItem *)item)) < 0)
return -1;
qsort(data->items, data->len,
const virCPUx86Data *data2)
{
virCPUx86DataIterator iter;
- virCPUx86DataItemPtr item;
+ virCPUx86DataItem *item;
virCPUx86DataIteratorInit(&iter, data2);
while ((item = virCPUx86DataNext(&iter))) {
const virCPUx86Data *data2)
{
virCPUx86DataIterator iter;
- virCPUx86DataItemPtr item1;
- virCPUx86DataItemPtr item2;
+ virCPUx86DataItem *item1;
+ virCPUx86DataItem *item2;
virCPUx86DataIteratorInit(&iter, data1);
while ((item1 = virCPUx86DataNext(&iter))) {
const virCPUx86Data *data2)
{
virCPUx86DataIterator iter;
- virCPUx86DataItemPtr item1;
- virCPUx86DataItemPtr item2;
+ virCPUx86DataItem *item1;
+ virCPUx86DataItem *item2;
virCPUx86DataIteratorInit(&iter, data1);
while ((item1 = virCPUx86DataNext(&iter))) {
/* also removes all detected features from data */
static int
-x86DataToCPUFeatures(virCPUDefPtr cpu,
+x86DataToCPUFeatures(virCPUDef *cpu,
int policy,
virCPUx86Data *data,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
size_t i;
for (i = 0; i < map->nfeatures; i++) {
- virCPUx86FeaturePtr feature = map->features[i];
+ virCPUx86Feature *feature = map->features[i];
if (x86DataIsSubset(data, &feature->data)) {
x86DataSubtract(data, &feature->data);
if (virCPUDefAddFeature(cpu, feature->name, policy) < 0)
/* also removes bits corresponding to vendor string from data */
-static virCPUx86VendorPtr
+static virCPUx86Vendor *
x86DataToVendor(const virCPUx86Data *data,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
- virCPUx86DataItemPtr item;
+ virCPUx86DataItem *item;
size_t i;
for (i = 0; i < map->nvendors; i++) {
- virCPUx86VendorPtr vendor = map->vendors[i];
+ virCPUx86Vendor *vendor = map->vendors[i];
if ((item = virCPUx86DataGet(data, &vendor->data)) &&
virCPUx86DataItemMatchMasked(item, &vendor->data)) {
virCPUx86DataItemClearBits(item, &vendor->data);
static int
virCPUx86VendorToData(const char *vendor,
- virCPUx86DataItemPtr item)
+ virCPUx86DataItem *item)
{
- virCPUx86CPUIDPtr cpuid;
+ virCPUx86CPUID *cpuid;
if (strlen(vendor) != VENDOR_STRING_LENGTH) {
virReportError(VIR_ERR_INTERNAL_ERROR,
unsigned int *stepping)
{
virCPUx86DataItem leaf1 = CPUID(.eax_in = 0x1);
- virCPUx86DataItemPtr item;
+ virCPUx86DataItem *item;
*family = *model = *stepping = 0;
x86DataToSignature(const virCPUx86Data *data)
{
virCPUx86DataItem leaf1 = CPUID(.eax_in = 0x1);
- virCPUx86DataItemPtr item;
+ virCPUx86DataItem *item;
if (!(item = virCPUx86DataGet(data, &leaf1)))
return 0;
* listed in the CPU definition.
*/
static int
-virCPUx86DisableRemovedFeatures(virCPUDefPtr cpu,
- virCPUx86ModelPtr model)
+virCPUx86DisableRemovedFeatures(virCPUDef *cpu,
+ virCPUx86Model *model)
{
char **feat = model->removedFeatures;
}
-static virCPUDefPtr
+static virCPUDef *
x86DataToCPU(const virCPUx86Data *data,
- virCPUx86ModelPtr model,
- virCPUx86MapPtr map,
- virDomainCapsCPUModelPtr hvModel,
+ virCPUx86Model *model,
+ virCPUx86Map *map,
+ virDomainCapsCPUModel *hvModel,
virCPUType cpuType)
{
g_autoptr(virCPUDef) cpu = NULL;
g_auto(virCPUx86Data) copy = VIR_CPU_X86_DATA_INIT;
g_auto(virCPUx86Data) modelData = VIR_CPU_X86_DATA_INIT;
- virCPUx86VendorPtr vendor;
+ virCPUx86Vendor *vendor;
cpu = virCPUDefNew();
*/
if (hvModel && hvModel->blockers) {
char **blocker;
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
for (blocker = hvModel->blockers; *blocker; blocker++) {
if ((feature = x86FeatureFind(map, *blocker)) &&
static void
-x86VendorFree(virCPUx86VendorPtr vendor)
+x86VendorFree(virCPUx86Vendor *vendor)
{
if (!vendor)
return;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUx86Vendor, x86VendorFree);
-static virCPUx86VendorPtr
-x86VendorFind(virCPUx86MapPtr map,
+static virCPUx86Vendor *
+x86VendorFind(virCPUx86Map *map,
const char *name)
{
size_t i;
const char *name,
void *data)
{
- virCPUx86MapPtr map = data;
+ virCPUx86Map *map = data;
g_autoptr(virCPUx86Vendor) vendor = NULL;
g_autofree char *string = NULL;
static void
-x86FeatureFree(virCPUx86FeaturePtr feature)
+x86FeatureFree(virCPUx86Feature *feature)
{
if (!feature)
return;
static int
x86FeatureInData(const char *name,
const virCPUx86Data *data,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
if (!(feature = x86FeatureFind(map, name)) &&
!(feature = x86FeatureFindInternal(name))) {
x86FeatureIsMigratable(const char *name,
void *cpu_map)
{
- virCPUx86MapPtr map = cpu_map;
+ virCPUx86Map *map = cpu_map;
size_t i;
for (i = 0; i < map->nblockers; i++) {
static char *
-x86FeatureNames(virCPUx86MapPtr map,
+x86FeatureNames(virCPUx86Map *map,
const char *separator,
virCPUx86Data *data)
{
virBufferAdd(&ret, "", 0);
for (i = 0; i < map->nfeatures; i++) {
- virCPUx86FeaturePtr feature = map->features[i];
+ virCPUx86Feature *feature = map->features[i];
if (x86DataIsSubset(data, &feature->data)) {
if (!first)
virBufferAdd(&ret, separator, -1);
static int
x86ParseCPUID(xmlXPathContextPtr ctxt,
- virCPUx86DataItemPtr item)
+ virCPUx86DataItem *item)
{
- virCPUx86CPUIDPtr cpuid;
+ virCPUx86CPUID *cpuid;
unsigned long eax_in, ecx_in;
unsigned long eax, ebx, ecx, edx;
int ret_eax_in, ret_ecx_in, ret_eax, ret_ebx, ret_ecx, ret_edx;
static int
x86ParseMSR(xmlXPathContextPtr ctxt,
- virCPUx86DataItemPtr item)
+ virCPUx86DataItem *item)
{
- virCPUx86MSRPtr msr;
+ virCPUx86MSR *msr;
unsigned long index;
unsigned long eax;
unsigned long edx;
const char *name,
void *data)
{
- virCPUx86MapPtr map = data;
+ virCPUx86Map *map = data;
g_autofree xmlNodePtr *nodes = NULL;
g_autoptr(virCPUx86Feature) feature = NULL;
virCPUx86DataItem item;
}
-static virCPUx86SignaturesPtr
+static virCPUx86Signatures *
virCPUx86SignaturesNew(size_t count)
{
- virCPUx86SignaturesPtr sigs;
+ virCPUx86Signatures *sigs;
sigs = g_new0(virCPUx86Signatures, 1);
sigs->items = g_new0(virCPUx86Signature, count);
static void
-virCPUx86SignaturesFree(virCPUx86SignaturesPtr sigs)
+virCPUx86SignaturesFree(virCPUx86Signatures *sigs)
{
size_t i;
}
-static virCPUx86SignaturesPtr
-virCPUx86SignaturesCopy(virCPUx86SignaturesPtr src)
+static virCPUx86Signatures *
+virCPUx86SignaturesCopy(virCPUx86Signatures *src)
{
- virCPUx86SignaturesPtr dst;
+ virCPUx86Signatures *dst;
size_t i;
if (!src || src->count == 0)
static bool
-virCPUx86SignaturesMatch(virCPUx86SignaturesPtr sigs,
+virCPUx86SignaturesMatch(virCPUx86Signatures *sigs,
uint32_t signature)
{
size_t i;
static char *
-virCPUx86SignaturesFormat(virCPUx86SignaturesPtr sigs)
+virCPUx86SignaturesFormat(virCPUx86Signatures *sigs)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
static void
-x86ModelFree(virCPUx86ModelPtr model)
+x86ModelFree(virCPUx86Model *model)
{
if (!model)
return;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUx86Model, x86ModelFree);
-static virCPUx86ModelPtr
-x86ModelCopy(virCPUx86ModelPtr model)
+static virCPUx86Model *
+x86ModelCopy(virCPUx86Model *model)
{
- virCPUx86ModelPtr copy;
+ virCPUx86Model *copy;
copy = g_new0(virCPUx86Model, 1);
copy->name = g_strdup(model->name);
}
-static virCPUx86ModelPtr
-x86ModelFind(virCPUx86MapPtr map,
+static virCPUx86Model *
+x86ModelFind(virCPUx86Map *map,
const char *name)
{
size_t i;
* + required and forced features
* - disabled and forbidden features
*/
-static virCPUx86ModelPtr
+static virCPUx86Model *
x86ModelFromCPU(const virCPUDef *cpu,
- virCPUx86MapPtr map,
+ virCPUx86Map *map,
int policy)
{
g_autoptr(virCPUx86Model) model = NULL;
}
for (i = 0; i < cpu->nfeatures; i++) {
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
virCPUFeaturePolicy fpol;
if (cpu->features[i].policy == -1)
static virCPUx86CompareResult
-x86ModelCompare(virCPUx86ModelPtr model1,
- virCPUx86ModelPtr model2)
+x86ModelCompare(virCPUx86Model *model1,
+ virCPUx86Model *model2)
{
virCPUx86CompareResult result = EQUAL;
virCPUx86DataIterator iter1;
virCPUx86DataIterator iter2;
- virCPUx86DataItemPtr item1;
- virCPUx86DataItemPtr item2;
+ virCPUx86DataItem *item1;
+ virCPUx86DataItem *item2;
virCPUx86DataIteratorInit(&iter1, &model1->data);
virCPUx86DataIteratorInit(&iter2, &model2->data);
static int
-x86ModelParseDecode(virCPUx86ModelPtr model,
+x86ModelParseDecode(virCPUx86Model *model,
xmlXPathContextPtr ctxt)
{
g_autofree char *host = NULL;
static int
-x86ModelParseAncestor(virCPUx86ModelPtr model,
+x86ModelParseAncestor(virCPUx86Model *model,
xmlXPathContextPtr ctxt,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
g_autofree char *name = NULL;
- virCPUx86ModelPtr ancestor;
+ virCPUx86Model *ancestor;
int rc;
if ((rc = virXPathBoolean("boolean(./model)", ctxt)) <= 0)
static int
-x86ModelParseSignatures(virCPUx86ModelPtr model,
+x86ModelParseSignatures(virCPUx86Model *model,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-x86ModelParseVendor(virCPUx86ModelPtr model,
+x86ModelParseVendor(virCPUx86Model *model,
xmlXPathContextPtr ctxt,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
g_autofree char *vendor = NULL;
int rc;
static int
-x86ModelParseFeatures(virCPUx86ModelPtr model,
+x86ModelParseFeatures(virCPUx86Model *model,
xmlXPathContextPtr ctxt,
- virCPUx86MapPtr map)
+ virCPUx86Map *map)
{
g_autofree xmlNodePtr *nodes = NULL;
size_t i;
for (i = 0; i < n; i++) {
g_autofree char *ftname = NULL;
g_autofree char *removed = NULL;
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
if (!(ftname = virXMLPropString(nodes[i], "name"))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
const char *name,
void *data)
{
- virCPUx86MapPtr map = data;
+ virCPUx86Map *map = data;
g_autoptr(virCPUx86Model) model = NULL;
if (x86ModelFind(map, name)) {
static void
-x86MapFree(virCPUx86MapPtr map)
+x86MapFree(virCPUx86Map *map)
{
size_t i;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCPUx86Map, x86MapFree);
-static virCPUx86MapPtr
+static virCPUx86Map *
virCPUx86LoadMap(void)
{
g_autoptr(virCPUx86Map) map = NULL;
}
-static virCPUx86MapPtr
+static virCPUx86Map *
virCPUx86GetMap(void)
{
if (virCPUx86DriverInitialize() < 0)
virCPUx86DataFormat(const virCPUData *data)
{
virCPUx86DataIterator iter;
- virCPUx86DataItemPtr item;
+ virCPUx86DataItem *item;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCPUx86DataIteratorInit(&iter, &data->data.x86);
virBufferAddLit(&buf, "<cpudata arch='x86'>\n");
while ((item = virCPUx86DataNext(&iter))) {
- virCPUx86CPUIDPtr cpuid;
- virCPUx86MSRPtr msr;
+ virCPUx86CPUID *cpuid;
+ virCPUx86MSR *msr;
switch (item->type) {
case VIR_CPU_X86_DATA_CPUID:
}
-static virCPUDataPtr
+static virCPUData *
virCPUx86DataParse(xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static virCPUCompareResult
-x86Compute(virCPUDefPtr host,
- virCPUDefPtr cpu,
- virCPUDataPtr *guest,
+x86Compute(virCPUDef *host,
+ virCPUDef *cpu,
+ virCPUData **guest,
char **message)
{
- virCPUx86MapPtr map = NULL;
+ virCPUx86Map *map = NULL;
g_autoptr(virCPUx86Model) host_model = NULL;
g_autoptr(virCPUx86Model) cpu_force = NULL;
g_autoptr(virCPUx86Model) cpu_require = NULL;
static virCPUCompareResult
-virCPUx86Compare(virCPUDefPtr host,
- virCPUDefPtr cpu,
+virCPUx86Compare(virCPUDef *host,
+ virCPUDef *cpu,
bool failIncompatible)
{
virCPUCompareResult ret;
* 2 if candidate is the best one (search should stop now).
*/
static int
-x86DecodeUseCandidate(virCPUx86ModelPtr current,
- virCPUDefPtr cpuCurrent,
- virCPUx86ModelPtr candidate,
- virCPUDefPtr cpuCandidate,
+x86DecodeUseCandidate(virCPUx86Model *current,
+ virCPUDef *cpuCurrent,
+ virCPUx86Model *candidate,
+ virCPUDef *cpuCandidate,
uint32_t signature,
const char *preferred)
{
*/
static void
x86DataFilterTSX(virCPUx86Data *data,
- virCPUx86VendorPtr vendor,
- virCPUx86MapPtr map)
+ virCPUx86Vendor *vendor,
+ virCPUx86Map *map)
{
unsigned int family;
unsigned int model;
model == 60 ||
model == 69 ||
model == 70)) {
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
VIR_DEBUG("Dropping broken TSX");
static int
-x86Decode(virCPUDefPtr cpu,
+x86Decode(virCPUDef *cpu,
const virCPUx86Data *cpuData,
- virDomainCapsCPUModelsPtr models,
+ virDomainCapsCPUModels *models,
const char *preferred,
bool migratable)
{
- virCPUx86MapPtr map;
- virCPUx86ModelPtr candidate;
- virCPUDefPtr cpuCandidate;
- virCPUx86ModelPtr model = NULL;
+ virCPUx86Map *map;
+ virCPUx86Model *candidate;
+ virCPUDef *cpuCandidate;
+ virCPUx86Model *model = NULL;
g_autoptr(virCPUDef) cpuModel = NULL;
g_auto(virCPUx86Data) data = VIR_CPU_X86_DATA_INIT;
- virCPUx86VendorPtr vendor;
- virDomainCapsCPUModelPtr hvModel = NULL;
+ virCPUx86Vendor *vendor;
+ virDomainCapsCPUModel *hvModel = NULL;
g_autofree char *sigs = NULL;
uint32_t signature;
unsigned int sigFamily;
}
static int
-x86DecodeCPUData(virCPUDefPtr cpu,
+x86DecodeCPUData(virCPUDef *cpu,
const virCPUData *data,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
return x86Decode(cpu, &data->data.x86, models, NULL, false);
}
static int
x86EncodePolicy(virCPUx86Data *data,
const virCPUDef *cpu,
- virCPUx86MapPtr map,
+ virCPUx86Map *map,
virCPUFeaturePolicy policy)
{
g_autoptr(virCPUx86Model) model = NULL;
static int
x86Encode(virArch arch,
const virCPUDef *cpu,
- virCPUDataPtr *forced,
- virCPUDataPtr *required,
- virCPUDataPtr *optional,
- virCPUDataPtr *disabled,
- virCPUDataPtr *forbidden,
- virCPUDataPtr *vendor)
-{
- virCPUx86MapPtr map = NULL;
+ virCPUData **forced,
+ virCPUData **required,
+ virCPUData **optional,
+ virCPUData **disabled,
+ virCPUData **forbidden,
+ virCPUData **vendor)
+{
+ virCPUx86Map *map = NULL;
g_autoptr(virCPUData) data_forced = NULL;
g_autoptr(virCPUData) data_required = NULL;
g_autoptr(virCPUData) data_optional = NULL;
return -1;
if (vendor) {
- virCPUx86VendorPtr v = NULL;
+ virCPUx86Vendor *v = NULL;
if (cpu->vendor && !(v = x86VendorFind(map, cpu->vendor))) {
virReportError(VIR_ERR_OPERATION_FAILED,
virCPUx86CheckFeature(const virCPUDef *cpu,
const char *name)
{
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
g_autoptr(virCPUx86Model) model = NULL;
if (!(map = virCPUx86GetMap()))
virCPUx86DataCheckFeature(const virCPUData *data,
const char *name)
{
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
if (!(map = virCPUx86GetMap()))
return -1;
* Sub leaf n+1 is invalid if eax[4:0] in sub leaf n equals 0.
*/
static int
-cpuidSetLeaf4(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeaf4(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = *subLeaf0;
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
if (virCPUx86DataAdd(data, subLeaf0) < 0)
return -1;
* Sub leaf n is invalid if n > eax in sub leaf 0.
*/
static int
-cpuidSetLeaf7(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeaf7(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = CPUID(.eax_in = 0x7);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
uint32_t sub;
if (virCPUx86DataAdd(data, subLeaf0) < 0)
* meaningful data even if it was (theoretically) considered invalid.
*/
static int
-cpuidSetLeafB(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeafB(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = *subLeaf0;
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
while (cpuid->ecx & 0xff00) {
if (virCPUx86DataAdd(data, &item) < 0)
* and edx[n-32] from sub leaf 1 is not set.
*/
static int
-cpuidSetLeafD(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeafD(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = CPUID(.eax_in = 0xd);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
virCPUx86CPUID sub0;
virCPUx86CPUID sub1;
uint32_t sub;
* 0x10: Sub leaf n is valid if ebx[n] (= res[ResID]) from sub leaf 0 is set.
*/
static int
-cpuidSetLeafResID(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0,
+cpuidSetLeafResID(virCPUData *data,
+ virCPUx86DataItem *subLeaf0,
uint32_t res)
{
virCPUx86DataItem item = CPUID(.eax_in = subLeaf0->data.cpuid.eax_in);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
uint32_t sub;
if (virCPUx86DataAdd(data, subLeaf0) < 0)
* Sub leaves n >= 2 are valid as long as eax[3:0] != 0.
*/
static int
-cpuidSetLeaf12(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeaf12(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = CPUID(.eax_in = 0x7);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
- virCPUx86DataItemPtr leaf7;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
+ virCPUx86DataItem *leaf7;
if (!(leaf7 = virCPUx86DataGet(&data->data.x86, &item)) ||
!(leaf7->data.cpuid.ebx & (1 << 2)))
* Sub leaf 0 reports the maximum supported sub leaf in eax.
*/
static int
-cpuidSetLeaf14(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeaf14(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = CPUID(.eax_in = 0x14);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
uint32_t sub;
if (virCPUx86DataAdd(data, subLeaf0) < 0)
* Sub leaf 0 reports the maximum supported sub leaf in eax.
*/
static int
-cpuidSetLeaf17(virCPUDataPtr data,
- virCPUx86DataItemPtr subLeaf0)
+cpuidSetLeaf17(virCPUData *data,
+ virCPUx86DataItem *subLeaf0)
{
virCPUx86DataItem item = CPUID(.eax_in = 0x17);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
uint32_t sub;
if (subLeaf0->data.cpuid.eax < 3)
static int
-cpuidSet(uint32_t base, virCPUDataPtr data)
+cpuidSet(uint32_t base, virCPUData *data)
{
int rc;
uint32_t max;
uint32_t leaf;
virCPUx86DataItem item = CPUID(.eax_in = base);
- virCPUx86CPUIDPtr cpuid = &item.data.cpuid;
+ virCPUx86CPUID *cpuid = &item.data.cpuid;
cpuidCall(cpuid);
max = cpuid->eax;
static int
-virCPUx86GetHost(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+virCPUx86GetHost(virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
{
g_autoptr(virCPUData) cpuData = NULL;
int ret;
#endif
-static virCPUDefPtr
-virCPUx86Baseline(virCPUDefPtr *cpus,
+static virCPUDef *
+virCPUx86Baseline(virCPUDef **cpus,
unsigned int ncpus,
- virDomainCapsCPUModelsPtr models,
+ virDomainCapsCPUModels *models,
const char **features,
bool migratable)
{
- virCPUx86MapPtr map = NULL;
+ virCPUx86Map *map = NULL;
g_autoptr(virCPUx86Model) base_model = NULL;
g_autoptr(virCPUDef) cpu = NULL;
size_t i;
- virCPUx86VendorPtr vendor = NULL;
+ virCPUx86Vendor *vendor = NULL;
bool outputVendor = true;
const char *modelName;
bool matchingNames = true;
}
if (features) {
- virCPUx86FeaturePtr feat;
+ virCPUx86Feature *feat;
if (!(featData = virCPUDataNew(archs[0])))
return NULL;
static int
-x86UpdateHostModel(virCPUDefPtr guest,
+x86UpdateHostModel(virCPUDef *guest,
const virCPUDef *host)
{
g_autoptr(virCPUDef) updated = NULL;
static int
-virCPUx86Update(virCPUDefPtr guest,
+virCPUx86Update(virCPUDef *guest,
const virCPUDef *host,
bool relative)
{
g_autoptr(virCPUx86Model) model = NULL;
- virCPUx86ModelPtr guestModel;
- virCPUx86MapPtr map;
+ virCPUx86Model *guestModel;
+ virCPUx86Map *map;
size_t i;
if (!(map = virCPUx86GetMap()))
static int
-virCPUx86UpdateLive(virCPUDefPtr cpu,
- virCPUDataPtr dataEnabled,
- virCPUDataPtr dataDisabled)
+virCPUx86UpdateLive(virCPUDef *cpu,
+ virCPUData *dataEnabled,
+ virCPUData *dataDisabled)
{
bool hostPassthrough = (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH ||
cpu->mode == VIR_CPU_MODE_MAXIMUM);
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
g_autoptr(virCPUx86Model) model = NULL;
g_autoptr(virCPUx86Model) modelDisabled = NULL;
g_auto(virCPUx86Data) enabled = VIR_CPU_X86_DATA_INIT;
x86DataCopy(&disabled, &dataDisabled->data.x86);
for (i = 0; i < map->nfeatures; i++) {
- virCPUx86FeaturePtr feature = map->features[i];
+ virCPUx86Feature *feature = map->features[i];
virCPUFeaturePolicy expected = VIR_CPU_FEATURE_LAST;
if (x86DataIsSubset(&model->data, &feature->data))
static int
virCPUx86GetModels(char ***models)
{
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
size_t i;
if (!(map = virCPUx86GetMap()))
static int
-virCPUx86Translate(virCPUDefPtr cpu,
- virDomainCapsCPUModelsPtr models)
+virCPUx86Translate(virCPUDef *cpu,
+ virDomainCapsCPUModels *models)
{
g_autoptr(virCPUDef) translated = NULL;
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
g_autoptr(virCPUx86Model) model = NULL;
size_t i;
return -1;
for (i = 0; i < cpu->nfeatures; i++) {
- virCPUFeatureDefPtr f = cpu->features + i;
+ virCPUFeatureDef *f = cpu->features + i;
if (virCPUDefUpdateFeature(translated, f->name, f->policy) < 0)
return -1;
}
static int
-virCPUx86ExpandFeatures(virCPUDefPtr cpu)
+virCPUx86ExpandFeatures(virCPUDef *cpu)
{
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
g_autoptr(virCPUDef) expanded = NULL;
g_autoptr(virCPUx86Model) model = NULL;
bool host = cpu->type == VIR_CPU_TYPE_HOST;
return -1;
for (i = 0; i < cpu->nfeatures; i++) {
- virCPUFeatureDefPtr f = cpu->features + i;
+ virCPUFeatureDef *f = cpu->features + i;
if (!host &&
f->policy != VIR_CPU_FEATURE_REQUIRE &&
}
-static virCPUDefPtr
-virCPUx86CopyMigratable(virCPUDefPtr cpu)
+static virCPUDef *
+virCPUx86CopyMigratable(virCPUDef *cpu)
{
g_autoptr(virCPUDef) copy = NULL;
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
if (!(map = virCPUx86GetMap()))
return NULL;
static int
-virCPUx86ValidateFeatures(virCPUDefPtr cpu)
+virCPUx86ValidateFeatures(virCPUDef *cpu)
{
- virCPUx86MapPtr map;
+ virCPUx86Map *map;
size_t i;
if (!(map = virCPUx86GetMap()))
int
-virCPUx86DataAdd(virCPUDataPtr cpuData,
+virCPUx86DataAdd(virCPUData *cpuData,
const virCPUx86DataItem *item)
{
return virCPUx86DataAddItem(&cpuData->data.x86, item);
int
-virCPUx86DataSetSignature(virCPUDataPtr cpuData,
+virCPUx86DataSetSignature(virCPUData *cpuData,
unsigned int family,
unsigned int model,
unsigned int stepping)
uint32_t
-virCPUx86DataGetSignature(virCPUDataPtr cpuData,
+virCPUx86DataGetSignature(virCPUData *cpuData,
unsigned int *family,
unsigned int *model,
unsigned int *stepping)
int
-virCPUx86DataSetVendor(virCPUDataPtr cpuData,
+virCPUx86DataSetVendor(virCPUData *cpuData,
const char *vendor)
{
virCPUx86DataItem item = CPUID(0);
static int
-virCPUx86DataAddFeature(virCPUDataPtr cpuData,
+virCPUx86DataAddFeature(virCPUData *cpuData,
const char *name)
{
- virCPUx86FeaturePtr feature;
- virCPUx86MapPtr map;
+ virCPUx86Feature *feature;
+ virCPUx86Map *map;
if (!(map = virCPUx86GetMap()))
return -1;
static bool
virCPUx86FeatureIsMSR(const char *name)
{
- virCPUx86FeaturePtr feature;
+ virCPUx86Feature *feature;
virCPUx86DataIterator iter;
- virCPUx86DataItemPtr item;
- virCPUx86MapPtr map;
+ virCPUx86DataItem *item;
+ virCPUx86Map *map;
if (!(map = virCPUx86GetMap()))
return false;
extern struct cpuArchDriver cpuDriverX86;
-int virCPUx86DataAdd(virCPUDataPtr cpuData,
+int virCPUx86DataAdd(virCPUData *cpuData,
const virCPUx86DataItem *cpuid);
-int virCPUx86DataSetSignature(virCPUDataPtr cpuData,
+int virCPUx86DataSetSignature(virCPUData *cpuData,
unsigned int family,
unsigned int model,
unsigned int stepping);
-uint32_t virCPUx86DataGetSignature(virCPUDataPtr cpuData,
+uint32_t virCPUx86DataGetSignature(virCPUData *cpuData,
unsigned int *family,
unsigned int *model,
unsigned int *stepping);
-int virCPUx86DataSetVendor(virCPUDataPtr cpuData,
+int virCPUx86DataSetVendor(virCPUData *cpuData,
const char *vendor);
bool virCPUx86FeatureFilterSelectMSR(const char *name,
#pragma once
typedef struct _virCPUx86CPUID virCPUx86CPUID;
-typedef virCPUx86CPUID *virCPUx86CPUIDPtr;
struct _virCPUx86CPUID {
uint32_t eax_in;
uint32_t ecx_in;
};
typedef struct _virCPUx86MSR virCPUx86MSR;
-typedef virCPUx86MSR *virCPUx86MSRPtr;
struct _virCPUx86MSR {
uint32_t index;
uint32_t eax;
} virCPUx86DataType;
typedef struct _virCPUx86DataItem virCPUx86DataItem;
-typedef virCPUx86DataItem *virCPUx86DataItemPtr;
struct _virCPUx86DataItem {
virCPUx86DataType type;
union {
VIR_LOG_INIT("datatypes");
-virClassPtr virConnectClass;
-virClassPtr virConnectCloseCallbackDataClass;
-virClassPtr virDomainClass;
-virClassPtr virDomainCheckpointClass;
-virClassPtr virDomainSnapshotClass;
-virClassPtr virInterfaceClass;
-virClassPtr virNetworkClass;
-virClassPtr virNetworkPortClass;
-virClassPtr virNodeDeviceClass;
-virClassPtr virNWFilterClass;
-virClassPtr virNWFilterBindingClass;
-virClassPtr virSecretClass;
-virClassPtr virStreamClass;
-virClassPtr virStorageVolClass;
-virClassPtr virStoragePoolClass;
+virClass *virConnectClass;
+virClass *virConnectCloseCallbackDataClass;
+virClass *virDomainClass;
+virClass *virDomainCheckpointClass;
+virClass *virDomainSnapshotClass;
+virClass *virInterfaceClass;
+virClass *virNetworkClass;
+virClass *virNetworkPortClass;
+virClass *virNodeDeviceClass;
+virClass *virNWFilterClass;
+virClass *virNWFilterBindingClass;
+virClass *virSecretClass;
+virClass *virStreamClass;
+virClass *virStorageVolClass;
+virClass *virStoragePoolClass;
static void virConnectDispose(void *obj);
static void virConnectCloseCallbackDataDispose(void *obj);
static void virStorageVolDispose(void *obj);
static void virStoragePoolDispose(void *obj);
-virClassPtr virAdmConnectClass;
-virClassPtr virAdmConnectCloseCallbackDataClass;
+virClass *virAdmConnectClass;
+virClass *virAdmConnectCloseCallbackDataClass;
static void virAdmConnectDispose(void *obj);
static void virAdmConnectCloseCallbackDataDispose(void *obj);
-virClassPtr virAdmServerClass;
-virClassPtr virAdmClientClass;
+virClass *virAdmServerClass;
+virClass *virAdmClientClass;
static void virAdmServerDispose(void *obj);
static void virAdmClientDispose(void *obj);
static void
-virConnectCloseCallbackDataReset(virConnectCloseCallbackDataPtr closeData)
+virConnectCloseCallbackDataReset(virConnectCloseCallbackData *closeData)
{
if (closeData->freeCallback)
closeData->freeCallback(closeData->opaque);
virConnectCloseCallbackDataReset(obj);
}
-virConnectCloseCallbackDataPtr
+virConnectCloseCallbackData *
virNewConnectCloseCallbackData(void)
{
if (virDataTypesInitialize() < 0)
return virObjectLockableNew(virConnectCloseCallbackDataClass);
}
-void virConnectCloseCallbackDataRegister(virConnectCloseCallbackDataPtr closeData,
+void virConnectCloseCallbackDataRegister(virConnectCloseCallbackData *closeData,
virConnectPtr conn,
virConnectCloseFunc cb,
void *opaque,
virObjectUnlock(closeData);
}
-void virConnectCloseCallbackDataUnregister(virConnectCloseCallbackDataPtr closeData,
+void virConnectCloseCallbackDataUnregister(virConnectCloseCallbackData *closeData,
virConnectCloseFunc cb)
{
virObjectLock(closeData);
virObjectUnlock(closeData);
}
-void virConnectCloseCallbackDataCall(virConnectCloseCallbackDataPtr closeData,
+void virConnectCloseCallbackDataCall(virConnectCloseCallbackData *closeData,
int reason)
{
virObjectLock(closeData);
}
virConnectCloseFunc
-virConnectCloseCallbackDataGetCallback(virConnectCloseCallbackDataPtr closeData)
+virConnectCloseCallbackDataGetCallback(virConnectCloseCallbackData *closeData)
{
virConnectCloseFunc cb;
static void
virAdmConnectCloseCallbackDataDispose(void *obj)
{
- virAdmConnectCloseCallbackDataPtr cb_data = obj;
+ virAdmConnectCloseCallbackData *cb_data = obj;
virObjectLock(cb_data);
virAdmConnectCloseCallbackDataReset(cb_data);
}
void
-virAdmConnectCloseCallbackDataReset(virAdmConnectCloseCallbackDataPtr cbdata)
+virAdmConnectCloseCallbackDataReset(virAdmConnectCloseCallbackData *cbdata)
{
if (cbdata->freeCallback)
cbdata->freeCallback(cbdata->opaque);
}
int
-virAdmConnectCloseCallbackDataUnregister(virAdmConnectCloseCallbackDataPtr cbdata,
+virAdmConnectCloseCallbackDataUnregister(virAdmConnectCloseCallbackData *cbdata,
virAdmConnectCloseFunc cb)
{
int ret = -1;
}
int
-virAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackDataPtr cbdata,
+virAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackData *cbdata,
virAdmConnectPtr conn,
virAdmConnectCloseFunc cb,
void *opaque,
#include "virobject.h"
#include "viruuid.h"
-extern virClassPtr virConnectClass;
-extern virClassPtr virDomainClass;
-extern virClassPtr virDomainCheckpointClass;
-extern virClassPtr virDomainSnapshotClass;
-extern virClassPtr virInterfaceClass;
-extern virClassPtr virNetworkClass;
-extern virClassPtr virNetworkPortClass;
-extern virClassPtr virNodeDeviceClass;
-extern virClassPtr virNWFilterClass;
-extern virClassPtr virNWFilterBindingClass;
-extern virClassPtr virSecretClass;
-extern virClassPtr virStreamClass;
-extern virClassPtr virStorageVolClass;
-extern virClassPtr virStoragePoolClass;
-
-extern virClassPtr virAdmConnectClass;
-extern virClassPtr virAdmServerClass;
-extern virClassPtr virAdmClientClass;
+extern virClass *virConnectClass;
+extern virClass *virDomainClass;
+extern virClass *virDomainCheckpointClass;
+extern virClass *virDomainSnapshotClass;
+extern virClass *virInterfaceClass;
+extern virClass *virNetworkClass;
+extern virClass *virNetworkPortClass;
+extern virClass *virNodeDeviceClass;
+extern virClass *virNWFilterClass;
+extern virClass *virNWFilterBindingClass;
+extern virClass *virSecretClass;
+extern virClass *virStreamClass;
+extern virClass *virStorageVolClass;
+extern virClass *virStoragePoolClass;
+
+extern virClass *virAdmConnectClass;
+extern virClass *virAdmServerClass;
+extern virClass *virAdmClientClass;
#define virCheckConnectReturn(obj, retval) \
do { \
typedef struct _virConnectCloseCallbackData virConnectCloseCallbackData;
-typedef virConnectCloseCallbackData *virConnectCloseCallbackDataPtr;
typedef struct _virAdmConnectCloseCallbackData virAdmConnectCloseCallbackData;
-typedef virAdmConnectCloseCallbackData *virAdmConnectCloseCallbackDataPtr;
/**
* Internal structures holding data related to connection close callbacks.
* them.
*/
unsigned int flags; /* a set of connection flags */
- virURIPtr uri; /* connection URI */
+ virURI *uri; /* connection URI */
/* The underlying hypervisor driver and network driver. */
- virHypervisorDriverPtr driver;
- virNetworkDriverPtr networkDriver;
- virInterfaceDriverPtr interfaceDriver;
- virStorageDriverPtr storageDriver;
- virNodeDeviceDriverPtr nodeDeviceDriver;
- virSecretDriverPtr secretDriver;
- virNWFilterDriverPtr nwfilterDriver;
+ virHypervisorDriver *driver;
+ virNetworkDriver *networkDriver;
+ virInterfaceDriver *interfaceDriver;
+ virStorageDriver *storageDriver;
+ virNodeDeviceDriver *nodeDeviceDriver;
+ virSecretDriver *secretDriver;
+ virNWFilterDriver *nwfilterDriver;
/* Private data pointer which can be used by domain driver as
* it pleases.
*/
struct _virAdmConnect {
virObjectLockable parent;
- virURIPtr uri;
+ virURI *uri;
void *privateData;
virFreeCallback privateDataFreeFunc;
/* Per-connection close callback */
- virAdmConnectCloseCallbackDataPtr closeCallback;
+ virAdmConnectCloseCallbackData *closeCallback;
};
/**
virConnectPtr conn;
unsigned int flags;
- virStreamDriverPtr driver;
+ virStreamDriver *driver;
void *privateData;
virFreeCallback ff;
};
void virAdmConnectWatchDispose(void);
bool virAdmConnectWasDisposed(void);
-virConnectCloseCallbackDataPtr virNewConnectCloseCallbackData(void);
-void virConnectCloseCallbackDataRegister(virConnectCloseCallbackDataPtr close,
+virConnectCloseCallbackData *virNewConnectCloseCallbackData(void);
+void virConnectCloseCallbackDataRegister(virConnectCloseCallbackData *close,
virConnectPtr conn,
virConnectCloseFunc cb,
void *opaque,
virFreeCallback freecb);
-void virConnectCloseCallbackDataUnregister(virConnectCloseCallbackDataPtr close,
+void virConnectCloseCallbackDataUnregister(virConnectCloseCallbackData *close,
virConnectCloseFunc cb);
-void virConnectCloseCallbackDataCall(virConnectCloseCallbackDataPtr close,
+void virConnectCloseCallbackDataCall(virConnectCloseCallbackData *close,
int reason);
virConnectCloseFunc
-virConnectCloseCallbackDataGetCallback(virConnectCloseCallbackDataPtr close);
-void virAdmConnectCloseCallbackDataReset(virAdmConnectCloseCallbackDataPtr cbdata);
-int virAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackDataPtr cbdata,
+virConnectCloseCallbackDataGetCallback(virConnectCloseCallbackData *close);
+void virAdmConnectCloseCallbackDataReset(virAdmConnectCloseCallbackData *cbdata);
+int virAdmConnectCloseCallbackDataRegister(virAdmConnectCloseCallbackData *cbdata,
virAdmConnectPtr conn,
virAdmConnectCloseFunc cb,
void *opaque,
virFreeCallback freecb);
-int virAdmConnectCloseCallbackDataUnregister(virAdmConnectCloseCallbackDataPtr cbdata,
+int virAdmConnectCloseCallbackDataUnregister(virAdmConnectCloseCallbackData *cbdata,
virAdmConnectCloseFunc cb);
typedef virDrvOpenStatus
(*virDrvConnectOpen)(virConnectPtr conn,
virConnectAuthPtr auth,
- virConfPtr conf,
+ virConf *conf,
unsigned int flags);
typedef int
unsigned int flags);
typedef struct _virHypervisorDriver virHypervisorDriver;
-typedef virHypervisorDriver *virHypervisorDriverPtr;
/**
* _virHypervisorDriver:
unsigned int flags);
typedef struct _virInterfaceDriver virInterfaceDriver;
-typedef virInterfaceDriver *virInterfaceDriverPtr;
/**
* _virInterfaceDriver:
unsigned int flags);
typedef struct _virNetworkDriver virNetworkDriver;
-typedef virNetworkDriver *virNetworkDriverPtr;
/**
* _virNetworkDriver:
typedef struct _virNodeDeviceDriver virNodeDeviceDriver;
-typedef virNodeDeviceDriver *virNodeDeviceDriverPtr;
/**
* _virNodeDeviceDriver:
typedef struct _virNWFilterDriver virNWFilterDriver;
-typedef virNWFilterDriver *virNWFilterDriverPtr;
/**
* _virNWFilterDriver:
int callbackID);
typedef struct _virSecretDriver virSecretDriver;
-typedef virSecretDriver *virSecretDriverPtr;
/**
* _virSecretDriver:
(*virDrvStateShutdownWait)(void);
typedef struct _virStateDriver virStateDriver;
-typedef virStateDriver *virStateDriverPtr;
-
struct _virStateDriver {
const char *name;
bool initialized;
typedef struct _virStorageDriver virStorageDriver;
-typedef virStorageDriver *virStorageDriverPtr;
/**
* _virStorageDriver:
(*virDrvStreamAbort)(virStreamPtr st);
typedef struct _virStreamDriver virStreamDriver;
-typedef virStreamDriver *virStreamDriverPtr;
-
struct _virStreamDriver {
virDrvStreamSend streamSend;
virDrvStreamRecv streamRecv;
VIR_ONCE_GLOBAL_INIT(virConnectCache);
static virConnectPtr
-virGetConnectGeneric(virThreadLocalPtr threadPtr, const char *name)
+virGetConnectGeneric(virThreadLocal *threadPtr, const char *name)
{
virConnectPtr conn;
#undef __VIR_DRIVER_H_INCLUDES___
typedef struct _virConnectDriver virConnectDriver;
-typedef virConnectDriver *virConnectDriverPtr;
-
struct _virConnectDriver {
/* Whether driver permits a server in the URI */
bool localOnly;
* - NULL list indicates wildcard supporting all schemes
*/
const char **uriSchemes;
- virHypervisorDriverPtr hypervisorDriver;
- virInterfaceDriverPtr interfaceDriver;
- virNetworkDriverPtr networkDriver;
- virNodeDeviceDriverPtr nodeDeviceDriver;
- virNWFilterDriverPtr nwfilterDriver;
- virSecretDriverPtr secretDriver;
- virStorageDriverPtr storageDriver;
+ virHypervisorDriver *hypervisorDriver;
+ virInterfaceDriver *interfaceDriver;
+ virNetworkDriver *networkDriver;
+ virNodeDeviceDriver *nodeDeviceDriver;
+ virNWFilterDriver *nwfilterDriver;
+ virSecretDriver *secretDriver;
+ virStorageDriver *storageDriver;
};
-int virRegisterConnectDriver(virConnectDriverPtr driver,
+int virRegisterConnectDriver(virConnectDriver *driver,
bool setSharedDrivers) G_GNUC_WARN_UNUSED_RESULT;
-int virRegisterStateDriver(virStateDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-
-int virSetSharedInterfaceDriver(virInterfaceDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-int virSetSharedNetworkDriver(virNetworkDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-int virSetSharedNodeDeviceDriver(virNodeDeviceDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-int virSetSharedNWFilterDriver(virNWFilterDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-int virSetSharedSecretDriver(virSecretDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
-int virSetSharedStorageDriver(virStorageDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
+int virRegisterStateDriver(virStateDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+
+int virSetSharedInterfaceDriver(virInterfaceDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+int virSetSharedNetworkDriver(virNetworkDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+int virSetSharedNodeDeviceDriver(virNodeDeviceDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+int virSetSharedNWFilterDriver(virNWFilterDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+int virSetSharedSecretDriver(virSecretDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
+int virSetSharedStorageDriver(virStorageDriver *driver) G_GNUC_WARN_UNUSED_RESULT;
bool virHasDriverForURIScheme(const char *scheme);
static int
-esxAutodetectSCSIControllerModel(virDomainDiskDefPtr def, int *model,
+esxAutodetectSCSIControllerModel(virDomainDiskDef *def, int *model,
void *opaque)
{
int result = -1;
}
-static virCapsPtr
+static virCaps *
esxCapsInit(esxPrivate *priv)
{
esxVI_Boolean supportsLongMode = esxSupportsLongMode(priv);
- virCapsPtr caps = NULL;
- virCapsGuestPtr guest = NULL;
+ virCaps *caps = NULL;
+ virCapsGuest *guest = NULL;
if (supportsLongMode == esxVI_Boolean_Undefined)
return NULL;
*/
static virDrvOpenStatus
esxConnectOpen(virConnectPtr conn, virConnectAuthPtr auth,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virDrvOpenStatus result = VIR_DRV_OPEN_ERROR;
g_autofree char *vmx = NULL;
virVMXContext ctx;
esxVMX_Data data;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *xml = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
esxPrivate *priv = conn->privateData;
virVMXContext ctx;
esxVMX_Data data;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *xml = NULL;
virCheckFlags(0, NULL);
int virtualHW_version;
virVMXContext ctx;
esxVMX_Data data;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *vmx = NULL;
virCheckFlags(0, NULL);
esxDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
esxPrivate *priv = conn->privateData;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
g_autofree char *vmx = NULL;
size_t i;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
esxVI_ObjectContent *virtualMachine = NULL;
int virtualHW_version;
virVMXContext ctx;
{
int result = -1;
esxPrivate *priv = domain->conn->privateData;
- virURIPtr parsedUri = NULL;
+ virURI *parsedUri = NULL;
char *saveptr;
char *path_resourcePool;
char *path_hostSystem;
esxVI_PhysicalNic *physicalNic = NULL;
virInterfaceDef def;
bool hasAddress = false;
- virInterfaceProtocolDefPtr protocols;
+ virInterfaceProtocolDef *protocols;
virInterfaceProtocolDef protocol;
virSocketAddr socketAddress;
- virInterfaceIPDefPtr ips;
+ virInterfaceIPDef *ips;
virInterfaceIPDef ip;
virCheckFlags(VIR_INTERFACE_XML_INACTIVE, NULL);
static int
-esxBandwidthToShapingPolicy(virNetDevBandwidthPtr bandwidth,
+esxBandwidthToShapingPolicy(virNetDevBandwidth *bandwidth,
esxVI_HostNetworkTrafficShapingPolicy **shapingPolicy)
{
int result = -1;
{
virNetworkPtr network = NULL;
esxPrivate *priv = conn->privateData;
- virNetworkDefPtr def = NULL;
+ virNetworkDef *def = NULL;
esxVI_HostVirtualSwitch *hostVirtualSwitch = NULL;
esxVI_HostPortGroup *hostPortGroupList = NULL;
esxVI_HostPortGroup *hostPortGroup = NULL;
static int
esxShapingPolicyToBandwidth(esxVI_HostNetworkTrafficShapingPolicy *shapingPolicy,
- virNetDevBandwidthPtr *bandwidth)
+ virNetDevBandwidth **bandwidth)
{
ESX_VI_CHECK_ARG_LIST(bandwidth);
esxVI_String *networkNameList = NULL;
esxVI_String *hostPortGroupKey = NULL;
esxVI_String *networkName = NULL;
- virNetworkDefPtr def;
+ virNetworkDef *def;
if (esxVI_EnsureSession(priv->primary) < 0)
return NULL;
esxVI_Context *host;
esxVI_Context *vCenter;
esxUtil_ParsedUri *parsedUri;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
int32_t maxVcpus;
esxVI_Boolean supportsVMotion;
esxVI_Boolean supportsLongMode; /* aka x86_64 */
LAST_BACKEND
};
-static virStorageDriverPtr backends[] = {
+static virStorageDriver *backends[] = {
&esxStorageBackendVMFS,
&esxStorageBackendISCSI
};
esxStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, -1);
esxStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, -1);
esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, NULL);
esxStoragePoolNumOfVolumes(virStoragePoolPtr pool)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, -1);
int maxnames)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, -1);
esxStorageVolLookupByName(virStoragePoolPtr pool, const char *name)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, NULL);
unsigned int flags)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, NULL);
virStorageVolPtr sourceVolume, unsigned int flags)
{
esxPrivate *priv = pool->conn->privateData;
- virStorageDriverPtr backend = pool->privateData;
+ virStorageDriver *backend = pool->privateData;
virCheckNonNullArgReturn(pool->privateData, NULL);
esxStorageVolDelete(virStorageVolPtr volume, unsigned int flags)
{
esxPrivate *priv = volume->conn->privateData;
- virStorageDriverPtr backend = volume->privateData;
+ virStorageDriver *backend = volume->privateData;
virCheckNonNullArgReturn(volume->privateData, -1);
esxStorageVolWipe(virStorageVolPtr volume, unsigned int flags)
{
esxPrivate *priv = volume->conn->privateData;
- virStorageDriverPtr backend = volume->privateData;
+ virStorageDriver *backend = volume->privateData;
virCheckNonNullArgReturn(volume->privateData, -1);
esxStorageVolGetInfo(virStorageVolPtr volume, virStorageVolInfoPtr info)
{
esxPrivate *priv = volume->conn->privateData;
- virStorageDriverPtr backend = volume->privateData;
+ virStorageDriver *backend = volume->privateData;
virCheckNonNullArgReturn(volume->privateData, -1);
esxStorageVolGetXMLDesc(virStorageVolPtr volume, unsigned int flags)
{
esxPrivate *priv = volume->conn->privateData;
- virStorageDriverPtr backend = volume->privateData;
+ virStorageDriver *backend = volume->privateData;
virCheckNonNullArgReturn(volume->privateData, NULL);
esxStorageVolGetPath(virStorageVolPtr volume)
{
esxPrivate *priv = volume->conn->privateData;
- virStorageDriverPtr backend = volume->privateData;
+ virStorageDriver *backend = volume->privateData;
virCheckNonNullArgReturn(volume->privateData, NULL);
VIR_LOG_INIT("esx.esx_util");
int
-esxUtil_ParseUri(esxUtil_ParsedUri **parsedUri, virURIPtr uri)
+esxUtil_ParseUri(esxUtil_ParsedUri **parsedUri, virURI *uri)
{
int result = -1;
size_t i;
*parsedUri = g_new0(esxUtil_ParsedUri, 1);
for (i = 0; i < uri->paramsCount; i++) {
- virURIParamPtr queryParam = &uri->params[i];
+ virURIParam *queryParam = &uri->params[i];
if (STRCASEEQ(queryParam->name, "transport")) {
g_free((*parsedUri)->transport);
char *path;
};
-int esxUtil_ParseUri(esxUtil_ParsedUri **parsedUri, virURIPtr uri);
+int esxUtil_ParseUri(esxUtil_ParsedUri **parsedUri, virURI *uri);
void esxUtil_FreeParsedUri(esxUtil_ParsedUri **parsedUri);
static size_t
esxVI_CURL_WriteBuffer(char *data, size_t size, size_t nmemb, void *userdata)
{
- virBufferPtr buffer = userdata;
+ virBuffer *buffer = userdata;
if (buffer) {
/*
int
esxVI_Enumeration_Serialize(const esxVI_Enumeration *enumeration,
- int value, const char *element, virBufferPtr output)
+ int value, const char *element, virBuffer *output)
{
size_t i;
const char *name = NULL;
int
esxVI_List_Serialize(esxVI_List *list, const char *element,
- virBufferPtr output,
+ virBuffer *output,
esxVI_List_SerializeFunc serializeFunc)
{
esxVI_List *item = NULL;
esxVI_ProductLine productLine;
unsigned long productVersion; /* = 1000000 * major + 1000 * minor + micro */
esxVI_UserSession *session; /* ... except the session ... */
- virMutexPtr sessionLock; /* ... that is protected by this mutex */
+ virMutex *sessionLock; /* ... that is protected by this mutex */
esxVI_Datacenter *datacenter;
char *datacenterPath; /* including folders */
esxVI_ComputeResource *computeResource;
esxVI_AnyType *anyType, int *value);
int esxVI_Enumeration_Serialize(const esxVI_Enumeration *enumeration,
int value, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Enumeration_Deserialize(const esxVI_Enumeration *enumeration,
xmlNodePtr node, int *value);
typedef int (*esxVI_List_CastFromAnyTypeFunc) (esxVI_AnyType *anyType,
esxVI_List **item);
typedef int (*esxVI_List_SerializeFunc) (esxVI_List *item, const char *element,
- virBufferPtr output);
+ virBuffer *output);
typedef int (*esxVI_List_DeserializeFunc) (xmlNodePtr node, esxVI_List **item);
int esxVI_List_Append(esxVI_List **list, esxVI_List *item);
esxVI_List_CastFromAnyTypeFunc castFromAnyTypeFunc,
esxVI_List_FreeFunc freeFunc);
int esxVI_List_Serialize(esxVI_List *list, const char *element,
- virBufferPtr output,
+ virBuffer *output,
esxVI_List_SerializeFunc serializeFunc);
int esxVI_List_Deserialize(xmlNodePtr node, esxVI_List **list,
esxVI_List_DeserializeFunc deserializeFunc,
#define ESX_VI__TEMPLATE__LIST__SERIALIZE(_type) \
int \
esxVI_##_type##_SerializeList(esxVI_##_type *list, const char *element, \
- virBufferPtr output) \
+ virBuffer *output) \
{ \
return esxVI_List_Serialize((esxVI_List *)list, element, output, \
(esxVI_List_SerializeFunc) \
#define ESX_VI__TEMPLATE__SERIALIZE_EXTRA(_type, _extra, _serialize) \
int \
esxVI_##_type##_Serialize(esxVI_##_type *item, \
- const char *element, virBufferPtr output) \
+ const char *element, virBuffer *output) \
{ \
if (!element || !output) { \
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", \
#define ESX_VI__TEMPLATE__ENUMERATION__SERIALIZE(_type) \
int \
esxVI_##_type##_Serialize(esxVI_##_type value, const char *element, \
- virBufferPtr output) \
+ virBuffer *output) \
{ \
return esxVI_Enumeration_Serialize(&_esxVI_##_type##_Enumeration, \
value, element, output); \
int
esxVI_String_Serialize(esxVI_String *string, const char *element,
- virBufferPtr output)
+ virBuffer *output)
{
return esxVI_String_SerializeValue(string ? string->value : NULL,
element, output);
int
esxVI_String_SerializeValue(const char *value, const char *element,
- virBufferPtr output)
+ virBuffer *output)
{
if (!element || !output) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
int
esxVI_ManagedObjectReference_Serialize
(esxVI_ManagedObjectReference *managedObjectReference,
- const char *element, virBufferPtr output)
+ const char *element, virBuffer *output)
{
if (!element || !output) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
};
int esxVI_Boolean_Serialize(esxVI_Boolean boolean_, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Boolean_Deserialize(xmlNodePtr node, esxVI_Boolean *boolean_);
int esxVI_String_CastFromAnyType(esxVI_AnyType *anyType, esxVI_String **string);
int esxVI_String_CastValueFromAnyType(esxVI_AnyType *anyType, char **string);
int esxVI_String_Serialize(esxVI_String *string, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_String_SerializeList(esxVI_String *stringList, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_String_SerializeValue(const char *value, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_String_Deserialize(xmlNodePtr node, esxVI_String **string);
int esxVI_String_DeserializeList(xmlNodePtr node, esxVI_String **stringList);
int esxVI_String_DeserializeValue(xmlNodePtr node, char **value);
int esxVI_Byte_DeepCopy(esxVI_Byte **dest, esxVI_Byte *src);
int esxVI_Byte_DeepCopyList(esxVI_Byte **destList, esxVI_Byte *srcList);
int esxVI_Byte_Serialize(esxVI_Byte *number, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Byte_SerializeList(esxVI_Byte *numberList, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Byte_Deserialize(xmlNodePtr node, esxVI_Byte **number);
int esxVI_Int_DeepCopy(esxVI_Int **dest, esxVI_Int *src);
int esxVI_Int_CastFromAnyType(esxVI_AnyType *anyType, esxVI_Int **number);
int esxVI_Int_Serialize(esxVI_Int *number, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Int_SerializeList(esxVI_Int *numberList, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Int_Deserialize(xmlNodePtr node, esxVI_Int **number);
int esxVI_Long_DeepCopy(esxVI_Long **dest, esxVI_Long *src);
int esxVI_Long_CastFromAnyType(esxVI_AnyType *anyType, esxVI_Long **number);
int esxVI_Long_Serialize(esxVI_Long *number, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Long_SerializeList(esxVI_Long *numberList, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_Long_Deserialize(xmlNodePtr node, esxVI_Long **number);
int esxVI_DateTime_Validate(esxVI_DateTime *dateTime);
int esxVI_DateTime_DeepCopy(esxVI_DateTime **dest, esxVI_DateTime *src);
int esxVI_DateTime_Serialize(esxVI_DateTime *dateTime, const char *element,
- virBufferPtr output);
+ virBuffer *output);
int esxVI_DateTime_Deserialize(xmlNodePtr node, esxVI_DateTime **dateTime);
int esxVI_DateTime_ConvertToCalendarTime(esxVI_DateTime *dateTime,
long long *secondsSinceEpoch);
esxVI_ManagedObjectReference **managedObjectReferenceList);
int esxVI_ManagedObjectReference_Serialize
(esxVI_ManagedObjectReference *managedObjectReference,
- const char *element, virBufferPtr output);
+ const char *element, virBuffer *output);
int esxVI_ManagedObjectReference_SerializeList
(esxVI_ManagedObjectReference *managedObjectReference,
- const char *element, virBufferPtr output);
+ const char *element, virBuffer *output);
int esxVI_ManagedObjectReference_Deserialize
(xmlNodePtr node, esxVI_ManagedObjectReference **managedObjectReference);
}
-static virCapsPtr
+static virCaps *
hypervCapsInit(hypervPrivate *priv)
{
- virCapsPtr caps = NULL;
- virCapsGuestPtr guest = NULL;
+ virCaps *caps = NULL;
+ virCapsGuest *guest = NULL;
caps = virCapabilitiesNew(VIR_ARCH_X86_64, 1, 1);
static int
-hypervDomainCreateSCSIController(virDomainPtr domain, virDomainControllerDefPtr def)
+hypervDomainCreateSCSIController(virDomainPtr domain, virDomainControllerDef *def)
{
g_autoptr(GHashTable) scsiResource = NULL;
g_autofree char *resourceType = NULL;
static int
hypervDomainAddVirtualDiskParent(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname,
WsXmlDocH *response)
static int
hypervDomainAddVirtualHardDisk(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
const char *hostname,
char *parentInstanceID)
{
static int
hypervDomainAttachVirtualDisk(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname)
{
static int
hypervDomainAttachPhysicalDisk(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname)
{
static int
hypervDomainAddOpticalDrive(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname,
WsXmlDocH *response)
static int
hypervDomainAddOpticalDisk(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
const char *hostname,
char *driveInstanceID)
{
static int
hypervDomainAttachCDROM(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname)
{
static int
hypervDomainAttachFloppy(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *driveSettings,
const char *hostname)
{
static int
hypervDomainAttachStorageVolume(virDomainPtr domain,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
Msvm_ResourceAllocationSettingData *controller,
const char *hostname)
{
static int
-hypervDomainAttachStorage(virDomainPtr domain, virDomainDefPtr def, const char *hostname)
+hypervDomainAttachStorage(virDomainPtr domain, virDomainDef *def, const char *hostname)
{
hypervPrivate *priv = domain->conn->privateData;
size_t i = 0;
static int
-hypervDomainAttachSerial(virDomainPtr domain, virDomainChrDefPtr serial)
+hypervDomainAttachSerial(virDomainPtr domain, virDomainChrDef *serial)
{
char uuid_string[VIR_UUID_STRING_BUFLEN];
hypervPrivate *priv = domain->conn->privateData;
g_autoptr(Msvm_VirtualSystemSettingData) vssd = NULL;
g_autoptr(Msvm_ResourceAllocationSettingData) rasd = NULL;
g_autoptr(Msvm_SerialPortSettingData) spsd = NULL;
- hypervWmiClassInfoPtr classInfo = NULL;
+ hypervWmiClassInfo *classInfo = NULL;
Msvm_ResourceAllocationSettingData *current = NULL;
Msvm_ResourceAllocationSettingData *entry = NULL;
g_autoptr(GHashTable) serialResource = NULL;
static int
hypervDomainAttachSyntheticEthernetAdapter(virDomainPtr domain,
- virDomainNetDefPtr net,
+ virDomainNetDef *net,
char *hostname)
{
hypervPrivate *priv = domain->conn->privateData;
* Functions for deserializing device entries
*/
static int
-hypervDomainDefAppendController(virDomainDefPtr def,
+hypervDomainDefAppendController(virDomainDef *def,
int idx,
virDomainControllerType controllerType)
{
- virDomainControllerDefPtr controller = NULL;
+ virDomainControllerDef *controller = NULL;
if (!(controller = virDomainControllerDefNew(controllerType)))
return -1;
static int
-hypervDomainDefAppendIDEController(virDomainDefPtr def)
+hypervDomainDefAppendIDEController(virDomainDef *def)
{
return hypervDomainDefAppendController(def, 0, VIR_DOMAIN_CONTROLLER_TYPE_IDE);
}
static int
-hypervDomainDefAppendSCSIController(virDomainDefPtr def, int idx)
+hypervDomainDefAppendSCSIController(virDomainDef *def, int idx)
{
return hypervDomainDefAppendController(def, idx, VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
}
static int
-hypervDomainDefAppendDisk(virDomainDefPtr def,
- virDomainDiskDefPtr disk,
+hypervDomainDefAppendDisk(virDomainDef *def,
+ virDomainDiskDef *disk,
virDomainDiskBus busType,
int diskNameOffset,
const char *diskNamePrefix,
static int
-hypervDomainDefParseFloppyStorageExtent(virDomainDefPtr def, virDomainDiskDefPtr disk)
+hypervDomainDefParseFloppyStorageExtent(virDomainDef *def, virDomainDiskDef *disk)
{
disk->bus = VIR_DOMAIN_DISK_BUS_FDC;
disk->dst = g_strdup("fda");
static int
hypervDomainDefParseVirtualExtent(hypervPrivate *priv,
- virDomainDefPtr def,
+ virDomainDef *def,
Msvm_StorageAllocationSettingData *disk_entry,
Msvm_ResourceAllocationSettingData *rasd,
Msvm_ResourceAllocationSettingData **ideChannels,
{
Msvm_ResourceAllocationSettingData *diskParent = NULL;
Msvm_ResourceAllocationSettingData *controller = NULL;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
int result = -1;
if (disk_entry->data->HostResource.count < 1)
static int
hypervDomainDefParsePhysicalDisk(hypervPrivate *priv,
- virDomainDefPtr def,
+ virDomainDef *def,
Msvm_ResourceAllocationSettingData *entry,
Msvm_ResourceAllocationSettingData *rasd,
Msvm_ResourceAllocationSettingData **ideChannels,
int result = -1;
Msvm_ResourceAllocationSettingData *controller = NULL;
g_autoptr(Msvm_DiskDrive) diskdrive = NULL;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
char **hostResource = entry->data->HostResource.data;
g_autofree char *hostEscaped = NULL;
g_autofree char *driveNumberStr = NULL;
static int
hypervDomainDefParseStorage(hypervPrivate *priv,
- virDomainDefPtr def,
+ virDomainDef *def,
Msvm_ResourceAllocationSettingData *rasd,
Msvm_StorageAllocationSettingData *sasd)
{
static int
-hypervDomainDefParseSerial(virDomainDefPtr def, Msvm_ResourceAllocationSettingData *rasd)
+hypervDomainDefParseSerial(virDomainDef *def, Msvm_ResourceAllocationSettingData *rasd)
{
for (; rasd; rasd = rasd->next) {
int port_num = 0;
char **conn = NULL;
const char *srcPath = NULL;
- virDomainChrDefPtr serial = NULL;
+ virDomainChrDef *serial = NULL;
if (rasd->data->ResourceType != MSVM_RASD_RESOURCETYPE_SERIAL_PORT)
continue;
static int
-hypervDomainDefParseEthernetAdapter(virDomainDefPtr def,
+hypervDomainDefParseEthernetAdapter(virDomainDef *def,
Msvm_EthernetPortAllocationSettingData *net,
hypervPrivate *priv)
{
static int
hypervDomainDefParseEthernet(virDomainPtr domain,
- virDomainDefPtr def,
+ virDomainDef *def,
Msvm_EthernetPortAllocationSettingData *nets)
{
Msvm_EthernetPortAllocationSettingData *entry = nets;
static virDrvOpenStatus
hypervConnectOpen(virConnectPtr conn, virConnectAuthPtr auth,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virDrvOpenStatus result = VIR_DRV_OPEN_ERROR;
/* Allocate space for all potential devices */
/* 256 scsi drives + 4 ide drives */
- def->disks = g_new0(virDomainDiskDefPtr,
+ def->disks = g_new0(virDomainDiskDef *,
HYPERV_MAX_SCSI_CONTROLLERS * HYPERV_MAX_DRIVES_PER_SCSI_CONTROLLER +
HYPERV_MAX_IDE_CHANNELS * HYPERV_MAX_DRIVES_PER_IDE_CHANNEL);
def->ndisks = 0;
/* 1 ide & 4 scsi controllers */
- def->controllers = g_new0(virDomainControllerDefPtr, 5);
+ def->controllers = g_new0(virDomainControllerDef *, 5);
def->ncontrollers = 0;
/* 8 synthetic + 4 legacy NICs */
- def->nets = g_new0(virDomainNetDefPtr, 12);
+ def->nets = g_new0(virDomainNetDef *, 12);
def->nnets = 0;
if (hypervDomainDefParseStorage(priv, def, rasd, sasd) < 0)
struct _hypervPrivate {
hypervParsedUri *parsedUri;
WsManClient *client;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
char *version;
};
VIR_LOG_INIT("hyperv.hyperv_util");
int
-hypervParseUri(hypervParsedUri **parsedUri, virURIPtr uri)
+hypervParseUri(hypervParsedUri **parsedUri, virURI *uri)
{
int result = -1;
size_t i;
*parsedUri = g_new0(hypervParsedUri, 1);
for (i = 0; i < uri->paramsCount; i++) {
- virURIParamPtr queryParam = &uri->params[i];
+ virURIParam *queryParam = &uri->params[i];
if (STRCASEEQ(queryParam->name, "transport")) {
VIR_FREE((*parsedUri)->transport);
char *transport;
};
-int hypervParseUri(hypervParsedUri **parsedUri, virURIPtr uri);
+int hypervParseUri(hypervParsedUri **parsedUri, virURI *uri);
void hypervFreeParsedUri(hypervParsedUri **parsedUri);
VIR_LOG_INIT("hyperv.hyperv_wmi");
int
-hypervGetWmiClassList(hypervPrivate *priv, hypervWmiClassInfoPtr wmiInfo,
- virBufferPtr query, hypervObject **wmiClass)
+hypervGetWmiClassList(hypervPrivate *priv, hypervWmiClassInfo *wmiInfo,
+ virBuffer *query, hypervObject **wmiClass)
{
hypervWqlQuery wqlQuery = HYPERV_WQL_QUERY_INITIALIZER;
* Returns a pointer to the newly instantiated object on success, which should
* be freed by hypervInvokeMethod. Otherwise returns NULL.
*/
-hypervInvokeParamsListPtr
+hypervInvokeParamsList *
hypervCreateInvokeParamsList(const char *method,
const char *selector,
- hypervWmiClassInfoPtr info)
+ hypervWmiClassInfo *info)
{
- hypervInvokeParamsListPtr params = NULL;
+ hypervInvokeParamsList *params = NULL;
params = g_new0(hypervInvokeParamsList, 1);
*
*/
void
-hypervFreeInvokeParams(hypervInvokeParamsListPtr params)
+hypervFreeInvokeParams(hypervInvokeParamsList *params)
{
- hypervParamPtr p = NULL;
+ hypervParam *p = NULL;
size_t i = 0;
if (params == NULL)
static inline int
-hypervCheckParams(hypervInvokeParamsListPtr params)
+hypervCheckParams(hypervInvokeParamsList *params)
{
if (params->nbParams + 1 > params->nbAvailParams) {
VIR_EXPAND_N(params->params, params->nbAvailParams, 5);
* Returns -1 on failure, 0 on success.
*/
int
-hypervAddSimpleParam(hypervInvokeParamsListPtr params, const char *name,
+hypervAddSimpleParam(hypervInvokeParamsList *params, const char *name,
const char *value)
{
- hypervParamPtr p = NULL;
+ hypervParam *p = NULL;
if (hypervCheckParams(params) < 0)
return -1;
* Adds an EPR param to the params list. Returns -1 on failure, 0 on success.
*/
int
-hypervAddEprParam(hypervInvokeParamsListPtr params,
+hypervAddEprParam(hypervInvokeParamsList *params,
const char *name,
- virBufferPtr query,
- hypervWmiClassInfoPtr classInfo)
+ virBuffer *query,
+ hypervWmiClassInfo *classInfo)
{
- hypervParamPtr p = NULL;
+ hypervParam *p = NULL;
if (hypervCheckParams(params) < 0)
return -1;
* Returns a pointer to the GHashTable on success, otherwise NULL.
*/
GHashTable *
-hypervCreateEmbeddedParam(hypervWmiClassInfoPtr classInfo)
+hypervCreateEmbeddedParam(hypervWmiClassInfo *classInfo)
{
size_t i;
size_t count;
* Returns -1 on failure, 0 on success.
*/
int
-hypervAddEmbeddedParam(hypervInvokeParamsListPtr params,
+hypervAddEmbeddedParam(hypervInvokeParamsList *params,
const char *name,
GHashTable **table,
- hypervWmiClassInfoPtr classInfo)
+ hypervWmiClassInfo *classInfo)
{
- hypervParamPtr p = NULL;
+ hypervParam *p = NULL;
if (hypervCheckParams(params) < 0)
return -1;
* Serializing parameters to XML and invoking methods
*/
static int
-hypervGetCimTypeInfo(hypervCimTypePtr typemap, const char *name,
- hypervCimTypePtr *property)
+hypervGetCimTypeInfo(hypervCimType *typemap, const char *name,
+ hypervCimType **property)
{
size_t i = 0;
while (typemap[i].name[0] != '\0') {
static int
-hypervCreateInvokeXmlDoc(hypervInvokeParamsListPtr params, WsXmlDocH *docRoot)
+hypervCreateInvokeXmlDoc(hypervInvokeParamsList *params, WsXmlDocH *docRoot)
{
g_autofree char *method = g_strdup_printf("%s_INPUT", params->method);
g_auto(WsXmlDocH) invokeXmlDocRoot = ws_xml_create_doc(NULL, method);
static int
-hypervSerializeSimpleParam(hypervParamPtr p, const char *resourceUri,
+hypervSerializeSimpleParam(hypervParam *p, const char *resourceUri,
WsXmlNodeH *methodNode)
{
WsXmlNodeH xmlNodeParam = NULL;
static int
-hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
+hypervSerializeEprParam(hypervParam *p, hypervPrivate *priv,
const char *resourceUri, WsXmlNodeH *methodNode)
{
WsXmlNodeH xmlNodeParam = NULL,
static int
-hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
+hypervSerializeEmbeddedParam(hypervParam *p, const char *resourceUri,
WsXmlNodeH *methodNode)
{
WsXmlNodeH xmlNodeInstance = NULL,
g_auto(WsXmlDocH) xmlDocCdata = NULL;
g_autofree char *cdataContent = NULL;
xmlNodePtr xmlNodeCdata = NULL;
- hypervWmiClassInfoPtr classInfo = p->embedded.info;
- g_autofree virHashKeyValuePairPtr items = NULL;
- hypervCimTypePtr property = NULL;
+ hypervWmiClassInfo *classInfo = p->embedded.info;
+ g_autofree virHashKeyValuePair *items = NULL;
+ hypervCimType *property = NULL;
ssize_t numKeys = -1;
int len = 0, i = 0;
*/
int
hypervInvokeMethod(hypervPrivate *priv,
- hypervInvokeParamsListPtr *paramsPtr,
+ hypervInvokeParamsList **paramsPtr,
WsXmlDocH *res)
{
g_autoptr(hypervInvokeParamsList) params = *paramsPtr;
g_auto(virBuffer) query = VIR_BUFFER_INITIALIZER;
g_autoptr(Msvm_ConcreteJob) job = NULL;
int jobState = -1;
- hypervParamPtr p = NULL;
+ hypervParam *p = NULL;
int timeout = HYPERV_JOB_TIMEOUT_MS;
*paramsPtr = NULL;
/* This function guarantees that wqlQuery->query is reset, even on failure */
int
-hypervEnumAndPull(hypervPrivate *priv, hypervWqlQueryPtr wqlQuery,
+hypervEnumAndPull(hypervPrivate *priv, hypervWqlQuery *wqlQuery,
hypervObject **list)
{
WsSerializerContextH serializerContext;
g_autoptr(client_opt_t) options = NULL;
g_autofree char *query_string = NULL;
- hypervWmiClassInfoPtr wmiInfo = wqlQuery->info;
+ hypervWmiClassInfo *wmiInfo = wqlQuery->info;
g_autoptr(filter_t) filter = NULL;
g_auto(WsXmlDocH) response = NULL;
g_autofree char *enumContext = NULL;
int
hypervMsvmVSMSAddResourceSettings(virDomainPtr domain,
GHashTable **resourceSettingsPtr,
- hypervWmiClassInfoPtr wmiInfo,
+ hypervWmiClassInfo *wmiInfo,
WsXmlDocH *response)
{
hypervPrivate *priv = domain->conn->privateData;
int
hypervMsvmVSMSModifyResourceSettings(hypervPrivate *priv,
GHashTable **resourceSettingsPtr,
- hypervWmiClassInfoPtr wmiInfo)
+ hypervWmiClassInfo *wmiInfo)
{
g_autoptr(GHashTable) resourceSettings = *resourceSettingsPtr;
g_autoptr(hypervInvokeParamsList) params = NULL;
typedef struct _hypervObject hypervObject;
struct _hypervObject {
XML_TYPE_PTR data; /* Unserialized data from wsman response */
- hypervWmiClassInfoPtr info; /* The info used to make wsman request */
+ hypervWmiClassInfo *info; /* The info used to make wsman request */
hypervObject *next;
hypervPrivate *priv;
};
typedef struct _hypervWqlQuery hypervWqlQuery;
-typedef hypervWqlQuery *hypervWqlQueryPtr;
struct _hypervWqlQuery {
- virBufferPtr query;
- hypervWmiClassInfoPtr info;
+ virBuffer *query;
+ hypervWmiClassInfo *info;
};
-int hypervEnumAndPull(hypervPrivate *priv, hypervWqlQueryPtr wqlQuery,
+int hypervEnumAndPull(hypervPrivate *priv, hypervWqlQuery *wqlQuery,
hypervObject **list);
void hypervFreeObject(void *object);
struct _hypervEprParam {
const char *name;
- virBufferPtr query;
- hypervWmiClassInfoPtr info; /* info of the object this param represents */
+ virBuffer *query;
+ hypervWmiClassInfo *info; /* info of the object this param represents */
};
typedef struct _hypervEprParam hypervEprParam;
struct _hypervEmbeddedParam {
const char *name;
GHashTable *table;
- hypervWmiClassInfoPtr info; /* info of the object this param represents */
+ hypervWmiClassInfo *info; /* info of the object this param represents */
};
typedef struct _hypervEmbeddedParam hypervEmbeddedParam;
};
};
typedef struct _hypervParam hypervParam;
-typedef hypervParam *hypervParamPtr;
struct _hypervInvokeParamsList {
const char *method;
const char *ns;
const char *resourceUri;
const char *selector;
- hypervParamPtr params;
+ hypervParam *params;
size_t nbParams;
size_t nbAvailParams;
};
typedef struct _hypervInvokeParamsList hypervInvokeParamsList;
-typedef hypervInvokeParamsList *hypervInvokeParamsListPtr;
-hypervInvokeParamsListPtr hypervCreateInvokeParamsList(const char *method,
+hypervInvokeParamsList *hypervCreateInvokeParamsList(const char *method,
const char *selector,
- hypervWmiClassInfoPtr obj);
+ hypervWmiClassInfo *obj);
-void hypervFreeInvokeParams(hypervInvokeParamsListPtr params);
+void hypervFreeInvokeParams(hypervInvokeParamsList *params);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(hypervInvokeParamsList, hypervFreeInvokeParams);
-int hypervAddSimpleParam(hypervInvokeParamsListPtr params, const char *name,
+int hypervAddSimpleParam(hypervInvokeParamsList *params, const char *name,
const char *value);
-int hypervAddEprParam(hypervInvokeParamsListPtr params,
+int hypervAddEprParam(hypervInvokeParamsList *params,
const char *name,
- virBufferPtr query,
- hypervWmiClassInfoPtr eprInfo);
+ virBuffer *query,
+ hypervWmiClassInfo *eprInfo);
-GHashTable *hypervCreateEmbeddedParam(hypervWmiClassInfoPtr info);
+GHashTable *hypervCreateEmbeddedParam(hypervWmiClassInfo *info);
int hypervSetEmbeddedProperty(GHashTable *table,
const char *name,
const char *value);
-int hypervAddEmbeddedParam(hypervInvokeParamsListPtr params,
+int hypervAddEmbeddedParam(hypervInvokeParamsList *params,
const char *name,
GHashTable **table,
- hypervWmiClassInfoPtr info);
+ hypervWmiClassInfo *info);
void hypervFreeEmbeddedParam(GHashTable *p);
int hypervInvokeMethod(hypervPrivate *priv,
- hypervInvokeParamsListPtr *paramsPtr,
+ hypervInvokeParamsList **paramsPtr,
WsXmlDocH *res);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
int hypervGetWmiClassList(hypervPrivate *priv,
- hypervWmiClassInfoPtr wmiInfo,
- virBufferPtr query,
+ hypervWmiClassInfo *wmiInfo,
+ virBuffer *query,
hypervObject **wmiClass);
/**
int hypervMsvmVSMSAddResourceSettings(virDomainPtr domain,
GHashTable **resourceSettingsPtr,
- hypervWmiClassInfoPtr wmiInfo,
+ hypervWmiClassInfo *wmiInfo,
WsXmlDocH *response);
int hypervMsvmVSMSModifyResourceSettings(hypervPrivate *priv,
GHashTable **resourceSettingsPtr,
- hypervWmiClassInfoPtr wmiInfo);
+ hypervWmiClassInfo *wmiInfo);
*/
typedef struct _hypervCimType hypervCimType;
-typedef hypervCimType *hypervCimTypePtr;
struct _hypervCimType {
/* Parameter name */
const char *name;
};
typedef struct _hypervWmiClassInfo hypervWmiClassInfo;
-typedef hypervWmiClassInfo *hypervWmiClassInfoPtr;
struct _hypervWmiClassInfo {
/* The WMI class name */
const char *name;
/* The wsman serializer info - one of the *_TypeInfo structs */
XmlSerializerInfo *serializerInfo;
/* Property type information */
- hypervCimTypePtr propertyInfo;
+ hypervCimType *propertyInfo;
};
#include "hyperv_wmi_classes.generated.h"
int
-virDomainCgroupSetupBlkio(virCgroupPtr cgroup, virDomainBlkiotune blkio)
+virDomainCgroupSetupBlkio(virCgroup *cgroup, virDomainBlkiotune blkio)
{
size_t i;
if (blkio.ndevices) {
for (i = 0; i < blkio.ndevices; i++) {
- virBlkioDevicePtr dev = &blkio.devices[i];
+ virBlkioDevice *dev = &blkio.devices[i];
if (dev->weight &&
virCgroupSetupBlkioDeviceWeight(cgroup, dev->path,
int
-virDomainCgroupSetupMemtune(virCgroupPtr cgroup, virDomainMemtune mem)
+virDomainCgroupSetupMemtune(virCgroup *cgroup, virDomainMemtune mem)
{
if (virMemoryLimitIsSet(mem.hard_limit))
if (virCgroupSetMemoryHardLimit(cgroup, mem.hard_limit) < 0)
int
-virDomainCgroupSetupDomainBlkioParameters(virCgroupPtr cgroup,
- virDomainDefPtr def,
+virDomainCgroupSetupDomainBlkioParameters(virCgroup *cgroup,
+ virDomainDef *def,
virTypedParameterPtr params,
int nparams)
{
STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_READ_BPS) ||
STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS)) {
size_t ndevices;
- virBlkioDevicePtr devices = NULL;
+ virBlkioDevice *devices = NULL;
size_t j;
if (virDomainDriverParseBlkioDeviceStr(params[i].value.s,
int
-virDomainCgroupSetMemoryLimitParameters(virCgroupPtr cgroup,
- virDomainObjPtr vm,
- virDomainDefPtr liveDef,
- virDomainDefPtr persistentDef,
+virDomainCgroupSetMemoryLimitParameters(virCgroup *cgroup,
+ virDomainObj *vm,
+ virDomainDef *liveDef,
+ virDomainDef *persistentDef,
virTypedParameterPtr params,
int nparams)
{
#include "domain_conf.h"
-int virDomainCgroupSetupBlkio(virCgroupPtr cgroup, virDomainBlkiotune blkio);
-int virDomainCgroupSetupMemtune(virCgroupPtr cgroup, virDomainMemtune mem);
-int virDomainCgroupSetupDomainBlkioParameters(virCgroupPtr cgroup,
- virDomainDefPtr def,
+int virDomainCgroupSetupBlkio(virCgroup *cgroup, virDomainBlkiotune blkio);
+int virDomainCgroupSetupMemtune(virCgroup *cgroup, virDomainMemtune mem);
+int virDomainCgroupSetupDomainBlkioParameters(virCgroup *cgroup,
+ virDomainDef *def,
virTypedParameterPtr params,
int nparams);
-int virDomainCgroupSetMemoryLimitParameters(virCgroupPtr cgroup,
- virDomainObjPtr vm,
- virDomainDefPtr liveDef,
- virDomainDefPtr persistentDef,
+int virDomainCgroupSetMemoryLimitParameters(virCgroup *cgroup,
+ virDomainObj *vm,
+ virDomainDef *liveDef,
+ virDomainDef *persistentDef,
virTypedParameterPtr params,
int nparams);
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
static void
-virDomainMachineNameAppendValid(virBufferPtr buf,
+virDomainMachineNameAppendValid(virBuffer *buf,
const char *name)
{
bool skip = true;
/* Modify dest_array to reflect all blkio device changes described in
* src_array. */
int
-virDomainDriverMergeBlkioDevice(virBlkioDevicePtr *dest_array,
+virDomainDriverMergeBlkioDevice(virBlkioDevice **dest_array,
size_t *dest_size,
- virBlkioDevicePtr src_array,
+ virBlkioDevice *src_array,
size_t src_size,
const char *type)
{
size_t i, j;
- virBlkioDevicePtr dest;
- virBlkioDevicePtr src;
+ virBlkioDevice *dest;
+ virBlkioDevice *src;
for (i = 0; i < src_size; i++) {
bool found = false;
*/
int
virDomainDriverParseBlkioDeviceStr(char *blkioDeviceStr, const char *type,
- virBlkioDevicePtr *dev, size_t *size)
+ virBlkioDevice **dev, size_t *size)
{
char *temp;
int ndevices = 0;
int nsep = 0;
size_t i;
- virBlkioDevicePtr result = NULL;
+ virBlkioDevice *result = NULL;
*dev = NULL;
*size = 0;
int
-virDomainDriverSetupPersistentDefBlkioParams(virDomainDefPtr persistentDef,
+virDomainDriverSetupPersistentDefBlkioParams(virDomainDef *persistentDef,
virTypedParameterPtr params,
int nparams)
{
STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS) ||
STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_READ_BPS) ||
STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS)) {
- virBlkioDevicePtr devices = NULL;
+ virBlkioDevice *devices = NULL;
size_t ndevices;
if (virDomainDriverParseBlkioDeviceStr(param->value.s,
int
-virDomainDriverNodeDeviceGetPCIInfo(virNodeDeviceDefPtr def,
- virPCIDeviceAddressPtr devAddr)
+virDomainDriverNodeDeviceGetPCIInfo(virNodeDeviceDef *def,
+ virPCIDeviceAddress *devAddr)
{
- virNodeDevCapsDefPtr cap;
+ virNodeDevCapsDef *cap;
cap = def->caps;
while (cap) {
int
virDomainDriverNodeDeviceReset(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr)
+ virHostdevManager *hostdevMgr)
{
g_autoptr(virPCIDevice) pci = NULL;
virPCIDeviceAddress devAddr;
int
virDomainDriverNodeDeviceReAttach(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr)
+ virHostdevManager *hostdevMgr)
{
g_autoptr(virPCIDevice) pci = NULL;
virPCIDeviceAddress devAddr;
int
virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr,
+ virHostdevManager *hostdevMgr,
const char *driverName)
{
g_autoptr(virPCIDevice) pci = NULL;
const char *name,
bool privileged);
-int virDomainDriverMergeBlkioDevice(virBlkioDevicePtr *dest_array,
+int virDomainDriverMergeBlkioDevice(virBlkioDevice **dest_array,
size_t *dest_size,
- virBlkioDevicePtr src_array,
+ virBlkioDevice *src_array,
size_t src_size,
const char *type);
int virDomainDriverParseBlkioDeviceStr(char *blkioDeviceStr, const char *type,
- virBlkioDevicePtr *dev, size_t *size);
+ virBlkioDevice **dev, size_t *size);
-int virDomainDriverSetupPersistentDefBlkioParams(virDomainDefPtr persistentDef,
+int virDomainDriverSetupPersistentDefBlkioParams(virDomainDef *persistentDef,
virTypedParameterPtr params,
int nparams);
-int virDomainDriverNodeDeviceGetPCIInfo(virNodeDeviceDefPtr def,
- virPCIDeviceAddressPtr devAddr);
+int virDomainDriverNodeDeviceGetPCIInfo(virNodeDeviceDef *def,
+ virPCIDeviceAddress *devAddr);
int virDomainDriverNodeDeviceReset(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr);
+ virHostdevManager *hostdevMgr);
int virDomainDriverNodeDeviceReAttach(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr);
+ virHostdevManager *hostdevMgr);
int virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev,
- virHostdevManagerPtr hostdevMgr,
+ virHostdevManager *hostdevMgr,
const char *driverName);
VIR_LOG_INIT("util.closecallbacks");
typedef struct _virDriverCloseDef virDriverCloseDef;
-typedef virDriverCloseDef *virDriverCloseDefPtr;
struct _virDriverCloseDef {
virConnectPtr conn;
virCloseCallback cb;
};
-static virClassPtr virCloseCallbacksClass;
+static virClass *virCloseCallbacksClass;
static void virCloseCallbacksDispose(void *obj);
static int virCloseCallbacksOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virCloseCallbacks);
-virCloseCallbacksPtr
+virCloseCallbacks *
virCloseCallbacksNew(void)
{
- virCloseCallbacksPtr closeCallbacks;
+ virCloseCallbacks *closeCallbacks;
if (virCloseCallbacksInitialize() < 0)
return NULL;
static void
virCloseCallbacksDispose(void *obj)
{
- virCloseCallbacksPtr closeCallbacks = obj;
+ virCloseCallbacks *closeCallbacks = obj;
virHashFree(closeCallbacks->list);
}
int
-virCloseCallbacksSet(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+virCloseCallbacksSet(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virConnectPtr conn,
virCloseCallback cb)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDriverCloseDefPtr closeDef;
+ virDriverCloseDef *closeDef;
int ret = -1;
virUUIDFormat(vm->def->uuid, uuidstr);
}
int
-virCloseCallbacksUnset(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+virCloseCallbacksUnset(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virCloseCallback cb)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDriverCloseDefPtr closeDef;
+ virDriverCloseDef *closeDef;
int ret = -1;
virUUIDFormat(vm->def->uuid, uuidstr);
}
virCloseCallback
-virCloseCallbacksGet(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+virCloseCallbacksGet(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virConnectPtr conn)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDriverCloseDefPtr closeDef;
+ virDriverCloseDef *closeDef;
virCloseCallback cb = NULL;
virUUIDFormat(vm->def->uuid, uuidstr);
}
virConnectPtr
-virCloseCallbacksGetConn(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm)
+virCloseCallbacksGetConn(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDriverCloseDefPtr closeDef;
+ virDriverCloseDef *closeDef;
virConnectPtr conn = NULL;
virUUIDFormat(vm->def->uuid, uuidstr);
typedef struct _virCloseCallbacksListEntry virCloseCallbacksListEntry;
-typedef virCloseCallbacksListEntry *virCloseCallbacksListEntryPtr;
struct _virCloseCallbacksListEntry {
unsigned char uuid[VIR_UUID_BUFLEN];
virCloseCallback callback;
};
typedef struct _virCloseCallbacksList virCloseCallbacksList;
-typedef virCloseCallbacksList *virCloseCallbacksListPtr;
struct _virCloseCallbacksList {
size_t nentries;
- virCloseCallbacksListEntryPtr entries;
+ virCloseCallbacksListEntry *entries;
};
struct virCloseCallbacksData {
virConnectPtr conn;
- virCloseCallbacksListPtr list;
+ virCloseCallbacksList *list;
};
static int
void *opaque)
{
struct virCloseCallbacksData *data = opaque;
- virDriverCloseDefPtr closeDef = payload;
+ virDriverCloseDef *closeDef = payload;
const char *uuidstr = key;
unsigned char uuid[VIR_UUID_BUFLEN];
return 0;
}
-static virCloseCallbacksListPtr
-virCloseCallbacksGetForConn(virCloseCallbacksPtr closeCallbacks,
+static virCloseCallbacksList *
+virCloseCallbacksGetForConn(virCloseCallbacks *closeCallbacks,
virConnectPtr conn)
{
- virCloseCallbacksListPtr list = NULL;
+ virCloseCallbacksList *list = NULL;
struct virCloseCallbacksData data;
list = g_new0(virCloseCallbacksList, 1);
void
-virCloseCallbacksRun(virCloseCallbacksPtr closeCallbacks,
+virCloseCallbacksRun(virCloseCallbacks *closeCallbacks,
virConnectPtr conn,
- virDomainObjListPtr domains,
+ virDomainObjList *domains,
void *opaque)
{
- virCloseCallbacksListPtr list;
+ virCloseCallbacksList *list;
size_t i;
VIR_DEBUG("conn=%p", conn);
virObjectUnlock(closeCallbacks);
for (i = 0; i < list->nentries; i++) {
- virDomainObjPtr vm;
+ virDomainObj *vm;
/* Grab a ref and lock to the vm */
if (!(vm = virDomainObjListFindByUUID(domains,
#include "conf/virdomainobjlist.h"
typedef struct _virCloseCallbacks virCloseCallbacks;
-typedef virCloseCallbacks *virCloseCallbacksPtr;
-typedef void (*virCloseCallback)(virDomainObjPtr vm,
+typedef void (*virCloseCallback)(virDomainObj *vm,
virConnectPtr conn,
void *opaque);
-virCloseCallbacksPtr virCloseCallbacksNew(void);
-int virCloseCallbacksSet(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+virCloseCallbacks *virCloseCallbacksNew(void);
+int virCloseCallbacksSet(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virConnectPtr conn,
virCloseCallback cb);
-int virCloseCallbacksUnset(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+int virCloseCallbacksUnset(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virCloseCallback cb);
virCloseCallback
-virCloseCallbacksGet(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm,
+virCloseCallbacksGet(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm,
virConnectPtr conn);
virConnectPtr
-virCloseCallbacksGetConn(virCloseCallbacksPtr closeCallbacks,
- virDomainObjPtr vm);
+virCloseCallbacksGetConn(virCloseCallbacks *closeCallbacks,
+ virDomainObj *vm);
void
-virCloseCallbacksRun(virCloseCallbacksPtr closeCallbacks,
+virCloseCallbacksRun(virCloseCallbacks *closeCallbacks,
virConnectPtr conn,
- virDomainObjListPtr domains,
+ virDomainObjList *domains,
void *opaque);
#define HOSTDEV_STATE_DIR RUNSTATEDIR "/libvirt/hostdevmgr"
-static virHostdevManagerPtr manager; /* global hostdev manager, never freed */
+static virHostdevManager *manager; /* global hostdev manager, never freed */
-static virClassPtr virHostdevManagerClass;
+static virClass *virHostdevManagerClass;
static void virHostdevManagerDispose(void *obj);
-static virHostdevManagerPtr virHostdevManagerNew(void);
+static virHostdevManager *virHostdevManagerNew(void);
struct virHostdevIsPCINodeDeviceUsedData {
- virHostdevManagerPtr mgr;
+ virHostdevManager *mgr;
const char *driverName;
const char *domainName;
bool usesVFIO;
* module usually expect an 'actual'. Even with these conventions in place,
* adding comments to highlight ownership-related issues is recommended */
-static int virHostdevIsPCINodeDeviceUsed(virPCIDeviceAddressPtr devAddr, void *opaque)
+static int virHostdevIsPCINodeDeviceUsed(virPCIDeviceAddress *devAddr, void *opaque)
{
- virPCIDevicePtr actual;
+ virPCIDevice *actual;
struct virHostdevIsPCINodeDeviceUsedData *helperData = opaque;
actual = virPCIDeviceListFindByIDs(helperData->mgr->activePCIHostdevs,
static void
virHostdevManagerDispose(void *obj)
{
- virHostdevManagerPtr hostdevMgr = obj;
+ virHostdevManager *hostdevMgr = obj;
virObjectUnref(hostdevMgr->activePCIHostdevs);
virObjectUnref(hostdevMgr->inactivePCIHostdevs);
g_free(hostdevMgr->stateDir);
}
-static virHostdevManagerPtr
+static virHostdevManager *
virHostdevManagerNew(void)
{
g_autoptr(virHostdevManager) hostdevMgr = NULL;
return g_steal_pointer(&hostdevMgr);
}
-virHostdevManagerPtr
+virHostdevManager *
virHostdevManagerGetDefault(void)
{
if (virHostdevManagerInitialize() < 0)
*/
static int
virHostdevGetPCIHostDevice(const virDomainHostdevDef *hostdev,
- virPCIDevicePtr *pci)
+ virPCIDevice **pci)
{
g_autoptr(virPCIDevice) actual = NULL;
const virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
return 0;
}
-static virPCIDeviceListPtr
-virHostdevGetPCIHostDeviceList(virDomainHostdevDefPtr *hostdevs, int nhostdevs)
+static virPCIDeviceList *
+virHostdevGetPCIHostDeviceList(virDomainHostdevDef **hostdevs, int nhostdevs)
{
g_autoptr(virPCIDeviceList) pcidevs = NULL;
size_t i;
return NULL;
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virDomainHostdevDef *hostdev = hostdevs[i];
g_autoptr(virPCIDevice) pci = NULL;
if (virHostdevGetPCIHostDevice(hostdev, &pci) == -1)
static int
-virHostdevPCISysfsPath(virDomainHostdevDefPtr hostdev,
+virHostdevPCISysfsPath(virDomainHostdevDef *hostdev,
char **sysfs_path)
{
return virPCIDeviceAddressGetSysfsFile(&hostdev->source.subsys.u.pci.addr, sysfs_path);
static int
-virHostdevIsVirtualFunction(virDomainHostdevDefPtr hostdev)
+virHostdevIsVirtualFunction(virDomainHostdevDef *hostdev)
{
g_autofree char *sysfs_path = NULL;
static int
-virHostdevNetDevice(virDomainHostdevDefPtr hostdev,
+virHostdevNetDevice(virDomainHostdevDef *hostdev,
int pfNetDevIdx,
char **linkdev,
int *vf)
* Returns 0 on success, -1 on failure.
*/
static int
-virHostdevSaveNetConfig(virDomainHostdevDefPtr hostdev,
+virHostdevSaveNetConfig(virDomainHostdevDef *hostdev,
const char *stateDir)
{
g_autofree char *linkdev = NULL;
* Returns 0 on success, -1 on failure.
*/
static int
-virHostdevSetNetConfig(virDomainHostdevDefPtr hostdev,
+virHostdevSetNetConfig(virDomainHostdevDef *hostdev,
const unsigned char *uuid)
{
g_autofree char *linkdev = NULL;
static int
-virHostdevRestoreNetConfig(virDomainHostdevDefPtr hostdev,
+virHostdevRestoreNetConfig(virDomainHostdevDef *hostdev,
const char *stateDir)
{
g_autofree char *linkdev = NULL;
- g_autofree virMacAddrPtr MAC = NULL;
- g_autofree virMacAddrPtr adminMAC = NULL;
+ g_autofree virMacAddr *MAC = NULL;
+ g_autofree virMacAddr *adminMAC = NULL;
g_autoptr(virNetDevVlan) vlan = NULL;
const virNetDevVPortProfile *virtPort;
int vf = -1;
}
static int
-virHostdevResetAllPCIDevices(virHostdevManagerPtr mgr,
- virPCIDeviceListPtr pcidevs)
+virHostdevResetAllPCIDevices(virHostdevManager *mgr,
+ virPCIDeviceList *pcidevs)
{
int ret = 0;
size_t i;
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
/* We can avoid looking up the actual device here, because performing
* a PCI reset on a device doesn't require any information other than
}
static void
-virHostdevReattachAllPCIDevices(virHostdevManagerPtr mgr,
- virPCIDeviceListPtr pcidevs)
+virHostdevReattachAllPCIDevices(virHostdevManager *mgr,
+ virPCIDeviceList *pcidevs)
{
size_t i;
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
- virPCIDevicePtr actual;
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *actual;
/* We need to look up the actual device because that's what
* virPCIDeviceReattach() expects as its argument */
static int
-virHostdevPreparePCIDevicesImpl(virHostdevManagerPtr mgr,
+virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
const unsigned char *uuid,
- virPCIDeviceListPtr pcidevs,
- virDomainHostdevDefPtr *hostdevs,
+ virPCIDeviceList *pcidevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
{
int last_processed_hostdev_vf = -1;
size_t i;
int ret = -1;
- virPCIDeviceAddressPtr devAddr = NULL;
+ virPCIDeviceAddress *devAddr = NULL;
virObjectLock(mgr->activePCIHostdevs);
virObjectLock(mgr->inactivePCIHostdevs);
/* Step 1: Perform some initial checks on the devices */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
bool strict_acs_check = !!(flags & VIR_HOSTDEV_STRICT_ACS_CHECK);
bool usesVFIO = (virPCIDeviceGetStubDriver(pci) == VIR_PCI_STUB_DRIVER_VFIO);
struct virHostdevIsPCINodeDeviceUsedData data = {mgr, drv_name, dom_name, false};
/* Step 2: detach managed devices and make sure unmanaged devices
* have already been taken care of */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
if (virPCIDeviceGetManaged(pci)) {
/* Step 5: Move devices from the inactive list to the active list */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
- virPCIDevicePtr actual;
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *actual;
VIR_DEBUG("Removing PCI device %s from inactive list",
virPCIDeviceGetName(pci));
/* Step 6: Set driver and domain information */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci;
- virPCIDevicePtr actual;
+ virPCIDevice *pci;
+ virPCIDevice *actual;
/* We need to look up the actual device and set the information
* there because 'pci' only contain address information and will
/* Step 7: Now set the original states for hostdev def */
for (i = 0; i < nhostdevs; i++) {
- virPCIDevicePtr actual;
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virPCIDevice *actual;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
continue;
/* Move devices back to the inactive list so that they can be
* processed properly below (reattachdevs label) */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
- virPCIDevicePtr actual;
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *actual;
VIR_DEBUG("Removing PCI device %s from active list",
virPCIDeviceGetName(pci));
int
-virHostdevPreparePCIDevices(virHostdevManagerPtr mgr,
+virHostdevPreparePCIDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
const unsigned char *uuid,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
{
static void
-virHostdevReAttachPCIDevicesImpl(virHostdevManagerPtr mgr,
+virHostdevReAttachPCIDevicesImpl(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virPCIDeviceListPtr pcidevs,
- virDomainHostdevDefPtr *hostdevs,
+ virPCIDeviceList *pcidevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
* used by the current domain and driver */
i = 0;
while (i < virPCIDeviceListCount(pcidevs)) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
- virPCIDevicePtr actual = NULL;
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *actual = NULL;
/* We need to look up the actual device, which is the one containing
* information such as by which domain and driver it is used. As a
/* Step 2: Move devices from the active list to the inactive list */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pcidevs, i);
- virPCIDevicePtr actual;
+ virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i);
+ virPCIDevice *actual;
VIR_DEBUG("Removing PCI device %s from active list",
virPCIDeviceGetName(pci));
* <interface type='hostdev'>
*/
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virDomainHostdevDef *hostdev = hostdevs[i];
if (virHostdevIsPCINetDevice(hostdev)) {
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
- virPCIDevicePtr actual;
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
+ virPCIDevice *actual;
actual = virPCIDeviceListFindByIDs(mgr->inactivePCIHostdevs,
pcisrc->addr.domain,
static void
-virHostdevDeleteMissingPCIDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevDeleteMissingPCIDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
void
-virHostdevReAttachPCIDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachPCIDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
g_autoptr(virPCIDeviceList) pcidevs = NULL;
int
-virHostdevUpdateActivePCIDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActivePCIDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
}
int
-virHostdevUpdateActiveUSBDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveUSBDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
{
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainHostdevDef *hostdev = NULL;
size_t i;
int ret = -1;
virObjectLock(mgr->activeUSBHostdevs);
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevSubsysUSBPtr usbsrc;
+ virDomainHostdevSubsysUSB *usbsrc;
g_autoptr(virUSBDevice) usb = NULL;
hostdev = hostdevs[i];
usbsrc = &hostdev->source.subsys.u.usb;
}
static int
-virHostdevUpdateActiveSCSIHostDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr hostdev,
- virDomainHostdevSubsysSCSIPtr scsisrc,
+virHostdevUpdateActiveSCSIHostDevices(virHostdevManager *mgr,
+ virDomainHostdevDef *hostdev,
+ virDomainHostdevSubsysSCSI *scsisrc,
const char *drv_name,
const char *dom_name)
{
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi = NULL;
- virSCSIDevicePtr tmp = NULL;
+ virSCSIDevice *tmp = NULL;
if (!(scsi = virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
}
int
-virHostdevUpdateActiveSCSIDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveSCSIDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
{
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainHostdevDef *hostdev = NULL;
size_t i;
int ret = -1;
virObjectLock(mgr->activeSCSIHostdevs);
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevSubsysSCSIPtr scsisrc;
+ virDomainHostdevSubsysSCSI *scsisrc;
hostdev = hostdevs[i];
scsisrc = &hostdev->source.subsys.u.scsi;
int
-virHostdevUpdateActiveMediatedDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveMediatedDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
virObjectLock(mgr->activeMediatedHostdevs);
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysMediatedDevPtr mdevsrc;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysMediatedDev *mdevsrc;
mdevsrc = &hostdev->source.subsys.u.mdev;
static int
-virHostdevMarkUSBDevices(virHostdevManagerPtr mgr,
+virHostdevMarkUSBDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virUSBDeviceListPtr list)
+ virUSBDeviceList *list)
{
size_t i, j;
unsigned int count;
- virUSBDevicePtr tmp;
+ virUSBDevice *tmp;
virObjectLock(mgr->activeUSBHostdevs);
count = virUSBDeviceListCount(list);
for (i = 0; i < count; i++) {
- virUSBDevicePtr usb = virUSBDeviceListGet(list, i);
+ virUSBDevice *usb = virUSBDeviceListGet(list, i);
if ((tmp = virUSBDeviceListFind(mgr->activeUSBHostdevs, usb))) {
const char *other_drvname;
const char *other_domname;
int
-virHostdevFindUSBDevice(virDomainHostdevDefPtr hostdev,
+virHostdevFindUSBDevice(virDomainHostdevDef *hostdev,
bool mandatory,
- virUSBDevicePtr *usb)
+ virUSBDevice **usb)
{
- virDomainHostdevSubsysUSBPtr usbsrc = &hostdev->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *usbsrc = &hostdev->source.subsys.u.usb;
unsigned vendor = usbsrc->vendor;
unsigned product = usbsrc->product;
unsigned bus = usbsrc->bus;
}
int
-virHostdevPrepareUSBDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareUSBDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
{
size_t i;
g_autoptr(virUSBDeviceList) list = NULL;
- virUSBDevicePtr tmp;
+ virUSBDevice *tmp;
bool coldBoot = !!(flags & VIR_HOSTDEV_COLD_BOOT);
if (!nhostdevs)
/* Loop 1: build temporary list
*/
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virDomainHostdevDef *hostdev = hostdevs[i];
bool required = true;
g_autoptr(virUSBDevice) usb = NULL;
}
static int
-virHostdevPrepareSCSIHostDevices(virDomainHostdevDefPtr hostdev,
- virDomainHostdevSubsysSCSIPtr scsisrc,
- virSCSIDeviceListPtr list)
+virHostdevPrepareSCSIHostDevices(virDomainHostdevDef *hostdev,
+ virDomainHostdevSubsysSCSI *scsisrc,
+ virSCSIDeviceList *list)
{
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi = NULL;
if (hostdev->managed) {
}
int
-virHostdevPrepareSCSIDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareSCSIDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i, j;
int count;
g_autoptr(virSCSIDeviceList) list = NULL;
- virSCSIDevicePtr tmp;
+ virSCSIDevice *tmp;
if (!nhostdevs)
return 0;
/* Loop 1: build temporary list */
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
if (!virHostdevIsSCSIDevice(hostdev))
continue;
count = virSCSIDeviceListCount(list);
for (i = 0; i < count; i++) {
- virSCSIDevicePtr scsi = virSCSIDeviceListGet(list, i);
+ virSCSIDevice *scsi = virSCSIDeviceListGet(list, i);
if ((tmp = virSCSIDeviceListFind(mgr->activeSCSIHostdevs,
scsi))) {
bool scsi_shareable = virSCSIDeviceGetShareable(scsi);
}
int
-virHostdevPrepareSCSIVHostDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareSCSIVHostDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
g_autoptr(virSCSIVHostDeviceList) list = NULL;
- virSCSIVHostDevicePtr tmp;
+ virSCSIVHostDevice *tmp;
size_t i, j;
if (!nhostdevs)
/* Loop 1: build temporary list */
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &hostdev->source.subsys.u.scsi_host;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &hostdev->source.subsys.u.scsi_host;
g_autoptr(virSCSIVHostDevice) host = NULL;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
int
-virHostdevPrepareMediatedDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareMediatedDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
/* Loop 1: Build a temporary list of ALL mediated devices. */
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysMediatedDevPtr src = &hostdev->source.subsys.u.mdev;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysMediatedDev *src = &hostdev->source.subsys.u.mdev;
g_autoptr(virMediatedDevice) mdev = NULL;
if (!virHostdevIsMdevDevice(hostdev))
* in cleanup label.
*/
while (virMediatedDeviceListCount(list) > 0) {
- virMediatedDevicePtr tmp = virMediatedDeviceListGet(list, 0);
+ virMediatedDevice *tmp = virMediatedDeviceListGet(list, 0);
virMediatedDeviceListSteal(list, tmp);
}
}
void
-virHostdevReAttachUSBDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachUSBDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
virObjectLock(mgr->activeUSBHostdevs);
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysUSBPtr usbsrc = &hostdev->source.subsys.u.usb;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysUSB *usbsrc = &hostdev->source.subsys.u.usb;
g_autoptr(virUSBDevice) usb = NULL;
- virUSBDevicePtr tmp;
+ virUSBDevice *tmp;
const char *usedby_drvname;
const char *usedby_domname;
}
static void
-virHostdevReAttachSCSIHostDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr hostdev,
- virDomainHostdevSubsysSCSIPtr scsisrc,
+virHostdevReAttachSCSIHostDevices(virHostdevManager *mgr,
+ virDomainHostdevDef *hostdev,
+ virDomainHostdevSubsysSCSI *scsisrc,
const char *drv_name,
const char *dom_name)
{
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi = NULL;
- virSCSIDevicePtr tmp;
+ virSCSIDevice *tmp;
if (!(scsi = virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
}
void
-virHostdevReAttachSCSIDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachSCSIDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
virObjectLock(mgr->activeSCSIHostdevs);
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
if (!virHostdevIsSCSIDevice(hostdev))
continue;
}
void
-virHostdevReAttachSCSIVHostDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachSCSIVHostDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
virObjectLock(mgr->activeSCSIVHostHostdevs);
for (i = 0; i < nhostdevs; i++) {
g_autoptr(virSCSIVHostDevice) host = NULL;
- virSCSIVHostDevicePtr tmp;
- virDomainHostdevDefPtr hostdev = hostdevs[i];
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &hostdev->source.subsys.u.scsi_host;
+ virSCSIVHostDevice *tmp;
+ virDomainHostdevDef *hostdev = hostdevs[i];
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &hostdev->source.subsys.u.scsi_host;
const char *usedby_drvname;
const char *usedby_domname;
* list of active host devices.
*/
void
-virHostdevReAttachMediatedDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachMediatedDevices(virHostdevManager *mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
const char *used_by_drvname = NULL;
virObjectLock(mgr->activeMediatedHostdevs);
for (i = 0; i < nhostdevs; i++) {
g_autofree char *sysfspath = NULL;
- virMediatedDevicePtr tmp;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc;
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virMediatedDevice *tmp;
+ virDomainHostdevSubsysMediatedDev *mdevsrc;
+ virDomainHostdevDef *hostdev = hostdevs[i];
if (!virHostdevIsMdevDevice(hostdev))
continue;
}
int
-virHostdevPCINodeDeviceDetach(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+virHostdevPCINodeDeviceDetach(virHostdevManager *mgr,
+ virPCIDevice *pci)
{
struct virHostdevIsPCINodeDeviceUsedData data = {mgr, NULL, NULL, false};
int ret = -1;
}
int
-virHostdevPCINodeDeviceReAttach(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+virHostdevPCINodeDeviceReAttach(virHostdevManager *mgr,
+ virPCIDevice *pci)
{
struct virHostdevIsPCINodeDeviceUsedData data = {mgr, NULL, NULL, false};
int ret = -1;
}
int
-virHostdevPCINodeDeviceReset(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+virHostdevPCINodeDeviceReset(virHostdevManager *mgr,
+ virPCIDevice *pci)
{
int ret = -1;
}
int
-virHostdevPrepareDomainDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
{
if (!def->nhostdevs)
}
void
-virHostdevReAttachDomainDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
{
if (!def->nhostdevs || !mgr)
}
int
-virHostdevUpdateActiveDomainDevices(virHostdevManagerPtr mgr,
+virHostdevUpdateActiveDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
{
if (!def->nhostdevs)
static int
-virHostdevGetNVMeDeviceList(virNVMeDeviceListPtr nvmeDevices,
- virStorageSourcePtr src,
+virHostdevGetNVMeDeviceList(virNVMeDeviceList *nvmeDevices,
+ virStorageSource *src,
const char *drv_name,
const char *dom_name)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
g_autoptr(virNVMeDevice) dev = NULL;
int
-virHostdevPrepareOneNVMeDevice(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareOneNVMeDevice(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
g_autoptr(virNVMeDeviceList) nvmeDevices = NULL;
g_autoptr(virPCIDeviceList) pciDevices = NULL;
const unsigned int pciFlags = 0;
- virNVMeDevicePtr temp = NULL;
+ virNVMeDevice *temp = NULL;
size_t i;
ssize_t lastGoodNVMeIdx = -1;
int ret = -1;
/* Let's check if all PCI devices are NVMe disks. */
for (i = 0; i < virPCIDeviceListCount(pciDevices); i++) {
- virPCIDevicePtr pci = virPCIDeviceListGet(pciDevices, i);
+ virPCIDevice *pci = virPCIDeviceListGet(pciDevices, i);
g_autofree char *drvPath = NULL;
g_autofree char *drvName = NULL;
int stub = VIR_PCI_STUB_DRIVER_NONE;
int
-virHostdevPrepareNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks)
{
size_t i;
int
-virHostdevReAttachOneNVMeDevice(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachOneNVMeDevice(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
g_autoptr(virNVMeDeviceList) nvmeDevices = NULL;
g_autoptr(virPCIDeviceList) pciDevices = NULL;
drv_name, dom_name, pciDevices, NULL, 0);
for (i = 0; i < virNVMeDeviceListCount(nvmeDevices); i++) {
- virNVMeDevicePtr temp = virNVMeDeviceListGet(nvmeDevices, i);
+ virNVMeDevice *temp = virNVMeDeviceListGet(nvmeDevices, i);
if (virNVMeDeviceListDel(hostdev_mgr->activeNVMeHostdevs, temp) < 0)
goto cleanup;
int
-virHostdevReAttachNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks)
{
size_t i;
int
-virHostdevUpdateActiveNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevUpdateActiveNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks)
{
g_autoptr(virNVMeDeviceList) nvmeDevices = NULL;
g_autoptr(virPCIDeviceList) pciDevices = NULL;
- virNVMeDevicePtr temp = NULL;
+ virNVMeDevice *temp = NULL;
size_t i;
ssize_t lastGoodNVMeIdx = -1;
ssize_t lastGoodPCIIdx = -1;
}
for (i = 0; i < virPCIDeviceListCount(pciDevices); i++) {
- virPCIDevicePtr actual = virPCIDeviceListGet(pciDevices, i);
+ virPCIDevice *actual = virPCIDeviceListGet(pciDevices, i);
/* We must restore some attributes that were lost on daemon restart. */
virPCIDeviceSetUnbindFromStub(actual, true);
lastGoodNVMeIdx--;
}
while (lastGoodPCIIdx >= 0) {
- virPCIDevicePtr actual = virPCIDeviceListGet(pciDevices, i);
+ virPCIDevice *actual = virPCIDeviceListGet(pciDevices, i);
virPCIDeviceListDel(hostdev_mgr->activePCIHostdevs,
virPCIDeviceGetAddress(actual));
typedef struct _virHostdevManager virHostdevManager;
-typedef virHostdevManager *virHostdevManagerPtr;
struct _virHostdevManager {
virObject parent;
char *stateDir;
- virPCIDeviceListPtr activePCIHostdevs;
- virPCIDeviceListPtr inactivePCIHostdevs;
- virUSBDeviceListPtr activeUSBHostdevs;
- virSCSIDeviceListPtr activeSCSIHostdevs;
- virSCSIVHostDeviceListPtr activeSCSIVHostHostdevs;
- virMediatedDeviceListPtr activeMediatedHostdevs;
+ virPCIDeviceList *activePCIHostdevs;
+ virPCIDeviceList *inactivePCIHostdevs;
+ virUSBDeviceList *activeUSBHostdevs;
+ virSCSIDeviceList *activeSCSIHostdevs;
+ virSCSIVHostDeviceList *activeSCSIVHostHostdevs;
+ virMediatedDeviceList *activeMediatedHostdevs;
/* NVMe devices are PCI devices really, but one NVMe disk can
* have multiple namespaces. */
- virNVMeDeviceListPtr activeNVMeHostdevs;
+ virNVMeDeviceList *activeNVMeHostdevs;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHostdevManager, virObjectUnref);
-virHostdevManagerPtr virHostdevManagerGetDefault(void);
+virHostdevManager *virHostdevManagerGetDefault(void);
int
-virHostdevPreparePCIDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPreparePCIDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
const unsigned char *uuid,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
int
-virHostdevFindUSBDevice(virDomainHostdevDefPtr hostdev,
+virHostdevFindUSBDevice(virDomainHostdevDef *hostdev,
bool mandatory,
- virUSBDevicePtr *usb)
+ virUSBDevice **usb)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
int
-virHostdevPrepareUSBDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareUSBDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-virHostdevPrepareSCSIDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareSCSIDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-virHostdevPrepareSCSIVHostDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareSCSIVHostDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-virHostdevPrepareMediatedDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareMediatedDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
void
-virHostdevReAttachPCIDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachPCIDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1);
void
-virHostdevReAttachUSBDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachUSBDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1);
void
-virHostdevReAttachSCSIDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachSCSIDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
void
-virHostdevReAttachSCSIVHostDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachSCSIVHostDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1);
void
-virHostdevReAttachMediatedDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachMediatedDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
ATTRIBUTE_NONNULL(1);
int
-virHostdevUpdateActivePCIDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActivePCIDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
int
-virHostdevUpdateActiveUSBDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveUSBDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
int
-virHostdevUpdateActiveSCSIDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveSCSIDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
int
-virHostdevUpdateActiveMediatedDevices(virHostdevManagerPtr mgr,
- virDomainHostdevDefPtr *hostdevs,
+virHostdevUpdateActiveMediatedDevices(virHostdevManager *mgr,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
const char *drv_name,
const char *dom_name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
int
-virHostdevUpdateActiveDomainDevices(virHostdevManagerPtr mgr,
+virHostdevUpdateActiveDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-virHostdevPrepareDomainDevices(virHostdevManagerPtr mgr,
+virHostdevPrepareDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
void
-virHostdevReAttachDomainDevices(virHostdevManagerPtr mgr,
+virHostdevReAttachDomainDevices(virHostdevManager *mgr,
const char *driver,
- virDomainDefPtr def,
+ virDomainDef *def,
unsigned int flags)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
/* functions used by NodeDevDetach/Reattach/Reset */
-int virHostdevPCINodeDeviceDetach(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+int virHostdevPCINodeDeviceDetach(virHostdevManager *mgr,
+ virPCIDevice *pci)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virHostdevPCINodeDeviceReAttach(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+int virHostdevPCINodeDeviceReAttach(virHostdevManager *mgr,
+ virPCIDevice *pci)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virHostdevPCINodeDeviceReset(virHostdevManagerPtr mgr,
- virPCIDevicePtr pci)
+int virHostdevPCINodeDeviceReset(virHostdevManager *mgr,
+ virPCIDevice *pci)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virHostdevPrepareOneNVMeDevice(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareOneNVMeDevice(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virStorageSourcePtr src);
+ virStorageSource *src);
int
-virHostdevPrepareNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevPrepareNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks);
int
-virHostdevReAttachOneNVMeDevice(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachOneNVMeDevice(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virStorageSourcePtr src);
+ virStorageSource *src);
int
-virHostdevReAttachNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevReAttachNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks);
int
-virHostdevUpdateActiveNVMeDevices(virHostdevManagerPtr hostdev_mgr,
+virHostdevUpdateActiveNVMeDevices(virHostdevManager *hostdev_mgr,
const char *drv_name,
const char *dom_name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks);
bool virHostdevIsPCIDevice(const virDomainHostdevDef *hostdev);
bool privileged;
} virNetcfDriverState, *virNetcfDriverStatePtr;
-static virClassPtr virNetcfDriverStateClass;
+static virClass *virNetcfDriverStateClass;
static void virNetcfDriverStateDispose(void *obj);
static int
static virDrvOpenStatus
netcfConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
}
for (i = 0; i < count; i++) {
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
struct netcf_if *iface;
iface = ncf_lookup_by_name(driver->netcf, names[i]);
}
for (i = 0; i < count && want < nnames; i++) {
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
struct netcf_if *iface;
iface = ncf_lookup_by_name(driver->netcf, allnames[i]);
tmp_iface_objs = g_new0(virInterfacePtr, count + 1);
for (i = 0; i < count; i++) {
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
iface = ncf_lookup_by_name(driver->netcf, names[i]);
if (!iface) {
{
struct netcf_if *iface;
virInterfacePtr ret = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
virObjectLock(driver);
iface = ncf_lookup_by_name(driver->netcf, name);
struct netcf_if *iface;
int niface;
virInterfacePtr ret = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
virObjectLock(driver);
niface = ncf_lookup_by_mac_string(driver->netcf, macstr, 1, &iface);
{
struct netcf_if *iface = NULL;
char *xmlstr = NULL;
- virInterfaceDefPtr ifacedef = NULL;
+ virInterfaceDef *ifacedef = NULL;
char *ret = NULL;
bool active;
{
struct netcf_if *iface = NULL;
char *xmlstr = NULL;
- virInterfaceDefPtr ifacedef = NULL;
+ virInterfaceDef *ifacedef = NULL;
virInterfacePtr ret = NULL;
virCheckFlags(0, NULL);
static int netcfInterfaceUndefine(virInterfacePtr ifinfo)
{
struct netcf_if *iface = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
int ret = -1;
virObjectLock(driver);
unsigned int flags)
{
struct netcf_if *iface = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
int ret = -1;
bool active;
unsigned int flags)
{
struct netcf_if *iface = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
int ret = -1;
bool active;
static int netcfInterfaceIsActive(virInterfacePtr ifinfo)
{
struct netcf_if *iface = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
int ret = -1;
bool active;
udev_list_entry_foreach(dev_entry, devices) {
struct udev_device *dev;
const char *path;
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
path = udev_list_entry_get_name(dev_entry);
dev = udev_device_new_from_syspath(udev, path);
udev_list_entry_foreach(dev_entry, devices) {
struct udev_device *dev;
const char *path;
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
/* Ensure we won't exceed the size of our array */
if (count > names_len)
const char *path;
const char *name;
const char *macaddr;
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
path = udev_list_entry_get_name(dev_entry);
dev = udev_device_new_from_syspath(udev, path);
struct udev *udev = udev_ref(driver->udev);
struct udev_device *dev;
virInterfacePtr ret = NULL;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
/* get a device reference based on the device name */
dev = udev_device_new_from_subsystem_sysname(udev, "net", name);
struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *dev_entry;
struct udev_device *dev;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
virInterfacePtr ret = NULL;
enumerate = udevGetDevices(udev, VIR_UDEV_IFACE_ALL);
{
struct udev *udev = udev_ref(driver->udev);
struct udev_device *dev;
- virInterfaceDefPtr def = NULL;
+ virInterfaceDef *def = NULL;
int status = -1;
dev = udev_device_new_from_subsystem_sysname(udev, "net",
static virDrvOpenStatus
udevConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
#define MAX_DRIVERS 21
-static virConnectDriverPtr virConnectDriverTab[MAX_DRIVERS];
+static virConnectDriver *virConnectDriverTab[MAX_DRIVERS];
static int virConnectDriverTabCount;
-static virStateDriverPtr virStateDriverTab[MAX_DRIVERS];
+static virStateDriver *virStateDriverTab[MAX_DRIVERS];
static int virStateDriverTabCount;
-static virNetworkDriverPtr virSharedNetworkDriver;
-static virInterfaceDriverPtr virSharedInterfaceDriver;
-static virStorageDriverPtr virSharedStorageDriver;
-static virNodeDeviceDriverPtr virSharedNodeDeviceDriver;
-static virSecretDriverPtr virSharedSecretDriver;
-static virNWFilterDriverPtr virSharedNWFilterDriver;
+static virNetworkDriver *virSharedNetworkDriver;
+static virInterfaceDriver *virSharedInterfaceDriver;
+static virStorageDriver *virSharedStorageDriver;
+static virNodeDeviceDriver *virSharedNodeDeviceDriver;
+static virSecretDriver *virSharedSecretDriver;
+static virNWFilterDriver *virSharedNWFilterDriver;
static int
* Returns 0 on success, or -1 in case of error.
*/
int
-virSetSharedNetworkDriver(virNetworkDriverPtr driver)
+virSetSharedNetworkDriver(virNetworkDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virSetSharedInterfaceDriver(virInterfaceDriverPtr driver)
+virSetSharedInterfaceDriver(virInterfaceDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virSetSharedStorageDriver(virStorageDriverPtr driver)
+virSetSharedStorageDriver(virStorageDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virSetSharedNodeDeviceDriver(virNodeDeviceDriverPtr driver)
+virSetSharedNodeDeviceDriver(virNodeDeviceDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virSetSharedSecretDriver(virSecretDriverPtr driver)
+virSetSharedSecretDriver(virSecretDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virSetSharedNWFilterDriver(virNWFilterDriverPtr driver)
+virSetSharedNWFilterDriver(virNWFilterDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
* Returns the driver priority or -1 in case of error.
*/
int
-virRegisterConnectDriver(virConnectDriverPtr driver,
+virRegisterConnectDriver(virConnectDriver *driver,
bool setSharedDrivers)
{
VIR_DEBUG("driver=%p name=%s", driver,
* Returns the driver priority or -1 in case of error.
*/
int
-virRegisterStateDriver(virStateDriverPtr driver)
+virRegisterStateDriver(virStateDriver *driver)
{
virCheckNonNullArgReturn(driver, -1);
static int
-virConnectGetDefaultURI(virConfPtr conf,
+virConnectGetDefaultURI(virConf *conf,
char **name)
{
const char *defname = getenv("LIBVIRT_DEFAULT_URI");
* offer the suggested fix.
*/
static int
-virConnectCheckURIMissingSlash(const char *uristr, virURIPtr uri)
+virConnectCheckURIMissingSlash(const char *uristr, virURI *uri)
{
if (!uri->path || !uri->server)
return 0;
goto failed;
if (virAccessManagerGetDefault() == NULL) {
- virAccessManagerPtr acl;
+ virAccessManager *acl;
virResetLastError();
#define XEN_CAP_REGEX "(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(aarch64|armv7l|x86_32|x86_64|ia64|powerpc64)(p|be)?"
static int
-libxlCapsAddCPUID(virCPUDataPtr data, virCPUx86CPUID *cpuid, ssize_t ncaps)
+libxlCapsAddCPUID(virCPUData *data, virCPUx86CPUID *cpuid, ssize_t ncaps)
{
virCPUx86DataItem item = { 0 };
size_t i;
* word 8 | - Non existent - | CPUID.80000008.EBX |
*
*/
-static virCPUDataPtr
-libxlCapsNodeData(virCPUDefPtr cpu, libxl_hwcap hwcap,
+static virCPUData *
+libxlCapsNodeData(virCPUDef *cpu, libxl_hwcap hwcap,
enum libxlHwcapVersion version)
{
ssize_t ncaps;
- virCPUDataPtr cpudata = NULL;
+ virCPUData *cpudata = NULL;
virCPUx86CPUID cpuid[] = {
{ .eax_in = 0x00000001,
.edx = hwcap[0] },
* the X'th 32-bit word of hw_cap.
*/
static int
-libxlCapsInitCPU(virCapsPtr caps, libxl_physinfo *phy_info,
+libxlCapsInitCPU(virCaps *caps, libxl_physinfo *phy_info,
enum libxlHwcapVersion version)
{
- virCPUDataPtr data = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUData *data = NULL;
+ virCPUDef *cpu = NULL;
int ret = -1;
int host_pae;
int host_lm;
}
static int
-libxlCapsInitHost(libxl_ctx *ctx, virCapsPtr caps)
+libxlCapsInitHost(libxl_ctx *ctx, virCaps *caps)
{
const libxl_version_info *ver_info;
enum libxlHwcapVersion version;
}
static int
-libxlCapsInitNuma(libxl_ctx *ctx, virCapsPtr caps)
+libxlCapsInitNuma(libxl_ctx *ctx, virCaps *caps)
{
libxl_numainfo *numa_info = NULL;
libxl_cputopology *cpu_topo = NULL;
int nr_nodes = 0, nr_cpus = 0, nr_siblings = 0;
- virCapsHostNUMACellCPUPtr *cpus = NULL;
- virCapsHostNUMACellSiblingInfoPtr siblings = NULL;
+ virCapsHostNUMACellCPU **cpus = NULL;
+ virCapsHostNUMACellSiblingInfo *siblings = NULL;
int *nr_cpus_node = NULL;
size_t i;
int ret = -1;
}
}
- cpus = g_new0(virCapsHostNUMACellCPUPtr, nr_nodes);
+ cpus = g_new0(virCapsHostNUMACellCPU *, nr_nodes);
nr_cpus_node = g_new0(int, nr_nodes);
}
static int
-libxlCapsInitGuests(libxl_ctx *ctx, virCapsPtr caps)
+libxlCapsInitGuests(libxl_ctx *ctx, virCaps *caps)
{
const libxl_version_info *ver_info;
g_autoptr(GRegex) regex = NULL;
}
for (i = 0; i < nr_guest_archs; ++i) {
- virCapsGuestPtr guest;
+ virCapsGuest *guest;
char const *const xen_machines[] = {
guest_archs[i].hvm ? "xenfv" :
(guest_archs[i].pvh ? "xenpvh" : "xenpv")};
- virCapsGuestMachinePtr *machines;
+ virCapsGuestMachine **machines;
if ((machines = virCapabilitiesAllocMachines(xen_machines, 1)) == NULL)
return -1;
static int
libxlMakeDomainOSCaps(const char *machine,
- virDomainCapsOSPtr os,
- virFirmwarePtr *firmwares,
+ virDomainCapsOS *os,
+ virFirmware **firmwares,
size_t nfirmwares)
{
- virDomainCapsLoaderPtr capsLoader = &os->loader;
+ virDomainCapsLoader *capsLoader = &os->loader;
size_t i;
os->supported = VIR_TRISTATE_BOOL_YES;
}
static int
-libxlMakeDomainDeviceDiskCaps(virDomainCapsDeviceDiskPtr dev)
+libxlMakeDomainDeviceDiskCaps(virDomainCapsDeviceDisk *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->diskDevice.report = true;
}
static int
-libxlMakeDomainDeviceGraphicsCaps(virDomainCapsDeviceGraphicsPtr dev)
+libxlMakeDomainDeviceGraphicsCaps(virDomainCapsDeviceGraphics *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->type.report = true;
}
static int
-libxlMakeDomainDeviceVideoCaps(virDomainCapsDeviceVideoPtr dev)
+libxlMakeDomainDeviceVideoCaps(virDomainCapsDeviceVideo *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->modelType.report = true;
}
static int
-libxlMakeDomainDeviceHostdevCaps(virDomainCapsDeviceHostdevPtr dev)
+libxlMakeDomainDeviceHostdevCaps(virDomainCapsDeviceHostdev *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->mode.report = true;
return 0;
}
-virCapsPtr
+virCaps *
libxlMakeCapabilities(libxl_ctx *ctx)
{
- virCapsPtr caps;
+ virCaps *caps;
#ifdef LIBXL_HAVE_NO_SUSPEND_RESUME
if ((caps = virCapabilitiesNew(virArchFromHost(), false, false)) == NULL)
#define PV_MAX_VCPUS 512
int
-libxlMakeDomainCapabilities(virDomainCapsPtr domCaps,
- virFirmwarePtr *firmwares,
+libxlMakeDomainCapabilities(virDomainCaps *domCaps,
+ virFirmware **firmwares,
size_t nfirmwares)
{
- virDomainCapsOSPtr os = &domCaps->os;
- virDomainCapsDeviceDiskPtr disk = &domCaps->disk;
- virDomainCapsDeviceGraphicsPtr graphics = &domCaps->graphics;
- virDomainCapsDeviceVideoPtr video = &domCaps->video;
- virDomainCapsDeviceHostdevPtr hostdev = &domCaps->hostdev;
+ virDomainCapsOS *os = &domCaps->os;
+ virDomainCapsDeviceDisk *disk = &domCaps->disk;
+ virDomainCapsDeviceGraphics *graphics = &domCaps->graphics;
+ virDomainCapsDeviceVideo *video = &domCaps->video;
+ virDomainCapsDeviceHostdev *hostdev = &domCaps->hostdev;
if (STREQ(domCaps->machine, "xenfv"))
domCaps->maxvcpus = HVM_MAX_VCPUS;
libxlDomainGetEmulatorType(const virDomainDef *def)
{
int ret = LIBXL_DEVICE_MODEL_VERSION_QEMU_XEN;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
g_autofree char *output = NULL;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM) {
bool libxlCapsHasPVUSB(void) G_GNUC_NO_INLINE;
-virCapsPtr
+virCaps *
libxlMakeCapabilities(libxl_ctx *ctx);
int
-libxlMakeDomainCapabilities(virDomainCapsPtr domCaps,
- virFirmwarePtr *firmwares,
+libxlMakeDomainCapabilities(virDomainCaps *domCaps,
+ virFirmware **firmwares,
size_t nfirmwares);
int
VIR_LOG_INIT("libxl.libxl_conf");
-static virClassPtr libxlDriverConfigClass;
+static virClass *libxlDriverConfigClass;
static void libxlDriverConfigDispose(void *obj);
static int libxlConfigOnceInit(void)
static void
libxlDriverConfigDispose(void *obj)
{
- libxlDriverConfigPtr cfg = obj;
+ libxlDriverConfig *cfg = obj;
virObjectUnref(cfg->caps);
libxl_ctx_free(cfg->ctx);
static int
libxlMakeDomCreateInfo(libxl_ctx *ctx,
- virDomainDefPtr def,
+ virDomainDef *def,
libxl_domain_create_info *c_info)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
}
static int
-libxlMakeChrdevStr(virDomainChrDefPtr def, char **buf)
+libxlMakeChrdevStr(virDomainChrDef *def, char **buf)
{
- virDomainChrSourceDefPtr srcdef = def->source;
+ virDomainChrSourceDef *srcdef = def->source;
const char *type = virDomainChrTypeToString(srcdef->type);
if (!type) {
}
static int
-libxlMakeDomBuildInfo(virDomainDefPtr def,
- libxlDriverConfigPtr cfg,
- virCapsPtr caps,
+libxlMakeDomBuildInfo(virDomainDef *def,
+ libxlDriverConfig *cfg,
+ virCaps *caps,
libxl_domain_config *d_config)
{
virDomainClockDef clock = def->clock;
* Use first sound device. man xl.cfg(5) describes soundhw as
* a single device. From the man page: soundhw=DEVICE
*/
- virDomainSoundDefPtr snd = def->sounds[0];
+ virDomainSoundDef *snd = def->sounds[0];
b_info->u.hvm.soundhw = g_strdup(virDomainSoundModelTypeToString(snd->model));
}
b_info->max_vcpus);
if (def->namespaceData) {
- libxlDomainXmlNsDefPtr nsdata = def->namespaceData;
+ libxlDomainXmlNsDef *nsdata = def->namespaceData;
if (nsdata->num_args > 0)
b_info->extra = g_strdupv(nsdata->args);
#ifdef LIBXL_HAVE_VNUMA
static int
-libxlMakeVnumaList(virDomainDefPtr def,
+libxlMakeVnumaList(virDomainDef *def,
libxl_ctx *ctx,
libxl_domain_config *d_config)
{
size_t nr_nodes;
size_t num_vnuma;
bool simulate = false;
- virBitmapPtr bitmap = NULL;
- virDomainNumaPtr numa = def->numa;
+ virBitmap *bitmap = NULL;
+ virDomainNuma *numa = def->numa;
libxl_domain_build_info *b_info = &d_config->b_info;
libxl_physinfo physinfo;
libxl_vnode_info *vnuma_nodes = NULL;
}
static char *
-libxlMakeNetworkDiskSrcStr(virStorageSourcePtr src,
+libxlMakeNetworkDiskSrcStr(virStorageSource *src,
const char *username,
const char *secret)
{
}
static int
-libxlMakeNetworkDiskSrc(virStorageSourcePtr src, char **srcstr)
+libxlMakeNetworkDiskSrc(virStorageSource *src, char **srcstr)
{
virConnectPtr conn = NULL;
g_autofree char *base64secret = NULL;
}
int
-libxlMakeDisk(virDomainDiskDefPtr l_disk, libxl_device_disk *x_disk)
+libxlMakeDisk(virDomainDiskDef *l_disk, libxl_device_disk *x_disk)
{
const char *driver = virDomainDiskGetDriver(l_disk);
int format = virDomainDiskGetFormat(l_disk);
}
static int
-libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakeDiskList(virDomainDef *def, libxl_domain_config *d_config)
{
- virDomainDiskDefPtr *l_disks = def->disks;
+ virDomainDiskDef **l_disks = def->disks;
int ndisks = def->ndisks;
libxl_device_disk *x_disks;
size_t i;
* libxl when not explicitly specified by the user.
*/
void
-libxlUpdateDiskDef(virDomainDiskDefPtr l_disk, libxl_device_disk *x_disk)
+libxlUpdateDiskDef(virDomainDiskDef *l_disk, libxl_device_disk *x_disk)
{
const char *driver = NULL;
}
int
-libxlMakeNic(virDomainDefPtr def,
- virDomainNetDefPtr l_nic,
+libxlMakeNic(virDomainDef *def,
+ virDomainNetDef *l_nic,
libxl_device_nic *x_nic,
bool attach)
{
}
static int
-libxlMakeNicList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakeNicList(virDomainDef *def, libxl_domain_config *d_config)
{
- virDomainNetDefPtr *l_nics = def->nets;
+ virDomainNetDef **l_nics = def->nets;
size_t nnics = def->nnets;
libxl_device_nic *x_nics;
size_t i, nvnics = 0;
}
int
-libxlMakeVfb(virPortAllocatorRangePtr graphicsports,
- virDomainGraphicsDefPtr l_vfb,
+libxlMakeVfb(virPortAllocatorRange *graphicsports,
+ virDomainGraphicsDef *l_vfb,
libxl_device_vfb *x_vfb)
{
unsigned short port;
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
libxl_device_vfb_init(x_vfb);
}
static int
-libxlMakeVfbList(virPortAllocatorRangePtr graphicsports,
- virDomainDefPtr def,
+libxlMakeVfbList(virPortAllocatorRange *graphicsports,
+ virDomainDef *def,
libxl_domain_config *d_config)
{
- virDomainGraphicsDefPtr *l_vfbs = def->graphics;
+ virDomainGraphicsDef **l_vfbs = def->graphics;
int nvfbs = def->ngraphics;
libxl_device_vfb *x_vfbs;
libxl_device_vkb *x_vkbs;
* populate libxl_domain_config->vfbs.
*/
static int
-libxlMakeBuildInfoVfb(virPortAllocatorRangePtr graphicsports,
- virDomainDefPtr def,
+libxlMakeBuildInfoVfb(virPortAllocatorRange *graphicsports,
+ virDomainDef *def,
libxl_domain_config *d_config)
{
libxl_domain_build_info *b_info = &d_config->b_info;
* libxl_domain_config->vfbs. Prior to calling this function,
*/
for (i = 0; i < def->ngraphics; i++) {
- virDomainGraphicsDefPtr l_vfb = def->graphics[i];
+ virDomainGraphicsDef *l_vfb = def->graphics[i];
unsigned short port;
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
if (l_vfb->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE)
continue;
* Otherwise autoballooning is enabled.
*/
static int
-libxlGetAutoballoonConf(libxlDriverConfigPtr cfg,
- virConfPtr conf)
+libxlGetAutoballoonConf(libxlDriverConfig *cfg,
+ virConf *conf)
{
g_autoptr(GRegex) regex = NULL;
g_autoptr(GError) err = NULL;
return 0;
}
-libxlDriverConfigPtr
+libxlDriverConfig *
libxlDriverConfigNew(void)
{
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
if (libxlConfigInitialize() < 0)
return NULL;
return NULL;
}
#else
- cfg->firmwares = g_new0(virFirmwarePtr, 1);
+ cfg->firmwares = g_new0(virFirmware *, 1);
cfg->nfirmwares = 1;
cfg->firmwares[0] = g_new0(virFirmware, 1);
cfg->firmwares[0]->name = g_strdup(LIBXL_FIRMWARE_DIR "/ovmf.bin");
}
int
-libxlDriverConfigInit(libxlDriverConfigPtr cfg)
+libxlDriverConfigInit(libxlDriverConfig *cfg)
{
uint64_t free_mem;
return 0;
}
-libxlDriverConfigPtr
-libxlDriverConfigGet(libxlDriverPrivatePtr driver)
+libxlDriverConfig *
+libxlDriverConfigGet(libxlDriverPrivate *driver)
{
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
libxlDriverLock(driver);
cfg = virObjectRef(driver->config);
return cfg;
}
-int libxlDriverConfigLoadFile(libxlDriverConfigPtr cfg,
+int libxlDriverConfigLoadFile(libxlDriverConfig *cfg,
const char *filename)
{
g_autoptr(virConf) conf = NULL;
* either the user-specified value or total physical memory as a default.
*/
int
-libxlDriverGetDom0MaxmemConf(libxlDriverConfigPtr cfg,
+libxlDriverGetDom0MaxmemConf(libxlDriverConfig *cfg,
unsigned long long *maxmem)
{
char **cmd_tokens = NULL;
#ifdef LIBXL_HAVE_DEVICE_CHANNEL
static int
-libxlPrepareChannel(virDomainChrDefPtr channel,
+libxlPrepareChannel(virDomainChrDef *channel,
const char *channelDir,
const char *domainName)
{
}
static int
-libxlMakeChannel(virDomainChrDefPtr l_channel,
+libxlMakeChannel(virDomainChrDef *l_channel,
libxl_device_channel *x_channel)
{
libxl_device_channel_init(x_channel);
static int
libxlMakeChannelList(const char *channelDir,
- virDomainDefPtr def,
+ virDomainDef *def,
libxl_domain_config *d_config)
{
- virDomainChrDefPtr *l_channels = def->channels;
+ virDomainChrDef **l_channels = def->channels;
size_t nchannels = def->nchannels;
libxl_device_channel *x_channels;
size_t i, nvchannels = 0;
#ifdef LIBXL_HAVE_PVUSB
int
-libxlMakeUSBController(virDomainControllerDefPtr controller,
+libxlMakeUSBController(virDomainControllerDef *controller,
libxl_device_usbctrl *usbctrl)
{
usbctrl->devid = controller->idx;
}
static int
-libxlMakeDefaultUSBControllers(virDomainDefPtr def,
+libxlMakeDefaultUSBControllers(virDomainDef *def,
libxl_domain_config *d_config)
{
- virDomainControllerDefPtr l_controller = NULL;
+ virDomainControllerDef *l_controller = NULL;
libxl_device_usbctrl *x_controllers = NULL;
size_t nusbdevs = 0;
size_t ncontrollers;
}
static int
-libxlMakeUSBControllerList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakeUSBControllerList(virDomainDef *def, libxl_domain_config *d_config)
{
- virDomainControllerDefPtr *l_controllers = def->controllers;
+ virDomainControllerDef **l_controllers = def->controllers;
size_t ncontrollers = def->ncontrollers;
size_t nusbctrls = 0;
libxl_device_usbctrl *x_usbctrls;
}
int
-libxlMakeUSB(virDomainHostdevDefPtr hostdev, libxl_device_usbdev *usbdev)
+libxlMakeUSB(virDomainHostdevDef *hostdev, libxl_device_usbdev *usbdev)
{
- virDomainHostdevSubsysUSBPtr usbsrc = &hostdev->source.subsys.u.usb;
- virUSBDevicePtr usb = NULL;
+ virDomainHostdevSubsysUSB *usbsrc = &hostdev->source.subsys.u.usb;
+ virUSBDevice *usb = NULL;
int ret = -1;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
}
static int
-libxlMakeUSBList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakeUSBList(virDomainDef *def, libxl_domain_config *d_config)
{
- virDomainHostdevDefPtr *l_hostdevs = def->hostdevs;
+ virDomainHostdevDef **l_hostdevs = def->hostdevs;
size_t nhostdevs = def->nhostdevs;
size_t nusbdevs = 0;
libxl_device_usbdev *x_usbdevs;
#endif
int
-libxlMakePCI(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev)
+libxlMakePCI(virDomainHostdevDef *hostdev, libxl_device_pci *pcidev)
{
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
return -1;
if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
}
static int
-libxlMakePCIList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakePCIList(virDomainDef *def, libxl_domain_config *d_config)
{
- virDomainHostdevDefPtr *l_hostdevs = def->hostdevs;
+ virDomainHostdevDef **l_hostdevs = def->hostdevs;
size_t nhostdevs = def->nhostdevs;
size_t npcidevs = 0;
libxl_device_pci *x_pcidevs;
}
static int
-libxlMakeVideo(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakeVideo(virDomainDef *def, libxl_domain_config *d_config)
{
libxl_domain_build_info *b_info = &d_config->b_info;
}
int
-libxlDriverNodeGetInfo(libxlDriverPrivatePtr driver, virNodeInfoPtr info)
+libxlDriverNodeGetInfo(libxlDriverPrivate *driver, virNodeInfoPtr info)
{
libxl_physinfo phy_info;
virArch hostarch = virArchFromHost();
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
int ret = -1;
libxl_physinfo_init(&phy_info);
}
int
-libxlBuildDomainConfig(virPortAllocatorRangePtr graphicsports,
- virDomainDefPtr def,
- libxlDriverConfigPtr cfg,
+libxlBuildDomainConfig(virPortAllocatorRange *graphicsports,
+ virDomainDef *def,
+ libxlDriverConfig *cfg,
libxl_domain_config *d_config)
{
- virCapsPtr caps = cfg->caps;
+ virCaps *caps = cfg->caps;
libxl_ctx *ctx = cfg->ctx;
libxl_domain_config_init(d_config);
return 0;
}
-virDomainXMLOptionPtr
-libxlCreateXMLConf(libxlDriverPrivatePtr driver)
+virDomainXMLOption *
+libxlCreateXMLConf(libxlDriverPrivate *driver)
{
libxlDomainDefParserConfig.priv = driver;
return virDomainXMLOptionNew(&libxlDomainDefParserConfig,
typedef struct _libxlDriverPrivate libxlDriverPrivate;
-typedef libxlDriverPrivate *libxlDriverPrivatePtr;
typedef struct _libxlDriverConfig libxlDriverConfig;
-typedef libxlDriverConfig *libxlDriverConfigPtr;
-
struct _libxlDriverConfig {
virObject parent;
unsigned int version;
/* log stream for driver-wide libxl ctx */
- libxlLoggerPtr logger;
+ libxlLogger *logger;
/* libxl ctx for driver wide ops; getVersion, getNodeInfo, ... */
libxl_ctx *ctx;
bool nested_hvm;
/* Once created, caps are immutable */
- virCapsPtr caps;
+ virCaps *caps;
char *configBaseDir;
char *configDir;
char *autoDumpDir;
char *channelDir;
- virFirmwarePtr *firmwares;
+ virFirmware **firmwares;
size_t nfirmwares;
};
struct _libxlDriverPrivate {
virMutex lock;
- virHostdevManagerPtr hostdevMgr;
+ virHostdevManager *hostdevMgr;
/* Require lock to get reference on 'config',
* then lockless thereafter */
- libxlDriverConfigPtr config;
+ libxlDriverConfig *config;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
void *inhibitOpaque;
/* Immutable pointer, self-locking APIs */
- virDomainObjListPtr domains;
+ virDomainObjList *domains;
/* Immutable pointer, immutable object */
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr domainEventState;
+ virObjectEventState *domainEventState;
/* Immutable pointer, immutable object */
- virPortAllocatorRangePtr reservedGraphicsPorts;
+ virPortAllocatorRange *reservedGraphicsPorts;
/* Immutable pointer, immutable object */
- virPortAllocatorRangePtr migrationPorts;
+ virPortAllocatorRange *migrationPorts;
/* Immutable pointer, lockless APIs */
- virSysinfoDefPtr hostsysinfo;
+ virSysinfoDef *hostsysinfo;
/* Immutable pointer. lockless access */
- virLockManagerPluginPtr lockManager;
+ virLockManagerPlugin *lockManager;
};
#define LIBXL_SAVE_MAGIC "libvirt-xml\n \0 \r"
#endif
typedef struct _libxlSavefileHeader libxlSavefileHeader;
-typedef libxlSavefileHeader *libxlSavefileHeaderPtr;
struct _libxlSavefileHeader {
char magic[sizeof(LIBXL_SAVE_MAGIC)-1];
uint32_t version;
typedef struct _libxlDomainXmlNsDef libxlDomainXmlNsDef;
-typedef libxlDomainXmlNsDef *libxlDomainXmlNsDefPtr;
struct _libxlDomainXmlNsDef {
size_t num_args;
char **args;
};
-libxlDriverConfigPtr
+libxlDriverConfig *
libxlDriverConfigNew(void);
int
-libxlDriverConfigInit(libxlDriverConfigPtr cfg);
+libxlDriverConfigInit(libxlDriverConfig *cfg);
-libxlDriverConfigPtr
-libxlDriverConfigGet(libxlDriverPrivatePtr driver);
+libxlDriverConfig *
+libxlDriverConfigGet(libxlDriverPrivate *driver);
int
-libxlDriverNodeGetInfo(libxlDriverPrivatePtr driver,
+libxlDriverNodeGetInfo(libxlDriverPrivate *driver,
virNodeInfoPtr info);
-int libxlDriverConfigLoadFile(libxlDriverConfigPtr cfg,
+int libxlDriverConfigLoadFile(libxlDriverConfig *cfg,
const char *filename);
int
-libxlDriverGetDom0MaxmemConf(libxlDriverConfigPtr cfg,
+libxlDriverGetDom0MaxmemConf(libxlDriverConfig *cfg,
unsigned long long *maxmem);
int
-libxlMakeDisk(virDomainDiskDefPtr l_dev, libxl_device_disk *x_dev);
+libxlMakeDisk(virDomainDiskDef *l_dev, libxl_device_disk *x_dev);
void
-libxlUpdateDiskDef(virDomainDiskDefPtr l_dev, libxl_device_disk *x_dev);
+libxlUpdateDiskDef(virDomainDiskDef *l_dev, libxl_device_disk *x_dev);
int
-libxlMakeNic(virDomainDefPtr def,
- virDomainNetDefPtr l_nic,
+libxlMakeNic(virDomainDef *def,
+ virDomainNetDef *l_nic,
libxl_device_nic *x_nic,
bool attach);
int
-libxlMakeVfb(virPortAllocatorRangePtr graphicsports,
- virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb);
+libxlMakeVfb(virPortAllocatorRange *graphicsports,
+ virDomainGraphicsDef *l_vfb, libxl_device_vfb *x_vfb);
int
-libxlMakePCI(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev);
+libxlMakePCI(virDomainHostdevDef *hostdev, libxl_device_pci *pcidev);
#ifdef LIBXL_HAVE_PVUSB
int
-libxlMakeUSBController(virDomainControllerDefPtr controller,
+libxlMakeUSBController(virDomainControllerDef *controller,
libxl_device_usbctrl *usbctrl);
int
-libxlMakeUSB(virDomainHostdevDefPtr hostdev, libxl_device_usbdev *usbdev);
+libxlMakeUSB(virDomainHostdevDef *hostdev, libxl_device_usbdev *usbdev);
#endif
-virDomainXMLOptionPtr
-libxlCreateXMLConf(libxlDriverPrivatePtr driver);
+virDomainXMLOption *
+libxlCreateXMLConf(libxlDriverPrivate *driver);
#ifdef LIBXL_HAVE_DEVICE_CHANNEL
# define LIBXL_ATTR_UNUSED
# define LIBXL_ATTR_UNUSED G_GNUC_UNUSED
#endif
int
-libxlBuildDomainConfig(virPortAllocatorRangePtr graphicsports,
- virDomainDefPtr def,
- libxlDriverConfigPtr cfg,
+libxlBuildDomainConfig(virPortAllocatorRange *graphicsports,
+ virDomainDef *def,
+ libxlDriverConfig *cfg,
libxl_domain_config *d_config);
static inline void
-libxlDriverLock(libxlDriverPrivatePtr driver)
+libxlDriverLock(libxlDriverPrivate *driver)
{
virMutexLock(&driver->lock);
}
static inline void
-libxlDriverUnlock(libxlDriverPrivatePtr driver)
+libxlDriverUnlock(libxlDriverPrivate *driver)
{
virMutexUnlock(&driver->lock);
}
"modify",
);
-static virClassPtr libxlDomainObjPrivateClass;
+static virClass *libxlDomainObjPrivateClass;
static void
libxlDomainObjPrivateDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(libxlDomainObjPrivate);
static int
-libxlDomainObjInitJob(libxlDomainObjPrivatePtr priv)
+libxlDomainObjInitJob(libxlDomainObjPrivate *priv)
{
memset(&priv->job, 0, sizeof(priv->job));
}
static void
-libxlDomainObjResetJob(libxlDomainObjPrivatePtr priv)
+libxlDomainObjResetJob(libxlDomainObjPrivate *priv)
{
struct libxlDomainJobObj *job = &priv->job;
}
static void
-libxlDomainObjFreeJob(libxlDomainObjPrivatePtr priv)
+libxlDomainObjFreeJob(libxlDomainObjPrivate *priv)
{
ignore_value(virCondDestroy(&priv->job.cond));
VIR_FREE(priv->job.current);
#define LIBXL_JOB_WAIT_TIME (1000ull * 30)
/*
- * obj must be locked before calling, libxlDriverPrivatePtr must NOT be locked
+ * obj must be locked before calling, libxlDriverPrivate *must NOT be locked
*
* This must be called by anything that will change the VM state
* in any way
* successful calls must be followed by EndJob eventually
*/
int
-libxlDomainObjBeginJob(libxlDriverPrivatePtr driver G_GNUC_UNUSED,
- virDomainObjPtr obj,
+libxlDomainObjBeginJob(libxlDriverPrivate *driver G_GNUC_UNUSED,
+ virDomainObj *obj,
enum libxlDomainJob job)
{
- libxlDomainObjPrivatePtr priv = obj->privateData;
+ libxlDomainObjPrivate *priv = obj->privateData;
unsigned long long now;
unsigned long long then;
* and obj is disposed.
*/
void
-libxlDomainObjEndJob(libxlDriverPrivatePtr driver G_GNUC_UNUSED,
- virDomainObjPtr obj)
+libxlDomainObjEndJob(libxlDriverPrivate *driver G_GNUC_UNUSED,
+ virDomainObj *obj)
{
- libxlDomainObjPrivatePtr priv = obj->privateData;
+ libxlDomainObjPrivate *priv = obj->privateData;
enum libxlDomainJob job = priv->job.active;
VIR_DEBUG("Stopping job: %s",
static void *
libxlDomainObjPrivateAlloc(void *opaque G_GNUC_UNUSED)
{
- libxlDomainObjPrivatePtr priv;
+ libxlDomainObjPrivate *priv;
if (libxlDomainObjPrivateInitialize() < 0)
return NULL;
static void
libxlDomainObjPrivateDispose(void *obj)
{
- libxlDomainObjPrivatePtr priv = obj;
+ libxlDomainObjPrivate *priv = obj;
libxlDomainObjFreeJob(priv);
virChrdevFree(priv->devs);
static void
libxlDomainObjPrivateFree(void *data)
{
- libxlDomainObjPrivatePtr priv = data;
+ libxlDomainObjPrivate *priv = data;
g_free(priv->lockState);
virObjectUnref(priv);
static int
libxlDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
- virDomainObjPtr vm,
- virDomainDefParserConfigPtr config G_GNUC_UNUSED)
+ virDomainObj *vm,
+ virDomainDefParserConfig *config G_GNUC_UNUSED)
{
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
priv->lockState = virXPathString("string(./lockstate)", ctxt);
}
static int
-libxlDomainObjPrivateXMLFormat(virBufferPtr buf,
- virDomainObjPtr vm)
+libxlDomainObjPrivateXMLFormat(virBuffer *buf,
+ virDomainObj *vm)
{
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
if (priv->lockState)
virBufferAsprintf(buf, "<lockstate>%s</lockstate>\n", priv->lockState);
static int
-libxlDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+libxlDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
(dev->type == VIR_DOMAIN_DEVICE_NET &&
dev->data.net->type == VIR_DOMAIN_NET_TYPE_HOSTDEV)) {
- virDomainHostdevDefPtr hostdev;
- virDomainHostdevSubsysPCIPtr pcisrc;
+ virDomainHostdevDef *hostdev;
+ virDomainHostdevSubsysPCI *pcisrc;
if (dev->type == VIR_DOMAIN_DEVICE_NET)
hostdev = &dev->data.net->data.hostdev.def;
}
if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
- virDomainDiskDefPtr disk = dev->data.disk;
+ virDomainDiskDef *disk = dev->data.disk;
int actual_type = virStorageSourceGetActualType(disk->src);
int format = virDomainDiskGetFormat(disk);
}
static int
-libxlDomainDefPostParse(virDomainDefPtr def,
+libxlDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- libxlDriverPrivatePtr driver = opaque;
+ libxlDriverPrivate *driver = opaque;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
if (!virCapabilitiesDomainSupported(cfg->caps, def->os.type,
/* Xen PV domains always have a PV console, so add one to the domain config
* via post-parse callback if not explicitly specified in the XML. */
if (def->os.type != VIR_DOMAIN_OSTYPE_HVM && def->nconsoles == 0) {
- virDomainChrDefPtr chrdef;
+ virDomainChrDef *chrdef;
if (!(chrdef = virDomainChrDefNew(NULL)))
return -1;
chrdef->target.port = 0;
chrdef->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN;
- def->consoles = g_new0(virDomainChrDefPtr, 1);
+ def->consoles = g_new0(virDomainChrDef *, 1);
def->nconsoles = 1;
def->consoles[0] = chrdef;
}
/* add implicit balloon device */
if (def->memballoon == NULL) {
- virDomainMemballoonDefPtr memballoon;
+ virDomainMemballoonDef *memballoon;
memballoon = g_new0(virDomainMemballoonDef,
1);
static void
-libxlDomainShutdownHandleDestroy(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm)
+libxlDomainShutdownHandleDestroy(libxlDriverPrivate *driver,
+ virDomainObj *vm)
{
libxlDomainDestroyInternal(driver, vm);
libxlDomainCleanup(driver, vm);
static void
-libxlDomainShutdownHandleRestart(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm)
+libxlDomainShutdownHandleRestart(libxlDriverPrivate *driver,
+ virDomainObj *vm)
{
libxlDomainDestroyInternal(driver, vm);
libxlDomainCleanup(driver, vm);
struct libxlShutdownThreadInfo
{
- libxlDriverPrivatePtr driver;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver;
+ virDomainObj *vm;
libxl_event *event;
};
libxlDomainShutdownThread(void *opaque)
{
struct libxlShutdownThreadInfo *shutdown_info = opaque;
- virDomainObjPtr vm = shutdown_info->vm;
+ virDomainObj *vm = shutdown_info->vm;
libxl_event *ev = shutdown_info->event;
- libxlDriverPrivatePtr driver = shutdown_info->driver;
- virObjectEventPtr dom_event = NULL;
+ libxlDriverPrivate *driver = shutdown_info->driver;
+ virObjectEvent *dom_event = NULL;
libxl_shutdown_reason xl_reason = ev->u.domain_shutdown.shutdown_reason;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
libxl_domain_config d_config;
}
#ifdef LIBXL_HAVE_SOFT_RESET
} else if (xl_reason == LIBXL_SHUTDOWN_REASON_SOFT_RESET) {
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
if (libxlRetrieveDomainConfigurationWrapper(cfg->ctx, vm->def->id,
&d_config) != 0) {
}
static void
-libxlDomainHandleDeath(libxlDriverPrivatePtr driver, virDomainObjPtr vm)
+libxlDomainHandleDeath(libxlDriverPrivate *driver, virDomainObj *vm)
{
- virObjectEventPtr dom_event = NULL;
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ virObjectEvent *dom_event = NULL;
+ libxlDomainObjPrivate *priv = vm->privateData;
if (priv->ignoreDeathEvent) {
priv->ignoreDeathEvent = false;
void
libxlDomainEventHandler(void *data, VIR_LIBXL_EVENT_CONST libxl_event *event)
{
- libxlDriverPrivatePtr driver = data;
+ libxlDriverPrivate *driver = data;
libxl_shutdown_reason xl_reason = event->u.domain_shutdown.shutdown_reason;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
g_autoptr(libxlDriverConfig) cfg = NULL;
if (event->type != LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN &&
}
if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) {
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
struct libxlShutdownThreadInfo *shutdown_info = NULL;
virThread thread;
g_autofree char *name = NULL;
}
char *
-libxlDomainManagedSavePath(libxlDriverPrivatePtr driver, virDomainObjPtr vm)
+libxlDomainManagedSavePath(libxlDriverPrivate *driver, virDomainObj *vm)
{
char *ret;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
* Returns the opened fd on success, -1 on failure.
*/
int
-libxlDomainSaveImageOpen(libxlDriverPrivatePtr driver,
- libxlDriverConfigPtr cfg G_GNUC_UNUSED,
+libxlDomainSaveImageOpen(libxlDriverPrivate *driver,
+ libxlDriverConfig *cfg G_GNUC_UNUSED,
const char *from,
- virDomainDefPtr *ret_def,
- libxlSavefileHeaderPtr ret_hdr)
+ virDomainDef **ret_def,
+ libxlSavefileHeader *ret_hdr)
{
int fd;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
libxlSavefileHeader hdr;
g_autofree char *xml = NULL;
/*
* Internal domain destroy function.
*
- * virDomainObjPtr must be locked on invocation
+ * virDomainObj *must be locked on invocation
*/
int
-libxlDomainDestroyInternal(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm)
+libxlDomainDestroyInternal(libxlDriverPrivate *driver,
+ virDomainObj *vm)
{
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
int ret = -1;
/* Ignore next LIBXL_EVENT_TYPE_DOMAIN_DEATH as the caller will handle
/*
* Cleanup function for domain that has reached shutoff state.
*
- * virDomainObjPtr must be locked on invocation
+ * virDomainObj *must be locked on invocation
*/
void
-libxlDomainCleanup(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm)
+libxlDomainCleanup(libxlDriverPrivate *driver,
+ virDomainObj *vm)
{
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
int vnc_port;
char *file;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
unsigned int hostdev_flags = VIR_HOSTDEV_SP_PCI;
g_autoptr(virConnect) conn = NULL;
size_t i;
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
if (net->ifname &&
STRPREFIX(net->ifname, LIBXL_GENERATED_PREFIX_XEN))
/*
* Core dump domain to default dump path.
*
- * virDomainObjPtr must be locked on invocation
+ * virDomainObj *must be locked on invocation
*/
int
-libxlDomainAutoCoreDump(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm)
+libxlDomainAutoCoreDump(libxlDriverPrivate *driver,
+ virDomainObj *vm)
{
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
g_autoptr(GDateTime) now = g_date_time_new_now_local();
}
int
-libxlDomainSetVcpuAffinities(libxlDriverPrivatePtr driver, virDomainObjPtr vm)
+libxlDomainSetVcpuAffinities(libxlDriverPrivate *driver, virDomainObj *vm)
{
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
libxl_bitmap map;
- virBitmapPtr cpumask = NULL;
+ virBitmap *cpumask = NULL;
size_t i;
int ret = -1;
}
static int
-libxlNetworkPrepareDevices(virDomainDefPtr def)
+libxlNetworkPrepareDevices(virDomainDef *def)
{
size_t i;
g_autoptr(virConnect) conn = NULL;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
virDomainNetType actualType;
/* If appropriate, grab a physical device from the configured
* network / determined at runtime, we need to do it
* separately.
*/
- virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevDef *hostdev = virDomainNetGetActualHostdev(net);
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
static void
libxlConsoleCallback(libxl_ctx *ctx, libxl_event *ev, void *for_callback)
{
- virDomainObjPtr vm = for_callback;
+ virDomainObj *vm = for_callback;
size_t i;
- virDomainChrDefPtr chr;
+ virDomainChrDef *chr;
char *console = NULL;
int ret;
* parameter. User-provided interface names are skipped.
*/
static void
-libxlDomainCreateIfaceNames(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlDomainCreateIfaceNames(virDomainDef *def, libxl_domain_config *d_config)
{
size_t i;
for (i = 0; i < def->nnets && i < d_config->num_nics; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
libxl_device_nic *x_nic = &d_config->nics[i];
const char *suffix =
x_nic->nictype != LIBXL_NIC_TYPE_VIF ? "-emu" : "";
}
static void
-libxlDomainUpdateDiskParams(virDomainDefPtr def, libxl_ctx *ctx)
+libxlDomainUpdateDiskParams(virDomainDef *def, libxl_ctx *ctx)
{
libxl_device_disk *disks;
int num_disks = 0;
#ifdef LIBXL_HAVE_DEVICE_CHANNEL
static void
-libxlDomainCreateChannelPTY(virDomainDefPtr def, libxl_ctx *ctx)
+libxlDomainCreateChannelPTY(virDomainDef *def, libxl_ctx *ctx)
{
libxl_device_channel *x_channels;
- virDomainChrDefPtr chr;
+ virDomainChrDef *chr;
size_t i;
int nchannels;
/*
* Start a domain through libxenlight.
*
- * virDomainObjPtr must be locked and a job acquired on invocation
+ * virDomainObj *must be locked and a job acquired on invocation
*/
static int
-libxlDomainStart(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainStart(libxlDriverPrivate *driver,
+ virDomainObj *vm,
bool start_paused,
int restore_fd,
uint32_t restore_ver LIBXL_DOMSTART_RESTORE_VER_ATTR)
{
libxl_domain_config d_config;
- virDomainDefPtr def = NULL;
- virObjectEventPtr event = NULL;
+ virDomainDef *def = NULL;
+ virObjectEvent *event = NULL;
libxlSavefileHeader hdr;
int ret = -1;
uint32_t domid = 0;
g_autofree char *dom_xml = NULL;
g_autofree char *managed_save_path = NULL;
int managed_save_fd = -1;
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
libxl_asyncprogress_how aop_console_how;
libxl_domain_restore_params params;
unsigned int hostdev_flags = VIR_HOSTDEV_SP_PCI;
}
int
-libxlDomainStartNew(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainStartNew(libxlDriverPrivate *driver,
+ virDomainObj *vm,
bool start_paused)
{
return libxlDomainStart(driver, vm, start_paused, -1, LIBXL_SAVE_VERSION);
}
int
-libxlDomainStartRestore(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainStartRestore(libxlDriverPrivate *driver,
+ virDomainObj *vm,
bool start_paused,
int restore_fd,
uint32_t restore_ver)
}
bool
-libxlDomainDefCheckABIStability(libxlDriverPrivatePtr driver,
- virDomainDefPtr src,
- virDomainDefPtr dst)
+libxlDomainDefCheckABIStability(libxlDriverPrivate *driver,
+ virDomainDef *src,
+ virDomainDef *dst)
{
- virDomainDefPtr migratableDefSrc = NULL;
- virDomainDefPtr migratableDefDst = NULL;
+ virDomainDef *migratableDefSrc = NULL;
+ virDomainDef *migratableDefDst = NULL;
bool ret = false;
if (!(migratableDefSrc = virDomainDefCopy(src, driver->xmlopt, NULL, true)) ||
static void
libxlDomainDefNamespaceFree(void *nsdata)
{
- libxlDomainXmlNsDefPtr def = nsdata;
+ libxlDomainXmlNsDef *def = nsdata;
if (!def)
return;
libxlDomainDefNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- libxlDomainXmlNsDefPtr nsdata = NULL;
+ libxlDomainXmlNsDef *nsdata = NULL;
g_autofree xmlNodePtr *nodes = NULL;
ssize_t nnodes;
size_t i;
static int
-libxlDomainDefNamespaceFormatXML(virBufferPtr buf,
+libxlDomainDefNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
- libxlDomainXmlNsDefPtr cmd = nsdata;
+ libxlDomainXmlNsDef *cmd = nsdata;
size_t i;
if (!cmd->num_args)
};
typedef struct _libxlDomainObjPrivate libxlDomainObjPrivate;
-typedef libxlDomainObjPrivate *libxlDomainObjPrivatePtr;
struct _libxlDomainObjPrivate {
virObjectLockable parent;
/* console */
- virChrdevsPtr devs;
+ virChrdevs *devs;
libxl_evgen_domain_death *deathW;
/* Flag to indicate the upcoming LIBXL_EVENT_TYPE_DOMAIN_DEATH is caused
* by libvirt and should not be handled separately */
bool ignoreDeathEvent;
- virThreadPtr migrationDstReceiveThr;
+ virThread *migrationDstReceiveThr;
unsigned short migrationPort;
char *lockState;
bool lockProcessRunning;
extern const struct libxl_event_hooks ev_hooks;
int
-libxlDomainObjPrivateInitCtx(virDomainObjPtr vm);
+libxlDomainObjPrivateInitCtx(virDomainObj *vm);
int
-libxlDomainObjBeginJob(libxlDriverPrivatePtr driver,
- virDomainObjPtr obj,
+libxlDomainObjBeginJob(libxlDriverPrivate *driver,
+ virDomainObj *obj,
enum libxlDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
void
-libxlDomainObjEndJob(libxlDriverPrivatePtr driver,
- virDomainObjPtr obj);
+libxlDomainObjEndJob(libxlDriverPrivate *driver,
+ virDomainObj *obj);
int
libxlDomainJobUpdateTime(struct libxlDomainJobObj *job)
G_GNUC_WARN_UNUSED_RESULT;
char *
-libxlDomainManagedSavePath(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm);
+libxlDomainManagedSavePath(libxlDriverPrivate *driver,
+ virDomainObj *vm);
int
-libxlDomainSaveImageOpen(libxlDriverPrivatePtr driver,
- libxlDriverConfigPtr cfg,
+libxlDomainSaveImageOpen(libxlDriverPrivate *driver,
+ libxlDriverConfig *cfg,
const char *from,
- virDomainDefPtr *ret_def,
- libxlSavefileHeaderPtr ret_hdr)
+ virDomainDef **ret_def,
+ libxlSavefileHeader *ret_hdr)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
int
-libxlDomainDestroyInternal(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm);
+libxlDomainDestroyInternal(libxlDriverPrivate *driver,
+ virDomainObj *vm);
void
-libxlDomainCleanup(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm);
+libxlDomainCleanup(libxlDriverPrivate *driver,
+ virDomainObj *vm);
/*
* Note: Xen 4.3 removed the const from the event handler signature.
VIR_LIBXL_EVENT_CONST libxl_event *event);
int
-libxlDomainAutoCoreDump(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm);
+libxlDomainAutoCoreDump(libxlDriverPrivate *driver,
+ virDomainObj *vm);
int
-libxlDomainSetVcpuAffinities(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm);
+libxlDomainSetVcpuAffinities(libxlDriverPrivate *driver,
+ virDomainObj *vm);
int
-libxlDomainStartNew(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainStartNew(libxlDriverPrivate *driver,
+ virDomainObj *vm,
bool start_paused);
int
-libxlDomainStartRestore(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainStartRestore(libxlDriverPrivate *driver,
+ virDomainObj *vm,
bool start_paused,
int restore_fd,
uint32_t restore_ver);
bool
-libxlDomainDefCheckABIStability(libxlDriverPrivatePtr driver,
- virDomainDefPtr src,
- virDomainDefPtr dst);
+libxlDomainDefCheckABIStability(libxlDriverPrivate *driver,
+ virDomainDef *src,
+ virDomainDef *dst);
} while (0)
-static libxlDriverPrivatePtr libxl_driver;
+static libxlDriverPrivate *libxl_driver;
/* Object used to store info related to libxl event registrations */
typedef struct _libxlOSEventHookInfo libxlOSEventHookInfo;
-typedef libxlOSEventHookInfo *libxlOSEventHookInfoPtr;
struct _libxlOSEventHookInfo {
libxl_ctx *ctx;
void *xl_priv;
/* Object used to store disk statistics across multiple xen backends */
typedef struct _libxlBlockStats libxlBlockStats;
-typedef libxlBlockStats *libxlBlockStatsPtr;
struct _libxlBlockStats {
long long rd_req;
long long rd_bytes;
/* Function declarations */
static int
-libxlDomainManagedSaveLoad(virDomainObjPtr vm,
+libxlDomainManagedSaveLoad(virDomainObj *vm,
void *opaque);
int vir_events,
void *fd_info)
{
- libxlOSEventHookInfoPtr info = fd_info;
+ libxlOSEventHookInfo *info = fd_info;
int events = 0;
if (vir_events & VIR_EVENT_HANDLE_READABLE)
void *xl_priv)
{
int vir_events = VIR_EVENT_HANDLE_ERROR;
- libxlOSEventHookInfoPtr info;
+ libxlOSEventHookInfo *info;
info = g_new0(libxlOSEventHookInfo, 1);
void **hndp,
short events)
{
- libxlOSEventHookInfoPtr info = *hndp;
+ libxlOSEventHookInfo *info = *hndp;
int vir_events = VIR_EVENT_HANDLE_ERROR;
if (events & POLLIN)
int fd G_GNUC_UNUSED,
void *hnd)
{
- libxlOSEventHookInfoPtr info = hnd;
+ libxlOSEventHookInfo *info = hnd;
virEventRemoveHandle(info->id);
}
static void
libxlTimerCallback(int timer G_GNUC_UNUSED, void *timer_info)
{
- libxlOSEventHookInfoPtr info = timer_info;
+ libxlOSEventHookInfo *info = timer_info;
/*
* libxl expects the event to be deregistered when calling
struct timeval abs_t,
void *xl_priv)
{
- libxlOSEventHookInfoPtr info;
+ libxlOSEventHookInfo *info;
gint64 now_us;
gint64 abs_us;
gint64 res_ms;
void **hndp,
struct timeval abs_t G_GNUC_UNUSED)
{
- libxlOSEventHookInfoPtr info = *hndp;
+ libxlOSEventHookInfo *info = *hndp;
/* Make the timeout fire */
virEventUpdateTimeout(info->id, 0);
libxlTimeoutDeregisterEventHook(void *priv G_GNUC_UNUSED,
void *hnd)
{
- libxlOSEventHookInfoPtr info = hnd;
+ libxlOSEventHookInfo *info = hnd;
virEventRemoveTimeout(info->id);
}
-static virDomainObjPtr
+static virDomainObj *
libxlDomObjFromDomain(virDomainPtr dom)
{
- virDomainObjPtr vm;
- libxlDriverPrivatePtr driver = dom->conn->privateData;
+ virDomainObj *vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
}
static int
-libxlAutostartDomain(virDomainObjPtr vm,
+libxlAutostartDomain(virDomainObj *vm,
void *opaque)
{
- libxlDriverPrivatePtr driver = opaque;
+ libxlDriverPrivate *driver = opaque;
int ret = -1;
virObjectRef(vm);
static void
-libxlReconnectNotifyNets(virDomainDefPtr def)
+libxlReconnectNotifyNets(virDomainDef *def)
{
size_t i;
g_autoptr(virConnect) conn = NULL;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
/* keep others from trying to use the macvtap device name, but
* don't return error if this happens, since that causes the
* domain to be unceremoniously killed, which would be *very*
* with libxenlight driver.
*/
static int
-libxlReconnectDomain(virDomainObjPtr vm,
+libxlReconnectDomain(virDomainObj *vm,
void *opaque)
{
- libxlDriverPrivatePtr driver = opaque;
- libxlDomainObjPrivatePtr priv = vm->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverPrivate *driver = opaque;
+ libxlDomainObjPrivate *priv = vm->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
int rc;
libxl_dominfo d_info;
int len;
uint8_t *data = NULL;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
unsigned int hostdev_flags = VIR_HOSTDEV_SP_PCI;
int ret = -1;
}
static void
-libxlReconnectDomains(libxlDriverPrivatePtr driver)
+libxlReconnectDomains(libxlDriverPrivate *driver)
{
virDomainObjListForEach(driver->domains, true, libxlReconnectDomain, driver);
}
};
static int
-libxlAddDom0(libxlDriverPrivatePtr driver)
+libxlAddDom0(libxlDriverPrivate *driver)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
libxl_dominfo d_info;
unsigned long long maxmem;
int ret = -1;
virStateInhibitCallback callback,
void *opaque)
{
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
g_autofree char *driverConf = NULL;
bool autostart = true;
static int
libxlStateReload(void)
{
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
if (!libxl_driver)
return 0;
static virDrvOpenStatus
libxlConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int
libxlConnectGetVersion(virConnectPtr conn, unsigned long *version)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg;
if (virConnectGetVersionEnsureACL(conn) < 0)
return 0;
static char *
libxlConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
libxlConnectGetMaxVcpus(virConnectPtr conn, const char *type G_GNUC_UNUSED)
{
int ret;
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg;
if (virConnectGetMaxVcpusEnsureACL(conn) < 0)
return -1;
static char *
libxlConnectGetCapabilities(virConnectPtr conn)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
char *xml;
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
return NULL;
static int
libxlConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectListDomainsEnsureACL(conn) < 0)
return -1;
static int
libxlConnectNumOfDomains(virConnectPtr conn)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectNumOfDomainsEnsureACL(conn) < 0)
return -1;
libxlDomainCreateXML(virConnectPtr conn, const char *xml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- virDomainDefPtr def;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = conn->privateData;
+ virDomainDef *def;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_START_PAUSED |
static virDomainPtr
libxlDomainLookupByID(virConnectPtr conn, int id)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByID(driver->domains, id);
static virDomainPtr
libxlDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByUUID(driver->domains, uuid);
static virDomainPtr
libxlDomainLookupByName(virConnectPtr conn, const char *name)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByName(driver->domains, name);
static int
libxlDomainSuspend(virDomainPtr dom)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
static int
libxlDomainResume(virDomainPtr dom)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
static int
libxlDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN |
static int
libxlDomainReboot(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_REBOOT_PARAVIRT, -1);
libxlDomainDestroyFlags(virDomainPtr dom,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
unsigned long long duration,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
if (target != VIR_NODE_SUSPEND_TARGET_MEM) {
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- /* Unlock virDomainObjPtr to not deadlock with even handler, which will try
+ /* Unlock virDomainObj *to not deadlock with even handler, which will try
* to send lifecycle event
*/
virObjectUnlock(vm);
static int
libxlDomainPMWakeup(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- virObjectEventPtr event = NULL;
- libxlDomainObjPrivatePtr priv;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ virObjectEvent *event = NULL;
+ libxlDomainObjPrivate *priv;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
virCheckFlags(0, -1);
static char *
libxlDomainGetOSType(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *type = NULL;
if (!(vm = libxlDomObjFromDomain(dom)))
static unsigned long long
libxlDomainGetMaxMemory(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned long long ret = 0;
if (!(vm = libxlDomObjFromDomain(dom)))
* domain configuration if needed. Return -1 on error.
*/
static int
-virDomainLiveConfigHelperMethod(virCapsPtr caps G_GNUC_UNUSED,
- virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr dom,
+virDomainLiveConfigHelperMethod(virCaps *caps G_GNUC_UNUSED,
+ virDomainXMLOption *xmlopt,
+ virDomainObj *dom,
unsigned int *flags,
- virDomainDefPtr *persistentDef)
+ virDomainDef **persistentDef)
{
if (virDomainObjUpdateModificationImpact(dom, flags) < 0)
return -1;
libxlDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virDomainDefPtr persistentDef = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_MEM_LIVE |
static int
libxlDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
libxl_dominfo d_info;
int ret = -1;
int *reason,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
}
/*
- * virDomainObjPtr must be locked on invocation
+ * virDomainObj *must be locked on invocation
*/
static int
-libxlDoDomainSave(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDoDomainSave(libxlDriverPrivate *driver,
+ virDomainObj *vm,
const char *to,
bool managed)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
libxlSavefileHeader hdr;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autofree char *xml = NULL;
uint32_t xml_len;
int fd = -1;
libxlDomainSaveFlags(virDomainPtr dom, const char *to, const char *dxml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
#ifdef LIBXL_HAVE_NO_SUSPEND_RESUME
libxlDomainRestoreFlags(virConnectPtr conn, const char *from,
const char *dxml, unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
libxlSavefileHeader hdr;
int fd = -1;
int ret = -1;
static int
libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
bool paused = false;
int ret = -1;
static int
libxlDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
g_autofree char *name = NULL;
int ret = -1;
}
static int
-libxlDomainManagedSaveLoad(virDomainObjPtr vm,
+libxlDomainManagedSaveLoad(virDomainObj *vm,
void *opaque)
{
- libxlDriverPrivatePtr driver = opaque;
+ libxlDriverPrivate *driver = opaque;
char *name;
int ret = -1;
static int
libxlDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int
libxlDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
g_autofree char *name = NULL;
libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def;
+ virDomainObj *vm;
libxl_bitmap map;
uint8_t *bitmask = NULL;
unsigned int maplen;
static int
libxlDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virDomainObj *vm;
+ virDomainDef *def;
int ret = -1;
bool active;
unsigned char *cpumap, int maplen,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr targetDef = NULL;
- virBitmapPtr pcpumap = NULL;
- virDomainVcpuDefPtr vcpuinfo;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *targetDef = NULL;
+ virBitmap *pcpumap = NULL;
+ virDomainVcpuDef *vcpuinfo;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
unsigned char *cpumaps, int maplen,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
- virDomainDefPtr targetDef = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm = NULL;
+ virDomainDef *targetDef = NULL;
g_autoptr(virBitmap) hostcpus = NULL;
int ret = -1;
libxlDomainGetVcpus(virDomainPtr dom, virVcpuInfoPtr info, int maxinfo,
unsigned char *cpumaps, int maplen)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
int ret = -1;
libxl_vcpuinfo *vcpuinfo;
int maxcpu, hostcpus;
static char *
libxlDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virDomainDef *def;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
const char *nativeConfig,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def = NULL;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def = NULL;
g_autoptr(virConf) conf = NULL;
char *xml = NULL;
const char * domainXml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def = NULL;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def = NULL;
g_autoptr(virConf) conf = NULL;
int len = MAX_CONFIG_SIZE;
char *ret = NULL;
libxlConnectListDefinedDomains(virConnectPtr conn,
char **const names, int nnames)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int
libxlConnectNumOfDefinedDomains(virConnectPtr conn)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
return -1;
libxlDomainCreateWithFlags(virDomainPtr dom,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_START_PAUSED, -1);
static virDomainPtr
libxlDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
- virObjectEventPtr event = NULL;
- virDomainDefPtr oldDef = NULL;
+ virObjectEvent *event = NULL;
+ virDomainDef *oldDef = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
libxlDomainUndefineFlags(virDomainPtr dom,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
g_autofree char *name = NULL;
int ret = -1;
}
static int
-libxlDomainChangeEjectableMedia(virDomainObjPtr vm, virDomainDiskDefPtr disk)
+libxlDomainChangeEjectableMedia(virDomainObj *vm, virDomainDiskDef *disk)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(libxl_driver);
- virDomainDiskDefPtr origdisk = NULL;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(libxl_driver);
+ virDomainDiskDef *origdisk = NULL;
libxl_device_disk x_disk;
size_t i;
int ret = -1;
}
static int
-libxlDomainAttachDeviceDiskLive(virDomainObjPtr vm, virDomainDeviceDefPtr dev)
+libxlDomainAttachDeviceDiskLive(virDomainObj *vm, virDomainDeviceDef *dev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(libxl_driver);
- virDomainDiskDefPtr l_disk = dev->data.disk;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(libxl_driver);
+ virDomainDiskDef *l_disk = dev->data.disk;
libxl_device_disk x_disk;
int ret = -1;
}
static int
-libxlDomainAttachHostPCIDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainAttachHostPCIDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
libxl_device_pci pcidev;
- virDomainHostdevDefPtr found;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevDef *found;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
int ret = -1;
libxl_device_pci_init(&pcidev);
#ifdef LIBXL_HAVE_PVUSB
static int
-libxlDomainAttachControllerDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainControllerDefPtr controller)
+libxlDomainAttachControllerDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainControllerDef *controller)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
const char *type = virDomainControllerTypeToString(controller->type);
libxl_device_usbctrl usbctrl;
int ret = -1;
}
static int
-libxlDomainAttachHostUSBDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainAttachHostUSBDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
libxl_device_usbdev usbdev;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
int ret = -1;
size_t i;
int ports = 0, usbdevs = 0;
if (ports <= usbdevs) {
/* no free ports, we will create a new usb controller */
- virDomainControllerDefPtr controller;
+ virDomainControllerDef *controller;
if (!(controller = virDomainControllerDefNew(VIR_DOMAIN_CONTROLLER_TYPE_USB)))
goto cleanup;
#endif
static int
-libxlDomainAttachHostDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainAttachHostDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
static int
-libxlDomainDetachDeviceDiskLive(virDomainObjPtr vm, virDomainDeviceDefPtr dev)
+libxlDomainDetachDeviceDiskLive(virDomainObj *vm, virDomainDeviceDef *dev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(libxl_driver);
- virDomainDiskDefPtr l_disk = NULL;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(libxl_driver);
+ virDomainDiskDef *l_disk = NULL;
libxl_device_disk x_disk;
int idx;
int ret = -1;
}
static int
-libxlDomainAttachNetDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net)
+libxlDomainAttachNetDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
virDomainNetType actualType;
libxl_device_nic nic;
int ret = -1;
}
if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
- virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevDef *hostdev = virDomainNetGetActualHostdev(net);
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
/* For those just allocated from a network pool whose backend is
* still VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT, we need to set
}
static int
-libxlDomainAttachDeviceLive(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+libxlDomainAttachDeviceLive(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int ret = -1;
}
static int
-libxlDomainAttachDeviceConfig(virDomainDefPtr vmdef, virDomainDeviceDefPtr dev)
+libxlDomainAttachDeviceConfig(virDomainDef *vmdef, virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr disk;
- virDomainNetDefPtr net;
- virDomainHostdevDefPtr hostdev;
- virDomainControllerDefPtr controller;
- virDomainHostdevDefPtr found;
+ virDomainDiskDef *disk;
+ virDomainNetDef *net;
+ virDomainHostdevDef *hostdev;
+ virDomainControllerDef *controller;
+ virDomainHostdevDef *found;
char mac[VIR_MAC_STRING_BUFLEN];
switch (dev->type) {
}
static int
-libxlComparePCIDevice(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info1,
+libxlComparePCIDevice(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info1,
void *opaque)
{
- virDomainDeviceInfoPtr info2 = opaque;
+ virDomainDeviceInfo *info2 = opaque;
if (info1->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
info2->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
}
static bool
-libxlIsMultiFunctionDevice(virDomainDefPtr def,
- virDomainDeviceInfoPtr dev)
+libxlIsMultiFunctionDevice(virDomainDef *def,
+ virDomainDeviceInfo *dev)
{
if (virDomainDeviceInfoIterate(def, libxlComparePCIDevice, dev) < 0)
return true;
}
static int
-libxlDomainDetachHostPCIDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainDetachHostPCIDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
- virDomainHostdevSubsysPCIPtr pcisrc = &subsys->u.pci;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainHostdevSubsys *subsys = &hostdev->source.subsys;
+ virDomainHostdevSubsysPCI *pcisrc = &subsys->u.pci;
libxl_device_pci pcidev;
- virDomainHostdevDefPtr detach;
+ virDomainHostdevDef *detach;
int idx;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
int ret = -1;
libxl_device_pci_init(&pcidev);
#ifdef LIBXL_HAVE_PVUSB
static int
-libxlDomainDetachControllerDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+libxlDomainDetachControllerDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int idx, ret = -1;
- virDomainControllerDefPtr detach = NULL;
- virDomainControllerDefPtr controller = dev->data.controller;
+ virDomainControllerDef *detach = NULL;
+ virDomainControllerDef *controller = dev->data.controller;
const char *type = virDomainControllerTypeToString(controller->type);
libxl_device_usbctrl usbctrl;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
libxl_device_usbctrl_init(&usbctrl);
}
static int
-libxlDomainDetachHostUSBDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainDetachHostUSBDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
- virDomainHostdevSubsysUSBPtr usbsrc = &subsys->u.usb;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainHostdevSubsys *subsys = &hostdev->source.subsys;
+ virDomainHostdevSubsysUSB *usbsrc = &subsys->u.usb;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
libxl_device_usbdev usbdev;
libxl_device_usbdev *usbdevs = NULL;
int num = 0;
- virDomainHostdevDefPtr detach;
+ virDomainHostdevDef *detach;
int idx;
size_t i;
bool found = false;
#endif
static int
-libxlDomainDetachHostDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+libxlDomainDetachHostDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
+ virDomainHostdevSubsys *subsys = &hostdev->source.subsys;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
static int
-libxlDomainDetachNetDevice(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net)
+libxlDomainDetachNetDevice(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
int detachidx;
- virDomainNetDefPtr detach = NULL;
+ virDomainNetDef *detach = NULL;
libxl_device_nic nic;
char mac[VIR_MAC_STRING_BUFLEN];
int ret = -1;
}
static int
-libxlDomainDetachDeviceLive(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+libxlDomainDetachDeviceLive(libxlDriverPrivate *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDef *hostdev;
int ret = -1;
switch (dev->type) {
static int
-libxlDomainDetachDeviceConfig(virDomainDefPtr vmdef, virDomainDeviceDefPtr dev)
+libxlDomainDetachDeviceConfig(virDomainDef *vmdef, virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr disk;
- virDomainDiskDefPtr detach;
- virDomainHostdevDefPtr hostdev;
- virDomainHostdevDefPtr det_hostdev;
- virDomainControllerDefPtr cont;
- virDomainControllerDefPtr det_cont;
- virDomainNetDefPtr net;
+ virDomainDiskDef *disk;
+ virDomainDiskDef *detach;
+ virDomainHostdevDef *hostdev;
+ virDomainHostdevDef *det_hostdev;
+ virDomainControllerDef *cont;
+ virDomainControllerDef *det_cont;
+ virDomainNetDef *net;
int idx;
switch (dev->type) {
}
static int
-libxlDomainUpdateDeviceLive(virDomainObjPtr vm, virDomainDeviceDefPtr dev)
+libxlDomainUpdateDeviceLive(virDomainObj *vm, virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
int ret = -1;
switch (dev->type) {
}
static int
-libxlDomainUpdateDeviceConfig(virDomainDefPtr vmdef, virDomainDeviceDefPtr dev)
+libxlDomainUpdateDeviceConfig(virDomainDef *vmdef, virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr orig;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *orig;
+ virDomainDiskDef *disk;
switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK:
static void
libxlDomainAttachDeviceNormalize(const virDomainDeviceDef *devConf,
- virDomainDeviceDefPtr devLive)
+ virDomainDeviceDef *devLive)
{
/*
* Fixup anything that needs to be identical in the live and
libxlDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr devConf = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *devConf = NULL;
virDomainDeviceDef devConfSave = { 0 };
- virDomainDeviceDefPtr devLive = NULL;
+ virDomainDeviceDef *devLive = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
libxlDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *dev = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
libxlDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *dev = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
libxlNodeGetFreeMemory(virConnectPtr conn)
{
libxl_physinfo phy_info;
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
unsigned long long ret = 0;
libxl_physinfo_init(&phy_info);
int n, lastCell, numCells;
int ret = -1, nr_nodes = 0;
libxl_numainfo *numa_info = NULL;
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
if (virNodeGetCellsFreeMemoryEnsureACL(conn) < 0)
goto cleanup;
void *opaque,
virFreeCallback freecb)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectDomainEventRegisterEnsureACL(conn) < 0)
return -1;
libxlConnectDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectDomainEventDeregisterEnsureACL(conn) < 0)
return -1;
static int
libxlDomainGetAutostart(virDomainPtr dom, int *autostart)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
static int
libxlDomainSetAutostart(virDomainPtr dom, int autostart)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
g_autofree char *configFile = NULL;
g_autofree char *autostartLink = NULL;
int ret = -1;
static char *
libxlDomainGetSchedulerType(virDomainPtr dom, int *nparams)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
char * ret = NULL;
const char *name = NULL;
libxl_scheduler sched_id;
int *nparams,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
libxl_domain_sched_params sc_info;
libxl_scheduler sched_id;
int ret = -1;
int nparams,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
libxl_domain_sched_params sc_info;
int sched_id;
size_t i;
virStreamPtr st,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainChrDefPtr chr = NULL;
- libxlDomainObjPrivatePtr priv;
+ virDomainChrDef *chr = NULL;
+ libxlDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_CONSOLE_FORCE, -1);
int *nparams,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainObj *vm;
libxl_bitmap nodemap;
- virBitmapPtr nodes = NULL;
+ virBitmap *nodes = NULL;
int rc, ret = -1;
size_t i, j;
static int
libxlDomainIsActive(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = libxlDomObjFromDomain(dom)))
static int
libxlDomainIsPersistent(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = libxlDomObjFromDomain(dom)))
static int
libxlDomainIsUpdated(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
const char *device,
virDomainInterfaceStatsPtr stats)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainNetDefPtr net = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virDomainNetDef *net = NULL;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
}
static int
-libxlDomainGetTotalCPUStats(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainGetTotalCPUStats(libxlDriverPrivate *driver,
+ virDomainObj *vm,
virTypedParameterPtr params,
unsigned int nparams)
{
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
libxl_dominfo d_info;
int ret = -1;
}
static int
-libxlDomainGetPerCPUStats(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainGetPerCPUStats(libxlDriverPrivate *driver,
+ virDomainObj *vm,
virTypedParameterPtr params,
unsigned int nparams,
int start_cpu,
libxl_vcpuinfo *vcpuinfo;
int maxcpu, hostcpus;
size_t i;
- libxlDriverConfigPtr cfg;
+ libxlDriverConfig *cfg;
int ret = -1;
if (nparams == 0 && ncpus != 0)
unsigned int ncpus,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
unsigned int nr_stats,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- libxlDriverConfigPtr cfg;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ libxlDriverConfig *cfg;
+ virDomainObj *vm;
libxl_dominfo d_info;
unsigned mem, maxmem;
size_t i = 0;
libxlDomainGetJobInfo(virDomainPtr dom,
virDomainJobInfoPtr info)
{
- libxlDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
+ libxlDomainObjPrivate *priv;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
int *nparams,
unsigned int flags)
{
- libxlDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
+ libxlDomainObjPrivate *priv;
+ virDomainObj *vm;
virDomainJobInfoPtr jobInfo;
int ret = -1;
int maxparams = 0;
}
static int
-libxlDomainBlockStatsVBD(virDomainObjPtr vm,
+libxlDomainBlockStatsVBD(virDomainObj *vm,
const char *dev,
- libxlBlockStatsPtr stats)
+ libxlBlockStats *stats)
{
int ret = -1;
int devno = libxlDiskPathToID(dev);
}
#else
static int
-libxlDomainBlockStatsVBD(virDomainObjPtr vm G_GNUC_UNUSED,
+libxlDomainBlockStatsVBD(virDomainObj *vm G_GNUC_UNUSED,
const char *dev G_GNUC_UNUSED,
- libxlBlockStatsPtr stats G_GNUC_UNUSED)
+ libxlBlockStats *stats G_GNUC_UNUSED)
{
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
"%s", _("platform unsupported"));
#endif
static int
-libxlDomainBlockStatsGatherSingle(virDomainObjPtr vm,
+libxlDomainBlockStatsGatherSingle(virDomainObj *vm,
const char *path,
- libxlBlockStatsPtr stats)
+ libxlBlockStats *stats)
{
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
const char *disk_drv;
int ret = -1, disk_fmt;
}
static int
-libxlDomainBlockStatsGather(virDomainObjPtr vm,
+libxlDomainBlockStatsGather(virDomainObj *vm,
const char *path,
- libxlBlockStatsPtr stats)
+ libxlBlockStats *stats)
{
int ret = -1;
const char *path,
virDomainBlockStatsPtr stats)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
libxlBlockStats blkstats;
int ret = -1;
int *nparams,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm;
libxlBlockStats blkstats;
int nstats;
int ret = -1;
virConnectDomainEventGenericCallback callback,
void *opaque, virFreeCallback freecb)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
int ret;
if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
static int
libxlConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
virDomainPtr **domains,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
+ libxlDriverPrivate *driver = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
const char *driverName,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ libxlDriverPrivate *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virCheckFlags(0, -1);
static int
libxlNodeDeviceReAttach(virNodeDevicePtr dev)
{
- libxlDriverPrivatePtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ libxlDriverPrivate *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
/* virNodeDeviceReAttachEnsureACL() is being called by
* virDomainDriverNodeDeviceReAttach() */
static int
libxlNodeDeviceReset(virNodeDevicePtr dev)
{
- libxlDriverPrivatePtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ libxlDriverPrivate *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
/* virNodeDeviceResetEnsureACL() is being called by
* virDomainDriverNodeDeviceReset() */
unsigned int flags)
{
const char *xmlin = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
char *xmlout = NULL;
#ifdef LIBXL_HAVE_NO_SUSPEND_RESUME
int *cookieoutlen G_GNUC_UNUSED,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
- virDomainDefPtr def = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ virDomainDef *def = NULL;
const char *dom_xml = NULL;
const char *dname = NULL;
const char *uri_in = NULL;
char **uri_out,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
- virDomainDefPtr def = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ virDomainDef *def = NULL;
const char *dom_xml = NULL;
const char *dname = NULL;
const char *uri_in = NULL;
int *cookieoutlen G_GNUC_UNUSED,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
const char *dom_xml = NULL;
const char *dname = NULL;
const char *uri = NULL;
unsigned int flags,
int cancelled)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ virDomainObj *vm = NULL;
const char *dname = NULL;
virDomainPtr ret = NULL;
unsigned int flags,
int cancelled)
{
- libxlDriverPrivatePtr driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = domain->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
#ifdef LIBXL_HAVE_NO_SUSPEND_RESUME
}
static int
-libxlGetDHCPInterfaces(virDomainObjPtr vm,
+libxlGetDHCPInterfaces(virDomainObj *vm,
virDomainInterfacePtr **ifaces)
{
g_autoptr(virConnect) conn = NULL;
unsigned int source,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
const char *virttype_str,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg;
char *ret = NULL;
int virttype = VIR_DOMAIN_VIRT_XEN;
- virDomainCapsPtr domCaps = NULL;
+ virDomainCaps *domCaps = NULL;
int arch = virArchFromHost(); /* virArch */
virCheckFlags(0, ret);
const char *xmlDesc,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg;
int ret = VIR_CPU_COMPARE_ERROR;
bool failIncompatible;
bool validateXML;
unsigned int ncpus,
unsigned int flags)
{
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
const char *uri,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dom->conn->privateData;
+ libxlDriverPrivate *driver = dom->conn->privateData;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
cfg->configDir, flags);
if (ret == 0) {
- virObjectEventPtr ev = NULL;
+ virObjectEvent *ev = NULL;
ev = virDomainEventMetadataChangeNewFromObj(vm, type, uri);
virObjectEventStateQueue(driver->domainEventState, ev);
}
const char *uri,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = libxlDomObjFromDomain(dom)))
}
-libxlLoggerPtr
+libxlLogger *
libxlLoggerNew(const char *logDir, virLogPriority minLevel)
{
xentoollog_logger_libvirt logger;
}
void
-libxlLoggerFree(libxlLoggerPtr logger)
+libxlLoggerFree(libxlLogger *logger)
{
xentoollog_logger *xtl_logger = (xentoollog_logger*)logger;
if (logger->defaultLogFile)
}
void
-libxlLoggerOpenFile(libxlLoggerPtr logger,
+libxlLoggerOpenFile(libxlLogger *logger,
int id,
const char *name,
const char *domain_config)
}
void
-libxlLoggerCloseFile(libxlLoggerPtr logger, int id)
+libxlLoggerCloseFile(libxlLogger *logger, int id)
{
g_autofree char *domidstr = NULL;
domidstr = g_strdup_printf("%d", id);
#include "util/virlog.h"
typedef struct xentoollog_logger_libvirt libxlLogger;
-typedef libxlLogger *libxlLoggerPtr;
-libxlLoggerPtr libxlLoggerNew(const char *logDir,
+libxlLogger *libxlLoggerNew(const char *logDir,
virLogPriority minLevel);
-void libxlLoggerFree(libxlLoggerPtr logger);
+void libxlLoggerFree(libxlLogger *logger);
-void libxlLoggerOpenFile(libxlLoggerPtr logger, int id, const char *name,
+void libxlLoggerOpenFile(libxlLogger *logger, int id, const char *name,
const char *domain_config);
-void libxlLoggerCloseFile(libxlLoggerPtr logger, int id);
+void libxlLoggerCloseFile(libxlLogger *logger, int id);
VIR_LOG_INIT("libxl.libxl_migration");
typedef struct _libxlMigrationCookie libxlMigrationCookie;
-typedef libxlMigrationCookie *libxlMigrationCookiePtr;
struct _libxlMigrationCookie {
/* Host properties */
char *srcHostname;
int recvfd;
virConnectPtr conn;
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned int flags;
- libxlMigrationCookiePtr migcookie;
+ libxlMigrationCookie *migcookie;
/* for freeing listen sockets */
- virNetSocketPtr *socks;
+ virNetSocket **socks;
size_t nsocks;
} libxlMigrationDstArgs;
-static virClassPtr libxlMigrationDstArgsClass;
+static virClass *libxlMigrationDstArgsClass;
static void
-libxlMigrationCookieFree(libxlMigrationCookiePtr mig)
+libxlMigrationCookieFree(libxlMigrationCookie *mig)
{
if (!mig)
return;
g_free(mig);
}
-static libxlMigrationCookiePtr
-libxlMigrationCookieNew(virDomainObjPtr dom)
+static libxlMigrationCookie *
+libxlMigrationCookieNew(virDomainObj *dom)
{
- libxlMigrationCookiePtr mig = NULL;
+ libxlMigrationCookie *mig = NULL;
mig = g_new0(libxlMigrationCookie, 1);
static int
-libxlMigrationBakeCookie(libxlMigrationCookiePtr mig,
+libxlMigrationBakeCookie(libxlMigrationCookie *mig,
char **cookieout,
int *cookieoutlen)
{
static int
libxlMigrationEatCookie(const char *cookiein,
int cookieinlen,
- libxlMigrationCookiePtr *migout)
+ libxlMigrationCookie **migout)
{
- libxlMigrationCookiePtr mig = NULL;
+ libxlMigrationCookie *mig = NULL;
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
g_autofree char *uuidstr = NULL;
libxlDoMigrateDstReceive(void *opaque)
{
libxlMigrationDstArgs *args = opaque;
- virDomainObjPtr vm = args->vm;
- virNetSocketPtr *socks = args->socks;
+ virDomainObj *vm = args->vm;
+ virNetSocket **socks = args->socks;
size_t nsocks = args->nsocks;
- libxlDriverPrivatePtr driver = args->conn->privateData;
+ libxlDriverPrivate *driver = args->conn->privateData;
int recvfd = args->recvfd;
size_t i;
static void
-libxlMigrateDstReceive(virNetSocketPtr sock,
+libxlMigrateDstReceive(virNetSocket *sock,
int events G_GNUC_UNUSED,
void *opaque)
{
libxlMigrationDstArgs *args = opaque;
- virNetSocketPtr *socks = args->socks;
+ virNetSocket **socks = args->socks;
size_t nsocks = args->nsocks;
- libxlDomainObjPrivatePtr priv = args->vm->privateData;
- virNetSocketPtr client_sock;
+ libxlDomainObjPrivate *priv = args->vm->privateData;
+ virNetSocket *client_sock;
int recvfd = -1;
size_t i;
g_autofree char *name = NULL;
}
static int
-libxlDoMigrateSrcSend(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDoMigrateSrcSend(libxlDriverPrivate *driver,
+ virDomainObj *vm,
unsigned long flags,
int sockfd)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
int xl_flags = 0;
int ret;
}
static bool
-libxlDomainMigrationIsAllowed(virDomainDefPtr def)
+libxlDomainMigrationIsAllowed(virDomainDef *def)
{
/* Migration is not allowed if definition contains any hostdevs */
if (def->nhostdevs > 0) {
char *
libxlDomainMigrationSrcBegin(virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
char **cookieout,
int *cookieoutlen)
{
- libxlDriverPrivatePtr driver = conn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- libxlMigrationCookiePtr mig = NULL;
- virDomainDefPtr tmpdef = NULL;
- virDomainDefPtr def;
+ libxlDriverPrivate *driver = conn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ libxlMigrationCookie *mig = NULL;
+ virDomainDef *tmpdef = NULL;
+ virDomainDef *def;
char *xml = NULL;
/*
return xml;
}
-virDomainDefPtr
-libxlDomainMigrationDstPrepareDef(libxlDriverPrivatePtr driver,
+virDomainDef *
+libxlDomainMigrationDstPrepareDef(libxlDriverPrivate *driver,
const char *dom_xml,
const char *dname)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- virDomainDefPtr def;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ virDomainDef *def;
if (!dom_xml) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
libxlDomainMigrationPrepareAny(virConnectPtr dconn,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *cookiein,
int cookieinlen,
- libxlMigrationCookiePtr *mig,
+ libxlMigrationCookie **mig,
char **xmlout,
bool *taint_hook)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
+ libxlDriverPrivate *driver = dconn->privateData;
if (libxlMigrationEatCookie(cookiein, cookieinlen, mig) < 0)
return -1;
VIR_DEBUG("Migrate hook filter returned nothing; using the"
" original XML");
} else {
- virDomainDefPtr newdef;
+ virDomainDef *newdef;
VIR_DEBUG("Using hook-filtered domain XML: %s", *xmlout);
newdef = virDomainDefParseString(*xmlout, driver->xmlopt,
int
libxlDomainMigrationDstPrepareTunnel3(virConnectPtr dconn,
virStreamPtr st,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *cookiein,
int cookieinlen,
unsigned int flags)
{
- libxlMigrationCookiePtr mig = NULL;
- libxlDriverPrivatePtr driver = dconn->privateData;
- virDomainObjPtr vm = NULL;
+ libxlMigrationCookie *mig = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ virDomainObj *vm = NULL;
libxlMigrationDstArgs *args = NULL;
bool taint_hook = false;
- libxlDomainObjPrivatePtr priv = NULL;
+ libxlDomainObjPrivate *priv = NULL;
char *xmlout = NULL;
int dataFD[2] = { -1, -1 };
int ret = -1;
int
libxlDomainMigrationDstPrepare(virConnectPtr dconn,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *uri_in,
char **uri_out,
const char *cookiein,
int cookieinlen,
unsigned int flags)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- libxlMigrationCookiePtr mig = NULL;
- virDomainObjPtr vm = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ libxlMigrationCookie *mig = NULL;
+ virDomainObj *vm = NULL;
char *hostname = NULL;
char *xmlout = NULL;
unsigned short port;
char portstr[100];
- virURIPtr uri = NULL;
- virNetSocketPtr *socks = NULL;
+ virURI *uri = NULL;
+ virNetSocket **socks = NULL;
size_t nsocks = 0;
int nsocks_listen = 0;
libxlMigrationDstArgs *args = NULL;
bool taint_hook = false;
- libxlDomainObjPrivatePtr priv = NULL;
+ libxlDomainObjPrivate *priv = NULL;
size_t i;
int ret = -1;
};
static int
-libxlMigrationSrcStartTunnel(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlMigrationSrcStartTunnel(libxlDriverPrivate *driver,
+ virDomainObj *vm,
unsigned long flags,
virStreamPtr st,
struct libxlTunnelControl **tnl)
* introduced in libxl.
*/
static int
-libxlDoMigrateSrcP2P(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDoMigrateSrcP2P(libxlDriverPrivate *driver,
+ virDomainObj *vm,
virConnectPtr sconn,
const char *xmlin,
virConnectPtr dconn,
* the migration process with an established virConnectPtr to the destination.
*/
int
-libxlDomainMigrationSrcPerformP2P(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcPerformP2P(libxlDriverPrivate *driver,
+ virDomainObj *vm,
virConnectPtr sconn,
const char *xmlin,
const char *dconnuri,
int useParams;
virConnectPtr dconn = NULL;
virErrorPtr orig_err = NULL;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
virObjectUnlock(vm);
dconn = virConnectOpenAuth(dconnuri, &virConnectAuthConfig, 0);
}
int
-libxlDomainMigrationSrcPerform(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcPerform(libxlDriverPrivate *driver,
+ virDomainObj *vm,
const char *dom_xml G_GNUC_UNUSED,
const char *dconnuri G_GNUC_UNUSED,
const char *uri_str,
const char *dname G_GNUC_UNUSED,
unsigned int flags)
{
- libxlDomainObjPrivatePtr priv = vm->privateData;
+ libxlDomainObjPrivate *priv = vm->privateData;
char *hostname = NULL;
unsigned short port = 0;
char portstr[100];
- virURIPtr uri = NULL;
- virNetSocketPtr sock;
+ virURI *uri = NULL;
+ virNetSocket *sock;
int sockfd = -1;
int ret = -1;
virDomainPtr
libxlDomainMigrationDstFinish(virConnectPtr dconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
unsigned int flags,
int cancelled)
{
- libxlDriverPrivatePtr driver = dconn->privateData;
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- libxlDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event = NULL;
+ libxlDriverPrivate *driver = dconn->privateData;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ libxlDomainObjPrivate *priv = vm->privateData;
+ virObjectEvent *event = NULL;
virDomainPtr dom = NULL;
if (priv->migrationDstReceiveThr) {
if (flags & VIR_MIGRATE_PERSIST_DEST) {
unsigned int oldPersist = vm->persistent;
- virDomainDefPtr vmdef;
+ virDomainDef *vmdef;
vm->persistent = 1;
if (!(vmdef = virDomainObjGetPersistentDef(driver->xmlopt, vm, NULL)))
}
int
-libxlDomainMigrationSrcConfirm(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcConfirm(libxlDriverPrivate *driver,
+ virDomainObj *vm,
unsigned int flags,
int cancelled)
{
- libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
- libxlDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event = NULL;
+ libxlDriverConfig *cfg = libxlDriverConfigGet(driver);
+ libxlDomainObjPrivate *priv = vm->privateData;
+ virObjectEvent *event = NULL;
int ret = -1;
if (cancelled) {
char *
libxlDomainMigrationSrcBegin(virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
char **cookieout,
int *cookieoutlen);
-virDomainDefPtr
-libxlDomainMigrationDstPrepareDef(libxlDriverPrivatePtr driver,
+virDomainDef *
+libxlDomainMigrationDstPrepareDef(libxlDriverPrivate *driver,
const char *dom_xml,
const char *dname);
int
libxlDomainMigrationDstPrepareTunnel3(virConnectPtr dconn,
virStreamPtr st,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *cookiein,
int cookieinlen,
unsigned int flags);
int
libxlDomainMigrationDstPrepare(virConnectPtr dconn,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *uri_in,
char **uri_out,
const char *cookiein,
unsigned int flags);
int
-libxlDomainMigrationSrcPerformP2P(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcPerformP2P(libxlDriverPrivate *driver,
+ virDomainObj *vm,
virConnectPtr sconn,
const char *dom_xml,
const char *dconnuri,
unsigned int flags);
int
-libxlDomainMigrationSrcPerform(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcPerform(libxlDriverPrivate *driver,
+ virDomainObj *vm,
const char *dom_xml,
const char *dconnuri,
const char *uri_str,
virDomainPtr
libxlDomainMigrationDstFinish(virConnectPtr dconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
unsigned int flags,
int cancelled);
int
-libxlDomainMigrationSrcConfirm(libxlDriverPrivatePtr driver,
- virDomainObjPtr vm,
+libxlDomainMigrationSrcConfirm(libxlDriverPrivate *driver,
+ virDomainObj *vm,
unsigned int flags,
int cancelled);
* Convenience method to grab a long int from the config file object
*/
int
-xenConfigGetBool(virConfPtr conf,
+xenConfigGetBool(virConf *conf,
const char *name,
int *value,
int def)
{
- virConfValuePtr val;
+ virConfValue *val;
*value = 0;
if (!(val = virConfGetValue(conf, name))) {
* Convenience method to grab a int from the config file object
*/
int
-xenConfigGetULong(virConfPtr conf,
+xenConfigGetULong(virConf *conf,
const char *name,
unsigned long *value,
unsigned long def)
{
- virConfValuePtr val;
+ virConfValue *val;
*value = 0;
if (!(val = virConfGetValue(conf, name))) {
* Convenience method to grab a int from the config file object
*/
static int
-xenConfigGetULongLong(virConfPtr conf,
+xenConfigGetULongLong(virConf *conf,
const char *name,
unsigned long long *value,
unsigned long long def)
{
- virConfValuePtr val;
+ virConfValue *val;
*value = 0;
if (!(val = virConfGetValue(conf, name))) {
static int
-xenConfigCopyStringInternal(virConfPtr conf,
+xenConfigCopyStringInternal(virConf *conf,
const char *name,
char **value,
int allowMissing)
int
-xenConfigCopyString(virConfPtr conf, const char *name, char **value)
+xenConfigCopyString(virConf *conf, const char *name, char **value)
{
return xenConfigCopyStringInternal(conf, name, value, 0);
}
int
-xenConfigCopyStringOpt(virConfPtr conf, const char *name, char **value)
+xenConfigCopyStringOpt(virConf *conf, const char *name, char **value)
{
return xenConfigCopyStringInternal(conf, name, value, 1);
}
* Convenience method to grab a string UUID from the config file object
*/
static int
-xenConfigGetUUID(virConfPtr conf, const char *name, unsigned char *uuid)
+xenConfigGetUUID(virConf *conf, const char *name, unsigned char *uuid)
{
g_autofree char *string = NULL;
int rc;
* Convenience method to grab a string from the config file object
*/
int
-xenConfigGetString(virConfPtr conf,
+xenConfigGetString(virConf *conf,
const char *name,
char **value,
const char *def)
int
-xenConfigSetInt(virConfPtr conf, const char *setting, long long l)
+xenConfigSetInt(virConf *conf, const char *setting, long long l)
{
- virConfValuePtr value = NULL;
+ virConfValue *value = NULL;
if ((long)l != l) {
virReportError(VIR_ERR_OVERFLOW, _("failed to store %lld to %s"),
int
-xenConfigSetString(virConfPtr conf, const char *setting, const char *str)
+xenConfigSetString(virConf *conf, const char *setting, const char *str)
{
- virConfValuePtr value = NULL;
+ virConfValue *value = NULL;
value = g_new0(virConfValue, 1);
static int
-xenParseMem(virConfPtr conf, virDomainDefPtr def)
+xenParseMem(virConf *conf, virDomainDef *def)
{
unsigned long long memory;
static int
-xenParseTimeOffset(virConfPtr conf, virDomainDefPtr def)
+xenParseTimeOffset(virConf *conf, virDomainDef *def)
{
int vmlocaltime;
static int
-xenParseEventsActions(virConfPtr conf, virDomainDefPtr def)
+xenParseEventsActions(virConf *conf, virDomainDef *def)
{
g_autofree char *on_poweroff = NULL;
g_autofree char *on_reboot = NULL;
}
-static virDomainHostdevDefPtr
+static virDomainHostdevDef *
xenParsePCI(char *entry)
{
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainHostdevDef *hostdev = NULL;
g_auto(GStrv) tokens = NULL;
g_auto(GStrv) options = NULL;
size_t nexttoken = 0;
static int
-xenParsePCIList(virConfPtr conf, virDomainDefPtr def)
+xenParsePCIList(virConf *conf, virDomainDef *def)
{
g_auto(GStrv) pcis = NULL;
char **entries = NULL;
for (entries = pcis; *entries; entries++) {
char *entry = *entries;
- virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDef *hostdev;
if (!(hostdev = xenParsePCI(entry)))
return -1;
static int
-xenParseCPU(virConfPtr conf,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt)
+xenParseCPU(virConf *conf,
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt)
{
unsigned long count = 0;
g_autofree char *cpus = NULL;
static int
-xenParseHypervisorFeatures(virConfPtr conf, virDomainDefPtr def)
+xenParseHypervisorFeatures(virConf *conf, virDomainDef *def)
{
g_autofree char *strval = NULL;
- virDomainTimerDefPtr timer;
+ virDomainTimerDef *timer;
int val = 0;
if (xenConfigGetString(conf, "tsc_mode", &strval, NULL) < 0)
#define MAX_VFB 1024
static int
-xenParseVfb(virConfPtr conf, virDomainDefPtr def)
+xenParseVfb(virConf *conf, virDomainDef *def)
{
int val;
char *listenAddr = NULL;
int hvm = def->os.type == VIR_DOMAIN_OSTYPE_HVM;
- virDomainGraphicsDefPtr graphics = NULL;
+ virDomainGraphicsDef *graphics = NULL;
if (hvm) {
if (xenConfigGetBool(conf, "vnc", &val, 0) < 0)
goto cleanup;
if (xenConfigCopyStringOpt(conf, "keymap", &graphics->data.vnc.keymap) < 0)
goto cleanup;
- def->graphics = g_new0(virDomainGraphicsDefPtr, 1);
+ def->graphics = g_new0(virDomainGraphicsDef *, 1);
def->graphics[0] = graphics;
def->ngraphics = 1;
graphics = NULL;
goto cleanup;
if (xenConfigCopyStringOpt(conf, "xauthority", &graphics->data.sdl.xauth) < 0)
goto cleanup;
- def->graphics = g_new0(virDomainGraphicsDefPtr, 1);
+ def->graphics = g_new0(virDomainGraphicsDef *, 1);
def->graphics[0] = graphics;
def->ngraphics = 1;
graphics = NULL;
goto cleanup;
VIR_FREE(listenAddr);
}
- def->graphics = g_new0(virDomainGraphicsDefPtr, 1);
+ def->graphics = g_new0(virDomainGraphicsDef *, 1);
def->graphics[0] = graphics;
def->ngraphics = 1;
graphics = NULL;
*
* Returns a character device object or NULL in case of failure.
*/
-static virDomainChrDefPtr
+static virDomainChrDef *
xenParseSxprChar(const char *value,
const char *tty)
{
const char *prefix;
char *tmp;
- virDomainChrDefPtr def;
+ virDomainChrDef *def;
if (!(def = virDomainChrDefNew(NULL)))
return NULL;
static int
-xenParseCharDev(virConfPtr conf, virDomainDefPtr def, const char *nativeFormat)
+xenParseCharDev(virConf *conf, virDomainDef *def, const char *nativeFormat)
{
g_auto(GStrv) serials = NULL;
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM) {
g_autofree char *parallel = NULL;
!(chr = xenParseSxprChar(parallel, NULL)))
goto cleanup;
if (chr) {
- def->parallels = g_new0(virDomainChrDefPtr, 1);
+ def->parallels = g_new0(virDomainChrDef *, 1);
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
chr->target.port = 0;
!(chr = xenParseSxprChar(serial, NULL)))
goto cleanup;
if (chr) {
- def->serials = g_new0(virDomainChrDefPtr, 1);
+ def->serials = g_new0(virDomainChrDef *, 1);
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
chr->target.port = 0;
def->serials[0] = chr;
}
}
} else {
- def->consoles = g_new0(virDomainChrDefPtr, 1);
+ def->consoles = g_new0(virDomainChrDef *, 1);
def->nconsoles = 1;
if (!(def->consoles[0] = xenParseSxprChar("pty", NULL)))
goto cleanup;
static int
-xenParseVifBridge(virDomainNetDefPtr net, const char *bridge)
+xenParseVifBridge(virDomainNetDef *net, const char *bridge)
{
char *vlanstr;
unsigned int tag;
}
-static virDomainNetDefPtr
+static virDomainNetDef *
xenParseVif(char *entry, const char *vif_typename)
{
- virDomainNetDefPtr net = NULL;
- virDomainNetDefPtr ret = NULL;
+ virDomainNetDef *net = NULL;
+ virDomainNetDef *ret = NULL;
g_auto(GStrv) keyvals = NULL;
GStrv keyval;
const char *script = NULL;
net->ifname = g_strdup(vifname);
if (rate) {
- virNetDevBandwidthPtr bandwidth;
+ virNetDevBandwidth *bandwidth;
unsigned long long kbytes_per_sec;
if (xenParseSxprVifRate(rate, &kbytes_per_sec) < 0)
static int
-xenParseVifList(virConfPtr conf, virDomainDefPtr def, const char *vif_typename)
+xenParseVifList(virConf *conf, virDomainDef *def, const char *vif_typename)
{
- virConfValuePtr list = virConfGetValue(conf, "vif");
+ virConfValue *list = virConfGetValue(conf, "vif");
if (!list || list->type != VIR_CONF_LIST)
return 0;
for (list = list->list; list; list = list->next) {
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
int rc;
if ((list->type != VIR_CONF_STRING) || (list->str == NULL))
* Returns 0 if successful or -1 if failed.
*/
static int
-xenParseSxprSound(virDomainDefPtr def,
+xenParseSxprSound(virDomainDef *def,
const char *str)
{
if (STREQ(str, "all")) {
* Hence use of MODEL_ES1370 + 1, instead of MODEL_LAST
*/
- def->sounds = g_new0(virDomainSoundDefPtr,
+ def->sounds = g_new0(virDomainSoundDef *,
VIR_DOMAIN_SOUND_MODEL_ES1370 + 1);
for (i = 0; i < (VIR_DOMAIN_SOUND_MODEL_ES1370 + 1); i++) {
- virDomainSoundDefPtr sound = g_new0(virDomainSoundDef, 1);
+ virDomainSoundDef *sound = g_new0(virDomainSoundDef, 1);
sound->model = i;
def->sounds[def->nsounds++] = sound;
}
while (*sound != '\0') {
char *next = strchr(sound, ',');
- virDomainSoundDefPtr snddef;
+ virDomainSoundDef *snddef;
if (next)
*next = '\0';
static int
-xenParseEmulatedDevices(virConfPtr conf, virDomainDefPtr def)
+xenParseEmulatedDevices(virConf *conf, virDomainDef *def)
{
g_autofree char *str = NULL;
static int
-xenParseGeneralMeta(virConfPtr conf, virDomainDefPtr def, virCapsPtr caps)
+xenParseGeneralMeta(virConf *conf, virDomainDef *def, virCaps *caps)
{
- virCapsDomainDataPtr capsdata = NULL;
+ virCapsDomainData *capsdata = NULL;
g_autofree char *str = NULL;
int ret = -1;
* A convenience function for parsing all config common to both XM and XL
*/
int
-xenParseConfigCommon(virConfPtr conf,
- virDomainDefPtr def,
- virCapsPtr caps,
+xenParseConfigCommon(virConf *conf,
+ virDomainDef *def,
+ virCaps *caps,
const char *nativeFormat,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
if (xenParseGeneralMeta(conf, def, caps) < 0)
return -1;
* Returns 0 in case of success, -1 in case of error
*/
static int
-xenFormatSxprChr(virDomainChrDefPtr def,
- virBufferPtr buf)
+xenFormatSxprChr(virDomainChrDef *def,
+ virBuffer *buf)
{
const char *type = virDomainChrTypeToString(def->source->type);
static int
-xenFormatSerial(virConfValuePtr list, virDomainChrDefPtr serial)
+xenFormatSerial(virConfValue *list, virDomainChrDef *serial)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
int ret;
if (serial) {
}
char *
-xenMakeIPList(virNetDevIPInfoPtr guestIP)
+xenMakeIPList(virNetDevIPInfo *guestIP)
{
size_t i;
char **address_array;
static int
xenFormatNet(virConnectPtr conn,
- virConfValuePtr list,
- virDomainNetDefPtr net,
+ virConfValue *list,
+ virDomainNetDef *net,
int hvm,
const char *vif_typename)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
char macaddr[VIR_MAC_STRING_BUFLEN];
virBufferAsprintf(&buf, "mac=%s", virMacAddrFormat(&net->mac, macaddr));
static int
-xenFormatPCI(virConfPtr conf, virDomainDefPtr def)
+xenFormatPCI(virConf *conf, virDomainDef *def)
{
- virConfValuePtr pciVal = NULL;
+ virConfValue *pciVal = NULL;
int hasPCI = 0;
size_t i;
for (i = 0; i < def->nhostdevs; i++) {
if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
def->hostdevs[i]->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
char *buf;
const char *permissive_str = NULL;
static int
-xenFormatGeneralMeta(virConfPtr conf, virDomainDefPtr def)
+xenFormatGeneralMeta(virConf *conf, virDomainDef *def)
{
char uuid[VIR_UUID_STRING_BUFLEN];
static int
-xenFormatMem(virConfPtr conf, virDomainDefPtr def)
+xenFormatMem(virConf *conf, virDomainDef *def)
{
if (xenConfigSetInt(conf, "maxmem",
VIR_DIV_UP(virDomainDefGetMemoryTotal(def), 1024)) < 0)
static int
-xenFormatTimeOffset(virConfPtr conf, virDomainDefPtr def)
+xenFormatTimeOffset(virConf *conf, virDomainDef *def)
{
int vmlocaltime;
static int
-xenFormatEventActions(virConfPtr conf, virDomainDefPtr def)
+xenFormatEventActions(virConf *conf, virDomainDef *def)
{
const char *lifecycle = NULL;
static int
-xenFormatCharDev(virConfPtr conf, virDomainDefPtr def,
+xenFormatCharDev(virConf *conf, virDomainDef *def,
const char *nativeFormat)
{
size_t i;
} else {
size_t j = 0;
int maxport = -1, port;
- virConfValuePtr serialVal = NULL;
+ virConfValue *serialVal = NULL;
if (STREQ(nativeFormat, XEN_CONFIG_FORMAT_XM)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
maxport = def->serials[i]->target.port;
for (port = 0; port <= maxport; port++) {
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
for (j = 0; j < def->nserials; j++) {
if (def->serials[j]->target.port == port) {
static int
-xenFormatCPUAllocation(virConfPtr conf, virDomainDefPtr def)
+xenFormatCPUAllocation(virConf *conf, virDomainDef *def)
{
g_autofree char *cpus = NULL;
static int
-xenFormatHypervisorFeatures(virConfPtr conf, virDomainDefPtr def)
+xenFormatHypervisorFeatures(virConf *conf, virDomainDef *def)
{
size_t i;
bool hvm = !!(def->os.type == VIR_DOMAIN_OSTYPE_HVM);
static int
-xenFormatEmulator(virConfPtr conf, virDomainDefPtr def)
+xenFormatEmulator(virConf *conf, virDomainDef *def)
{
if (def->emulator &&
xenConfigSetString(conf, "device_model_override", def->emulator) < 0)
static int
-xenFormatVfb(virConfPtr conf, virDomainDefPtr def)
+xenFormatVfb(virConf *conf, virDomainDef *def)
{
int hvm = def->os.type == VIR_DOMAIN_OSTYPE_HVM ? 1 : 0;
def->graphics[0]->data.sdl.xauth) < 0)
return -1;
} else {
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
if (xenConfigSetInt(conf, "sdl", 0) < 0)
return -1;
return -1;
}
} else {
- virConfValuePtr vfb;
- virConfValuePtr disp;
+ virConfValue *vfb;
+ virConfValue *disp;
char *vfbstr = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, ",xauthority=%s",
def->graphics[0]->data.sdl.xauth);
} else {
- virDomainGraphicsListenDefPtr glisten
+ virDomainGraphicsListenDef *glisten
= virDomainGraphicsGetListen(def->graphics[0], 0);
virBufferAddLit(&buf, "type=vnc");
static int
-xenFormatSound(virConfPtr conf, virDomainDefPtr def)
+xenFormatSound(virConf *conf, virDomainDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char * model;
static int
-xenFormatVif(virConfPtr conf,
+xenFormatVif(virConf *conf,
virConnectPtr conn,
- virDomainDefPtr def,
+ virDomainDef *def,
const char *vif_typename)
{
- virConfValuePtr netVal = NULL;
+ virConfValue *netVal = NULL;
size_t i;
int hvm = def->os.type == VIR_DOMAIN_OSTYPE_HVM;
* A convenience function for formatting all config common to both XM and XL
*/
int
-xenFormatConfigCommon(virConfPtr conf,
- virDomainDefPtr def,
+xenFormatConfigCommon(virConf *conf,
+ virDomainDef *def,
virConnectPtr conn,
const char *nativeFormat)
{
int
-xenDomainDefAddImplicitInputDevice(virDomainDefPtr def)
+xenDomainDefAddImplicitInputDevice(virDomainDef *def)
{
virDomainInputBus implicitInputBus = VIR_DOMAIN_INPUT_BUS_XEN;
#define XEN_CONFIG_FORMAT_XM "xen-xm"
#define XEN_CONFIG_FORMAT_SEXPR "xen-sxpr"
-int xenConfigGetString(virConfPtr conf,
+int xenConfigGetString(virConf *conf,
const char *name,
char **value,
const char *def);
-int xenConfigGetBool(virConfPtr conf, const char *name, int *value, int def);
+int xenConfigGetBool(virConf *conf, const char *name, int *value, int def);
-int xenConfigSetInt(virConfPtr conf, const char *name, long long value);
+int xenConfigSetInt(virConf *conf, const char *name, long long value);
-int xenConfigSetString(virConfPtr conf, const char *setting, const char *value);
+int xenConfigSetString(virConf *conf, const char *setting, const char *value);
-int xenConfigGetULong(virConfPtr conf,
+int xenConfigGetULong(virConf *conf,
const char *name,
unsigned long *value,
unsigned long def);
int
-xenConfigCopyString(virConfPtr conf,
+xenConfigCopyString(virConf *conf,
const char *name,
char **value);
-int xenConfigCopyStringOpt(virConfPtr conf,
+int xenConfigCopyStringOpt(virConf *conf,
const char *name,
char **value);
-int xenParseConfigCommon(virConfPtr conf,
- virDomainDefPtr def,
- virCapsPtr caps,
+int xenParseConfigCommon(virConf *conf,
+ virDomainDef *def,
+ virCaps *caps,
const char *nativeFormat,
- virDomainXMLOptionPtr xmlopt);
+ virDomainXMLOption *xmlopt);
-int xenFormatConfigCommon(virConfPtr conf,
- virDomainDefPtr def,
+int xenFormatConfigCommon(virConf *conf,
+ virDomainDef *def,
virConnectPtr conn,
const char *nativeFormat);
-char *xenMakeIPList(virNetDevIPInfoPtr guestIP);
+char *xenMakeIPList(virNetDevIPInfo *guestIP);
-int xenDomainDefAddImplicitInputDevice(virDomainDefPtr def);
+int xenDomainDefAddImplicitInputDevice(virDomainDef *def);
libxl_device_disk *disk);
#endif
-static int xenParseCmdline(virConfPtr conf, char **r_cmdline)
+static int xenParseCmdline(virConf *conf, char **r_cmdline)
{
char *cmdline = NULL;
g_autofree char *root = NULL;
}
static int
-xenParseXLOS(virConfPtr conf, virDomainDefPtr def, virCapsPtr caps)
+xenParseXLOS(virConf *conf, virDomainDef *def, virCaps *caps)
{
size_t i;
}
if (!def->cpu) {
- virCPUDefPtr cpu = virCPUDefNew();
+ virCPUDef *cpu = virCPUDefNew();
cpu->mode = VIR_CPU_MODE_HOST_PASSTHROUGH;
cpu->type = VIR_CPU_TYPE_GUEST;
cpu->nfeatures = 0;
}
static int
-xenParseXLCPUID(virConfPtr conf, virDomainDefPtr def)
+xenParseXLCPUID(virConf *conf, virDomainDef *def)
{
g_autofree char *cpuid_str = NULL;
char **cpuid_pairs = NULL;
static int
-xenParseXLSpice(virConfPtr conf, virDomainDefPtr def)
+xenParseXLSpice(virConf *conf, virDomainDef *def)
{
- virDomainGraphicsDefPtr graphics = NULL;
+ virDomainGraphicsDef *graphics = NULL;
unsigned long port;
char *listenAddr = NULL;
int val;
else
graphics->data.spice.copypaste = VIR_TRISTATE_BOOL_NO;
- def->graphics = g_new0(virDomainGraphicsDefPtr, 1);
+ def->graphics = g_new0(virDomainGraphicsDef *, 1);
def->graphics[0] = graphics;
def->ngraphics = 1;
}
#ifdef LIBXL_HAVE_VNUMA
static int
-xenParseXLVnuma(virConfPtr conf,
- virDomainDefPtr def)
+xenParseXLVnuma(virConf *conf,
+ virDomainDef *def)
{
int ret = -1;
char *tmp = NULL;
size_t vcpus = 0;
size_t nr_nodes = 0;
size_t vnodeCnt = 0;
- virCPUDefPtr cpu = NULL;
- virConfValuePtr list;
- virConfValuePtr vnode;
- virDomainNumaPtr numa;
+ virCPUDef *cpu = NULL;
+ virConfValue *list;
+ virConfValue *vnode;
+ virDomainNuma *numa;
numa = def->numa;
if (numa == NULL)
list = list->list;
while (list) {
int pnode = -1;
- virBitmapPtr cpumask = NULL;
+ virBitmap *cpumask = NULL;
unsigned long long kbsize = 0;
/* Is there a sublist (vnode)? */
#endif
static int
-xenParseXLXenbusLimits(virConfPtr conf, virDomainDefPtr def)
+xenParseXLXenbusLimits(virConf *conf, virDomainDef *def)
{
int ctlr_idx;
- virDomainControllerDefPtr xenbus_ctlr;
+ virDomainControllerDef *xenbus_ctlr;
unsigned long limit;
ctlr_idx = virDomainControllerFindByType(def, VIR_DOMAIN_CONTROLLER_TYPE_XENBUS);
}
static int
-xenParseXLDiskSrc(virDomainDiskDefPtr disk, char *srcstr)
+xenParseXLDiskSrc(virDomainDiskDef *disk, char *srcstr)
{
char *tmpstr = NULL;
int ret = -1;
*
*/
static int
-xenParseXLDisk(virConfPtr conf, virDomainDefPtr def)
+xenParseXLDisk(virConf *conf, virDomainDef *def)
{
int ret = -1;
- virConfValuePtr list = virConfGetValue(conf, "disk");
+ virConfValue *list = virConfGetValue(conf, "disk");
XLU_Config *xluconf;
libxl_device_disk *libxldisk;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
libxldisk = g_new0(libxl_device_disk, 1);
}
static int
-xenParseXLInputDevs(virConfPtr conf, virDomainDefPtr def)
+xenParseXLInputDevs(virConf *conf, virDomainDef *def)
{
const char *str;
- virConfValuePtr val;
+ virConfValue *val;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM) {
val = virConfGetValue(conf, "usbdevice");
(STREQ(str, "tablet") ||
STREQ(str, "mouse") ||
STREQ(str, "keyboard"))) {
- virDomainInputDefPtr input;
+ virDomainInputDef *input;
input = g_new0(virDomainInputDef,
1);
}
static int
-xenParseXLUSBController(virConfPtr conf, virDomainDefPtr def)
+xenParseXLUSBController(virConf *conf, virDomainDef *def)
{
- virConfValuePtr list = virConfGetValue(conf, "usbctrl");
- virDomainControllerDefPtr controller = NULL;
+ virConfValue *list = virConfGetValue(conf, "usbctrl");
+ virDomainControllerDef *controller = NULL;
if (list && list->type == VIR_CONF_LIST) {
list = list->list;
}
static int
-xenParseXLUSB(virConfPtr conf, virDomainDefPtr def)
+xenParseXLUSB(virConf *conf, virDomainDef *def)
{
- virConfValuePtr list = virConfGetValue(conf, "usbdev");
- virDomainHostdevDefPtr hostdev = NULL;
+ virConfValue *list = virConfGetValue(conf, "usbdev");
+ virDomainHostdevDef *hostdev = NULL;
if (list && list->type == VIR_CONF_LIST) {
list = list->list;
}
static int
-xenParseXLChannel(virConfPtr conf, virDomainDefPtr def)
+xenParseXLChannel(virConf *conf, virDomainDef *def)
{
- virConfValuePtr list = virConfGetValue(conf, "channel");
- virDomainChrDefPtr channel = NULL;
+ virConfValue *list = virConfGetValue(conf, "channel");
+ virDomainChrDef *channel = NULL;
char *name = NULL;
char *path = NULL;
}
static int
-xenParseXLNamespaceData(virConfPtr conf, virDomainDefPtr def)
+xenParseXLNamespaceData(virConf *conf, virDomainDef *def)
{
- virConfValuePtr list = virConfGetValue(conf, "device_model_args");
- virConfValuePtr next;
+ virConfValue *list = virConfGetValue(conf, "device_model_args");
+ virConfValue *next;
size_t nargs = 0;
- libxlDomainXmlNsDefPtr nsdata = NULL;
+ libxlDomainXmlNsDef *nsdata = NULL;
size_t n = 0;
if (!list || list->type != VIR_CONF_LIST)
return 0;
}
-virDomainDefPtr
-xenParseXL(virConfPtr conf,
- virCapsPtr caps,
- virDomainXMLOptionPtr xmlopt)
+virDomainDef *
+xenParseXL(virConf *conf,
+ virCaps *caps,
+ virDomainXMLOption *xmlopt)
{
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
if (!(def = virDomainDefNew()))
return NULL;
static int
-xenFormatXLOS(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLOS(virConf *conf, virDomainDef *def)
{
size_t i;
}
static int
-xenFormatXLCPUID(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLCPUID(virConf *conf, virDomainDef *def)
{
char **cpuid_pairs = NULL;
g_autofree char *cpuid_string = NULL;
#ifdef LIBXL_HAVE_VNUMA
static int
-xenFormatXLVnode(virConfValuePtr list,
- virBufferPtr buf)
+xenFormatXLVnode(virConfValue *list,
+ virBuffer *buf)
{
- virConfValuePtr numaPnode;
- virConfValuePtr tmp;
+ virConfValue *numaPnode;
+ virConfValue *tmp;
numaPnode = g_new0(virConfValue, 1);
}
static int
-xenFormatXLVnuma(virConfValuePtr list,
- virDomainNumaPtr numa,
+xenFormatXLVnuma(virConfValue *list,
+ virDomainNuma *numa,
size_t node,
size_t nr_nodes)
{
int ret = -1;
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr numaVnode;
- virConfValuePtr tmp;
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(numa, node);
+ virConfValue *numaVnode;
+ virConfValue *tmp;
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(numa, node);
size_t nodeSize = virDomainNumaGetNodeMemorySize(numa, node) / 1024;
g_autofree char *nodeVcpus = NULL;
}
static int
-xenFormatXLDomainVnuma(virConfPtr conf,
- virDomainDefPtr def)
+xenFormatXLDomainVnuma(virConf *conf,
+ virDomainDef *def)
{
- virDomainNumaPtr numa = def->numa;
- virConfValuePtr vnumaVal;
+ virDomainNuma *numa = def->numa;
+ virConfValue *vnumaVal;
size_t i;
size_t nr_nodes;
#endif
static int
-xenFormatXLXenbusLimits(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLXenbusLimits(virConf *conf, virDomainDef *def)
{
size_t i;
}
static char *
-xenFormatXLDiskSrcNet(virStorageSourcePtr src)
+xenFormatXLDiskSrcNet(virStorageSource *src)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
static int
-xenFormatXLDiskSrc(virStorageSourcePtr src, char **srcstr)
+xenFormatXLDiskSrc(virStorageSource *src, char **srcstr)
{
int actualType = virStorageSourceGetActualType(src);
static int
-xenFormatXLDisk(virConfValuePtr list, virDomainDiskDefPtr disk)
+xenFormatXLDisk(virConfValue *list, virDomainDiskDef *disk)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
int format = virDomainDiskGetFormat(disk);
const char *driver = virDomainDiskGetDriver(disk);
g_autofree char *target = NULL;
static int
-xenFormatXLDomainDisks(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLDomainDisks(virConf *conf, virDomainDef *def)
{
- virConfValuePtr diskVal;
+ virConfValue *diskVal;
size_t i;
diskVal = g_new0(virConfValue, 1);
static int
-xenFormatXLSpice(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLSpice(virConf *conf, virDomainDef *def)
{
- virDomainGraphicsListenDefPtr glisten;
- virDomainGraphicsDefPtr graphics;
+ virDomainGraphicsListenDef *glisten;
+ virDomainGraphicsDef *graphics;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM && def->graphics) {
graphics = def->graphics[0];
}
static int
-xenFormatXLInputDevs(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLInputDevs(virConf *conf, virDomainDef *def)
{
size_t i;
const char *devtype;
- virConfValuePtr usbdevices = NULL;
- virConfValuePtr lastdev;
+ virConfValue *usbdevices = NULL;
+ virConfValue *lastdev;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM) {
usbdevices = g_new0(virConfValue, 1);
}
static int
-xenFormatXLUSBController(virConfPtr conf,
- virDomainDefPtr def)
+xenFormatXLUSBController(virConf *conf,
+ virDomainDef *def)
{
- virConfValuePtr usbctrlVal = NULL;
+ virConfValue *usbctrlVal = NULL;
int hasUSBCtrl = 0;
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (def->controllers[i]->model != -1) {
static int
-xenFormatXLUSB(virConfPtr conf,
- virDomainDefPtr def)
+xenFormatXLUSB(virConf *conf,
+ virDomainDef *def)
{
- virConfValuePtr usbVal = NULL;
+ virConfValue *usbVal = NULL;
int hasUSB = 0;
size_t i;
for (i = 0; i < def->nhostdevs; i++) {
if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
def->hostdevs[i]->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
char *buf;
buf = g_strdup_printf("hostbus=%x,hostaddr=%x",
}
static int
-xenFormatXLChannel(virConfValuePtr list, virDomainChrDefPtr channel)
+xenFormatXLChannel(virConfValue *list, virDomainChrDef *channel)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int sourceType = channel->source->type;
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
/* connection */
virBufferAddLit(&buf, "connection=");
}
static int
-xenFormatXLDomainChannels(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLDomainChannels(virConf *conf, virDomainDef *def)
{
- virConfValuePtr channelVal = NULL;
+ virConfValue *channelVal = NULL;
size_t i;
channelVal = g_new0(virConfValue, 1);
channelVal->list = NULL;
for (i = 0; i < def->nchannels; i++) {
- virDomainChrDefPtr chr = def->channels[i];
+ virDomainChrDef *chr = def->channels[i];
if (chr->targetType != VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_XEN)
continue;
}
static int
-xenFormatXLDomainNamespaceData(virConfPtr conf, virDomainDefPtr def)
+xenFormatXLDomainNamespaceData(virConf *conf, virDomainDef *def)
{
- libxlDomainXmlNsDefPtr nsdata = def->namespaceData;
- virConfValuePtr args = NULL;
+ libxlDomainXmlNsDef *nsdata = def->namespaceData;
+ virConfValue *args = NULL;
size_t i;
if (!nsdata)
args->list = NULL;
for (i = 0; i < nsdata->num_args; i++) {
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
val = g_new0(virConfValue, 1);
return -1;
}
-virConfPtr
-xenFormatXL(virDomainDefPtr def, virConnectPtr conn)
+virConf *
+xenFormatXL(virDomainDef *def, virConnectPtr conn)
{
g_autoptr(virConf) conf = NULL;
#include "domain_conf.h"
#include "xen_common.h"
-virDomainDefPtr xenParseXL(virConfPtr conn,
- virCapsPtr caps,
- virDomainXMLOptionPtr xmlopt);
+virDomainDef *xenParseXL(virConf *conn,
+ virCaps *caps,
+ virDomainXMLOption *xmlopt);
-virConfPtr xenFormatXL(virDomainDefPtr def, virConnectPtr);
+virConf *xenFormatXL(virDomainDef *def, virConnectPtr);
const char *xenTranslateCPUFeature(const char *feature_name, bool from_libxl);
#define VIR_FROM_THIS VIR_FROM_XENXM
static int
-xenParseXMOS(virConfPtr conf, virDomainDefPtr def)
+xenParseXMOS(virConf *conf, virDomainDef *def)
{
size_t i;
}
-static virDomainDiskDefPtr
+static virDomainDiskDef *
xenParseXMDisk(char *entry, int hvm)
{
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
char *head;
char *offset;
char *tmp;
static int
-xenParseXMDiskList(virConfPtr conf, virDomainDefPtr def)
+xenParseXMDiskList(virConf *conf, virDomainDef *def)
{
char **disks = NULL, **entries;
int hvm = def->os.type == VIR_DOMAIN_OSTYPE_HVM;
return rc;
for (entries = disks; *entries; entries++) {
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
char *entry = *entries;
if (!(disk = xenParseXMDisk(entry, hvm)))
static int
-xenFormatXMDisk(virConfValuePtr list,
- virDomainDiskDefPtr disk)
+xenFormatXMDisk(virConfValue *list,
+ virDomainDiskDef *disk)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val;
- virConfValuePtr tmp;
+ virConfValue *val;
+ virConfValue *tmp;
const char *src = virDomainDiskGetSource(disk);
int format = virDomainDiskGetFormat(disk);
const char *driver = virDomainDiskGetDriver(disk);
static int
-xenFormatXMDisks(virConfPtr conf, virDomainDefPtr def)
+xenFormatXMDisks(virConf *conf, virDomainDef *def)
{
- virConfValuePtr diskVal = NULL;
+ virConfValue *diskVal = NULL;
size_t i = 0;
diskVal = g_new0(virConfValue, 1);
static int
-xenParseXMInputDevs(virConfPtr conf, virDomainDefPtr def)
+xenParseXMInputDevs(virConf *conf, virDomainDef *def)
{
g_autofree char *str = NULL;
(STREQ(str, "tablet") ||
STREQ(str, "mouse") ||
STREQ(str, "keyboard"))) {
- virDomainInputDefPtr input;
+ virDomainInputDef *input;
input = g_new0(virDomainInputDef, 1);
input->bus = VIR_DOMAIN_INPUT_BUS_USB;
/*
* Convert an XM config record into a virDomainDef object.
*/
-virDomainDefPtr
-xenParseXM(virConfPtr conf,
- virCapsPtr caps,
- virDomainXMLOptionPtr xmlopt)
+virDomainDef *
+xenParseXM(virConf *conf,
+ virCaps *caps,
+ virDomainXMLOption *xmlopt)
{
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
if (!(def = virDomainDefNew()))
return NULL;
}
static int
-xenFormatXMOS(virConfPtr conf, virDomainDefPtr def)
+xenFormatXMOS(virConf *conf, virDomainDef *def)
{
size_t i;
static int
-xenFormatXMInputDevs(virConfPtr conf, virDomainDefPtr def)
+xenFormatXMInputDevs(virConf *conf, virDomainDef *def)
{
size_t i;
const char *devtype;
/*
* Convert a virDomainDef object into an XM config record.
*/
-virConfPtr
+virConf *
xenFormatXM(virConnectPtr conn,
- virDomainDefPtr def)
+ virDomainDef *def)
{
g_autoptr(virConf) conf = NULL;
#include "virconf.h"
#include "domain_conf.h"
-virConfPtr xenFormatXM(virConnectPtr conn, virDomainDefPtr def);
+virConf *xenFormatXM(virConnectPtr conn, virDomainDef *def);
-virDomainDefPtr xenParseXM(virConfPtr conf,
- virCapsPtr caps, virDomainXMLOptionPtr xmlopt);
+virDomainDef *xenParseXM(virConf *conf,
+ virCaps *caps, virDomainXMLOption *xmlopt);
VIR_LOG_INIT("locking.domain_lock");
-static int virDomainLockManagerAddLease(virLockManagerPtr lock,
- virDomainLeaseDefPtr lease)
+static int virDomainLockManagerAddLease(virLockManager *lock,
+ virDomainLeaseDef *lease)
{
unsigned int leaseFlags = 0;
virLockManagerParam lparams[] = {
}
-static int virDomainLockManagerAddImage(virLockManagerPtr lock,
- virStorageSourcePtr src)
+static int virDomainLockManagerAddImage(virLockManager *lock,
+ virStorageSource *src)
{
unsigned int diskFlags = 0;
int type = virStorageSourceGetActualType(src);
}
-static virLockManagerPtr virDomainLockManagerNew(virLockManagerPluginPtr plugin,
+static virLockManager *virDomainLockManagerNew(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
+ virDomainObj *dom,
bool withResources,
unsigned int flags)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
size_t i;
virLockManagerParam params[] = {
{ .type = VIR_LOCK_MANAGER_PARAM_TYPE_UUID,
VIR_DEBUG("Adding disks");
for (i = 0; i < dom->def->ndisks; i++) {
- virDomainDiskDefPtr disk = dom->def->disks[i];
+ virDomainDiskDef *disk = dom->def->disks[i];
if (virDomainLockManagerAddImage(lock, disk->src) < 0)
goto error;
}
-int virDomainLockProcessStart(virLockManagerPluginPtr plugin,
+int virDomainLockProcessStart(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
+ virDomainObj *dom,
bool paused,
int *fd)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret;
int flags = VIR_LOCK_MANAGER_ACQUIRE_RESTRICT;
return ret;
}
-int virDomainLockProcessPause(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
+int virDomainLockProcessPause(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
char **state)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret;
VIR_DEBUG("plugin=%p dom=%p state=%p",
return ret;
}
-int virDomainLockProcessResume(virLockManagerPluginPtr plugin,
+int virDomainLockProcessResume(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
+ virDomainObj *dom,
const char *state)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret;
VIR_DEBUG("plugin=%p dom=%p state=%s",
return ret;
}
-int virDomainLockProcessInquire(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
+int virDomainLockProcessInquire(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
char **state)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret;
VIR_DEBUG("plugin=%p dom=%p state=%p",
}
-int virDomainLockImageAttach(virLockManagerPluginPtr plugin,
+int virDomainLockImageAttach(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
- virStorageSourcePtr src)
+ virDomainObj *dom,
+ virStorageSource *src)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret = -1;
VIR_DEBUG("plugin=%p dom=%p src=%p", plugin, dom, src);
}
-int virDomainLockImageDetach(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
- virStorageSourcePtr src)
+int virDomainLockImageDetach(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
+ virStorageSource *src)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret = -1;
VIR_DEBUG("plugin=%p dom=%p src=%p", plugin, dom, src);
}
-int virDomainLockLeaseAttach(virLockManagerPluginPtr plugin,
+int virDomainLockLeaseAttach(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
- virDomainLeaseDefPtr lease)
+ virDomainObj *dom,
+ virDomainLeaseDef *lease)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret = -1;
VIR_DEBUG("plugin=%p dom=%p lease=%p",
return ret;
}
-int virDomainLockLeaseDetach(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
- virDomainLeaseDefPtr lease)
+int virDomainLockLeaseDetach(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
+ virDomainLeaseDef *lease)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
int ret = -1;
VIR_DEBUG("plugin=%p dom=%p lease=%p",
#include "domain_conf.h"
#include "lock_manager.h"
-int virDomainLockProcessStart(virLockManagerPluginPtr plugin,
+int virDomainLockProcessStart(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
+ virDomainObj *dom,
bool paused,
int *fd);
-int virDomainLockProcessPause(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
+int virDomainLockProcessPause(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
char **state);
-int virDomainLockProcessResume(virLockManagerPluginPtr plugin,
+int virDomainLockProcessResume(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
+ virDomainObj *dom,
const char *state);
-int virDomainLockProcessInquire(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
+int virDomainLockProcessInquire(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
char **state);
-int virDomainLockImageAttach(virLockManagerPluginPtr plugin,
+int virDomainLockImageAttach(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
- virStorageSourcePtr src);
-int virDomainLockImageDetach(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
- virStorageSourcePtr src);
+ virDomainObj *dom,
+ virStorageSource *src);
+int virDomainLockImageDetach(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
+ virStorageSource *src);
-int virDomainLockLeaseAttach(virLockManagerPluginPtr plugin,
+int virDomainLockLeaseAttach(virLockManagerPlugin *plugin,
const char *uri,
- virDomainObjPtr dom,
- virDomainLeaseDefPtr lease);
-int virDomainLockLeaseDetach(virLockManagerPluginPtr plugin,
- virDomainObjPtr dom,
- virDomainLeaseDefPtr lease);
+ virDomainObj *dom,
+ virDomainLeaseDef *lease);
+int virDomainLockLeaseDetach(virLockManagerPlugin *plugin,
+ virDomainObj *dom,
+ virDomainLeaseDef *lease);
struct _virLockDaemon {
GMutex lock;
- virNetDaemonPtr dmn;
+ virNetDaemon *dmn;
GHashTable *lockspaces;
- virLockSpacePtr defaultLockspace;
+ virLockSpace *defaultLockspace;
};
-virLockDaemonPtr lockDaemon = NULL;
+virLockDaemon *lockDaemon = NULL;
static bool execRestart;
static void *
-virLockDaemonClientNew(virNetServerClientPtr client,
+virLockDaemonClientNew(virNetServerClient *client,
void *opaque);
static void
virLockDaemonClientFree(void *opaque);
static void *
-virLockDaemonClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object,
+virLockDaemonClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object,
void *opaque);
-static virJSONValuePtr
-virLockDaemonClientPreExecRestart(virNetServerClientPtr client,
+static virJSONValue *
+virLockDaemonClientPreExecRestart(virNetServerClient *client,
void *opaque);
static void
-virLockDaemonFree(virLockDaemonPtr lockd)
+virLockDaemonFree(virLockDaemon *lockd)
{
if (!lockd)
return;
}
static inline void
-virLockDaemonLock(virLockDaemonPtr lockd)
+virLockDaemonLock(virLockDaemon *lockd)
{
g_mutex_lock(&lockd->lock);
}
static inline void
-virLockDaemonUnlock(virLockDaemonPtr lockd)
+virLockDaemonUnlock(virLockDaemon *lockd)
{
g_mutex_unlock(&lockd->lock);
}
virLockSpaceFree(data);
}
-static virLockDaemonPtr
-virLockDaemonNew(virLockDaemonConfigPtr config, bool privileged)
+static virLockDaemon *
+virLockDaemonNew(virLockDaemonConfig *config, bool privileged)
{
- virLockDaemonPtr lockd;
- virNetServerPtr srv = NULL;
+ virLockDaemon *lockd;
+ virNetServer *srv = NULL;
lockd = g_new0(virLockDaemon, 1);
}
-static virNetServerPtr
-virLockDaemonNewServerPostExecRestart(virNetDaemonPtr dmn G_GNUC_UNUSED,
+static virNetServer *
+virLockDaemonNewServerPostExecRestart(virNetDaemon *dmn G_GNUC_UNUSED,
const char *name,
- virJSONValuePtr object,
+ virJSONValue *object,
void *opaque)
{
if (STREQ(name, "virtlockd")) {
}
-static virLockDaemonPtr
-virLockDaemonNewPostExecRestart(virJSONValuePtr object, bool privileged)
+static virLockDaemon *
+virLockDaemonNewPostExecRestart(virJSONValue *object, bool privileged)
{
- virLockDaemonPtr lockd;
- virJSONValuePtr child;
- virJSONValuePtr lockspaces;
+ virLockDaemon *lockd;
+ virJSONValue *child;
+ virJSONValue *lockspaces;
size_t i;
const char *serverNames[] = { "virtlockd" };
}
for (i = 0; i < virJSONValueArraySize(lockspaces); i++) {
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
child = virJSONValueArrayGet(lockspaces, i);
}
-int virLockDaemonAddLockSpace(virLockDaemonPtr lockd,
+int virLockDaemonAddLockSpace(virLockDaemon *lockd,
const char *path,
- virLockSpacePtr lockspace)
+ virLockSpace *lockspace)
{
int ret;
virLockDaemonLock(lockd);
return ret;
}
-virLockSpacePtr virLockDaemonFindLockSpace(virLockDaemonPtr lockd,
+virLockSpace *virLockDaemonFindLockSpace(virLockDaemon *lockd,
const char *path)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
virLockDaemonLock(lockd);
if (path && STRNEQ(path, ""))
lockspace = virHashLookup(lockd->lockspaces, path);
}
static void
-virLockDaemonShutdownHandler(virNetDaemonPtr dmn,
+virLockDaemonShutdownHandler(virNetDaemon *dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static void
-virLockDaemonExecRestartHandler(virNetDaemonPtr dmn,
+virLockDaemonExecRestartHandler(virNetDaemon *dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static int
-virLockDaemonSetupSignals(virNetDaemonPtr dmn)
+virLockDaemonSetupSignals(virNetDaemon *dmn)
{
if (virNetDaemonAddSignalHandler(dmn, SIGINT, virLockDaemonShutdownHandler, NULL) < 0)
return -1;
struct virLockDaemonClientReleaseData {
- virLockDaemonClientPtr client;
+ virLockDaemonClient *client;
bool hadSomeLeases;
bool gotError;
};
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virLockSpacePtr lockspace = payload;
+ virLockSpace *lockspace = payload;
struct virLockDaemonClientReleaseData *data = opaque;
int rc;
static void
virLockDaemonClientFree(void *opaque)
{
- virLockDaemonClientPtr priv = opaque;
+ virLockDaemonClient *priv = opaque;
if (!priv)
return;
static void *
-virLockDaemonClientNew(virNetServerClientPtr client,
+virLockDaemonClientNew(virNetServerClient *client,
void *opaque)
{
- virLockDaemonClientPtr priv;
+ virLockDaemonClient *priv;
uid_t clientuid;
gid_t clientgid;
unsigned long long timestamp;
static void *
-virLockDaemonClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object,
+virLockDaemonClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object,
void *opaque)
{
- virLockDaemonClientPtr priv = virLockDaemonClientNew(client, opaque);
+ virLockDaemonClient *priv = virLockDaemonClientNew(client, opaque);
unsigned int ownerPid;
const char *ownerUUID;
const char *ownerName;
}
-static virJSONValuePtr
-virLockDaemonClientPreExecRestart(virNetServerClientPtr client G_GNUC_UNUSED,
+static virJSONValue *
+virLockDaemonClientPreExecRestart(virNetServerClient *client G_GNUC_UNUSED,
void *opaque)
{
- virLockDaemonClientPtr priv = opaque;
- virJSONValuePtr object = virJSONValueNewObject();
+ virLockDaemonClient *priv = opaque;
+ virJSONValue *object = virJSONValueNewObject();
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (virJSONValueObjectAppendBoolean(object, "restricted", priv->restricted) < 0) {
char *wantmagic = NULL;
int ret = -1;
char *state = NULL;
- virJSONValuePtr object = NULL;
+ virJSONValue *object = NULL;
VIR_DEBUG("Running post-restart exec");
static int
virLockDaemonPreExecRestart(const char *state_file,
- virNetDaemonPtr dmn,
+ virNetDaemon *dmn,
char **argv)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) daemon = NULL;
g_autofree char *state = NULL;
g_autofree char *magic = NULL;
- g_autofree virHashKeyValuePairPtr pairs = NULL;
- virHashKeyValuePairPtr tmp;
+ g_autofree virHashKeyValuePair *pairs = NULL;
+ virHashKeyValuePair *tmp;
VIR_DEBUG("Running pre-restart exec");
tmp = pairs = virHashGetItems(lockDaemon->lockspaces, NULL, false);
while (tmp && tmp->key) {
- virLockSpacePtr lockspace = (virLockSpacePtr)tmp->value;
+ virLockSpace *lockspace = (virLockSpace *)tmp->value;
g_autoptr(virJSONValue) child = NULL;
if (!(child = virLockSpacePreExecRestart(lockspace)))
}
int main(int argc, char **argv) {
- virNetServerPtr lockSrv = NULL;
- virNetServerPtr adminSrv = NULL;
- virNetServerProgramPtr lockProgram = NULL;
- virNetServerProgramPtr adminProgram = NULL;
+ virNetServer *lockSrv = NULL;
+ virNetServer *adminSrv = NULL;
+ virNetServerProgram *lockProgram = NULL;
+ virNetServerProgram *adminProgram = NULL;
char *remote_config_file = NULL;
int statuswrite = -1;
int ret = 1;
bool implicit_conf = false;
mode_t old_umask;
bool privileged = false;
- virLockDaemonConfigPtr config = NULL;
+ virLockDaemonConfig *config = NULL;
int rv;
struct option opts[] = {
#include "virlockspace.h"
typedef struct _virLockDaemon virLockDaemon;
-typedef virLockDaemon *virLockDaemonPtr;
typedef struct _virLockDaemonClient virLockDaemonClient;
-typedef virLockDaemonClient *virLockDaemonClientPtr;
struct _virLockDaemonClient {
GMutex lock;
pid_t clientPid;
};
-extern virLockDaemonPtr lockDaemon;
+extern virLockDaemon *lockDaemon;
-int virLockDaemonAddLockSpace(virLockDaemonPtr lockd,
+int virLockDaemonAddLockSpace(virLockDaemon *lockd,
const char *path,
- virLockSpacePtr lockspace);
+ virLockSpace *lockspace);
-virLockSpacePtr virLockDaemonFindLockSpace(virLockDaemonPtr lockd,
+virLockSpace *virLockDaemonFindLockSpace(virLockDaemon *lockd,
const char *path);
}
-virLockDaemonConfigPtr
+virLockDaemonConfig *
virLockDaemonConfigNew(bool privileged G_GNUC_UNUSED)
{
- virLockDaemonConfigPtr data;
+ virLockDaemonConfig *data;
data = g_new0(virLockDaemonConfig, 1);
}
void
-virLockDaemonConfigFree(virLockDaemonConfigPtr data)
+virLockDaemonConfigFree(virLockDaemonConfig *data)
{
if (!data)
return;
}
static int
-virLockDaemonConfigLoadOptions(virLockDaemonConfigPtr data,
- virConfPtr conf)
+virLockDaemonConfigLoadOptions(virLockDaemonConfig *data,
+ virConf *conf)
{
if (virConfGetValueUInt(conf, "log_level", &data->log_level) < 0)
return -1;
* Only used in the remote case, hence the name.
*/
int
-virLockDaemonConfigLoadFile(virLockDaemonConfigPtr data,
+virLockDaemonConfigLoadFile(virLockDaemonConfig *data,
const char *filename,
bool allow_missing)
{
#include "internal.h"
typedef struct _virLockDaemonConfig virLockDaemonConfig;
-typedef virLockDaemonConfig *virLockDaemonConfigPtr;
-
struct _virLockDaemonConfig {
unsigned int log_level;
char *log_filters;
int virLockDaemonConfigFilePath(bool privileged, char **configfile);
-virLockDaemonConfigPtr virLockDaemonConfigNew(bool privileged);
-void virLockDaemonConfigFree(virLockDaemonConfigPtr data);
-int virLockDaemonConfigLoadFile(virLockDaemonConfigPtr data,
+virLockDaemonConfig *virLockDaemonConfigNew(bool privileged);
+void virLockDaemonConfigFree(virLockDaemonConfig *data);
+int virLockDaemonConfigLoadFile(virLockDaemonConfig *data,
const char *filename,
bool allow_missing);
#include "lock_daemon_dispatch_stubs.h"
static int
-virLockSpaceProtocolDispatchAcquireResource(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchAcquireResource(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolAcquireResourceArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
unsigned int newFlags;
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchCreateResource(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchCreateResource(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolCreateResourceArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchDeleteResource(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchDeleteResource(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolDeleteResourceArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchNew(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchNew(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolNewArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchRegister(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchRegister(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolRegisterArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchReleaseResource(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchReleaseResource(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolReleaseResourceArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchRestrict(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchRestrict(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolRestrictArgs *args)
{
int rv = -1;
unsigned int flags = args->flags;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
g_mutex_lock(&priv->lock);
static int
-virLockSpaceProtocolDispatchCreateLockSpace(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLockSpaceProtocolDispatchCreateLockSpace(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLockSpaceProtocolCreateLockSpaceArgs *args)
{
int rv = -1;
- virLockDaemonClientPtr priv =
+ virLockDaemonClient *priv =
virNetServerClientGetPrivateData(client);
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
g_mutex_lock(&priv->lock);
#include "domain_conf.h"
typedef struct _virLockManager virLockManager;
-typedef virLockManager *virLockManagerPtr;
typedef struct _virLockDriver virLockDriver;
-typedef virLockDriver *virLockDriverPtr;
typedef struct _virLockManagerParam virLockManagerParam;
-typedef virLockManagerParam *virLockManagerParamPtr;
typedef enum {
/* State passing is used to re-acquire existing leases */
*
* Returns 0 if successful initialized a new context, -1 on error
*/
-typedef int (*virLockDriverNew)(virLockManagerPtr man,
+typedef int (*virLockDriverNew)(virLockManager *man,
unsigned int type,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags);
/**
* Release any resources associated with the lock manager
* context private data
*/
-typedef void (*virLockDriverFree)(virLockManagerPtr man);
+typedef void (*virLockDriverFree)(virLockManager *man);
/**
* virLockDriverAddResource:
*
* Returns 0 on success, or -1 on failure
*/
-typedef int (*virLockDriverAddResource)(virLockManagerPtr man,
+typedef int (*virLockDriverAddResource)(virLockManager *man,
unsigned int type,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags);
/**
*
* Returns 0 on success, or -1 on failure
*/
-typedef int (*virLockDriverAcquire)(virLockManagerPtr man,
+typedef int (*virLockDriverAcquire)(virLockManager *man,
const char *state,
unsigned int flags,
virDomainLockFailureAction action,
*
* Returns 0 on success, or -1 on failure
*/
-typedef int (*virLockDriverRelease)(virLockManagerPtr man,
+typedef int (*virLockDriverRelease)(virLockManager *man,
char **state,
unsigned int flags);
*
* Returns 0 on success, or -1 on failure.
*/
-typedef int (*virLockDriverInquire)(virLockManagerPtr man,
+typedef int (*virLockDriverInquire)(virLockManager *man,
char **state,
unsigned int flags);
struct _virLockManager {
- virLockDriverPtr driver;
+ virLockDriver *driver;
void *privateData;
};
VIR_LOG_INIT("locking.lock_driver_lockd");
typedef struct _virLockManagerLockDaemonPrivate virLockManagerLockDaemonPrivate;
-typedef virLockManagerLockDaemonPrivate *virLockManagerLockDaemonPrivatePtr;
typedef struct _virLockManagerLockDaemonResource virLockManagerLockDaemonResource;
-typedef virLockManagerLockDaemonResource *virLockManagerLockDaemonResourcePtr;
typedef struct _virLockManagerLockDaemonDriver virLockManagerLockDaemonDriver;
-typedef virLockManagerLockDaemonDriver *virLockManagerLockDaemonDriverPtr;
struct _virLockManagerLockDaemonResource {
char *lockspace;
pid_t pid;
size_t nresources;
- virLockManagerLockDaemonResourcePtr resources;
+ virLockManagerLockDaemonResource *resources;
bool hasRWDisks;
};
char *scsiLockSpaceDir;
};
-static virLockManagerLockDaemonDriverPtr driver;
+static virLockManagerLockDaemonDriver *driver;
static int virLockManagerLockDaemonLoadConfig(const char *configFile)
{
static int
-virLockManagerLockDaemonConnectionRegister(virLockManagerPtr lock,
- virNetClientPtr client,
- virNetClientProgramPtr program,
+virLockManagerLockDaemonConnectionRegister(virLockManager *lock,
+ virNetClient *client,
+ virNetClientProgram *program,
int *counter)
{
- virLockManagerLockDaemonPrivatePtr priv = lock->privateData;
+ virLockManagerLockDaemonPrivate *priv = lock->privateData;
virLockSpaceProtocolRegisterArgs args;
memset(&args, 0, sizeof(args));
static int
-virLockManagerLockDaemonConnectionRestrict(virLockManagerPtr lock G_GNUC_UNUSED,
- virNetClientPtr client,
- virNetClientProgramPtr program,
+virLockManagerLockDaemonConnectionRestrict(virLockManager *lock G_GNUC_UNUSED,
+ virNetClient *client,
+ virNetClientProgram *program,
int *counter)
{
virLockSpaceProtocolRestrictArgs args;
}
-static virNetClientPtr virLockManagerLockDaemonConnectionNew(bool privileged,
- virNetClientProgramPtr *prog)
+static virNetClient *virLockManagerLockDaemonConnectionNew(bool privileged,
+ virNetClientProgram **prog)
{
- virNetClientPtr client = NULL;
+ virNetClient *client = NULL;
char *lockdpath;
char *daemonPath = NULL;
}
-static virNetClientPtr
-virLockManagerLockDaemonConnect(virLockManagerPtr lock,
- virNetClientProgramPtr *program,
+static virNetClient *
+virLockManagerLockDaemonConnect(virLockManager *lock,
+ virNetClientProgram **program,
int *counter)
{
- virNetClientPtr client;
+ virNetClient *client;
if (!(client = virLockManagerLockDaemonConnectionNew(geteuid() == 0, program)))
return NULL;
static int virLockManagerLockDaemonSetupLockspace(const char *path)
{
- virNetClientPtr client;
- virNetClientProgramPtr program = NULL;
+ virNetClient *client;
+ virNetClientProgram *program = NULL;
virLockSpaceProtocolCreateLockSpaceArgs args;
int rv = -1;
int counter = 0;
}
static void
-virLockManagerLockDaemonPrivateFree(virLockManagerLockDaemonPrivatePtr priv)
+virLockManagerLockDaemonPrivateFree(virLockManagerLockDaemonPrivate *priv)
{
size_t i;
g_free(priv);
}
-static void virLockManagerLockDaemonFree(virLockManagerPtr lock)
+static void virLockManagerLockDaemonFree(virLockManager *lock)
{
if (!lock)
return;
}
-static int virLockManagerLockDaemonNew(virLockManagerPtr lock,
+static int virLockManagerLockDaemonNew(virLockManager *lock,
unsigned int type,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
- virLockManagerLockDaemonPrivatePtr priv = NULL;
+ virLockManagerLockDaemonPrivate *priv = NULL;
size_t i;
int ret = -1;
#endif
-static int virLockManagerLockDaemonAddResource(virLockManagerPtr lock,
+static int virLockManagerLockDaemonAddResource(virLockManager *lock,
unsigned int type,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
- virLockManagerLockDaemonPrivatePtr priv = lock->privateData;
+ virLockManagerLockDaemonPrivate *priv = lock->privateData;
char *newName = NULL;
char *newLockspace = NULL;
bool autoCreate = false;
}
-static int virLockManagerLockDaemonAcquire(virLockManagerPtr lock,
+static int virLockManagerLockDaemonAcquire(virLockManager *lock,
const char *state G_GNUC_UNUSED,
unsigned int flags,
virDomainLockFailureAction action G_GNUC_UNUSED,
int *fd)
{
- virNetClientPtr client = NULL;
- virNetClientProgramPtr program = NULL;
+ virNetClient *client = NULL;
+ virNetClientProgram *program = NULL;
int counter = 0;
int rv = -1;
- virLockManagerLockDaemonPrivatePtr priv = lock->privateData;
+ virLockManagerLockDaemonPrivate *priv = lock->privateData;
virCheckFlags(VIR_LOCK_MANAGER_ACQUIRE_REGISTER_ONLY |
VIR_LOCK_MANAGER_ACQUIRE_RESTRICT, -1);
return rv;
}
-static int virLockManagerLockDaemonRelease(virLockManagerPtr lock,
+static int virLockManagerLockDaemonRelease(virLockManager *lock,
char **state,
unsigned int flags)
{
- virNetClientPtr client = NULL;
- virNetClientProgramPtr program = NULL;
+ virNetClient *client = NULL;
+ virNetClientProgram *program = NULL;
int counter = 0;
int rv = -1;
size_t i;
- virLockManagerLockDaemonPrivatePtr priv = lock->privateData;
+ virLockManagerLockDaemonPrivate *priv = lock->privateData;
virCheckFlags(0, -1);
}
-static int virLockManagerLockDaemonInquire(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerLockDaemonInquire(virLockManager *lock G_GNUC_UNUSED,
char **state,
unsigned int flags)
{
}
-static int virLockManagerNopNew(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerNopNew(virLockManager *lock G_GNUC_UNUSED,
unsigned int type G_GNUC_UNUSED,
size_t nparams G_GNUC_UNUSED,
- virLockManagerParamPtr params G_GNUC_UNUSED,
+ virLockManagerParam *params G_GNUC_UNUSED,
unsigned int flags_unused G_GNUC_UNUSED)
{
return 0;
}
-static int virLockManagerNopAddResource(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerNopAddResource(virLockManager *lock G_GNUC_UNUSED,
unsigned int type G_GNUC_UNUSED,
const char *name G_GNUC_UNUSED,
size_t nparams G_GNUC_UNUSED,
- virLockManagerParamPtr params G_GNUC_UNUSED,
+ virLockManagerParam *params G_GNUC_UNUSED,
unsigned int flags_unused G_GNUC_UNUSED)
{
return 0;
}
-static int virLockManagerNopAcquire(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerNopAcquire(virLockManager *lock G_GNUC_UNUSED,
const char *state G_GNUC_UNUSED,
unsigned int flags_unused G_GNUC_UNUSED,
virDomainLockFailureAction action G_GNUC_UNUSED,
return 0;
}
-static int virLockManagerNopRelease(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerNopRelease(virLockManager *lock G_GNUC_UNUSED,
char **state,
unsigned int flags_unused G_GNUC_UNUSED)
{
return 0;
}
-static int virLockManagerNopInquire(virLockManagerPtr lock G_GNUC_UNUSED,
+static int virLockManagerNopInquire(virLockManager *lock G_GNUC_UNUSED,
char **state,
unsigned int flags_unused G_GNUC_UNUSED)
{
return 0;
}
-static void virLockManagerNopFree(virLockManagerPtr lock G_GNUC_UNUSED)
+static void virLockManagerNopFree(virLockManager *lock G_GNUC_UNUSED)
{
}
#endif
typedef struct _virLockManagerSanlockDriver virLockManagerSanlockDriver;
-typedef virLockManagerSanlockDriver *virLockManagerSanlockDriverPtr;
typedef struct _virLockManagerSanlockPrivate virLockManagerSanlockPrivate;
-typedef virLockManagerSanlockPrivate *virLockManagerSanlockPrivatePtr;
struct _virLockManagerSanlockDriver {
bool requireLeaseForDisks;
gid_t group;
};
-static virLockManagerSanlockDriverPtr sanlockDriver;
+static virLockManagerSanlockDriver *sanlockDriver;
struct _virLockManagerSanlockPrivate {
const char *vm_uri;
* sanlock plugin for the libvirt virLockManager API
*/
static int
-virLockManagerSanlockLoadConfig(virLockManagerSanlockDriverPtr driver,
+virLockManagerSanlockLoadConfig(virLockManagerSanlockDriver *driver,
const char *configFile)
{
g_autoptr(virConf) conf = NULL;
}
static int
-virLockManagerSanlockInitLockspace(virLockManagerSanlockDriverPtr driver,
+virLockManagerSanlockInitLockspace(virLockManagerSanlockDriver *driver,
struct sanlk_lockspace *ls)
{
int ret;
#define LOCKSPACE_RETRIES 10
static int
-virLockManagerSanlockSetupLockspace(virLockManagerSanlockDriverPtr driver)
+virLockManagerSanlockSetupLockspace(virLockManagerSanlockDriver *driver)
{
int fd = -1;
struct stat st;
const char *configFile,
unsigned int flags)
{
- virLockManagerSanlockDriverPtr driver;
+ virLockManagerSanlockDriver *driver;
VIR_DEBUG("version=%u configFile=%s flags=0x%x",
version, NULLSTR(configFile), flags);
}
-static int virLockManagerSanlockNew(virLockManagerPtr lock,
+static int virLockManagerSanlockNew(virLockManager *lock,
unsigned int type,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
- virLockManagerParamPtr param;
- virLockManagerSanlockPrivatePtr priv;
+ virLockManagerParam *param;
+ virLockManagerSanlockPrivate *priv;
size_t i;
int resCount = 0;
return 0;
}
-static void virLockManagerSanlockFree(virLockManagerPtr lock)
+static void virLockManagerSanlockFree(virLockManager *lock)
{
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
size_t i;
if (!priv)
}
-static int virLockManagerSanlockAddLease(virLockManagerPtr lock,
+static int virLockManagerSanlockAddLease(virLockManager *lock,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
bool shared)
{
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
g_autofree struct sanlk_resource *res = NULL;
size_t i;
static int
-virLockManagerSanlockAddDisk(virLockManagerSanlockDriverPtr driver,
- virLockManagerPtr lock,
+virLockManagerSanlockAddDisk(virLockManagerSanlockDriver *driver,
+ virLockManager *lock,
const char *name,
size_t nparams,
- virLockManagerParamPtr params G_GNUC_UNUSED,
+ virLockManagerParam *params G_GNUC_UNUSED,
bool shared)
{
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
g_autofree struct sanlk_resource *res = NULL;
g_autofree char *path = NULL;
g_autofree char *hash = NULL;
static int
-virLockManagerSanlockCreateLease(virLockManagerSanlockDriverPtr driver,
+virLockManagerSanlockCreateLease(virLockManagerSanlockDriver *driver,
struct sanlk_resource *res)
{
int fd = -1;
}
-static int virLockManagerSanlockAddResource(virLockManagerPtr lock,
+static int virLockManagerSanlockAddResource(virLockManager *lock,
unsigned int type,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
- virLockManagerSanlockDriverPtr driver = sanlockDriver;
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockDriver *driver = sanlockDriver;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
virCheckFlags(VIR_LOCK_MANAGER_RESOURCE_READONLY |
VIR_LOCK_MANAGER_RESOURCE_SHARED, -1);
return ret;
}
-static int virLockManagerSanlockAcquire(virLockManagerPtr lock,
+static int virLockManagerSanlockAcquire(virLockManager *lock,
const char *state,
unsigned int flags,
virDomainLockFailureAction action,
int *fd)
{
- virLockManagerSanlockDriverPtr driver = sanlockDriver;
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockDriver *driver = sanlockDriver;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
struct sanlk_options *opt = NULL;
struct sanlk_resource **res_args;
int res_count;
}
-static int virLockManagerSanlockRelease(virLockManagerPtr lock,
+static int virLockManagerSanlockRelease(virLockManager *lock,
char **state,
unsigned int flags)
{
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
int res_count = priv->res_count;
int rv;
return 0;
}
-static int virLockManagerSanlockInquire(virLockManagerPtr lock,
+static int virLockManagerSanlockInquire(virLockManager *lock,
char **state,
unsigned int flags)
{
- virLockManagerSanlockPrivatePtr priv = lock->privateData;
+ virLockManagerSanlockPrivate *priv = lock->privateData;
int rv, res_count;
virCheckFlags(0, -1);
struct _virLockManagerPlugin {
char *name;
- virLockDriverPtr driver;
+ virLockDriver *driver;
void *handle;
int refs;
};
static void virLockManagerLogParams(size_t nparams,
- virLockManagerParamPtr params)
+ virLockManagerParam *params)
{
size_t i;
char uuidstr[VIR_UUID_STRING_BUFLEN];
* Returns a plugin object, or NULL if loading failed.
*/
#if WITH_DLFCN_H
-virLockManagerPluginPtr virLockManagerPluginNew(const char *name,
+virLockManagerPlugin *virLockManagerPluginNew(const char *name,
const char *driverName,
const char *configDir,
unsigned int flags)
{
void *handle = NULL;
- virLockDriverPtr driver;
- virLockManagerPluginPtr plugin = NULL;
+ virLockDriver *driver;
+ virLockManagerPlugin *plugin = NULL;
char *modfile = NULL;
char *configFile = NULL;
return NULL;
}
#else /* !WITH_DLFCN_H */
-virLockManagerPluginPtr
+virLockManagerPlugin *
virLockManagerPluginNew(const char *name G_GNUC_UNUSED,
const char *driverName G_GNUC_UNUSED,
const char *configDir G_GNUC_UNUSED,
*
* Acquires an additional reference on the plugin.
*/
-void virLockManagerPluginRef(virLockManagerPluginPtr plugin)
+void virLockManagerPluginRef(virLockManagerPlugin *plugin)
{
plugin->refs++;
}
*
*/
#if WITH_DLFCN_H
-void virLockManagerPluginUnref(virLockManagerPluginPtr plugin)
+void virLockManagerPluginUnref(virLockManagerPlugin *plugin)
{
if (!plugin)
return;
g_free(plugin);
}
#else /* !WITH_DLFCN_H */
-void virLockManagerPluginUnref(virLockManagerPluginPtr plugin G_GNUC_UNUSED)
+void virLockManagerPluginUnref(virLockManagerPlugin *plugin G_GNUC_UNUSED)
{
}
#endif /* !WITH_DLFCN_H */
-const char *virLockManagerPluginGetName(virLockManagerPluginPtr plugin)
+const char *virLockManagerPluginGetName(virLockManagerPlugin *plugin)
{
VIR_DEBUG("plugin=%p", plugin);
}
-bool virLockManagerPluginUsesState(virLockManagerPluginPtr plugin)
+bool virLockManagerPluginUsesState(virLockManagerPlugin *plugin)
{
VIR_DEBUG("plugin=%p", plugin);
}
-virLockDriverPtr virLockManagerPluginGetDriver(virLockManagerPluginPtr plugin)
+virLockDriver *virLockManagerPluginGetDriver(virLockManagerPlugin *plugin)
{
VIR_DEBUG("plugin=%p", plugin);
*
* Returns a new lock manager context
*/
-virLockManagerPtr virLockManagerNew(virLockDriverPtr driver,
+virLockManager *virLockManagerNew(virLockDriver *driver,
unsigned int type,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
- virLockManagerPtr lock;
+ virLockManager *lock;
VIR_DEBUG("driver=%p type=%u nparams=%zu params=%p flags=0x%x",
driver, type, nparams, params, flags);
virLockManagerLogParams(nparams, params);
}
-int virLockManagerAddResource(virLockManagerPtr lock,
+int virLockManagerAddResource(virLockManager *lock,
unsigned int type,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags)
{
VIR_DEBUG("lock=%p type=%u name=%s nparams=%zu params=%p flags=0x%x",
flags);
}
-int virLockManagerAcquire(virLockManagerPtr lock,
+int virLockManagerAcquire(virLockManager *lock,
const char *state,
unsigned int flags,
virDomainLockFailureAction action,
}
-int virLockManagerRelease(virLockManagerPtr lock,
+int virLockManagerRelease(virLockManager *lock,
char **state,
unsigned int flags)
{
}
-int virLockManagerInquire(virLockManagerPtr lock,
+int virLockManagerInquire(virLockManager *lock,
char **state,
unsigned int flags)
{
}
-int virLockManagerFree(virLockManagerPtr lock)
+int virLockManagerFree(virLockManager *lock)
{
VIR_DEBUG("lock=%p", lock);
#include "lock_driver.h"
typedef struct _virLockManagerPlugin virLockManagerPlugin;
-typedef virLockManagerPlugin *virLockManagerPluginPtr;
-virLockManagerPluginPtr virLockManagerPluginNew(const char *name,
+virLockManagerPlugin *virLockManagerPluginNew(const char *name,
const char *driverName,
const char *configDir,
unsigned int flags);
-void virLockManagerPluginRef(virLockManagerPluginPtr plugin);
-void virLockManagerPluginUnref(virLockManagerPluginPtr plugin);
+void virLockManagerPluginRef(virLockManagerPlugin *plugin);
+void virLockManagerPluginUnref(virLockManagerPlugin *plugin);
-const char *virLockManagerPluginGetName(virLockManagerPluginPtr plugin);
-bool virLockManagerPluginUsesState(virLockManagerPluginPtr plugin);
+const char *virLockManagerPluginGetName(virLockManagerPlugin *plugin);
+bool virLockManagerPluginUsesState(virLockManagerPlugin *plugin);
-virLockDriverPtr virLockManagerPluginGetDriver(virLockManagerPluginPtr plugin);
+virLockDriver *virLockManagerPluginGetDriver(virLockManagerPlugin *plugin);
-virLockManagerPtr virLockManagerNew(virLockDriverPtr driver,
+virLockManager *virLockManagerNew(virLockDriver *driver,
unsigned int type,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags);
-int virLockManagerAddResource(virLockManagerPtr manager,
+int virLockManagerAddResource(virLockManager *manager,
unsigned int type,
const char *name,
size_t nparams,
- virLockManagerParamPtr params,
+ virLockManagerParam *params,
unsigned int flags);
-int virLockManagerAcquire(virLockManagerPtr manager,
+int virLockManagerAcquire(virLockManager *manager,
const char *state,
unsigned int flags,
virDomainLockFailureAction action,
int *fd);
-int virLockManagerRelease(virLockManagerPtr manager,
+int virLockManagerRelease(virLockManager *manager,
char **state,
unsigned int flags);
-int virLockManagerInquire(virLockManagerPtr manager,
+int virLockManagerInquire(virLockManager *manager,
char **state,
unsigned int flags);
-int virLockManagerFree(virLockManagerPtr manager);
+int virLockManagerFree(virLockManager *manager);
struct _virLogDaemon {
GMutex lock;
- virNetDaemonPtr dmn;
- virLogHandlerPtr handler;
+ virNetDaemon *dmn;
+ virLogHandler *handler;
};
-virLogDaemonPtr logDaemon = NULL;
+virLogDaemon *logDaemon = NULL;
static bool execRestart;
static void *
-virLogDaemonClientNew(virNetServerClientPtr client,
+virLogDaemonClientNew(virNetServerClient *client,
void *opaque);
static void
virLogDaemonClientFree(void *opaque);
static void *
-virLogDaemonClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object,
+virLogDaemonClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object,
void *opaque);
-static virJSONValuePtr
-virLogDaemonClientPreExecRestart(virNetServerClientPtr client,
+static virJSONValue *
+virLogDaemonClientPreExecRestart(virNetServerClient *client,
void *opaque);
static void
-virLogDaemonFree(virLogDaemonPtr logd)
+virLogDaemonFree(virLogDaemon *logd)
{
if (!logd)
return;
static void
virLogDaemonInhibitor(bool inhibit, void *opaque)
{
- virLogDaemonPtr dmn = opaque;
+ virLogDaemon *dmn = opaque;
/* virtlogd uses inhibition only to stop session daemon being killed after
* the specified timeout, for the system daemon this is taken care of by
virNetDaemonRemoveShutdownInhibition(dmn->dmn);
}
-static virLogDaemonPtr
-virLogDaemonNew(virLogDaemonConfigPtr config, bool privileged)
+static virLogDaemon *
+virLogDaemonNew(virLogDaemonConfig *config, bool privileged)
{
- virLogDaemonPtr logd;
- virNetServerPtr srv = NULL;
+ virLogDaemon *logd;
+ virNetServer *srv = NULL;
logd = g_new0(virLogDaemon, 1);
}
-virLogHandlerPtr
-virLogDaemonGetHandler(virLogDaemonPtr dmn)
+virLogHandler *
+virLogDaemonGetHandler(virLogDaemon *dmn)
{
return dmn->handler;
}
-static virNetServerPtr
-virLogDaemonNewServerPostExecRestart(virNetDaemonPtr dmn,
+static virNetServer *
+virLogDaemonNewServerPostExecRestart(virNetDaemon *dmn,
const char *name,
- virJSONValuePtr object,
+ virJSONValue *object,
void *opaque)
{
if (STREQ(name, "virtlogd")) {
}
-static virLogDaemonPtr
-virLogDaemonNewPostExecRestart(virJSONValuePtr object, bool privileged,
- virLogDaemonConfigPtr config)
+static virLogDaemon *
+virLogDaemonNewPostExecRestart(virJSONValue *object, bool privileged,
+ virLogDaemonConfig *config)
{
- virLogDaemonPtr logd;
- virJSONValuePtr child;
+ virLogDaemon *logd;
+ virJSONValue *child;
const char *serverNames[] = { "virtlogd" };
logd = g_new0(virLogDaemon, 1);
}
static void
-virLogDaemonShutdownHandler(virNetDaemonPtr dmn,
+virLogDaemonShutdownHandler(virNetDaemon *dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static void
-virLogDaemonExecRestartHandler(virNetDaemonPtr dmn,
+virLogDaemonExecRestartHandler(virNetDaemon *dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static int
-virLogDaemonSetupSignals(virNetDaemonPtr dmn)
+virLogDaemonSetupSignals(virNetDaemon *dmn)
{
if (virNetDaemonAddSignalHandler(dmn, SIGINT, virLogDaemonShutdownHandler, NULL) < 0)
return -1;
static void
virLogDaemonClientFree(void *opaque)
{
- virLogDaemonClientPtr priv = opaque;
+ virLogDaemonClient *priv = opaque;
if (!priv)
return;
static void *
-virLogDaemonClientNew(virNetServerClientPtr client,
+virLogDaemonClientNew(virNetServerClient *client,
void *opaque)
{
- virLogDaemonClientPtr priv;
+ virLogDaemonClient *priv;
uid_t clientuid;
gid_t clientgid;
unsigned long long timestamp;
static void *
-virLogDaemonClientNewPostExecRestart(virNetServerClientPtr client,
- virJSONValuePtr object G_GNUC_UNUSED,
+virLogDaemonClientNewPostExecRestart(virNetServerClient *client,
+ virJSONValue *object G_GNUC_UNUSED,
void *opaque)
{
- virLogDaemonClientPtr priv = virLogDaemonClientNew(client, opaque);
+ virLogDaemonClient *priv = virLogDaemonClientNew(client, opaque);
if (!priv)
return NULL;
}
-static virJSONValuePtr
-virLogDaemonClientPreExecRestart(virNetServerClientPtr client G_GNUC_UNUSED,
+static virJSONValue *
+virLogDaemonClientPreExecRestart(virNetServerClient *client G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virJSONValuePtr object = virJSONValueNewObject();
+ virJSONValue *object = virJSONValueNewObject();
return object;
}
const char *pid_file,
int *pid_file_fd,
bool privileged,
- virLogDaemonConfigPtr config)
+ virLogDaemonConfig *config)
{
const char *gotmagic;
char *wantmagic = NULL;
int ret = -1;
char *state = NULL;
- virJSONValuePtr object = NULL;
+ virJSONValue *object = NULL;
VIR_DEBUG("Running post-restart exec");
static int
virLogDaemonPreExecRestart(const char *state_file,
- virNetDaemonPtr dmn,
+ virNetDaemon *dmn,
char **argv)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
}
int main(int argc, char **argv) {
- virNetServerPtr logSrv = NULL;
- virNetServerPtr adminSrv = NULL;
- virNetServerProgramPtr logProgram = NULL;
- virNetServerProgramPtr adminProgram = NULL;
+ virNetServer *logSrv = NULL;
+ virNetServer *adminSrv = NULL;
+ virNetServerProgram *logProgram = NULL;
+ virNetServerProgram *adminProgram = NULL;
char *remote_config_file = NULL;
int statuswrite = -1;
int ret = 1;
bool implicit_conf = false;
mode_t old_umask;
bool privileged = false;
- virLogDaemonConfigPtr config = NULL;
+ virLogDaemonConfig *config = NULL;
int rv;
struct option opts[] = {
#include "log_handler.h"
typedef struct _virLogDaemon virLogDaemon;
-typedef virLogDaemon *virLogDaemonPtr;
typedef struct _virLogDaemonClient virLogDaemonClient;
-typedef virLogDaemonClient *virLogDaemonClientPtr;
-
struct _virLogDaemonClient {
GMutex lock;
pid_t clientPid;
};
-extern virLogDaemonPtr logDaemon;
+extern virLogDaemon *logDaemon;
-virLogHandlerPtr virLogDaemonGetHandler(virLogDaemonPtr dmn);
+virLogHandler *virLogDaemonGetHandler(virLogDaemon *dmn);
}
-virLogDaemonConfigPtr
+virLogDaemonConfig *
virLogDaemonConfigNew(bool privileged G_GNUC_UNUSED)
{
- virLogDaemonConfigPtr data;
+ virLogDaemonConfig *data;
data = g_new0(virLogDaemonConfig, 1);
}
void
-virLogDaemonConfigFree(virLogDaemonConfigPtr data)
+virLogDaemonConfigFree(virLogDaemonConfig *data)
{
if (!data)
return;
}
static int
-virLogDaemonConfigLoadOptions(virLogDaemonConfigPtr data,
- virConfPtr conf)
+virLogDaemonConfigLoadOptions(virLogDaemonConfig *data,
+ virConf *conf)
{
if (virConfGetValueUInt(conf, "log_level", &data->log_level) < 0)
return -1;
/* Read the config file if it exists.
*/
int
-virLogDaemonConfigLoadFile(virLogDaemonConfigPtr data,
+virLogDaemonConfigLoadFile(virLogDaemonConfig *data,
const char *filename,
bool allow_missing)
{
#include "internal.h"
typedef struct _virLogDaemonConfig virLogDaemonConfig;
-typedef virLogDaemonConfig *virLogDaemonConfigPtr;
-
struct _virLogDaemonConfig {
unsigned int log_level;
char *log_filters;
int virLogDaemonConfigFilePath(bool privileged, char **configfile);
-virLogDaemonConfigPtr virLogDaemonConfigNew(bool privileged);
-void virLogDaemonConfigFree(virLogDaemonConfigPtr data);
-int virLogDaemonConfigLoadFile(virLogDaemonConfigPtr data,
+virLogDaemonConfig *virLogDaemonConfigNew(bool privileged);
+void virLogDaemonConfigFree(virLogDaemonConfig *data);
+int virLogDaemonConfigLoadFile(virLogDaemonConfig *data,
const char *filename,
bool allow_missing);
#include "log_daemon_dispatch_stubs.h"
static int
-virLogManagerProtocolDispatchDomainOpenLogFile(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+virLogManagerProtocolDispatchDomainOpenLogFile(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
virLogManagerProtocolDomainOpenLogFileArgs *args,
virLogManagerProtocolDomainOpenLogFileRet *ret)
{
static int
-virLogManagerProtocolDispatchDomainGetLogFilePosition(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLogManagerProtocolDispatchDomainGetLogFilePosition(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLogManagerProtocolDomainGetLogFilePositionArgs *args,
virLogManagerProtocolDomainGetLogFilePositionRet *ret)
{
static int
-virLogManagerProtocolDispatchDomainReadLogFile(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLogManagerProtocolDispatchDomainReadLogFile(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLogManagerProtocolDomainReadLogFileArgs *args,
virLogManagerProtocolDomainReadLogFileRet *ret)
{
static int
-virLogManagerProtocolDispatchDomainAppendLogFile(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+virLogManagerProtocolDispatchDomainAppendLogFile(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
virLogManagerProtocolDomainAppendLogFileArgs *args,
virLogManagerProtocolDomainAppendLogFileRet *ret)
{
#define DEFAULT_MODE 0600
typedef struct _virLogHandlerLogFile virLogHandlerLogFile;
-typedef virLogHandlerLogFile *virLogHandlerLogFilePtr;
-
struct _virLogHandlerLogFile {
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int watch;
int pipefd; /* Read from QEMU via this */
bool drained;
size_t max_size;
size_t max_backups;
- virLogHandlerLogFilePtr *files;
+ virLogHandlerLogFile **files;
size_t nfiles;
virLogHandlerShutdownInhibitor inhibitor;
void *opaque;
};
-static virClassPtr virLogHandlerClass;
+static virClass *virLogHandlerClass;
static void virLogHandlerDispose(void *obj);
static int
static void
-virLogHandlerLogFileFree(virLogHandlerLogFilePtr file)
+virLogHandlerLogFileFree(virLogHandlerLogFile *file)
{
if (!file)
return;
static void
-virLogHandlerLogFileClose(virLogHandlerPtr handler,
- virLogHandlerLogFilePtr file)
+virLogHandlerLogFileClose(virLogHandler *handler,
+ virLogHandlerLogFile *file)
{
size_t i;
}
-static virLogHandlerLogFilePtr
-virLogHandlerGetLogFileFromWatch(virLogHandlerPtr handler,
+static virLogHandlerLogFile *
+virLogHandlerGetLogFileFromWatch(virLogHandler *handler,
int watch)
{
size_t i;
int events G_GNUC_UNUSED,
void *opaque)
{
- virLogHandlerPtr handler = opaque;
- virLogHandlerLogFilePtr logfile;
+ virLogHandler *handler = opaque;
+ virLogHandlerLogFile *logfile;
char buf[1024];
ssize_t len;
}
-virLogHandlerPtr
+virLogHandler *
virLogHandlerNew(bool privileged,
size_t max_size,
size_t max_backups,
virLogHandlerShutdownInhibitor inhibitor,
void *opaque)
{
- virLogHandlerPtr handler;
+ virLogHandler *handler;
if (virLogHandlerInitialize() < 0)
return NULL;
}
-static virLogHandlerLogFilePtr
-virLogHandlerLogFilePostExecRestart(virLogHandlerPtr handler,
- virJSONValuePtr object)
+static virLogHandlerLogFile *
+virLogHandlerLogFilePostExecRestart(virLogHandler *handler,
+ virJSONValue *object)
{
- virLogHandlerLogFilePtr file;
+ virLogHandlerLogFile *file;
const char *path;
const char *domuuid;
const char *tmp;
}
-virLogHandlerPtr
-virLogHandlerNewPostExecRestart(virJSONValuePtr object,
+virLogHandler *
+virLogHandlerNewPostExecRestart(virJSONValue *object,
bool privileged,
size_t max_size,
size_t max_backups,
virLogHandlerShutdownInhibitor inhibitor,
void *opaque)
{
- virLogHandlerPtr handler;
- virJSONValuePtr files;
+ virLogHandler *handler;
+ virJSONValue *files;
size_t i;
if (!(handler = virLogHandlerNew(privileged,
}
for (i = 0; i < virJSONValueArraySize(files); i++) {
- virLogHandlerLogFilePtr file;
- virJSONValuePtr child = virJSONValueArrayGet(files, i);
+ virLogHandlerLogFile *file;
+ virJSONValue *child = virJSONValueArrayGet(files, i);
if (!(file = virLogHandlerLogFilePostExecRestart(handler, child)))
goto error;
static void
virLogHandlerDispose(void *obj)
{
- virLogHandlerPtr handler = obj;
+ virLogHandler *handler = obj;
size_t i;
for (i = 0; i < handler->nfiles; i++) {
int
-virLogHandlerDomainOpenLogFile(virLogHandlerPtr handler,
+virLogHandlerDomainOpenLogFile(virLogHandler *handler,
const char *driver,
const unsigned char *domuuid,
const char *domname,
off_t *offset)
{
size_t i;
- virLogHandlerLogFilePtr file = NULL;
+ virLogHandlerLogFile *file = NULL;
int pipefd[2] = { -1, -1 };
virObjectLock(handler);
static void
-virLogHandlerDomainLogFileDrain(virLogHandlerLogFilePtr file)
+virLogHandlerDomainLogFileDrain(virLogHandlerLogFile *file)
{
char buf[1024];
ssize_t len;
int
-virLogHandlerDomainGetLogFilePosition(virLogHandlerPtr handler,
+virLogHandlerDomainGetLogFilePosition(virLogHandler *handler,
const char *path,
unsigned int flags,
ino_t *inode,
off_t *offset)
{
- virLogHandlerLogFilePtr file = NULL;
+ virLogHandlerLogFile *file = NULL;
int ret = -1;
size_t i;
char *
-virLogHandlerDomainReadLogFile(virLogHandlerPtr handler,
+virLogHandlerDomainReadLogFile(virLogHandler *handler,
const char *path,
ino_t inode,
off_t offset,
size_t maxlen,
unsigned int flags)
{
- virRotatingFileReaderPtr file = NULL;
+ virRotatingFileReader *file = NULL;
char *data = NULL;
ssize_t got;
int
-virLogHandlerDomainAppendLogFile(virLogHandlerPtr handler,
+virLogHandlerDomainAppendLogFile(virLogHandler *handler,
const char *driver G_GNUC_UNUSED,
const unsigned char *domuuid G_GNUC_UNUSED,
const char *domname G_GNUC_UNUSED,
unsigned int flags)
{
size_t i;
- virRotatingFileWriterPtr writer = NULL;
- virRotatingFileWriterPtr newwriter = NULL;
+ virRotatingFileWriter *writer = NULL;
+ virRotatingFileWriter *newwriter = NULL;
int ret = -1;
virCheckFlags(0, -1);
}
-virJSONValuePtr
-virLogHandlerPreExecRestart(virLogHandlerPtr handler)
+virJSONValue *
+virLogHandlerPreExecRestart(virLogHandler *handler)
{
g_autoptr(virJSONValue) ret = virJSONValueNewObject();
g_autoptr(virJSONValue) files = virJSONValueNewArray();
#include "virjson.h"
typedef struct _virLogHandler virLogHandler;
-typedef virLogHandler *virLogHandlerPtr;
typedef void (*virLogHandlerShutdownInhibitor)(bool inhibit,
void *opaque);
-virLogHandlerPtr virLogHandlerNew(bool privileged,
+virLogHandler *virLogHandlerNew(bool privileged,
size_t max_size,
size_t max_backups,
virLogHandlerShutdownInhibitor inhibitor,
void *opaque);
-virLogHandlerPtr virLogHandlerNewPostExecRestart(virJSONValuePtr child,
+virLogHandler *virLogHandlerNewPostExecRestart(virJSONValue *child,
bool privileged,
size_t max_size,
size_t max_backups,
virLogHandlerShutdownInhibitor inhibitor,
void *opaque);
-void virLogHandlerFree(virLogHandlerPtr handler);
+void virLogHandlerFree(virLogHandler *handler);
-int virLogHandlerDomainOpenLogFile(virLogHandlerPtr handler,
+int virLogHandlerDomainOpenLogFile(virLogHandler *handler,
const char *driver,
const unsigned char *domuuid,
const char *domname,
ino_t *inode,
off_t *offset);
-int virLogHandlerDomainGetLogFilePosition(virLogHandlerPtr handler,
+int virLogHandlerDomainGetLogFilePosition(virLogHandler *handler,
const char *path,
unsigned int flags,
ino_t *inode,
off_t *offset);
-char *virLogHandlerDomainReadLogFile(virLogHandlerPtr handler,
+char *virLogHandlerDomainReadLogFile(virLogHandler *handler,
const char *path,
ino_t inode,
off_t offset,
size_t maxlen,
unsigned int flags);
-int virLogHandlerDomainAppendLogFile(virLogHandlerPtr handler,
+int virLogHandlerDomainAppendLogFile(virLogHandler *handler,
const char *driver,
const unsigned char *domuuid,
const char *domname,
const char *message,
unsigned int flags);
-virJSONValuePtr virLogHandlerPreExecRestart(virLogHandlerPtr handler);
+virJSONValue *virLogHandlerPreExecRestart(virLogHandler *handler);
#define VIR_FROM_THIS VIR_FROM_LOGGING
struct _virLogManager {
- virNetClientPtr client;
- virNetClientProgramPtr program;
+ virNetClient *client;
+ virNetClientProgram *program;
unsigned int serial;
};
}
-static virNetClientPtr
+static virNetClient *
virLogManagerConnect(bool privileged,
- virNetClientProgramPtr *prog)
+ virNetClientProgram **prog)
{
- virNetClientPtr client = NULL;
+ virNetClient *client = NULL;
char *logdpath;
char *daemonPath = NULL;
}
-virLogManagerPtr
+virLogManager *
virLogManagerNew(bool privileged)
{
- virLogManagerPtr mgr;
+ virLogManager *mgr;
mgr = g_new0(virLogManager, 1);
void
-virLogManagerFree(virLogManagerPtr mgr)
+virLogManagerFree(virLogManager *mgr)
{
if (!mgr)
return;
int
-virLogManagerDomainOpenLogFile(virLogManagerPtr mgr,
+virLogManagerDomainOpenLogFile(virLogManager *mgr,
const char *driver,
const unsigned char *domuuid,
const char *domname,
int
-virLogManagerDomainGetLogFilePosition(virLogManagerPtr mgr,
+virLogManagerDomainGetLogFilePosition(virLogManager *mgr,
const char *path,
unsigned int flags,
ino_t *inode,
char *
-virLogManagerDomainReadLogFile(virLogManagerPtr mgr,
+virLogManagerDomainReadLogFile(virLogManager *mgr,
const char *path,
ino_t inode,
off_t offset,
int
-virLogManagerDomainAppendMessage(virLogManagerPtr mgr,
+virLogManagerDomainAppendMessage(virLogManager *mgr,
const char *driver,
const unsigned char *domuuid,
const char *domname,
#include "internal.h"
typedef struct _virLogManager virLogManager;
-typedef virLogManager *virLogManagerPtr;
-virLogManagerPtr virLogManagerNew(bool privileged);
+virLogManager *virLogManagerNew(bool privileged);
-void virLogManagerFree(virLogManagerPtr mgr);
+void virLogManagerFree(virLogManager *mgr);
-int virLogManagerDomainOpenLogFile(virLogManagerPtr mgr,
+int virLogManagerDomainOpenLogFile(virLogManager *mgr,
const char *driver,
const unsigned char *domuuid,
const char *domname,
ino_t *inode,
off_t *offset);
-int virLogManagerDomainGetLogFilePosition(virLogManagerPtr mgr,
+int virLogManagerDomainGetLogFilePosition(virLogManager *mgr,
const char *path,
unsigned int flags,
ino_t *inode,
off_t *offset);
-char *virLogManagerDomainReadLogFile(virLogManagerPtr mgr,
+char *virLogManagerDomainReadLogFile(virLogManager *mgr,
const char *path,
ino_t inode,
off_t offset,
size_t maxlen,
unsigned int flags);
-int virLogManagerDomainAppendMessage(virLogManagerPtr mgr,
+int virLogManagerDomainAppendMessage(virLogManager *mgr,
const char *driver,
const unsigned char *domuuid,
const char *domname,
VIR_LOG_INIT("lxc.lxc_cgroup");
-static int virLXCCgroupSetupCpuTune(virDomainDefPtr def,
- virCgroupPtr cgroup)
+static int virLXCCgroupSetupCpuTune(virDomainDef *def,
+ virCgroup *cgroup)
{
if (def->cputune.sharesSpecified) {
if (virCgroupSetCpuShares(cgroup, def->cputune.shares) < 0)
}
-static int virLXCCgroupSetupCpusetTune(virDomainDefPtr def,
- virCgroupPtr cgroup,
- virBitmapPtr nodemask)
+static int virLXCCgroupSetupCpusetTune(virDomainDef *def,
+ virCgroup *cgroup,
+ virBitmap *nodemask)
{
g_autofree char *mask = NULL;
virDomainNumatuneMemMode mode;
}
-static int virLXCCgroupSetupBlkioTune(virDomainDefPtr def,
- virCgroupPtr cgroup)
+static int virLXCCgroupSetupBlkioTune(virDomainDef *def,
+ virCgroup *cgroup)
{
return virDomainCgroupSetupBlkio(cgroup, def->blkio);
}
-static int virLXCCgroupSetupMemTune(virDomainDefPtr def,
- virCgroupPtr cgroup)
+static int virLXCCgroupSetupMemTune(virDomainDef *def,
+ virCgroup *cgroup)
{
if (virCgroupSetMemory(cgroup, virDomainDefGetMemoryInitial(def)) < 0)
return -1;
}
-static int virLXCCgroupGetMemSwapUsage(virCgroupPtr cgroup,
- virLXCMeminfoPtr meminfo)
+static int virLXCCgroupGetMemSwapUsage(virCgroup *cgroup,
+ struct virLXCMeminfo *meminfo)
{
return virCgroupGetMemSwapUsage(cgroup, &meminfo->swapusage);
}
-static int virLXCCgroupGetMemSwapTotal(virCgroupPtr cgroup,
- virLXCMeminfoPtr meminfo)
+static int virLXCCgroupGetMemSwapTotal(virCgroup *cgroup,
+ struct virLXCMeminfo *meminfo)
{
return virCgroupGetMemSwapHardLimit(cgroup, &meminfo->swaptotal);
}
-static int virLXCCgroupGetMemUsage(virCgroupPtr cgroup,
- virLXCMeminfoPtr meminfo)
+static int virLXCCgroupGetMemUsage(virCgroup *cgroup,
+ struct virLXCMeminfo *meminfo)
{
int ret;
unsigned long memUsage;
}
-static int virLXCCgroupGetMemTotal(virCgroupPtr cgroup,
- virLXCMeminfoPtr meminfo)
+static int virLXCCgroupGetMemTotal(virCgroup *cgroup,
+ struct virLXCMeminfo *meminfo)
{
return virCgroupGetMemoryHardLimit(cgroup, &meminfo->memtotal);
}
-static int virLXCCgroupGetMemStat(virCgroupPtr cgroup,
- virLXCMeminfoPtr meminfo)
+static int virLXCCgroupGetMemStat(virCgroup *cgroup,
+ struct virLXCMeminfo *meminfo)
{
return virCgroupGetMemoryStat(cgroup,
&meminfo->cached,
}
-int virLXCCgroupGetMeminfo(virLXCMeminfoPtr meminfo)
+int virLXCCgroupGetMeminfo(struct virLXCMeminfo *meminfo)
{
g_autoptr(virCgroup) cgroup = NULL;
typedef struct _virLXCCgroupDevicePolicy virLXCCgroupDevicePolicy;
-typedef virLXCCgroupDevicePolicy *virLXCCgroupDevicePolicyPtr;
-
struct _virLXCCgroupDevicePolicy {
char type;
int major;
int
-virLXCSetupHostUSBDeviceCgroup(virUSBDevicePtr dev G_GNUC_UNUSED,
+virLXCSetupHostUSBDeviceCgroup(virUSBDevice *dev G_GNUC_UNUSED,
const char *path,
void *opaque)
{
- virCgroupPtr cgroup = opaque;
+ virCgroup *cgroup = opaque;
VIR_DEBUG("Process path '%s' for USB device", path);
if (virCgroupAllowDevicePath(cgroup, path,
int
-virLXCTeardownHostUSBDeviceCgroup(virUSBDevicePtr dev G_GNUC_UNUSED,
+virLXCTeardownHostUSBDeviceCgroup(virUSBDevice *dev G_GNUC_UNUSED,
const char *path,
void *opaque)
{
- virCgroupPtr cgroup = opaque;
+ virCgroup *cgroup = opaque;
VIR_DEBUG("Process path '%s' for USB device", path);
if (virCgroupDenyDevicePath(cgroup, path,
}
-static int virLXCCgroupSetupDeviceACL(virDomainDefPtr def,
- virCgroupPtr cgroup)
+static int virLXCCgroupSetupDeviceACL(virDomainDef *def,
+ virCgroup *cgroup)
{
int capMknod = def->caps_features[VIR_DOMAIN_PROCES_CAPS_FEATURE_MKNOD];
size_t i;
}
for (i = 0; devices[i].type != 0; i++) {
- virLXCCgroupDevicePolicyPtr dev = &devices[i];
+ virLXCCgroupDevicePolicy *dev = &devices[i];
if (virCgroupAllowDevice(cgroup,
dev->type,
dev->major,
VIR_DEBUG("Allowing any hostdev block devs");
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
- virDomainHostdevSubsysUSBPtr usbsrc = &hostdev->source.subsys.u.usb;
- virUSBDevicePtr usb;
+ virDomainHostdevDef *hostdev = def->hostdevs[i];
+ virDomainHostdevSubsysUSB *usbsrc = &hostdev->source.subsys.u.usb;
+ virUSBDevice *usb;
switch (hostdev->mode) {
case VIR_DOMAIN_HOSTDEV_MODE_SUBSYS:
/* Sync'ed with Host clock */
for (i = 0; i < def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = def->clock.timers[i];
+ virDomainTimerDef *timer = def->clock.timers[i];
const char *dev = NULL;
/* Check if "present" is set to "no" otherwise enable it. */
}
-virCgroupPtr virLXCCgroupCreate(virDomainDefPtr def,
+virCgroup *virLXCCgroupCreate(virDomainDef *def,
pid_t initpid,
size_t nnicindexes,
int *nicindexes)
{
- virCgroupPtr cgroup = NULL;
+ virCgroup *cgroup = NULL;
g_autofree char *machineName = virLXCDomainGetMachineName(def, 0);
if (!machineName)
}
-int virLXCCgroupSetup(virDomainDefPtr def,
- virCgroupPtr cgroup,
- virBitmapPtr nodemask)
+int virLXCCgroupSetup(virDomainDef *def,
+ virCgroup *cgroup,
+ virBitmap *nodemask)
{
if (virLXCCgroupSetupCpuTune(def, cgroup) < 0)
return -1;
#include "lxc_fuse.h"
#include "virusb.h"
-virCgroupPtr virLXCCgroupCreate(virDomainDefPtr def,
+virCgroup *virLXCCgroupCreate(virDomainDef *def,
pid_t initpid,
size_t nnicindexes,
int *nicindexes);
-virCgroupPtr virLXCCgroupJoin(virDomainDefPtr def);
-int virLXCCgroupSetup(virDomainDefPtr def,
- virCgroupPtr cgroup,
- virBitmapPtr nodemask);
+virCgroup *virLXCCgroupJoin(virDomainDef *def);
+int virLXCCgroupSetup(virDomainDef *def,
+ virCgroup *cgroup,
+ virBitmap *nodemask);
-int virLXCCgroupGetMeminfo(virLXCMeminfoPtr meminfo);
+int virLXCCgroupGetMeminfo(struct virLXCMeminfo *meminfo);
int
-virLXCSetupHostUSBDeviceCgroup(virUSBDevicePtr dev,
+virLXCSetupHostUSBDeviceCgroup(virUSBDevice *dev,
const char *path,
void *opaque);
int
-virLXCTeardownHostUSBDeviceCgroup(virUSBDevicePtr dev,
+virLXCTeardownHostUSBDeviceCgroup(virUSBDevice *dev,
const char *path,
void *opaque);
VIR_LOG_INIT("lxc.lxc_conf");
-static virClassPtr virLXCDriverConfigClass;
+static virClass *virLXCDriverConfigClass;
static void virLXCDriverConfigDispose(void *obj);
static int virLXCConfigOnceInit(void)
/* Functions */
-virCapsPtr virLXCDriverCapsInit(virLXCDriverPtr driver)
+virCaps *virLXCDriverCapsInit(virLXCDriver *driver)
{
- virCapsPtr caps;
- virCapsGuestPtr guest;
+ virCaps *caps;
+ virCapsGuest *guest;
virArch altArch;
g_autofree char *lxc_path = NULL;
/**
* virLXCDriverGetCapabilities:
*
- * Get a reference to the virCapsPtr instance for the
+ * Get a reference to the virCaps *instance for the
* driver. If @refresh is true, the capabilities will be
* rebuilt first
*
* The caller must release the reference with virObjetUnref
*
- * Returns: a reference to a virCapsPtr instance or NULL
+ * Returns: a reference to a virCaps *instance or NULL
*/
-virCapsPtr virLXCDriverGetCapabilities(virLXCDriverPtr driver,
+virCaps *virLXCDriverGetCapabilities(virLXCDriver *driver,
bool refresh)
{
- virCapsPtr ret;
+ virCaps *ret;
if (refresh) {
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
if ((caps = virLXCDriverCapsInit(driver)) == NULL)
return NULL;
}
-virDomainXMLOptionPtr
-lxcDomainXMLConfInit(virLXCDriverPtr driver, const char *defsecmodel)
+virDomainXMLOption *
+lxcDomainXMLConfInit(virLXCDriver *driver, const char *defsecmodel)
{
virLXCDriverDomainDefParserConfig.priv = driver;
virLXCDriverDomainDefParserConfig.defSecModel = defsecmodel;
}
-virLXCDriverConfigPtr
+virLXCDriverConfig *
virLXCDriverConfigNew(void)
{
- virLXCDriverConfigPtr cfg;
+ virLXCDriverConfig *cfg;
if (virLXCConfigInitialize() < 0)
return NULL;
}
int
-virLXCLoadDriverConfig(virLXCDriverConfigPtr cfg,
+virLXCLoadDriverConfig(virLXCDriverConfig *cfg,
const char *filename)
{
g_autoptr(virConf) conf = NULL;
return 0;
}
-virLXCDriverConfigPtr virLXCDriverGetConfig(virLXCDriverPtr driver)
+virLXCDriverConfig *virLXCDriverGetConfig(virLXCDriver *driver)
{
- virLXCDriverConfigPtr cfg;
+ virLXCDriverConfig *cfg;
lxcDriverLock(driver);
cfg = virObjectRef(driver->config);
lxcDriverUnlock(driver);
static void
virLXCDriverConfigDispose(void *obj)
{
- virLXCDriverConfigPtr cfg = obj;
+ virLXCDriverConfig *cfg = obj;
g_free(cfg->configDir);
g_free(cfg->autostartDir);
#define LXC_AUTOSTART_DIR LXC_CONFIG_DIR "/autostart"
typedef struct _virLXCDriver virLXCDriver;
-typedef virLXCDriver *virLXCDriverPtr;
typedef struct _virLXCDriverConfig virLXCDriverConfig;
-typedef virLXCDriverConfig *virLXCDriverConfigPtr;
-
struct _virLXCDriverConfig {
virObject parent;
/* Require lock to get reference on 'config',
* then lockless thereafter */
- virLXCDriverConfigPtr config;
+ virLXCDriverConfig *config;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
/* Require lock to get a reference on the object,
* lockless access thereafter */
- virCapsPtr caps;
+ virCaps *caps;
/* Immutable pointer, Immutable object */
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
/* Immutable pointer, lockless APIs */
- virSysinfoDefPtr hostsysinfo;
+ virSysinfoDef *hostsysinfo;
/* Atomic inc/dec only */
unsigned int nactive;
void *inhibitOpaque;
/* Immutable pointer, self-locking APIs */
- virDomainObjListPtr domains;
+ virDomainObjList *domains;
- virHostdevManagerPtr hostdevMgr;
+ virHostdevManager *hostdevMgr;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr domainEventState;
+ virObjectEventState *domainEventState;
/* Immutable pointer. self-locking APIs */
- virSecurityManagerPtr securityManager;
+ virSecurityManager *securityManager;
/* Immutable pointer, self-locking APIs */
- virCloseCallbacksPtr closeCallbacks;
+ virCloseCallbacks *closeCallbacks;
};
-virLXCDriverConfigPtr virLXCDriverConfigNew(void);
-virLXCDriverConfigPtr virLXCDriverGetConfig(virLXCDriverPtr driver);
-int virLXCLoadDriverConfig(virLXCDriverConfigPtr cfg,
+virLXCDriverConfig *virLXCDriverConfigNew(void);
+virLXCDriverConfig *virLXCDriverGetConfig(virLXCDriver *driver);
+int virLXCLoadDriverConfig(virLXCDriverConfig *cfg,
const char *filename);
-virCapsPtr virLXCDriverCapsInit(virLXCDriverPtr driver);
-virCapsPtr virLXCDriverGetCapabilities(virLXCDriverPtr driver,
+virCaps *virLXCDriverCapsInit(virLXCDriver *driver);
+virCaps *virLXCDriverGetCapabilities(virLXCDriver *driver,
bool refresh);
-virDomainXMLOptionPtr lxcDomainXMLConfInit(virLXCDriverPtr driver,
+virDomainXMLOption *lxcDomainXMLConfInit(virLXCDriver *driver,
const char *defsecmodel);
-static inline void lxcDriverLock(virLXCDriverPtr driver)
+static inline void lxcDriverLock(virLXCDriver *driver)
{
virMutexLock(&driver->lock);
}
-static inline void lxcDriverUnlock(virLXCDriverPtr driver)
+static inline void lxcDriverUnlock(virLXCDriver *driver)
{
virMutexUnlock(&driver->lock);
}
typedef struct __lxc_child_argv lxc_child_argv_t;
struct __lxc_child_argv {
- virDomainDefPtr config;
- virSecurityManagerPtr securityDriver;
+ virDomainDef *config;
+ virSecurityManager *securityDriver;
size_t nveths;
char **veths;
int monitor;
int *nsInheritFDs;
};
-static int lxcContainerMountFSBlock(virDomainFSDefPtr fs,
+static int lxcContainerMountFSBlock(virDomainFSDef *fs,
const char *srcprefix,
const char *sec_mount_options);
* lxcContainerBuildInitCmd:
* @vmDef: pointer to vm definition structure
*
- * Build a virCommandPtr for launching the container 'init' process
+ * Build a virCommand *for launching the container 'init' process
*
- * Returns a virCommandPtr
+ * Returns a virCommand *
*/
-static virCommandPtr lxcContainerBuildInitCmd(virDomainDefPtr vmDef,
+static virCommand *lxcContainerBuildInitCmd(virDomainDef *vmDef,
char **ttyPaths,
size_t nttyPaths)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virCommandPtr cmd;
+ virCommand *cmd;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
*
* Returns 0 on success or -1 in case of error
*/
-static int lxcContainerSetID(virDomainDefPtr def)
+static int lxcContainerSetID(virDomainDef *def)
{
/* Only call virSetUIDGID when user namespace is enabled
* for this container. And user namespace is only enabled
}
-static virDomainNetDefPtr
-lxcContainerGetNetDef(virDomainDefPtr vmDef, const char *devName)
+static virDomainNetDef *
+lxcContainerGetNetDef(virDomainDef *vmDef, const char *devName)
{
size_t i;
- virDomainNetDefPtr netDef;
+ virDomainNetDef *netDef;
for (i = 0; i < vmDef->nnets; i++) {
netDef = vmDef->nets[i];
* Returns 0 on success or nonzero in case of error
*/
static int
-lxcContainerRenameAndEnableInterfaces(virDomainDefPtr vmDef,
+lxcContainerRenameAndEnableInterfaces(virDomainDef *vmDef,
size_t nveths,
char **veths)
{
size_t i;
const char *newname;
- virDomainNetDefPtr netDef;
+ virDomainNetDef *netDef;
bool privNet = vmDef->features[VIR_DOMAIN_FEATURE_PRIVNET] ==
VIR_TRISTATE_SWITCH_ON;
return ret;
}
-static int lxcContainerResolveSymlinks(virDomainFSDefPtr fs, bool gentle)
+static int lxcContainerResolveSymlinks(virDomainFSDef *fs, bool gentle)
{
char *newroot;
return 0;
}
-static int lxcContainerPrepareRoot(virDomainDefPtr def,
- virDomainFSDefPtr root,
+static int lxcContainerPrepareRoot(virDomainDef *def,
+ virDomainFSDef *root,
const char *sec_mount_options)
{
g_autofree char *dst = NULL;
return 0;
}
-static int lxcContainerPivotRoot(virDomainFSDefPtr root)
+static int lxcContainerPivotRoot(virDomainFSDef *root)
{
g_autofree char *oldroot = NULL;
g_autofree char *newroot = NULL;
}
#if WITH_FUSE
-static int lxcContainerMountProcFuse(virDomainDefPtr def,
+static int lxcContainerMountProcFuse(virDomainDef *def,
const char *stateDir)
{
g_autofree char *meminfo_path = NULL;
return 0;
}
#else
-static int lxcContainerMountProcFuse(virDomainDefPtr def G_GNUC_UNUSED,
+static int lxcContainerMountProcFuse(virDomainDef *def G_GNUC_UNUSED,
const char *stateDir G_GNUC_UNUSED)
{
return 0;
}
#endif
-static int lxcContainerMountFSDev(virDomainDefPtr def,
+static int lxcContainerMountFSDev(virDomainDef *def,
const char *stateDir)
{
g_autofree char *path = NULL;
return 0;
}
-static int lxcContainerMountFSDevPTS(virDomainDefPtr def,
+static int lxcContainerMountFSDevPTS(virDomainDef *def,
const char *stateDir)
{
g_autofree char *path = NULL;
}
-static int lxcContainerMountFSBind(virDomainFSDefPtr fs,
+static int lxcContainerMountFSBind(virDomainFSDef *fs,
const char *srcprefix)
{
g_autofree char *src = NULL;
* libblkid to detect the format first. We go straight to using
* /etc/filesystems, and then /proc/filesystems
*/
-static int lxcContainerMountFSBlockAuto(virDomainFSDefPtr fs,
+static int lxcContainerMountFSBlockAuto(virDomainFSDef *fs,
int fsflags,
const char *src,
const char *srcprefix,
* Mount a block device 'src' on fs->dst, automatically
* probing for filesystem type
*/
-static int lxcContainerMountFSBlockHelper(virDomainFSDefPtr fs,
+static int lxcContainerMountFSBlockHelper(virDomainFSDef *fs,
const char *src,
const char *srcprefix,
const char *sec_mount_options)
}
-static int lxcContainerMountFSBlock(virDomainFSDefPtr fs,
+static int lxcContainerMountFSBlock(virDomainFSDef *fs,
const char *srcprefix,
const char *sec_mount_options)
{
}
-static int lxcContainerMountFSTmpfs(virDomainFSDefPtr fs,
+static int lxcContainerMountFSTmpfs(virDomainFSDef *fs,
char *sec_mount_options)
{
g_autofree char *data = NULL;
}
-static int lxcContainerMountFS(virDomainFSDefPtr fs,
+static int lxcContainerMountFS(virDomainFSDef *fs,
char *sec_mount_options)
{
switch (fs->type) {
}
-static int lxcContainerMountAllFS(virDomainDefPtr vmDef,
+static int lxcContainerMountAllFS(virDomainDef *vmDef,
char *sec_mount_options)
{
size_t i;
static bool
-lxcNeedNetworkNamespace(virDomainDefPtr def)
+lxcNeedNetworkNamespace(virDomainDef *def)
{
size_t i;
if (def->nets != NULL)
* approach to do a better-chroot-than-chroot
* this is based on this thread https://lkml.org/lkml/2008/3/5/29
*/
-static int lxcContainerSetupPivotRoot(virDomainDefPtr vmDef,
- virDomainFSDefPtr root,
+static int lxcContainerSetupPivotRoot(virDomainDef *vmDef,
+ virDomainFSDef *root,
char **ttyPaths,
size_t nttyPaths,
- virSecurityManagerPtr securityDriver)
+ virSecurityManager *securityDriver)
{
g_autoptr(virCgroup) cgroup = NULL;
g_autofree char *sec_mount_options = NULL;
return 0;
}
-static int lxcContainerResolveAllSymlinks(virDomainDefPtr vmDef)
+static int lxcContainerResolveAllSymlinks(virDomainDef *vmDef)
{
size_t i;
VIR_DEBUG("Resolving symlinks");
for (i = 0; i < vmDef->nfss; i++) {
- virDomainFSDefPtr fs = vmDef->fss[i];
+ virDomainFSDef *fs = vmDef->fss[i];
/* In the first pass, be gentle as some files may
depend on other filesystems to be mounted */
if (lxcContainerResolveSymlinks(fs, true) < 0)
*/
#if WITH_CAPNG
-static int lxcContainerDropCapabilities(virDomainDefPtr def,
+static int lxcContainerDropCapabilities(virDomainDef *def,
bool keepReboot)
{
int ret;
return 0;
}
#else
-static int lxcContainerDropCapabilities(virDomainDefPtr def G_GNUC_UNUSED,
+static int lxcContainerDropCapabilities(virDomainDef *def G_GNUC_UNUSED,
bool keepReboot G_GNUC_UNUSED)
{
VIR_WARN("libcap-ng support not compiled in, unable to clear capabilities");
*
* The owner of the tty is also changed to the given user.
*/
-static int lxcContainerSetUserGroup(virCommandPtr cmd,
- virDomainDefPtr vmDef,
+static int lxcContainerSetUserGroup(virCommand *cmd,
+ virDomainDef *vmDef,
const char *ttyPath)
{
uid_t uid;
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789-";
-static int lxcContainerSetHostname(virDomainDefPtr def)
+static int lxcContainerSetHostname(virDomainDef *def)
{
g_autofree char *name = NULL;
const char *hostname = NULL;
static int lxcContainerChild(void *data)
{
lxc_child_argv_t *argv = data;
- virDomainDefPtr vmDef = argv->config;
+ virDomainDef *vmDef = argv->config;
int ttyfd = -1;
int ret = -1;
g_autofree char *ttyPath = NULL;
- virDomainFSDefPtr root;
- virCommandPtr cmd = NULL;
+ virDomainFSDef *root;
+ virCommand *cmd = NULL;
int hasReboot;
g_autofree gid_t *groups = NULL;
int ngroups;
return ret;
}
-static int userns_required(virDomainDefPtr def)
+static int userns_required(virDomainDef *def)
{
return def->idmap.uidmap && def->idmap.gidmap;
}
*
* Returns PID of container on success or -1 in case of error
*/
-int lxcContainerStart(virDomainDefPtr def,
- virSecurityManagerPtr securityDriver,
+int lxcContainerStart(virDomainDef *def,
+ virSecurityManager *securityDriver,
size_t nveths,
char **veths,
size_t npassFDs,
return pid;
}
-int lxcContainerChown(virDomainDefPtr def, const char *path)
+int lxcContainerChown(virDomainDef *def, const char *path)
{
uid_t uid;
gid_t gid;
int lxcContainerSendContinue(int control);
int lxcContainerWaitForContinue(int control);
-int lxcContainerStart(virDomainDefPtr def,
- virSecurityManagerPtr securityDriver,
+int lxcContainerStart(virDomainDef *def,
+ virSecurityManager *securityDriver,
size_t nveths,
char **veths,
size_t npassFDs,
virArch lxcContainerGetAlt32bitArch(virArch arch);
-int lxcContainerChown(virDomainDefPtr def, const char *path);
+int lxcContainerChown(virDomainDef *def, const char *path);
bool lxcIsBasicMountLocation(const char *path);
VIR_LOG_INIT("lxc.lxc_controller");
typedef struct _virLXCControllerConsole virLXCControllerConsole;
-typedef virLXCControllerConsole *virLXCControllerConsolePtr;
struct _virLXCControllerConsole {
int hostWatch;
int hostFd; /* PTY FD in the host OS */
size_t fromContLen;
char fromContBuf[1024];
- virNetDaemonPtr daemon;
+ virNetDaemon *daemon;
};
typedef struct _virLXCController virLXCController;
-typedef virLXCController *virLXCControllerPtr;
struct _virLXCController {
char *name;
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virDomainObj *vm;
+ virDomainDef *def;
int handshakeFd;
int *nsFDs;
size_t nconsoles;
- virLXCControllerConsolePtr consoles;
+ virLXCControllerConsole *consoles;
char *devptmx;
size_t nloopDevs;
int *loopDevFds;
- virSecurityManagerPtr securityManager;
+ virSecurityManager *securityManager;
- virNetDaemonPtr daemon;
+ virNetDaemon *daemon;
bool firstClient;
- virNetServerClientPtr client;
- virNetServerProgramPtr prog;
+ virNetServerClient *client;
+ virNetServerProgram *prog;
bool inShutdown;
int timerShutdown;
- virCgroupPtr cgroup;
+ virCgroup *cgroup;
- virLXCFusePtr fuse;
+ struct virLXCFuse *fuse;
};
#include "lxc_controller_dispatch.h"
-static void virLXCControllerFree(virLXCControllerPtr ctrl);
-static int virLXCControllerEventSendInit(virLXCControllerPtr ctrl,
+static void virLXCControllerFree(virLXCController *ctrl);
+static int virLXCControllerEventSendInit(virLXCController *ctrl,
pid_t initpid);
static void virLXCControllerQuitTimer(int timer G_GNUC_UNUSED, void *opaque)
{
- virLXCControllerPtr ctrl = opaque;
+ virLXCController *ctrl = opaque;
VIR_DEBUG("Triggering event loop quit");
virNetDaemonQuit(ctrl->daemon);
}
-static virLXCDriverPtr
+static virLXCDriver *
virLXCControllerDriverNew(void)
{
- virLXCDriverPtr driver = g_new0(virLXCDriver, 1);
+ virLXCDriver *driver = g_new0(virLXCDriver, 1);
if (virMutexInit(&driver->lock) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static void
-virLXCControllerDriverFree(virLXCDriverPtr driver)
+virLXCControllerDriverFree(virLXCDriver *driver)
{
if (!driver)
return;
}
-static virLXCControllerPtr virLXCControllerNew(const char *name)
+static virLXCController *virLXCControllerNew(const char *name)
{
- virLXCControllerPtr ctrl = g_new0(virLXCController, 1);
- virLXCDriverPtr driver = NULL;
+ virLXCController *ctrl = g_new0(virLXCController, 1);
+ virLXCDriver *driver = NULL;
g_autofree char *configFile = NULL;
ctrl->timerShutdown = -1;
}
-static int virLXCControllerCloseLoopDevices(virLXCControllerPtr ctrl)
+static int virLXCControllerCloseLoopDevices(virLXCController *ctrl)
{
size_t i;
}
-static void virLXCControllerStopInit(virLXCControllerPtr ctrl)
+static void virLXCControllerStopInit(virLXCController *ctrl)
{
if (ctrl->initpid == 0)
return;
}
-static void virLXCControllerConsoleClose(virLXCControllerConsolePtr console)
+static void virLXCControllerConsoleClose(virLXCControllerConsole *console)
{
if (console->hostWatch != -1)
virEventRemoveHandle(console->hostWatch);
static void
-virLXCControllerFreeFuse(virLXCControllerPtr ctrl)
+virLXCControllerFreeFuse(virLXCController *ctrl)
{
return lxcFreeFuse(&ctrl->fuse);
}
-static void virLXCControllerFree(virLXCControllerPtr ctrl)
+static void virLXCControllerFree(virLXCController *ctrl)
{
size_t i;
}
-static int virLXCControllerAddConsole(virLXCControllerPtr ctrl,
+static int virLXCControllerAddConsole(virLXCController *ctrl,
int hostFd)
{
VIR_EXPAND_N(ctrl->consoles, ctrl->nconsoles, 1);
}
-static int virLXCControllerConsoleSetNonblocking(virLXCControllerConsolePtr console)
+static int virLXCControllerConsoleSetNonblocking(virLXCControllerConsole *console)
{
if (virSetBlocking(console->hostFd, false) < 0 ||
virSetBlocking(console->contFd, false) < 0) {
}
-static int virLXCControllerDaemonHandshake(virLXCControllerPtr ctrl)
+static int virLXCControllerDaemonHandshake(virLXCController *ctrl)
{
if (lxcContainerSendContinue(ctrl->handshakeFd) < 0) {
virReportSystemError(errno, "%s",
}
-static int virLXCControllerValidateNICs(virLXCControllerPtr ctrl)
+static int virLXCControllerValidateNICs(virLXCController *ctrl)
{
if (ctrl->def->nnets != ctrl->nveths) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
-static int virLXCControllerGetNICIndexes(virLXCControllerPtr ctrl)
+static int virLXCControllerGetNICIndexes(virLXCController *ctrl)
{
size_t i;
}
-static int virLXCControllerValidateConsoles(virLXCControllerPtr ctrl)
+static int virLXCControllerValidateConsoles(virLXCController *ctrl)
{
if (ctrl->def->nconsoles != ctrl->nconsoles) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
-static int virLXCControllerSetupLoopDeviceFS(virDomainFSDefPtr fs)
+static int virLXCControllerSetupLoopDeviceFS(virDomainFSDef *fs)
{
int lofd;
char *loname = NULL;
}
-static int virLXCControllerSetupLoopDeviceDisk(virDomainDiskDefPtr disk)
+static int virLXCControllerSetupLoopDeviceDisk(virDomainDiskDef *disk)
{
int lofd;
g_autofree char *loname = NULL;
}
-static int virLXCControllerSetupNBDDeviceFS(virDomainFSDefPtr fs)
+static int virLXCControllerSetupNBDDeviceFS(virDomainFSDef *fs)
{
char *dev;
}
-static int virLXCControllerSetupNBDDeviceDisk(virDomainDiskDefPtr disk)
+static int virLXCControllerSetupNBDDeviceDisk(virDomainDiskDef *disk)
{
g_autofree char *dev = NULL;
const char *src = virDomainDiskGetSource(disk);
return 0;
}
-static int virLXCControllerAppendNBDPids(virLXCControllerPtr ctrl,
+static int virLXCControllerAppendNBDPids(virLXCController *ctrl,
const char *dev)
{
g_autofree char *pidpath = NULL;
return 0;
}
-static int virLXCControllerSetupLoopDevices(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupLoopDevices(virLXCController *ctrl)
{
size_t i;
VIR_DEBUG("Setting up loop devices for filesystems");
for (i = 0; i < ctrl->def->nfss; i++) {
- virDomainFSDefPtr fs = ctrl->def->fss[i];
+ virDomainFSDef *fs = ctrl->def->fss[i];
int fd;
if (fs->type != VIR_DOMAIN_FS_TYPE_FILE)
VIR_DEBUG("Setting up loop devices for disks");
for (i = 0; i < ctrl->def->ndisks; i++) {
- virDomainDiskDefPtr disk = ctrl->def->disks[i];
+ virDomainDiskDef *disk = ctrl->def->disks[i];
int fd;
const char *driver = virDomainDiskGetDriver(disk);
int format = virDomainDiskGetFormat(disk);
/*
* To be run while still single threaded
*/
-static int virLXCControllerSetupCpuAffinity(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupCpuAffinity(virLXCController *ctrl)
{
int hostcpus, maxcpu = CPU_SETSIZE;
- virBitmapPtr cpumap;
- virBitmapPtr cpumapToSet;
+ virBitmap *cpumap;
+ virBitmap *cpumapToSet;
VIR_DEBUG("Setting CPU affinity");
}
-static int virLXCControllerGetNumadAdvice(virLXCControllerPtr ctrl,
- virBitmapPtr *mask)
+static int virLXCControllerGetNumadAdvice(virLXCController *ctrl,
+ virBitmap **mask)
{
- virBitmapPtr nodemask = NULL;
+ virBitmap *nodemask = NULL;
g_autofree char *nodeset = NULL;
/* Get the advisory nodeset from numad if 'placement' of
*
* Returns 0 on success or -1 in case of error
*/
-static int virLXCControllerSetupResourceLimits(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupResourceLimits(virLXCController *ctrl)
{
- virBitmapPtr auto_nodeset = NULL;
+ virBitmap *auto_nodeset = NULL;
int ret = -1;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
virDomainNumatuneMemMode mode;
if (virDomainNumatuneGetMode(ctrl->def->numa, -1, &mode) == 0) {
* Creates the cgroup and sets up the various limits associated
* with it
*/
-static int virLXCControllerSetupCgroupLimits(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupCgroupLimits(virLXCController *ctrl)
{
- virBitmapPtr auto_nodeset = NULL;
+ virBitmap *auto_nodeset = NULL;
int ret = -1;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
size_t i;
VIR_DEBUG("Setting up cgroup resource limits");
}
-static void virLXCControllerClientCloseHook(virNetServerClientPtr client)
+static void virLXCControllerClientCloseHook(virNetServerClient *client)
{
- virLXCControllerPtr ctrl = virNetServerClientGetPrivateData(client);
+ virLXCController *ctrl = virNetServerClientGetPrivateData(client);
VIR_DEBUG("Client %p has closed", client);
if (ctrl->client == client)
static void virLXCControllerClientPrivateFree(void *data)
{
- virLXCControllerPtr ctrl = data;
+ virLXCController *ctrl = data;
VIR_DEBUG("Got private data free %p", ctrl);
}
-static void *virLXCControllerClientPrivateNew(virNetServerClientPtr client,
+static void *virLXCControllerClientPrivateNew(virNetServerClient *client,
void *opaque)
{
- virLXCControllerPtr ctrl = opaque;
+ virLXCController *ctrl = opaque;
virNetServerClientSetCloseHook(client, virLXCControllerClientCloseHook);
VIR_DEBUG("Got new client %p", client);
}
-static int virLXCControllerSetupServer(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupServer(virLXCController *ctrl)
{
- virNetServerPtr srv = NULL;
- virNetServerServicePtr svc = NULL;
+ virNetServer *srv = NULL;
+ virNetServerService *svc = NULL;
g_autofree char *sockpath = NULL;
sockpath = g_strdup_printf("%s/%s.sock", LXC_STATE_DIR, ctrl->name);
static virMutex lock = VIR_MUTEX_INITIALIZER;
-static void virLXCControllerSignalChildIO(virNetDaemonPtr dmn,
+static void virLXCControllerSignalChildIO(virNetDaemon *dmn,
siginfo_t *info G_GNUC_UNUSED,
void *opaque)
{
- virLXCControllerPtr ctrl = opaque;
+ virLXCController *ctrl = opaque;
int ret;
int status;
}
-static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsolePtr console)
+static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsole *console)
{
int hostEvents = 0;
int contEvents = 0;
static void virLXCControllerConsoleEPoll(int watch, int fd, int events, void *opaque)
{
- virLXCControllerConsolePtr console = opaque;
+ virLXCControllerConsole *console = opaque;
virMutexLock(&lock);
VIR_DEBUG("IO event watch=%d fd=%d events=%d fromHost=%zu fromcont=%zu",
static void virLXCControllerConsoleIO(int watch, int fd, int events, void *opaque)
{
- virLXCControllerConsolePtr console = opaque;
+ virLXCControllerConsole *console = opaque;
virMutexLock(&lock);
VIR_DEBUG("IO event watch=%d fd=%d events=%d fromHost=%zu fromcont=%zu",
*
* Returns 0 on success or -1 in case of error
*/
-static int virLXCControllerMain(virLXCControllerPtr ctrl)
+static int virLXCControllerMain(virLXCController *ctrl)
{
int rc = -1;
size_t i;
}
static unsigned int
-virLXCControllerLookupUsernsMap(virDomainIdMapEntryPtr map,
+virLXCControllerLookupUsernsMap(virDomainIdMapEntry *map,
int num,
unsigned int src)
{
}
static int
-virLXCControllerSetupUsernsMap(virDomainIdMapEntryPtr map,
+virLXCControllerSetupUsernsMap(virDomainIdMapEntry *map,
int num,
char *path)
{
*
* Returns 0 on success or -1 in case of error
*/
-static int virLXCControllerSetupUserns(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupUserns(virLXCController *ctrl)
{
g_autofree char *uid_map = NULL;
g_autofree char *gid_map = NULL;
return 0;
}
-static int virLXCControllerSetupDev(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupDev(virLXCController *ctrl)
{
g_autofree char *mount_options = NULL;
g_autofree char *opts = NULL;
return 0;
}
-static int virLXCControllerPopulateDevices(virLXCControllerPtr ctrl)
+static int virLXCControllerPopulateDevices(virLXCController *ctrl)
{
size_t i;
const struct {
static int
-virLXCControllerSetupTimers(virLXCControllerPtr ctrl)
+virLXCControllerSetupTimers(virLXCController *ctrl)
{
- virDomainDefPtr def = ctrl->def;
+ virDomainDef *def = ctrl->def;
size_t i;
/* Not sync'ed with Host clock */
return 0;
for (i = 0; i < def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = def->clock.timers[i];
+ virDomainTimerDef *timer = def->clock.timers[i];
g_autofree char *path = NULL;
const char *timer_dev = NULL;
struct stat sb;
static int
-virLXCControllerSetupHostdevSubsysUSB(virDomainDefPtr vmDef,
- virDomainHostdevDefPtr def,
- virSecurityManagerPtr securityDriver)
+virLXCControllerSetupHostdevSubsysUSB(virDomainDef *vmDef,
+ virDomainHostdevDef *def,
+ virSecurityManager *securityDriver)
{
g_autofree char *src = NULL;
g_autofree char *dstdir = NULL;
g_autofree char *vroot = NULL;
struct stat sb;
mode_t mode;
- virDomainHostdevSubsysUSBPtr usbsrc = &def->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *usbsrc = &def->source.subsys.u.usb;
src = g_strdup_printf(USB_DEVFS "/%03d/%03d", usbsrc->bus, usbsrc->device);
static int
-virLXCControllerSetupHostdevCapsStorage(virDomainDefPtr vmDef,
- virDomainHostdevDefPtr def,
- virSecurityManagerPtr securityDriver)
+virLXCControllerSetupHostdevCapsStorage(virDomainDef *vmDef,
+ virDomainHostdevDef *def,
+ virSecurityManager *securityDriver)
{
g_autofree char *dst = NULL;
g_autofree char *path = NULL;
static int
-virLXCControllerSetupHostdevCapsMisc(virDomainDefPtr vmDef,
- virDomainHostdevDefPtr def,
- virSecurityManagerPtr securityDriver)
+virLXCControllerSetupHostdevCapsMisc(virDomainDef *vmDef,
+ virDomainHostdevDef *def,
+ virSecurityManager *securityDriver)
{
g_autofree char *dst = NULL;
g_autofree char *path = NULL;
}
static int
-virLXCControllerSetupHostdevSubsys(virDomainDefPtr vmDef,
- virDomainHostdevDefPtr def,
- virSecurityManagerPtr securityDriver)
+virLXCControllerSetupHostdevSubsys(virDomainDef *vmDef,
+ virDomainHostdevDef *def,
+ virSecurityManager *securityDriver)
{
switch (def->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
static int
-virLXCControllerSetupHostdevCaps(virDomainDefPtr vmDef,
- virDomainHostdevDefPtr def,
- virSecurityManagerPtr securityDriver)
+virLXCControllerSetupHostdevCaps(virDomainDef *vmDef,
+ virDomainHostdevDef *def,
+ virSecurityManager *securityDriver)
{
switch (def->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_CAPS_TYPE_STORAGE:
static int
-virLXCControllerSetupAllHostdevs(virLXCControllerPtr ctrl)
+virLXCControllerSetupAllHostdevs(virLXCController *ctrl)
{
size_t i;
- virDomainDefPtr vmDef = ctrl->def;
- virSecurityManagerPtr securityDriver = ctrl->securityManager;
+ virDomainDef *vmDef = ctrl->def;
+ virSecurityManager *securityDriver = ctrl->securityManager;
VIR_DEBUG("Setting up hostdevs");
for (i = 0; i < vmDef->nhostdevs; i++) {
- virDomainHostdevDefPtr def = vmDef->hostdevs[i];
+ virDomainHostdevDef *def = vmDef->hostdevs[i];
switch (def->mode) {
case VIR_DOMAIN_HOSTDEV_MODE_SUBSYS:
if (virLXCControllerSetupHostdevSubsys(vmDef,
}
-static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
- virDomainDiskDefPtr def,
- virSecurityManagerPtr securityDriver)
+static int virLXCControllerSetupDisk(virLXCController *ctrl,
+ virDomainDiskDef *def,
+ virSecurityManager *securityDriver)
{
g_autofree char *dst = NULL;
int ret = -1;
return ret;
}
-static int virLXCControllerSetupAllDisks(virLXCControllerPtr ctrl)
+static int virLXCControllerSetupAllDisks(virLXCController *ctrl)
{
size_t i;
VIR_DEBUG("Setting up disks");
*
* Returns 0 on success or -1 in case of error
*/
-static int virLXCControllerMoveInterfaces(virLXCControllerPtr ctrl)
+static int virLXCControllerMoveInterfaces(virLXCController *ctrl)
{
size_t i;
- virDomainDefPtr def = ctrl->def;
+ virDomainDef *def = ctrl->def;
for (i = 0; i < ctrl->nveths; i++) {
if (virNetDevSetNamespace(ctrl->veths[i], ctrl->initpid) < 0)
}
for (i = 0; i < def->nhostdevs; i ++) {
- virDomainHostdevDefPtr hdev = def->hostdevs[i];
+ virDomainHostdevDef *hdev = def->hostdevs[i];
virDomainHostdevCaps hdcaps;
if (hdev->mode != VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES)
*
* Returns 0 on success or -1 in case of error
*/
-static int virLXCControllerDeleteInterfaces(virLXCControllerPtr ctrl)
+static int virLXCControllerDeleteInterfaces(virLXCController *ctrl)
{
size_t i;
int ret = 0;
}
-static int lxcSetPersonality(virDomainDefPtr def)
+static int lxcSetPersonality(virDomainDef *def)
{
virArch altArch;
* @ttyName. Heavily borrowed from glibc, but doesn't require that
* devpts == "/dev/pts" */
static int
-lxcCreateTty(virLXCControllerPtr ctrl, int *ttyprimary,
+lxcCreateTty(virLXCController *ctrl, int *ttyprimary,
char **ttyName, char **ttyHostPath)
{
int ret = -1;
static int
-virLXCControllerSetupDevPTS(virLXCControllerPtr ctrl)
+virLXCControllerSetupDevPTS(virLXCController *ctrl)
{
g_autofree char *mount_options = NULL;
g_autofree char *opts = NULL;
static int
-virLXCControllerSetupFuse(virLXCControllerPtr ctrl)
+virLXCControllerSetupFuse(virLXCController *ctrl)
{
return lxcSetupFuse(&ctrl->fuse, ctrl->def);
}
static int
-virLXCControllerStartFuse(virLXCControllerPtr ctrl)
+virLXCControllerStartFuse(virLXCController *ctrl)
{
return lxcStartFuse(ctrl->fuse);
}
static int
-virLXCControllerSetupConsoles(virLXCControllerPtr ctrl,
+virLXCControllerSetupConsoles(virLXCController *ctrl,
char **containerTTYPaths)
{
size_t i;
static void
-virLXCControllerEventSend(virLXCControllerPtr ctrl,
+virLXCControllerEventSend(virLXCController *ctrl,
int procnr,
xdrproc_t proc,
void *data)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
if (!ctrl->client) {
VIR_WARN("Dropping event %d because libvirtd is not connected", procnr);
static int
-virLXCControllerEventSendExit(virLXCControllerPtr ctrl,
+virLXCControllerEventSendExit(virLXCController *ctrl,
int exitstatus)
{
virLXCMonitorExitEventMsg msg;
static int
-virLXCControllerEventSendInit(virLXCControllerPtr ctrl,
+virLXCControllerEventSendInit(virLXCController *ctrl,
pid_t initpid)
{
virLXCMonitorInitEventMsg msg;
static int
-virLXCControllerRun(virLXCControllerPtr ctrl)
+virLXCControllerRun(virLXCController *ctrl)
{
int rc = -1;
int control[2] = { -1, -1};
size_t nttyFDs = 0;
g_autofree int *passFDs = NULL;
size_t npassFDs = 0;
- virLXCControllerPtr ctrl = NULL;
+ virLXCController *ctrl = NULL;
size_t i;
const char *securityDriver = "none";
VIR_LOG_INIT("lxc.lxc_domain");
static int
-virLXCDomainObjInitJob(virLXCDomainObjPrivatePtr priv)
+virLXCDomainObjInitJob(virLXCDomainObjPrivate *priv)
{
memset(&priv->job, 0, sizeof(priv->job));
}
static void
-virLXCDomainObjResetJob(virLXCDomainObjPrivatePtr priv)
+virLXCDomainObjResetJob(virLXCDomainObjPrivate *priv)
{
struct virLXCDomainJobObj *job = &priv->job;
}
static void
-virLXCDomainObjFreeJob(virLXCDomainObjPrivatePtr priv)
+virLXCDomainObjFreeJob(virLXCDomainObjPrivate *priv)
{
ignore_value(virCondDestroy(&priv->job.cond));
}
#define LXC_JOB_WAIT_TIME (1000ull * 30)
/*
- * obj must be locked before calling, virLXCDriverPtr must NOT be locked
+ * obj must be locked before calling, virLXCDriver *must NOT be locked
*
* This must be called by anything that will change the VM state
* in any way
* Successful calls must be followed by EndJob eventually.
*/
int
-virLXCDomainObjBeginJob(virLXCDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr obj,
+virLXCDomainObjBeginJob(virLXCDriver *driver G_GNUC_UNUSED,
+ virDomainObj *obj,
enum virLXCDomainJob job)
{
- virLXCDomainObjPrivatePtr priv = obj->privateData;
+ virLXCDomainObjPrivate *priv = obj->privateData;
unsigned long long now;
unsigned long long then;
* earlier virLXCDomainBeginJob() call
*/
void
-virLXCDomainObjEndJob(virLXCDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr obj)
+virLXCDomainObjEndJob(virLXCDriver *driver G_GNUC_UNUSED,
+ virDomainObj *obj)
{
- virLXCDomainObjPrivatePtr priv = obj->privateData;
+ virLXCDomainObjPrivate *priv = obj->privateData;
enum virLXCDomainJob job = priv->job.active;
VIR_DEBUG("Stopping job: %s",
static void *
virLXCDomainObjPrivateAlloc(void *opaque G_GNUC_UNUSED)
{
- virLXCDomainObjPrivatePtr priv = g_new0(virLXCDomainObjPrivate, 1);
+ virLXCDomainObjPrivate *priv = g_new0(virLXCDomainObjPrivate, 1);
if (virLXCDomainObjInitJob(priv) < 0) {
g_free(priv);
static void
virLXCDomainObjPrivateFree(void *data)
{
- virLXCDomainObjPrivatePtr priv = data;
+ virLXCDomainObjPrivate *priv = data;
virCgroupFree(priv->cgroup);
virLXCDomainObjFreeJob(priv);
lxcDomainDefNamespaceFree(void *nsdata)
{
size_t i;
- lxcDomainDefPtr lxcDef = nsdata;
+ lxcDomainDef *lxcDef = nsdata;
if (!lxcDef)
return;
lxcDomainDefNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- lxcDomainDefPtr lxcDef = NULL;
+ lxcDomainDef *lxcDef = NULL;
g_autofree xmlNodePtr *nodes = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
int n;
static int
-lxcDomainDefNamespaceFormatXML(virBufferPtr buf,
+lxcDomainDefNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
- lxcDomainDefPtr lxcDef = nsdata;
+ lxcDomainDef *lxcDef = nsdata;
size_t i;
if (!lxcDef)
static int
-virLXCDomainObjPrivateXMLFormat(virBufferPtr buf,
- virDomainObjPtr vm)
+virLXCDomainObjPrivateXMLFormat(virBuffer *buf,
+ virDomainObj *vm)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
virBufferAsprintf(buf, "<init pid='%lld'/>\n",
(long long)priv->initpid);
static int
virLXCDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
- virDomainObjPtr vm,
- virDomainDefParserConfigPtr config G_GNUC_UNUSED)
+ virDomainObj *vm,
+ virDomainDefParserConfig *config G_GNUC_UNUSED)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
long long thepid;
if (virXPathLongLong("string(./init[1]/@pid)", ctxt, &thepid) < 0) {
};
static int
-virLXCDomainDefPostParse(virDomainDefPtr def,
+virLXCDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- virLXCDriverPtr driver = opaque;
+ virLXCDriver *driver = opaque;
g_autoptr(virCaps) caps = virLXCDriverGetCapabilities(driver, false);
if (!caps)
return -1;
static int
-virLXCDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+virLXCDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
char *
-virLXCDomainGetMachineName(virDomainDefPtr def, pid_t pid)
+virLXCDomainGetMachineName(virDomainDef *def, pid_t pid)
{
char *ret = NULL;
int
-virLXCDomainSetRunlevel(virDomainObjPtr vm,
+virLXCDomainSetRunlevel(virDomainObj *vm,
int runlevel)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
lxcDomainInitctlCallbackData data;
size_t nfifos = 0;
size_t i;
VIR_ENUM_DECL(virLXCDomainNamespaceSource);
typedef struct _lxcDomainDef lxcDomainDef;
-typedef lxcDomainDef *lxcDomainDefPtr;
struct _lxcDomainDef {
int ns_source[VIR_LXC_DOMAIN_NAMESPACE_LAST]; /* virLXCDomainNamespaceSource */
char *ns_val[VIR_LXC_DOMAIN_NAMESPACE_LAST];
typedef struct _virLXCDomainObjPrivate virLXCDomainObjPrivate;
-typedef virLXCDomainObjPrivate *virLXCDomainObjPrivatePtr;
struct _virLXCDomainObjPrivate {
- virLXCMonitorPtr monitor;
+ virLXCMonitor *monitor;
bool doneStopEvent;
int stopReason;
bool wantReboot;
pid_t initpid;
- virCgroupPtr cgroup;
+ virCgroup *cgroup;
char *machineName;
struct virLXCDomainJobObj job;
extern virDomainDefParserConfig virLXCDriverDomainDefParserConfig;
int
-virLXCDomainObjBeginJob(virLXCDriverPtr driver,
- virDomainObjPtr obj,
+virLXCDomainObjBeginJob(virLXCDriver *driver,
+ virDomainObj *obj,
enum virLXCDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
void
-virLXCDomainObjEndJob(virLXCDriverPtr driver,
- virDomainObjPtr obj);
+virLXCDomainObjEndJob(virLXCDriver *driver,
+ virDomainObj *obj);
char *
-virLXCDomainGetMachineName(virDomainDefPtr def, pid_t pid);
+virLXCDomainGetMachineName(virDomainDef *def, pid_t pid);
int
-virLXCDomainSetRunlevel(virDomainObjPtr vm,
+virLXCDomainSetRunlevel(virDomainObj *vm,
int runlevel);
virStateInhibitCallback callback,
void *opaque);
static int lxcStateCleanup(void);
-virLXCDriverPtr lxc_driver = NULL;
+virLXCDriver *lxc_driver = NULL;
/**
* lxcDomObjFromDomain:
* @domain: Domain pointer that has to be looked up
*
- * This function looks up @domain and returns the appropriate virDomainObjPtr
+ * This function looks up @domain and returns the appropriate virDomainObj *
* that has to be released by calling virDomainObjEndAPI.
*
* Returns the domain object with incremented reference counter which is locked
* on success, NULL otherwise.
*/
-static virDomainObjPtr
+static virDomainObj *
lxcDomObjFromDomain(virDomainPtr domain)
{
- virDomainObjPtr vm;
- virLXCDriverPtr driver = domain->conn->privateData;
+ virDomainObj *vm;
+ virLXCDriver *driver = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
static virDrvOpenStatus lxcConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int lxcConnectClose(virConnectPtr conn)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
virCloseCallbacksRun(driver->closeCallbacks, conn, driver->domains, driver);
conn->privateData = NULL;
static char *lxcConnectGetCapabilities(virConnectPtr conn) {
- virLXCDriverPtr driver = conn->privateData;
- virCapsPtr caps;
+ virLXCDriver *driver = conn->privateData;
+ virCaps *caps;
char *xml;
if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
static virDomainPtr lxcDomainLookupByID(virConnectPtr conn,
int id)
{
- virLXCDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByID(driver->domains, id);
static virDomainPtr lxcDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virLXCDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByUUID(driver->domains, uuid);
static virDomainPtr lxcDomainLookupByName(virConnectPtr conn,
const char *name)
{
- virLXCDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByName(driver->domains, name);
static int lxcDomainIsActive(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = lxcDomObjFromDomain(dom)))
static int lxcDomainIsPersistent(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = lxcDomObjFromDomain(dom)))
static int lxcDomainIsUpdated(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = lxcDomObjFromDomain(dom)))
static int lxcConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectListDomainsEnsureACL(conn) < 0)
return -1;
static int lxcConnectNumOfDomains(virConnectPtr conn)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectNumOfDomainsEnsureACL(conn) < 0)
return -1;
static int lxcConnectListDefinedDomains(virConnectPtr conn,
char **const names, int nnames)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int lxcConnectNumOfDefinedDomains(virConnectPtr conn)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
return -1;
static virDomainPtr
lxcDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
- virLXCDriverPtr driver = conn->privateData;
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
+ virLXCDriver *driver = conn->privateData;
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
- virObjectEventPtr event = NULL;
- virDomainDefPtr oldDef = NULL;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
- virCapsPtr caps = NULL;
+ virObjectEvent *event = NULL;
+ virDomainDef *oldDef = NULL;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
+ virCaps *caps = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
static int lxcDomainUndefineFlags(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(0, -1);
static int lxcDomainGetInfo(virDomainPtr dom,
virDomainInfoPtr info)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
int *reason,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
static char *lxcDomainGetOSType(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = lxcDomObjFromDomain(dom)))
static unsigned long long
lxcDomainGetMaxMemory(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned long long ret = 0;
if (!(vm = lxcDomObjFromDomain(dom)))
static int lxcDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainObj *vm;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
- virLXCDriverPtr driver = dom->conn->privateData;
- virLXCDriverConfigPtr cfg = NULL;
+ virLXCDomainObjPrivate *priv;
+ virLXCDriver *driver = dom->conn->privateData;
+ virLXCDriverConfig *cfg = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
int nparams,
unsigned int flags)
{
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
- virDomainObjPtr vm = NULL;
- virLXCDomainObjPrivatePtr priv = NULL;
- virLXCDriverConfigPtr cfg = NULL;
- virLXCDriverPtr driver = dom->conn->privateData;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
+ virDomainObj *vm = NULL;
+ virLXCDomainObjPrivate *priv = NULL;
+ virLXCDriverConfig *cfg = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
int *nparams,
unsigned int flags)
{
- virDomainDefPtr persistentDef = NULL;
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
- virLXCDomainObjPrivatePtr priv = NULL;
+ virDomainDef *persistentDef = NULL;
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
+ virLXCDomainObjPrivate *priv = NULL;
unsigned long long val;
int ret = -1;
size_t i;
static char *lxcDomainGetXMLDesc(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
unsigned int flags)
{
char *xml = NULL;
- virDomainDefPtr def = NULL;
- virLXCDriverPtr driver = conn->privateData;
- virCapsPtr caps = virLXCDriverGetCapabilities(driver, false);
+ virDomainDef *def = NULL;
+ virLXCDriver *driver = conn->privateData;
+ virCaps *caps = virLXCDriverGetCapabilities(driver, false);
virCheckFlags(0, NULL);
int *files,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);
int *files,
unsigned int flags)
{
- virLXCDriverPtr driver = conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virLXCDriver *driver = conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
virDomainPtr dom = NULL;
- virObjectEventPtr event = NULL;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
- virCapsPtr caps = NULL;
+ virObjectEvent *event = NULL;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
+ virCaps *caps = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY |
static int lxcDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
memset(seclabel, 0, sizeof(*seclabel));
*
* Comment from Dan Berrange:
*
- * Well the PID as stored in the virDomainObjPtr can't be changed
+ * Well the PID as stored in the virDomainObj *can't be changed
* because you've got a locked object. The OS level PID could have
* exited, though and in extreme circumstances have cycled through all
* PIDs back to ours. We could sanity check that our PID still exists
* LXC monitor hasn't seen SIGHUP/ERR on poll().
*/
if (virDomainObjIsActive(vm)) {
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
if (!priv->initpid) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
static int lxcNodeGetSecurityModel(virConnectPtr conn,
virSecurityModelPtr secmodel)
{
- virLXCDriverPtr driver = conn->privateData;
- virCapsPtr caps = NULL;
+ virLXCDriver *driver = conn->privateData;
+ virCaps *caps = NULL;
int ret = 0;
memset(secmodel, 0, sizeof(*secmodel));
void *opaque,
virFreeCallback freecb)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectDomainEventRegisterEnsureACL(conn) < 0)
return -1;
lxcConnectDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectDomainEventDeregisterEnsureACL(conn) < 0)
return -1;
void *opaque,
virFreeCallback freecb)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
int ret;
if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
lxcConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
lxcDomainDestroyFlags(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
virCheckFlags(0, -1);
}
-static virSecurityManagerPtr
-lxcSecurityInit(virLXCDriverConfigPtr cfg)
+static virSecurityManager *
+lxcSecurityInit(virLXCDriverConfig *cfg)
{
unsigned int flags = VIR_SECURITY_MANAGER_PRIVILEGED;
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
VIR_INFO("lxcSecurityInit %s", cfg->securityDriverName);
virStateInhibitCallback callback G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virLXCDriverConfigPtr cfg = NULL;
+ virLXCDriverConfig *cfg = NULL;
bool autostart = true;
const char *defsecmodel;
return VIR_DRV_STATE_INIT_ERROR;
}
-static void lxcNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
+static void lxcNotifyLoadDomain(virDomainObj *vm, int newVM, void *opaque)
{
- virLXCDriverPtr driver = opaque;
+ virLXCDriver *driver = opaque;
if (newVM) {
- virObjectEventPtr event =
+ virObjectEvent *event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
VIR_DOMAIN_EVENT_DEFINED_ADDED);
static int
lxcStateReload(void)
{
- virLXCDriverConfigPtr cfg = NULL;
+ virLXCDriverConfig *cfg = NULL;
if (!lxc_driver)
return 0;
unsigned int source,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
int *nparams)
{
char *ret = NULL;
- virDomainObjPtr vm;
- virLXCDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ virLXCDomainObjPrivate *priv;
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
static int
-lxcGetVcpuBWLive(virCgroupPtr cgroup, unsigned long long *period,
+lxcGetVcpuBWLive(virCgroup *cgroup, unsigned long long *period,
long long *quota)
{
return virCgroupGetCpuPeriodQuota(cgroup, period, quota);
}
-static int lxcSetVcpuBWLive(virCgroupPtr cgroup, unsigned long long period,
+static int lxcSetVcpuBWLive(virCgroup *cgroup, unsigned long long period,
long long quota)
{
return virCgroupSetupCpuPeriodQuota(cgroup, period, quota);
int nparams,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virCapsPtr caps = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virCaps *caps = NULL;
size_t i;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDefCopy = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDefCopy = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
int rc;
- virLXCDomainObjPrivatePtr priv;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDomainObjPrivate *priv;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int *nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
unsigned long long shares = 0;
unsigned long long period = 0;
long long quota = 0;
int rc;
bool cpu_bw_status = false;
int saved_nparams = 0;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
const char *path,
virDomainBlockStatsPtr stats)
{
- virLXCDriverPtr driver = dom->conn->privateData;
+ virLXCDriver *driver = dom->conn->privateData;
int ret = -1;
- virDomainObjPtr vm;
- virDomainDiskDefPtr disk = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ virDomainDiskDef *disk = NULL;
+ virLXCDomainObjPrivate *priv;
if (!(vm = lxcDomObjFromDomain(dom)))
return ret;
int * nparams,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
+ virLXCDriver *driver = dom->conn->privateData;
int tmp, ret = -1;
- virDomainObjPtr vm;
- virDomainDiskDefPtr disk = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ virDomainDiskDef *disk = NULL;
+ virLXCDomainObjPrivate *priv;
long long rd_req, rd_bytes, wr_req, wr_bytes;
virTypedParameterPtr param;
int nparams,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDriverConfig *cfg = NULL;
+ virLXCDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int *nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int maxparams = LXC_NB_BLKIO_PARAM;
unsigned int val;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
const char *device,
virDomainInterfaceStatsPtr stats)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainNetDefPtr net = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainNetDef *net = NULL;
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
static int lxcDomainGetAutostart(virDomainPtr dom,
int *autostart)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = lxcDomObjFromDomain(dom)))
static int lxcDomainSetAutostart(virDomainPtr dom,
int autostart)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autofree char *configFile = NULL;
g_autofree char *autostartLink = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
return ret;
}
-static int lxcFreezeContainer(virDomainObjPtr vm)
+static int lxcFreezeContainer(virDomainObj *vm)
{
int timeout = 1000; /* In milliseconds */
int check_interval = 1; /* In milliseconds */
int exp = 10;
int waited_time = 0;
g_autofree char *state = NULL;
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
while (waited_time < timeout) {
int r;
static int lxcDomainSuspend(virDomainPtr dom)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
static int lxcDomainResume(virDomainPtr dom)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
int ret = -1;
int state;
- virLXCDomainObjPrivatePtr priv;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDomainObjPrivate *priv;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
if (!(vm = lxcDomObjFromDomain(dom)))
goto cleanup;
virStreamPtr st,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
size_t i;
virCheckFlags(0, -1);
unsigned int signum,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virLXCDomainObjPrivate *priv;
pid_t victim;
int ret = -1;
virDomainPtr **domains,
unsigned int flags)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
lxcDomainShutdownFlags(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virLXCDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
+ virLXCDriver *driver = dom->conn->privateData;
+ virLXCDomainObjPrivate *priv;
+ virDomainObj *vm;
int ret = -1;
int rc = -1;
lxcDomainReboot(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virLXCDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
+ virLXCDriver *driver = dom->conn->privateData;
+ virLXCDomainObjPrivate *priv;
+ virDomainObj *vm;
int ret = -1;
int rc = -1;
static int
-lxcDomainAttachDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev)
{
int ret = -1;
- virDomainDiskDefPtr disk;
- virDomainNetDefPtr net;
- virDomainHostdevDefPtr hostdev;
+ virDomainDiskDef *disk;
+ virDomainNetDef *net;
+ virDomainHostdevDef *hostdev;
switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK:
static int
-lxcDomainUpdateDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev)
+lxcDomainUpdateDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev)
{
int ret = -1;
- virDomainNetDefPtr net;
+ virDomainNetDef *net;
virDomainDeviceDef oldDev = { .type = dev->type };
int idx;
static int
-lxcDomainDetachDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev)
{
int ret = -1;
- virDomainDiskDefPtr disk;
- virDomainDiskDefPtr det_disk;
- virDomainNetDefPtr net;
- virDomainHostdevDefPtr hostdev;
- virDomainHostdevDefPtr det_hostdev;
+ virDomainDiskDef *disk;
+ virDomainDiskDef *det_disk;
+ virDomainNetDef *net;
+ virDomainHostdevDef *hostdev;
+ virDomainHostdevDef *det_hostdev;
int idx;
switch (dev->type) {
struct lxcDomainAttachDeviceMknodData {
- virLXCDriverPtr driver;
+ virLXCDriver *driver;
mode_t mode;
dev_t dev;
- virDomainObjPtr vm;
- virDomainDeviceDefPtr def;
+ virDomainObj *vm;
+ virDomainDeviceDef *def;
char *file;
};
* to actually label the dst here, so hack the config */
switch (data->def->type) {
case VIR_DOMAIN_DEVICE_DISK: {
- virDomainDiskDefPtr def = data->def->data.disk;
+ virDomainDiskDef *def = data->def->data.disk;
char *tmpsrc = def->src->path;
def->src->path = data->file;
if (virSecurityManagerSetImageLabel(data->driver->securityManager,
} break;
case VIR_DOMAIN_DEVICE_HOSTDEV: {
- virDomainHostdevDefPtr def = data->def->data.hostdev;
+ virDomainHostdevDef *def = data->def->data.hostdev;
if (virSecurityManagerSetHostdevLabel(data->driver->securityManager,
data->vm->def, def, NULL) < 0)
goto cleanup;
static int
-lxcDomainAttachDeviceMknod(virLXCDriverPtr driver,
+lxcDomainAttachDeviceMknod(virLXCDriver *driver,
mode_t mode,
dev_t dev,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr def,
+ virDomainObj *vm,
+ virDomainDeviceDef *def,
char *file)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
struct lxcDomainAttachDeviceMknodData data;
memset(&data, 0, sizeof(data));
static int
-lxcDomainAttachDeviceUnlink(virDomainObjPtr vm,
+lxcDomainAttachDeviceUnlink(virDomainObj *vm,
char *file)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
if (virProcessRunInMountNamespace(priv->initpid,
lxcDomainAttachDeviceUnlinkHelper,
static int
-lxcDomainAttachDeviceDiskLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceDiskLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainDiskDefPtr def = dev->data.disk;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainDiskDef *def = dev->data.disk;
int ret = -1;
struct stat sb;
g_autofree char *file = NULL;
perms) < 0)
goto cleanup;
- vm->def->disks = g_renew(virDomainDiskDefPtr,
+ vm->def->disks = g_renew(virDomainDiskDef *,
vm->def->disks,
vm->def->ndisks + 1);
static int
-lxcDomainAttachDeviceNetLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net)
+lxcDomainAttachDeviceNetLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
int ret = -1;
virDomainNetType actualType;
const virNetDevBandwidth *actualBandwidth;
return -1;
/* preallocate new slot for device */
- vm->def->nets = g_renew(virDomainNetDefPtr,
+ vm->def->nets = g_renew(virDomainNetDef *,
vm->def->nets,
vm->def->nnets + 1);
static int
-lxcDomainAttachDeviceHostdevSubsysUSBLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevSubsysUSBLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = dev->data.hostdev;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = dev->data.hostdev;
int ret = -1;
g_autofree char *src = NULL;
struct stat sb;
- virUSBDevicePtr usb = NULL;
- virDomainHostdevSubsysUSBPtr usbsrc;
+ virUSBDevice *usb = NULL;
+ virDomainHostdevSubsysUSB *usbsrc;
if (virDomainHostdevFind(vm->def, def, NULL) >= 0) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
goto cleanup;
}
- vm->def->hostdevs = g_renew(virDomainHostdevDefPtr,
+ vm->def->hostdevs = g_renew(virDomainHostdevDef *,
vm->def->hostdevs,
vm->def->nhostdevs + 1);
static int
-lxcDomainAttachDeviceHostdevStorageLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevStorageLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = dev->data.hostdev;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = dev->data.hostdev;
int ret = -1;
struct stat sb;
goto cleanup;
}
- vm->def->hostdevs = g_renew(virDomainHostdevDefPtr,
+ vm->def->hostdevs = g_renew(virDomainHostdevDef *,
vm->def->hostdevs,
vm->def->nhostdevs + 1);
static int
-lxcDomainAttachDeviceHostdevMiscLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevMiscLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = dev->data.hostdev;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = dev->data.hostdev;
int ret = -1;
struct stat sb;
VIR_CGROUP_DEVICE_RWM) < 0)
goto cleanup;
- vm->def->hostdevs = g_renew(virDomainHostdevDefPtr,
+ vm->def->hostdevs = g_renew(virDomainHostdevDef *,
vm->def->hostdevs,
vm->def->nhostdevs + 1);
static int
-lxcDomainAttachDeviceHostdevSubsysLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevSubsysLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
switch (dev->data.hostdev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
static int
-lxcDomainAttachDeviceHostdevCapsLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevCapsLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
switch (dev->data.hostdev->source.caps.type) {
case VIR_DOMAIN_HOSTDEV_CAPS_TYPE_STORAGE:
static int
-lxcDomainAttachDeviceHostdevLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceHostdevLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
if (!priv->initpid) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
static int
-lxcDomainAttachDeviceLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainAttachDeviceLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int ret = -1;
static int
-lxcDomainDetachDeviceDiskLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceDiskLive(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainDiskDefPtr def = NULL;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainDiskDef *def = NULL;
int idx;
g_autofree char *dst = NULL;
const char *src;
static int
-lxcDomainDetachDeviceNetLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceNetLive(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int detachidx, ret = -1;
virDomainNetType actualType;
- virDomainNetDefPtr detach = NULL;
+ virDomainNetDef *detach = NULL;
const virNetDevVPortProfile *vport = NULL;
virErrorPtr save_err = NULL;
static int
-lxcDomainDetachDeviceHostdevUSBLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevUSBLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = NULL;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = NULL;
int idx, ret = -1;
g_autofree char *dst = NULL;
- virUSBDevicePtr usb = NULL;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
- virDomainHostdevSubsysUSBPtr usbsrc;
+ virUSBDevice *usb = NULL;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
+ virDomainHostdevSubsysUSB *usbsrc;
if ((idx = virDomainHostdevFind(vm->def,
dev->data.hostdev,
static int
-lxcDomainDetachDeviceHostdevStorageLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevStorageLive(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = NULL;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = NULL;
int idx;
if (!priv->initpid) {
static int
-lxcDomainDetachDeviceHostdevMiscLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevMiscLive(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virDomainHostdevDefPtr def = NULL;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virDomainHostdevDef *def = NULL;
int idx;
if (!priv->initpid) {
static int
-lxcDomainDetachDeviceHostdevSubsysLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevSubsysLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
switch (dev->data.hostdev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
static int
-lxcDomainDetachDeviceHostdevCapsLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevCapsLive(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
switch (dev->data.hostdev->source.caps.type) {
case VIR_DOMAIN_HOSTDEV_CAPS_TYPE_STORAGE:
static int
-lxcDomainDetachDeviceHostdevLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceHostdevLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
if (!priv->initpid) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
static int
-lxcDomainDetachDeviceLive(virLXCDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+lxcDomainDetachDeviceLive(virLXCDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int ret = -1;
const char *xml,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL;
- virDomainDeviceDefPtr dev_copy = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *dev = NULL;
+ virDomainDeviceDef *dev_copy = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
const char *xml,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *dev = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
const char *xml,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virCapsPtr caps = NULL;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL;
- virDomainDeviceDefPtr dev_copy = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virCaps *caps = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainDeviceDef *dev = NULL;
+ virDomainDeviceDef *dev_copy = NULL;
int ret = -1;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int **fdlist,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virLXCDomainObjPrivate *priv;
int ret = -1;
size_t nfds = 0;
static char *
lxcConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- virLXCDriverPtr driver = conn->privateData;
+ virLXCDriver *driver = conn->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
unsigned int nr_stats,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
unsigned long long swap_usage;
unsigned long mem_usage;
- virLXCDriverPtr driver = dom->conn->privateData;
+ virLXCDriver *driver = dom->conn->privateData;
virCheckFlags(0, -1);
const char *uri,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virLXCDriverConfigPtr cfg = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virLXCDriverConfig *cfg = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
cfg->configDir, flags);
if (ret == 0) {
- virObjectEventPtr ev = NULL;
+ virObjectEvent *ev = NULL;
ev = virDomainEventMetadataChangeNewFromObj(vm, type, uri);
virObjectEventStateQueue(driver->domainEventState, ev);
}
const char *uri,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = lxcDomObjFromDomain(dom)))
unsigned int ncpus,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
lxcDomainGetHostname(virDomainPtr dom,
unsigned int flags)
{
- virLXCDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virLXCDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
char macaddr[VIR_MAC_STRING_BUFLEN];
g_autoptr(virConnect) conn = NULL;
size_t i, j;
for (i = 0; i < vm->def->nnets; i++) {
g_autoptr(virNetwork) network = NULL;
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
g_autofree virNetworkDHCPLeasePtr *leases = NULL;
int n_leases;
static int
lxcDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
g_autofree char *mempath = NULL;
struct stat sb;
struct fuse_context *context = fuse_get_context();
- virDomainDefPtr def = (virDomainDefPtr)context->private_data;
+ virDomainDef *def = (virDomainDef *)context->private_data;
memset(stbuf, 0, sizeof(struct stat));
mempath = g_strdup_printf("/proc/%s", path);
return res;
}
-static int lxcProcReadMeminfo(char *hostpath, virDomainDefPtr def,
+static int lxcProcReadMeminfo(char *hostpath, virDomainDef *def,
char *buf, size_t size, off_t offset)
{
int res;
size_t n;
struct virLXCMeminfo meminfo;
g_auto(virBuffer) buffer = VIR_BUFFER_INITIALIZER;
- virBufferPtr new_meminfo = &buffer;
+ virBuffer *new_meminfo = &buffer;
if (virLXCCgroupGetMeminfo(&meminfo) < 0) {
virErrorSetErrnoFromLastError();
int res = -ENOENT;
g_autofree char *hostpath = NULL;
struct fuse_context *context = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
hostpath = g_strdup_printf("/proc/%s", path);
context = fuse_get_context();
- def = (virDomainDefPtr)context->private_data;
+ def = (virDomainDef *)context->private_data;
if (STREQ(path, fuse_meminfo_path)) {
if ((res = lxcProcReadMeminfo(hostpath, def, buf, size, offset)) < 0)
.read = lxcProcRead,
};
-static void lxcFuseDestroy(virLXCFusePtr fuse)
+static void lxcFuseDestroy(struct virLXCFuse *fuse)
{
virMutexLock(&fuse->lock);
fuse_unmount(fuse->mountpoint, fuse->ch);
static void lxcFuseRun(void *opaque)
{
- virLXCFusePtr fuse = opaque;
+ struct virLXCFuse *fuse = opaque;
if (fuse_loop(fuse->fuse) < 0)
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
lxcFuseDestroy(fuse);
}
-int lxcSetupFuse(virLXCFusePtr *f, virDomainDefPtr def)
+int lxcSetupFuse(struct virLXCFuse **f, virDomainDef *def)
{
int ret = -1;
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
- virLXCFusePtr fuse = g_new0(virLXCFuse, 1);
+ struct virLXCFuse *fuse = g_new0(virLXCFuse, 1);
fuse->def = def;
goto cleanup;
}
-int lxcStartFuse(virLXCFusePtr fuse)
+int lxcStartFuse(struct virLXCFuse *fuse)
{
if (virThreadCreateFull(&fuse->thread, false, lxcFuseRun,
"lxc-fuse", false, (void *)fuse) < 0) {
return 0;
}
-void lxcFreeFuse(virLXCFusePtr *f)
+void lxcFreeFuse(struct virLXCFuse **f)
{
- virLXCFusePtr fuse = *f;
+ struct virLXCFuse *fuse = *f;
/* lxcFuseRun thread create success */
if (fuse) {
/* exit fuse_loop, lxcFuseRun thread may try to destroy
}
}
#else
-int lxcSetupFuse(virLXCFusePtr *f G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+int lxcSetupFuse(struct virLXCFuse **f G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
-int lxcStartFuse(virLXCFusePtr f G_GNUC_UNUSED)
+int lxcStartFuse(struct virLXCFuse *f G_GNUC_UNUSED)
{
return 0;
}
-void lxcFreeFuse(virLXCFusePtr *f G_GNUC_UNUSED)
+void lxcFreeFuse(struct virLXCFuse **f G_GNUC_UNUSED)
{
}
#endif
unsigned long long swaptotal;
unsigned long long swapusage;
};
-typedef struct virLXCMeminfo *virLXCMeminfoPtr;
struct virLXCFuse {
- virDomainDefPtr def;
+ virDomainDef *def;
virThread thread;
char *mountpoint;
struct fuse *fuse;
virMutex lock;
};
typedef struct virLXCFuse virLXCFuse;
-typedef struct virLXCFuse *virLXCFusePtr;
-int lxcSetupFuse(virLXCFusePtr *f, virDomainDefPtr def);
-int lxcStartFuse(virLXCFusePtr f);
-void lxcFreeFuse(virLXCFusePtr *f);
+int lxcSetupFuse(struct virLXCFuse **f, virDomainDef *def);
+int lxcStartFuse(struct virLXCFuse *f);
+void lxcFreeFuse(struct virLXCFuse **f);
VIR_LOG_INIT("lxc.lxc_hostdev");
int
-virLXCUpdateActiveUSBHostdevs(virLXCDriverPtr driver,
- virDomainDefPtr def)
+virLXCUpdateActiveUSBHostdevs(virLXCDriver *driver,
+ virDomainDef *def)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
if (!def->nhostdevs)
return 0;
}
static int
-virLXCPrepareHostUSBDevices(virLXCDriverPtr driver,
- virDomainDefPtr def)
+virLXCPrepareHostUSBDevices(virLXCDriver *driver,
+ virDomainDef *def)
{
- virDomainHostdevDefPtr *hostdevs = def->hostdevs;
+ virDomainHostdevDef **hostdevs = def->hostdevs;
int nhostdevs = def->nhostdevs;
const char *dom_name = def->name;
unsigned int flags = 0;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
return virHostdevPrepareUSBDevices(hostdev_mgr, LXC_DRIVER_NAME, dom_name,
hostdevs, nhostdevs, flags);
}
-int virLXCPrepareHostDevices(virLXCDriverPtr driver,
- virDomainDefPtr def)
+int virLXCPrepareHostDevices(virLXCDriver *driver,
+ virDomainDef *def)
{
size_t i;
/* Sanity check for supported configurations only */
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr dev = def->hostdevs[i];
+ virDomainHostdevDef *dev = def->hostdevs[i];
switch (dev->mode) {
case VIR_DOMAIN_HOSTDEV_MODE_SUBSYS:
static void
-virLXCDomainReAttachHostUSBDevices(virLXCDriverPtr driver,
+virLXCDomainReAttachHostUSBDevices(virLXCDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virHostdevReAttachUSBDevices(hostdev_mgr, LXC_DRIVER_NAME,
name, hostdevs, nhostdevs);
}
-void virLXCDomainReAttachHostDevices(virLXCDriverPtr driver,
- virDomainDefPtr def)
+void virLXCDomainReAttachHostDevices(virLXCDriver *driver,
+ virDomainDef *def)
{
if (!def->nhostdevs)
return;
#include "lxc_conf.h"
#include "domain_conf.h"
-int virLXCUpdateActiveUSBHostdevs(virLXCDriverPtr driver,
- virDomainDefPtr def);
-int virLXCFindHostdevUSBDevice(virDomainHostdevDefPtr hostdev,
+int virLXCUpdateActiveUSBHostdevs(virLXCDriver *driver,
+ virDomainDef *def);
+int virLXCFindHostdevUSBDevice(virDomainHostdevDef *hostdev,
bool mandatory,
- virUSBDevicePtr *usb);
-int virLXCPrepareHostdevUSBDevices(virLXCDriverPtr driver,
+ virUSBDevice **usb);
+int virLXCPrepareHostdevUSBDevices(virLXCDriver *driver,
const char *name,
- virUSBDeviceListPtr list);
-int virLXCPrepareHostDevices(virLXCDriverPtr driver,
- virDomainDefPtr def);
-void virLXCDomainReAttachHostDevices(virLXCDriverPtr driver,
- virDomainDefPtr def);
+ virUSBDeviceList *list);
+int virLXCPrepareHostDevices(virLXCDriver *driver,
+ virDomainDef *def);
+void virLXCDomainReAttachHostDevices(virLXCDriver *driver,
+ virDomainDef *def);
struct _virLXCMonitor {
virObjectLockable parent;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virLXCMonitorCallbacks cb;
- virNetClientPtr client;
- virNetClientProgramPtr program;
+ virNetClient *client;
+ virNetClientProgram *program;
};
-static virClassPtr virLXCMonitorClass;
+static virClass *virLXCMonitorClass;
static void virLXCMonitorDispose(void *obj);
static int virLXCMonitorOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virLXCMonitor);
static void
-virLXCMonitorHandleEventExit(virNetClientProgramPtr prog,
- virNetClientPtr client,
+virLXCMonitorHandleEventExit(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-virLXCMonitorHandleEventInit(virNetClientProgramPtr prog,
- virNetClientPtr client,
+virLXCMonitorHandleEventInit(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static virNetClientProgramEvent virLXCMonitorEvents[] = {
static void
-virLXCMonitorHandleEventExit(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+virLXCMonitorHandleEventExit(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
- virLXCMonitorPtr mon = opaque;
+ virLXCMonitor *mon = opaque;
virLXCMonitorExitEventMsg *msg = evdata;
VIR_DEBUG("Event exit %d", msg->status);
static void
-virLXCMonitorHandleEventInit(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+virLXCMonitorHandleEventInit(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
- virLXCMonitorPtr mon = opaque;
+ virLXCMonitor *mon = opaque;
virLXCMonitorInitEventMsg *msg = evdata;
VIR_DEBUG("Event init %lld", (long long)msg->initpid);
}
-static void virLXCMonitorEOFNotify(virNetClientPtr client G_GNUC_UNUSED,
+static void virLXCMonitorEOFNotify(virNetClient *client G_GNUC_UNUSED,
int reason G_GNUC_UNUSED,
void *opaque)
{
- virLXCMonitorPtr mon = opaque;
+ virLXCMonitor *mon = opaque;
virLXCMonitorCallbackEOFNotify eofNotify;
- virDomainObjPtr vm;
+ virDomainObj *vm;
VIR_DEBUG("EOF notify mon=%p", mon);
virObjectLock(mon);
static void virLXCMonitorCloseFreeCallback(void *opaque)
{
- virLXCMonitorPtr mon = opaque;
+ virLXCMonitor *mon = opaque;
virObjectUnref(mon);
}
-virLXCMonitorPtr virLXCMonitorNew(virDomainObjPtr vm,
+virLXCMonitor *virLXCMonitorNew(virDomainObj *vm,
const char *socketdir,
- virLXCMonitorCallbacksPtr cb)
+ virLXCMonitorCallbacks *cb)
{
- virLXCMonitorPtr mon;
+ virLXCMonitor *mon;
g_autofree char *sockpath = NULL;
if (virLXCMonitorInitialize() < 0)
static void virLXCMonitorDispose(void *opaque)
{
- virLXCMonitorPtr mon = opaque;
+ virLXCMonitor *mon = opaque;
VIR_DEBUG("mon=%p", mon);
if (mon->cb.destroy)
}
-void virLXCMonitorClose(virLXCMonitorPtr mon)
+void virLXCMonitorClose(virLXCMonitor *mon)
{
- virDomainObjPtr vm;
- virNetClientPtr client;
+ virDomainObj *vm;
+ virNetClient *client;
VIR_DEBUG("mon=%p", mon);
if (mon->client) {
#include "lxc_monitor_protocol.h"
typedef struct _virLXCMonitor virLXCMonitor;
-typedef virLXCMonitor *virLXCMonitorPtr;
typedef struct _virLXCMonitorCallbacks virLXCMonitorCallbacks;
-typedef virLXCMonitorCallbacks *virLXCMonitorCallbacksPtr;
-typedef void (*virLXCMonitorCallbackDestroy)(virLXCMonitorPtr mon,
- virDomainObjPtr vm);
-typedef void (*virLXCMonitorCallbackEOFNotify)(virLXCMonitorPtr mon,
- virDomainObjPtr vm);
+typedef void (*virLXCMonitorCallbackDestroy)(virLXCMonitor *mon,
+ virDomainObj *vm);
+typedef void (*virLXCMonitorCallbackEOFNotify)(virLXCMonitor *mon,
+ virDomainObj *vm);
-typedef void (*virLXCMonitorCallbackExitNotify)(virLXCMonitorPtr mon,
+typedef void (*virLXCMonitorCallbackExitNotify)(virLXCMonitor *mon,
virLXCMonitorExitStatus status,
- virDomainObjPtr vm);
+ virDomainObj *vm);
-typedef void (*virLXCMonitorCallbackInitNotify)(virLXCMonitorPtr mon,
+typedef void (*virLXCMonitorCallbackInitNotify)(virLXCMonitor *mon,
pid_t pid,
- virDomainObjPtr vm);
+ virDomainObj *vm);
struct _virLXCMonitorCallbacks {
virLXCMonitorCallbackDestroy destroy;
virLXCMonitorCallbackInitNotify initNotify;
};
-virLXCMonitorPtr virLXCMonitorNew(virDomainObjPtr vm,
+virLXCMonitor *virLXCMonitorNew(virDomainObj *vm,
const char *socketdir,
- virLXCMonitorCallbacksPtr cb);
+ virLXCMonitorCallbacks *cb);
-void virLXCMonitorClose(virLXCMonitorPtr mon);
+void virLXCMonitorClose(virLXCMonitor *mon);
-void virLXCMonitorLock(virLXCMonitorPtr mon);
-void virLXCMonitorUnlock(virLXCMonitorPtr mon);
+void virLXCMonitorLock(virLXCMonitor *mon);
+void virLXCMonitorUnlock(virLXCMonitor *mon);
"ipv6.address"
);
-static virDomainFSDefPtr
+static virDomainFSDef *
lxcCreateFSDef(int type,
const char *src,
const char* dst,
bool readonly,
unsigned long long usage)
{
- virDomainFSDefPtr def;
+ virDomainFSDef *def;
if (!(def = virDomainFSDefNew(NULL)))
return NULL;
}
typedef struct _lxcFstab lxcFstab;
-typedef lxcFstab *lxcFstabPtr;
struct _lxcFstab {
- lxcFstabPtr next;
+ lxcFstab *next;
char *src;
char *dst;
char *type;
};
static void
-lxcFstabFree(lxcFstabPtr fstab)
+lxcFstabFree(lxcFstab *fstab)
{
while (fstab) {
- lxcFstabPtr next = NULL;
+ lxcFstab *next = NULL;
next = fstab->next;
g_free(fstab->src);
return NULL;
}
-static lxcFstabPtr
+static lxcFstab *
lxcParseFstabLine(char *fstabLine)
{
- lxcFstabPtr fstab = NULL;
+ lxcFstab *fstab = NULL;
char **parts;
if (!fstabLine)
}
static int
-lxcAddFSDef(virDomainDefPtr def,
+lxcAddFSDef(virDomainDef *def,
int type,
const char *src,
const char *dst,
bool readonly,
unsigned long long usage)
{
- virDomainFSDefPtr fsDef = NULL;
+ virDomainFSDef *fsDef = NULL;
if (!(fsDef = lxcCreateFSDef(type, src, dst, readonly, usage)))
goto error;
}
static int
-lxcSetRootfs(virDomainDefPtr def,
- virConfPtr properties)
+lxcSetRootfs(virDomainDef *def,
+ virConf *properties)
{
int type = VIR_DOMAIN_FS_TYPE_MOUNT;
g_autofree char *value = NULL;
}
static int
-lxcAddFstabLine(virDomainDefPtr def, lxcFstabPtr fstab)
+lxcAddFstabLine(virDomainDef *def, lxcFstab *fstab)
{
const char *src = NULL;
g_autofree char *dst = NULL;
}
static int
-lxcFstabWalkCallback(const char* name, virConfValuePtr value, void * data)
+lxcFstabWalkCallback(const char* name, virConfValue *value, void * data)
{
int ret = 0;
- lxcFstabPtr fstabLine;
- virDomainDefPtr def = data;
+ lxcFstab *fstabLine;
+ virDomainDef *def = data;
/* We only care about lxc.mount.entry lines */
if (STRNEQ(name, "lxc.mount.entry"))
return ret;
}
-static virDomainNetDefPtr
+static virDomainNetDef *
lxcCreateNetDef(const char *type,
const char *linkdev,
const char *mac,
const char *macvlanmode,
const char *name)
{
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
virMacAddr macAddr;
if (!(net = virDomainNetDefNew(NULL)))
return NULL;
}
-static virDomainHostdevDefPtr
+static virDomainHostdevDef *
lxcCreateHostdevDef(int mode, int type, const char *data)
{
- virDomainHostdevDefPtr hostdev = virDomainHostdevDefNew();
+ virDomainHostdevDef *hostdev = virDomainHostdevDefNew();
if (!hostdev)
return NULL;
}
typedef struct _lxcNetworkParseData lxcNetworkParseData;
-typedef lxcNetworkParseData *lxcNetworkParseDataPtr;
struct _lxcNetworkParseData {
char *type;
char *link;
char *macvlanmode;
char *vlanid;
char *name;
- virNetDevIPAddrPtr *ips;
+ virNetDevIPAddr **ips;
size_t nips;
char *gateway_ipv4;
char *gateway_ipv6;
typedef struct {
size_t ndata;
- lxcNetworkParseDataPtr *parseData;
+ lxcNetworkParseData **parseData;
} lxcNetworkParseDataArray;
static int
lxcAddNetworkRouteDefinition(const char *address,
int family,
- virNetDevIPRoutePtr **routes,
+ virNetDevIPRoute ***routes,
size_t *nroutes)
{
g_autoptr(virNetDevIPRoute) route = NULL;
}
static int
-lxcAddNetworkDefinition(virDomainDefPtr def, lxcNetworkParseData *data)
+lxcAddNetworkDefinition(virDomainDef *def, lxcNetworkParseData *data)
{
- virDomainNetDefPtr net = NULL;
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainNetDef *net = NULL;
+ virDomainHostdevDef *hostdev = NULL;
bool isPhys, isVlan = false;
size_t i;
static int
lxcNetworkParseDataIPs(const char *name,
- virConfValuePtr value,
+ virConfValue *value,
lxcNetworkParseData *parseData)
{
int family = AF_INET;
char **ipparts = NULL;
- g_autofree virNetDevIPAddrPtr ip = g_new0(virNetDevIPAddr, 1);
+ g_autofree virNetDevIPAddr *ip = g_new0(virNetDevIPAddr, 1);
if (STREQ(name, "ipv6") || STREQ(name, "ipv6.address"))
family = AF_INET6;
static int
lxcNetworkParseDataSuffix(const char *entry,
- virConfValuePtr value,
+ virConfValue *value,
lxcNetworkParseData *parseData)
{
int elem = virLXCNetworkConfigEntryTypeFromString(entry);
}
-static lxcNetworkParseDataPtr
+static lxcNetworkParseData *
lxcNetworkGetParseDataByIndex(lxcNetworkParseDataArray *networks,
unsigned int index)
{
static int
lxcNetworkParseDataEntry(const char *name,
- virConfValuePtr value,
+ virConfValue *value,
lxcNetworkParseDataArray *networks)
{
lxcNetworkParseData *parseData;
}
-static lxcNetworkParseDataPtr
+static lxcNetworkParseData *
lxcNetworkGetParseDataByIndexLegacy(lxcNetworkParseDataArray *networks,
const char *entry)
{
static int
lxcNetworkParseDataEntryLegacy(const char *name,
- virConfValuePtr value,
+ virConfValue *value,
lxcNetworkParseDataArray *networks)
{
const char *suffix = STRSKIP(name, "lxc.network.");
static int
-lxcNetworkWalkCallback(const char *name, virConfValuePtr value, void *data)
+lxcNetworkWalkCallback(const char *name, virConfValue *value, void *data)
{
lxcNetworkParseDataArray *networks = data;
}
static int
-lxcConvertNetworkSettings(virDomainDefPtr def, virConfPtr properties)
+lxcConvertNetworkSettings(virDomainDef *def, virConf *properties)
{
int status;
bool privnet = true;
lxcNetworkParseDataArray networks = {0, NULL};
int ret = -1;
- networks.parseData = g_new0(lxcNetworkParseDataPtr, 1);
+ networks.parseData = g_new0(lxcNetworkParseData *, 1);
if (virConfWalk(properties, lxcNetworkWalkCallback, &networks) < 0)
goto error;
for (i = 0; i < networks.ndata; i++) {
- lxcNetworkParseDataPtr data = networks.parseData[i];
+ lxcNetworkParseData *data = networks.parseData[i];
status = lxcAddNetworkDefinition(def, data);
error:
for (i = 0; i < networks.ndata; i++) {
- lxcNetworkParseDataPtr data = networks.parseData[i];
+ lxcNetworkParseData *data = networks.parseData[i];
for (j = 0; j < data->nips; j++)
g_free(data->ips[j]);
g_free(data->ips);
}
static int
-lxcCreateConsoles(virDomainDefPtr def, virConfPtr properties)
+lxcCreateConsoles(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
int nbttys = 0;
- virDomainChrDefPtr console;
+ virDomainChrDef *console;
size_t i;
if (virConfGetValueString(properties, "lxc.tty.max", &value) <= 0) {
return -1;
}
- def->consoles = g_new0(virDomainChrDefPtr, nbttys);
+ def->consoles = g_new0(virDomainChrDef *, nbttys);
def->nconsoles = nbttys;
for (i = 0; i < nbttys; i++) {
}
static int
-lxcIdmapWalkCallback(const char *name, virConfValuePtr value, void *data)
+lxcIdmapWalkCallback(const char *name, virConfValue *value, void *data)
{
- virDomainDefPtr def = data;
- virDomainIdMapEntryPtr idmap = NULL;
+ virDomainDef *def = data;
+ virDomainIdMapEntry *idmap = NULL;
char type;
unsigned long start, target, count;
}
static int
-lxcSetMemTune(virDomainDefPtr def, virConfPtr properties)
+lxcSetMemTune(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
unsigned long long size = 0;
}
static int
-lxcSetCpuTune(virDomainDefPtr def, virConfPtr properties)
+lxcSetCpuTune(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
}
static int
-lxcSetCpusetTune(virDomainDefPtr def, virConfPtr properties)
+lxcSetCpusetTune(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
if (virConfGetValueString(properties, "lxc.cgroup.cpuset.cpus",
&value) > 0) {
}
static int
-lxcBlkioDeviceWalkCallback(const char *name, virConfValuePtr value, void *data)
+lxcBlkioDeviceWalkCallback(const char *name, virConfValue *value, void *data)
{
char **parts = NULL;
- virBlkioDevicePtr device = NULL;
- virDomainDefPtr def = data;
+ virBlkioDevice *device = NULL;
+ virDomainDef *def = data;
size_t i = 0;
g_autofree char *path = NULL;
int ret = -1;
}
static int
-lxcSetBlkioTune(virDomainDefPtr def, virConfPtr properties)
+lxcSetBlkioTune(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
}
static void
-lxcSetCapDrop(virDomainDefPtr def, virConfPtr properties)
+lxcSetCapDrop(virDomainDef *def, virConf *properties)
{
g_autofree char *value = NULL;
char **toDrop = NULL;
g_strfreev(toDrop);
}
-virDomainDefPtr
+virDomainDef *
lxcParseConfigString(const char *config,
- virCapsPtr caps G_GNUC_UNUSED,
- virDomainXMLOptionPtr xmlopt)
+ virCaps *caps G_GNUC_UNUSED,
+ virDomainXMLOption *xmlopt)
{
- virDomainDefPtr vmdef = NULL;
+ virDomainDef *vmdef = NULL;
g_autoptr(virConf) properties = NULL;
g_autofree char *value = NULL;
VIR_ENUM_DECL(virLXCNetworkConfigEntry);
-virDomainDefPtr lxcParseConfigString(const char *config,
- virCapsPtr caps,
- virDomainXMLOptionPtr xmlopt);
+virDomainDef *lxcParseConfigString(const char *config,
+ virCaps *caps,
+ virDomainXMLOption *xmlopt);
#define START_POSTFIX ": starting up\n"
static void
-lxcProcessAutoDestroy(virDomainObjPtr dom,
+lxcProcessAutoDestroy(virDomainObj *dom,
virConnectPtr conn,
void *opaque)
{
- virLXCDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDriver *driver = opaque;
+ virObjectEvent *event = NULL;
+ virLXCDomainObjPrivate *priv;
VIR_DEBUG("driver=%p dom=%s conn=%p", driver, dom->def->name, conn);
* Precondition: driver is locked
*/
static int
-virLXCProcessReboot(virLXCDriverPtr driver,
- virDomainObjPtr vm)
+virLXCProcessReboot(virLXCDriver *driver,
+ virDomainObj *vm)
{
virConnectPtr conn = virCloseCallbacksGetConn(driver->closeCallbacks, vm);
int reason = vm->state.reason;
bool autodestroy = false;
int ret = -1;
- virDomainDefPtr savedDef;
+ virDomainDef *savedDef;
VIR_DEBUG("Faking reboot");
static void
-lxcProcessRemoveDomainStatus(virLXCDriverConfigPtr cfg,
- virDomainObjPtr vm)
+lxcProcessRemoveDomainStatus(virLXCDriverConfig *cfg,
+ virDomainObj *vm)
{
g_autofree char *file = g_strdup_printf("%s/%s.xml",
cfg->stateDir,
* If @flags is zero then whole cleanup process is done,
* otherwise only selected sections are run.
*/
-static void virLXCProcessCleanup(virLXCDriverPtr driver,
- virDomainObjPtr vm,
+static void virLXCProcessCleanup(virLXCDriver *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason,
unsigned int flags)
{
size_t i;
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
const virNetDevVPortProfile *vport = NULL;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
g_autoptr(virConnect) conn = NULL;
VIR_DEBUG("Cleanup VM name=%s pid=%d reason=%d flags=0x%x",
virLXCDomainReAttachHostDevices(driver, vm->def);
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr iface = vm->def->nets[i];
+ virDomainNetDef *iface = vm->def->nets[i];
vport = virDomainNetGetActualVirtPortProfile(iface);
if (iface->ifname) {
if (vport &&
int
-virLXCProcessValidateInterface(virDomainNetDefPtr net)
+virLXCProcessValidateInterface(virDomainNetDef *net)
{
if (net->script) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
char *
-virLXCProcessSetupInterfaceTap(virDomainDefPtr vm,
- virDomainNetDefPtr net,
+virLXCProcessSetupInterfaceTap(virDomainDef *vm,
+ virDomainNetDef *net,
const char *brname)
{
g_autofree char *parentVeth = NULL;
char *
-virLXCProcessSetupInterfaceDirect(virLXCDriverPtr driver,
- virDomainDefPtr def,
- virDomainNetDefPtr net)
+virLXCProcessSetupInterfaceDirect(virLXCDriver *driver,
+ virDomainDef *def,
+ virDomainNetDef *net)
{
char *ret = NULL;
char *res_ifname = NULL;
const virNetDevBandwidth *bw;
const virNetDevVPortProfile *prof;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
const char *linkdev = virDomainNetGetActualDirectDev(net);
unsigned int macvlan_create_flags = VIR_NETDEV_MACVLAN_CREATE_IFUP;
[VIR_LXC_DOMAIN_NAMESPACE_SHAREUTS] = "uts",
};
-static int virLXCProcessSetupNamespaceName(virLXCDriverPtr driver,
+static int virLXCProcessSetupNamespaceName(virLXCDriver *driver,
int ns_type,
const char *name)
{
int fd = -1;
- virDomainObjPtr vm;
- virLXCDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ virLXCDomainObjPrivate *priv;
g_autofree char *path = NULL;
vm = virDomainObjListFindByName(driver->domains, name);
* Returns 0 on success or -1 in case of error
*/
static int
-virLXCProcessSetupNamespaces(virLXCDriverPtr driver,
- lxcDomainDefPtr lxcDef,
+virLXCProcessSetupNamespaces(virLXCDriver *driver,
+ lxcDomainDef *lxcDef,
int *nsFDs)
{
size_t i;
* Returns 0 on success or -1 in case of error
*/
static int
-virLXCProcessSetupInterfaces(virLXCDriverPtr driver,
- virDomainDefPtr def,
+virLXCProcessSetupInterfaces(virLXCDriver *driver,
+ virDomainDef *def,
char ***veths)
{
int ret = -1;
size_t i;
size_t niface = 0;
- virDomainNetDefPtr net;
+ virDomainNetDef *net;
virDomainNetType type;
g_autoptr(virConnect) netconn = NULL;
virErrorPtr save_err = NULL;
if (ret < 0) {
virErrorPreserveLast(&save_err);
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr iface = def->nets[i];
+ virDomainNetDef *iface = def->nets[i];
const virNetDevVPortProfile *vport = virDomainNetGetActualVirtPortProfile(iface);
if (vport && vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH)
ignore_value(virNetDevOpenvswitchRemovePort(
}
static void
-virLXCProcessCleanInterfaces(virDomainDefPtr def)
+virLXCProcessCleanInterfaces(virDomainDef *def)
{
size_t i;
}
-extern virLXCDriverPtr lxc_driver;
-static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon,
- virDomainObjPtr vm)
+extern virLXCDriver *lxc_driver;
+static void virLXCProcessMonitorEOFNotify(virLXCMonitor *mon,
+ virDomainObj *vm)
{
- virLXCDriverPtr driver = lxc_driver;
- virObjectEventPtr event = NULL;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDriver *driver = lxc_driver;
+ virObjectEvent *event = NULL;
+ virLXCDomainObjPrivate *priv;
VIR_DEBUG("mon=%p vm=%p", mon, vm);
virObjectEventStateQueue(driver->domainEventState, event);
}
-static void virLXCProcessMonitorExitNotify(virLXCMonitorPtr mon G_GNUC_UNUSED,
+static void virLXCProcessMonitorExitNotify(virLXCMonitor *mon G_GNUC_UNUSED,
virLXCMonitorExitStatus status,
- virDomainObjPtr vm)
+ virDomainObj *vm)
{
- virLXCDomainObjPrivatePtr priv = vm->privateData;
+ virLXCDomainObjPrivate *priv = vm->privateData;
virObjectLock(vm);
/* XXX a little evil */
-extern virLXCDriverPtr lxc_driver;
-static void virLXCProcessMonitorInitNotify(virLXCMonitorPtr mon G_GNUC_UNUSED,
+extern virLXCDriver *lxc_driver;
+static void virLXCProcessMonitorInitNotify(virLXCMonitor *mon G_GNUC_UNUSED,
pid_t initpid,
- virDomainObjPtr vm)
+ virDomainObj *vm)
{
- virLXCDriverPtr driver = lxc_driver;
- virLXCDomainObjPrivatePtr priv;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriver *driver = lxc_driver;
+ virLXCDomainObjPrivate *priv;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
ino_t inode = 0;
virObjectLock(vm);
};
-static virLXCMonitorPtr virLXCProcessConnectMonitor(virLXCDriverPtr driver,
- virDomainObjPtr vm)
+static virLXCMonitor *virLXCProcessConnectMonitor(virLXCDriver *driver,
+ virDomainObj *vm)
{
- virLXCMonitorPtr monitor = NULL;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCMonitor *monitor = NULL;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
if (virSecurityManagerSetSocketLabel(driver->securityManager, vm->def) < 0)
goto cleanup;
}
-int virLXCProcessStop(virLXCDriverPtr driver,
- virDomainObjPtr vm,
+int virLXCProcessStop(virLXCDriver *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason)
{
int rc;
- virLXCDomainObjPrivatePtr priv;
+ virLXCDomainObjPrivate *priv;
VIR_DEBUG("Stopping VM name=%s pid=%d reason=%d",
vm->def->name, (int)vm->pid, (int)reason);
}
-static virCommandPtr
-virLXCProcessBuildControllerCmd(virLXCDriverPtr driver,
- virDomainObjPtr vm,
+static virCommand *
+virLXCProcessBuildControllerCmd(virLXCDriver *driver,
+ virDomainObj *vm,
char **veths,
int *ttyFDs,
size_t nttyFDs,
size_t i;
g_autofree char *filterstr = NULL;
g_autofree char *outputstr = NULL;
- virCommandPtr cmd;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virCommand *cmd;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
cmd = virCommandNew(vm->def->emulator);
}
static int
-virLXCProcessReadLogOutputData(virDomainObjPtr vm,
+virLXCProcessReadLogOutputData(virDomainObj *vm,
int fd,
char *buf,
size_t buflen)
static int
-virLXCProcessReadLogOutput(virDomainObjPtr vm,
+virLXCProcessReadLogOutput(virDomainObj *vm,
char *logfile,
off_t pos,
char *buf,
static int
-virLXCProcessEnsureRootFS(virDomainObjPtr vm)
+virLXCProcessEnsureRootFS(virDomainObj *vm)
{
- virDomainFSDefPtr root = virDomainGetFilesystemForTarget(vm->def, "/");
+ virDomainFSDef *root = virDomainGetFilesystemForTarget(vm->def, "/");
if (root)
return 0;
* Returns 0 on success or -1 in case of error
*/
int virLXCProcessStart(virConnectPtr conn,
- virLXCDriverPtr driver,
- virDomainObjPtr vm,
+ virLXCDriver * driver,
+ virDomainObj *vm,
unsigned int nfiles, int *files,
bool autoDestroy,
virDomainRunningReason reason)
char ebuf[1024];
g_autofree char *timestamp = NULL;
int nsInheritFDs[VIR_LXC_DOMAIN_NAMESPACE_LAST];
- virCommandPtr cmd = NULL;
- virLXCDomainObjPrivatePtr priv = vm->privateData;
- virCapsPtr caps = NULL;
+ virCommand *cmd = NULL;
+ virLXCDomainObjPrivate *priv = vm->privateData;
+ virCaps *caps = NULL;
virErrorPtr err = NULL;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
g_autoptr(virCgroup) selfcgroup = NULL;
int status;
g_autofree char *pidfile = NULL;
}
if (!vm->def->resource) {
- virDomainResourceDefPtr res = g_new0(virDomainResourceDef, 1);
+ virDomainResourceDef *res = g_new0(virDomainResourceDef, 1);
res->partition = g_strdup("/machine");
}
struct virLXCProcessAutostartData {
- virLXCDriverPtr driver;
+ virLXCDriver *driver;
virConnectPtr conn;
};
static int
-virLXCProcessAutostartDomain(virDomainObjPtr vm,
+virLXCProcessAutostartDomain(virDomainObj *vm,
void *opaque)
{
const struct virLXCProcessAutostartData *data = opaque;
vm->def->name,
virGetLastErrorMessage());
} else {
- virObjectEventPtr event =
+ virObjectEvent *event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
void
-virLXCProcessAutostartAll(virLXCDriverPtr driver)
+virLXCProcessAutostartAll(virLXCDriver *driver)
{
/* XXX: Figure out a better way todo this. The domain
* startup code needs a connection handle in order
static void
-virLXCProcessReconnectNotifyNets(virDomainDefPtr def)
+virLXCProcessReconnectNotifyNets(virDomainDef *def)
{
size_t i;
g_autoptr(virConnect) conn = NULL;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
/* type='bridge|network|ethernet' interfaces may be using an
* autogenerated netdev name, so we should update the counter
static int
-virLXCProcessReconnectDomain(virDomainObjPtr vm,
+virLXCProcessReconnectDomain(virDomainObj *vm,
void *opaque)
{
- virLXCDriverPtr driver = opaque;
- virLXCDomainObjPrivatePtr priv;
- virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
+ virLXCDriver *driver = opaque;
+ virLXCDomainObjPrivate *priv;
+ virLXCDriverConfig *cfg = virLXCDriverGetConfig(driver);
int ret = -1;
virObjectLock(vm);
}
-int virLXCProcessReconnectAll(virLXCDriverPtr driver,
- virDomainObjListPtr doms)
+int virLXCProcessReconnectAll(virLXCDriver *driver,
+ virDomainObjList *doms)
{
virDomainObjListForEach(doms, false, virLXCProcessReconnectDomain, driver);
return 0;
#include "lxc_conf.h"
int virLXCProcessStart(virConnectPtr conn,
- virLXCDriverPtr driver,
- virDomainObjPtr vm,
+ virLXCDriver * driver,
+ virDomainObj *vm,
unsigned int nfiles, int *files,
bool autoDestroy,
virDomainRunningReason reason);
-int virLXCProcessStop(virLXCDriverPtr driver,
- virDomainObjPtr vm,
+int virLXCProcessStop(virLXCDriver *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason);
-void virLXCProcessAutoDestroyRun(virLXCDriverPtr driver,
+void virLXCProcessAutoDestroyRun(virLXCDriver *driver,
virConnectPtr conn);
-void virLXCProcessAutoDestroyShutdown(virLXCDriverPtr driver);
-int virLXCProcessAutoDestroyAdd(virLXCDriverPtr driver,
- virDomainObjPtr vm,
+void virLXCProcessAutoDestroyShutdown(virLXCDriver *driver);
+int virLXCProcessAutoDestroyAdd(virLXCDriver *driver,
+ virDomainObj *vm,
virConnectPtr conn);
-int virLXCProcessAutoDestroyRemove(virLXCDriverPtr driver,
- virDomainObjPtr vm);
+int virLXCProcessAutoDestroyRemove(virLXCDriver *driver,
+ virDomainObj *vm);
-void virLXCProcessAutostartAll(virLXCDriverPtr driver);
-int virLXCProcessReconnectAll(virLXCDriverPtr driver,
- virDomainObjListPtr doms);
+void virLXCProcessAutostartAll(virLXCDriver *driver);
+int virLXCProcessReconnectAll(virLXCDriver *driver,
+ virDomainObjList *doms);
-int virLXCProcessValidateInterface(virDomainNetDefPtr net);
-char *virLXCProcessSetupInterfaceTap(virDomainDefPtr vm,
- virDomainNetDefPtr net,
+int virLXCProcessValidateInterface(virDomainNetDef *net);
+char *virLXCProcessSetupInterfaceTap(virDomainDef *vm,
+ virDomainNetDef *net,
const char *brname);
-char *virLXCProcessSetupInterfaceDirect(virLXCDriverPtr driver,
- virDomainDefPtr def,
- virDomainNetDefPtr net);
+char *virLXCProcessSetupInterfaceDirect(virLXCDriver *driver,
+ virDomainDef *def,
+ virDomainNetDef *net);
VIR_LOG_INIT("network.bridge_driver");
-static virNetworkDriverStatePtr network_driver;
+static virNetworkDriverState *network_driver;
-static virNetworkDriverStatePtr
+static virNetworkDriverState *
networkGetDriver(void)
{
/* Maybe one day we can store @network_driver in the
static void
-networkDriverLock(virNetworkDriverStatePtr driver)
+networkDriverLock(virNetworkDriverState *driver)
{
virMutexLock(&driver->lock);
}
static void
-networkDriverUnlock(virNetworkDriverStatePtr driver)
+networkDriverUnlock(virNetworkDriverState *driver)
{
virMutexUnlock(&driver->lock);
}
-static dnsmasqCapsPtr
-networkGetDnsmasqCaps(virNetworkDriverStatePtr driver)
+static dnsmasqCaps *
+networkGetDnsmasqCaps(virNetworkDriverState *driver)
{
- dnsmasqCapsPtr ret;
+ dnsmasqCaps *ret;
networkDriverLock(driver);
ret = virObjectRef(driver->dnsmasqCaps);
networkDriverUnlock(driver);
static int
-networkDnsmasqCapsRefresh(virNetworkDriverStatePtr driver)
+networkDnsmasqCapsRefresh(virNetworkDriverState *driver)
{
- dnsmasqCapsPtr caps;
+ dnsmasqCaps *caps;
if (!(caps = dnsmasqCapsNewFromBinary(DNSMASQ)))
return -1;
extern virXMLNamespace networkDnsmasqXMLNamespace;
typedef struct _networkDnsmasqXmlNsDef networkDnsmasqXmlNsDef;
-typedef networkDnsmasqXmlNsDef *networkDnsmasqXmlNsDefPtr;
struct _networkDnsmasqXmlNsDef {
size_t noptions;
char **options;
static void
networkDnsmasqDefNamespaceFree(void *nsdata)
{
- networkDnsmasqXmlNsDefPtr def = nsdata;
+ networkDnsmasqXmlNsDef *def = nsdata;
if (!def)
return;
static int
-networkDnsmasqDefNamespaceParseOptions(networkDnsmasqXmlNsDefPtr nsdef,
+networkDnsmasqDefNamespaceParseOptions(networkDnsmasqXmlNsDef *nsdef,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-networkDnsmasqDefNamespaceFormatXML(virBufferPtr buf,
+networkDnsmasqDefNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
- networkDnsmasqXmlNsDefPtr def = nsdata;
+ networkDnsmasqXmlNsDef *def = nsdata;
size_t i;
if (!def->noptions)
};
-virNetworkXMLOptionPtr
+virNetworkXMLOption *
networkDnsmasqCreateXMLConf(void)
{
return virNetworkXMLOptionNew(&networkDnsmasqXMLNamespace);
networkStateCleanup(void);
static int
-networkStartNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj);
+networkStartNetwork(virNetworkDriverState *driver,
+ virNetworkObj *obj);
static int
-networkShutdownNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj);
+networkShutdownNetwork(virNetworkDriverState *driver,
+ virNetworkObj *obj);
static int
-networkStartNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj);
+networkStartNetworkVirtual(virNetworkDriverState *driver,
+ virNetworkObj *obj);
static int
-networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj);
+networkShutdownNetworkVirtual(virNetworkDriverState *driver,
+ virNetworkObj *obj);
static int
-networkStartNetworkExternal(virNetworkObjPtr obj);
+networkStartNetworkExternal(virNetworkObj *obj);
static int
-networkShutdownNetworkExternal(virNetworkObjPtr obj);
+networkShutdownNetworkExternal(virNetworkObj *obj);
static void
-networkReloadFirewallRules(virNetworkDriverStatePtr driver,
+networkReloadFirewallRules(virNetworkDriverState *driver,
bool startup,
bool force);
static void
-networkRefreshDaemons(virNetworkDriverStatePtr driver);
+networkRefreshDaemons(virNetworkDriverState *driver);
static int
-networkPlugBandwidth(virNetworkObjPtr obj,
- virMacAddrPtr mac,
- virNetDevBandwidthPtr ifaceBand,
+networkPlugBandwidth(virNetworkObj *obj,
+ virMacAddr *mac,
+ virNetDevBandwidth *ifaceBand,
unsigned int *class_id);
static int
-networkUnplugBandwidth(virNetworkObjPtr obj,
- virNetDevBandwidthPtr ifaceBand,
+networkUnplugBandwidth(virNetworkObj *obj,
+ virNetDevBandwidth *ifaceBand,
unsigned int *class_id);
static void
-networkNetworkObjTaint(virNetworkObjPtr obj,
+networkNetworkObjTaint(virNetworkObj *obj,
virNetworkTaintFlags taint);
-static virNetworkObjPtr
+static virNetworkObj *
networkObjFromNetwork(virNetworkPtr net)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
obj = virNetworkObjFindByUUID(driver->networks, net->uuid);
static int
-networkRunHook(virNetworkObjPtr obj,
- virNetworkPortDefPtr port,
+networkRunHook(virNetworkObj *obj,
+ virNetworkPortDef *port,
int op,
int sub_op)
{
- virNetworkDefPtr def;
+ virNetworkDef *def;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autofree char *xml = NULL;
int hookret;
static char *
-networkDnsmasqLeaseFileNameDefault(virNetworkDriverStatePtr driver,
+networkDnsmasqLeaseFileNameDefault(virNetworkDriverState *driver,
const char *netname)
{
char *leasefile;
static char *
-networkDnsmasqLeaseFileNameCustom(virNetworkDriverStatePtr driver,
+networkDnsmasqLeaseFileNameCustom(virNetworkDriverState *driver,
const char *bridge)
{
char *leasefile;
static char *
-networkDnsmasqConfigFileName(virNetworkDriverStatePtr driver,
+networkDnsmasqConfigFileName(virNetworkDriverState *driver,
const char *netname)
{
char *conffile;
static char *
-networkRadvdConfigFileName(virNetworkDriverStatePtr driver,
+networkRadvdConfigFileName(virNetworkDriverState *driver,
const char *netname)
{
char *configfile;
/* do needed cleanup steps and remove the network from the list */
static int
-networkRemoveInactive(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkRemoveInactive(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
g_autofree char *leasefile = NULL;
g_autofree char *customleasefile = NULL;
g_autofree char *statusfile = NULL;
g_autofree char *macMapFile = NULL;
g_autoptr(dnsmasqContext) dctx = NULL;
- virNetworkDefPtr def = virNetworkObjGetPersistentDef(obj);
+ virNetworkDef *def = virNetworkObjGetPersistentDef(obj);
/* remove the (possibly) existing dnsmasq and radvd files */
if (!(dctx = dnsmasqContextNew(def->name,
static int
-networkNotifyPort(virNetworkObjPtr obj,
- virNetworkPortDefPtr port);
+networkNotifyPort(virNetworkObj *obj,
+ virNetworkPortDef *port);
static bool
-networkUpdatePort(virNetworkPortDefPtr port,
+networkUpdatePort(virNetworkPortDef *port,
void *opaque)
{
- virNetworkObjPtr obj = opaque;
+ virNetworkObj *obj = opaque;
networkNotifyPort(obj, port);
}
static int
-networkUpdateState(virNetworkObjPtr obj,
+networkUpdateState(virNetworkObj *obj,
void *opaque)
{
- virNetworkDefPtr def;
- virNetworkDriverStatePtr driver = opaque;
+ virNetworkDef *def;
+ virNetworkDriverState *driver = opaque;
g_autoptr(dnsmasqCaps) dnsmasq_caps = networkGetDnsmasqCaps(driver);
- virMacMapPtr macmap;
+ virMacMap *macmap;
g_autofree char *macMapFile = NULL;
int ret = -1;
static int
-networkAutostartConfig(virNetworkObjPtr obj,
+networkAutostartConfig(virNetworkObj *obj,
void *opaque)
{
- virNetworkDriverStatePtr driver = opaque;
+ virNetworkDriverState *driver = opaque;
int ret = -1;
virObjectLock(obj);
GVariant *parameters,
gpointer user_data)
{
- virNetworkDriverStatePtr driver = user_data;
+ virNetworkDriverState *driver = user_data;
bool reload = false;
if (STREQ(interfaceName, "org.fedoraproject.FirewallD1") &&
static virDrvOpenStatus
networkConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static char *
-networkBuildDnsmasqLeaseTime(virNetworkDHCPLeaseTimeDefPtr lease)
+networkBuildDnsmasqLeaseTime(virNetworkDHCPLeaseTimeDef *lease)
{
const char *unit;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
*/
static int
networkBuildDnsmasqDhcpHostsList(dnsmasqContext *dctx,
- virNetworkIPDefPtr ipdef)
+ virNetworkIPDef *ipdef)
{
size_t i;
bool ipv6 = false;
if (VIR_SOCKET_ADDR_IS_FAMILY(&ipdef->address, AF_INET6))
ipv6 = true;
for (i = 0; i < ipdef->nhosts; i++) {
- virNetworkDHCPHostDefPtr host = &(ipdef->hosts[i]);
+ virNetworkDHCPHostDef *host = &(ipdef->hosts[i]);
g_autofree char *leasetime = networkBuildDnsmasqLeaseTime(host->lease);
if (VIR_SOCKET_ADDR_VALID(&host->ip))
static int
networkBuildDnsmasqHostsList(dnsmasqContext *dctx,
- virNetworkDNSDefPtr dnsdef)
+ virNetworkDNSDef *dnsdef)
{
size_t i, j;
if (dnsdef) {
for (i = 0; i < dnsdef->nhosts; i++) {
- virNetworkDNSHostDefPtr host = &(dnsdef->hosts[i]);
+ virNetworkDNSHostDef *host = &(dnsdef->hosts[i]);
if (VIR_SOCKET_ADDR_VALID(&host->ip)) {
for (j = 0; j < host->nnames; j++)
if (dnsmasqAddHost(dctx, &host->ip, host->names[j]) < 0)
static int
-networkDnsmasqConfLocalPTRs(virBufferPtr buf,
- virNetworkDefPtr def)
+networkDnsmasqConfLocalPTRs(virBuffer *buf,
+ virNetworkDef *def)
{
- virNetworkIPDefPtr ip;
+ virNetworkIPDef *ip;
size_t i;
int rc;
int
-networkDnsmasqConfContents(virNetworkObjPtr obj,
+networkDnsmasqConfContents(virNetworkObj *obj,
const char *pidfile,
char **configstr,
char **hostsfilestr,
dnsmasqContext *dctx,
- dnsmasqCapsPtr caps G_GNUC_UNUSED)
+ dnsmasqCaps *caps G_GNUC_UNUSED)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_auto(virBuffer) configbuf = VIR_BUFFER_INITIALIZER;
int r;
int nbleases = 0;
size_t i;
- virNetworkDNSDefPtr dns = &def->dns;
+ virNetworkDNSDef *dns = &def->dns;
bool wantDNS = dns->enable != VIR_TRISTATE_BOOL_NO;
- virNetworkIPDefPtr tmpipdef;
- virNetworkIPDefPtr ipdef;
- virNetworkIPDefPtr ipv4def;
- virNetworkIPDefPtr ipv6def;
+ virNetworkIPDef *tmpipdef;
+ virNetworkIPDef *ipdef;
+ virNetworkIPDef *ipv4def;
+ virNetworkIPDef *ipv6def;
bool ipv6SLAAC;
*configstr = NULL;
bool addNoResolv = false;
for (i = 0; i < def->dns.nfwds; i++) {
- virNetworkDNSForwarderPtr fwd = &def->dns.forwarders[i];
+ virNetworkDNSForwarder *fwd = &def->dns.forwarders[i];
virBufferAddLit(&configbuf, "server=");
if (fwd->domain)
}
if (def->namespaceData) {
- networkDnsmasqXmlNsDefPtr dnsmasqxmlns = def->namespaceData;
+ networkDnsmasqXmlNsDef *dnsmasqxmlns = def->namespaceData;
for (i = 0; i < dnsmasqxmlns->noptions; i++)
virBufferAsprintf(&configbuf, "%s\n", dnsmasqxmlns->options[i]);
}
/* build the dnsmasq command line */
static int ATTRIBUTE_NONNULL(3)
-networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj,
- virCommandPtr *cmdout,
+networkBuildDhcpDaemonCommandLine(virNetworkDriverState *driver,
+ virNetworkObj *obj,
+ virCommand **cmdout,
char *pidfile,
dnsmasqContext *dctx)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_autoptr(dnsmasqCaps) dnsmasq_caps = networkGetDnsmasqCaps(driver);
g_autoptr(virCommand) cmd = NULL;
g_autofree char *configfile = NULL;
static int
-networkStartDhcpDaemon(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkStartDhcpDaemon(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
- virNetworkIPDefPtr ipdef;
+ virNetworkDef *def = virNetworkObjGetDef(obj);
+ virNetworkIPDef *ipdef;
size_t i;
bool needDnsmasq = false;
g_autoptr(virCommand) cmd = NULL;
* Returns 0 on success, -1 on failure.
*/
static int
-networkRefreshDhcpDaemon(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkRefreshDhcpDaemon(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
size_t i;
pid_t dnsmasqPid;
- virNetworkIPDefPtr ipdef;
- virNetworkIPDefPtr ipv4def;
- virNetworkIPDefPtr ipv6def;
+ virNetworkIPDef *ipdef;
+ virNetworkIPDef *ipv4def;
+ virNetworkIPDef *ipv6def;
g_autoptr(dnsmasqContext) dctx = NULL;
/* if no IP addresses specified, nothing to do */
* Returns 0 on success, -1 on failure.
*/
static int
-networkRestartDhcpDaemon(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkRestartDhcpDaemon(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
pid_t dnsmasqPid = virNetworkObjGetDnsmasqPid(obj);
" AdvRouterAddr off;\n";
static int
-networkRadvdConfContents(virNetworkObjPtr obj,
+networkRadvdConfContents(virNetworkObj *obj,
char **configstr)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_auto(virBuffer) configbuf = VIR_BUFFER_INITIALIZER;
size_t i;
- virNetworkIPDefPtr ipdef;
+ virNetworkIPDef *ipdef;
bool v6present = false, dhcp6 = false;
*configstr = NULL;
/* write file and return its name (which must be freed by caller) */
static int
-networkRadvdConfWrite(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj,
+networkRadvdConfWrite(virNetworkDriverState *driver,
+ virNetworkObj *obj,
char **configFile)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_autofree char *configStr = NULL;
g_autofree char *myConfigFile = NULL;
static int
-networkStartRadvd(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkStartRadvd(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_autoptr(dnsmasqCaps) dnsmasq_caps = networkGetDnsmasqCaps(driver);
pid_t radvdPid;
g_autofree char *pidfile = NULL;
static int
-networkRefreshRadvd(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkRefreshRadvd(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_autoptr(dnsmasqCaps) dnsmasq_caps = networkGetDnsmasqCaps(driver);
g_autofree char *radvdpidbase = NULL;
g_autofree char *pidfile = NULL;
#if 0
/* currently unused, so it causes a build error unless we #if it out */
static int
-networkRestartRadvd(virNetworkObjPtr obj)
+networkRestartRadvd(virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
g_autofree char *radvdpidbase = NULL;
g_autofree char *pidfile = NULL;
static int
-networkRefreshDaemonsHelper(virNetworkObjPtr obj,
+networkRefreshDaemonsHelper(virNetworkObj *obj,
void *opaque)
{
- virNetworkDefPtr def;
- virNetworkDriverStatePtr driver = opaque;
+ virNetworkDef *def;
+ virNetworkDriverState *driver = opaque;
virObjectLock(obj);
def = virNetworkObjGetDef(obj);
* This should be called when libvirtd is restarted.
*/
static void
-networkRefreshDaemons(virNetworkDriverStatePtr driver)
+networkRefreshDaemons(virNetworkDriverState *driver)
{
VIR_INFO("Refreshing network daemons");
virNetworkObjListForEach(driver->networks,
static int
-networkReloadFirewallRulesHelper(virNetworkObjPtr obj,
+networkReloadFirewallRulesHelper(virNetworkObj *obj,
void *opaque G_GNUC_UNUSED)
{
- virNetworkDefPtr def;
+ virNetworkDef *def;
virObjectLock(obj);
def = virNetworkObjGetDef(obj);
static void
-networkReloadFirewallRules(virNetworkDriverStatePtr driver,
+networkReloadFirewallRules(virNetworkDriverState *driver,
bool startup,
bool force)
{
static int
-networkSetIPv6Sysctls(virNetworkObjPtr obj)
+networkSetIPv6Sysctls(virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
bool enableIPv6 = !!virNetworkDefGetIPByIndex(def, AF_INET6, 0);
int rc;
/* add an IP address to a bridge */
static int
-networkAddAddrToBridge(virNetworkObjPtr obj,
- virNetworkIPDefPtr ipdef)
+networkAddAddrToBridge(virNetworkObj *obj,
+ virNetworkIPDef *ipdef)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
int prefix = virNetworkIPDefPrefix(ipdef);
if (prefix < 0) {
static int
-networkStartHandleMACTableManagerMode(virNetworkObjPtr obj)
+networkStartHandleMACTableManagerMode(virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
const char *brname = def->bridge;
if (brname &&
/* add an IP (static) route to a bridge */
static int
-networkAddRouteToBridge(virNetworkObjPtr obj,
- virNetDevIPRoutePtr routedef)
+networkAddRouteToBridge(virNetworkObj *obj,
+ virNetDevIPRoute *routedef)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
int prefix = virNetDevIPRouteGetPrefix(routedef);
unsigned int metric = virNetDevIPRouteGetMetric(routedef);
- virSocketAddrPtr addr = virNetDevIPRouteGetAddress(routedef);
- virSocketAddrPtr gateway = virNetDevIPRouteGetGateway(routedef);
+ virSocketAddr *addr = virNetDevIPRouteGetAddress(routedef);
+ virSocketAddr *gateway = virNetDevIPRouteGetGateway(routedef);
if (prefix < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static int
-networkStartNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkStartNetworkVirtual(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
size_t i;
bool v4present = false, v6present = false;
virErrorPtr save_err = NULL;
- virNetworkIPDefPtr ipdef;
- virNetDevIPRoutePtr routedef;
- virMacMapPtr macmap;
+ virNetworkIPDef *ipdef;
+ virNetDevIPRoute *routedef;
+ virMacMap *macmap;
g_autofree char *macMapFile = NULL;
bool dnsmasqStarted = false;
bool devOnline = false;
devOnline = true;
for (i = 0; i < def->nroutes; i++) {
- virSocketAddrPtr gateway = NULL;
+ virSocketAddr *gateway = NULL;
routedef = def->routes[i];
gateway = virNetDevIPRouteGetGateway(routedef);
static int
-networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkShutdownNetworkVirtual(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
pid_t radvdPid;
pid_t dnsmasqPid;
static int
-networkStartNetworkBridge(virNetworkObjPtr obj)
+networkStartNetworkBridge(virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
/* put anything here that needs to be done each time a network of
* type BRIDGE, is started. On failure, undo anything you've done,
static int
-networkShutdownNetworkBridge(virNetworkObjPtr obj G_GNUC_UNUSED)
+networkShutdownNetworkBridge(virNetworkObj *obj G_GNUC_UNUSED)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
/* put anything here that needs to be done each time a network of
* type BRIDGE is shutdown. On failure, undo anything you've done,
* Creates an implicit interface pool of VF's when a PF dev is given
*/
static int
-networkCreateInterfacePool(virNetworkDefPtr netdef)
+networkCreateInterfacePool(virNetworkDef *netdef)
{
size_t numVirtFns = 0;
unsigned int maxVirtFns = 0;
char **vfNames = NULL;
- virPCIDeviceAddressPtr *virtFns;
+ virPCIDeviceAddress **virtFns;
int ret = -1;
size_t i;
netdef->forward.ifs = g_new0(virNetworkForwardIfDef, numVirtFns);
for (i = 0; i < numVirtFns; i++) {
- virPCIDeviceAddressPtr thisVirtFn = virtFns[i];
+ virPCIDeviceAddress *thisVirtFn = virtFns[i];
const char *thisName = vfNames[i];
- virNetworkForwardIfDefPtr thisIf
+ virNetworkForwardIfDef *thisIf
= &netdef->forward.ifs[netdef->forward.nifs];
switch ((virNetworkForwardType) netdef->forward.type) {
static int
-networkStartNetworkExternal(virNetworkObjPtr obj)
+networkStartNetworkExternal(virNetworkObj *obj)
{
/* put anything here that needs to be done each time a network of
* type BRIDGE, PRIVATE, VEPA, HOSTDEV or PASSTHROUGH is started. On
static int
-networkShutdownNetworkExternal(virNetworkObjPtr obj G_GNUC_UNUSED)
+networkShutdownNetworkExternal(virNetworkObj *obj G_GNUC_UNUSED)
{
/* put anything here that needs to be done each time a network of
* type BRIDGE, PRIVATE, VEPA, HOSTDEV or PASSTHROUGH is shutdown. On
static int
-networkStartNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkStartNetwork(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
int ret = -1;
VIR_DEBUG("driver=%p, network=%p", driver, obj);
static int
-networkShutdownNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr obj)
+networkShutdownNetwork(virNetworkDriverState *driver,
+ virNetworkObj *obj)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
int ret = 0;
g_autofree char *stateFile = NULL;
networkLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
obj = virNetworkObjFindByUUID(driver->networks, uuid);
networkLookupByName(virConnectPtr conn,
const char *name)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
obj = virNetworkObjFindByName(driver->networks, name);
static int
networkConnectNumOfNetworks(virConnectPtr conn)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
if (virConnectNumOfNetworksEnsureACL(conn) < 0)
return -1;
char **const names,
int maxnames)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
if (virConnectListNetworksEnsureACL(conn) < 0)
return -1;
static int
networkConnectNumOfDefinedNetworks(virConnectPtr conn)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
if (virConnectNumOfDefinedNetworksEnsureACL(conn) < 0)
return -1;
char **const names,
int maxnames)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
if (virConnectListDefinedNetworksEnsureACL(conn) < 0)
return -1;
virNetworkPtr **nets,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1);
void *opaque,
virFreeCallback freecb)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
int ret = -1;
if (virConnectNetworkEventRegisterAnyEnsureACL(conn) < 0)
networkConnectNetworkEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
if (virConnectNetworkEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
static int
networkIsActive(virNetworkPtr net)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = networkObjFromNetwork(net)))
static int
networkIsPersistent(virNetworkPtr net)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = networkObjFromNetwork(net)))
* than libvirt). Set this network's name to that new name.
*/
static int
-networkFindUnusedBridgeName(virNetworkObjListPtr nets,
- virNetworkDefPtr def)
+networkFindUnusedBridgeName(virNetworkObjList *nets,
+ virNetworkDef *def)
{
int id = 0;
const char *templ = "virbr%d";
* network's bridge name.
*/
static int
-networkBridgeNameValidate(virNetworkObjListPtr nets,
- virNetworkDefPtr def)
+networkBridgeNameValidate(virNetworkObjList *nets,
+ virNetworkDef *def)
{
virMutexLock(&bridgeNameValidateMutex);
static int
-networkValidate(virNetworkDriverStatePtr driver,
- virNetworkDefPtr def)
+networkValidate(virNetworkDriverState *driver,
+ virNetworkDef *def)
{
size_t i, j;
bool vlanUsed, vlanAllowed, badVlanUse = false;
- virPortGroupDefPtr defaultPortGroup = NULL;
- virNetworkIPDefPtr ipdef;
+ virPortGroupDef *defaultPortGroup = NULL;
+ virNetworkIPDef *ipdef;
bool ipv4def = false, ipv6def = false;
bool bandwidthAllowed = false;
bool usesInterface = false, usesAddress = false;
* the type of each.
*/
for (i = 0; i < def->forward.nifs; i++) {
- virNetworkForwardIfDefPtr iface = &def->forward.ifs[i];
+ virNetworkForwardIfDef *iface = &def->forward.ifs[i];
g_autofree char *sysfs_path = NULL;
switch ((virNetworkForwardHostdevDeviceType)iface->type) {
networkCreateXML(virConnectPtr conn,
const char *xml)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr newDef;
- virNetworkObjPtr obj = NULL;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *newDef;
+ virNetworkObj *obj = NULL;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(newDef = virNetworkDefParseString(xml, network_driver->xmlopt)))
goto cleanup;
networkDefineXML(virConnectPtr conn,
const char *xml)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr def = NULL;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *def = NULL;
bool freeDef = true;
- virNetworkObjPtr obj = NULL;
+ virNetworkObj *obj = NULL;
virNetworkPtr net = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(def = virNetworkDefParseString(xml, network_driver->xmlopt)))
goto cleanup;
static int
networkUndefine(virNetworkPtr net)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
bool active = false;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = networkObjFromNetwork(net)))
goto cleanup;
const char *xml,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj = NULL;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj = NULL;
+ virNetworkDef *def;
int isActive, ret = -1;
size_t i;
- virNetworkIPDefPtr ipdef;
+ virNetworkIPDef *ipdef;
bool oldDhcpActive = false;
bool needFirewallRefresh = false;
static int
networkCreate(virNetworkPtr net)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = networkObjFromNetwork(net)))
goto cleanup;
static int
networkDestroy(virNetworkPtr net)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = networkObjFromNetwork(net)))
goto cleanup;
networkGetXMLDesc(virNetworkPtr net,
unsigned int flags)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr curDef;
- virNetworkDefPtr def;
- virNetworkDefPtr newDef;
+ virNetworkObj *obj;
+ virNetworkDef *curDef;
+ virNetworkDef *def;
+ virNetworkDef *newDef;
char *ret = NULL;
virCheckFlags(VIR_NETWORK_XML_INACTIVE, NULL);
static char *
networkGetBridgeName(virNetworkPtr net)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkObj *obj;
+ virNetworkDef *def;
char *bridge = NULL;
if (!(obj = networkObjFromNetwork(net)))
networkGetAutostart(virNetworkPtr net,
int *autostart)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = networkObjFromNetwork(net)))
networkSetAutostart(virNetworkPtr net,
int autostart)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
g_autofree char *configFile = NULL;
g_autofree char *autostartLink = NULL;
bool new_autostart;
virNetworkDHCPLeasePtr **leases,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
size_t i;
size_t nleases = 0;
int rv = -1;
g_autofree char *custom_lease_file = NULL;
g_autoptr(virJSONValue) leases_array = NULL;
g_autofree virNetworkDHCPLeasePtr *leases_ret = NULL;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkObj *obj;
+ virNetworkDef *def;
virMacAddr mac_addr;
virCheckFlags(0, -1);
currtime = (long long)time(NULL);
for (i = 0; i < size; i++) {
- virJSONValuePtr lease_tmp = virJSONValueArrayGet(leases_array, i);
+ virJSONValue *lease_tmp = virJSONValueArrayGet(leases_array, i);
long long expirytime_tmp = -1;
const char *mac_tmp = NULL;
/* Obtain prefix */
for (j = 0; j < def->nips; j++) {
- virNetworkIPDefPtr ipdef_tmp = &def->ips[j];
+ virNetworkIPDef *ipdef_tmp = &def->ips[j];
if (ipv6 && VIR_SOCKET_ADDR_IS_FAMILY(&ipdef_tmp->address,
AF_INET6)) {
/* A unified function to log network connections and disconnections */
static void
-networkLogAllocation(virNetworkDefPtr netdef,
- virNetworkForwardIfDefPtr dev,
- virMacAddrPtr mac,
+networkLogAllocation(virNetworkDef *netdef,
+ virNetworkForwardIfDef *dev,
+ virMacAddr *mac,
bool inUse)
{
char macStr[VIR_MAC_STRING_BUFLEN];
* Returns 0 on success, -1 on failure.
*/
static int
-networkAllocatePort(virNetworkObjPtr obj,
- virNetworkPortDefPtr port)
+networkAllocatePort(virNetworkObj *obj,
+ virNetworkPortDef *port)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr netdef = NULL;
- virPortGroupDefPtr portgroup = NULL;
- virNetworkForwardIfDefPtr dev = NULL;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *netdef = NULL;
+ virPortGroupDef *portgroup = NULL;
+ virNetworkForwardIfDef *dev = NULL;
size_t i;
- virNetDevVPortProfilePtr portprofile = NULL;
+ virNetDevVPortProfile *portprofile = NULL;
netdef = virNetworkObjGetDef(obj);
VIR_DEBUG("Allocating port from net %s", netdef->name);
}
if (port->vlan.nTags == 0) {
- virNetDevVlanPtr vlan = NULL;
+ virNetDevVlan *vlan = NULL;
if (portgroup && portgroup->vlan.nTags > 0)
vlan = &portgroup->vlan;
else if (netdef->vlan.nTags > 0)
* order.
*/
static int
-networkNotifyPort(virNetworkObjPtr obj,
- virNetworkPortDefPtr port)
+networkNotifyPort(virNetworkObj *obj,
+ virNetworkPortDef *port)
{
- virNetworkDefPtr netdef;
- virNetworkForwardIfDefPtr dev = NULL;
+ virNetworkDef *netdef;
+ virNetworkForwardIfDef *dev = NULL;
size_t i;
netdef = virNetworkObjGetDef(obj);
* Returns 0 on success, -1 on failure.
*/
static int
-networkReleasePort(virNetworkObjPtr obj,
- virNetworkPortDefPtr port)
+networkReleasePort(virNetworkObj *obj,
+ virNetworkPortDef *port)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr netdef;
- virNetworkForwardIfDefPtr dev = NULL;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *netdef;
+ virNetworkForwardIfDef *dev = NULL;
size_t i;
netdef = virNetworkObjGetDef(obj);
* 1 if no QoS is set (@new_rate untouched)
*/
static int
-networkCheckBandwidth(virNetworkObjPtr obj,
- virNetDevBandwidthPtr ifaceBand,
- virNetDevBandwidthPtr oldBandwidth,
- virMacAddrPtr ifaceMac,
+networkCheckBandwidth(virNetworkObj *obj,
+ virNetDevBandwidth *ifaceBand,
+ virNetDevBandwidth *oldBandwidth,
+ virMacAddr *ifaceMac,
unsigned long long *new_rate)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
- virNetDevBandwidthPtr netBand = def->bandwidth;
+ virNetworkDef *def = virNetworkObjGetDef(obj);
+ virNetDevBandwidth *netBand = def->bandwidth;
unsigned long long tmp_floor_sum = virNetworkObjGetFloorSum(obj);
unsigned long long tmp_new_rate = 0;
char ifmac[VIR_MAC_STRING_BUFLEN];
* Returns next free class ID or -1 if none is available.
*/
static ssize_t
-networkNextClassID(virNetworkObjPtr obj)
+networkNextClassID(virNetworkObj *obj)
{
ssize_t ret = 0;
- virBitmapPtr classIdMap = virNetworkObjGetClassIdMap(obj);
+ virBitmap *classIdMap = virNetworkObjGetClassIdMap(obj);
if ((ret = virBitmapNextClearBit(classIdMap, -1)) < 0)
ret = virBitmapSize(classIdMap);
static int
-networkPlugBandwidthImpl(virNetworkObjPtr obj,
- virMacAddrPtr mac,
- virNetDevBandwidthPtr ifaceBand,
+networkPlugBandwidthImpl(virNetworkObj *obj,
+ virMacAddr *mac,
+ virNetDevBandwidth *ifaceBand,
unsigned int *class_id,
unsigned long long new_rate)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
- virBitmapPtr classIdMap = virNetworkObjGetClassIdMap(obj);
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *def = virNetworkObjGetDef(obj);
+ virBitmap *classIdMap = virNetworkObjGetClassIdMap(obj);
unsigned long long tmp_floor_sum = virNetworkObjGetFloorSum(obj);
ssize_t next_id = 0;
int plug_ret;
static int
-networkPlugBandwidth(virNetworkObjPtr obj,
- virMacAddrPtr mac,
- virNetDevBandwidthPtr ifaceBand,
+networkPlugBandwidth(virNetworkObj *obj,
+ virMacAddr *mac,
+ virNetDevBandwidth *ifaceBand,
unsigned int *class_id)
{
int plug_ret;
static int
-networkUnplugBandwidth(virNetworkObjPtr obj,
- virNetDevBandwidthPtr ifaceBand,
+networkUnplugBandwidth(virNetworkObj *obj,
+ virNetDevBandwidth *ifaceBand,
unsigned int *class_id)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
- virBitmapPtr classIdMap = virNetworkObjGetClassIdMap(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
+ virBitmap *classIdMap = virNetworkObjGetClassIdMap(obj);
unsigned long long tmp_floor_sum = virNetworkObjGetFloorSum(obj);
- virNetworkDriverStatePtr driver = networkGetDriver();
+ virNetworkDriverState *driver = networkGetDriver();
int ret = 0;
unsigned long long new_rate;
static void
-networkNetworkObjTaint(virNetworkObjPtr obj,
+networkNetworkObjTaint(virNetworkObj *obj,
virNetworkTaintFlags taint)
{
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
if (virNetworkObjTaint(obj, taint)) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
static int
-networkUpdatePortBandwidth(virNetworkObjPtr obj,
- virMacAddrPtr mac,
+networkUpdatePortBandwidth(virNetworkObj *obj,
+ virMacAddr *mac,
unsigned int *class_id,
- virNetDevBandwidthPtr oldBandwidth,
- virNetDevBandwidthPtr newBandwidth)
+ virNetDevBandwidth *oldBandwidth,
+ virNetDevBandwidth *newBandwidth)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkDef *def;
unsigned long long tmp_floor_sum;
unsigned long long new_rate = 0;
unsigned long long old_floor, new_floor;
networkPortLookupByUUID(virNetworkPtr net,
const unsigned char *uuid)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
- virNetworkPortDefPtr portdef = NULL;
+ virNetworkObj *obj;
+ virNetworkDef *def;
+ virNetworkPortDef *portdef = NULL;
virNetworkPortPtr ret = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(uuid, uuidstr);
const char *xmldesc,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
g_autoptr(virNetworkPortDef) portdef = NULL;
virNetworkPortPtr ret = NULL;
int rc;
networkPortGetXMLDesc(virNetworkPortPtr port,
unsigned int flags)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
- virNetworkPortDefPtr portdef = NULL;
+ virNetworkObj *obj;
+ virNetworkDef *def;
+ virNetworkPortDef *portdef = NULL;
char *ret = NULL;
virCheckFlags(0, NULL);
networkPortDelete(virNetworkPortPtr port,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
- virNetworkPortDefPtr portdef;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
+ virNetworkPortDef *portdef;
int ret = -1;
virCheckFlags(0, -1);
int nparams,
unsigned int flags)
{
- virNetworkDriverStatePtr driver = networkGetDriver();
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
- virNetworkPortDefPtr portdef;
+ virNetworkDriverState *driver = networkGetDriver();
+ virNetworkObj *obj;
+ virNetworkDef *def;
+ virNetworkPortDef *portdef;
g_autoptr(virNetDevBandwidth) bandwidth = NULL;
g_autofree char *dir = NULL;
int ret = -1;
int *nparams,
unsigned int flags)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
- virNetworkPortDefPtr portdef;
+ virNetworkObj *obj;
+ virNetworkDef *def;
+ virNetworkPortDef *portdef;
int maxparams = 0;
int ret = -1;
virNetworkPortPtr **ports,
unsigned int flags)
{
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
virCheckFlags(0, -1);
#include "virdnsmasq.h"
#include "virnetworkobj.h"
-virNetworkXMLOptionPtr
+virNetworkXMLOption *
networkDnsmasqCreateXMLConf(void);
int
networkRegister(void);
int
-networkDnsmasqConfContents(virNetworkObjPtr obj,
+networkDnsmasqConfContents(virNetworkObj *obj,
const char *pidfile,
char **configstr,
char **hostsfilestr,
dnsmasqContext *dctx,
- dnsmasqCapsPtr caps);
+ dnsmasqCaps *caps);
static int
-networkHasRunningNetworksWithFWHelper(virNetworkObjPtr obj,
+networkHasRunningNetworksWithFWHelper(virNetworkObj *obj,
void *opaque)
{
bool *activeWithFW = opaque;
virObjectLock(obj);
if (virNetworkObjIsActive(obj)) {
- virNetworkDefPtr def = virNetworkObjGetDef(obj);
+ virNetworkDef *def = virNetworkObjGetDef(obj);
switch ((virNetworkForwardType) def->forward.type) {
case VIR_NETWORK_FORWARD_NONE:
static bool
-networkHasRunningNetworksWithFW(virNetworkDriverStatePtr driver)
+networkHasRunningNetworksWithFW(virNetworkDriverState *driver)
{
bool activeWithFW = false;
void
-networkPreReloadFirewallRules(virNetworkDriverStatePtr driver,
+networkPreReloadFirewallRules(virNetworkDriverState *driver,
bool startup,
bool force)
{
* other scenarios where we can ruin host network connectivity.
* XXX: Using a proper library is preferred over parsing /proc
*/
-int networkCheckRouteCollision(virNetworkDefPtr def)
+int networkCheckRouteCollision(virNetworkDef *def)
{
int len;
char *cur;
while (cur) {
char iface[17], dest[128], mask[128];
unsigned int addr_val, mask_val;
- virNetworkIPDefPtr ipdef;
- virNetDevIPRoutePtr routedef;
+ virNetworkIPDef *ipdef;
+ virNetDevIPRoute *routedef;
int num;
size_t i;
i++) {
virSocketAddr r_mask, r_addr;
- virSocketAddrPtr tmp_addr = virNetDevIPRouteGetAddress(routedef);
+ virSocketAddr *tmp_addr = virNetDevIPRouteGetAddress(routedef);
int r_prefix = virNetDevIPRouteGetPrefix(routedef);
if (!tmp_addr ||
static const char networkLocalBroadcast[] = "255.255.255.255/32";
static int
-networkAddMasqueradingFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkAddMasqueradingFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
int prefix = virNetworkIPDefPrefix(ipdef);
const char *forwardIf = virNetworkDefForwardIf(def, 0);
}
static int
-networkRemoveMasqueradingFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkRemoveMasqueradingFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
int prefix = virNetworkIPDefPrefix(ipdef);
const char *forwardIf = virNetworkDefForwardIf(def, 0);
static int
-networkAddRoutingFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkAddRoutingFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
int prefix = virNetworkIPDefPrefix(ipdef);
const char *forwardIf = virNetworkDefForwardIf(def, 0);
static int
-networkRemoveRoutingFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkRemoveRoutingFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
int prefix = virNetworkIPDefPrefix(ipdef);
const char *forwardIf = virNetworkDefForwardIf(def, 0);
static void
-networkAddGeneralIPv4FirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkAddGeneralIPv4FirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipv4def;
+ virNetworkIPDef *ipv4def;
/* First look for first IPv4 address that has dhcp or tftpboot defined. */
/* We support dhcp config on 1 IPv4 interface only. */
}
static void
-networkRemoveGeneralIPv4FirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkRemoveGeneralIPv4FirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipv4def;
+ virNetworkIPDef *ipv4def;
for (i = 0;
(ipv4def = virNetworkDefGetIPByIndex(def, AF_INET, i));
* If any IPv6 addresses are defined, then add the rules for regular operation.
*/
static void
-networkAddGeneralIPv6FirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkAddGeneralIPv6FirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
if (!virNetworkDefGetIPByIndex(def, AF_INET6, 0) &&
!def->ipv6nogw) {
}
static void
-networkRemoveGeneralIPv6FirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkRemoveGeneralIPv6FirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
if (!virNetworkDefGetIPByIndex(def, AF_INET6, 0) &&
!def->ipv6nogw) {
static void
-networkAddGeneralFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkAddGeneralFirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
networkAddGeneralIPv4FirewallRules(fw, def);
networkAddGeneralIPv6FirewallRules(fw, def);
static void
-networkRemoveGeneralFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkRemoveGeneralFirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
networkRemoveGeneralIPv4FirewallRules(fw, def);
networkRemoveGeneralIPv6FirewallRules(fw, def);
}
static void
-networkAddChecksumFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkAddChecksumFirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipv4def;
+ virNetworkIPDef *ipv4def;
/* First look for first IPv4 address that has dhcp or tftpboot defined. */
/* We support dhcp config on 1 IPv4 interface only. */
static void
-networkRemoveChecksumFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def)
+networkRemoveChecksumFirewallRules(virFirewall *fw,
+ virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipv4def;
+ virNetworkIPDef *ipv4def;
/* First look for first IPv4 address that has dhcp or tftpboot defined. */
/* We support dhcp config on 1 IPv4 interface only. */
static int
-networkAddIPSpecificFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkAddIPSpecificFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
/* NB: in the case of IPv6, routing rules are added when the
* forward mode is NAT. This is because IPv6 has no NAT.
static int
-networkRemoveIPSpecificFirewallRules(virFirewallPtr fw,
- virNetworkDefPtr def,
- virNetworkIPDefPtr ipdef)
+networkRemoveIPSpecificFirewallRules(virFirewall *fw,
+ virNetworkDef *def,
+ virNetworkIPDef *ipdef)
{
if (def->forward.type == VIR_NETWORK_FORWARD_NAT) {
if (VIR_SOCKET_ADDR_IS_FAMILY(&ipdef->address, AF_INET) ||
/* Add all rules for all ip addresses (and general rules) on a network */
-int networkAddFirewallRules(virNetworkDefPtr def)
+int networkAddFirewallRules(virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipdef;
+ virNetworkIPDef *ipdef;
g_autoptr(virFirewall) fw = virFirewallNew();
if (virOnce(&createdOnce, networkSetupPrivateChains) < 0)
}
/* Remove all rules for all ip addresses (and general rules) on a network */
-void networkRemoveFirewallRules(virNetworkDefPtr def)
+void networkRemoveFirewallRules(virNetworkDef *def)
{
size_t i;
- virNetworkIPDefPtr ipdef;
+ virNetworkIPDef *ipdef;
g_autoptr(virFirewall) fw = virFirewallNew();
virFirewallStartTransaction(fw, VIR_FIREWALL_TRANSACTION_IGNORE_ERRORS);
#include <config.h>
-void networkPreReloadFirewallRules(virNetworkDriverStatePtr driver G_GNUC_UNUSED,
+void networkPreReloadFirewallRules(virNetworkDriverState *driver G_GNUC_UNUSED,
bool startup G_GNUC_UNUSED,
bool force G_GNUC_UNUSED)
{
}
-int networkCheckRouteCollision(virNetworkDefPtr def G_GNUC_UNUSED)
+int networkCheckRouteCollision(virNetworkDef *def G_GNUC_UNUSED)
{
return 0;
}
-int networkAddFirewallRules(virNetworkDefPtr def G_GNUC_UNUSED)
+int networkAddFirewallRules(virNetworkDef *def G_GNUC_UNUSED)
{
return 0;
}
-void networkRemoveFirewallRules(virNetworkDefPtr def G_GNUC_UNUSED)
+void networkRemoveFirewallRules(virNetworkDef *def G_GNUC_UNUSED)
{
}
int lockFD;
/* Immutable pointer, self-locking APIs */
- virNetworkObjListPtr networks;
+ virNetworkObjList *networks;
/* Immutable pointers, Immutable objects */
char *networkConfigDir;
/* Require lock to get a reference on the object,
* lockless access thereafter
*/
- dnsmasqCapsPtr dnsmasqCaps;
+ dnsmasqCaps *dnsmasqCaps;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr networkEventState;
+ virObjectEventState *networkEventState;
- virNetworkXMLOptionPtr xmlopt;
+ virNetworkXMLOption *xmlopt;
};
typedef struct _virNetworkDriverState virNetworkDriverState;
-typedef virNetworkDriverState *virNetworkDriverStatePtr;
-void networkPreReloadFirewallRules(virNetworkDriverStatePtr driver, bool startup, bool force);
+void networkPreReloadFirewallRules(virNetworkDriverState *driver, bool startup, bool force);
void networkPostReloadFirewallRules(bool startup);
-int networkCheckRouteCollision(virNetworkDefPtr def);
+int networkCheckRouteCollision(virNetworkDef *def);
-int networkAddFirewallRules(virNetworkDefPtr def);
+int networkAddFirewallRules(virNetworkDef *def);
-void networkRemoveFirewallRules(virNetworkDefPtr def);
+void networkRemoveFirewallRules(virNetworkDef *def);
#define VIR_FROM_THIS VIR_FROM_NODEDEV
-virNodeDeviceDriverStatePtr driver;
+virNodeDeviceDriverState *driver;
virDrvOpenStatus
nodeConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
* the driver name for a device each time its entry is used.
*/
static int
-nodeDeviceUpdateDriverName(virNodeDeviceDefPtr def)
+nodeDeviceUpdateDriverName(virNodeDeviceDef *def)
{
g_autofree char *driver_link = NULL;
g_autofree char *devpath = NULL;
#else
/* XXX: Implement me for non-linux */
static int
-nodeDeviceUpdateDriverName(virNodeDeviceDefPtr def G_GNUC_UNUSED)
+nodeDeviceUpdateDriverName(virNodeDeviceDef *def G_GNUC_UNUSED)
{
return 0;
}
}
-static virNodeDeviceObjPtr
+static virNodeDeviceObj *
nodeDeviceObjFindByName(const char *name)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
if (!(obj = virNodeDeviceObjListFindByName(driver->devs, name))) {
virReportError(VIR_ERR_NO_NODE_DEVICE,
nodeDeviceLookupByName(virConnectPtr conn,
const char *name)
{
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
virNodeDevicePtr device = NULL;
if (nodeDeviceWaitInit() < 0)
const char *wwpn,
unsigned int flags)
{
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *def;
virNodeDevicePtr device = NULL;
virCheckFlags(0, NULL);
const char *uuid,
unsigned int flags)
{
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *def;
virNodeDevicePtr device = NULL;
virCheckFlags(0, NULL);
nodeDeviceGetXMLDesc(virNodeDevicePtr device,
unsigned int flags)
{
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
char *ret = NULL;
virCheckFlags(0, NULL);
char *
nodeDeviceGetParent(virNodeDevicePtr device)
{
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
char *ret = NULL;
if (!(obj = nodeDeviceObjFindByName(device->name)))
int
nodeDeviceNumOfCaps(virNodeDevicePtr device)
{
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
int ret = -1;
if (!(obj = nodeDeviceObjFindByName(device->name)))
char **const names,
int maxnames)
{
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
virNodeDevCapType *list = NULL;
int ncaps = 0;
int ret = -1;
static bool
-nodeDeviceHasCapability(virNodeDeviceDefPtr def, virNodeDevCapType type)
+nodeDeviceHasCapability(virNodeDeviceDef *def, virNodeDevCapType type)
{
- virNodeDevCapsDefPtr cap = def->caps;
+ virNodeDevCapsDef *cap = def->caps;
while (cap != NULL) {
if (cap->data.type == type)
/* format a json string that provides configuration information about this mdev
* to the mdevctl utility */
static int
-nodeDeviceDefToMdevctlConfig(virNodeDeviceDefPtr def, char **buf)
+nodeDeviceDefToMdevctlConfig(virNodeDeviceDef *def, char **buf)
{
size_t i;
- virNodeDevCapMdevPtr mdev = &def->caps->data.mdev;
+ virNodeDevCapMdev *mdev = &def->caps->data.mdev;
g_autoptr(virJSONValue) json = virJSONValueNewObject();
if (virJSONValueObjectAppendString(json, "mdev_type", mdev->type) < 0)
g_autoptr(virJSONValue) attributes = virJSONValueNewArray();
for (i = 0; i < mdev->nattributes; i++) {
- virMediatedDeviceAttrPtr attr = mdev->attributes[i];
+ virMediatedDeviceAttr *attr = mdev->attributes[i];
g_autoptr(virJSONValue) jsonattr = virJSONValueNewObject();
if (virJSONValueObjectAppendString(jsonattr, attr->name, attr->value) < 0)
static char *
nodeDeviceFindAddressByName(const char *name)
{
- virNodeDeviceDefPtr def = NULL;
- virNodeDevCapsDefPtr caps = NULL;
+ virNodeDeviceDef *def = NULL;
+ virNodeDevCapsDef *caps = NULL;
char *addr = NULL;
- virNodeDeviceObjPtr dev = virNodeDeviceObjListFindByName(driver->devs, name);
+ virNodeDeviceObj *dev = virNodeDeviceObjListFindByName(driver->devs, name);
if (!dev) {
virReportError(VIR_ERR_NO_NODE_DEVICE,
char **uuid_out,
char **errmsg)
{
- virCommandPtr cmd;
+ virCommand *cmd;
g_autofree char *json = NULL;
g_autofree char *parent_addr = nodeDeviceFindAddressByName(def->parent);
static int
-virMdevctlStart(virNodeDeviceDefPtr def, char **uuid, char **errmsg)
+virMdevctlStart(virNodeDeviceDef *def, char **uuid, char **errmsg)
{
int status;
g_autoptr(virCommand) cmd = nodeDeviceGetMdevctlStartCommand(def, uuid,
static int
-virMdevctlDefine(virNodeDeviceDefPtr def, char **uuid, char **errmsg)
+virMdevctlDefine(virNodeDeviceDef *def, char **uuid, char **errmsg)
{
int status;
g_autoptr(virCommand) cmd = nodeDeviceGetMdevctlDefineCommand(def, uuid, errmsg);
static virNodeDevicePtr
nodeDeviceCreateXMLMdev(virConnectPtr conn,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
g_autofree char *uuid = NULL;
g_autofree char *errmsg = NULL;
}
-virCommandPtr
+virCommand *
nodeDeviceGetMdevctlStopCommand(const char *uuid, char **errmsg)
{
- virCommandPtr cmd = virCommandNewArgList(MDEVCTL,
- "stop",
- "-u",
- uuid,
- NULL);
+ virCommand *cmd = virCommandNewArgList(MDEVCTL,
+ "stop",
+ "-u",
+ uuid,
+ NULL);
virCommandSetErrorBuffer(cmd, errmsg);
return cmd;
return cmd;
}
-virCommand*
+virCommand *
nodeDeviceGetMdevctlCreateCommand(const char *uuid, char **errmsg)
{
virCommand *cmd = virCommandNewArgList(MDEVCTL,
}
static int
-virMdevctlStop(virNodeDeviceDefPtr def, char **errmsg)
+virMdevctlStop(virNodeDeviceDef *def, char **errmsg)
{
int status;
g_autoptr(virCommand) cmd = NULL;
nodeDeviceDestroy(virNodeDevicePtr device)
{
int ret = -1;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr def;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *def;
g_autofree char *parent = NULL;
g_autofree char *wwnn = NULL;
g_autofree char *wwpn = NULL;
void
nodeDeviceUnlock(void);
-extern virNodeDeviceDriverStatePtr driver;
+extern virNodeDeviceDriverState *driver;
int
nodedevRegister(void);
virDrvOpenStatus nodeConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth,
- virConfPtr conf,
+ virConf *conf,
unsigned int flags);
int nodeConnectClose(virConnectPtr conn);
int nodeConnectIsSecure(virConnectPtr conn);
nodeConnectNodeDeviceEventDeregisterAny(virConnectPtr conn,
int callbackID);
-virCommandPtr
-nodeDeviceGetMdevctlStartCommand(virNodeDeviceDefPtr def,
+virCommand *
+nodeDeviceGetMdevctlStartCommand(virNodeDeviceDef *def,
char **uuid_out,
char **errmsg);
char **uuid_out,
char **errmsg);
-virCommandPtr
+virCommand *
nodeDeviceGetMdevctlStopCommand(const char *uuid,
char **errmsg);
nodeDeviceGetMdevctlUndefineCommand(const char *uuid,
char **errmsg);
-virCommandPtr
+virCommand *
nodeDeviceGetMdevctlListCommand(bool defined,
char **output,
char **errmsg);
#endif
typedef struct _udevEventData udevEventData;
-typedef udevEventData *udevEventDataPtr;
-
struct _udevEventData {
virObjectLockable parent;
int mdevctlTimeout;
};
-static virClassPtr udevEventDataClass;
+static virClass *udevEventDataClass;
static void
udevEventDataDispose(void *obj)
{
struct udev *udev = NULL;
- udevEventDataPtr priv = obj;
+ udevEventData *priv = obj;
if (priv->watch != -1)
virEventRemoveHandle(priv->watch);
VIR_ONCE_GLOBAL_INIT(udevEventData);
-static udevEventDataPtr
+static udevEventData *
udevEventDataNew(void)
{
- udevEventDataPtr ret = NULL;
+ udevEventData *ret = NULL;
if (udevEventDataInitialize() < 0)
return NULL;
static int
udevGenerateDeviceName(struct udev_device *device,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
const char *s)
{
nodeDeviceGenerateName(def,
static int
udevProcessPCI(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapPCIDevPtr pci_dev = &def->caps->data.pci_dev;
- virPCIEDeviceInfoPtr pci_express = NULL;
- virPCIDevicePtr pciDev = NULL;
+ virNodeDevCapPCIDev *pci_dev = &def->caps->data.pci_dev;
+ virPCIEDeviceInfo *pci_express = NULL;
+ virPCIDevice *pciDev = NULL;
virPCIDeviceAddress devAddr;
int ret = -1;
char *p;
static int
udevProcessDRMDevice(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapDRMPtr drm = &def->caps->data.drm;
+ virNodeDevCapDRM *drm = &def->caps->data.drm;
int minor;
if (udevGenerateDeviceName(device, def, NULL) != 0)
static int
udevProcessUSBDevice(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapUSBDevPtr usb_dev = &def->caps->data.usb_dev;
+ virNodeDevCapUSBDev *usb_dev = &def->caps->data.usb_dev;
if (udevGetUintProperty(device, "BUSNUM", &usb_dev->bus, 10) < 0)
return -1;
static int
udevProcessUSBInterface(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapUSBIfPtr usb_if = &def->caps->data.usb_if;
+ virNodeDevCapUSBIf *usb_if = &def->caps->data.usb_if;
if (udevGetUintSysfsAttr(device, "bInterfaceNumber",
&usb_if->number, 16) < 0)
static int
udevProcessNetworkInterface(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
const char *devtype = udev_device_get_devtype(device);
- virNodeDevCapNetPtr net = &def->caps->data.net;
+ virNodeDevCapNet *net = &def->caps->data.net;
if (devtype && STREQ(devtype, "wlan")) {
net->subtype = VIR_NODE_DEV_CAP_NET_80211;
static int
udevProcessSCSIHost(struct udev_device *device G_GNUC_UNUSED,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapSCSIHostPtr scsi_host = &def->caps->data.scsi_host;
+ virNodeDevCapSCSIHost *scsi_host = &def->caps->data.scsi_host;
g_autofree char *filename = NULL;
char *str;
static int
udevProcessSCSITarget(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
const char *sysname = NULL;
- virNodeDevCapSCSITargetPtr scsi_target = &def->caps->data.scsi_target;
+ virNodeDevCapSCSITarget *scsi_target = &def->caps->data.scsi_target;
sysname = udev_device_get_sysname(device);
static int
-udevGetSCSIType(virNodeDeviceDefPtr def G_GNUC_UNUSED,
+udevGetSCSIType(virNodeDeviceDef *def G_GNUC_UNUSED,
unsigned int type,
char **typestring)
{
static int
udevProcessSCSIDevice(struct udev_device *device G_GNUC_UNUSED,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
int ret = -1;
unsigned int tmp = 0;
- virNodeDevCapSCSIPtr scsi = &def->caps->data.scsi;
+ virNodeDevCapSCSI *scsi = &def->caps->data.scsi;
g_autofree char *filename = NULL;
char *p = NULL;
static int
udevProcessDisk(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapStoragePtr storage = &def->caps->data.storage;
+ virNodeDevCapStorage *storage = &def->caps->data.storage;
if (udevGetUint64SysfsAttr(device, "size", &storage->num_blocks) < 0)
return -1;
static int
udevProcessRemoveableMedia(struct udev_device *device,
- virNodeDeviceDefPtr def,
+ virNodeDeviceDef *def,
int has_media)
{
- virNodeDevCapStoragePtr storage = &def->caps->data.storage;
+ virNodeDevCapStorage *storage = &def->caps->data.storage;
int is_removable = 0;
if (udevGetIntSysfsAttr(device, "removable", &is_removable, 0) < 0)
static int
udevProcessCDROM(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
int has_media = 0;
static int
udevProcessFloppy(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
int has_media = 0;
static int
udevProcessSD(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapStoragePtr storage = &def->caps->data.storage;
+ virNodeDevCapStorage *storage = &def->caps->data.storage;
if (udevGetUint64SysfsAttr(device, "size",
&storage->num_blocks) < 0)
static int
udevProcessDASD(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapStoragePtr storage = &def->caps->data.storage;
+ virNodeDevCapStorage *storage = &def->caps->data.storage;
if (udevGetStringSysfsAttr(device, "device/uid", &storage->serial) < 0)
return -1;
* a storage device, and we can make a good guess at what kind of
* storage device it is from other information that is provided. */
static int
-udevKludgeStorageType(virNodeDeviceDefPtr def)
+udevKludgeStorageType(virNodeDeviceDef *def)
{
VIR_DEBUG("Could not find definitive storage type for device "
"with sysfs path '%s', trying to guess it",
static int
udevProcessStorage(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
- virNodeDevCapStoragePtr storage = &def->caps->data.storage;
+ virNodeDevCapStorage *storage = &def->caps->data.storage;
int ret = -1;
const char* devnode;
static int
udevProcessSCSIGeneric(struct udev_device *dev,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
if (udevGetStringProperty(dev, "DEVNAME", &def->caps->data.sg.path) < 0 ||
!def->caps->data.sg.path)
static int
udevProcessMediatedDevice(struct udev_device *dev,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
int ret = -1;
int iommugrp = -1;
char *linkpath = NULL;
char *canonicalpath = NULL;
- virNodeDevCapMdevPtr data = &def->caps->data.mdev;
+ virNodeDevCapMdev *data = &def->caps->data.mdev;
/* Because of a kernel uevent race, we might get the 'add' event prior to
* the sysfs tree being ready, so any attempt to access any sysfs attribute
static int
udevGetCCWAddress(const char *sysfs_path,
- virNodeDevCapDataPtr data)
+ virNodeDevCapData *data)
{
char *p;
static int
udevProcessCCW(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
int online = 0;
static int
udevProcessCSS(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
/* only process IO subchannel and vfio-ccw devices to keep the list sane */
if (!def->driver ||
static int
udevGetVDPACharDev(const char *sysfs_path,
- virNodeDevCapDataPtr data)
+ virNodeDevCapData *data)
{
struct dirent *entry;
g_autoptr(DIR) dir = NULL;
static int
udevProcessVDPA(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
if (udevGenerateDeviceName(device, def, NULL) != 0)
return -1;
static int
udevProcessAPCard(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
char *c;
- virNodeDevCapDataPtr data = &def->caps->data;
+ virNodeDevCapData *data = &def->caps->data;
/* The sysfs path would be in the format /sys/bus/ap/devices/cardXX,
where XX is the ap adapter id */
static int
udevProcessAPQueue(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
char *c;
- virNodeDevCapDataPtr data = &def->caps->data;
+ virNodeDevCapData *data = &def->caps->data;
/* The sysfs path would be in the format /sys/bus/ap/devices
/XX.YYYY, where XX is the ap adapter id and YYYY is the ap
static int
udevProcessAPMatrix(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
/* Both udev_device_get_sysname and udev_device_get_subsystem return
* "matrix" for an AP matrix device, so in order to prevent confusion in
* naming, let's fallback to hardcoding the name.
*/
- virNodeDevCapDataPtr data = &def->caps->data;
+ virNodeDevCapData *data = &def->caps->data;
data->ap_matrix.addr = g_strdup(udev_device_get_sysname(device));
def->name = g_strdup("ap_matrix");
static int
udevGetDeviceNodes(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
const char *devnode = NULL;
struct udev_list_entry *list_entry = NULL;
static int
udevGetDeviceDetails(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
switch (def->caps->data.type) {
case VIR_NODE_DEV_CAP_PCI_DEV:
static int
udevRemoveOneDeviceSysPath(const char *path)
{
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr def;
- virObjectEventPtr event = NULL;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *def;
+ virObjectEvent *event = NULL;
if (!(obj = virNodeDeviceObjListFindBySysfsPath(driver->devs, path))) {
VIR_DEBUG("Failed to find device to remove that has udev path '%s'",
static int
udevSetParent(struct udev_device *device,
- virNodeDeviceDefPtr def)
+ virNodeDeviceDef *def)
{
struct udev_device *parent_device = NULL;
const char *parent_sysfs_path = NULL;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr objdef;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *objdef;
parent_device = device;
do {
static int
udevAddOneDevice(struct udev_device *device)
{
- virNodeDeviceDefPtr def = NULL;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr objdef;
- virObjectEventPtr event = NULL;
+ virNodeDeviceDef *def = NULL;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *objdef;
+ virObjectEvent *event = NULL;
bool new_device = true;
int ret = -1;
bool was_persistent = false;
static int
nodeStateCleanup(void)
{
- udevEventDataPtr priv = NULL;
+ udevEventData *priv = NULL;
if (!driver)
return -1;
* this function
*/
static bool
-udevEventMonitorSanityCheck(udevEventDataPtr priv,
+udevEventMonitorSanityCheck(udevEventData *priv,
int fd)
{
int rc = -1;
static void
udevEventHandleThread(void *opaque G_GNUC_UNUSED)
{
- udevEventDataPtr priv = driver->privateData;
+ udevEventData *priv = driver->privateData;
struct udev_device *device = NULL;
/* continue rather than break from the loop on non-fatal errors */
int events G_GNUC_UNUSED,
void *data G_GNUC_UNUSED)
{
- udevEventDataPtr priv = driver->privateData;
+ udevEventData *priv = driver->privateData;
virObjectLock(priv);
/* DMI is intel-compatible specific */
#if defined(__x86_64__) || defined(__i386__) || defined(__amd64__)
static void
-udevGetDMIData(virNodeDevCapSystemPtr syscap)
+udevGetDMIData(virNodeDevCapSystem *syscap)
{
- udevEventDataPtr priv = driver->privateData;
+ udevEventData *priv = driver->privateData;
struct udev *udev = NULL;
struct udev_device *device = NULL;
- virNodeDevCapSystemHardwarePtr hardware = &syscap->hardware;
- virNodeDevCapSystemFirmwarePtr firmware = &syscap->firmware;
+ virNodeDevCapSystemHardware *hardware = &syscap->hardware;
+ virNodeDevCapSystemFirmware *firmware = &syscap->firmware;
virObjectLock(priv);
udev = udev_monitor_get_udev(priv->udev_monitor);
static int
udevSetupSystemDev(void)
{
- virNodeDeviceDefPtr def = NULL;
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceDef *def = NULL;
+ virNodeDeviceObj *obj = NULL;
int ret = -1;
def = g_new0(virNodeDeviceDef, 1);
nodeStateInitializeEnumerate(void *opaque)
{
struct udev *udev = opaque;
- udevEventDataPtr priv = driver->privateData;
+ udevEventData *priv = driver->privateData;
/* Populate with known devices */
if (udevEnumerateDevices(udev) != 0)
virStateInhibitCallback callback G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- udevEventDataPtr priv = NULL;
+ udevEventData *priv = NULL;
struct udev *udev = NULL;
if (root != NULL) {
# define VIR_IFKEY_LEN ((VIR_UUID_STRING_BUFLEN) + (VIR_MAC_STRING_BUFLEN))
typedef struct _virNWFilterSnoopReq virNWFilterSnoopReq;
-typedef virNWFilterSnoopReq *virNWFilterSnoopReqPtr;
typedef struct _virNWFilterSnoopIPLease virNWFilterSnoopIPLease;
-typedef virNWFilterSnoopIPLease *virNWFilterSnoopIPLeasePtr;
typedef enum {
THREAD_STATUS_NONE,
*/
int refctr;
- virNWFilterTechDriverPtr techdriver;
- virNWFilterBindingDefPtr binding;
+ virNWFilterTechDriver * techdriver;
+ virNWFilterBindingDef * binding;
int ifindex;
char ifkey[VIR_IFKEY_LEN];
- virNWFilterDriverStatePtr driver;
+ virNWFilterDriverState * driver;
/* start and end of lease list, ordered by lease time */
- virNWFilterSnoopIPLeasePtr start;
- virNWFilterSnoopIPLeasePtr end;
+ virNWFilterSnoopIPLease * start;
+ virNWFilterSnoopIPLease * end;
char *threadkey;
virErrorPtr threadError;
struct _virNWFilterSnoopIPLease {
virSocketAddr ipAddress;
virSocketAddr ipServer;
- virNWFilterSnoopReqPtr snoopReq;
+ virNWFilterSnoopReq * snoopReq;
unsigned int timeout;
/* timer list */
- virNWFilterSnoopIPLeasePtr prev;
- virNWFilterSnoopIPLeasePtr next;
+ virNWFilterSnoopIPLease *prev;
+ virNWFilterSnoopIPLease *next;
};
typedef struct _virNWFilterSnoopEthHdr virNWFilterSnoopEthHdr;
-typedef virNWFilterSnoopEthHdr *virNWFilterSnoopEthHdrPtr;
-
struct _virNWFilterSnoopEthHdr {
virMacAddr eh_dst;
virMacAddr eh_src;
G_STATIC_ASSERT(sizeof(struct _virNWFilterSnoopEthHdr) == 14);
typedef struct _virNWFilterSnoopDHCPHdr virNWFilterSnoopDHCPHdr;
-typedef virNWFilterSnoopDHCPHdr *virNWFilterSnoopDHCPHdrPtr;
-
struct _virNWFilterSnoopDHCPHdr {
uint8_t d_op;
uint8_t d_htype;
# define PCAP_FLOOD_TIMEOUT_MS 10 /* ms */
typedef struct _virNWFilterDHCPDecodeJob virNWFilterDHCPDecodeJob;
-typedef virNWFilterDHCPDecodeJob *virNWFilterDHCPDecodeJobPtr;
-
struct _virNWFilterDHCPDecodeJob {
unsigned char packet[PCAP_PBUFSIZE];
int caplen;
# define MAX_QUEUED_JOBS (DHCP_PKT_BURST + 2 * DHCP_PKT_RATE)
typedef struct _virNWFilterSnoopRateLimitConf virNWFilterSnoopRateLimitConf;
-typedef virNWFilterSnoopRateLimitConf *virNWFilterSnoopRateLimitConfPtr;
-
struct _virNWFilterSnoopRateLimitConf {
time_t prev;
unsigned int pkt_ctr;
# define SNOOP_POLL_MAX_TIMEOUT_MS (10 * 1000) /* milliseconds */
typedef struct _virNWFilterSnoopPcapConf virNWFilterSnoopPcapConf;
-typedef virNWFilterSnoopPcapConf *virNWFilterSnoopPcapConfPtr;
-
struct _virNWFilterSnoopPcapConf {
pcap_t *handle;
const pcap_direction_t dir;
};
/* local function prototypes */
-static int virNWFilterSnoopReqLeaseDel(virNWFilterSnoopReqPtr req,
- virSocketAddrPtr ipaddr,
+static int virNWFilterSnoopReqLeaseDel(virNWFilterSnoopReq *req,
+ virSocketAddr *ipaddr,
bool update_leasefile,
bool instantiate);
-static void virNWFilterSnoopReqLock(virNWFilterSnoopReqPtr req);
-static void virNWFilterSnoopReqUnlock(virNWFilterSnoopReqPtr req);
+static void virNWFilterSnoopReqLock(virNWFilterSnoopReq *req);
+static void virNWFilterSnoopReqUnlock(virNWFilterSnoopReq *req);
static void virNWFilterSnoopLeaseFileLoad(void);
-static void virNWFilterSnoopLeaseFileSave(virNWFilterSnoopIPLeasePtr ipl);
+static void virNWFilterSnoopLeaseFileSave(virNWFilterSnoopIPLease *ipl);
/* local variables */
static struct virNWFilterSnoopState virNWFilterSnoopState = {
static char *
-virNWFilterSnoopActivate(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopActivate(virNWFilterSnoopReq *req)
{
g_autofree char *key = g_strdup_printf("%p-%d", req, req->ifindex);
char *ret = NULL;
* virNWFilterSnoopListAdd - add an IP lease to a list
*/
static void
-virNWFilterSnoopListAdd(virNWFilterSnoopIPLeasePtr plnew,
- virNWFilterSnoopIPLeasePtr *start,
- virNWFilterSnoopIPLeasePtr *end)
+virNWFilterSnoopListAdd(virNWFilterSnoopIPLease *plnew,
+ virNWFilterSnoopIPLease **start,
+ virNWFilterSnoopIPLease **end)
{
- virNWFilterSnoopIPLeasePtr pl;
+ virNWFilterSnoopIPLease *pl;
plnew->next = plnew->prev = NULL;
* virNWFilterSnoopListDel - remove an IP lease from a list
*/
static void
-virNWFilterSnoopListDel(virNWFilterSnoopIPLeasePtr ipl,
- virNWFilterSnoopIPLeasePtr *start,
- virNWFilterSnoopIPLeasePtr *end)
+virNWFilterSnoopListDel(virNWFilterSnoopIPLease *ipl,
+ virNWFilterSnoopIPLease **start,
+ virNWFilterSnoopIPLease **end)
{
if (ipl->prev)
ipl->prev->next = ipl->next;
* virNWFilterSnoopLeaseTimerAdd - add an IP lease to the timer list
*/
static void
-virNWFilterSnoopIPLeaseTimerAdd(virNWFilterSnoopIPLeasePtr plnew)
+virNWFilterSnoopIPLeaseTimerAdd(virNWFilterSnoopIPLease *plnew)
{
- virNWFilterSnoopReqPtr req = plnew->snoopReq;
+ virNWFilterSnoopReq *req = plnew->snoopReq;
/* protect req->start / req->end */
virNWFilterSnoopReqLock(req);
* virNWFilterSnoopLeaseTimerDel - remove an IP lease from the timer list
*/
static void
-virNWFilterSnoopIPLeaseTimerDel(virNWFilterSnoopIPLeasePtr ipl)
+virNWFilterSnoopIPLeaseTimerDel(virNWFilterSnoopIPLease *ipl)
{
- virNWFilterSnoopReqPtr req = ipl->snoopReq;
+ virNWFilterSnoopReq *req = ipl->snoopReq;
/* protect req->start / req->end */
virNWFilterSnoopReqLock(req);
* efficient.
*/
static int
-virNWFilterSnoopIPLeaseInstallRule(virNWFilterSnoopIPLeasePtr ipl,
+virNWFilterSnoopIPLeaseInstallRule(virNWFilterSnoopIPLease *ipl,
bool instantiate)
{
g_autofree char *ipaddr = virSocketAddrFormat(&ipl->ipAddress);
int rc = -1;
- virNWFilterSnoopReqPtr req;
+ virNWFilterSnoopReq *req;
if (!ipaddr)
return -1;
* virNWFilterSnoopIPLeaseUpdate - update the timeout on an IP lease
*/
static void
-virNWFilterSnoopIPLeaseUpdate(virNWFilterSnoopIPLeasePtr ipl, time_t timeout)
+virNWFilterSnoopIPLeaseUpdate(virNWFilterSnoopIPLease *ipl, time_t timeout)
{
if (timeout < ipl->timeout)
return; /* no take-backs */
/*
* virNWFilterSnoopGetByIP - lookup IP lease by IP address
*/
-static virNWFilterSnoopIPLeasePtr
-virNWFilterSnoopIPLeaseGetByIP(virNWFilterSnoopIPLeasePtr start,
- virSocketAddrPtr ipaddr)
+static virNWFilterSnoopIPLease *
+virNWFilterSnoopIPLeaseGetByIP(virNWFilterSnoopIPLease *start,
+ virSocketAddr *ipaddr)
{
- virNWFilterSnoopIPLeasePtr pl;
+ virNWFilterSnoopIPLease *pl;
for (pl = start;
pl && !virSocketAddrEqual(&pl->ipAddress, ipaddr);
* virNWFilterSnoopReqLeaseTimerRun - run the IP lease timeout list
*/
static unsigned int
-virNWFilterSnoopReqLeaseTimerRun(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqLeaseTimerRun(virNWFilterSnoopReq *req)
{
time_t now = time(0);
bool is_last = false;
* Get a reference to the given Snoop request
*/
static void
-virNWFilterSnoopReqGet(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqGet(virNWFilterSnoopReq *req)
{
g_atomic_int_add(&req->refctr, 1);
}
* interface key. The caller must release the request with a call
* to virNWFilerSnoopReqPut(req).
*/
-static virNWFilterSnoopReqPtr
+static virNWFilterSnoopReq *
virNWFilterSnoopReqNew(const char *ifkey)
{
- g_autofree virNWFilterSnoopReqPtr req = g_new0(virNWFilterSnoopReq, 1);
+ g_autofree virNWFilterSnoopReq *req = g_new0(virNWFilterSnoopReq, 1);
if (ifkey == NULL || strlen(ifkey) != VIR_IFKEY_LEN - 1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
* The lease file is NOT rewritten.
*/
static void
-virNWFilterSnoopReqFree(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqFree(virNWFilterSnoopReq *req)
{
- virNWFilterSnoopIPLeasePtr ipl;
+ virNWFilterSnoopIPLease *ipl;
if (!req)
return;
* Lock a Snoop request 'req'
*/
static void
-virNWFilterSnoopReqLock(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqLock(virNWFilterSnoopReq *req)
{
virMutexLock(&req->lock);
}
* Unlock a Snoop request 'req'
*/
static void
-virNWFilterSnoopReqUnlock(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqUnlock(virNWFilterSnoopReq *req)
{
virMutexUnlock(&req->lock);
}
static void
virNWFilterSnoopReqRelease(void *req0)
{
- virNWFilterSnoopReqPtr req = req0;
+ virNWFilterSnoopReq *req = req0;
if (!req)
return;
* Get a Snoop request given an interface key; caller must release
* the Snoop request with a call to virNWFilterSnoopReqPut()
*/
-static virNWFilterSnoopReqPtr
+static virNWFilterSnoopReq *
virNWFilterSnoopReqGetByIFKey(const char *ifkey)
{
- virNWFilterSnoopReqPtr req;
+ virNWFilterSnoopReq *req;
virNWFilterSnoopLock();
* after this call.
*/
static void
-virNWFilterSnoopReqPut(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqPut(virNWFilterSnoopReq *req)
{
if (!req)
return;
* virNWFilterSnoopReqLeaseAdd - create or update an IP lease
*/
static int
-virNWFilterSnoopReqLeaseAdd(virNWFilterSnoopReqPtr req,
- virNWFilterSnoopIPLeasePtr plnew,
+virNWFilterSnoopReqLeaseAdd(virNWFilterSnoopReq *req,
+ virNWFilterSnoopIPLease *plnew,
bool update_leasefile)
{
- virNWFilterSnoopIPLeasePtr pl;
+ virNWFilterSnoopIPLease *pl;
plnew->snoopReq = req;
* and re-build the filtering rules with them
*/
static int
-virNWFilterSnoopReqRestore(virNWFilterSnoopReqPtr req)
+virNWFilterSnoopReqRestore(virNWFilterSnoopReq *req)
{
int ret = 0;
- virNWFilterSnoopIPLeasePtr ipl;
+ virNWFilterSnoopIPLease *ipl;
/* protect req->start */
virNWFilterSnoopReqLock(req);
* Returns 0 on success, -1 if the instantiation of the rules failed
*/
static int
-virNWFilterSnoopReqLeaseDel(virNWFilterSnoopReqPtr req,
- virSocketAddrPtr ipaddr, bool update_leasefile,
+virNWFilterSnoopReqLeaseDel(virNWFilterSnoopReq *req,
+ virSocketAddr *ipaddr, bool update_leasefile,
bool instantiate)
{
int ret = 0;
- virNWFilterSnoopIPLeasePtr ipl;
+ virNWFilterSnoopIPLease *ipl;
g_autofree char *ipstr = NULL;
/* protect req->start, req->ifname and the lease */
req->binding,
req->ifindex);
} else {
- virNWFilterVarValuePtr dhcpsrvrs =
+ virNWFilterVarValue *dhcpsrvrs =
virHashLookup(req->binding->filterparams,
NWFILTER_VARNAME_DHCPSERVER);
}
static int
-virNWFilterSnoopDHCPGetOpt(virNWFilterSnoopDHCPHdrPtr pd, int len,
+virNWFilterSnoopDHCPGetOpt(virNWFilterSnoopDHCPHdr *pd, int len,
uint8_t *pmtype, uint32_t *pleasetime)
{
int oind, olen;
* Returns -1 in case of error with the installation of rules
*/
static int
-virNWFilterSnoopDHCPDecode(virNWFilterSnoopReqPtr req,
- virNWFilterSnoopEthHdrPtr pep,
+virNWFilterSnoopDHCPDecode(virNWFilterSnoopReq *req,
+ virNWFilterSnoopEthHdr *pep,
int len, bool fromVM)
{
struct iphdr *pip;
struct udphdr *pup;
- virNWFilterSnoopDHCPHdrPtr pd;
+ virNWFilterSnoopDHCPHdr *pd;
virNWFilterSnoopIPLease ipl;
uint8_t mtype;
uint32_t leasetime;
if (len < 0)
return -2;
- pd = (virNWFilterSnoopDHCPHdrPtr) ((char *)pup + sizeof(*pup));
+ pd = (virNWFilterSnoopDHCPHdr *) ((char *)pup + sizeof(*pup));
len -= sizeof(*pup);
if (len < 0)
return -2; /* invalid packet length */
*/
static void virNWFilterDHCPDecodeWorker(void *jobdata, void *opaque)
{
- virNWFilterSnoopReqPtr req = opaque;
- g_autofree virNWFilterDHCPDecodeJobPtr job = jobdata;
- virNWFilterSnoopEthHdrPtr packet = (virNWFilterSnoopEthHdrPtr)job->packet;
+ virNWFilterSnoopReq *req = opaque;
+ g_autofree virNWFilterDHCPDecodeJob *job = jobdata;
+ virNWFilterSnoopEthHdr *packet = (virNWFilterSnoopEthHdr *)job->packet;
if (virNWFilterSnoopDHCPDecode(req, packet,
job->caplen, job->fromVM) == -1) {
* Submit a job to the worker thread doing the time-consuming work...
*/
static int
-virNWFilterSnoopDHCPDecodeJobSubmit(virThreadPoolPtr pool,
- virNWFilterSnoopEthHdrPtr pep,
+virNWFilterSnoopDHCPDecodeJobSubmit(virThreadPool *pool,
+ virNWFilterSnoopEthHdr *pep,
int len, pcap_direction_t dir,
int *qCtr)
{
- virNWFilterDHCPDecodeJobPtr job;
+ virNWFilterDHCPDecodeJob *job;
int ret;
if (len <= MIN_VALID_DHCP_PKT_SIZE || len > sizeof(job->packet))
* return 1. If the number of packets is below the rate, it returns 0.
*/
static unsigned int
-virNWFilterSnoopRateLimit(virNWFilterSnoopRateLimitConfPtr rl)
+virNWFilterSnoopRateLimit(virNWFilterSnoopRateLimitConf *rl)
{
time_t now = time(0);
int diff;
* sending too many packets.
*/
static void
-virNWFilterSnoopRatePenalty(virNWFilterSnoopPcapConfPtr pc,
+virNWFilterSnoopRatePenalty(virNWFilterSnoopPcapConf *pc,
unsigned int diff, unsigned int limit)
{
if (diff > limit) {
}
static int
-virNWFilterSnoopAdjustPoll(virNWFilterSnoopPcapConfPtr pc,
+virNWFilterSnoopAdjustPoll(virNWFilterSnoopPcapConf *pc,
size_t nPc, struct pollfd *pfd,
int *pollTo)
{
static void
virNWFilterDHCPSnoopThread(void *req0)
{
- virNWFilterSnoopReqPtr req = req0;
+ virNWFilterSnoopReq *req = req0;
struct pcap_pkthdr *hdr;
- virNWFilterSnoopEthHdrPtr packet;
+ virNWFilterSnoopEthHdr *packet;
int ifindex = 0;
int errcount = 0;
int tmp = -1, rv, n, pollTo;
size_t i;
g_autofree char *threadkey = NULL;
- virThreadPoolPtr worker = NULL;
+ virThreadPool *worker = NULL;
time_t last_displayed = 0, last_displayed_queue = 0;
virNWFilterSnoopPcapConf pcapConf[] = {
{
}
int
-virNWFilterDHCPSnoopReq(virNWFilterTechDriverPtr techdriver,
- virNWFilterBindingDefPtr binding,
- virNWFilterDriverStatePtr driver)
+virNWFilterDHCPSnoopReq(virNWFilterTechDriver *techdriver,
+ virNWFilterBindingDef *binding,
+ virNWFilterDriverState *driver)
{
- virNWFilterSnoopReqPtr req;
+ virNWFilterSnoopReq *req;
bool isnewreq;
char ifkey[VIR_IFKEY_LEN];
int tmp;
virThread thread;
- virNWFilterVarValuePtr dhcpsrvrs;
+ virNWFilterVarValue *dhcpsrvrs;
bool threadPuts = false;
virNWFilterSnoopIFKeyFMT(ifkey, binding->owneruuid, &binding->mac);
*/
static int
virNWFilterSnoopLeaseFileWrite(int lfd, const char *ifkey,
- virNWFilterSnoopIPLeasePtr ipl)
+ virNWFilterSnoopIPLease *ipl)
{
g_autofree char *lbuf = NULL;
g_autofree char *ipstr = virSocketAddrFormat(&ipl->ipAddress);
* exceeds a threshold.
*/
static void
-virNWFilterSnoopLeaseFileSave(virNWFilterSnoopIPLeasePtr ipl)
+virNWFilterSnoopLeaseFileSave(virNWFilterSnoopIPLease *ipl)
{
- virNWFilterSnoopReqPtr req = ipl->snoopReq;
+ virNWFilterSnoopReq *req = ipl->snoopReq;
virNWFilterSnoopLock();
const char *name G_GNUC_UNUSED,
const void *data G_GNUC_UNUSED)
{
- virNWFilterSnoopReqPtr req = (virNWFilterSnoopReqPtr)payload;
+ virNWFilterSnoopReq *req = (virNWFilterSnoopReq *)payload;
bool del_req;
/* clean up orphaned, expired leases */
const char *name G_GNUC_UNUSED,
void *data)
{
- virNWFilterSnoopReqPtr req = payload;
+ virNWFilterSnoopReq *req = payload;
int tfd = *(int *)data;
- virNWFilterSnoopIPLeasePtr ipl;
+ virNWFilterSnoopIPLease *ipl;
/* protect req->start */
virNWFilterSnoopReqLock(req);
char line[256], ifkey[VIR_IFKEY_LEN];
char ipstr[INET_ADDRSTRLEN], srvstr[INET_ADDRSTRLEN];
virNWFilterSnoopIPLease ipl;
- virNWFilterSnoopReqPtr req;
+ virNWFilterSnoopReq *req;
time_t now;
FILE *fp;
int ln = 0, tmp;
const char *name G_GNUC_UNUSED,
const void *data G_GNUC_UNUSED)
{
- virNWFilterSnoopReqPtr req = (virNWFilterSnoopReqPtr)payload;
+ virNWFilterSnoopReq *req = (virNWFilterSnoopReq *)payload;
/* protect req->binding->portdevname */
virNWFilterSnoopReqLock(req);
}
if (ifkey) {
- virNWFilterSnoopReqPtr req;
+ virNWFilterSnoopReq *req;
req = virNWFilterSnoopReqGetByIFKey(ifkey);
if (!req) {
}
int
-virNWFilterDHCPSnoopReq(virNWFilterTechDriverPtr techdriver G_GNUC_UNUSED,
- virNWFilterBindingDefPtr binding G_GNUC_UNUSED,
- virNWFilterDriverStatePtr driver G_GNUC_UNUSED)
+virNWFilterDHCPSnoopReq(virNWFilterTechDriver *techdriver G_GNUC_UNUSED,
+ virNWFilterBindingDef *binding G_GNUC_UNUSED,
+ virNWFilterDriverState *driver G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR,
_("libvirt was not compiled with libpcap and \""
int virNWFilterDHCPSnoopInit(void);
void virNWFilterDHCPSnoopShutdown(void);
-int virNWFilterDHCPSnoopReq(virNWFilterTechDriverPtr techdriver,
- virNWFilterBindingDefPtr binding,
- virNWFilterDriverStatePtr driver);
+int virNWFilterDHCPSnoopReq(virNWFilterTechDriver *techdriver,
+ virNWFilterBindingDef *binding,
+ virNWFilterDriverState *driver);
void virNWFilterDHCPSnoopEnd(const char *ifname);
VIR_LOG_INIT("nwfilter.nwfilter_driver");
-static virNWFilterDriverStatePtr driver;
+static virNWFilterDriverState *driver;
static int nwfilterStateCleanup(void);
static int
virNWFilterTriggerRebuildImpl(void *opaque)
{
- virNWFilterDriverStatePtr nwdriver = opaque;
+ virNWFilterDriverState *nwdriver = opaque;
return virNWFilterBuildAll(nwdriver, true);
}
static virDrvOpenStatus
nwfilterConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
}
-static virNWFilterObjPtr
+static virNWFilterObj *
nwfilterObjFromNWFilter(const unsigned char *uuid)
{
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (!(obj = virNWFilterObjListFindByUUID(driver->nwfilters, uuid))) {
nwfilterLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
virNWFilterPtr nwfilter = NULL;
nwfilterDriverLock();
nwfilterLookupByName(virConnectPtr conn,
const char *name)
{
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
virNWFilterPtr nwfilter = NULL;
nwfilterDriverLock();
nwfilterDefineXML(virConnectPtr conn,
const char *xml)
{
- virNWFilterDefPtr def;
- virNWFilterObjPtr obj = NULL;
- virNWFilterDefPtr objdef;
+ virNWFilterDef *def;
+ virNWFilterObj *obj = NULL;
+ virNWFilterDef *objdef;
virNWFilterPtr nwfilter = NULL;
if (!driver->privileged) {
static int
nwfilterUndefine(virNWFilterPtr nwfilter)
{
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
int ret = -1;
nwfilterDriverLock();
nwfilterGetXMLDesc(virNWFilterPtr nwfilter,
unsigned int flags)
{
- virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
+ virNWFilterObj *obj;
+ virNWFilterDef *def;
char *ret = NULL;
virCheckFlags(0, NULL);
const char *portdev)
{
virNWFilterBindingPtr ret = NULL;
- virNWFilterBindingObjPtr obj;
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingObj *obj;
+ virNWFilterBindingDef *def;
obj = virNWFilterBindingObjListFindByPortDev(driver->bindings,
portdev);
nwfilterBindingGetXMLDesc(virNWFilterBindingPtr binding,
unsigned int flags)
{
- virNWFilterBindingObjPtr obj;
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingObj *obj;
+ virNWFilterBindingDef *def;
char *ret = NULL;
virCheckFlags(0, NULL);
const char *xml,
unsigned int flags)
{
- virNWFilterBindingDefPtr def;
- virNWFilterBindingObjPtr obj = NULL;
+ virNWFilterBindingDef *def;
+ virNWFilterBindingObj *obj = NULL;
virNWFilterBindingPtr ret = NULL;
virCheckFlags(0, NULL);
static int
nwfilterBindingDelete(virNWFilterBindingPtr binding)
{
- virNWFilterBindingObjPtr obj;
- virNWFilterBindingDefPtr def;
+ virNWFilterBindingObj *obj;
+ virNWFilterBindingDef *def;
int ret = -1;
obj = virNWFilterBindingObjListFindByPortDev(driver->bindings, binding->portdev);
};
static int
-printVar(virNWFilterVarCombIterPtr vars,
+printVar(virNWFilterVarCombIter *vars,
char *buf, int bufsize,
- nwItemDescPtr item,
+ nwItemDesc *item,
bool *done)
{
*done = false;
static int
-_printDataType(virNWFilterVarCombIterPtr vars,
+_printDataType(virNWFilterVarCombIter *vars,
char *buf, int bufsize,
- nwItemDescPtr item,
+ nwItemDesc *item,
bool asHex, bool directionIn)
{
bool done;
static int
-printDataType(virNWFilterVarCombIterPtr vars,
+printDataType(virNWFilterVarCombIter *vars,
char *buf, int bufsize,
- nwItemDescPtr item)
+ nwItemDesc *item)
{
return _printDataType(vars, buf, bufsize, item, 0, 0);
}
static int
-printDataTypeDirection(virNWFilterVarCombIterPtr vars,
+printDataTypeDirection(virNWFilterVarCombIter *vars,
char *buf, int bufsize,
- nwItemDescPtr item, bool directionIn)
+ nwItemDesc *item, bool directionIn)
{
return _printDataType(vars, buf, bufsize, item, 0, directionIn);
}
static int
-printDataTypeAsHex(virNWFilterVarCombIterPtr vars,
+printDataTypeAsHex(virNWFilterVarCombIter *vars,
char *buf, int bufsize,
- nwItemDescPtr item)
+ nwItemDesc *item)
{
return _printDataType(vars, buf, bufsize, item, 1, 0);
}
static int
-ebtablesHandleEthHdr(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
- virNWFilterVarCombIterPtr vars,
- ethHdrDataDefPtr ethHdr,
+ebtablesHandleEthHdr(virFirewall *fw,
+ virFirewallRule *fwrule,
+ virNWFilterVarCombIter *vars,
+ ethHdrDataDef *ethHdr,
bool reverse)
{
char macaddr[VIR_MAC_STRING_BUFLEN];
static void
-iptablesCreateBaseChainsFW(virFirewallPtr fw,
+iptablesCreateBaseChainsFW(virFirewall *fw,
virFirewallLayer layer)
{
virFirewallAddRuleFull(fw, layer,
static void
-iptablesCreateTmpRootChainFW(virFirewallPtr fw,
+iptablesCreateTmpRootChainFW(virFirewall *fw,
virFirewallLayer layer,
char prefix,
bool incoming, const char *ifname)
static void
-iptablesCreateTmpRootChainsFW(virFirewallPtr fw,
+iptablesCreateTmpRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-_iptablesRemoveRootChainFW(virFirewallPtr fw,
+_iptablesRemoveRootChainFW(virFirewall *fw,
virFirewallLayer layer,
char prefix,
bool incoming, const char *ifname,
static void
-iptablesRemoveRootChainFW(virFirewallPtr fw,
+iptablesRemoveRootChainFW(virFirewall *fw,
virFirewallLayer layer,
char prefix,
bool incoming,
static void
-iptablesRemoveTmpRootChainFW(virFirewallPtr fw,
+iptablesRemoveTmpRootChainFW(virFirewall *fw,
virFirewallLayer layer,
char prefix,
bool incoming,
static void
-iptablesRemoveTmpRootChainsFW(virFirewallPtr fw,
+iptablesRemoveTmpRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-iptablesRemoveRootChainsFW(virFirewallPtr fw,
+iptablesRemoveRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-iptablesLinkTmpRootChainFW(virFirewallPtr fw,
+iptablesLinkTmpRootChainFW(virFirewall *fw,
virFirewallLayer layer,
const char *basechain,
char prefix,
static void
-iptablesLinkTmpRootChainsFW(virFirewallPtr fw,
+iptablesLinkTmpRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-iptablesSetupVirtInPostFW(virFirewallPtr fw G_GNUC_UNUSED,
+iptablesSetupVirtInPostFW(virFirewall *fw G_GNUC_UNUSED,
virFirewallLayer layer G_GNUC_UNUSED,
const char *ifname G_GNUC_UNUSED)
{
static void
-iptablesClearVirtInPostFW(virFirewallPtr fw,
+iptablesClearVirtInPostFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-_iptablesUnlinkRootChainFW(virFirewallPtr fw,
+_iptablesUnlinkRootChainFW(virFirewall *fw,
virFirewallLayer layer,
const char *basechain,
char prefix,
static void
-iptablesUnlinkRootChainFW(virFirewallPtr fw,
+iptablesUnlinkRootChainFW(virFirewall *fw,
virFirewallLayer layer,
const char *basechain,
char prefix,
static void
-iptablesUnlinkTmpRootChainFW(virFirewallPtr fw,
+iptablesUnlinkTmpRootChainFW(virFirewall *fw,
virFirewallLayer layer,
const char *basechain,
char prefix,
static void
-iptablesUnlinkRootChainsFW(virFirewallPtr fw,
+iptablesUnlinkRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-iptablesUnlinkTmpRootChainsFW(virFirewallPtr fw,
+iptablesUnlinkTmpRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static void
-iptablesRenameTmpRootChainFW(virFirewallPtr fw,
+iptablesRenameTmpRootChainFW(virFirewall *fw,
virFirewallLayer layer,
char prefix,
bool incoming,
static void
-iptablesRenameTmpRootChainsFW(virFirewallPtr fw,
+iptablesRenameTmpRootChainsFW(virFirewall *fw,
virFirewallLayer layer,
const char *ifname)
{
static int
-iptablesHandleSrcMacAddr(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
- virNWFilterVarCombIterPtr vars,
- nwItemDescPtr srcMacAddr,
+iptablesHandleSrcMacAddr(virFirewall *fw,
+ virFirewallRule *fwrule,
+ virNWFilterVarCombIter *vars,
+ nwItemDesc *srcMacAddr,
bool directionIn,
bool *srcmacskipped)
{
static int
-iptablesHandleIPHdr(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
- virNWFilterVarCombIterPtr vars,
- ipHdrDataDefPtr ipHdr,
+iptablesHandleIPHdr(virFirewall *fw,
+ virFirewallRule *fwrule,
+ virNWFilterVarCombIter *vars,
+ ipHdrDataDef *ipHdr,
bool directionIn,
bool *skipRule, bool *skipMatch)
{
static int
-iptablesHandleIPHdrAfterStateMatch(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
- virNWFilterVarCombIterPtr vars,
- ipHdrDataDefPtr ipHdr,
+iptablesHandleIPHdrAfterStateMatch(virFirewall *fw,
+ virFirewallRule *fwrule,
+ virNWFilterVarCombIter *vars,
+ ipHdrDataDef *ipHdr,
bool directionIn)
{
char number[VIR_INT64_STR_BUFLEN];
static int
-iptablesHandlePortData(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
- virNWFilterVarCombIterPtr vars,
- portDataDefPtr portData,
+iptablesHandlePortData(virFirewall *fw,
+ virFirewallRule *fwrule,
+ virNWFilterVarCombIter *vars,
+ portDataDef *portData,
bool directionIn)
{
char portstr[20];
static void
-iptablesEnforceDirection(virFirewallPtr fw,
- virFirewallRulePtr fwrule,
+iptablesEnforceDirection(virFirewall *fw,
+ virFirewallRule *fwrule,
bool directionIn,
- virNWFilterRuleDefPtr rule)
+ virNWFilterRuleDef *rule)
{
switch (iptables_ctdir_corrected) {
case CTDIR_STATUS_UNKNOWN:
* pointed to by res, != 0 otherwise.
*/
static int
-_iptablesCreateRuleInstance(virFirewallPtr fw,
+_iptablesCreateRuleInstance(virFirewall *fw,
virFirewallLayer layer,
bool directionIn,
const char *chainPrefix,
- virNWFilterRuleDefPtr rule,
+ virNWFilterRuleDef *rule,
const char *ifname,
- virNWFilterVarCombIterPtr vars,
+ virNWFilterVarCombIter *vars,
const char *match, bool defMatch,
const char *accept_target,
bool maySkipICMP)
bool skipRule = false;
bool skipMatch = false;
bool hasICMPType = false;
- virFirewallRulePtr fwrule;
+ virFirewallRule *fwrule;
size_t fwruleargs;
PRINT_IPT_ROOT_CHAIN(chain, chainPrefix, ifname);
}
static int
-iptablesCreateRuleInstanceStateCtrl(virFirewallPtr fw,
+iptablesCreateRuleInstanceStateCtrl(virFirewall *fw,
virFirewallLayer layer,
- virNWFilterRuleDefPtr rule,
+ virNWFilterRuleDef *rule,
const char *ifname,
- virNWFilterVarCombIterPtr vars)
+ virNWFilterVarCombIter *vars)
{
int rc = 0;
bool directionIn = false;
static int
-iptablesCreateRuleInstance(virFirewallPtr fw,
+iptablesCreateRuleInstance(virFirewall *fw,
virFirewallLayer layer,
- virNWFilterRuleDefPtr rule,
+ virNWFilterRuleDef *rule,
const char *ifname,
- virNWFilterVarCombIterPtr vars)
+ virNWFilterVarCombIter *vars)
{
int rc;
bool directionIn = false;
* pointed to by res, != 0 otherwise.
*/
static int
-ebtablesCreateRuleInstance(virFirewallPtr fw,
+ebtablesCreateRuleInstance(virFirewall *fw,
char chainPrefix,
const char *chainSuffix,
- virNWFilterRuleDefPtr rule,
+ virNWFilterRuleDef *rule,
const char *ifname,
- virNWFilterVarCombIterPtr vars,
+ virNWFilterVarCombIter *vars,
bool reverse)
{
char macaddr[VIR_MAC_STRING_BUFLEN];
char chain[MAX_CHAINNAME_LENGTH];
const char *target;
bool hasMask = false;
- virFirewallRulePtr fwrule;
+ virFirewallRule *fwrule;
if (STREQ(chainSuffix,
virNWFilterChainSuffixTypeToString(
* pointed to by res, -1 otherwise
*/
static int
-ebiptablesCreateRuleInstance(virFirewallPtr fw,
+ebiptablesCreateRuleInstance(virFirewall *fw,
const char *chainSuffix,
- virNWFilterRuleDefPtr rule,
+ virNWFilterRuleDef *rule,
const char *ifname,
- virNWFilterVarCombIterPtr vars)
+ virNWFilterVarCombIter *vars)
{
if (virNWFilterRuleIsProtocolEthernet(rule)) {
if (rule->tt == VIR_NWFILTER_RULE_DIRECTION_OUT ||
static void
-ebtablesCreateTmpRootChainFW(virFirewallPtr fw,
+ebtablesCreateTmpRootChainFW(virFirewall *fw,
int incoming, const char *ifname)
{
char chain[MAX_CHAINNAME_LENGTH];
static void
-ebtablesLinkTmpRootChainFW(virFirewallPtr fw,
+ebtablesLinkTmpRootChainFW(virFirewall *fw,
int incoming, const char *ifname)
{
char chain[MAX_CHAINNAME_LENGTH];
static void
-_ebtablesRemoveRootChainFW(virFirewallPtr fw,
+_ebtablesRemoveRootChainFW(virFirewall *fw,
bool incoming, const char *ifname,
int isTempChain)
{
static void
-ebtablesRemoveRootChainFW(virFirewallPtr fw,
+ebtablesRemoveRootChainFW(virFirewall *fw,
bool incoming, const char *ifname)
{
_ebtablesRemoveRootChainFW(fw, incoming, ifname, false);
static void
-ebtablesRemoveTmpRootChainFW(virFirewallPtr fw,
+ebtablesRemoveTmpRootChainFW(virFirewall *fw,
bool incoming, const char *ifname)
{
_ebtablesRemoveRootChainFW(fw, incoming, ifname, 1);
static void
-_ebtablesUnlinkRootChainFW(virFirewallPtr fw,
+_ebtablesUnlinkRootChainFW(virFirewall *fw,
bool incoming, const char *ifname,
int isTempChain)
{
static void
-ebtablesUnlinkRootChainFW(virFirewallPtr fw,
+ebtablesUnlinkRootChainFW(virFirewall *fw,
bool incoming, const char *ifname)
{
_ebtablesUnlinkRootChainFW(fw, incoming, ifname, false);
static void
-ebtablesUnlinkTmpRootChainFW(virFirewallPtr fw,
+ebtablesUnlinkTmpRootChainFW(virFirewall *fw,
int incoming, const char *ifname)
{
_ebtablesUnlinkRootChainFW(fw, incoming, ifname, 1);
}
static void
-ebtablesCreateTmpSubChainFW(virFirewallPtr fw,
+ebtablesCreateTmpSubChainFW(virFirewall *fw,
bool incoming,
const char *ifname,
enum l3_proto_idx protoidx,
char rootchain[MAX_CHAINNAME_LENGTH], chain[MAX_CHAINNAME_LENGTH];
char chainPrefix = incoming ? CHAINPREFIX_HOST_IN_TEMP
: CHAINPREFIX_HOST_OUT_TEMP;
- virFirewallRulePtr fwrule;
+ virFirewallRule *fwrule;
PRINT_ROOT_CHAIN(rootchain, chainPrefix, ifname);
PRINT_CHAIN(chain, chainPrefix, ifname,
static int
-ebtablesRemoveSubChainsQuery(virFirewallPtr fw,
+ebtablesRemoveSubChainsQuery(virFirewall *fw,
virFirewallLayer layer,
const char *const *lines,
void *opaque)
static void
-_ebtablesRemoveSubChainsFW(virFirewallPtr fw,
+_ebtablesRemoveSubChainsFW(virFirewall *fw,
const char *ifname,
const char *chainprefixes)
{
}
static void
-ebtablesRemoveSubChainsFW(virFirewallPtr fw,
+ebtablesRemoveSubChainsFW(virFirewall *fw,
const char *ifname)
{
_ebtablesRemoveSubChainsFW(fw, ifname, chainprefixes_host);
static void
-ebtablesRemoveTmpSubChainsFW(virFirewallPtr fw,
+ebtablesRemoveTmpSubChainsFW(virFirewall *fw,
const char *ifname)
{
_ebtablesRemoveSubChainsFW(fw, ifname, chainprefixes_host_temp);
}
static void
-ebtablesRenameTmpSubChainFW(virFirewallPtr fw,
+ebtablesRenameTmpSubChainFW(virFirewall *fw,
int incoming,
const char *ifname,
const char *protocol)
}
static void
-ebtablesRenameTmpRootChainFW(virFirewallPtr fw,
+ebtablesRenameTmpRootChainFW(virFirewall *fw,
bool incoming,
const char *ifname)
{
static int
-ebtablesRenameTmpSubAndRootChainsQuery(virFirewallPtr fw,
+ebtablesRenameTmpSubAndRootChainsQuery(virFirewall *fw,
virFirewallLayer layer,
const char *const *lines,
void *opaque G_GNUC_UNUSED)
static void
-ebtablesRenameTmpSubAndRootChainsFW(virFirewallPtr fw,
+ebtablesRenameTmpSubAndRootChainsFW(virFirewall *fw,
const char *ifname)
{
char rootchain[MAX_CHAINNAME_LENGTH];
static int
ebtablesApplyDHCPOnlyRules(const char *ifname,
const virMacAddr *macaddr,
- virNWFilterVarValuePtr dhcpsrvrs,
+ virNWFilterVarValue *dhcpsrvrs,
bool leaveTemporary)
{
char chain_in [MAX_CHAINNAME_LENGTH],
static int
-iptablesRuleInstCommand(virFirewallPtr fw,
+iptablesRuleInstCommand(virFirewall *fw,
const char *ifname,
- virNWFilterRuleInstPtr rule)
+ virNWFilterRuleInst *rule)
{
- virNWFilterVarCombIterPtr vciter;
- virNWFilterVarCombIterPtr tmp;
+ virNWFilterVarCombIter *vciter;
+ virNWFilterVarCombIter *tmp;
int ret = -1;
/* rule->vars holds all the variables names that this rule will access.
static int
-ebtablesRuleInstCommand(virFirewallPtr fw,
+ebtablesRuleInstCommand(virFirewall *fw,
const char *ifname,
- virNWFilterRuleInstPtr rule)
+ virNWFilterRuleInst *rule)
{
- virNWFilterVarCombIterPtr vciter;
- virNWFilterVarCombIterPtr tmp;
+ virNWFilterVarCombIter *vciter;
+ virNWFilterVarCombIter *tmp;
int ret = -1;
/* rule->vars holds all the variables names that this rule will access.
}
typedef struct _ebtablesSubChainInst ebtablesSubChainInst;
-typedef ebtablesSubChainInst *ebtablesSubChainInstPtr;
struct _ebtablesSubChainInst {
virNWFilterChainPriority priority;
bool incoming;
static int
ebtablesGetSubChainInsts(GHashTable *chains,
bool incoming,
- ebtablesSubChainInstPtr **insts,
+ ebtablesSubChainInst ***insts,
size_t *ninsts)
{
- g_autofree virHashKeyValuePairPtr filter_names = NULL;
+ g_autofree virHashKeyValuePair *filter_names = NULL;
size_t nfilter_names;
size_t i;
qsort(filter_names, nfilter_names, sizeof(*filter_names), ebiptablesFilterOrderSort);
for (i = 0; filter_names[i].key; i++) {
- g_autofree ebtablesSubChainInstPtr inst = NULL;
+ g_autofree ebtablesSubChainInst *inst = NULL;
enum l3_proto_idx idx = ebtablesGetProtoIdxByFiltername(
filter_names[i].key);
static int
ebiptablesApplyNewRules(const char *ifname,
- virNWFilterRuleInstPtr *rules,
+ virNWFilterRuleInst **rules,
size_t nrules)
{
size_t i, j;
bool haveEbtables = false;
bool haveIptables = false;
bool haveIp6tables = false;
- g_autofree ebtablesSubChainInstPtr *subchains = NULL;
+ g_autofree ebtablesSubChainInst **subchains = NULL;
size_t nsubchains = 0;
int ret = -1;
static void
-ebiptablesTearNewRulesFW(virFirewallPtr fw, const char *ifname)
+ebiptablesTearNewRulesFW(virFirewall *fw, const char *ifname)
{
iptablesUnlinkTmpRootChainsFW(fw, VIR_FIREWALL_LAYER_IPV4, ifname);
iptablesRemoveTmpRootChainsFW(fw, VIR_FIREWALL_LAYER_IPV4, ifname);
static int
-ebiptablesDriverProbeStateMatchQuery(virFirewallPtr fw G_GNUC_UNUSED,
+ebiptablesDriverProbeStateMatchQuery(virFirewall *fw G_GNUC_UNUSED,
virFirewallLayer layer G_GNUC_UNUSED,
const char *const *lines,
void *opaque)
static int _virNWFilterTeardownFilter(const char *ifname);
-static virNWFilterTechDriverPtr filter_tech_drivers[] = {
+static virNWFilterTechDriver *filter_tech_drivers[] = {
&ebiptables_driver,
NULL
};
/* Serializes instantiation of filters. This is necessary
* to avoid lock ordering deadlocks. eg virNWFilterInstantiateFilterUpdate
- * will hold a lock on a virNWFilterObjPtr. This in turn invokes
+ * will hold a lock on a virNWFilterObj *. This in turn invokes
* virNWFilterDoInstantiate which invokes virNWFilterDetermineMissingVarsRec
* which invokes virNWFilterObjListFindInstantiateFilter. This iterates over
- * every single virNWFilterObjPtr in the list. So if 2 threads try to
+ * every single virNWFilterObj *in the list. So if 2 threads try to
* instantiate a filter in parallel, they'll both hold 1 lock at the top level
* in virNWFilterInstantiateFilterUpdate which will cause the other thread
* to deadlock in virNWFilterObjListFindInstantiateFilter.
}
-virNWFilterTechDriverPtr
+virNWFilterTechDriver *
virNWFilterTechDriverForName(const char *name)
{
size_t i = 0;
static void
-virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst)
+virNWFilterRuleInstFree(virNWFilterRuleInst *inst)
{
if (!inst)
return;
typedef struct _virNWFilterInst virNWFilterInst;
-typedef virNWFilterInst *virNWFilterInstPtr;
struct _virNWFilterInst {
- virNWFilterObjPtr *filters;
+ virNWFilterObj **filters;
size_t nfilters;
- virNWFilterRuleInstPtr *rules;
+ virNWFilterRuleInst **rules;
size_t nrules;
};
static void
-virNWFilterInstReset(virNWFilterInstPtr inst)
+virNWFilterInstReset(virNWFilterInst *inst)
{
size_t i;
static int
-virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
- virNWFilterDefPtr def,
+virNWFilterDefToInst(virNWFilterDriverState *driver,
+ virNWFilterDef *def,
GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
- virNWFilterInstPtr inst);
+ virNWFilterInst *inst);
static int
-virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
- virNWFilterRuleDefPtr rule,
+virNWFilterRuleDefToRuleInst(virNWFilterDef *def,
+ virNWFilterRuleDef *rule,
GHashTable *vars,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
- virNWFilterRuleInstPtr ruleinst;
+ virNWFilterRuleInst *ruleinst;
int ret = -1;
ruleinst = g_new0(virNWFilterRuleInst, 1);
static int
-virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver,
- virNWFilterIncludeDefPtr inc,
+virNWFilterIncludeDefToRuleInst(virNWFilterDriverState *driver,
+ virNWFilterIncludeDef *inc,
GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
GHashTable *tmpvars = NULL;
- virNWFilterDefPtr childdef;
- virNWFilterDefPtr newChilddef;
+ virNWFilterDef *childdef;
+ virNWFilterDef *newChilddef;
int ret = -1;
VIR_DEBUG("Instantiating filter %s", inc->filterref);
* Returns 0 on success, -1 on error
*/
static int
-virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
- virNWFilterDefPtr def,
+virNWFilterDefToInst(virNWFilterDriverState *driver,
+ virNWFilterDef *def,
GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
size_t i;
int ret = -1;
static int
-virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter,
+virNWFilterDetermineMissingVarsRec(virNWFilterDef *filter,
GHashTable *vars,
GHashTable *missing_vars,
int useNewFilter,
- virNWFilterDriverStatePtr driver)
+ virNWFilterDriverState *driver)
{
- virNWFilterObjPtr obj;
+ virNWFilterObj *obj;
int rc = 0;
size_t i, j;
- virNWFilterDefPtr next_filter;
- virNWFilterDefPtr newNext_filter;
- virNWFilterVarValuePtr val;
+ virNWFilterDef *next_filter;
+ virNWFilterDef *newNext_filter;
+ virNWFilterVarValue *val;
for (i = 0; i < filter->nentries; i++) {
- virNWFilterRuleDefPtr rule = filter->filterEntries[i]->rule;
- virNWFilterIncludeDefPtr inc = filter->filterEntries[i]->include;
+ virNWFilterRuleDef * rule = filter->filterEntries[i]->rule;
+ virNWFilterIncludeDef *inc = filter->filterEntries[i]->include;
if (rule) {
/* check all variables of this rule */
for (j = 0; j < rule->nVarAccess; j++) {
* Call this function while holding the NWFilter filter update lock
*/
static int
-virNWFilterDoInstantiate(virNWFilterTechDriverPtr techdriver,
- virNWFilterBindingDefPtr binding,
- virNWFilterDefPtr filter,
+virNWFilterDoInstantiate(virNWFilterTechDriver *techdriver,
+ virNWFilterBindingDef *binding,
+ virNWFilterDef *filter,
int ifindex,
enum instCase useNewFilter,
bool *foundNewFilter,
bool teardownOld,
- virNWFilterDriverStatePtr driver,
+ virNWFilterDriverState *driver,
bool forceWithPendingReq)
{
int rc;
virNWFilterInst inst;
bool instantiate = true;
g_autofree char *buf = NULL;
- virNWFilterVarValuePtr lv;
+ virNWFilterVarValue *lv;
const char *learning;
bool reportIP = false;
* Call this function while holding the NWFilter filter update lock
*/
static int
-virNWFilterInstantiateFilterUpdate(virNWFilterDriverStatePtr driver,
+virNWFilterInstantiateFilterUpdate(virNWFilterDriverState *driver,
bool teardownOld,
- virNWFilterBindingDefPtr binding,
+ virNWFilterBindingDef *binding,
int ifindex,
enum instCase useNewFilter,
bool forceWithPendingReq,
{
int rc = -1;
const char *drvname = EBIPTABLES_DRIVER_ID;
- virNWFilterTechDriverPtr techdriver;
- virNWFilterObjPtr obj;
- virNWFilterDefPtr filter;
- virNWFilterDefPtr newFilter;
+ virNWFilterTechDriver *techdriver;
+ virNWFilterObj *obj;
+ virNWFilterDef *filter;
+ virNWFilterDef *newFilter;
char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0};
- virNWFilterVarValuePtr ipaddr;
+ virNWFilterVarValue *ipaddr;
techdriver = virNWFilterTechDriverForName(drvname);
static int
-virNWFilterInstantiateFilterInternal(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+virNWFilterInstantiateFilterInternal(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
bool teardownOld,
enum instCase useNewFilter,
bool *foundNewFilter)
int
-virNWFilterInstantiateFilterLate(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+virNWFilterInstantiateFilterLate(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
int ifindex)
{
int rc;
int
-virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding)
+virNWFilterInstantiateFilter(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding)
{
bool foundNewFilter = false;
int
-virNWFilterUpdateInstantiateFilter(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+virNWFilterUpdateInstantiateFilter(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
bool *skipIface)
{
bool foundNewFilter = false;
}
static int
-virNWFilterRollbackUpdateFilter(virNWFilterBindingDefPtr binding)
+virNWFilterRollbackUpdateFilter(virNWFilterBindingDef *binding)
{
const char *drvname = EBIPTABLES_DRIVER_ID;
int ifindex;
- virNWFilterTechDriverPtr techdriver;
+ virNWFilterTechDriver *techdriver;
techdriver = virNWFilterTechDriverForName(drvname);
if (!techdriver) {
static int
-virNWFilterTearOldFilter(virNWFilterBindingDefPtr binding)
+virNWFilterTearOldFilter(virNWFilterBindingDef *binding)
{
const char *drvname = EBIPTABLES_DRIVER_ID;
int ifindex;
- virNWFilterTechDriverPtr techdriver;
+ virNWFilterTechDriver *techdriver;
techdriver = virNWFilterTechDriverForName(drvname);
if (!techdriver) {
_virNWFilterTeardownFilter(const char *ifname)
{
const char *drvname = EBIPTABLES_DRIVER_ID;
- virNWFilterTechDriverPtr techdriver;
+ virNWFilterTechDriver *techdriver;
techdriver = virNWFilterTechDriverForName(drvname);
if (!techdriver) {
int
-virNWFilterTeardownFilter(virNWFilterBindingDefPtr binding)
+virNWFilterTeardownFilter(virNWFilterBindingDef *binding)
{
int ret;
virMutexLock(&updateMutex);
};
static int
-virNWFilterBuildOne(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+virNWFilterBuildOne(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
GHashTable *skipInterfaces,
int step)
{
struct virNWFilterBuildData {
- virNWFilterDriverStatePtr driver;
+ virNWFilterDriverState *driver;
GHashTable *skipInterfaces;
int step;
};
static int
-virNWFilterBuildIter(virNWFilterBindingObjPtr binding, void *opaque)
+virNWFilterBuildIter(virNWFilterBindingObj *binding, void *opaque)
{
struct virNWFilterBuildData *data = opaque;
- virNWFilterBindingDefPtr def = virNWFilterBindingObjGetDef(binding);
+ virNWFilterBindingDef *def = virNWFilterBindingObjGetDef(binding);
return virNWFilterBuildOne(data->driver, def,
data->skipInterfaces, data->step);
}
int
-virNWFilterBuildAll(virNWFilterDriverStatePtr driver,
+virNWFilterBuildAll(virNWFilterDriverState *driver,
bool newFilters)
{
struct virNWFilterBuildData data = {
#include "virnwfilterbindingdef.h"
#include "nwfilter_tech_driver.h"
-virNWFilterTechDriverPtr virNWFilterTechDriverForName(const char *name);
+virNWFilterTechDriver *virNWFilterTechDriverForName(const char *name);
int virNWFilterTechDriversInit(bool privileged);
void virNWFilterTechDriversShutdown(void);
};
-int virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding);
-int virNWFilterUpdateInstantiateFilter(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+int virNWFilterInstantiateFilter(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding);
+int virNWFilterUpdateInstantiateFilter(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
bool *skipIface);
-int virNWFilterInstantiateFilterLate(virNWFilterDriverStatePtr driver,
- virNWFilterBindingDefPtr binding,
+int virNWFilterInstantiateFilterLate(virNWFilterDriverState *driver,
+ virNWFilterBindingDef *binding,
int ifindex);
-int virNWFilterTeardownFilter(virNWFilterBindingDefPtr binding);
+int virNWFilterTeardownFilter(virNWFilterBindingDef *binding);
GHashTable *virNWFilterCreateVarHashmap(const char *macaddr,
const virNWFilterVarValue *value);
-int virNWFilterBuildAll(virNWFilterDriverStatePtr driver,
+int virNWFilterBuildAll(virNWFilterDriverState *driver,
bool newFilters);
static GHashTable *ifaceLockMap;
typedef struct _virNWFilterIfaceLock virNWFilterIfaceLock;
-typedef virNWFilterIfaceLock *virNWFilterIfaceLockPtr;
struct _virNWFilterIfaceLock {
char ifname[IF_NAMESIZE];
virMutex lock;
};
typedef struct _virNWFilterIPAddrLearnReq virNWFilterIPAddrLearnReq;
-typedef virNWFilterIPAddrLearnReq *virNWFilterIPAddrLearnReqPtr;
struct _virNWFilterIPAddrLearnReq {
- virNWFilterTechDriverPtr techdriver;
+ virNWFilterTechDriver *techdriver;
int ifindex;
- virNWFilterBindingDefPtr binding;
- virNWFilterDriverStatePtr driver;
+ virNWFilterBindingDef *binding;
+ virNWFilterDriverState *driver;
int howDetect; /* bitmask of enum howDetect */
int status;
int
virNWFilterLockIface(const char *ifname)
{
- virNWFilterIfaceLockPtr ifaceLock;
+ virNWFilterIfaceLock *ifaceLock;
virMutexLock(&ifaceMapLock);
void
virNWFilterUnlockIface(const char *ifname)
{
- virNWFilterIfaceLockPtr ifaceLock;
+ virNWFilterIfaceLock *ifaceLock;
virMutexLock(&ifaceMapLock);
static void
-virNWFilterIPAddrLearnReqFree(virNWFilterIPAddrLearnReqPtr req)
+virNWFilterIPAddrLearnReqFree(virNWFilterIPAddrLearnReq *req)
{
if (!req)
return;
#if WITH_LIBPCAP
static int
-virNWFilterRegisterLearnReq(virNWFilterIPAddrLearnReqPtr req)
+virNWFilterRegisterLearnReq(virNWFilterIPAddrLearnReq *req)
{
int res = -1;
g_autofree char *ifindex_str = g_strdup_printf("%d", req->ifindex);
{
int rc = -1;
int ifindex;
- virNWFilterIPAddrLearnReqPtr req;
+ virNWFilterIPAddrLearnReq *req;
g_autofree char *ifindex_str = NULL;
/* It's possible that it's already been removed as a result of
#ifdef WITH_LIBPCAP
-static virNWFilterIPAddrLearnReqPtr
+static virNWFilterIPAddrLearnReq *
virNWFilterDeregisterLearnReq(int ifindex)
{
- virNWFilterIPAddrLearnReqPtr res;
+ virNWFilterIPAddrLearnReq *res;
g_autofree char *ifindex_str = g_strdup_printf("%d", ifindex);
virMutexLock(&pendingLearnReqLock);
const u_char *packet;
struct ether_header *ether_hdr;
struct ether_vlan_header *vlan_hdr;
- virNWFilterIPAddrLearnReqPtr req = arg;
+ virNWFilterIPAddrLearnReq *req = arg;
uint32_t vmaddr = 0, bcastaddr = 0;
unsigned int ethHdrSize;
char *listen_if = (req->binding->linkdevname ?
uint16_t etherType;
bool showError = true;
enum howDetect howDetected = 0;
- virNWFilterTechDriverPtr techdriver = req->techdriver;
+ virNWFilterTechDriver *techdriver = req->techdriver;
struct pollfd fds[1];
if (virNWFilterLockIface(req->binding->portdevname) < 0)
* firewall rules on the interface.
*/
int
-virNWFilterLearnIPAddress(virNWFilterTechDriverPtr techdriver,
- virNWFilterBindingDefPtr binding,
+virNWFilterLearnIPAddress(virNWFilterTechDriver *techdriver,
+ virNWFilterBindingDef *binding,
int ifindex,
- virNWFilterDriverStatePtr driver,
+ virNWFilterDriverState *driver,
int howDetect)
{
int rc;
virThread thread;
- virNWFilterIPAddrLearnReqPtr req = NULL;
+ virNWFilterIPAddrLearnReq *req = NULL;
if (howDetect == 0)
return -1;
#else
int
-virNWFilterLearnIPAddress(virNWFilterTechDriverPtr techdriver G_GNUC_UNUSED,
- virNWFilterBindingDefPtr binding G_GNUC_UNUSED,
+virNWFilterLearnIPAddress(virNWFilterTechDriver *techdriver G_GNUC_UNUSED,
+ virNWFilterBindingDef *binding G_GNUC_UNUSED,
int ifindex G_GNUC_UNUSED,
- virNWFilterDriverStatePtr driver G_GNUC_UNUSED,
+ virNWFilterDriverState *driver G_GNUC_UNUSED,
int howDetect G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
DETECT_STATIC = 2,
};
-int virNWFilterLearnIPAddress(virNWFilterTechDriverPtr techdriver,
- virNWFilterBindingDefPtr binding,
+int virNWFilterLearnIPAddress(virNWFilterTechDriver *techdriver,
+ virNWFilterBindingDef *binding,
int ifindex,
- virNWFilterDriverStatePtr driver,
+ virNWFilterDriverState *driver,
int howDetect);
bool virNWFilterHasLearnReq(int ifindex);
#include "virnwfilterobj.h"
typedef struct _virNWFilterTechDriver virNWFilterTechDriver;
-typedef virNWFilterTechDriver *virNWFilterTechDriverPtr;
typedef struct _virNWFilterRuleInst virNWFilterRuleInst;
-typedef virNWFilterRuleInst *virNWFilterRuleInstPtr;
struct _virNWFilterRuleInst {
const char *chainSuffix;
virNWFilterChainPriority chainPriority;
- virNWFilterRuleDefPtr def;
+ virNWFilterRuleDef *def;
virNWFilterRulePriority priority;
GHashTable *vars;
};
typedef void (*virNWFilterTechDrvShutdown)(void);
typedef int (*virNWFilterRuleApplyNewRules)(const char *ifname,
- virNWFilterRuleInstPtr *rules,
+ virNWFilterRuleInst **rules,
size_t nrules);
typedef int (*virNWFilterRuleTeardownNewRules)(const char *ifname);
typedef int (*virNWFilterApplyDHCPOnlyRules)(const char *ifname,
const virMacAddr *macaddr,
- virNWFilterVarValuePtr dhcpsrvs,
+ virNWFilterVarValue *dhcpsrvs,
bool leaveTemporary);
typedef int (*virNWFilterRemoveBasicRules)(const char *ifname);
unsigned long version;
char *help = NULL;
char *tmp;
- virCommandPtr cmd = virCommandNewArgList(cmdstr, "--help", NULL);
+ virCommand *cmd = virCommandNewArgList(cmdstr, "--help", NULL);
if (retversion)
*retversion = 0;
}
-virCapsPtr openvzCapsInit(void)
+virCaps *openvzCapsInit(void)
{
g_autoptr(virCaps) caps = NULL;
- virCapsGuestPtr guest;
+ virCapsGuest *guest;
if ((caps = virCapabilitiesNew(virArchFromHost(),
false, false)) == NULL)
int
-openvzReadNetworkConf(virDomainDefPtr def,
+openvzReadNetworkConf(virDomainDef *def,
int veid)
{
int ret;
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
char *temp = NULL;
char *token, *saveptr = NULL;
static int
-openvzReadFSConf(virDomainDefPtr def,
+openvzReadFSConf(virDomainDef *def,
int veid)
{
int ret;
- virDomainFSDefPtr fs = NULL;
+ virDomainFSDef *fs = NULL;
g_autofree char *veid_str = NULL;
char *temp = NULL;
const char *param;
static int
-openvzReadMemConf(virDomainDefPtr def, int veid)
+openvzReadMemConf(virDomainDef *def, int veid)
{
int ret = -1;
char *temp = NULL;
int veid, ret;
char *status;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDomainObjPtr dom = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *dom = NULL;
+ virDomainDef *def = NULL;
char *temp = NULL;
char *outbuf = NULL;
char *line;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
unsigned int vcpus = 0;
if (openvzAssignUUIDs() < 0)
int openvzGetVEID(const char *name)
{
- virCommandPtr cmd;
+ virCommand *cmd;
char *outbuf;
char *temp;
int veid;
static int
-openvzDomainDefPostParse(virDomainDefPtr def,
+openvzDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
static int
-openvzDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+openvzDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
.features = VIR_DOMAIN_DEF_FEATURE_NAME_SLASH,
};
-virDomainXMLOptionPtr openvzXMLOption(struct openvz_driver *driver)
+virDomainXMLOption *openvzXMLOption(struct openvz_driver *driver)
{
openvzDomainDefParserConfig.priv = driver;
return virDomainXMLOptionNew(&openvzDomainDefParserConfig,
struct openvz_driver {
virMutex lock;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
- virDomainObjListPtr domains;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
+ virDomainObjList *domains;
int version;
};
int openvzWriteVPSConfigParam(int vpsid, const char *param, const char *value);
int openvzReadConfigParam(const char *conf_file, const char *param, char **value);
int openvzCopyDefaultConfig(int vpsid);
-virCapsPtr openvzCapsInit(void);
+virCaps *openvzCapsInit(void);
int openvzLoadDomains(struct openvz_driver *driver);
void openvzFreeDriver(struct openvz_driver *driver);
int strtoI(const char *str);
int openvzSetDefinedUUID(int vpsid, unsigned char *uuid);
int openvzGetVEID(const char *name);
-int openvzReadNetworkConf(virDomainDefPtr def, int veid);
-virDomainXMLOptionPtr openvzXMLOption(struct openvz_driver *driver);
+int openvzReadNetworkConf(virDomainDef *def, int veid);
+virDomainXMLOption *openvzXMLOption(struct openvz_driver *driver);
static int openvzGetProcessInfo(unsigned long long *cpuTime, int vpsid);
static int openvzConnectGetMaxVcpus(virConnectPtr conn, const char *type);
static int openvzDomainGetMaxVcpus(virDomainPtr dom);
-static int openvzDomainSetVcpusInternal(virDomainObjPtr vm,
+static int openvzDomainSetVcpusInternal(virDomainObj *vm,
unsigned int nvcpus,
- virDomainXMLOptionPtr xmlopt);
-static int openvzDomainSetMemoryInternal(virDomainObjPtr vm,
+ virDomainXMLOption *xmlopt);
+static int openvzDomainSetMemoryInternal(virDomainObj *vm,
unsigned long long memory);
-static int openvzGetVEStatus(virDomainObjPtr vm, int *status, int *reason);
+static int openvzGetVEStatus(virDomainObj *vm, int *status, int *reason);
static void openvzDriverLock(struct openvz_driver *driver)
{
struct openvz_driver ovz_driver;
-static virDomainObjPtr
+static virDomainObj *
openvzDomObjFromDomainLocked(struct openvz_driver *driver,
const unsigned char *uuid)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (!(vm = virDomainObjListFindByUUID(driver->domains, uuid))) {
}
-static virDomainObjPtr
+static virDomainObj *
openvzDomObjFromDomain(struct openvz_driver *driver,
const unsigned char *uuid)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
openvzDriverLock(driver);
vm = openvzDomObjFromDomainLocked(driver, uuid);
0 - OK
Caller has to free the cmd
*/
-static virCommandPtr
-openvzDomainDefineCmd(virDomainDefPtr vmdef)
+static virCommand *
+openvzDomainDefineCmd(virDomainDef *vmdef)
{
- virCommandPtr cmd = virCommandNewArgList(VZCTL,
+ virCommand *cmd = virCommandNewArgList(VZCTL,
"--quiet",
"create",
NULL);
}
-static int openvzSetInitialConfig(virDomainDefPtr vmdef)
+static int openvzSetInitialConfig(virDomainDef *vmdef)
{
int ret = -1;
int vpsid;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
if (vmdef->nfss > 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
-openvzSetDiskQuota(virDomainDefPtr vmdef,
- virDomainFSDefPtr fss,
+openvzSetDiskQuota(virDomainDef *vmdef,
+ virDomainFSDef *fss,
bool persist)
{
int ret = -1;
unsigned long long sl, hl;
- virCommandPtr cmd = virCommandNewArgList(VZCTL,
+ virCommand *cmd = virCommandNewArgList(VZCTL,
"--quiet",
"set",
vmdef->name,
{
char *hostname = NULL;
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(0, NULL);
if (!(vm = openvzDomObjFromDomain(driver, dom->uuid)))
int id)
{
struct openvz_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
openvzDriverLock(driver);
static char *openvzDomainGetOSType(virDomainPtr dom)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = openvzDomObjFromDomain(driver, dom->uuid)))
const unsigned char *uuid)
{
struct openvz_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
if (!(vm = openvzDomObjFromDomain(driver, uuid)))
const char *name)
{
struct openvz_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
openvzDriverLock(driver);
virDomainInfoPtr info)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int state;
int ret = -1;
unsigned int flags)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
static int openvzDomainIsActive(virDomainPtr dom)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = openvzDomObjFromDomain(driver, dom->uuid)))
static int openvzDomainIsPersistent(virDomainPtr dom)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = openvzDomObjFromDomain(driver, dom->uuid)))
static char *openvzDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) {
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "chkpnt", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = openvzDomObjFromDomain(driver, dom->uuid)))
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "chkpnt", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = openvzDomObjFromDomain(driver, dom->uuid)))
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "stop", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
int status;
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "restart", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
int status;
static int
openvzDomainSetNetwork(virConnectPtr conn, const char *vpsid,
- virDomainNetDefPtr net,
- virBufferPtr configBuf)
+ virDomainNetDef *net,
+ virBuffer *configBuf)
{
int rc = -1;
char macaddr[VIR_MAC_STRING_BUFLEN];
virMacAddr host_mac;
char host_macaddr[VIR_MAC_STRING_BUFLEN];
struct openvz_driver *driver = conn->privateData;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char *guest_ifname = NULL;
if (net == NULL)
static int
openvzDomainSetNetworkConfig(virConnectPtr conn,
- virDomainDefPtr def)
+ virDomainDef *def)
{
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
openvzDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
struct openvz_driver *driver = conn->privateData;
- virDomainDefPtr vmdef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "start", NULL);
struct openvz_driver *driver = conn->privateData;
- virDomainDefPtr vmdef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "start", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
int status;
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", "start", "destroy", NULL);
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
int status;
openvzDomainSetAutostart(virDomainPtr dom, int autostart)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", NULL);
int ret = -1;
openvzDomainGetAutostart(virDomainPtr dom, int *autostart)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *value = NULL;
int ret = -1;
VIR_DOMAIN_VCPU_MAXIMUM));
}
-static int openvzDomainSetVcpusInternal(virDomainObjPtr vm,
+static int openvzDomainSetVcpusInternal(virDomainObj *vm,
unsigned int nvcpus,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", NULL);
char str_vcpus[32];
static int openvzDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj * vm;
struct openvz_driver *driver = dom->conn->privateData;
int ret = -1;
static virDrvOpenStatus openvzConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
struct openvz_driver *driver;
int ret;
char buf[32];
char *endptr;
- virCommandPtr cmd = virCommandNewArgList(VZLIST, "-ovpsid", "-H", NULL);
+ virCommand *cmd = virCommandNewArgList(VZLIST, "-ovpsid", "-H", NULL);
virCommandSetOutputFD(cmd, &outfd);
if (virCommandRunAsync(cmd, NULL) < 0)
char vpsname[32];
char buf[32];
char *endptr;
- virCommandPtr cmd = virCommandNewArgList(VZLIST,
+ virCommand *cmd = virCommandNewArgList(VZLIST,
"-ovpsid", "-H", "-S", NULL);
/* the -S options lists only stopped domains */
}
static int
-openvzDomainSetMemoryInternal(virDomainObjPtr vm,
+openvzDomainSetMemoryInternal(virDomainObj *vm,
unsigned long long mem)
{
g_autoptr(virCommand) cmd = virCommandNewArgList(VZCTL, "--quiet", NULL);
int ret = -1;
char *endp, *output = NULL;
const char *tmp;
- virCommandPtr cmd = virCommandNewArgList(VZLIST, "--no-header", NULL);
+ virCommand *cmd = virCommandNewArgList(VZLIST, "--no-header", NULL);
virCommandSetOutputBuffer(cmd, &output);
virCommandAddArgFormat(cmd, "-o%s.b,%s.l", param, param);
unsigned long long limit)
{
int ret = -1;
- virCommandPtr cmd = virCommandNewArgList(VZCTL, "--quiet", "set", NULL);
+ virCommand *cmd = virCommandNewArgList(VZCTL, "--quiet", "set", NULL);
/* LONG_MAX indicates unlimited so reject larger values */
if (barrier > LONG_MAX || limit > LONG_MAX) {
static int
-openvzGetVEStatus(virDomainObjPtr vm, int *status, int *reason)
+openvzGetVEStatus(virDomainObj *vm, int *status, int *reason)
{
- virCommandPtr cmd;
+ virCommand *cmd;
char *outbuf;
char *line;
int state;
virDomainInterfaceStatsPtr stats)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainNetDefPtr net = NULL;
+ virDomainObj *vm;
+ virDomainNetDef *net = NULL;
int ret = -1;
if (!(vm = openvzDomObjFromDomain(driver, dom->uuid)))
static int
-openvzUpdateDevice(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev,
+openvzUpdateDevice(virDomainDef *vmdef,
+ virDomainDeviceDef *dev,
bool persist)
{
- virDomainFSDefPtr fs;
- virDomainFSDefPtr cur;
+ virDomainFSDef *fs;
+ virDomainFSDef *cur;
int pos;
if (dev->type == VIR_DOMAIN_DEVICE_FS) {
int ret = -1;
int veid;
struct openvz_driver *driver = dom->conn->privateData;
- virDomainDeviceDefPtr dev = NULL;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDeviceDef *dev = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
bool persist = false;
virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
int *cookieoutlen G_GNUC_UNUSED,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
struct openvz_driver *driver = domain->conn->privateData;
char *xml = NULL;
int status;
struct openvz_driver *driver = dconn->privateData;
const char *dom_xml = NULL;
const char *uri_in = NULL;
- virDomainDefPtr def = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainObj *vm = NULL;
g_autofree char *my_hostname = NULL;
const char *hostname = NULL;
g_autoptr(virURI) uri = NULL;
unsigned int flags)
{
struct openvz_driver *driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
const char *uri_str = NULL;
- virURIPtr uri = NULL;
- virCommandPtr cmd = NULL;
+ virURI *uri = NULL;
+ virCommand *cmd = NULL;
int ret = -1;
virCheckFlags(OPENVZ_MIGRATION_FLAGS, -1);
int cancelled)
{
struct openvz_driver *driver = dconn->privateData;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
const char *dname = NULL;
virDomainPtr dom = NULL;
int status;
int cancelled)
{
struct openvz_driver *driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int status;
int ret = -1;
openvzDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
struct openvz_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
virCheckFlags(0, -1);
int len;
char *output = NULL;
- virCommandPtr cmd = virCommandNewArgList(VZLIST,
+ virCommand *cmd = virCommandNewArgList(VZLIST,
"-o",
param,
domain->name,
There are a number of locks on various objects
- * virQEMUDriverPtr
+ * virQEMUDriver *
The qemu_conf.h file has inline comments describing the locking
needs for each field. Any field marked immutable, self-locking
access to the data. No code outside qemu_conf.c should ever
acquire this lock
- * virDomainObjPtr
+ * virDomainObj *
Will be locked and the reference counter will be increased after calling
any of the virDomainObjListFindBy{ID,Name,UUID} methods. The preferred way
of decrementing the reference counter and unlocking the domain is using the
virDomainObjEndAPI() function.
- Lock must be held when changing/reading any variable in the virDomainObjPtr
+ Lock must be held when changing/reading any variable in the virDomainObj *
This lock must not be held for anything which sleeps/waits (i.e. monitor
commands).
* qemuMonitorPrivatePtr: Job conditions
- Since virDomainObjPtr lock must not be held during sleeps, the job
+ Since virDomainObj *lock must not be held during sleeps, the job
conditions provide additional protection for code making updates.
QEMU driver uses three kinds of job conditions: asynchronous, agent
depends whether caller wishes to communicate only with agent socket, or
only with qemu monitor socket.
- Immediately after acquiring the virDomainObjPtr lock, any method
+ Immediately after acquiring the virDomainObj *lock, any method
which intends to update state must acquire asynchronous, normal or
- agent job . The virDomainObjPtr lock is released while blocking on
+ agent job . The virDomainObj *lock is released while blocking on
these condition variables. Once the job condition is acquired, a
- method can safely release the virDomainObjPtr lock whenever it hits
+ method can safely release the virDomainObj *lock whenever it hits
a piece of code which may sleep/wait, and re-acquire it after the
sleep/wait. Whenever an asynchronous job wants to talk to the
monitor, it needs to acquire nested job (a special kind of normal
job) to obtain exclusive access to the monitor.
- Since the virDomainObjPtr lock was dropped while waiting for the
+ Since the virDomainObj *lock was dropped while waiting for the
job condition, it is possible that the domain is no longer active
when the condition is finally obtained. The monitor lock is only
safe to grab after verifying that the domain is still active.
- * qemuMonitorPtr: Mutex
+ * qemuMonitor *: Mutex
Lock to be used when invoking any monitor command to ensure safety
wrt any asynchronous events that may be dispatched from the monitor.
The job condition *MUST* be held before acquiring the monitor lock
- The virDomainObjPtr lock *MUST* be held before acquiring the monitor
+ The virDomainObj *lock *MUST* be held before acquiring the monitor
lock.
- The virDomainObjPtr lock *MUST* then be released when invoking the
+ The virDomainObj *lock *MUST* then be released when invoking the
monitor command.
Helper methods
--------------
-To lock the virDomainObjPtr
+To lock the virDomainObj *
virObjectLock()
- - Acquires the virDomainObjPtr lock
+ - Acquires the virDomainObj *lock
virObjectUnlock()
- - Releases the virDomainObjPtr lock
+ - Releases the virDomainObj *lock
qemuDomainObjBeginJob()
- Waits until the job is compatible with current async job or no
async job is running
- - Waits for job.cond condition 'job.active != 0' using virDomainObjPtr
+ - Waits for job.cond condition 'job.active != 0' using virDomainObj *
mutex
- Rechecks if the job is still compatible and repeats waiting if it
isn't
qemuDomainObjBeginAsyncJob()
- Waits until no async job is running
- - Waits for job.cond condition 'job.active != 0' using virDomainObjPtr
+ - Waits for job.cond condition 'job.active != 0' using virDomainObj *
mutex
- Rechecks if any async job was started while waiting on job.cond
and repeats waiting in that case
qemuDomainObjEnterMonitor()
- Acquires the qemuMonitorObjPtr lock
- - Releases the virDomainObjPtr lock
+ - Releases the virDomainObj *lock
qemuDomainObjExitMonitor()
- Releases the qemuMonitorObjPtr lock
- - Acquires the virDomainObjPtr lock
+ - Acquires the virDomainObj *lock
These functions must not be used by an asynchronous job.
Note that the virDomainObj is unlocked during the time in
qemuDomainObjEnterMonitorAsync()
- Validates that the right async job is still running
- Acquires the qemuMonitorObjPtr lock
- - Releases the virDomainObjPtr lock
+ - Releases the virDomainObj *lock
- Validates that the VM is still active
qemuDomainObjExitMonitor()
- Releases the qemuMonitorObjPtr lock
- - Acquires the virDomainObjPtr lock
+ - Acquires the virDomainObj *lock
These functions are for use inside an asynchronous job; the caller
must check for a return of -1 (VM not running, so nothing to exit).
To keep a domain alive while waiting on a remote command
qemuDomainObjEnterRemote()
- - Releases the virDomainObjPtr lock
+ - Releases the virDomainObj *lock
qemuDomainObjExitRemote()
- - Acquires the virDomainObjPtr lock
+ - Acquires the virDomainObj *lock
Design patterns
---------------
- * Accessing something directly to do with a virDomainObjPtr
+ * Accessing something directly to do with a virDomainObj *
- virDomainObjPtr obj;
+ virDomainObj *obj;
obj = qemuDomObjFromDomain(dom);
virDomainObjEndAPI(&obj);
- * Updating something directly to do with a virDomainObjPtr
+ * Updating something directly to do with a virDomainObj *
- virDomainObjPtr obj;
+ virDomainObj *obj;
obj = qemuDomObjFromDomain(dom);
virDomainObjEndAPI(&obj);
- * Invoking a monitor command on a virDomainObjPtr
+ * Invoking a monitor command on a virDomainObj *
- virDomainObjPtr obj;
- qemuDomainObjPrivatePtr priv;
+ virDomainObj *obj;
+ qemuDomainObjPrivate *priv;
obj = qemuDomObjFromDomain(dom);
virDomainObjEndAPI(&obj);
- * Invoking an agent command on a virDomainObjPtr
+ * Invoking an agent command on a virDomainObj *
- virDomainObjPtr obj;
- qemuAgentPtr agent;
+ virDomainObj *obj;
+ qemuAgent *agent;
obj = qemuDomObjFromDomain(dom);
* Running asynchronous job
- virDomainObjPtr obj;
- qemuDomainObjPrivatePtr priv;
+ virDomainObj *obj;
+ qemuDomainObjPrivate *priv;
obj = qemuDomObjFromDomain(dom);
* Coordinating with a remote server for migration
- virDomainObjPtr obj;
- qemuDomainObjPrivatePtr priv;
+ virDomainObj *obj;
+ qemuDomainObjPrivate *priv;
obj = qemuDomObjFromDomain(dom);
*
static struct {
const char *type;
- void (*handler)(qemuAgentPtr agent, virJSONValuePtr data);
+ void (*handler)(qemuAgent *agent, virJSONValue *data);
} eventHandlers[] = {
};
*/
typedef struct _qemuAgentMessage qemuAgentMessage;
-typedef qemuAgentMessage *qemuAgentMessagePtr;
-
struct _qemuAgentMessage {
char *txBuffer;
int txOffset;
bool singleSync;
bool inSync;
- virDomainObjPtr vm;
+ virDomainObj *vm;
- qemuAgentCallbacksPtr cb;
+ qemuAgentCallbacks *cb;
/* If there's a command being processed this will be
* non-NULL */
- qemuAgentMessagePtr msg;
+ qemuAgentMessage *msg;
/* Buffer incoming data ready for agent
* code to process & find message boundaries */
int timeout;
};
-static virClassPtr qemuAgentClass;
+static virClass *qemuAgentClass;
static void qemuAgentDispose(void *obj);
static int qemuAgentOnceInit(void)
static void qemuAgentDispose(void *obj)
{
- qemuAgentPtr agent = obj;
+ qemuAgent *agent = obj;
VIR_DEBUG("agent=%p", agent);
if (agent->cb && agent->cb->destroy)
(agent->cb->destroy)(agent, agent->vm);
static int
-qemuAgentIOProcessEvent(qemuAgentPtr agent,
- virJSONValuePtr obj)
+qemuAgentIOProcessEvent(qemuAgent *agent,
+ virJSONValue *obj)
{
const char *type;
VIR_DEBUG("agent=%p obj=%p", agent, obj);
/*
for (i = 0; i < G_N_ELEMENTS(eventHandlers); i++) {
if (STREQ(eventHandlers[i].type, type)) {
- virJSONValuePtr data = virJSONValueObjectGet(obj, "data");
+ virJSONValue *data = virJSONValueObjectGet(obj, "data");
VIR_DEBUG("handle %s handler=%p data=%p", type,
eventHandlers[i].handler, data);
(eventHandlers[i].handler)(agent, data);
}
static int
-qemuAgentIOProcessLine(qemuAgentPtr agent,
+qemuAgentIOProcessLine(qemuAgent *agent,
const char *line,
- qemuAgentMessagePtr msg)
+ qemuAgentMessage *msg)
{
- virJSONValuePtr obj = NULL;
+ virJSONValue *obj = NULL;
int ret = -1;
VIR_DEBUG("Line [%s]", line);
return ret;
}
-static int qemuAgentIOProcessData(qemuAgentPtr agent,
+static int qemuAgentIOProcessData(qemuAgent *agent,
char *data,
size_t len,
- qemuAgentMessagePtr msg)
+ qemuAgentMessage *msg)
{
int used = 0;
size_t i = 0;
* replies/errors.
*/
static int
-qemuAgentIOProcess(qemuAgentPtr agent)
+qemuAgentIOProcess(qemuAgent *agent)
{
int len;
- qemuAgentMessagePtr msg = NULL;
+ qemuAgentMessage *msg = NULL;
/* See if there's a message ready for reply; that is,
* one that has completed writing all its data.
* Call this function while holding the agent lock.
*/
static int
-qemuAgentIOWrite(qemuAgentPtr agent)
+qemuAgentIOWrite(qemuAgent *agent)
{
int done;
* Returns -1 on error, or number of bytes read
*/
static int
-qemuAgentIORead(qemuAgentPtr agent)
+qemuAgentIORead(qemuAgent *agent)
{
size_t avail = agent->bufferLength - agent->bufferOffset;
int ret = 0;
static void
-qemuAgentRegister(qemuAgentPtr agent)
+qemuAgentRegister(qemuAgent *agent)
{
GIOCondition cond = 0;
static void
-qemuAgentUnregister(qemuAgentPtr agent)
+qemuAgentUnregister(qemuAgent *agent)
{
if (agent->watch) {
g_source_destroy(agent->watch);
}
-static void qemuAgentUpdateWatch(qemuAgentPtr agent)
+static void qemuAgentUpdateWatch(qemuAgent *agent)
{
qemuAgentUnregister(agent);
if (agent->socket)
GIOCondition cond,
gpointer opaque)
{
- qemuAgentPtr agent = opaque;
+ qemuAgent *agent = opaque;
bool error = false;
bool eof = false;
/* We have to unlock to avoid deadlock against command thread,
* but is this safe ? I think it is, because the callback
- * will try to acquire the virDomainObjPtr mutex next */
+ * will try to acquire the virDomainObj *mutex next */
if (eof) {
- void (*eofNotify)(qemuAgentPtr, virDomainObjPtr)
+ void (*eofNotify)(qemuAgent *, virDomainObj *)
= agent->cb->eofNotify;
- virDomainObjPtr vm = agent->vm;
+ virDomainObj *vm = agent->vm;
/* Make sure anyone waiting wakes up now */
virCondSignal(&agent->notify);
VIR_DEBUG("Triggering EOF callback");
(eofNotify)(agent, vm);
} else if (error) {
- void (*errorNotify)(qemuAgentPtr, virDomainObjPtr)
+ void (*errorNotify)(qemuAgent *, virDomainObj *)
= agent->cb->errorNotify;
- virDomainObjPtr vm = agent->vm;
+ virDomainObj *vm = agent->vm;
/* Make sure anyone waiting wakes up now */
virCondSignal(&agent->notify);
}
-qemuAgentPtr
-qemuAgentOpen(virDomainObjPtr vm,
+qemuAgent *
+qemuAgentOpen(virDomainObj *vm,
const virDomainChrSourceDef *config,
GMainContext *context,
- qemuAgentCallbacksPtr cb,
+ qemuAgentCallbacks *cb,
bool singleSync)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
g_autoptr(GError) gerr = NULL;
if (!cb || !cb->eofNotify) {
cleanup:
/* We don't want the 'destroy' callback invoked during
* cleanup from construction failure, because that can
- * give a double-unref on virDomainObjPtr in the caller,
+ * give a double-unref on virDomainObj *in the caller,
* so kill the callbacks now.
*/
agent->cb = NULL;
static void
-qemuAgentNotifyCloseLocked(qemuAgentPtr agent)
+qemuAgentNotifyCloseLocked(qemuAgent *agent)
{
if (agent) {
agent->running = false;
void
-qemuAgentNotifyClose(qemuAgentPtr agent)
+qemuAgentNotifyClose(qemuAgent *agent)
{
if (!agent)
return;
}
-void qemuAgentClose(qemuAgentPtr agent)
+void qemuAgentClose(qemuAgent *agent)
{
if (!agent)
return;
* -2 on timeout,
* -1 otherwise
*/
-static int qemuAgentSend(qemuAgentPtr agent,
- qemuAgentMessagePtr msg,
+static int qemuAgentSend(qemuAgent *agent,
+ qemuAgentMessage *msg,
int seconds)
{
int ret = -1;
* -1 otherwise
*/
static int
-qemuAgentGuestSync(qemuAgentPtr agent)
+qemuAgentGuestSync(qemuAgent *agent)
{
int ret = -1;
int send_ret;
* XXX see qerror.h for different klasses & fill out useful params
*/
static const char *
-qemuAgentStringifyError(virJSONValuePtr error)
+qemuAgentStringifyError(virJSONValue *error)
{
const char *klass = virJSONValueObjectGetString(error, "class");
const char *detail = virJSONValueObjectGetString(error, "desc");
}
static const char *
-qemuAgentCommandName(virJSONValuePtr cmd)
+qemuAgentCommandName(virJSONValue *cmd)
{
const char *name = virJSONValueObjectGetString(cmd, "execute");
if (name)
}
static int
-qemuAgentCheckError(virJSONValuePtr cmd,
- virJSONValuePtr reply,
+qemuAgentCheckError(virJSONValue *cmd,
+ virJSONValue *reply,
bool report_unsupported)
{
if (virJSONValueObjectHasKey(reply, "error")) {
- virJSONValuePtr error = virJSONValueObjectGet(reply, "error");
+ virJSONValue *error = virJSONValueObjectGet(reply, "error");
g_autofree char *cmdstr = virJSONValueToString(cmd, false);
g_autofree char *replystr = virJSONValueToString(reply, false);
}
static int
-qemuAgentCommandFull(qemuAgentPtr agent,
- virJSONValuePtr cmd,
- virJSONValuePtr *reply,
+qemuAgentCommandFull(qemuAgent *agent,
+ virJSONValue *cmd,
+ virJSONValue **reply,
int seconds,
bool report_unsupported)
{
}
static int
-qemuAgentCommand(qemuAgentPtr agent,
- virJSONValuePtr cmd,
- virJSONValuePtr *reply,
+qemuAgentCommand(qemuAgent *agent,
+ virJSONValue *cmd,
+ virJSONValue **reply,
int seconds)
{
return qemuAgentCommandFull(agent, cmd, reply, seconds, true);
}
-static virJSONValuePtr G_GNUC_NULL_TERMINATED
+static virJSONValue *G_GNUC_NULL_TERMINATED
qemuAgentMakeCommand(const char *cmdname,
...)
{
return g_steal_pointer(&obj);
}
-static virJSONValuePtr
+static virJSONValue *
qemuAgentMakeStringsArray(const char **strings, unsigned int len)
{
size_t i;
return g_steal_pointer(&ret);
}
-void qemuAgentNotifyEvent(qemuAgentPtr agent,
+void qemuAgentNotifyEvent(qemuAgent *agent,
qemuAgentEvent event)
{
virObjectLock(agent);
"powerdown", "reboot", "halt",
);
-int qemuAgentShutdown(qemuAgentPtr agent,
+int qemuAgentShutdown(qemuAgent *agent,
qemuAgentShutdownMode mode)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuAgentMakeCommand("guest-shutdown",
"s:mode", qemuAgentShutdownModeTypeToString(mode),
* Returns: number of file system frozen on success,
* -1 on error.
*/
-int qemuAgentFSFreeze(qemuAgentPtr agent, const char **mountpoints,
+int qemuAgentFSFreeze(qemuAgent *agent, const char **mountpoints,
unsigned int nmountpoints)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr arg = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *arg = NULL;
+ virJSONValue *reply = NULL;
if (mountpoints && nmountpoints) {
arg = qemuAgentMakeStringsArray(mountpoints, nmountpoints);
* Returns: number of file system thawed on success,
* -1 on error.
*/
-int qemuAgentFSThaw(qemuAgentPtr agent)
+int qemuAgentFSThaw(qemuAgent *agent)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuAgentMakeCommand("guest-fsfreeze-thaw", NULL);
);
int
-qemuAgentSuspend(qemuAgentPtr agent,
+qemuAgentSuspend(qemuAgent *agent,
unsigned int target)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuAgentMakeCommand(qemuAgentSuspendModeTypeToString(target),
NULL);
}
int
-qemuAgentArbitraryCommand(qemuAgentPtr agent,
+qemuAgentArbitraryCommand(qemuAgent *agent,
const char *cmd_str,
char **result,
int timeout)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
*result = NULL;
if (timeout < VIR_DOMAIN_QEMU_AGENT_COMMAND_MIN) {
}
int
-qemuAgentFSTrim(qemuAgentPtr agent,
+qemuAgentFSTrim(qemuAgent *agent,
unsigned long long minimum)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuAgentMakeCommand("guest-fstrim",
"U:minimum", minimum,
}
int
-qemuAgentGetVCPUs(qemuAgentPtr agent,
- qemuAgentCPUInfoPtr *info)
+qemuAgentGetVCPUs(qemuAgent *agent,
+ qemuAgentCPUInfo **info)
{
int ret = -1;
size_t i;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data = NULL;
size_t ndata;
if (!(cmd = qemuAgentMakeCommand("guest-get-vcpus", NULL)))
*info = g_new0(qemuAgentCPUInfo, ndata);
for (i = 0; i < ndata; i++) {
- virJSONValuePtr entry = virJSONValueArrayGet(data, i);
- qemuAgentCPUInfoPtr in = *info + i;
+ virJSONValue *entry = virJSONValueArrayGet(data, i);
+ qemuAgentCPUInfo *in = *info + i;
if (!entry) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
/* returns the value provided by the guest agent or -1 on internal error */
static int
-qemuAgentSetVCPUsCommand(qemuAgentPtr agent,
- qemuAgentCPUInfoPtr info,
+qemuAgentSetVCPUsCommand(qemuAgent *agent,
+ qemuAgentCPUInfo *info,
size_t ninfo,
int *nmodified)
{
*nmodified = 0;
for (i = 0; i < ninfo; i++) {
- qemuAgentCPUInfoPtr in = &info[i];
+ qemuAgentCPUInfo *in = &info[i];
g_autoptr(virJSONValue) cpu = virJSONValueNewObject();
/* don't set state for cpus that were not touched */
* Returns -1 on error, 0 on success.
*/
int
-qemuAgentSetVCPUs(qemuAgentPtr agent,
- qemuAgentCPUInfoPtr info,
+qemuAgentSetVCPUs(qemuAgent *agent,
+ qemuAgentCPUInfo *info,
size_t ninfo)
{
int rv;
/* modify the cpu info structure to set the correct amount of cpus */
int
qemuAgentUpdateCPUInfo(unsigned int nvcpus,
- qemuAgentCPUInfoPtr cpuinfo,
+ qemuAgentCPUInfo *cpuinfo,
int ncpuinfo)
{
size_t i;
* guest agent does not support the command without reporting an error
*/
int
-qemuAgentGetHostname(qemuAgentPtr agent,
+qemuAgentGetHostname(qemuAgent *agent,
char **hostname,
bool report_unsupported)
{
g_autoptr(virJSONValue) cmd = qemuAgentMakeCommand("guest-get-host-name", NULL);
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
const char *result = NULL;
int rc;
int
-qemuAgentGetTime(qemuAgentPtr agent,
+qemuAgentGetTime(qemuAgent *agent,
long long *seconds,
unsigned int *nseconds)
{
int ret = -1;
unsigned long long json_time;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuAgentMakeCommand("guest-get-time",
NULL);
* @sync: let guest agent to read domain's RTC (@setTime is ignored)
*/
int
-qemuAgentSetTime(qemuAgentPtr agent,
+qemuAgentSetTime(qemuAgent *agent,
long long seconds,
unsigned int nseconds,
bool rtcSync)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (rtcSync) {
cmd = qemuAgentMakeCommand("guest-set-time", NULL);
}
void
-qemuAgentDiskAddressFree(qemuAgentDiskAddressPtr info)
+qemuAgentDiskAddressFree(qemuAgentDiskAddress *info)
{
if (!info)
return;
void
-qemuAgentDiskInfoFree(qemuAgentDiskInfoPtr info)
+qemuAgentDiskInfoFree(qemuAgentDiskInfo *info)
{
if (!info)
return;
void
-qemuAgentFSInfoFree(qemuAgentFSInfoPtr info)
+qemuAgentFSInfoFree(qemuAgentFSInfo *info)
{
size_t i;
}
-static qemuAgentDiskAddressPtr
-qemuAgentGetDiskAddress(virJSONValuePtr json)
+static qemuAgentDiskAddress *
+qemuAgentGetDiskAddress(virJSONValue *json)
{
- virJSONValuePtr pci;
- virJSONValuePtr ccw;
+ virJSONValue *pci;
+ virJSONValue *ccw;
g_autoptr(qemuAgentDiskAddress) addr = NULL;
addr = g_new0(qemuAgentDiskAddress, 1);
GET_DISK_ADDR(pci, &addr->pci_controller.function, "function");
if ((ccw = virJSONValueObjectGet(json, "ccw-address"))) {
- g_autofree virDomainDeviceCCWAddressPtr ccw_addr = NULL;
+ g_autofree virDomainDeviceCCWAddress *ccw_addr = NULL;
ccw_addr = g_new0(virDomainDeviceCCWAddress, 1);
static int
-qemuAgentGetFSInfoFillDisks(virJSONValuePtr jsondisks,
- qemuAgentFSInfoPtr fsinfo)
+qemuAgentGetFSInfoFillDisks(virJSONValue *jsondisks,
+ qemuAgentFSInfo *fsinfo)
{
size_t ndisks;
size_t i;
ndisks = virJSONValueArraySize(jsondisks);
if (ndisks)
- fsinfo->disks = g_new0(qemuAgentDiskAddressPtr, ndisks);
+ fsinfo->disks = g_new0(qemuAgentDiskAddress *, ndisks);
fsinfo->ndisks = ndisks;
for (i = 0; i < fsinfo->ndisks; i++) {
- virJSONValuePtr jsondisk = virJSONValueArrayGet(jsondisks, i);
+ virJSONValue *jsondisk = virJSONValueArrayGet(jsondisks, i);
if (!jsondisk) {
virReportError(VIR_ERR_INTERNAL_ERROR,
* -1 otherwise (libvirt error is reported)
*/
int
-qemuAgentGetFSInfo(qemuAgentPtr agent,
- qemuAgentFSInfoPtr **info,
+qemuAgentGetFSInfo(qemuAgent *agent,
+ qemuAgentFSInfo ***info,
bool report_unsupported)
{
size_t i;
int ret = -1;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *data;
size_t ndata = 0;
- qemuAgentFSInfoPtr *info_ret = NULL;
+ qemuAgentFSInfo **info_ret = NULL;
int rc;
cmd = qemuAgentMakeCommand("guest-get-fsinfo", NULL);
*info = NULL;
goto cleanup;
}
- info_ret = g_new0(qemuAgentFSInfoPtr, ndata);
+ info_ret = g_new0(qemuAgentFSInfo *, ndata);
for (i = 0; i < ndata; i++) {
/* Reverse the order to arrange in mount order */
- virJSONValuePtr entry = virJSONValueArrayGet(data, ndata - 1 - i);
- virJSONValuePtr disk;
+ virJSONValue *entry = virJSONValueArrayGet(data, ndata - 1 - i);
+ virJSONValue *disk;
unsigned long long bytes_val;
const char *result = NULL;
static int
qemuAgentGetInterfaceOneAddress(virDomainIPAddressPtr ip_addr,
- virJSONValuePtr ip_addr_obj,
+ virJSONValue *ip_addr_obj,
const char *name)
{
const char *type, *addr;
qemuAgentGetInterfaceAddresses(virDomainInterfacePtr **ifaces_ret,
size_t *ifaces_count,
GHashTable *ifaces_store,
- virJSONValuePtr iface_obj)
+ virJSONValue *iface_obj)
{
- virJSONValuePtr ip_addr_arr = NULL;
+ virJSONValue *ip_addr_arr = NULL;
const char *hwaddr, *name = NULL;
virDomainInterfacePtr iface = NULL;
g_autofree char *ifname = NULL;
VIR_EXPAND_N(iface->addrs, addrs_count, virJSONValueArraySize(ip_addr_arr));
for (j = 0; j < virJSONValueArraySize(ip_addr_arr); j++) {
- virJSONValuePtr ip_addr_obj = virJSONValueArrayGet(ip_addr_arr, j);
+ virJSONValue *ip_addr_obj = virJSONValueArrayGet(ip_addr_arr, j);
virDomainIPAddressPtr ip_addr = iface->addrs + iface->naddrs;
iface->naddrs++;
static int
qemuAgentGetAllInterfaceAddresses(virDomainInterfacePtr **ifaces_ret,
- virJSONValuePtr ret_array)
+ virJSONValue *ret_array)
{
g_autoptr(GHashTable) ifaces_store = NULL;
size_t ifaces_count = 0;
ifaces_store = virHashNew(NULL);
for (i = 0; i < virJSONValueArraySize(ret_array); i++) {
- virJSONValuePtr iface_obj = virJSONValueArrayGet(ret_array, i);
+ virJSONValue *iface_obj = virJSONValueArrayGet(ret_array, i);
if (qemuAgentGetInterfaceAddresses(ifaces_ret, &ifaces_count,
ifaces_store, iface_obj) < 0)
* Returns: number of interfaces on success, -1 on error.
*/
int
-qemuAgentGetInterfaces(qemuAgentPtr agent,
+qemuAgentGetInterfaces(qemuAgent *agent,
virDomainInterfacePtr **ifaces)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr ret_array = NULL;
+ virJSONValue *ret_array = NULL;
if (!(cmd = qemuAgentMakeCommand("guest-network-get-interfaces", NULL)))
return -1;
int
-qemuAgentSetUserPassword(qemuAgentPtr agent,
+qemuAgentSetUserPassword(qemuAgent *agent,
const char *user,
const char *password,
bool crypted)
* -1 otherwise (libvirt error is reported)
*/
int
-qemuAgentGetUsers(qemuAgentPtr agent,
+qemuAgentGetUsers(qemuAgent *agent,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
size_t ndata;
size_t i;
int rc;
return -1;
for (i = 0; i < ndata; i++) {
- virJSONValuePtr entry = virJSONValueArrayGet(data, i);
+ virJSONValue *entry = virJSONValueArrayGet(data, i);
char param_name[VIR_TYPED_PARAM_FIELD_LENGTH];
const char *strvalue;
double logintime;
* -1 otherwise (libvirt error is reported)
*/
int
-qemuAgentGetOSInfo(qemuAgentPtr agent,
+qemuAgentGetOSInfo(qemuAgent *agent,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
int rc;
if (!(cmd = qemuAgentMakeCommand("guest-get-osinfo", NULL)))
* -1 otherwise (libvirt error is reported)
*/
int
-qemuAgentGetTimezone(qemuAgentPtr agent,
+qemuAgentGetTimezone(qemuAgent *agent,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
const char *name;
int offset;
int rc;
* The agent object must be locked prior to calling this function.
*/
void
-qemuAgentSetResponseTimeout(qemuAgentPtr agent,
+qemuAgentSetResponseTimeout(qemuAgent *agent,
int timeout)
{
agent->timeout = timeout;
* -1 otherwise (error is reported)
*/
int
-qemuAgentSSHGetAuthorizedKeys(qemuAgentPtr agent,
+qemuAgentSSHGetAuthorizedKeys(qemuAgent *agent,
const char *user,
char ***keys)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
if (!(cmd = qemuAgentMakeCommand("guest-ssh-get-authorized-keys",
"s:username", user,
* -1 otherwise (error is reported)
*/
int
-qemuAgentSSHAddAuthorizedKeys(qemuAgentPtr agent,
+qemuAgentSSHAddAuthorizedKeys(qemuAgent *agent,
const char *user,
const char **keys,
size_t nkeys,
* -1 otherwise (error is reported)
*/
int
-qemuAgentSSHRemoveAuthorizedKeys(qemuAgentPtr agent,
+qemuAgentSSHRemoveAuthorizedKeys(qemuAgent *agent,
const char *user,
const char **keys,
size_t nkeys)
}
-int qemuAgentGetDisks(qemuAgentPtr agent,
- qemuAgentDiskInfoPtr **disks,
+int qemuAgentGetDisks(qemuAgent *agent,
+ qemuAgentDiskInfo ***disks,
bool report_unsupported)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
size_t ndata;
size_t i;
int rc;
ndata = virJSONValueArraySize(data);
- *disks = g_new0(qemuAgentDiskInfoPtr, ndata);
+ *disks = g_new0(qemuAgentDiskInfo *, ndata);
for (i = 0; i < ndata; i++) {
- virJSONValuePtr addr;
- virJSONValuePtr entry = virJSONValueArrayGet(data, i);
- qemuAgentDiskInfoPtr disk;
+ virJSONValue *addr;
+ virJSONValue *entry = virJSONValueArrayGet(data, i);
+ qemuAgentDiskInfo *disk;
if (!entry) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
#include "domain_conf.h"
typedef struct _qemuAgent qemuAgent;
-typedef qemuAgent *qemuAgentPtr;
typedef struct _qemuAgentCallbacks qemuAgentCallbacks;
-typedef qemuAgentCallbacks *qemuAgentCallbacksPtr;
struct _qemuAgentCallbacks {
- void (*destroy)(qemuAgentPtr mon,
- virDomainObjPtr vm);
- void (*eofNotify)(qemuAgentPtr mon,
- virDomainObjPtr vm);
- void (*errorNotify)(qemuAgentPtr mon,
- virDomainObjPtr vm);
+ void (*destroy)(qemuAgent *mon,
+ virDomainObj *vm);
+ void (*eofNotify)(qemuAgent *mon,
+ virDomainObj *vm);
+ void (*errorNotify)(qemuAgent *mon,
+ virDomainObj *vm);
};
-qemuAgentPtr qemuAgentOpen(virDomainObjPtr vm,
+qemuAgent *qemuAgentOpen(virDomainObj *vm,
const virDomainChrSourceDef *config,
GMainContext *context,
- qemuAgentCallbacksPtr cb,
+ qemuAgentCallbacks *cb,
bool singleSync);
-void qemuAgentClose(qemuAgentPtr mon);
+void qemuAgentClose(qemuAgent *mon);
-void qemuAgentNotifyClose(qemuAgentPtr mon);
+void qemuAgentNotifyClose(qemuAgent *mon);
typedef enum {
QEMU_AGENT_EVENT_NONE = 0,
QEMU_AGENT_EVENT_RESET,
} qemuAgentEvent;
-void qemuAgentNotifyEvent(qemuAgentPtr mon,
+void qemuAgentNotifyEvent(qemuAgent *mon,
qemuAgentEvent event);
typedef enum {
} qemuAgentShutdownMode;
typedef struct _qemuAgentDiskAddress qemuAgentDiskAddress;
-typedef qemuAgentDiskAddress *qemuAgentDiskAddressPtr;
struct _qemuAgentDiskAddress {
char *serial;
virPCIDeviceAddress pci_controller;
unsigned int target;
unsigned int unit;
char *devnode;
- virDomainDeviceCCWAddressPtr ccw_addr;
+ virDomainDeviceCCWAddress *ccw_addr;
};
-void qemuAgentDiskAddressFree(qemuAgentDiskAddressPtr addr);
+void qemuAgentDiskAddressFree(qemuAgentDiskAddress *addr);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuAgentDiskAddress, qemuAgentDiskAddressFree);
typedef struct _qemuAgentDiskInfo qemuAgentDiskInfo;
-typedef qemuAgentDiskInfo *qemuAgentDiskInfoPtr;
struct _qemuAgentDiskInfo {
char *name;
bool partition;
char **dependencies;
- qemuAgentDiskAddressPtr address;
+ qemuAgentDiskAddress *address;
char *alias;
};
-void qemuAgentDiskInfoFree(qemuAgentDiskInfoPtr info);
+void qemuAgentDiskInfoFree(qemuAgentDiskInfo *info);
typedef struct _qemuAgentFSInfo qemuAgentFSInfo;
-typedef qemuAgentFSInfo *qemuAgentFSInfoPtr;
struct _qemuAgentFSInfo {
char *mountpoint; /* path to mount point */
char *name; /* device name in the guest (e.g. "sda1") */
long long total_bytes;
long long used_bytes;
size_t ndisks;
- qemuAgentDiskAddressPtr *disks;
+ qemuAgentDiskAddress **disks;
};
-void qemuAgentFSInfoFree(qemuAgentFSInfoPtr info);
+void qemuAgentFSInfoFree(qemuAgentFSInfo *info);
-int qemuAgentShutdown(qemuAgentPtr mon,
+int qemuAgentShutdown(qemuAgent *mon,
qemuAgentShutdownMode mode);
-int qemuAgentFSFreeze(qemuAgentPtr mon,
+int qemuAgentFSFreeze(qemuAgent *mon,
const char **mountpoints, unsigned int nmountpoints);
-int qemuAgentFSThaw(qemuAgentPtr mon);
-int qemuAgentGetFSInfo(qemuAgentPtr mon,
- qemuAgentFSInfoPtr **info,
+int qemuAgentFSThaw(qemuAgent *mon);
+int qemuAgentGetFSInfo(qemuAgent *mon,
+ qemuAgentFSInfo ***info,
bool report_unsupported);
-int qemuAgentSuspend(qemuAgentPtr mon,
+int qemuAgentSuspend(qemuAgent *mon,
unsigned int target);
-int qemuAgentArbitraryCommand(qemuAgentPtr mon,
+int qemuAgentArbitraryCommand(qemuAgent *mon,
const char *cmd,
char **result,
int timeout);
-int qemuAgentFSTrim(qemuAgentPtr mon,
+int qemuAgentFSTrim(qemuAgent *mon,
unsigned long long minimum);
typedef struct _qemuAgentCPUInfo qemuAgentCPUInfo;
-typedef qemuAgentCPUInfo *qemuAgentCPUInfoPtr;
struct _qemuAgentCPUInfo {
unsigned int id; /* logical cpu ID */
bool online; /* true if the CPU is activated */
bool modified; /* set to true if the vcpu state needs to be changed */
};
-int qemuAgentGetVCPUs(qemuAgentPtr mon, qemuAgentCPUInfoPtr *info);
-int qemuAgentSetVCPUs(qemuAgentPtr mon, qemuAgentCPUInfoPtr cpus, size_t ncpus);
+int qemuAgentGetVCPUs(qemuAgent *mon, qemuAgentCPUInfo **info);
+int qemuAgentSetVCPUs(qemuAgent *mon, qemuAgentCPUInfo *cpus, size_t ncpus);
int qemuAgentUpdateCPUInfo(unsigned int nvcpus,
- qemuAgentCPUInfoPtr cpuinfo,
+ qemuAgentCPUInfo *cpuinfo,
int ncpuinfo);
int
-qemuAgentGetHostname(qemuAgentPtr mon,
+qemuAgentGetHostname(qemuAgent *mon,
char **hostname,
bool report_unsupported);
-int qemuAgentGetTime(qemuAgentPtr mon,
+int qemuAgentGetTime(qemuAgent *mon,
long long *seconds,
unsigned int *nseconds);
-int qemuAgentSetTime(qemuAgentPtr mon,
+int qemuAgentSetTime(qemuAgent *mon,
long long seconds,
unsigned int nseconds,
bool sync);
-int qemuAgentGetInterfaces(qemuAgentPtr mon,
+int qemuAgentGetInterfaces(qemuAgent *mon,
virDomainInterfacePtr **ifaces);
-int qemuAgentSetUserPassword(qemuAgentPtr mon,
+int qemuAgentSetUserPassword(qemuAgent *mon,
const char *user,
const char *password,
bool crypted);
-int qemuAgentGetUsers(qemuAgentPtr mon,
+int qemuAgentGetUsers(qemuAgent *mon,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
bool report_unsupported);
-int qemuAgentGetOSInfo(qemuAgentPtr mon,
+int qemuAgentGetOSInfo(qemuAgent *mon,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
bool report_unsupported);
-int qemuAgentGetTimezone(qemuAgentPtr mon,
+int qemuAgentGetTimezone(qemuAgent *mon,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
bool report_unsupported);
-void qemuAgentSetResponseTimeout(qemuAgentPtr mon,
+void qemuAgentSetResponseTimeout(qemuAgent *mon,
int timeout);
-int qemuAgentSSHGetAuthorizedKeys(qemuAgentPtr agent,
+int qemuAgentSSHGetAuthorizedKeys(qemuAgent *agent,
const char *user,
char ***keys);
-int qemuAgentSSHAddAuthorizedKeys(qemuAgentPtr agent,
+int qemuAgentSSHAddAuthorizedKeys(qemuAgent *agent,
const char *user,
const char **keys,
size_t nkeys,
bool reset);
-int qemuAgentSSHRemoveAuthorizedKeys(qemuAgentPtr agent,
+int qemuAgentSSHRemoveAuthorizedKeys(qemuAgent *agent,
const char *user,
const char **keys,
size_t nkeys);
-int qemuAgentGetDisks(qemuAgentPtr mon,
- qemuAgentDiskInfoPtr **disks,
+int qemuAgentGetDisks(qemuAgent *mon,
+ qemuAgentDiskInfo ***disks,
bool report_unsupported);
static ssize_t
-qemuGetNextChrDevIndex(virDomainDefPtr def,
- virDomainChrDefPtr chr,
+qemuGetNextChrDevIndex(virDomainDef *def,
+ virDomainChrDef *chr,
const char *prefix)
{
const virDomainChrDef **arrPtr;
int
-qemuAssignDeviceChrAlias(virDomainDefPtr def,
- virDomainChrDefPtr chr,
+qemuAssignDeviceChrAlias(virDomainDef *def,
+ virDomainChrDef *chr,
ssize_t idx)
{
const char *prefix = NULL;
int
-qemuAssignDeviceControllerAlias(virDomainDefPtr domainDef,
- virQEMUCapsPtr qemuCaps,
- virDomainControllerDefPtr controller)
+qemuAssignDeviceControllerAlias(virDomainDef *domainDef,
+ virQEMUCaps *qemuCaps,
+ virDomainControllerDef *controller)
{
const char *prefix = virDomainControllerTypeToString(controller->type);
int
-qemuAssignDeviceDiskAlias(virDomainDefPtr def,
- virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps)
+qemuAssignDeviceDiskAlias(virDomainDef *def,
+ virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps)
{
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
const char *prefix = virDomainDiskBusTypeToString(disk->bus);
int controllerModel = -1;
int
-qemuAssignDeviceHostdevAlias(virDomainDefPtr def,
+qemuAssignDeviceHostdevAlias(virDomainDef *def,
char **alias,
int idx)
{
int
-qemuAssignDeviceNetAlias(virDomainDefPtr def,
- virDomainNetDefPtr net,
+qemuAssignDeviceNetAlias(virDomainDef *def,
+ virDomainNetDef *net,
int idx)
{
if (net->info.alias)
static int
-qemuAssignDeviceFSAlias(virDomainFSDefPtr fss,
+qemuAssignDeviceFSAlias(virDomainFSDef *fss,
int idx)
{
if (fss->info.alias)
static int
-qemuAssignDeviceSoundAlias(virDomainSoundDefPtr sound,
+qemuAssignDeviceSoundAlias(virDomainSoundDef *sound,
int idx)
{
if (sound->info.alias)
static int
-qemuAssignDeviceVideoAlias(virDomainVideoDefPtr video,
+qemuAssignDeviceVideoAlias(virDomainVideoDef *video,
int idx)
{
if (video->info.alias)
static int
-qemuAssignDeviceHubAlias(virDomainHubDefPtr hub,
+qemuAssignDeviceHubAlias(virDomainHubDef *hub,
int idx)
{
if (hub->info.alias)
static int
-qemuAssignDeviceSmartcardAlias(virDomainSmartcardDefPtr smartcard,
+qemuAssignDeviceSmartcardAlias(virDomainSmartcardDef *smartcard,
int idx)
{
if (smartcard->info.alias)
static int
-qemuAssignDeviceMemballoonAlias(virDomainMemballoonDefPtr memballoon,
+qemuAssignDeviceMemballoonAlias(virDomainMemballoonDef *memballoon,
int idx)
{
if (memballoon->info.alias)
static int
-qemuAssignDeviceTPMAlias(virDomainTPMDefPtr tpm,
+qemuAssignDeviceTPMAlias(virDomainTPMDef *tpm,
int idx)
{
if (tpm->info.alias)
int
-qemuAssignDeviceRedirdevAlias(virDomainDefPtr def,
- virDomainRedirdevDefPtr redirdev,
+qemuAssignDeviceRedirdevAlias(virDomainDef *def,
+ virDomainRedirdevDef *redirdev,
int idx)
{
if (redirdev->info.alias)
int
-qemuAssignDeviceRNGAlias(virDomainDefPtr def,
- virDomainRNGDefPtr rng)
+qemuAssignDeviceRNGAlias(virDomainDef *def,
+ virDomainRNGDef *rng)
{
size_t i;
int maxidx = 0;
static int
-qemuDeviceMemoryGetAliasID(virDomainDefPtr def,
- virDomainMemoryDefPtr mem,
+qemuDeviceMemoryGetAliasID(virDomainDef *def,
+ virDomainMemoryDef *mem,
bool oldAlias,
const char *prefix)
{
* Returns 0 on success, -1 on error.
*/
int
-qemuAssignDeviceMemoryAlias(virDomainDefPtr def,
- virDomainMemoryDefPtr mem,
+qemuAssignDeviceMemoryAlias(virDomainDef *def,
+ virDomainMemoryDef *mem,
bool oldAlias)
{
const char *prefix = NULL;
int
-qemuAssignDeviceShmemAlias(virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
+qemuAssignDeviceShmemAlias(virDomainDef *def,
+ virDomainShmemDef *shmem,
int idx)
{
if (shmem->info.alias)
int
-qemuAssignDeviceWatchdogAlias(virDomainWatchdogDefPtr watchdog)
+qemuAssignDeviceWatchdogAlias(virDomainWatchdogDef *watchdog)
{
/* Currently, there's just one watchdog per domain */
}
int
-qemuAssignDeviceInputAlias(virDomainDefPtr def,
- virDomainInputDefPtr input,
+qemuAssignDeviceInputAlias(virDomainDef *def,
+ virDomainInputDef *input,
int idx)
{
if (input->info.alias)
int
-qemuAssignDeviceVsockAlias(virDomainVsockDefPtr vsock)
+qemuAssignDeviceVsockAlias(virDomainVsockDef *vsock)
{
if (vsock->info.alias)
return 0;
int
-qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
+qemuAssignDeviceAliases(virDomainDef *def, virQEMUCaps *qemuCaps)
{
size_t i;
#include "qemu_domain.h"
#include "qemu_domain_address.h"
-int qemuAssignDeviceChrAlias(virDomainDefPtr def,
- virDomainChrDefPtr chr,
+int qemuAssignDeviceChrAlias(virDomainDef *def,
+ virDomainChrDef *chr,
ssize_t idx);
-int qemuAssignDeviceControllerAlias(virDomainDefPtr domainDef,
- virQEMUCapsPtr qemuCaps,
- virDomainControllerDefPtr controller);
+int qemuAssignDeviceControllerAlias(virDomainDef *domainDef,
+ virQEMUCaps *qemuCaps,
+ virDomainControllerDef *controller);
-int qemuAssignDeviceDiskAlias(virDomainDefPtr def,
- virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps);
+int qemuAssignDeviceDiskAlias(virDomainDef *def,
+ virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps);
-int qemuAssignDeviceHostdevAlias(virDomainDefPtr def,
+int qemuAssignDeviceHostdevAlias(virDomainDef *def,
char **alias,
int idx);
-int qemuAssignDeviceNetAlias(virDomainDefPtr def,
- virDomainNetDefPtr net,
+int qemuAssignDeviceNetAlias(virDomainDef *def,
+ virDomainNetDef *net,
int idx);
-int qemuAssignDeviceRedirdevAlias(virDomainDefPtr def,
- virDomainRedirdevDefPtr redirdev,
+int qemuAssignDeviceRedirdevAlias(virDomainDef *def,
+ virDomainRedirdevDef *redirdev,
int idx);
-int qemuAssignDeviceRNGAlias(virDomainDefPtr def,
- virDomainRNGDefPtr rng);
+int qemuAssignDeviceRNGAlias(virDomainDef *def,
+ virDomainRNGDef *rng);
-int qemuAssignDeviceMemoryAlias(virDomainDefPtr def,
- virDomainMemoryDefPtr mems,
+int qemuAssignDeviceMemoryAlias(virDomainDef *def,
+ virDomainMemoryDef *mems,
bool oldAlias);
-int qemuAssignDeviceShmemAlias(virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
+int qemuAssignDeviceShmemAlias(virDomainDef *def,
+ virDomainShmemDef *shmem,
int idx);
-int qemuAssignDeviceWatchdogAlias(virDomainWatchdogDefPtr watchdog);
+int qemuAssignDeviceWatchdogAlias(virDomainWatchdogDef *watchdog);
-int qemuAssignDeviceInputAlias(virDomainDefPtr def,
- virDomainInputDefPtr input,
+int qemuAssignDeviceInputAlias(virDomainDef *def,
+ virDomainInputDef *input,
int idx);
-int qemuAssignDeviceVsockAlias(virDomainVsockDefPtr vsock);
+int qemuAssignDeviceVsockAlias(virDomainVsockDef *vsock);
-int qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps);
+int qemuAssignDeviceAliases(virDomainDef *def, virQEMUCaps *qemuCaps);
int qemuDomainDeviceAliasIndex(const virDomainDeviceInfo *info,
const char *prefix);
VIR_LOG_INIT("qemu.qemu_backup");
-static virDomainBackupDefPtr
-qemuDomainGetBackup(virDomainObjPtr vm)
+static virDomainBackupDef *
+qemuDomainGetBackup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!priv->backup) {
virReportError(VIR_ERR_NO_DOMAIN_BACKUP, "%s",
static int
-qemuBackupPrepare(virDomainBackupDefPtr def)
+qemuBackupPrepare(virDomainBackupDef *def)
{
if (def->type == VIR_DOMAIN_BACKUP_TYPE_PULL) {
struct qemuBackupDiskData {
- virDomainBackupDiskDefPtr backupdisk;
- virDomainDiskDefPtr domdisk;
- qemuBlockJobDataPtr blockjob;
- virStorageSourcePtr store;
- virStorageSourcePtr terminator;
- virStorageSourcePtr backingStore;
+ virDomainBackupDiskDef *backupdisk;
+ virDomainDiskDef *domdisk;
+ qemuBlockJobData *blockjob;
+ virStorageSource *store;
+ virStorageSource *terminator;
+ virStorageSource *backingStore;
char *incrementalBitmap;
const char *domdiskIncrementalBitmap; /* name of temporary bitmap installed on disk source */
- qemuBlockStorageSourceChainDataPtr crdata;
+ qemuBlockStorageSourceChainData *crdata;
bool labelled;
bool initialized;
bool created;
static void
-qemuBackupDiskDataCleanupOne(virDomainObjPtr vm,
+qemuBackupDiskDataCleanupOne(virDomainObj *vm,
struct qemuBackupDiskData *dd)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!dd->started) {
if (dd->added) {
static void
-qemuBackupDiskDataCleanup(virDomainObjPtr vm,
+qemuBackupDiskDataCleanup(virDomainObj *vm,
struct qemuBackupDiskData *dd,
size_t ndd)
{
int
-qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePtr backingChain,
- virStorageSourcePtr targetsrc,
+qemuBackupDiskPrepareOneBitmapsChain(virStorageSource *backingChain,
+ virStorageSource *targetsrc,
const char *targetbitmap,
const char *incremental,
- virJSONValuePtr actions,
+ virJSONValue *actions,
GHashTable *blockNamedNodeData)
{
g_autoptr(virJSONValue) tmpactions = NULL;
static int
qemuBackupDiskPrepareOneBitmaps(struct qemuBackupDiskData *dd,
- virJSONValuePtr actions,
+ virJSONValue *actions,
bool pull,
GHashTable *blockNamedNodeData)
{
static int
-qemuBackupDiskPrepareDataOne(virDomainObjPtr vm,
- virDomainBackupDiskDefPtr backupdisk,
+qemuBackupDiskPrepareDataOne(virDomainObj *vm,
+ virDomainBackupDiskDef *backupdisk,
struct qemuBackupDiskData *dd,
- virJSONValuePtr actions,
+ virJSONValue *actions,
bool pull,
GHashTable *blockNamedNodeData,
- virQEMUDriverConfigPtr cfg)
+ virQEMUDriverConfig *cfg)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
/* set data structure */
dd->backupdisk = backupdisk;
static int
-qemuBackupDiskPrepareDataOnePush(virJSONValuePtr actions,
+qemuBackupDiskPrepareDataOnePush(virJSONValue *actions,
struct qemuBackupDiskData *dd)
{
qemuMonitorTransactionBackupSyncMode syncmode = QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_FULL;
static int
-qemuBackupDiskPrepareDataOnePull(virJSONValuePtr actions,
+qemuBackupDiskPrepareDataOnePull(virJSONValue *actions,
struct qemuBackupDiskData *dd)
{
if (!dd->backupdisk->exportbitmap &&
static ssize_t
-qemuBackupDiskPrepareData(virDomainObjPtr vm,
- virDomainBackupDefPtr def,
+qemuBackupDiskPrepareData(virDomainObj *vm,
+ virDomainBackupDef *def,
GHashTable *blockNamedNodeData,
- virJSONValuePtr actions,
- virQEMUDriverConfigPtr cfg,
+ virJSONValue *actions,
+ virQEMUDriverConfig *cfg,
struct qemuBackupDiskData **rdd)
{
struct qemuBackupDiskData *disks = NULL;
static int
-qemuBackupDiskPrepareOneStorage(virDomainObjPtr vm,
+qemuBackupDiskPrepareOneStorage(virDomainObj *vm,
GHashTable *blockNamedNodeData,
struct qemuBackupDiskData *dd,
bool reuse_external)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rc;
if (!reuse_external &&
static int
-qemuBackupDiskPrepareStorage(virDomainObjPtr vm,
+qemuBackupDiskPrepareStorage(virDomainObj *vm,
struct qemuBackupDiskData *disks,
size_t ndisks,
GHashTable *blockNamedNodeData,
static void
-qemuBackupDiskStarted(virDomainObjPtr vm,
+qemuBackupDiskStarted(virDomainObj *vm,
struct qemuBackupDiskData *dd,
size_t ndd)
{
* function must be called while in the monitor context.
*/
static int
-qemuBackupBeginPullExportDisks(virDomainObjPtr vm,
+qemuBackupBeginPullExportDisks(virDomainObj *vm,
struct qemuBackupDiskData *disks,
size_t ndisks)
{
void
-qemuBackupJobTerminate(virDomainObjPtr vm,
+qemuBackupJobTerminate(virDomainObj *vm,
qemuDomainJobStatus jobstatus)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
size_t i;
for (i = 0; i < priv->backup->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = priv->backup->disks + i;
+ virDomainBackupDiskDef *backupdisk = priv->backup->disks + i;
if (!backupdisk->store)
continue;
* if there are no outstanding active blockjobs.
*/
void
-qemuBackupJobCancelBlockjobs(virDomainObjPtr vm,
- virDomainBackupDefPtr backup,
+qemuBackupJobCancelBlockjobs(virDomainObj *vm,
+ virDomainBackupDef *backup,
bool terminatebackup,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
int rc = 0;
bool has_active = false;
return;
for (i = 0; i < backup->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = backup->disks + i;
- virDomainDiskDefPtr disk;
+ virDomainBackupDiskDef *backupdisk = backup->disks + i;
+ virDomainDiskDef *disk;
g_autoptr(qemuBlockJobData) job = NULL;
if (!backupdisk->store)
#define QEMU_BACKUP_TLS_ALIAS_BASE "libvirt_backup"
static int
-qemuBackupBeginPrepareTLS(virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
- virDomainBackupDefPtr def,
- virJSONValuePtr *tlsProps,
- virJSONValuePtr *tlsSecretProps)
+qemuBackupBeginPrepareTLS(virDomainObj *vm,
+ virQEMUDriverConfig *cfg,
+ virDomainBackupDef *def,
+ virJSONValue **tlsProps,
+ virJSONValue **tlsSecretProps)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *tlsObjAlias = qemuAliasTLSObjFromSrcAlias(QEMU_BACKUP_TLS_ALIAS_BASE);
g_autoptr(qemuDomainSecretInfo) secinfo = NULL;
const char *tlsKeySecretAlias = NULL;
int
-qemuBackupBegin(virDomainObjPtr vm,
+qemuBackupBegin(virDomainObj *vm,
const char *backupXML,
const char *checkpointXML,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
g_autoptr(virDomainBackupDef) def = NULL;
g_autofree char *suffix = NULL;
bool pull = false;
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
g_autoptr(virDomainCheckpointDef) chkdef = NULL;
g_autoptr(virJSONValue) actions = NULL;
g_autoptr(virJSONValue) tlsProps = NULL;
qemuBackupDiskStarted(vm, dd, ndd);
if (chk) {
- virDomainMomentObjPtr tmpchk = g_steal_pointer(&chk);
+ virDomainMomentObj *tmpchk = g_steal_pointer(&chk);
if (qemuCheckpointCreateFinalize(priv->driver, vm, cfg, tmpchk, true) < 0)
goto endjob;
}
char *
-qemuBackupGetXMLDesc(virDomainObjPtr vm,
+qemuBackupGetXMLDesc(virDomainObj *vm,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainBackupDefPtr backup;
+ virDomainBackupDef *backup;
virCheckFlags(0, NULL);
void
-qemuBackupNotifyBlockjobEnd(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBackupNotifyBlockjobEnd(virDomainObj *vm,
+ virDomainDiskDef *disk,
qemuBlockjobState state,
const char *errmsg,
unsigned long long cur,
unsigned long long end,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool has_running = false;
bool has_cancelling = false;
bool has_cancelled = false;
bool has_failed = false;
qemuDomainJobStatus jobstatus = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
- virDomainBackupDefPtr backup = priv->backup;
+ virDomainBackupDef *backup = priv->backup;
size_t i;
VIR_DEBUG("vm: '%s', disk:'%s', state:'%d' errmsg:'%s'",
backup->errmsg = g_strdup(errmsg);
for (i = 0; i < backup->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = backup->disks + i;
+ virDomainBackupDiskDef *backupdisk = backup->disks + i;
if (!backupdisk->store)
continue;
static void
-qemuBackupGetJobInfoStatsUpdateOne(virDomainObjPtr vm,
+qemuBackupGetJobInfoStatsUpdateOne(virDomainObj *vm,
bool push,
const char *diskdst,
qemuDomainBackupStats *stats,
- qemuMonitorJobInfoPtr *blockjobs,
+ qemuMonitorJobInfo **blockjobs,
size_t nblockjobs)
{
- virDomainDiskDefPtr domdisk;
- qemuMonitorJobInfoPtr monblockjob = NULL;
+ virDomainDiskDef *domdisk;
+ qemuMonitorJobInfo *monblockjob = NULL;
g_autoptr(qemuBlockJobData) diskblockjob = NULL;
size_t i;
int
-qemuBackupGetJobInfoStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainJobInfoPtr jobInfo)
+qemuBackupGetJobInfoStats(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuDomainJobInfo *jobInfo)
{
qemuDomainBackupStats *stats = &jobInfo->stats.backup;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorJobInfoPtr *blockjobs = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitorJobInfo **blockjobs = NULL;
size_t nblockjobs = 0;
size_t i;
int rc;
#pragma once
int
-qemuBackupBegin(virDomainObjPtr vm,
+qemuBackupBegin(virDomainObj *vm,
const char *backupXML,
const char *checkpointXML,
unsigned int flags);
char *
-qemuBackupGetXMLDesc(virDomainObjPtr vm,
+qemuBackupGetXMLDesc(virDomainObj *vm,
unsigned int flags);
void
-qemuBackupJobCancelBlockjobs(virDomainObjPtr vm,
- virDomainBackupDefPtr backup,
+qemuBackupJobCancelBlockjobs(virDomainObj *vm,
+ virDomainBackupDef *backup,
bool terminatebackup,
int asyncJob);
void
-qemuBackupNotifyBlockjobEnd(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBackupNotifyBlockjobEnd(virDomainObj *vm,
+ virDomainDiskDef *disk,
qemuBlockjobState state,
const char *errmsg,
unsigned long long cur,
int asyncJob);
void
-qemuBackupJobTerminate(virDomainObjPtr vm,
+qemuBackupJobTerminate(virDomainObj *vm,
qemuDomainJobStatus jobstatus);
int
-qemuBackupGetJobInfoStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainJobInfoPtr jobInfo);
+qemuBackupGetJobInfoStats(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuDomainJobInfo *jobInfo);
/* exported for testing */
int
-qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePtr backingChain,
- virStorageSourcePtr targetsrc,
+qemuBackupDiskPrepareOneBitmapsChain(virStorageSource *backingChain,
+ virStorageSource *targetsrc,
const char *targetbitmap,
const char *incremental,
- virJSONValuePtr actions,
+ virJSONValue *actions,
GHashTable *blockNamedNodeData);
static int
qemuBlockNamedNodesArrayToHash(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
GHashTable *table = opaque;
static void
-qemuBlockNodeNameBackingChainDataFree(qemuBlockNodeNameBackingChainDataPtr data)
+qemuBlockNodeNameBackingChainDataFree(qemuBlockNodeNameBackingChainData *data)
{
if (!data)
return;
static int
-qemuBlockNodeNameGetBackingChainBacking(virJSONValuePtr next,
+qemuBlockNodeNameGetBackingChainBacking(virJSONValue *next,
GHashTable *nodenamestable,
- qemuBlockNodeNameBackingChainDataPtr *nodenamedata)
+ qemuBlockNodeNameBackingChainData **nodenamedata)
{
g_autoptr(qemuBlockNodeNameBackingChainData) data = NULL;
- qemuBlockNodeNameBackingChainDataPtr backingdata = NULL;
- virJSONValuePtr backing = virJSONValueObjectGetObject(next, "backing");
- virJSONValuePtr parent = virJSONValueObjectGetObject(next, "parent");
- virJSONValuePtr parentnodedata;
- virJSONValuePtr nodedata;
+ qemuBlockNodeNameBackingChainData *backingdata = NULL;
+ virJSONValue *backing = virJSONValueObjectGetObject(next, "backing");
+ virJSONValue *parent = virJSONValueObjectGetObject(next, "parent");
+ virJSONValue *parentnodedata;
+ virJSONValue *nodedata;
const char *nodename = virJSONValueObjectGetString(next, "node-name");
const char *drvname = NULL;
const char *drvparent = NULL;
static int
qemuBlockNodeNameGetBackingChainDisk(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
struct qemuBlockNodeNameGetBackingChainData *data = opaque;
* Tries to reconstruct the backing chain from @json to allow detection of
* node names that were auto-assigned by qemu. This is a best-effort operation
* and may not be successful. The returned hash table contains the entries as
- * qemuBlockNodeNameBackingChainDataPtr accessible by the node name. The fields
+ * qemuBlockNodeNameBackingChainData *accessible by the node name. The fields
* then can be used to recover the full backing chain.
*
* Returns a hash table on success and NULL on failure.
*/
GHashTable *
-qemuBlockNodeNameGetBackingChain(virJSONValuePtr namednodes,
- virJSONValuePtr blockstats)
+qemuBlockNodeNameGetBackingChain(virJSONValue *namednodes,
+ virJSONValue *blockstats)
{
struct qemuBlockNodeNameGetBackingChainData data;
g_autoptr(GHashTable) namednodestable = NULL;
static void
-qemuBlockDiskClearDetectedNodes(virDomainDiskDefPtr disk)
+qemuBlockDiskClearDetectedNodes(virDomainDiskDef *disk)
{
- virStorageSourcePtr next = disk->src;
+ virStorageSource *next = disk->src;
while (virStorageSourceIsBacking(next)) {
VIR_FREE(next->nodeformat);
static int
-qemuBlockDiskDetectNodes(virDomainDiskDefPtr disk,
+qemuBlockDiskDetectNodes(virDomainDiskDef *disk,
GHashTable *disktable)
{
- qemuBlockNodeNameBackingChainDataPtr entry = NULL;
- virStorageSourcePtr src = disk->src;
+ qemuBlockNodeNameBackingChainData *entry = NULL;
+ virStorageSource *src = disk->src;
g_autofree char *alias = NULL;
/* don't attempt the detection if the top level already has node names */
int
-qemuBlockNodeNamesDetect(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockNodeNamesDetect(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) disktable = NULL;
g_autoptr(virJSONValue) data = NULL;
g_autoptr(virJSONValue) blockstats = NULL;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
size_t i;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_NAMED_BLOCK_NODES))
* Returns a filled GHashTable *on success NULL on error.
*/
GHashTable *
-qemuBlockGetNodeData(virJSONValuePtr data)
+qemuBlockGetNodeData(virJSONValue *data)
{
g_autoptr(GHashTable) nodedata = NULL;
* separate processes.
*/
bool
-qemuBlockStorageSourceSupportsConcurrentAccess(virStorageSourcePtr src)
+qemuBlockStorageSourceSupportsConcurrentAccess(virStorageSource *src)
{
/* no need to check in backing chain since only RAW storage supports this */
return src->format == VIR_STORAGE_FILE_RAW;
*
* Formats a URI from a virStorageSource.
*/
-virURIPtr
-qemuBlockStorageSourceGetURI(virStorageSourcePtr src)
+virURI *
+qemuBlockStorageSourceGetURI(virStorageSource *src)
{
g_autoptr(virURI) uri = NULL;
/**
* qemuBlockStorageSourceBuildJSONSocketAddress
- * @host: the virStorageNetHostDefPtr definition to build
+ * @host: the virStorageNetHostDef * definition to build
* @legacy: use old field names/values
*
* Formats @hosts into a json object conforming to the 'SocketAddress' type
* For compatibility with old approach used in the gluster driver of old qemus
* use the old spelling for TCP transport and, the path field of the unix socket.
*
- * Returns a virJSONValuePtr for a single server.
+ * Returns a virJSONValue * for a single server.
*/
-static virJSONValuePtr
-qemuBlockStorageSourceBuildJSONSocketAddress(virStorageNetHostDefPtr host,
+static virJSONValue *
+qemuBlockStorageSourceBuildJSONSocketAddress(virStorageNetHostDef *host,
bool legacy)
{
g_autoptr(virJSONValue) server = NULL;
* Formats src->hosts into a json object conforming to the 'SocketAddress' type
* in qemu.
*/
-static virJSONValuePtr
-qemuBlockStorageSourceBuildHostsJSONSocketAddress(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceBuildHostsJSONSocketAddress(virStorageSource *src,
bool legacy)
{
g_autoptr(virJSONValue) servers = NULL;
g_autoptr(virJSONValue) server = NULL;
- virStorageNetHostDefPtr host;
+ virStorageNetHostDef *host;
size_t i;
servers = virJSONValueNewArray();
/**
* qemuBlockStorageSourceBuildJSONInetSocketAddress
- * @host: the virStorageNetHostDefPtr definition to build
+ * @host: the virStorageNetHostDef * definition to build
*
* Formats @hosts into a json object conforming to the 'InetSocketAddress' type
* in qemu.
*
- * Returns a virJSONValuePtr for a single server.
+ * Returns a virJSONValue *for a single server.
*/
-static virJSONValuePtr
-qemuBlockStorageSourceBuildJSONInetSocketAddress(virStorageNetHostDefPtr host)
+static virJSONValue *
+qemuBlockStorageSourceBuildJSONInetSocketAddress(virStorageNetHostDef *host)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
g_autofree char *port = NULL;
if (host->transport != VIR_STORAGE_NET_HOST_TRANS_TCP) {
/**
- * qemuBlockStorageSourceBuildJSONNFSServer(virStorageNetHostDefPtr host)
- * @host: the virStorageNetHostDefPtr definition to build
+ * qemuBlockStorageSourceBuildJSONNFSServer(virStorageNetHostDef *host)
+ * @host: the virStorageNetHostDef * definition to build
*
* Formats @hosts into a json object conforming to the 'NFSServer' type
* in qemu.
*
- * Returns a virJSONValuePtr for a single server.
+ * Returns a virJSONValue *for a single server.
*/
-static virJSONValuePtr
-qemuBlockStorageSourceBuildJSONNFSServer(virStorageNetHostDefPtr host)
+static virJSONValue *
+qemuBlockStorageSourceBuildJSONNFSServer(virStorageNetHostDef *host)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
ignore_value(virJSONValueObjectCreate(&ret,
"s:host", host->name,
* Formats src->hosts into a json object conforming to the 'InetSocketAddress'
* type in qemu.
*/
-static virJSONValuePtr
-qemuBlockStorageSourceBuildHostsJSONInetSocketAddress(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceBuildHostsJSONInetSocketAddress(virStorageSource *src)
{
g_autoptr(virJSONValue) servers = NULL;
g_autoptr(virJSONValue) server = NULL;
- virStorageNetHostDefPtr host;
+ virStorageNetHostDef *host;
size_t i;
servers = virJSONValueNewArray();
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetGlusterProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetGlusterProps(virStorageSource *src,
bool legacy,
bool onlytarget)
{
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetVxHSProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetVxHSProps(virStorageSource *src,
bool onlytarget)
{
g_autoptr(virJSONValue) server = NULL;
const char *tlsAlias = src->tlsAlias;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (src->nhosts != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetNFSProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetNFSProps(virStorageSource *src)
{
g_autoptr(virJSONValue) server = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (!(server = qemuBlockStorageSourceBuildJSONNFSServer(&src->hosts[0])))
return NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetCURLProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetCURLProps(virStorageSource *src,
bool onlytarget)
{
- qemuDomainStorageSourcePrivatePtr srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
const char *passwordalias = NULL;
const char *cookiealias = NULL;
const char *username = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
g_autoptr(virURI) uri = NULL;
g_autofree char *uristr = NULL;
g_autofree char *cookiestr = NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetISCSIProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetISCSIProps(virStorageSource *src,
bool onlytarget)
{
- qemuDomainStorageSourcePrivatePtr srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
g_autofree char *target = NULL;
char *lunStr = NULL;
char *username = NULL;
char *objalias = NULL;
g_autofree char *portal = NULL;
unsigned int lun = 0;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
/* { driver:"iscsi",
* transport:"tcp", ("iser" also possible)
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetNBDProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetNBDProps(virStorageSource *src,
bool onlytarget)
{
g_autoptr(virJSONValue) serverprops = NULL;
const char *tlsAlias = src->tlsAlias;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (src->nhosts != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetRBDProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetRBDProps(virStorageSource *src,
bool onlytarget)
{
- qemuDomainStorageSourcePrivatePtr srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
g_autoptr(virJSONValue) servers = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
const char *username = NULL;
g_autoptr(virJSONValue) authmodes = NULL;
g_autoptr(virJSONValue) mode = NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetSheepdogProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetSheepdogProps(virStorageSource *src)
{
g_autoptr(virJSONValue) serverprops = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (src->nhosts != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetSshProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetSshProps(virStorageSource *src)
{
g_autoptr(virJSONValue) serverprops = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
const char *username = NULL;
g_autoptr(virJSONValue) host_key_check = NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetFileProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetFileProps(virStorageSource *src,
bool onlytarget)
{
const char *iomode = NULL;
const char *prManagerAlias = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (!onlytarget) {
if (src->pr)
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetVvfatProps(virStorageSourcePtr src,
+static virJSONValue *
+qemuBlockStorageSourceGetVvfatProps(virStorageSource *src,
bool onlytarget)
{
g_autoptr(virJSONValue) ret = NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetNVMeProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetNVMeProps(virStorageSource *src)
{
const virStorageSourceNVMeDef *nvme = src->nvme;
g_autofree char *pciAddr = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (!(pciAddr = virPCIDeviceAddressAsString(&nvme->pciAddr)))
return NULL;
static int
-qemuBlockStorageSourceGetBlockdevGetCacheProps(virStorageSourcePtr src,
- virJSONValuePtr props)
+qemuBlockStorageSourceGetBlockdevGetCacheProps(virStorageSource *src,
+ virJSONValue *props)
{
g_autoptr(virJSONValue) cacheobj = NULL;
bool direct = false;
* Creates a JSON object describing the underlying storage or protocol of a
* storage source. Returns NULL on error and reports an appropriate error message.
*/
-virJSONValuePtr
-qemuBlockStorageSourceGetBackendProps(virStorageSourcePtr src,
+virJSONValue *
+qemuBlockStorageSourceGetBackendProps(virStorageSource *src,
unsigned int flags)
{
int actualType = virStorageSourceGetActualType(src);
static int
-qemuBlockStorageSourceGetFormatLUKSProps(virStorageSourcePtr src,
- virJSONValuePtr props)
+qemuBlockStorageSourceGetFormatLUKSProps(virStorageSource *src,
+ virJSONValue *props)
{
- qemuDomainStorageSourcePrivatePtr srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
if (!srcPriv || !srcPriv->encinfo || !srcPriv->encinfo->s.aes.alias) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
-qemuBlockStorageSourceGetFormatRawProps(virStorageSourcePtr src,
- virJSONValuePtr props)
+qemuBlockStorageSourceGetFormatRawProps(virStorageSource *src,
+ virJSONValue *props)
{
if (virJSONValueObjectAdd(props, "s:driver", "raw", NULL) < 0)
return -1;
static int
-qemuBlockStorageSourceGetCryptoProps(virStorageSourcePtr src,
- virJSONValuePtr *encprops)
+qemuBlockStorageSourceGetCryptoProps(virStorageSource *src,
+ virJSONValue **encprops)
{
- qemuDomainStorageSourcePrivatePtr srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
const char *encformat = NULL;
*encprops = NULL;
static int
-qemuBlockStorageSourceGetFormatQcowGenericProps(virStorageSourcePtr src,
+qemuBlockStorageSourceGetFormatQcowGenericProps(virStorageSource *src,
const char *format,
- virJSONValuePtr props)
+ virJSONValue *props)
{
g_autoptr(virJSONValue) encprops = NULL;
static int
-qemuBlockStorageSourceGetFormatQcow2Props(virStorageSourcePtr src,
- virJSONValuePtr props)
+qemuBlockStorageSourceGetFormatQcow2Props(virStorageSource *src,
+ virJSONValue *props)
{
/* currently unhandled qcow2 props:
*
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetBlockdevFormatCommonProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetBlockdevFormatCommonProps(virStorageSource *src)
{
const char *detectZeroes = NULL;
const char *discard = NULL;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetBlockdevFormatProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetBlockdevFormatProps(virStorageSource *src)
{
const char *driver = NULL;
g_autoptr(virJSONValue) props = NULL;
* -blockdev. The formatted object contains both the storage and format layer
* in nested form including link to the backing chain layer if necessary.
*/
-virJSONValuePtr
-qemuBlockStorageSourceGetBlockdevProps(virStorageSourcePtr src,
- virStorageSourcePtr backingStore)
+virJSONValue *
+qemuBlockStorageSourceGetBlockdevProps(virStorageSource *src,
+ virStorageSource *backingStore)
{
g_autoptr(virJSONValue) props = NULL;
const char *storagenode = src->nodestorage;
}
-static virJSONValuePtr
-qemuBlockStorageSourceGetBlockdevStorageSliceProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuBlockStorageSourceGetBlockdevStorageSliceProps(virStorageSource *src)
{
g_autoptr(virJSONValue) props = NULL;
void
-qemuBlockStorageSourceAttachDataFree(qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachDataFree(qemuBlockStorageSourceAttachData *data)
{
if (!data)
return;
* Returns the filled data structure on success or NULL on error and a libvirt
* error is reported
*/
-qemuBlockStorageSourceAttachDataPtr
-qemuBlockStorageSourceAttachPrepareBlockdev(virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
+qemuBlockStorageSourceAttachData *
+qemuBlockStorageSourceAttachPrepareBlockdev(virStorageSource *src,
+ virStorageSource *backingStore,
bool autoreadonly)
{
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
static int
-qemuBlockStorageSourceAttachApplyStorageDeps(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApplyStorageDeps(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (data->prmgrProps &&
qemuMonitorAddObject(mon, &data->prmgrProps, &data->prmgrAlias) < 0)
static int
-qemuBlockStorageSourceAttachApplyStorage(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApplyStorage(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (data->storageProps) {
if (qemuMonitorBlockdevAdd(mon, &data->storageProps) < 0)
static int
-qemuBlockStorageSourceAttachApplyFormatDeps(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApplyFormatDeps(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (data->encryptsecretProps &&
qemuMonitorAddObject(mon, &data->encryptsecretProps,
static int
-qemuBlockStorageSourceAttachApplyFormat(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApplyFormat(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (data->formatProps) {
if (qemuMonitorBlockdevAdd(mon, &data->formatProps) < 0)
static int
-qemuBlockStorageSourceAttachApplyStorageSlice(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApplyStorageSlice(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (data->storageSliceProps) {
if (qemuMonitorBlockdevAdd(mon, &data->storageSliceProps) < 0)
* calling qemuBlockStorageSourceAttachRollback.
*/
int
-qemuBlockStorageSourceAttachApply(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachApply(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
if (qemuBlockStorageSourceAttachApplyStorageDeps(mon, data) < 0 ||
qemuBlockStorageSourceAttachApplyStorage(mon, data) < 0 ||
* This function expects being called after the monitor was entered.
*/
void
-qemuBlockStorageSourceAttachRollback(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data)
+qemuBlockStorageSourceAttachRollback(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data)
{
virErrorPtr orig_err;
* @src: disk source structure
* @driveAlias: Alias of the -drive backend, the pointer is always consumed
*
- * Prepare qemuBlockStorageSourceAttachDataPtr for detaching a single source
+ * Prepare qemuBlockStorageSourceAttachData *for detaching a single source
* from a VM. If @driveAlias is NULL -blockdev is assumed.
*/
-qemuBlockStorageSourceAttachDataPtr
-qemuBlockStorageSourceDetachPrepare(virStorageSourcePtr src,
+qemuBlockStorageSourceAttachData *
+qemuBlockStorageSourceDetachPrepare(virStorageSource *src,
char *driveAlias)
{
- qemuDomainStorageSourcePrivatePtr srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
data = g_new0(qemuBlockStorageSourceAttachData, 1);
void
-qemuBlockStorageSourceChainDataFree(qemuBlockStorageSourceChainDataPtr data)
+qemuBlockStorageSourceChainDataFree(qemuBlockStorageSourceChainData *data)
{
size_t i;
* qemuBlockStorageSourceChainDetachPrepareBlockdev
* @src: storage source chain to remove
*
- * Prepares qemuBlockStorageSourceChainDataPtr for detaching @src and its
+ * Prepares qemuBlockStorageSourceChainData *for detaching @src and its
* backingStore if -blockdev was used.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBlockStorageSourceChainDetachPrepareBlockdev(virStorageSourcePtr src)
+qemuBlockStorageSourceChainData *
+qemuBlockStorageSourceChainDetachPrepareBlockdev(virStorageSource *src)
{
g_autoptr(qemuBlockStorageSourceAttachData) backend = NULL;
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
- virStorageSourcePtr n;
+ virStorageSource *n;
data = g_new0(qemuBlockStorageSourceChainData, 1);
* @src: storage source chain to remove
* @driveAlias: Alias of the 'drive' backend (always consumed)
*
- * Prepares qemuBlockStorageSourceChainDataPtr for detaching @src and its
+ * Prepares qemuBlockStorageSourceChainData *for detaching @src and its
* backingStore if -drive was used.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBlockStorageSourceChainDetachPrepareDrive(virStorageSourcePtr src,
+qemuBlockStorageSourceChainData *
+qemuBlockStorageSourceChainDetachPrepareDrive(virStorageSource *src,
char *driveAlias)
{
g_autoptr(qemuBlockStorageSourceAttachData) backend = NULL;
* qemuBlockStorageSourceChainDetachPrepareChardev
* @src: storage source chain to remove
*
- * Prepares qemuBlockStorageSourceChainDataPtr for detaching @src and its
+ * Prepares qemuBlockStorageSourceChainData *for detaching @src and its
* backingStore if -chardev was used.
*/
-qemuBlockStorageSourceChainDataPtr
+qemuBlockStorageSourceChainData *
qemuBlockStorageSourceChainDetachPrepareChardev(char *chardevAlias)
{
g_autoptr(qemuBlockStorageSourceAttachData) backend = NULL;
* can be used to roll-back the changes.
*/
int
-qemuBlockStorageSourceChainAttach(qemuMonitorPtr mon,
- qemuBlockStorageSourceChainDataPtr data)
+qemuBlockStorageSourceChainAttach(qemuMonitor *mon,
+ qemuBlockStorageSourceChainData *data)
{
size_t i;
* objects described by @data.
*/
void
-qemuBlockStorageSourceChainDetach(qemuMonitorPtr mon,
- qemuBlockStorageSourceChainDataPtr data)
+qemuBlockStorageSourceChainDetach(qemuMonitor *mon,
+ qemuBlockStorageSourceChainData *data)
{
size_t i;
* monitor internally.
*/
int
-qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
int ret;
int
-qemuBlockSnapshotAddLegacy(virJSONValuePtr actions,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc,
+qemuBlockSnapshotAddLegacy(virJSONValue *actions,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc,
bool reuse)
{
const char *format = virStorageFileFormatTypeToString(newsrc->format);
int
-qemuBlockSnapshotAddBlockdev(virJSONValuePtr actions,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc)
+qemuBlockSnapshotAddBlockdev(virJSONValue *actions,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc)
{
return qemuMonitorTransactionSnapshotBlockdev(actions,
disk->src->nodeformat,
*
* Creates blockdev properties for a disk copy-on-read layer.
*/
-virJSONValuePtr
-qemuBlockStorageGetCopyOnReadProps(virDomainDiskDefPtr disk)
+virJSONValue *
+qemuBlockStorageGetCopyOnReadProps(virDomainDiskDef *disk)
{
- qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- virJSONValuePtr ret = NULL;
+ qemuDomainDiskPrivate *priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virJSONValue *ret = NULL;
ignore_value(virJSONValueObjectCreate(&ret,
"s:driver", "copy-on-read",
* pseudo protocol for any complex configuration.
*/
char *
-qemuBlockGetBackingStoreString(virStorageSourcePtr src,
+qemuBlockGetBackingStoreString(virStorageSource *src,
bool pretty)
{
int actualType = virStorageSourceGetActualType(src);
g_autoptr(virJSONValue) backingProps = NULL;
g_autoptr(virJSONValue) sliceProps = NULL;
- virJSONValuePtr props = NULL;
+ virJSONValue *props = NULL;
g_autoptr(virURI) uri = NULL;
g_autofree char *backingJSON = NULL;
static int
-qemuBlockStorageSourceCreateAddBacking(virStorageSourcePtr backing,
- virJSONValuePtr props,
+qemuBlockStorageSourceCreateAddBacking(virStorageSource *backing,
+ virJSONValue *props,
bool format)
{
g_autofree char *backingFileStr = NULL;
static int
-qemuBlockStorageSourceCreateGetFormatPropsGeneric(virStorageSourcePtr src,
+qemuBlockStorageSourceCreateGetFormatPropsGeneric(virStorageSource *src,
const char *driver,
- virJSONValuePtr *retprops,
- virStorageSourcePtr backing)
+ virJSONValue **retprops,
+ virStorageSource *backing)
{
g_autoptr(virJSONValue) props = NULL;
static int
-qemuBlockStorageSourceCreateGetEncryptionLUKS(virStorageSourcePtr src,
- virJSONValuePtr *luksProps)
+qemuBlockStorageSourceCreateGetEncryptionLUKS(virStorageSource *src,
+ virJSONValue **luksProps)
{
- qemuDomainStorageSourcePrivatePtr srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
g_autoptr(virJSONValue) props = NULL;
g_autofree char *cipheralg = NULL;
const char *keysecret = NULL;
static int
-qemuBlockStorageSourceCreateGetFormatPropsLUKS(virStorageSourcePtr src,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatPropsLUKS(virStorageSource *src,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) luksprops = NULL;
static int
-qemuBlockStorageSourceCreateAddEncryptionQcow(virStorageSourcePtr src,
- virJSONValuePtr props)
+qemuBlockStorageSourceCreateAddEncryptionQcow(virStorageSource *src,
+ virJSONValue *props)
{
g_autoptr(virJSONValue) encryptProps = NULL;
static int
-qemuBlockStorageSourceCreateGetFormatPropsQcow2(virStorageSourcePtr src,
- virStorageSourcePtr backing,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatPropsQcow2(virStorageSource *src,
+ virStorageSource *backing,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) qcow2props = NULL;
const char *qcow2version = NULL;
static int
-qemuBlockStorageSourceCreateGetFormatPropsQcow(virStorageSourcePtr src,
- virStorageSourcePtr backing,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatPropsQcow(virStorageSource *src,
+ virStorageSource *backing,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) qcowprops = NULL;
static int
-qemuBlockStorageSourceCreateGetFormatPropsQed(virStorageSourcePtr src,
- virStorageSourcePtr backing,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatPropsQed(virStorageSource *src,
+ virStorageSource *backing,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) qedprops = NULL;
* of 'raw' storage is also returns NULL as there is nothing to do.
*/
int
-qemuBlockStorageSourceCreateGetFormatProps(virStorageSourcePtr src,
- virStorageSourcePtr backing,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatProps(virStorageSource *src,
+ virStorageSource *backing,
+ virJSONValue **props)
{
switch ((virStorageFileFormat) src->format) {
case VIR_STORAGE_FILE_RAW:
* on given protocol. @src->physical is used as size for the storage.
*/
int
-qemuBlockStorageSourceCreateGetStorageProps(virStorageSourcePtr src,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetStorageProps(virStorageSource *src,
+ virJSONValue **props)
{
int actualType = virStorageSourceGetActualType(src);
g_autoptr(virJSONValue) location = NULL;
static int
-qemuBlockStorageSourceCreateGeneric(virDomainObjPtr vm,
- virJSONValuePtr createProps,
- virStorageSourcePtr src,
- virStorageSourcePtr chain,
+qemuBlockStorageSourceCreateGeneric(virDomainObj *vm,
+ virJSONValue *createProps,
+ virStorageSource *src,
+ virStorageSource *chain,
bool storageCreate,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(virJSONValue) props = createProps;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuBlockJobDataPtr job = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuBlockJobData *job = NULL;
int ret = -1;
int rc;
static int
-qemuBlockStorageSourceCreateStorage(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr chain,
+qemuBlockStorageSourceCreateStorage(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *chain,
qemuDomainAsyncJob asyncJob)
{
int actualType = virStorageSourceGetActualType(src);
static int
-qemuBlockStorageSourceCreateFormat(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
- virStorageSourcePtr chain,
+qemuBlockStorageSourceCreateFormat(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *backingStore,
+ virStorageSource *chain,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(virJSONValue) createformatprops = NULL;
* store.
*/
int
-qemuBlockStorageSourceCreate(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
- virStorageSourcePtr chain,
- qemuBlockStorageSourceAttachDataPtr data,
+qemuBlockStorageSourceCreate(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *backingStore,
+ virStorageSource *chain,
+ qemuBlockStorageSourceAttachData *data,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
int rc;
*/
int
qemuBlockStorageSourceCreateDetectSize(GHashTable *blockNamedNodeData,
- virStorageSourcePtr src,
- virStorageSourcePtr templ)
+ virStorageSource *src,
+ virStorageSource *templ)
{
- qemuBlockNamedNodeDataPtr entry;
+ qemuBlockNamedNodeData *entry;
if (!(entry = virHashLookup(blockNamedNodeData, templ->nodeformat))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
int
-qemuBlockRemoveImageMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockRemoveImageMetadata(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *diskTarget,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
int ret = 0;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
*
* Looks up a bitmap named @bitmap of the @src image.
*/
-qemuBlockNamedNodeDataBitmapPtr
+qemuBlockNamedNodeDataBitmap *
qemuBlockNamedNodeDataGetBitmapByName(GHashTable *blockNamedNodeData,
- virStorageSourcePtr src,
+ virStorageSource *src,
const char *bitmap)
{
- qemuBlockNamedNodeDataPtr nodedata;
+ qemuBlockNamedNodeData *nodedata;
size_t i;
if (!(nodedata = virHashLookup(blockNamedNodeData, src->nodeformat)))
return NULL;
for (i = 0; i < nodedata->nbitmaps; i++) {
- qemuBlockNamedNodeDataBitmapPtr bitmapdata = nodedata->bitmaps[i];
+ qemuBlockNamedNodeDataBitmap *bitmapdata = nodedata->bitmaps[i];
if (STRNEQ(bitmapdata->name, bitmap))
continue;
GHashTable *
-qemuBlockGetNamedNodeData(virDomainObjPtr vm,
+qemuBlockGetNamedNodeData(virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
bool supports_flat = virQEMUCapsGet(priv->qemuCaps,
QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NODES_FLAT);
* from @blockNamedNodeData so they must not be freed.
*/
static GSList *
-qemuBlockGetBitmapMergeActionsGetBitmaps(virStorageSourcePtr topsrc,
+qemuBlockGetBitmapMergeActionsGetBitmaps(virStorageSource *topsrc,
const char *bitmapname,
GHashTable *blockNamedNodeData)
{
g_autoptr(GSList) ret = NULL;
- qemuBlockNamedNodeDataPtr entry;
+ qemuBlockNamedNodeData *entry;
size_t i;
/* for now it doesn't make sense to consider bitmaps which are not present
return NULL;
for (i = 0; i < entry->nbitmaps; i++) {
- qemuBlockNamedNodeDataBitmapPtr bitmap = entry->bitmaps[i];
+ qemuBlockNamedNodeDataBitmap *bitmap = entry->bitmaps[i];
if (bitmapname &&
STRNEQ(bitmapname, bitmap->name))
* Note that @actions may be NULL if no merging is required.
*/
int
-qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
- virStorageSourcePtr basesrc,
- virStorageSourcePtr target,
+qemuBlockGetBitmapMergeActions(virStorageSource *topsrc,
+ virStorageSource *basesrc,
+ virStorageSource *target,
const char *bitmapname,
const char *dstbitmapname,
- virStorageSourcePtr writebitmapsrc,
- virJSONValuePtr *actions,
+ virStorageSource *writebitmapsrc,
+ virJSONValue **actions,
GHashTable *blockNamedNodeData)
{
g_autoptr(virJSONValue) act = virJSONValueNewArray();
- virStorageSourcePtr n;
+ virStorageSource *n;
g_autoptr(GSList) bitmaps = NULL;
GSList *next;
bool mergebitmapdisabled = true;
g_autoptr(virJSONValue) merge = virJSONValueNewArray();
unsigned long long granularity = 0;
- qemuBlockNamedNodeDataBitmapPtr bitmap;
+ qemuBlockNamedNodeDataBitmap *bitmap;
/* explicitly named destinations mean that we want a temporary
* disabled bitmap only, so undo the default for non-explicit cases */
* 3) all must be active, persistent and not inconsistent
*/
bool
-qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
+qemuBlockBitmapChainIsValid(virStorageSource *src,
const char *bitmapname,
GHashTable *blockNamedNodeData)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
bool found = false;
bool chain_ended = false;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
- qemuBlockNamedNodeDataBitmapPtr bitmap;
+ qemuBlockNamedNodeDataBitmap *bitmap;
if (!(bitmap = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData,
n, bitmapname))) {
* there are no actions to perform for the given job.
*/
int
-qemuBlockBitmapsHandleBlockcopy(virStorageSourcePtr src,
- virStorageSourcePtr mirror,
+qemuBlockBitmapsHandleBlockcopy(virStorageSource *src,
+ virStorageSource *mirror,
GHashTable *blockNamedNodeData,
bool shallow,
- virJSONValuePtr *actions)
+ virJSONValue **actions)
{
- virStorageSourcePtr base = NULL;
+ virStorageSource *base = NULL;
if (shallow)
base = src->backingStore;
* 'actions' if there is anything to do. Otherwise NULL is returned.
*/
int
-qemuBlockBitmapsHandleCommitFinish(virStorageSourcePtr topsrc,
- virStorageSourcePtr basesrc,
+qemuBlockBitmapsHandleCommitFinish(virStorageSource *topsrc,
+ virStorageSource *basesrc,
bool active,
GHashTable *blockNamedNodeData,
- virJSONValuePtr *actions)
+ virJSONValue **actions)
{
- virStorageSourcePtr writebitmapsrc = NULL;
+ virStorageSource *writebitmapsrc = NULL;
if (active)
writebitmapsrc = basesrc;
* nodenames of @src are used to identify the specific image in qemu.
*/
static int
-qemuBlockReopenFormat(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuBlockReopenFormat(virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virJSONValue) reopenprops = NULL;
int rc;
* if @src is already read-write.
*/
int
-qemuBlockReopenReadWrite(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuBlockReopenReadWrite(virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob)
{
if (!src->readonly)
* if @src is already read-only.
*/
int
-qemuBlockReopenReadOnly(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuBlockReopenReadOnly(virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob)
{
if (src->readonly)
* accepted by qemu.
*/
char *
-qemuBlockStorageSourceGetCookieString(virStorageSourcePtr src)
+qemuBlockStorageSourceGetCookieString(virStorageSource *src)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
for (i = 0; i < src->ncookies; i++) {
- virStorageNetCookieDefPtr cookie = src->cookies[i];
+ virStorageNetCookieDef *cookie = src->cookies[i];
virBufferAsprintf(&buf, "%s=%s; ", cookie->name, cookie->value);
}
* relative.
*/
int
-qemuBlockUpdateRelativeBacking(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr topsrc)
+qemuBlockUpdateRelativeBacking(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *topsrc)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
- virStorageSourcePtr n;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
+ virStorageSource *n;
for (n = src; virStorageSourceHasBacking(n); n = n->backingStore) {
int rc;
}
-virJSONValuePtr
+virJSONValue *
qemuBlockExportGetNBDProps(const char *nodename,
const char *exportname,
bool writable,
{
g_autofree char *exportid = NULL;
g_autoptr(virJSONValue) bitmapsarr = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
exportid = g_strdup_printf("libvirt-nbd-%s", nodename);
* This function must be called while in the monitor context.
*/
int
-qemuBlockExportAddNBD(virDomainObjPtr vm,
+qemuBlockExportAddNBD(virDomainObj *vm,
const char *drivealias,
- virStorageSourcePtr src,
+ virStorageSource *src,
const char *exportname,
bool writable,
const char *bitmap)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV)) {
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCK_EXPORT_ADD)) {
#include "viruri.h"
typedef struct qemuBlockNodeNameBackingChainData qemuBlockNodeNameBackingChainData;
-typedef qemuBlockNodeNameBackingChainData *qemuBlockNodeNameBackingChainDataPtr;
struct qemuBlockNodeNameBackingChainData {
char *qemufilename; /* name of the image from qemu */
char *nodeformat; /* node name of the format layer */
char *nodestorage; /* node name of the storage backing the format node */
- qemuBlockNodeNameBackingChainDataPtr backing;
+ qemuBlockNodeNameBackingChainData *backing;
/* for testing purposes */
char *drvformat;
};
GHashTable *
-qemuBlockNodeNameGetBackingChain(virJSONValuePtr namednodesdata,
- virJSONValuePtr blockstats);
+qemuBlockNodeNameGetBackingChain(virJSONValue *namednodesdata,
+ virJSONValue *blockstats);
int
-qemuBlockNodeNamesDetect(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockNodeNamesDetect(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
GHashTable *
-qemuBlockGetNodeData(virJSONValuePtr data);
+qemuBlockGetNodeData(virJSONValue *data);
bool
-qemuBlockStorageSourceSupportsConcurrentAccess(virStorageSourcePtr src);
+qemuBlockStorageSourceSupportsConcurrentAccess(virStorageSource *src);
typedef enum {
QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_LEGACY = 1 << 0,
QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_SKIP_UNMAP = 1 << 3,
} qemuBlockStorageSourceBackendPropsFlags;
-virJSONValuePtr
-qemuBlockStorageSourceGetBackendProps(virStorageSourcePtr src,
+virJSONValue *
+qemuBlockStorageSourceGetBackendProps(virStorageSource *src,
unsigned int flags);
-virURIPtr
-qemuBlockStorageSourceGetURI(virStorageSourcePtr src);
+virURI *
+qemuBlockStorageSourceGetURI(virStorageSource *src);
-virJSONValuePtr
-qemuBlockStorageSourceGetBlockdevProps(virStorageSourcePtr src,
- virStorageSourcePtr backingStore);
+virJSONValue *
+qemuBlockStorageSourceGetBlockdevProps(virStorageSource *src,
+ virStorageSource *backingStore);
-virJSONValuePtr
-qemuBlockStorageGetCopyOnReadProps(virDomainDiskDefPtr disk);
+virJSONValue *
+qemuBlockStorageGetCopyOnReadProps(virDomainDiskDef *disk);
typedef struct qemuBlockStorageSourceAttachData qemuBlockStorageSourceAttachData;
-typedef qemuBlockStorageSourceAttachData *qemuBlockStorageSourceAttachDataPtr;
struct qemuBlockStorageSourceAttachData {
- virJSONValuePtr prmgrProps;
+ virJSONValue *prmgrProps;
char *prmgrAlias;
- virJSONValuePtr storageProps;
+ virJSONValue *storageProps;
const char *storageNodeName;
bool storageAttached;
- virJSONValuePtr storageSliceProps;
+ virJSONValue *storageSliceProps;
const char *storageSliceNodeName;
bool storageSliceAttached;
- virJSONValuePtr formatProps;
+ virJSONValue *formatProps;
const char *formatNodeName;
bool formatAttached;
char *driveAlias;
bool driveAdded;
- virDomainChrSourceDefPtr chardevDef;
+ virDomainChrSourceDef *chardevDef;
char *chardevAlias;
char *chardevCmd;
bool chardevAdded;
- virJSONValuePtr authsecretProps;
+ virJSONValue *authsecretProps;
char *authsecretAlias;
- virJSONValuePtr encryptsecretProps;
+ virJSONValue *encryptsecretProps;
char *encryptsecretAlias;
- virJSONValuePtr httpcookiesecretProps;
+ virJSONValue *httpcookiesecretProps;
char *httpcookiesecretAlias;
- virJSONValuePtr tlsProps;
+ virJSONValue *tlsProps;
char *tlsAlias;
- virJSONValuePtr tlsKeySecretProps;
+ virJSONValue *tlsKeySecretProps;
char *tlsKeySecretAlias;
};
void
-qemuBlockStorageSourceAttachDataFree(qemuBlockStorageSourceAttachDataPtr data);
+qemuBlockStorageSourceAttachDataFree(qemuBlockStorageSourceAttachData *data);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockStorageSourceAttachData,
qemuBlockStorageSourceAttachDataFree);
-qemuBlockStorageSourceAttachDataPtr
-qemuBlockStorageSourceAttachPrepareBlockdev(virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
+qemuBlockStorageSourceAttachData *
+qemuBlockStorageSourceAttachPrepareBlockdev(virStorageSource *src,
+ virStorageSource *backingStore,
bool autoreadonly);
-qemuBlockStorageSourceAttachDataPtr
-qemuBlockStorageSourceDetachPrepare(virStorageSourcePtr src,
+qemuBlockStorageSourceAttachData *
+qemuBlockStorageSourceDetachPrepare(virStorageSource *src,
char *driveAlias);
int
-qemuBlockStorageSourceAttachApply(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data);
+qemuBlockStorageSourceAttachApply(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data);
void
-qemuBlockStorageSourceAttachRollback(qemuMonitorPtr mon,
- qemuBlockStorageSourceAttachDataPtr data);
+qemuBlockStorageSourceAttachRollback(qemuMonitor *mon,
+ qemuBlockStorageSourceAttachData *data);
int
-qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virStorageSourcePtr src);
+ virStorageSource *src);
struct _qemuBlockStorageSourceChainData {
- qemuBlockStorageSourceAttachDataPtr *srcdata;
+ qemuBlockStorageSourceAttachData **srcdata;
size_t nsrcdata;
};
typedef struct _qemuBlockStorageSourceChainData qemuBlockStorageSourceChainData;
-typedef qemuBlockStorageSourceChainData *qemuBlockStorageSourceChainDataPtr;
void
-qemuBlockStorageSourceChainDataFree(qemuBlockStorageSourceChainDataPtr data);
+qemuBlockStorageSourceChainDataFree(qemuBlockStorageSourceChainData *data);
-qemuBlockStorageSourceChainDataPtr
-qemuBlockStorageSourceChainDetachPrepareBlockdev(virStorageSourcePtr src);
-qemuBlockStorageSourceChainDataPtr
-qemuBlockStorageSourceChainDetachPrepareDrive(virStorageSourcePtr src,
+qemuBlockStorageSourceChainData *
+qemuBlockStorageSourceChainDetachPrepareBlockdev(virStorageSource *src);
+qemuBlockStorageSourceChainData *
+qemuBlockStorageSourceChainDetachPrepareDrive(virStorageSource *src,
char *driveAlias);
-qemuBlockStorageSourceChainDataPtr
+qemuBlockStorageSourceChainData *
qemuBlockStorageSourceChainDetachPrepareChardev(char *chardevAlias);
int
-qemuBlockStorageSourceChainAttach(qemuMonitorPtr mon,
- qemuBlockStorageSourceChainDataPtr data);
+qemuBlockStorageSourceChainAttach(qemuMonitor *mon,
+ qemuBlockStorageSourceChainData *data);
void
-qemuBlockStorageSourceChainDetach(qemuMonitorPtr mon,
- qemuBlockStorageSourceChainDataPtr data);
+qemuBlockStorageSourceChainDetach(qemuMonitor *mon,
+ qemuBlockStorageSourceChainData *data);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockStorageSourceChainData,
qemuBlockStorageSourceChainDataFree);
int
-qemuBlockSnapshotAddLegacy(virJSONValuePtr actions,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc,
+qemuBlockSnapshotAddLegacy(virJSONValue *actions,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc,
bool reuse);
int
-qemuBlockSnapshotAddBlockdev(virJSONValuePtr actions,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc);
+qemuBlockSnapshotAddBlockdev(virJSONValue *actions,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc);
char *
-qemuBlockGetBackingStoreString(virStorageSourcePtr src,
+qemuBlockGetBackingStoreString(virStorageSource *src,
bool pretty)
ATTRIBUTE_NONNULL(1);
int
-qemuBlockStorageSourceCreateGetFormatProps(virStorageSourcePtr src,
- virStorageSourcePtr backing,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetFormatProps(virStorageSource *src,
+ virStorageSource *backing,
+ virJSONValue **props)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) G_GNUC_WARN_UNUSED_RESULT;
int
-qemuBlockStorageSourceCreateGetStorageProps(virStorageSourcePtr src,
- virJSONValuePtr *props)
+qemuBlockStorageSourceCreateGetStorageProps(virStorageSource *src,
+ virJSONValue **props)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int
-qemuBlockStorageSourceCreate(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
- virStorageSourcePtr chain,
- qemuBlockStorageSourceAttachDataPtr data,
+qemuBlockStorageSourceCreate(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *backingStore,
+ virStorageSource *chain,
+ qemuBlockStorageSourceAttachData *data,
qemuDomainAsyncJob asyncJob);
int
qemuBlockStorageSourceCreateDetectSize(GHashTable *blockNamedNodeData,
- virStorageSourcePtr src,
- virStorageSourcePtr templ);
+ virStorageSource *src,
+ virStorageSource *templ);
int
-qemuBlockRemoveImageMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockRemoveImageMetadata(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *diskTarget,
- virStorageSourcePtr src);
+ virStorageSource *src);
-qemuBlockNamedNodeDataBitmapPtr
+qemuBlockNamedNodeDataBitmap *
qemuBlockNamedNodeDataGetBitmapByName(GHashTable *blockNamedNodeData,
- virStorageSourcePtr src,
+ virStorageSource *src,
const char *bitmap);
GHashTable *
-qemuBlockGetNamedNodeData(virDomainObjPtr vm,
+qemuBlockGetNamedNodeData(virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
int
-qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
- virStorageSourcePtr basesrc,
- virStorageSourcePtr target,
+qemuBlockGetBitmapMergeActions(virStorageSource *topsrc,
+ virStorageSource *basesrc,
+ virStorageSource *target,
const char *bitmapname,
const char *dstbitmapname,
- virStorageSourcePtr writebitmapsrc,
- virJSONValuePtr *actions,
+ virStorageSource *writebitmapsrc,
+ virJSONValue **actions,
GHashTable *blockNamedNodeData);
bool
-qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
+qemuBlockBitmapChainIsValid(virStorageSource *src,
const char *bitmapname,
GHashTable *blockNamedNodeData);
int
-qemuBlockBitmapsHandleBlockcopy(virStorageSourcePtr src,
- virStorageSourcePtr mirror,
+qemuBlockBitmapsHandleBlockcopy(virStorageSource *src,
+ virStorageSource *mirror,
GHashTable *blockNamedNodeData,
bool shallow,
- virJSONValuePtr *actions);
+ virJSONValue **actions);
int
-qemuBlockBitmapsHandleCommitFinish(virStorageSourcePtr topsrc,
- virStorageSourcePtr basesrc,
+qemuBlockBitmapsHandleCommitFinish(virStorageSource *topsrc,
+ virStorageSource *basesrc,
bool active,
GHashTable *blockNamedNodeData,
- virJSONValuePtr *actions);
+ virJSONValue **actions);
int
-qemuBlockReopenReadWrite(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuBlockReopenReadWrite(virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob);
int
-qemuBlockReopenReadOnly(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuBlockReopenReadOnly(virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob);
bool
qemuBlockStorageSourceNeedsStorageSliceLayer(const virStorageSource *src);
char *
-qemuBlockStorageSourceGetCookieString(virStorageSourcePtr src);
+qemuBlockStorageSourceGetCookieString(virStorageSource *src);
int
-qemuBlockUpdateRelativeBacking(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr topsrc);
+qemuBlockUpdateRelativeBacking(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *topsrc);
-virJSONValuePtr
+virJSONValue *
qemuBlockExportGetNBDProps(const char *nodename,
const char *exportname,
bool writable,
int
-qemuBlockExportAddNBD(virDomainObjPtr vm,
+qemuBlockExportAddNBD(virDomainObj *vm,
const char *drivealias,
- virStorageSourcePtr src,
+ virStorageSource *src,
const char *exportname,
bool writable,
const char *bitmap);
"create",
"broken");
-static virClassPtr qemuBlockJobDataClass;
+static virClass *qemuBlockJobDataClass;
static void
-qemuBlockJobDataDisposeJobdata(qemuBlockJobDataPtr job)
+qemuBlockJobDataDisposeJobdata(qemuBlockJobData *job)
{
if (job->type == QEMU_BLOCKJOB_TYPE_CREATE)
virObjectUnref(job->data.create.src);
static void
qemuBlockJobDataDispose(void *obj)
{
- qemuBlockJobDataPtr job = obj;
+ qemuBlockJobData *job = obj;
virObjectUnref(job->chain);
virObjectUnref(job->mirrorChain);
VIR_ONCE_GLOBAL_INIT(qemuBlockJobData);
-qemuBlockJobDataPtr
+qemuBlockJobData *
qemuBlockJobDataNew(qemuBlockJobType type,
const char *name)
{
* it. This function marks the job as broken.
*/
static void
-qemuBlockJobMarkBroken(qemuBlockJobDataPtr job)
+qemuBlockJobMarkBroken(qemuBlockJobData *job)
{
qemuBlockJobDataDisposeJobdata(job);
job->brokentype = job->type;
* then job->mirrorchain needs to be set manually.
*/
int
-qemuBlockJobRegister(qemuBlockJobDataPtr job,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBlockJobRegister(qemuBlockJobData *job,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
bool savestatus)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (disk && QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static void
-qemuBlockJobUnregister(qemuBlockJobDataPtr job,
- virDomainObjPtr vm)
+qemuBlockJobUnregister(qemuBlockJobData *job,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainDiskPrivatePtr diskPriv;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainDiskPrivate *diskPriv;
if (job->disk) {
diskPriv = QEMU_DOMAIN_DISK_PRIVATE(job->disk);
*
* Returns 0 on success and -1 on failure.
*/
-qemuBlockJobDataPtr
-qemuBlockJobDiskNew(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBlockJobData *
+qemuBlockJobDiskNew(virDomainObj *vm,
+ virDomainDiskDef *disk,
qemuBlockJobType type,
const char *jobname)
{
}
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewPull(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr base,
+qemuBlockJobData *
+qemuBlockJobDiskNewPull(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *base,
unsigned int jobflags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(qemuBlockJobData) job = NULL;
g_autofree char *jobname = NULL;
}
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewCommit(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr topparent,
- virStorageSourcePtr top,
- virStorageSourcePtr base,
+qemuBlockJobData *
+qemuBlockJobDiskNewCommit(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *topparent,
+ virStorageSource *top,
+ virStorageSource *base,
bool delete_imgs,
unsigned int jobflags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(qemuBlockJobData) job = NULL;
g_autofree char *jobname = NULL;
qemuBlockJobType jobtype = QEMU_BLOCKJOB_TYPE_COMMIT;
}
-qemuBlockJobDataPtr
-qemuBlockJobNewCreate(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr chain,
+qemuBlockJobData *
+qemuBlockJobNewCreate(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *chain,
bool storage)
{
g_autoptr(qemuBlockJobData) job = NULL;
}
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewCopy(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr mirror,
+qemuBlockJobData *
+qemuBlockJobDiskNewCopy(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *mirror,
bool shallow,
bool reuse,
unsigned int jobflags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(qemuBlockJobData) job = NULL;
g_autofree char *jobname = NULL;
}
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewBackup(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr store,
+qemuBlockJobData *
+qemuBlockJobDiskNewBackup(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *store,
const char *bitmap)
{
g_autoptr(qemuBlockJobData) job = NULL;
*
* Get a reference to the block job data object associated with @disk.
*/
-qemuBlockJobDataPtr
-qemuBlockJobDiskGetJob(virDomainDiskDefPtr disk)
+qemuBlockJobData *
+qemuBlockJobDiskGetJob(virDomainDiskDef *disk)
{
- qemuBlockJobDataPtr job = QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob;
+ qemuBlockJobData *job = QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob;
if (!job)
return NULL;
* Mark @job as started in qemu.
*/
void
-qemuBlockJobStarted(qemuBlockJobDataPtr job,
- virDomainObjPtr vm)
+qemuBlockJobStarted(qemuBlockJobData *job,
+ virDomainObj *vm)
{
if (job->state == QEMU_BLOCKJOB_STATE_NEW)
job->state = QEMU_BLOCKJOB_STATE_RUNNING;
* to @job if it was started.
*/
void
-qemuBlockJobStartupFinalize(virDomainObjPtr vm,
- qemuBlockJobDataPtr job)
+qemuBlockJobStartupFinalize(virDomainObj *vm,
+ qemuBlockJobData *job)
{
if (!job)
return;
bool
-qemuBlockJobIsRunning(qemuBlockJobDataPtr job)
+qemuBlockJobIsRunning(qemuBlockJobData *job)
{
return job->state == QEMU_BLOCKJOB_STATE_RUNNING ||
job->state == QEMU_BLOCKJOB_STATE_READY ||
int
-qemuBlockJobRefreshJobs(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuBlockJobRefreshJobs(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorJobInfoPtr *jobinfo = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitorJobInfo **jobinfo = NULL;
size_t njobinfo = 0;
- qemuBlockJobDataPtr job = NULL;
+ qemuBlockJobData *job = NULL;
int newstate;
size_t i;
int ret = -1;
* for a block job. The former event is emitted only for local disks.
*/
static void
-qemuBlockJobEmitEvents(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBlockJobEmitEvents(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
virDomainBlockJobType type,
virConnectDomainEventBlockJobStatus status)
{
- virObjectEventPtr event = NULL;
- virObjectEventPtr event2 = NULL;
+ virObjectEvent *event = NULL;
+ virObjectEvent *event2 = NULL;
/* don't emit events for jobs without disk */
if (!disk)
* Remove all runtime related data from the storage source.
*/
static void
-qemuBlockJobCleanStorageSourceRuntime(virStorageSourcePtr src)
+qemuBlockJobCleanStorageSourceRuntime(virStorageSource *src)
{
src->id = 0;
src->detected = false;
* @disk and updates its source to @newsrc.
*/
static void
-qemuBlockJobRewriteConfigDiskSource(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc)
+qemuBlockJobRewriteConfigDiskSource(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc)
{
- virDomainDiskDefPtr persistDisk = NULL;
+ virDomainDiskDef *persistDisk = NULL;
g_autoptr(virStorageSource) copy = NULL;
- virStorageSourcePtr n;
+ virStorageSource *n;
if (!vm->newDef)
return;
static void
-qemuBlockJobEventProcessLegacyCompleted(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobEventProcessLegacyCompleted(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob)
{
- virDomainDiskDefPtr disk = job->disk;
+ virDomainDiskDef *disk = job->disk;
if (!disk)
return;
* restart, also update the domain's status XML.
*/
static void
-qemuBlockJobEventProcessLegacy(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobEventProcessLegacy(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob)
{
- virDomainDiskDefPtr disk = job->disk;
+ virDomainDiskDef *disk = job->disk;
VIR_DEBUG("disk=%s, mirrorState=%s, type=%d, state=%d, newstate=%d",
disk->dst,
static void
-qemuBlockJobEventProcessConcludedRemoveChain(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockJobEventProcessConcludedRemoveChain(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virStorageSourcePtr chain)
+ virStorageSource *chain)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
* chains of both @disk and the persistent config definition equivalent must
* be identical.
*/
-static virDomainDiskDefPtr
-qemuBlockJobGetConfigDisk(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr diskChainBottom)
+static virDomainDiskDef *
+qemuBlockJobGetConfigDisk(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *diskChainBottom)
{
- virStorageSourcePtr disksrc = NULL;
- virStorageSourcePtr cfgsrc = NULL;
- virDomainDiskDefPtr ret = NULL;
+ virStorageSource *disksrc = NULL;
+ virStorageSource *cfgsrc = NULL;
+ virDomainDiskDef *ret = NULL;
if (!vm->newDef || !disk)
return NULL;
* data.
*/
static void
-qemuBlockJobClearConfigChain(virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuBlockJobClearConfigChain(virDomainObj *vm,
+ virDomainDiskDef *disk)
{
- virDomainDiskDefPtr cfgdisk = NULL;
+ virDomainDiskDef *cfgdisk = NULL;
if (!vm->newDef || !disk)
return;
static int
-qemuBlockJobProcessEventCompletedPullBitmaps(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedPullBitmaps(virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
* and base image are no longer required and can be unplugged.
*/
static void
-qemuBlockJobProcessEventCompletedPull(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedPull(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
virStorageSource *base = NULL;
- virStorageSourcePtr baseparent = NULL;
- virDomainDiskDefPtr cfgdisk = NULL;
- virStorageSourcePtr cfgbase = NULL;
- virStorageSourcePtr cfgbaseparent = NULL;
- virStorageSourcePtr n;
- virStorageSourcePtr tmp;
+ virStorageSource *baseparent = NULL;
+ virDomainDiskDef *cfgdisk = NULL;
+ virStorageSource *cfgbase = NULL;
+ virStorageSource *cfgbaseparent = NULL;
+ virStorageSource *n;
+ virStorageSource *tmp;
VIR_DEBUG("pull job '%s' on VM '%s' completed", job->name, vm->def->name);
* TODO look into removing backing store for non-local snapshots too
*/
static void
-qemuBlockJobDeleteImages(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr top)
+qemuBlockJobDeleteImages(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *top)
{
- virStorageSourcePtr p = top;
+ virStorageSource *p = top;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
uid_t uid;
gid_t gid;
* Handles the bitmap changes after commit. This returns -1 on monitor failures.
*/
static int
-qemuBlockJobProcessEventCompletedCommitBitmaps(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedCommitBitmaps(virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
bool active = job->type == QEMU_BLOCKJOB_TYPE_ACTIVE_COMMIT;
* removed/deleted.
*/
static void
-qemuBlockJobProcessEventCompletedCommit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedCommit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- virStorageSourcePtr baseparent = NULL;
- virDomainDiskDefPtr cfgdisk = NULL;
- virStorageSourcePtr cfgnext = NULL;
- virStorageSourcePtr cfgtopparent = NULL;
- virStorageSourcePtr cfgtop = NULL;
- virStorageSourcePtr cfgbase = NULL;
- virStorageSourcePtr cfgbaseparent = NULL;
- virStorageSourcePtr n;
+ virStorageSource *baseparent = NULL;
+ virDomainDiskDef *cfgdisk = NULL;
+ virStorageSource *cfgnext = NULL;
+ virStorageSource *cfgtopparent = NULL;
+ virStorageSource *cfgtop = NULL;
+ virStorageSource *cfgbase = NULL;
+ virStorageSource *cfgbaseparent = NULL;
+ virStorageSource *n;
VIR_DEBUG("commit job '%s' on VM '%s' completed", job->name, vm->def->name);
* removed/deleted.
*/
static void
-qemuBlockJobProcessEventCompletedActiveCommit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedActiveCommit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- virStorageSourcePtr baseparent = NULL;
- virDomainDiskDefPtr cfgdisk = NULL;
- virStorageSourcePtr cfgnext = NULL;
- virStorageSourcePtr cfgtop = NULL;
- virStorageSourcePtr cfgbase = NULL;
- virStorageSourcePtr cfgbaseparent = NULL;
- virStorageSourcePtr n;
+ virStorageSource *baseparent = NULL;
+ virDomainDiskDef *cfgdisk = NULL;
+ virStorageSource *cfgnext = NULL;
+ virStorageSource *cfgtop = NULL;
+ virStorageSource *cfgbase = NULL;
+ virStorageSource *cfgbaseparent = NULL;
+ virStorageSource *n;
VIR_DEBUG("active commit job '%s' on VM '%s' completed", job->name, vm->def->name);
static int
-qemuBlockJobProcessEventCompletedCopyBitmaps(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventCompletedCopyBitmaps(virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
bool shallow = job->jobflags & VIR_DOMAIN_BLOCK_COPY_SHALLOW;
}
static void
-qemuBlockJobProcessEventConcludedCopyPivot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventConcludedCopyPivot(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("copy job '%s' on VM '%s' pivoted", job->name, vm->def->name);
/* mirror may be NULL for copy job corresponding to migration */
static void
-qemuBlockJobProcessEventConcludedCopyAbort(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventConcludedCopyAbort(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
VIR_DEBUG("copy job '%s' on VM '%s' aborted", job->name, vm->def->name);
static void
-qemuBlockJobProcessEventFailedActiveCommit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventFailedActiveCommit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDiskDefPtr disk = job->disk;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDiskDef *disk = job->disk;
VIR_DEBUG("active commit job '%s' on VM '%s' failed", job->name, vm->def->name);
static void
-qemuBlockJobProcessEventConcludedCreate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventConcludedCreate(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(qemuBlockStorageSourceAttachData) backend = NULL;
static void
-qemuBlockJobProcessEventConcludedBackup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobProcessEventConcludedBackup(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob,
qemuBlockjobState newstate,
unsigned long long progressCurrent,
static void
-qemuBlockJobEventProcessConcludedTransition(qemuBlockJobDataPtr job,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockJobEventProcessConcludedTransition(qemuBlockJobData *job,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
unsigned long long progressCurrent,
unsigned long long progressTotal)
static void
-qemuBlockJobEventProcessConcluded(qemuBlockJobDataPtr job,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuBlockJobEventProcessConcluded(qemuBlockJobData *job,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuMonitorJobInfoPtr *jobinfo = NULL;
+ qemuMonitorJobInfo **jobinfo = NULL;
size_t njobinfo = 0;
size_t i;
bool refreshed = false;
static void
-qemuBlockJobEventProcess(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobEventProcess(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
qemuDomainAsyncJob asyncJob)
{
* blockJobStatus by qemuProcessHandleBlockJob event handler.
*/
void
-qemuBlockJobUpdate(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobUpdate(virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (job->newstate == -1)
return;
* is called.
*/
void
-qemuBlockJobSyncBegin(qemuBlockJobDataPtr job)
+qemuBlockJobSyncBegin(qemuBlockJobData *job)
{
const char *diskdst = NULL;
* qemuBlockJobStartupFinalize will be called.
*/
void
-qemuBlockJobSyncEnd(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobSyncEnd(virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob)
{
const char *diskdst = NULL;
}
-qemuBlockJobDataPtr
-qemuBlockJobGetByDisk(virDomainDiskDefPtr disk)
+qemuBlockJobData *
+qemuBlockJobGetByDisk(virDomainDiskDef *disk)
{
- qemuBlockJobDataPtr job = QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob;
+ qemuBlockJobData *job = QEMU_DOMAIN_DISK_PRIVATE(disk)->blockjob;
if (!job)
return NULL;
typedef struct _qemuBlockJobPullData qemuBlockJobPullData;
-typedef qemuBlockJobPullData *qemuBlockJobDataPullPtr;
-
struct _qemuBlockJobPullData {
- virStorageSourcePtr base;
+ virStorageSource *base;
};
typedef struct _qemuBlockJobCommitData qemuBlockJobCommitData;
-typedef qemuBlockJobCommitData *qemuBlockJobDataCommitPtr;
-
struct _qemuBlockJobCommitData {
- virStorageSourcePtr topparent;
- virStorageSourcePtr top;
- virStorageSourcePtr base;
+ virStorageSource *topparent;
+ virStorageSource *top;
+ virStorageSource *base;
bool deleteCommittedImages;
};
typedef struct _qemuBlockJobCreateData qemuBlockJobCreateData;
-typedef qemuBlockJobCreateData *qemuBlockJobDataCreatePtr;
-
struct _qemuBlockJobCreateData {
bool storage;
- virStorageSourcePtr src;
+ virStorageSource *src;
};
typedef struct _qemuBlockJobCopyData qemuBlockJobCopyData;
-typedef qemuBlockJobCopyData *qemuBlockJobDataCopyPtr;
-
struct _qemuBlockJobCopyData {
bool shallownew;
};
typedef struct _qemuBlockJobBackupData qemuBlockJobBackupData;
-typedef qemuBlockJobBackupData *qemuBlockJobDataBackupPtr;
-
struct _qemuBlockJobBackupData {
- virStorageSourcePtr store;
+ virStorageSource *store;
char *bitmap;
};
typedef struct _qemuBlockJobData qemuBlockJobData;
-typedef qemuBlockJobData *qemuBlockJobDataPtr;
-
struct _qemuBlockJobData {
virObject parent;
char *name;
- virDomainDiskDefPtr disk; /* may be NULL, if blockjob does not correspond to any disk */
- virStorageSourcePtr chain; /* Reference to the chain the job operates on. */
- virStorageSourcePtr mirrorChain; /* reference to 'mirror' part of the job */
+ virDomainDiskDef *disk; /* may be NULL, if blockjob does not correspond to any disk */
+ virStorageSource *chain; /* Reference to the chain the job operates on. */
+ virStorageSource *mirrorChain; /* reference to 'mirror' part of the job */
unsigned int jobflags; /* per job flags */
bool jobflagsmissing; /* job flags were not stored */
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockJobData, virObjectUnref);
int
-qemuBlockJobRegister(qemuBlockJobDataPtr job,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBlockJobRegister(qemuBlockJobData *job,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
bool savestatus)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-qemuBlockJobDataPtr
+qemuBlockJobData *
qemuBlockJobDataNew(qemuBlockJobType type,
const char *name)
ATTRIBUTE_NONNULL(2);
-qemuBlockJobDataPtr
-qemuBlockJobDiskNew(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuBlockJobData *
+qemuBlockJobDiskNew(virDomainObj *vm,
+ virDomainDiskDef *disk,
qemuBlockJobType type,
const char *jobname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4);
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewPull(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr base,
+qemuBlockJobData *
+qemuBlockJobDiskNewPull(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *base,
unsigned int jobflags);
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewCommit(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr topparent,
- virStorageSourcePtr top,
- virStorageSourcePtr base,
+qemuBlockJobData *
+qemuBlockJobDiskNewCommit(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *topparent,
+ virStorageSource *top,
+ virStorageSource *base,
bool delete_imgs,
unsigned int jobflags);
-qemuBlockJobDataPtr
-qemuBlockJobNewCreate(virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr chain,
+qemuBlockJobData *
+qemuBlockJobNewCreate(virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *chain,
bool storage);
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewCopy(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr mirror,
+qemuBlockJobData *
+qemuBlockJobDiskNewCopy(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *mirror,
bool shallow,
bool reuse,
unsigned int jobflags);
-qemuBlockJobDataPtr
-qemuBlockJobDiskNewBackup(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr store,
+qemuBlockJobData *
+qemuBlockJobDiskNewBackup(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *store,
const char *bitmap);
-qemuBlockJobDataPtr
-qemuBlockJobDiskGetJob(virDomainDiskDefPtr disk)
+qemuBlockJobData *
+qemuBlockJobDiskGetJob(virDomainDiskDef *disk)
ATTRIBUTE_NONNULL(1);
void
-qemuBlockJobStarted(qemuBlockJobDataPtr job,
- virDomainObjPtr vm)
+qemuBlockJobStarted(qemuBlockJobData *job,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
bool
-qemuBlockJobIsRunning(qemuBlockJobDataPtr job)
+qemuBlockJobIsRunning(qemuBlockJobData *job)
ATTRIBUTE_NONNULL(1);
void
-qemuBlockJobStartupFinalize(virDomainObjPtr vm,
- qemuBlockJobDataPtr job);
+qemuBlockJobStartupFinalize(virDomainObj *vm,
+ qemuBlockJobData *job);
int
-qemuBlockJobRefreshJobs(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+qemuBlockJobRefreshJobs(virQEMUDriver *driver,
+ virDomainObj *vm);
void
-qemuBlockJobUpdate(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+qemuBlockJobUpdate(virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob);
-void qemuBlockJobSyncBegin(qemuBlockJobDataPtr job);
-void qemuBlockJobSyncEnd(virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
+void qemuBlockJobSyncBegin(qemuBlockJobData *job);
+void qemuBlockJobSyncEnd(virDomainObj *vm,
+ qemuBlockJobData *job,
int asyncJob);
-qemuBlockJobDataPtr
-qemuBlockJobGetByDisk(virDomainDiskDefPtr disk)
+qemuBlockJobData *
+qemuBlockJobGetByDisk(virDomainDiskDef *disk)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
qemuBlockjobState
typedef struct _virQEMUCapsMachineType virQEMUCapsMachineType;
-typedef virQEMUCapsMachineType *virQEMUCapsMachineTypePtr;
struct _virQEMUCapsMachineType {
char *name;
char *alias;
};
typedef struct _virQEMUCapsHostCPUData virQEMUCapsHostCPUData;
-typedef virQEMUCapsHostCPUData *virQEMUCapsHostCPUDataPtr;
struct _virQEMUCapsHostCPUData {
/* Only the "info" part is stored in the capabilities cache, the rest is
* re-computed from other fields and external data sources every time we
* probe QEMU or load the cache.
*/
- qemuMonitorCPUModelInfoPtr info;
+ qemuMonitorCPUModelInfo *info;
/* Host CPU definition reported in domain capabilities. */
- virCPUDefPtr reported;
+ virCPUDef *reported;
/* Migratable host CPU definition used for updating guest CPU. */
- virCPUDefPtr migratable;
+ virCPUDef *migratable;
/* CPU definition with features detected by libvirt using virCPUGetHost
* combined with features reported by QEMU. This is used for backward
* compatible comparison between a guest CPU and a host CPU. */
- virCPUDefPtr full;
+ virCPUDef *full;
};
typedef struct _virQEMUCapsAccel virQEMUCapsAccel;
-typedef virQEMUCapsAccel *virQEMUCapsAccelPtr;
struct _virQEMUCapsAccel {
size_t nmachineTypes;
- virQEMUCapsMachineTypePtr machineTypes;
+ virQEMUCapsMachineType *machineTypes;
virQEMUCapsHostCPUData hostCPU;
- qemuMonitorCPUDefsPtr cpuModels;
+ qemuMonitorCPUDefs *cpuModels;
};
time_t modDirMtime;
bool invalidation;
- virBitmapPtr flags;
+ virBitmap *flags;
unsigned int version;
unsigned int kvmVersion;
};
-static virClassPtr virQEMUCapsClass;
+static virClass *virQEMUCapsClass;
static void virQEMUCapsDispose(void *obj);
static int virQEMUCapsOnceInit(void)
}
-static virQEMUCapsAccelPtr
-virQEMUCapsGetAccel(virQEMUCapsPtr qemuCaps,
+static virQEMUCapsAccel *
+virQEMUCapsGetAccel(virQEMUCaps *qemuCaps,
virDomainVirtType type)
{
if (type == VIR_DOMAIN_VIRT_KVM)
static void
-virQEMUCapsSetDefaultMachine(virQEMUCapsAccelPtr caps,
+virQEMUCapsSetDefaultMachine(virQEMUCapsAccel *caps,
size_t defIdx)
{
virQEMUCapsMachineType tmp = caps->machineTypes[defIdx];
static int
-virQEMUCapsInitGuest(virCapsPtr caps,
- virFileCachePtr cache,
+virQEMUCapsInitGuest(virCaps *caps,
+ virFileCache *cache,
virArch hostarch,
virArch guestarch)
{
char *binary = NULL;
- virQEMUCapsPtr qemuCaps = NULL;
+ virQEMUCaps *qemuCaps = NULL;
int ret = -1;
binary = virQEMUCapsGetDefaultEmulator(hostarch, guestarch);
static int
-virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineTypesCaps(virQEMUCaps *qemuCaps,
size_t *nmachines,
- virCapsGuestMachinePtr **machines)
+ virCapsGuestMachine ***machines)
{
size_t i;
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
/* Guest capabilities do not report TCG vs. KVM caps separately. We just
* take the set of machine types we probed first. */
*nmachines = accel->nmachineTypes;
if (*nmachines)
- *machines = g_new0(virCapsGuestMachinePtr, accel->nmachineTypes);
+ *machines = g_new0(virCapsGuestMachine *, accel->nmachineTypes);
for (i = 0; i < accel->nmachineTypes; i++) {
- virCapsGuestMachinePtr mach;
+ virCapsGuestMachine *mach;
mach = g_new0(virCapsGuestMachine, 1);
(*machines)[i] = mach;
if (accel->machineTypes[i].alias) {
while (i < *nmachines) {
size_t j;
bool found = false;
- virCapsGuestMachinePtr machine = (*machines)[i];
+ virCapsGuestMachine *machine = (*machines)[i];
if (!machine->canonical) {
i++;
}
if (!found) {
- virCapsGuestMachinePtr mach;
+ virCapsGuestMachine *mach;
mach = g_new0(virCapsGuestMachine, 1);
if (VIR_INSERT_ELEMENT_COPY(*machines, i, *nmachines, mach) < 0) {
VIR_FREE(mach);
int
-virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
+virQEMUCapsInitGuestFromBinary(virCaps *caps,
const char *binary,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
virArch guestarch)
{
- virCapsGuestPtr guest;
- virCapsGuestMachinePtr *machines = NULL;
+ virCapsGuest *guest;
+ virCapsGuestMachine **machines = NULL;
size_t nmachines = 0;
int ret = -1;
}
-virCPUDefPtr
+virCPUDef *
virQEMUCapsProbeHostCPU(virArch hostArch,
- virDomainCapsCPUModelsPtr models)
+ virDomainCapsCPUModels *models)
{
return virCPUGetHost(hostArch, VIR_CPU_TYPE_GUEST, NULL, models);
}
-virCapsPtr
-virQEMUCapsInit(virFileCachePtr cache)
+virCaps *
+virQEMUCapsInit(virFileCache *cache)
{
- virCapsPtr caps;
+ virCaps *caps;
size_t i;
virArch hostarch = virArchFromHost();
struct virQEMUCapsDevicePropsFlags {
const char *value;
int flag;
- int (*cb)(virJSONValuePtr props, virQEMUCapsPtr caps);
+ int (*cb)(virJSONValue *props, virQEMUCaps *caps);
};
static int
-virQEMUCapsDevicePropsVirtioBlkSCSIDefault(virJSONValuePtr props,
- virQEMUCapsPtr qemuCaps)
+virQEMUCapsDevicePropsVirtioBlkSCSIDefault(virJSONValue *props,
+ virQEMUCaps *qemuCaps)
{
bool def = false;
};
static void
-virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps,
+virQEMUCapsProcessStringFlags(virQEMUCaps *qemuCaps,
size_t nflags,
struct virQEMUCapsStringFlags *flags,
size_t nvalues,
}
-int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
- virFileCachePtr capsCache,
+int virQEMUCapsGetDefaultVersion(virCaps *caps,
+ virFileCache *capsCache,
unsigned int *version)
{
- virQEMUCapsPtr qemucaps;
+ virQEMUCaps *qemucaps;
virArch hostarch;
- virCapsDomainDataPtr capsdata;
+ virCapsDomainData *capsdata;
if (*version > 0)
return 0;
}
-virQEMUCapsPtr
+virQEMUCaps *
virQEMUCapsNew(void)
{
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
if (virQEMUCapsInitialize() < 0)
return NULL;
}
-virQEMUCapsPtr
+virQEMUCaps *
virQEMUCapsNewBinary(const char *binary)
{
- virQEMUCapsPtr qemuCaps = virQEMUCapsNew();
+ virQEMUCaps *qemuCaps = virQEMUCapsNew();
if (qemuCaps)
qemuCaps->binary = g_strdup(binary);
static int
-virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUDataPtr dst,
- virQEMUCapsHostCPUDataPtr src)
+virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUData *dst,
+ virQEMUCapsHostCPUData *src)
{
if (src->info &&
!(dst->info = qemuMonitorCPUModelInfoCopy(src->info)))
static void
-virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUDataPtr cpuData)
+virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUData *cpuData)
{
qemuMonitorCPUModelInfoFree(cpuData->info);
virCPUDefFree(cpuData->reported);
static int
-virQEMUCapsSEVInfoCopy(virSEVCapabilityPtr *dst,
- virSEVCapabilityPtr src)
+virQEMUCapsSEVInfoCopy(virSEVCapability **dst,
+ virSEVCapability *src)
{
g_autoptr(virSEVCapability) tmp = NULL;
static void
-virQEMUCapsAccelCopyMachineTypes(virQEMUCapsAccelPtr dst,
- virQEMUCapsAccelPtr src)
+virQEMUCapsAccelCopyMachineTypes(virQEMUCapsAccel *dst,
+ virQEMUCapsAccel *src)
{
size_t i;
static int
-virQEMUCapsAccelCopy(virQEMUCapsAccelPtr dst,
- virQEMUCapsAccelPtr src)
+virQEMUCapsAccelCopy(virQEMUCapsAccel *dst,
+ virQEMUCapsAccel *src)
{
virQEMUCapsAccelCopyMachineTypes(dst, src);
}
-virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
+virQEMUCaps *virQEMUCapsNewCopy(virQEMUCaps *qemuCaps)
{
- virQEMUCapsPtr ret = virQEMUCapsNewBinary(qemuCaps->binary);
+ virQEMUCaps *ret = virQEMUCapsNewBinary(qemuCaps->binary);
size_t i;
if (!ret)
static void
-virQEMUCapsAccelClear(virQEMUCapsAccelPtr caps)
+virQEMUCapsAccelClear(virQEMUCapsAccel *caps)
{
size_t i;
void virQEMUCapsDispose(void *obj)
{
- virQEMUCapsPtr qemuCaps = obj;
+ virQEMUCaps *qemuCaps = obj;
virBitmapFree(qemuCaps->flags);
}
void
-virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSet(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag)
{
ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
void
-virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...)
+virQEMUCapsSetList(virQEMUCaps *qemuCaps, ...)
{
va_list list;
int flag;
void
-virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
+virQEMUCapsClear(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag)
{
ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
bool
-virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGet(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag)
{
return qemuCaps && virBitmapIsBitSet(qemuCaps->flags, flag);
}
-bool virQEMUCapsHasPCIMultiBus(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsHasPCIMultiBus(virQEMUCaps *qemuCaps,
const virDomainDef *def)
{
/* x86_64 and i686 support PCI-multibus on all machine types
}
-const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps)
+const char *virQEMUCapsGetBinary(virQEMUCaps *qemuCaps)
{
return qemuCaps->binary;
}
void
-virQEMUCapsSetArch(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetArch(virQEMUCaps *qemuCaps,
virArch arch)
{
qemuCaps->arch = arch;
}
-virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps)
+virArch virQEMUCapsGetArch(virQEMUCaps *qemuCaps)
{
return qemuCaps->arch;
}
-unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps)
+unsigned int virQEMUCapsGetVersion(virQEMUCaps *qemuCaps)
{
return qemuCaps->version;
}
-unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps)
+unsigned int virQEMUCapsGetKVMVersion(virQEMUCaps *qemuCaps)
{
return qemuCaps->kvmVersion;
}
-const char *virQEMUCapsGetPackage(virQEMUCapsPtr qemuCaps)
+const char *virQEMUCapsGetPackage(virQEMUCaps *qemuCaps)
{
return qemuCaps->package;
}
int
-virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
+virQEMUCapsAddCPUDefinitions(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char **name,
size_t count,
{
size_t i;
size_t start;
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, type);
- qemuMonitorCPUDefsPtr defs = accel->cpuModels;
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
+ qemuMonitorCPUDefs *defs = accel->cpuModels;
if (defs) {
start = defs->ncpus;
}
for (i = 0; i < count; i++) {
- qemuMonitorCPUDefInfoPtr cpu = defs->cpus + start + i;
+ qemuMonitorCPUDefInfo *cpu = defs->cpus + start + i;
cpu->usable = usable;
cpu->name = g_strdup(name[i]);
}
-static virDomainCapsCPUModelsPtr
-virQEMUCapsCPUDefsToModels(qemuMonitorCPUDefsPtr defs,
+static virDomainCapsCPUModels *
+virQEMUCapsCPUDefsToModels(qemuMonitorCPUDefs *defs,
const char **modelAllowed,
const char **modelForbidden)
{
return NULL;
for (i = 0; i < defs->ncpus; i++) {
- qemuMonitorCPUDefInfoPtr cpu = defs->cpus + i;
+ qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
if (modelAllowed && !g_strv_contains(modelAllowed, cpu->name))
continue;
}
-virDomainCapsCPUModelsPtr
-virQEMUCapsGetCPUModels(virQEMUCapsPtr qemuCaps,
+virDomainCapsCPUModels *
+virQEMUCapsGetCPUModels(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char **modelAllowed,
const char **modelForbidden)
{
- qemuMonitorCPUDefsPtr defs;
+ qemuMonitorCPUDefs *defs;
if (!(defs = virQEMUCapsGetAccel(qemuCaps, type)->cpuModels))
return NULL;
}
-virCPUDefPtr
-virQEMUCapsGetHostModel(virQEMUCapsPtr qemuCaps,
+virCPUDef *
+virQEMUCapsGetHostModel(virQEMUCaps *qemuCaps,
virDomainVirtType type,
virQEMUCapsHostCPUType cpuType)
{
- virQEMUCapsHostCPUDataPtr cpuData;
+ virQEMUCapsHostCPUData *cpuData;
cpuData = &virQEMUCapsGetAccel(qemuCaps, type)->hostCPU;
switch (cpuType) {
static void
-virQEMUCapsSetHostModel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetHostModel(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- virCPUDefPtr reported,
- virCPUDefPtr migratable,
- virCPUDefPtr full)
+ virCPUDef *reported,
+ virCPUDef *migratable,
+ virCPUDef *full)
{
- virQEMUCapsHostCPUDataPtr cpuData;
+ virQEMUCapsHostCPUData *cpuData;
cpuData = &virQEMUCapsGetAccel(qemuCaps, type)->hostCPU;
cpuData->reported = reported;
bool
-virQEMUCapsIsArchSupported(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsArchSupported(virQEMUCaps *qemuCaps,
virArch arch)
{
if (arch == qemuCaps->arch)
bool
-virQEMUCapsIsVirtTypeSupported(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsVirtTypeSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType)
{
if (virtType == VIR_DOMAIN_VIRT_QEMU &&
};
bool
-virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsCPUModeSupported(virQEMUCaps *qemuCaps,
virArch hostarch,
virDomainVirtType type,
virCPUMode mode,
const char *machineType)
{
- qemuMonitorCPUDefsPtr cpus;
+ qemuMonitorCPUDefs *cpus;
/* CPU models (except for "host") are not supported by QEMU for on s390
* KVM domains with old machine types regardless on QEMU version. */
* present @name is returned.
*/
const char *
-virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetCanonicalMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name)
{
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
size_t i;
if (!name || !qemuCaps)
int
-virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineMaxCpus(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name)
{
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
size_t i;
if (!name)
bool
-virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineHotplugCpus(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name)
{
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
size_t i;
accel = virQEMUCapsGetAccel(qemuCaps, virtType);
const char *
-virQEMUCapsGetMachineDefaultCPU(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineDefaultCPU(virQEMUCaps *qemuCaps,
const char *name,
virDomainVirtType type)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, type);
- qemuMonitorCPUDefsPtr defs = accel->cpuModels;
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
+ qemuMonitorCPUDefs *defs = accel->cpuModels;
const char *cpuType = NULL;
size_t i;
bool
-virQEMUCapsIsCPUDeprecated(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsCPUDeprecated(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char *model)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, type);
- qemuMonitorCPUDefsPtr defs = accel->cpuModels;
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
+ qemuMonitorCPUDefs *defs = accel->cpuModels;
size_t i;
for (i = 0; i < defs->ncpus; i++) {
bool
-virQEMUCapsIsMachineDeprecated(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsMachineDeprecated(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char *machine)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, type);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
size_t i;
for (i = 0; i < accel->nmachineTypes; i++) {
bool
-virQEMUCapsGetMachineNumaMemSupported(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineNumaMemSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name)
{
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
size_t i;
accel = virQEMUCapsGetAccel(qemuCaps, virtType);
const char *
-virQEMUCapsGetMachineDefaultRAMid(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetMachineDefaultRAMid(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name)
{
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
size_t i;
accel = virQEMUCapsGetAccel(qemuCaps, virtType);
* after it's been called is a bug.
*/
void
-virQEMUCapsSetGICCapabilities(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetGICCapabilities(virQEMUCaps *qemuCaps,
virGICCapability *capabilities,
size_t ncapabilities)
{
}
-virSEVCapabilityPtr
-virQEMUCapsGetSEVCapabilities(virQEMUCapsPtr qemuCaps)
+virSEVCapability *
+virQEMUCapsGetSEVCapabilities(virQEMUCaps *qemuCaps)
{
return qemuCaps->sevCapabilities;
}
static int
-virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPCommands(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
char **commands = NULL;
int ncommands;
static int
-virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPEvents(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
char **events = NULL;
int nevents;
static int
-virQEMUCapsProbeQMPObjectTypes(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPObjectTypes(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
int nvalues;
char **values;
static int
-virQEMUCapsProbeQMPDeviceProperties(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPDeviceProperties(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
size_t i;
return -1;
for (j = 0; j < device->nprops; j++) {
- virJSONValuePtr entry = virHashLookup(qemuprops, device->props[j].value);
+ virJSONValue *entry = virHashLookup(qemuprops, device->props[j].value);
if (!entry)
continue;
static int
-virQEMUCapsProbeQMPObjectProperties(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPObjectProperties(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
size_t i;
void
-virQEMUCapsAddMachine(virQEMUCapsPtr qemuCaps,
+virQEMUCapsAddMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name,
const char *alias,
const char *defaultRAMid,
bool deprecated)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, virtType);
- virQEMUCapsMachineTypePtr mach;
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
+ virQEMUCapsMachineType *mach;
accel->machineTypes = g_renew(virQEMUCapsMachineType,
accel->machineTypes,
* into the list.
*/
bool
-virQEMUCapsHasMachines(virQEMUCapsPtr qemuCaps)
+virQEMUCapsHasMachines(virQEMUCaps *qemuCaps)
{
return !!qemuCaps->kvm.nmachineTypes || !!qemuCaps->tcg.nmachineTypes;
static int
-virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps,
+virQEMUCapsProbeQMPMachineTypes(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
- qemuMonitorPtr mon)
+ qemuMonitor *mon)
{
- qemuMonitorMachineInfoPtr *machines = NULL;
+ qemuMonitorMachineInfo **machines = NULL;
int nmachines = 0;
size_t i;
ssize_t defIdx = -1;
ssize_t preferredIdx = -1;
const char *preferredMachine = preferredMachines[qemuCaps->arch];
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, virtType);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
return -1;
bool
-virQEMUCapsIsMachineSupported(virQEMUCapsPtr qemuCaps,
+virQEMUCapsIsMachineSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *canonical_machine)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, virtType);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
size_t i;
for (i = 0; i < accel->nmachineTypes; i++) {
static int
-virQEMUCapsProbeQMPMachineProps(virQEMUCapsPtr qemuCaps,
+virQEMUCapsProbeQMPMachineProps(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
- qemuMonitorPtr mon)
+ qemuMonitor *mon)
{
char **values;
int nvalues;
static int
-virQEMUCapsFetchCPUDefinitions(qemuMonitorPtr mon,
+virQEMUCapsFetchCPUDefinitions(qemuMonitor *mon,
virArch arch,
- qemuMonitorCPUDefsPtr *cpuDefs)
+ qemuMonitorCPUDefs **cpuDefs)
{
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
size_t i;
int
-virQEMUCapsFetchCPUModels(qemuMonitorPtr mon,
+virQEMUCapsFetchCPUModels(qemuMonitor *mon,
virArch arch,
- virDomainCapsCPUModelsPtr *cpuModels)
+ virDomainCapsCPUModels **cpuModels)
{
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
static int
-virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
- virQEMUCapsAccelPtr accel,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPCPUDefinitions(virQEMUCaps *qemuCaps,
+ virQEMUCapsAccel *accel,
+ qemuMonitor *mon)
{
- qemuMonitorCPUDefsPtr defs;
+ qemuMonitorCPUDefs *defs;
size_t i;
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_DEFINITIONS))
int
-virQEMUCapsProbeCPUDefinitionsTest(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeCPUDefinitionsTest(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
return virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, &qemuCaps->kvm, mon);
}
static int
-virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
- virQEMUCapsAccelPtr accel,
- qemuMonitorPtr mon,
+virQEMUCapsProbeQMPHostCPU(virQEMUCaps *qemuCaps,
+ virQEMUCapsAccel *accel,
+ qemuMonitor *mon,
virDomainVirtType virtType)
{
const char *model = virtType == VIR_DOMAIN_VIRT_KVM ? "host" : "max";
- qemuMonitorCPUModelInfoPtr modelInfo = NULL;
- qemuMonitorCPUModelInfoPtr nonMigratable = NULL;
+ qemuMonitorCPUModelInfo *modelInfo = NULL;
+ qemuMonitorCPUModelInfo *nonMigratable = NULL;
GHashTable *hash = NULL;
- virCPUDefPtr cpu;
+ virCPUDef *cpu;
qemuMonitorCPUModelExpansionType type;
bool fail_no_props = true;
int ret = -1;
goto cleanup;
if (nonMigratable) {
- qemuMonitorCPUPropertyPtr prop;
- qemuMonitorCPUPropertyPtr nmProp;
+ qemuMonitorCPUProperty *prop;
+ qemuMonitorCPUProperty *nmProp;
size_t i;
if (!(hash = virHashNew(NULL)))
* 1 when @features is filled in, but migratability info is not available.
*/
int
-virQEMUCapsGetCPUFeatures(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetCPUFeatures(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
bool migratable,
char ***features)
{
- qemuMonitorCPUModelInfoPtr modelInfo;
+ qemuMonitorCPUModelInfo *modelInfo;
char **list;
size_t i;
size_t n;
n = 0;
for (i = 0; i < modelInfo->nprops; i++) {
- qemuMonitorCPUPropertyPtr prop = modelInfo->props + i;
+ qemuMonitorCPUProperty *prop = modelInfo->props + i;
if (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO)
continue;
};
static int
-virQEMUCapsProbeQMPTPM(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPTPM(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
int nentries;
size_t i;
static int
-virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPKVMState(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
bool enabled = false;
bool present = false;
};
static int
-virQEMUCapsProbeQMPCommandLine(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPCommandLine(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
g_autoptr(GHashTable) options = NULL;
size_t i;
return -1;
for (i = 0; i < G_N_ELEMENTS(virQEMUCapsCommandLine); i++) {
- virJSONValuePtr option = g_hash_table_lookup(options, virQEMUCapsCommandLine[i].option);
+ virJSONValue *option = g_hash_table_lookup(options, virQEMUCapsCommandLine[i].option);
size_t j;
if (!option)
}
for (j = 0; j < virJSONValueArraySize(option); j++) {
- virJSONValuePtr param = virJSONValueArrayGet(option, j);
+ virJSONValue *param = virJSONValueArrayGet(option, j);
const char *paramname = virJSONValueObjectGetString(param, "name");
if (STREQ_NULLABLE(virQEMUCapsCommandLine[i].param, paramname))
}
static int
-virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
char **caps = NULL;
int ncaps;
* Returns: 0 on success, <0 on failure
*/
static int
-virQEMUCapsProbeQMPGICCapabilities(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPGICCapabilities(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
virGICCapability *caps = NULL;
int ncaps;
static int
-virQEMUCapsProbeQMPSEVCapabilities(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPSEVCapabilities(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
int rc = -1;
virSEVCapability *caps = NULL;
typedef struct _virQEMUCapsCPUFeatureTranslationTable virQEMUCapsCPUFeatureTranslationTable;
-typedef virQEMUCapsCPUFeatureTranslationTable *virQEMUCapsCPUFeatureTranslationTablePtr;
struct _virQEMUCapsCPUFeatureTranslationTable {
const char *libvirt;
const char *qemu;
static const char *
-virQEMUCapsCPUFeatureTranslate(virQEMUCapsPtr qemuCaps,
+virQEMUCapsCPUFeatureTranslate(virQEMUCaps *qemuCaps,
const char *feature,
bool reversed)
{
- virQEMUCapsCPUFeatureTranslationTablePtr table = NULL;
- virQEMUCapsCPUFeatureTranslationTablePtr entry;
+ virQEMUCapsCPUFeatureTranslationTable *table = NULL;
+ virQEMUCapsCPUFeatureTranslationTable *entry;
if (ARCH_IS_X86(qemuCaps->arch))
table = virQEMUCapsCPUFeaturesX86;
const char *
-virQEMUCapsCPUFeatureToQEMU(virQEMUCapsPtr qemuCaps,
+virQEMUCapsCPUFeatureToQEMU(virQEMUCaps *qemuCaps,
const char *feature)
{
return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, false);
const char *
-virQEMUCapsCPUFeatureFromQEMU(virQEMUCapsPtr qemuCaps,
+virQEMUCapsCPUFeatureFromQEMU(virQEMUCaps *qemuCaps,
const char *feature)
{
return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, true);
/**
* Returns 0 when host CPU model provided by QEMU was filled in qemuCaps,
- * 1 when the caller should fall back to using virCapsPtr->host.cpu,
+ * 1 when the caller should fall back to using virCaps *->host.cpu,
* 2 when cpu model info is not supported for this configuration,
* -1 on error.
*/
static int
-virQEMUCapsInitCPUModelS390(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitCPUModelS390(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- qemuMonitorCPUModelInfoPtr modelInfo,
- virCPUDefPtr cpu,
+ qemuMonitorCPUModelInfo *modelInfo,
+ virCPUDef *cpu,
bool migratable)
{
size_t i;
cpu->nfeatures = 0;
for (i = 0; i < modelInfo->nprops; i++) {
- virCPUFeatureDefPtr feature = cpu->features + cpu->nfeatures;
- qemuMonitorCPUPropertyPtr prop = modelInfo->props + i;
+ virCPUFeatureDef *feature = cpu->features + cpu->nfeatures;
+ qemuMonitorCPUProperty *prop = modelInfo->props + i;
const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
if (prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN)
}
-virCPUDataPtr
-virQEMUCapsGetCPUModelX86Data(virQEMUCapsPtr qemuCaps,
- qemuMonitorCPUModelInfoPtr model,
+virCPUData *
+virQEMUCapsGetCPUModelX86Data(virQEMUCaps *qemuCaps,
+ qemuMonitorCPUModelInfo *model,
bool migratable)
{
unsigned long long sigFamily = 0;
unsigned long long sigModel = 0;
unsigned long long sigStepping = 0;
- virCPUDataPtr data = NULL;
- virCPUDataPtr ret = NULL;
+ virCPUData *data = NULL;
+ virCPUData *ret = NULL;
size_t i;
if (!(data = virCPUDataNew(VIR_ARCH_X86_64)))
goto cleanup;
for (i = 0; i < model->nprops; i++) {
- qemuMonitorCPUPropertyPtr prop = model->props + i;
+ qemuMonitorCPUProperty *prop = model->props + i;
const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
switch (prop->type) {
/**
* Returns 0 when host CPU model provided by QEMU was filled in qemuCaps,
- * 1 when the caller should fall back to using virCapsPtr->host.cpu,
+ * 1 when the caller should fall back to using virCaps *->host.cpu,
* -1 on error.
*/
static int
-virQEMUCapsInitCPUModelX86(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitCPUModelX86(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- qemuMonitorCPUModelInfoPtr model,
- virCPUDefPtr cpu,
+ qemuMonitorCPUModelInfo *model,
+ virCPUDef *cpu,
bool migratable)
{
g_autoptr(virDomainCapsCPUModels) cpuModels = NULL;
- virCPUDataPtr data = NULL;
+ virCPUData *data = NULL;
int ret = -1;
if (!model)
* -1 on error.
*/
int
-virQEMUCapsInitCPUModel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitCPUModel(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable)
{
- qemuMonitorCPUModelInfoPtr modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, type);
+ qemuMonitorCPUModelInfo *modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, type);
int ret = 1;
if (migratable && modelInfo && !modelInfo->migratability)
}
-static virCPUDefPtr
+static virCPUDef *
virQEMUCapsNewHostCPUModel(void)
{
- virCPUDefPtr cpu = virCPUDefNew();
+ virCPUDef *cpu = virCPUDefNew();
cpu->type = VIR_CPU_TYPE_GUEST;
cpu->mode = VIR_CPU_MODE_CUSTOM;
void
-virQEMUCapsInitHostCPUModel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitHostCPUModel(virQEMUCaps *qemuCaps,
virArch hostArch,
virDomainVirtType type)
{
- virCPUDefPtr cpu = NULL;
- virCPUDefPtr cpuExpanded = NULL;
- virCPUDefPtr migCPU = NULL;
- virCPUDefPtr hostCPU = NULL;
- virCPUDefPtr fullCPU = NULL;
+ virCPUDef *cpu = NULL;
+ virCPUDef *cpuExpanded = NULL;
+ virCPUDef *migCPU = NULL;
+ virCPUDef *hostCPU = NULL;
+ virCPUDef *fullCPU = NULL;
size_t i;
int rc;
}
-qemuMonitorCPUModelInfoPtr
-virQEMUCapsGetCPUModelInfo(virQEMUCapsPtr qemuCaps,
+qemuMonitorCPUModelInfo *
+virQEMUCapsGetCPUModelInfo(virQEMUCaps *qemuCaps,
virDomainVirtType type)
{
return virQEMUCapsGetAccel(qemuCaps, type)->hostCPU.info;
void
-virQEMUCapsSetCPUModelInfo(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetCPUModelInfo(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- qemuMonitorCPUModelInfoPtr modelInfo)
+ qemuMonitorCPUModelInfo *modelInfo)
{
virQEMUCapsGetAccel(qemuCaps, type)->hostCPU.info = modelInfo;
}
static int
-virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccelPtr caps,
+virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccel *caps,
xmlXPathContextPtr ctxt,
const char *typeStr)
{
xmlNodePtr hostCPUNode;
xmlNodePtr *nodes = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- qemuMonitorCPUModelInfoPtr hostCPU = NULL;
+ qemuMonitorCPUModelInfo *hostCPU = NULL;
g_autofree char *xpath = g_strdup_printf("./hostCPU[@type='%s']", typeStr);
int ret = -1;
size_t i;
hostCPU->nprops = n;
for (i = 0; i < n; i++) {
- qemuMonitorCPUPropertyPtr prop = hostCPU->props + i;
+ qemuMonitorCPUProperty *prop = hostCPU->props + i;
ctxt->node = nodes[i];
static int
-virQEMUCapsLoadCPUModels(virQEMUCapsAccelPtr caps,
+virQEMUCapsLoadCPUModels(virQEMUCapsAccel *caps,
xmlXPathContextPtr ctxt,
const char *typeStr)
{
return -1;
for (i = 0; i < n; i++) {
- qemuMonitorCPUDefInfoPtr cpu = defs->cpus + i;
+ qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
int usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;
g_autofree char * strUsable = NULL;
g_autofree xmlNodePtr * blockerNodes = NULL;
static int
-virQEMUCapsLoadMachines(virQEMUCapsAccelPtr caps,
+virQEMUCapsLoadMachines(virQEMUCapsAccel *caps,
xmlXPathContextPtr ctxt,
const char *typeStr)
{
static int
-virQEMUCapsLoadAccel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsLoadAccel(virQEMUCaps *qemuCaps,
xmlXPathContextPtr ctxt,
virDomainVirtType type)
{
- virQEMUCapsAccelPtr caps = virQEMUCapsGetAccel(qemuCaps, type);
+ virQEMUCapsAccel *caps = virQEMUCapsGetAccel(qemuCaps, type);
const char *typeStr = type == VIR_DOMAIN_VIRT_KVM ? "kvm" : "tcg";
if (virQEMUCapsLoadHostCPUModelInfo(caps, ctxt, typeStr) < 0)
time_t kvmCtime;
};
typedef struct _virQEMUCapsCachePriv virQEMUCapsCachePriv;
-typedef virQEMUCapsCachePriv *virQEMUCapsCachePrivPtr;
static void
virQEMUCapsCachePrivFree(void *privData)
{
- virQEMUCapsCachePrivPtr priv = privData;
+ virQEMUCapsCachePriv *priv = privData;
g_free(priv->libDir);
g_free(priv->kernelVersion);
static int
-virQEMUCapsParseSEVInfo(virQEMUCapsPtr qemuCaps, xmlXPathContextPtr ctxt)
+virQEMUCapsParseSEVInfo(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
{
g_autoptr(virSEVCapability) sev = NULL;
*/
int
virQEMUCapsLoadCache(virArch hostArch,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
const char *filename,
bool skipInvalidation)
{
qemuCaps->gicCapabilities = g_new0(virGICCapability, n);
for (i = 0; i < n; i++) {
- virGICCapabilityPtr cap = &qemuCaps->gicCapabilities[i];
+ virGICCapability *cap = &qemuCaps->gicCapabilities[i];
if (!(str = virXMLPropString(nodes[i], "version"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static void
-virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsAccelPtr caps,
- virBufferPtr buf,
+virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsAccel *caps,
+ virBuffer *buf,
const char *typeStr)
{
- qemuMonitorCPUModelInfoPtr model = caps->hostCPU.info;
+ qemuMonitorCPUModelInfo *model = caps->hostCPU.info;
size_t i;
if (!model)
virBufferAdjustIndent(buf, 2);
for (i = 0; i < model->nprops; i++) {
- qemuMonitorCPUPropertyPtr prop = model->props + i;
+ qemuMonitorCPUProperty *prop = model->props + i;
virBufferAsprintf(buf, "<property name='%s' type='%s' ",
prop->name,
static void
-virQEMUCapsFormatCPUModels(virQEMUCapsAccelPtr caps,
- virBufferPtr buf,
+virQEMUCapsFormatCPUModels(virQEMUCapsAccel *caps,
+ virBuffer *buf,
const char *typeStr)
{
- qemuMonitorCPUDefsPtr defs = caps->cpuModels;
+ qemuMonitorCPUDefs *defs = caps->cpuModels;
size_t i;
if (!defs)
return;
for (i = 0; i < defs->ncpus; i++) {
- qemuMonitorCPUDefInfoPtr cpu = defs->cpus + i;
+ qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
virBufferAsprintf(buf, "<cpu type='%s' ", typeStr);
virBufferEscapeString(buf, "name='%s'", cpu->name);
static void
-virQEMUCapsFormatMachines(virQEMUCapsAccelPtr caps,
- virBufferPtr buf,
+virQEMUCapsFormatMachines(virQEMUCapsAccel *caps,
+ virBuffer *buf,
const char *typeStr)
{
size_t i;
static void
-virQEMUCapsFormatAccel(virQEMUCapsPtr qemuCaps,
- virBufferPtr buf,
+virQEMUCapsFormatAccel(virQEMUCaps *qemuCaps,
+ virBuffer *buf,
virDomainVirtType type)
{
- virQEMUCapsAccelPtr caps = virQEMUCapsGetAccel(qemuCaps, type);
+ virQEMUCapsAccel *caps = virQEMUCapsGetAccel(qemuCaps, type);
const char *typeStr = type == VIR_DOMAIN_VIRT_KVM ? "kvm" : "tcg";
virQEMUCapsFormatHostCPUModelInfo(caps, buf, typeStr);
static void
-virQEMUCapsFormatSEVInfo(virQEMUCapsPtr qemuCaps, virBufferPtr buf)
+virQEMUCapsFormatSEVInfo(virQEMUCaps *qemuCaps, virBuffer *buf)
{
- virSEVCapabilityPtr sev = virQEMUCapsGetSEVCapabilities(qemuCaps);
+ virSEVCapability *sev = virQEMUCapsGetSEVCapabilities(qemuCaps);
virBufferAddLit(buf, "<sev>\n");
virBufferAdjustIndent(buf, 2);
char *
-virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps)
+virQEMUCapsFormatCache(virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
virQEMUCapsFormatAccel(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
- virGICCapabilityPtr cap;
+ virGICCapability *cap;
bool kernel;
bool emulated;
const char *filename,
void *privData G_GNUC_UNUSED)
{
- virQEMUCapsPtr qemuCaps = data;
+ virQEMUCaps *qemuCaps = data;
char *xml = NULL;
int ret = -1;
/* Determine whether '/dev/kvm' is usable as QEMU user:QEMU group. */
static bool
-virQEMUCapsKVMUsable(virQEMUCapsCachePrivPtr priv)
+virQEMUCapsKVMUsable(virQEMUCapsCachePriv *priv)
{
struct stat sb;
static const char *kvm_device = "/dev/kvm";
virQEMUCapsIsValid(void *data,
void *privData)
{
- virQEMUCapsPtr qemuCaps = data;
- virQEMUCapsCachePrivPtr priv = privData;
+ virQEMUCaps *qemuCaps = data;
+ virQEMUCapsCachePriv *priv = privData;
bool kvmUsable;
struct stat sb;
bool kvmSupportsNesting;
* Returns: 0 on success, <0 on failure
*/
static int
-virQEMUCapsInitQMPArch(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsInitQMPArch(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
g_autofree char *archstr = NULL;
* Initialize @qemuCaps with basic architecture-dependent capabilities.
*/
void
-virQEMUCapsInitQMPBasicArch(virQEMUCapsPtr qemuCaps)
+virQEMUCapsInitQMPBasicArch(virQEMUCaps *qemuCaps)
{
switch (qemuCaps->arch) {
case VIR_ARCH_I686:
* Add all QEMU capabilities based on version of QEMU.
*/
static void
-virQEMUCapsInitQMPVersionCaps(virQEMUCapsPtr qemuCaps)
+virQEMUCapsInitQMPVersionCaps(virQEMUCaps *qemuCaps)
{
if (qemuCaps->version >= 1006000)
virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
* for libvirt to be able to drive it properly should be processed here.
*/
void
-virQEMUCapsInitProcessCapsInterlock(virQEMUCapsPtr qemuCaps)
+virQEMUCapsInitProcessCapsInterlock(virQEMUCaps *qemuCaps)
{
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV))
virQEMUCapsClear(qemuCaps, QEMU_CAPS_BLOCKDEV_BACKUP);
* are detected.
*/
static void
-virQEMUCapsInitProcessCaps(virQEMUCapsPtr qemuCaps)
+virQEMUCapsInitProcessCaps(virQEMUCaps *qemuCaps)
{
/* 'intel-iommu' shows up as a device since 2.2.0, but can
* not be used with -device until 2.7.0. Before that it
static int
-virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
struct virQEMUCapsStringFlags *entry;
- virJSONValuePtr schemareply;
+ virJSONValue *schemareply;
GHashTable *schema = NULL;
size_t i;
#define QEMU_MIN_MICRO 0
virDomainVirtType
-virQEMUCapsGetVirtType(virQEMUCapsPtr qemuCaps)
+virQEMUCapsGetVirtType(virQEMUCaps *qemuCaps)
{
virDomainVirtType type;
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
}
int
-virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsInitQMPMonitor(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
int major, minor, micro;
g_autofree char *package = NULL;
- virQEMUCapsAccelPtr accel;
+ virQEMUCapsAccel *accel;
virDomainVirtType type;
/* @mon is supposed to be locked by callee */
int
-virQEMUCapsInitQMPMonitorTCG(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon)
+virQEMUCapsInitQMPMonitorTCG(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, VIR_DOMAIN_VIRT_QEMU);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, VIR_DOMAIN_VIRT_QEMU);
if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, accel, mon) < 0)
return -1;
static int
-virQEMUCapsInitQMPSingle(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitQMPSingle(virQEMUCaps *qemuCaps,
const char *libDir,
uid_t runUid,
gid_t runGid,
static int
-virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitQMP(virQEMUCaps *qemuCaps,
const char *libDir,
uid_t runUid,
gid_t runGid)
}
-virQEMUCapsPtr
+virQEMUCaps *
virQEMUCapsNewForBinaryInternal(virArch hostArch,
const char *binary,
const char *libDir,
unsigned int microcodeVersion,
const char *kernelVersion)
{
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
struct stat sb;
if (!(qemuCaps = virQEMUCapsNewBinary(binary)))
virQEMUCapsNewData(const char *binary,
void *privData)
{
- virQEMUCapsCachePrivPtr priv = privData;
+ virQEMUCapsCachePriv *priv = privData;
return virQEMUCapsNewForBinaryInternal(priv->hostArch,
binary,
void *privData,
bool *outdated)
{
- virQEMUCapsPtr qemuCaps = virQEMUCapsNewBinary(binary);
- virQEMUCapsCachePrivPtr priv = privData;
+ virQEMUCaps *qemuCaps = virQEMUCapsNewBinary(binary);
+ virQEMUCapsCachePriv *priv = privData;
int ret;
if (!qemuCaps)
void
-virQEMUCapsFilterByMachineType(virQEMUCapsPtr qemuCaps,
+virQEMUCapsFilterByMachineType(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *machineType)
{
};
-virFileCachePtr
+virFileCache *
virQEMUCapsCacheNew(const char *libDir,
const char *cacheDir,
uid_t runUid,
gid_t runGid)
{
char *capsCacheDir = NULL;
- virFileCachePtr cache = NULL;
- virQEMUCapsCachePrivPtr priv = NULL;
+ virFileCache *cache = NULL;
+ virQEMUCapsCachePriv *priv = NULL;
struct utsname uts;
capsCacheDir = g_strdup_printf("%s/capabilities", cacheDir);
}
-virQEMUCapsPtr
-virQEMUCapsCacheLookup(virFileCachePtr cache,
+virQEMUCaps *
+virQEMUCapsCacheLookup(virFileCache *cache,
const char *binary)
{
- virQEMUCapsCachePrivPtr priv = virFileCacheGetPriv(cache);
- virQEMUCapsPtr ret = NULL;
+ virQEMUCapsCachePriv *priv = virFileCacheGetPriv(cache);
+ virQEMUCaps *ret = NULL;
priv->microcodeVersion = virHostCPUGetMicrocodeVersion(priv->hostArch);
}
-virQEMUCapsPtr
-virQEMUCapsCacheLookupCopy(virFileCachePtr cache,
+virQEMUCaps *
+virQEMUCapsCacheLookupCopy(virFileCache *cache,
virDomainVirtType virtType,
const char *binary,
const char *machineType)
{
- virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(cache, binary);
- virQEMUCapsPtr ret;
+ virQEMUCaps *qemuCaps = virQEMUCapsCacheLookup(cache, binary);
+ virQEMUCaps *ret;
if (!qemuCaps)
return NULL;
*
* Returns QEMU capabilities matching the requirements, NULL on error.
*/
-virQEMUCapsPtr
-virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
+virQEMUCaps *
+virQEMUCapsCacheLookupDefault(virFileCache *cache,
const char *binary,
const char *archStr,
const char *virttypeStr,
}
bool
-virQEMUCapsSupportsVmport(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSupportsVmport(virQEMUCaps *qemuCaps,
const virDomainDef *def)
{
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT))
* Note that this may differ from QEMU's own default machine
*/
const char *
-virQEMUCapsGetPreferredMachine(virQEMUCapsPtr qemuCaps,
+virQEMUCapsGetPreferredMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, virtType);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
if (!accel->nmachineTypes)
return NULL;
static int
-virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoaderPtr capsLoader,
+virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoader *capsLoader,
bool secure,
- virFirmwarePtr *firmwares,
+ virFirmware **firmwares,
size_t nfirmwares)
{
size_t i;
static int
-virQEMUCapsFillDomainOSCaps(virDomainCapsOSPtr os,
+virQEMUCapsFillDomainOSCaps(virDomainCapsOS *os,
const char *machine,
virArch arch,
bool privileged,
- virFirmwarePtr *firmwares,
+ virFirmware **firmwares,
size_t nfirmwares)
{
- virDomainCapsLoaderPtr capsLoader = &os->loader;
+ virDomainCapsLoader *capsLoader = &os->loader;
uint64_t autoFirmwares = 0;
bool secure = false;
- virFirmwarePtr *firmwaresAlt = NULL;
+ virFirmware **firmwaresAlt = NULL;
size_t nfirmwaresAlt = 0;
int ret = -1;
static void
-virQEMUCapsFillDomainCPUCaps(virQEMUCapsPtr qemuCaps,
+virQEMUCapsFillDomainCPUCaps(virQEMUCaps *qemuCaps,
virArch hostarch,
- virDomainCapsPtr domCaps)
+ virDomainCaps *domCaps)
{
if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
VIR_CPU_MODE_HOST_PASSTHROUGH,
if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
VIR_CPU_MODE_HOST_MODEL,
domCaps->machine)) {
- virCPUDefPtr cpu = virQEMUCapsGetHostModel(qemuCaps, domCaps->virttype,
+ virCPUDef *cpu = virQEMUCapsGetHostModel(qemuCaps, domCaps->virttype,
VIR_QEMU_CAPS_HOST_CPU_REPORTED);
domCaps->cpu.hostModel = virCPUDefCopy(cpu);
}
static void
-virQEMUCapsFillDomainFeaturesFromQEMUCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsPtr domCaps)
+virQEMUCapsFillDomainFeaturesFromQEMUCaps(virQEMUCaps *qemuCaps,
+ virDomainCaps *domCaps)
{
size_t i;
static void
-virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCapsPtr qemuCaps,
+virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCaps *qemuCaps,
const char *machine,
- virDomainCapsDeviceDiskPtr disk)
+ virDomainCapsDeviceDisk *disk)
{
disk->supported = VIR_TRISTATE_BOOL_YES;
disk->diskDevice.report = true;
void
-virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceGraphicsPtr dev)
+virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceGraphics *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->type.report = true;
void
-virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceVideoPtr dev)
+virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceVideo *dev)
{
dev->supported = VIR_TRISTATE_BOOL_YES;
dev->modelType.report = true;
static void
-virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceHostdevPtr hostdev)
+virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceHostdev *hostdev)
{
bool supportsPassthroughVFIO = qemuHostdevHostSupportsPassthroughVFIO();
void
-virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceRNGPtr rng)
+virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceRNG *rng)
{
rng->supported = VIR_TRISTATE_BOOL_YES;
rng->model.report = true;
* otherwise
*/
bool
-virQEMUCapsSupportsGICVersion(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSupportsGICVersion(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
virGICVersion version)
{
return false;
for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
- virGICCapabilityPtr cap = &(qemuCaps->gicCapabilities[i]);
+ virGICCapability *cap = &(qemuCaps->gicCapabilities[i]);
if (cap->version != version)
continue;
* required.
*/
static void
-virQEMUCapsFillDomainFeatureGICCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsPtr domCaps)
+virQEMUCapsFillDomainFeatureGICCaps(virQEMUCaps *qemuCaps,
+ virDomainCaps *domCaps)
{
- virDomainCapsFeatureGICPtr gic = &domCaps->gic;
+ virDomainCapsFeatureGIC *gic = &domCaps->gic;
virGICVersion version;
gic->supported = VIR_TRISTATE_BOOL_NO;
* and convert it to a form suitable for @domCaps.
*/
static void
-virQEMUCapsFillDomainFeatureSEVCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsPtr domCaps)
+virQEMUCapsFillDomainFeatureSEVCaps(virQEMUCaps *qemuCaps,
+ virDomainCaps *domCaps)
{
virSEVCapability *cap = qemuCaps->sevCapabilities;
int
-virQEMUCapsFillDomainCaps(virQEMUCapsPtr qemuCaps,
+virQEMUCapsFillDomainCaps(virQEMUCaps *qemuCaps,
virArch hostarch,
- virDomainCapsPtr domCaps,
+ virDomainCaps *domCaps,
bool privileged,
- virFirmwarePtr *firmwares,
+ virFirmware **firmwares,
size_t nfirmwares)
{
- virDomainCapsOSPtr os = &domCaps->os;
- virDomainCapsDeviceDiskPtr disk = &domCaps->disk;
- virDomainCapsDeviceHostdevPtr hostdev = &domCaps->hostdev;
- virDomainCapsDeviceGraphicsPtr graphics = &domCaps->graphics;
- virDomainCapsDeviceVideoPtr video = &domCaps->video;
- virDomainCapsDeviceRNGPtr rng = &domCaps->rng;
+ virDomainCapsOS *os = &domCaps->os;
+ virDomainCapsDeviceDisk *disk = &domCaps->disk;
+ virDomainCapsDeviceHostdev *hostdev = &domCaps->hostdev;
+ virDomainCapsDeviceGraphics *graphics = &domCaps->graphics;
+ virDomainCapsDeviceVideo *video = &domCaps->video;
+ virDomainCapsDeviceRNG *rng = &domCaps->rng;
virQEMUCapsFillDomainFeaturesFromQEMUCaps(qemuCaps, domCaps);
void
-virQEMUCapsSetMicrocodeVersion(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetMicrocodeVersion(virQEMUCaps *qemuCaps,
unsigned int microcodeVersion)
{
qemuCaps->microcodeVersion = microcodeVersion;
static void
-virQEMUCapsStripMachineAliasesForVirtType(virQEMUCapsPtr qemuCaps,
+virQEMUCapsStripMachineAliasesForVirtType(virQEMUCaps *qemuCaps,
virDomainVirtType virtType)
{
- virQEMUCapsAccelPtr accel = virQEMUCapsGetAccel(qemuCaps, virtType);
+ virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
size_t i;
for (i = 0; i < accel->nmachineTypes; i++) {
- virQEMUCapsMachineTypePtr mach = &accel->machineTypes[i];
+ virQEMUCapsMachineType *mach = &accel->machineTypes[i];
g_autofree char *name = g_steal_pointer(&mach->alias);
if (name) {
* file can be stable when new files are added.
*/
void
-virQEMUCapsStripMachineAliases(virQEMUCapsPtr qemuCaps)
+virQEMUCapsStripMachineAliases(virQEMUCaps *qemuCaps)
{
virQEMUCapsStripMachineAliasesForVirtType(qemuCaps, VIR_DOMAIN_VIRT_KVM);
virQEMUCapsStripMachineAliasesForVirtType(qemuCaps, VIR_DOMAIN_VIRT_QEMU);
} virQEMUCapsFlags;
typedef struct _virQEMUCaps virQEMUCaps;
-typedef virQEMUCaps *virQEMUCapsPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virQEMUCaps, virObjectUnref);
-virQEMUCapsPtr virQEMUCapsNew(void);
-virQEMUCapsPtr virQEMUCapsNewBinary(const char *binary);
+virQEMUCaps *virQEMUCapsNew(void);
+virQEMUCaps *virQEMUCapsNewBinary(const char *binary);
-void virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
+void virQEMUCapsSet(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag) ATTRIBUTE_NONNULL(1);
-void virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...) ATTRIBUTE_NONNULL(1);
+void virQEMUCapsSetList(virQEMUCaps *qemuCaps, ...) ATTRIBUTE_NONNULL(1);
-void virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
+void virQEMUCapsClear(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag) ATTRIBUTE_NONNULL(1);
-bool virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsGet(virQEMUCaps *qemuCaps,
virQEMUCapsFlags flag);
-void virQEMUCapsInitProcessCapsInterlock(virQEMUCapsPtr qemuCaps);
+void virQEMUCapsInitProcessCapsInterlock(virQEMUCaps *qemuCaps);
-bool virQEMUCapsHasPCIMultiBus(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsHasPCIMultiBus(virQEMUCaps *qemuCaps,
const virDomainDef *def);
-bool virQEMUCapsSupportsVmport(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsSupportsVmport(virQEMUCaps *qemuCaps,
const virDomainDef *def);
-const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps);
-virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps);
-unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps);
-const char *virQEMUCapsGetPackage(virQEMUCapsPtr qemuCaps);
+const char *virQEMUCapsGetBinary(virQEMUCaps *qemuCaps);
+virArch virQEMUCapsGetArch(virQEMUCaps *qemuCaps);
+unsigned int virQEMUCapsGetVersion(virQEMUCaps *qemuCaps);
+const char *virQEMUCapsGetPackage(virQEMUCaps *qemuCaps);
-unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps);
-int virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
+unsigned int virQEMUCapsGetKVMVersion(virQEMUCaps *qemuCaps);
+int virQEMUCapsAddCPUDefinitions(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char **name,
size_t count,
virDomainCapsCPUUsable usable);
-virDomainCapsCPUModelsPtr virQEMUCapsGetCPUModels(virQEMUCapsPtr qemuCaps,
+virDomainCapsCPUModels *virQEMUCapsGetCPUModels(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char **modelAllowed,
const char **modelForbidden);
-int virQEMUCapsFetchCPUModels(qemuMonitorPtr mon,
+int virQEMUCapsFetchCPUModels(qemuMonitor *mon,
virArch arch,
- virDomainCapsCPUModelsPtr *cpuModels);
+ virDomainCapsCPUModels **cpuModels);
typedef enum {
/* Host CPU definition reported in domain capabilities. */
VIR_QEMU_CAPS_HOST_CPU_FULL,
} virQEMUCapsHostCPUType;
-virCPUDefPtr virQEMUCapsGetHostModel(virQEMUCapsPtr qemuCaps,
+virCPUDef *virQEMUCapsGetHostModel(virQEMUCaps *qemuCaps,
virDomainVirtType type,
virQEMUCapsHostCPUType cpuType);
-int virQEMUCapsGetCPUFeatures(virQEMUCapsPtr qemuCaps,
+int virQEMUCapsGetCPUFeatures(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
bool migratable,
char ***features);
-virDomainVirtType virQEMUCapsGetVirtType(virQEMUCapsPtr qemuCaps);
+virDomainVirtType virQEMUCapsGetVirtType(virQEMUCaps *qemuCaps);
-bool virQEMUCapsIsArchSupported(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsArchSupported(virQEMUCaps *qemuCaps,
virArch arch);
-bool virQEMUCapsIsVirtTypeSupported(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsVirtTypeSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType);
-bool virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsCPUModeSupported(virQEMUCaps *qemuCaps,
virArch hostarch,
virDomainVirtType type,
virCPUMode mode,
const char *machineType);
-const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
+const char *virQEMUCapsGetCanonicalMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name);
-bool virQEMUCapsIsMachineSupported(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsMachineSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *canonical_machine)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
-int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps,
+int virQEMUCapsGetMachineMaxCpus(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name);
-bool virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsGetMachineHotplugCpus(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name);
-const char *virQEMUCapsGetMachineDefaultCPU(virQEMUCapsPtr qemuCaps,
+const char *virQEMUCapsGetMachineDefaultCPU(virQEMUCaps *qemuCaps,
const char *name,
virDomainVirtType type);
-bool virQEMUCapsIsCPUDeprecated(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsCPUDeprecated(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char *model);
-bool virQEMUCapsIsMachineDeprecated(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsIsMachineDeprecated(virQEMUCaps *qemuCaps,
virDomainVirtType type,
const char *machine);
-bool virQEMUCapsGetMachineNumaMemSupported(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsGetMachineNumaMemSupported(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name);
-const char *virQEMUCapsGetMachineDefaultRAMid(virQEMUCapsPtr qemuCaps,
+const char *virQEMUCapsGetMachineDefaultRAMid(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name);
-void virQEMUCapsFilterByMachineType(virQEMUCapsPtr qemuCaps,
+void virQEMUCapsFilterByMachineType(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *machineType);
char * virQEMUCapsGetDefaultEmulator(virArch hostarch,
virArch guestarch);
-virFileCachePtr virQEMUCapsCacheNew(const char *libDir,
+virFileCache *virQEMUCapsCacheNew(const char *libDir,
const char *cacheDir,
uid_t uid,
gid_t gid);
-virQEMUCapsPtr virQEMUCapsCacheLookup(virFileCachePtr cache,
+virQEMUCaps *virQEMUCapsCacheLookup(virFileCache *cache,
const char *binary);
-virQEMUCapsPtr virQEMUCapsCacheLookupCopy(virFileCachePtr cache,
+virQEMUCaps *virQEMUCapsCacheLookupCopy(virFileCache *cache,
virDomainVirtType virtType,
const char *binary,
const char *machineType);
-virQEMUCapsPtr virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
+virQEMUCaps *virQEMUCapsCacheLookupDefault(virFileCache *cache,
const char *binary,
const char *archStr,
const char *virttypeStr,
virDomainVirtType *retVirttype,
const char **retMachine);
-virCapsPtr virQEMUCapsInit(virFileCachePtr cache);
+virCaps *virQEMUCapsInit(virFileCache *cache);
-int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
- virFileCachePtr capsCache,
+int virQEMUCapsGetDefaultVersion(virCaps *caps,
+ virFileCache *capsCache,
unsigned int *version);
VIR_ENUM_DECL(virQEMUCaps);
-bool virQEMUCapsSupportsGICVersion(virQEMUCapsPtr qemuCaps,
+bool virQEMUCapsSupportsGICVersion(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
virGICVersion version);
-const char *virQEMUCapsGetPreferredMachine(virQEMUCapsPtr qemuCaps,
+const char *virQEMUCapsGetPreferredMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType);
-int virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
+int virQEMUCapsInitGuestFromBinary(virCaps *caps,
const char *binary,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
virArch guestarch);
-int virQEMUCapsFillDomainCaps(virQEMUCapsPtr qemuCaps,
+int virQEMUCapsFillDomainCaps(virQEMUCaps *qemuCaps,
virArch hostarch,
- virDomainCapsPtr domCaps,
+ virDomainCaps *domCaps,
bool privileged,
- virFirmwarePtr *firmwares,
+ virFirmware **firmwares,
size_t nfirmwares);
-void virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceGraphicsPtr dev);
+void virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceGraphics *dev);
-void virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceVideoPtr dev);
+void virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceVideo *dev);
-void virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCapsPtr qemuCaps,
- virDomainCapsDeviceRNGPtr rng);
+void virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCaps *qemuCaps,
+ virDomainCapsDeviceRNG *rng);
bool virQEMUCapsGuestIsNative(virArch host,
virArch guest);
void *opaque);
const char *
-virQEMUCapsCPUFeatureToQEMU(virQEMUCapsPtr qemuCaps,
+virQEMUCapsCPUFeatureToQEMU(virQEMUCaps *qemuCaps,
const char *feature);
const char *
-virQEMUCapsCPUFeatureFromQEMU(virQEMUCapsPtr qemuCaps,
+virQEMUCapsCPUFeatureFromQEMU(virQEMUCaps *qemuCaps,
const char *feature);
-virSEVCapabilityPtr
-virQEMUCapsGetSEVCapabilities(virQEMUCapsPtr qemuCaps);
+virSEVCapability *
+virQEMUCapsGetSEVCapabilities(virQEMUCaps *qemuCaps);
virArch virQEMUCapsArchFromString(const char *arch);
const char *virQEMUCapsArchToString(virArch arch);
#pragma once
-virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps);
+virQEMUCaps *virQEMUCapsNewCopy(virQEMUCaps *qemuCaps);
-virQEMUCapsPtr
+virQEMUCaps *
virQEMUCapsNewForBinaryInternal(virArch hostArch,
const char *binary,
const char *libDir,
const char *kernelVersion);
int virQEMUCapsLoadCache(virArch hostArch,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
const char *filename,
bool skipInvalidation);
-char *virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps);
+char *virQEMUCapsFormatCache(virQEMUCaps *qemuCaps);
int
-virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon);
+virQEMUCapsInitQMPMonitor(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon);
int
-virQEMUCapsInitQMPMonitorTCG(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon);
+virQEMUCapsInitQMPMonitorTCG(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon);
void
-virQEMUCapsSetArch(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetArch(virQEMUCaps *qemuCaps,
virArch arch);
void
-virQEMUCapsInitHostCPUModel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitHostCPUModel(virQEMUCaps *qemuCaps,
virArch hostArch,
virDomainVirtType type);
int
-virQEMUCapsInitCPUModel(virQEMUCapsPtr qemuCaps,
+virQEMUCapsInitCPUModel(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable);
void
-virQEMUCapsInitQMPBasicArch(virQEMUCapsPtr qemuCaps);
+virQEMUCapsInitQMPBasicArch(virQEMUCaps *qemuCaps);
-qemuMonitorCPUModelInfoPtr
-virQEMUCapsGetCPUModelInfo(virQEMUCapsPtr qemuCaps,
+qemuMonitorCPUModelInfo *
+virQEMUCapsGetCPUModelInfo(virQEMUCaps *qemuCaps,
virDomainVirtType type);
void
-virQEMUCapsSetCPUModelInfo(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetCPUModelInfo(virQEMUCaps *qemuCaps,
virDomainVirtType type,
- qemuMonitorCPUModelInfoPtr modelInfo);
+ qemuMonitorCPUModelInfo *modelInfo);
-virCPUDataPtr
-virQEMUCapsGetCPUModelX86Data(virQEMUCapsPtr qemuCaps,
- qemuMonitorCPUModelInfoPtr model,
+virCPUData *
+virQEMUCapsGetCPUModelX86Data(virQEMUCaps *qemuCaps,
+ qemuMonitorCPUModelInfo *model,
bool migratable);
-virCPUDefPtr
+virCPUDef *
virQEMUCapsProbeHostCPU(virArch hostArch,
- virDomainCapsCPUModelsPtr models) G_GNUC_NO_INLINE;
+ virDomainCapsCPUModels *models) G_GNUC_NO_INLINE;
void
-virQEMUCapsSetGICCapabilities(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetGICCapabilities(virQEMUCaps *qemuCaps,
virGICCapability *capabilities,
size_t ncapabilities);
void
-virQEMUCapsSetSEVCapabilities(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetSEVCapabilities(virQEMUCaps *qemuCaps,
virSEVCapability *capabilities);
int
-virQEMUCapsProbeCPUDefinitionsTest(virQEMUCapsPtr qemuCaps,
- qemuMonitorPtr mon);
+virQEMUCapsProbeCPUDefinitionsTest(virQEMUCaps *qemuCaps,
+ qemuMonitor *mon);
void
-virQEMUCapsSetMicrocodeVersion(virQEMUCapsPtr qemuCaps,
+virQEMUCapsSetMicrocodeVersion(virQEMUCaps *qemuCaps,
unsigned int microcodeVersion);
void
-virQEMUCapsStripMachineAliases(virQEMUCapsPtr qemuCaps);
+virQEMUCapsStripMachineAliases(virQEMUCaps *qemuCaps);
bool
-virQEMUCapsHasMachines(virQEMUCapsPtr qemuCaps);
+virQEMUCapsHasMachines(virQEMUCaps *qemuCaps);
void
-virQEMUCapsAddMachine(virQEMUCapsPtr qemuCaps,
+virQEMUCapsAddMachine(virQEMUCaps *qemuCaps,
virDomainVirtType virtType,
const char *name,
const char *alias,
static int
-qemuSetupImagePathCgroup(virDomainObjPtr vm,
+qemuSetupImagePathCgroup(virDomainObj *vm,
const char *path,
bool readonly)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int perms = VIR_CGROUP_DEVICE_READ;
g_auto(GStrv) targetPaths = NULL;
size_t i;
static int
-qemuSetupImageCgroupInternal(virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuSetupImageCgroupInternal(virDomainObj *vm,
+ virStorageSource *src,
bool forceReadonly)
{
g_autofree char *path = NULL;
int
-qemuSetupImageCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuSetupImageCgroup(virDomainObj *vm,
+ virStorageSource *src)
{
return qemuSetupImageCgroupInternal(vm, src, false);
}
int
-qemuTeardownImageCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuTeardownImageCgroup(virDomainObj *vm,
+ virStorageSource *src)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *path = NULL;
int perms = VIR_CGROUP_DEVICE_RWM;
bool hasPR = false;
return 0;
for (i = 0; i < vm->def->ndisks; i++) {
- virStorageSourcePtr diskSrc = vm->def->disks[i]->src;
+ virStorageSource *diskSrc = vm->def->disks[i]->src;
if (src == diskSrc)
continue;
int
-qemuSetupImageChainCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuSetupImageChainCgroup(virDomainObj *vm,
+ virStorageSource *src)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
bool forceReadonly = false;
for (next = src; virStorageSourceIsBacking(next); next = next->backingStore) {
int
-qemuTeardownImageChainCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuTeardownImageChainCgroup(virDomainObj *vm,
+ virStorageSource *src)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
for (next = src; virStorageSourceIsBacking(next); next = next->backingStore) {
if (qemuTeardownImageCgroup(vm, next) < 0)
static int
-qemuSetupChrSourceCgroup(virDomainObjPtr vm,
- virDomainChrSourceDefPtr source)
+qemuSetupChrSourceCgroup(virDomainObj *vm,
+ virDomainChrSourceDef *source)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
static int
-qemuTeardownChrSourceCgroup(virDomainObjPtr vm,
- virDomainChrSourceDefPtr source)
+qemuTeardownChrSourceCgroup(virDomainObj *vm,
+ virDomainChrSourceDef *source)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
static int
-qemuSetupChardevCgroupCB(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrDefPtr dev,
+qemuSetupChardevCgroupCB(virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrDef *dev,
void *opaque)
{
- virDomainObjPtr vm = opaque;
+ virDomainObj *vm = opaque;
return qemuSetupChrSourceCgroup(vm, dev->source);
}
static int
-qemuSetupTPMCgroup(virDomainObjPtr vm,
- virDomainTPMDefPtr dev)
+qemuSetupTPMCgroup(virDomainObj *vm,
+ virDomainTPMDef *dev)
{
int ret = 0;
int
-qemuSetupInputCgroup(virDomainObjPtr vm,
- virDomainInputDefPtr dev)
+qemuSetupInputCgroup(virDomainObj *vm,
+ virDomainInputDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = 0;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
int
-qemuTeardownInputCgroup(virDomainObjPtr vm,
- virDomainInputDefPtr dev)
+qemuTeardownInputCgroup(virDomainObj *vm,
+ virDomainInputDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = 0;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
* -1 otherwise.
*/
int
-qemuSetupHostdevCgroup(virDomainObjPtr vm,
- virDomainHostdevDefPtr dev)
+qemuSetupHostdevCgroup(virDomainObj *vm,
+ virDomainHostdevDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *path = NULL;
int perms;
int rv;
* -1 otherwise.
*/
int
-qemuTeardownHostdevCgroup(virDomainObjPtr vm,
- virDomainHostdevDefPtr dev)
+qemuTeardownHostdevCgroup(virDomainObj *vm,
+ virDomainHostdevDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *path = NULL;
int rv;
int
-qemuSetupMemoryDevicesCgroup(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuSetupMemoryDevicesCgroup(virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
int
-qemuTeardownMemoryDevicesCgroup(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuTeardownMemoryDevicesCgroup(virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
static int
-qemuSetupGraphicsCgroup(virDomainObjPtr vm,
- virDomainGraphicsDefPtr gfx)
+qemuSetupGraphicsCgroup(virDomainObj *vm,
+ virDomainGraphicsDef *gfx)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
const char *rendernode = virDomainGraphicsGetRenderNode(gfx);
int ret;
static int
-qemuSetupVideoCgroup(virDomainObjPtr vm,
- virDomainVideoDefPtr def)
+qemuSetupVideoCgroup(virDomainObj *vm,
+ virDomainVideoDef *def)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainVideoAccelDefPtr accel = def->accel;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainVideoAccelDef *accel = def->accel;
int ret;
if (!accel)
static int
-qemuSetupBlkioCgroup(virDomainObjPtr vm)
+qemuSetupBlkioCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virCgroupHasController(priv->cgroup,
VIR_CGROUP_CONTROLLER_BLKIO)) {
static int
-qemuSetupMemoryCgroup(virDomainObjPtr vm)
+qemuSetupMemoryCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
if (virMemoryLimitIsSet(vm->def->mem.hard_limit) ||
static int
-qemuSetupFirmwareCgroup(virDomainObjPtr vm)
+qemuSetupFirmwareCgroup(virDomainObj *vm)
{
if (!vm->def->os.loader)
return 0;
int
-qemuSetupRNGCgroup(virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuSetupRNGCgroup(virDomainObj *vm,
+ virDomainRNGDef *rng)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
int
-qemuTeardownRNGCgroup(virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuTeardownRNGCgroup(virDomainObj *vm,
+ virDomainRNGDef *rng)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
int
-qemuSetupChardevCgroup(virDomainObjPtr vm,
- virDomainChrDefPtr dev)
+qemuSetupChardevCgroup(virDomainObj *vm,
+ virDomainChrDef *dev)
{
return qemuSetupChrSourceCgroup(vm, dev->source);
}
int
-qemuTeardownChardevCgroup(virDomainObjPtr vm,
- virDomainChrDefPtr dev)
+qemuTeardownChardevCgroup(virDomainObj *vm,
+ virDomainChrDef *dev)
{
return qemuTeardownChrSourceCgroup(vm, dev->source);
}
static int
-qemuSetupSEVCgroup(virDomainObjPtr vm)
+qemuSetupSEVCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
}
static int
-qemuSetupDevicesCgroup(virDomainObjPtr vm)
+qemuSetupDevicesCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
const char *const *deviceACL = NULL;
int rv = -1;
static int
-qemuSetupCpusetCgroup(virDomainObjPtr vm)
+qemuSetupCpusetCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET))
return 0;
static int
-qemuSetupCpuCgroup(virDomainObjPtr vm)
+qemuSetupCpuCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
if (vm->def->cputune.sharesSpecified) {
static int
-qemuInitCgroup(virDomainObjPtr vm,
+qemuInitCgroup(virDomainObj *vm,
size_t nnicindexes,
int *nicindexes)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
if (!priv->driver->privileged)
priv->cgroup = NULL;
if (!vm->def->resource) {
- virDomainResourceDefPtr res;
+ virDomainResourceDef *res;
res = g_new0(virDomainResourceDef, 1);
}
static int
-qemuRestoreCgroupThread(virCgroupPtr cgroup,
+qemuRestoreCgroupThread(virCgroup *cgroup,
virCgroupThreadName thread,
int id)
{
}
static void
-qemuRestoreCgroupState(virDomainObjPtr vm)
+qemuRestoreCgroupState(virDomainObj *vm)
{
g_autofree char *mem_mask = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i = 0;
g_autoptr(virBitmap) all_nodes = NULL;
goto error;
for (i = 0; i < virDomainDefGetVcpusMax(vm->def); i++) {
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, i);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, i);
if (!vcpu->online)
continue;
}
int
-qemuConnectCgroup(virDomainObjPtr vm)
+qemuConnectCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
if (!priv->driver->privileged)
}
int
-qemuSetupCgroup(virDomainObjPtr vm,
+qemuSetupCgroup(virDomainObj *vm,
size_t nnicindexes,
int *nicindexes)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!vm->pid) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
int
-qemuSetupCgroupVcpuBW(virCgroupPtr cgroup,
+qemuSetupCgroupVcpuBW(virCgroup *cgroup,
unsigned long long period,
long long quota)
{
int
-qemuSetupCgroupCpusetCpus(virCgroupPtr cgroup,
- virBitmapPtr cpumask)
+qemuSetupCgroupCpusetCpus(virCgroup *cgroup,
+ virBitmap *cpumask)
{
return virCgroupSetupCpusetCpus(cgroup, cpumask);
}
int
-qemuSetupCgroupForExtDevices(virDomainObjPtr vm,
- virQEMUDriverPtr driver)
+qemuSetupCgroupForExtDevices(virDomainObj *vm,
+ virQEMUDriver *driver)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCgroup) cgroup_temp = NULL;
if (!qemuExtDevicesHasDevice(vm->def) ||
int
-qemuSetupGlobalCpuCgroup(virDomainObjPtr vm)
+qemuSetupGlobalCpuCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned long long period = vm->def->cputune.global_period;
long long quota = vm->def->cputune.global_quota;
g_autofree char *mem_mask = NULL;
int
-qemuRemoveCgroup(virDomainObjPtr vm)
+qemuRemoveCgroup(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->cgroup == NULL)
return 0; /* Not supported, so claim success */
static void
-qemuCgroupEmulatorAllNodesDataFree(qemuCgroupEmulatorAllNodesDataPtr data)
+qemuCgroupEmulatorAllNodesDataFree(qemuCgroupEmulatorAllNodesData *data)
{
if (!data)
return;
* Returns 0 on success -1 on error
*/
int
-qemuCgroupEmulatorAllNodesAllow(virCgroupPtr cgroup,
- qemuCgroupEmulatorAllNodesDataPtr *retData)
+qemuCgroupEmulatorAllNodesAllow(virCgroup *cgroup,
+ qemuCgroupEmulatorAllNodesData **retData)
{
- qemuCgroupEmulatorAllNodesDataPtr data = NULL;
+ qemuCgroupEmulatorAllNodesData *data = NULL;
g_autofree char *all_nodes_str = NULL;
g_autoptr(virBitmap) all_nodes = NULL;
int ret = -1;
* associated data.
*/
void
-qemuCgroupEmulatorAllNodesRestore(qemuCgroupEmulatorAllNodesDataPtr data)
+qemuCgroupEmulatorAllNodesRestore(qemuCgroupEmulatorAllNodesData *data)
{
virErrorPtr err;
#include "domain_conf.h"
#include "qemu_conf.h"
-int qemuSetupImageCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src);
-int qemuTeardownImageCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src);
-int qemuSetupImageChainCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src);
-int qemuTeardownImageChainCgroup(virDomainObjPtr vm,
- virStorageSourcePtr src);
-int qemuSetupInputCgroup(virDomainObjPtr vm,
- virDomainInputDefPtr dev);
-int qemuTeardownInputCgroup(virDomainObjPtr vm,
- virDomainInputDefPtr dev);
-int qemuSetupHostdevCgroup(virDomainObjPtr vm,
- virDomainHostdevDefPtr dev)
+int qemuSetupImageCgroup(virDomainObj *vm,
+ virStorageSource *src);
+int qemuTeardownImageCgroup(virDomainObj *vm,
+ virStorageSource *src);
+int qemuSetupImageChainCgroup(virDomainObj *vm,
+ virStorageSource *src);
+int qemuTeardownImageChainCgroup(virDomainObj *vm,
+ virStorageSource *src);
+int qemuSetupInputCgroup(virDomainObj *vm,
+ virDomainInputDef *dev);
+int qemuTeardownInputCgroup(virDomainObj *vm,
+ virDomainInputDef *dev);
+int qemuSetupHostdevCgroup(virDomainObj *vm,
+ virDomainHostdevDef *dev)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuTeardownHostdevCgroup(virDomainObjPtr vm,
- virDomainHostdevDefPtr dev)
+int qemuTeardownHostdevCgroup(virDomainObj *vm,
+ virDomainHostdevDef *dev)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuSetupMemoryDevicesCgroup(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
-int qemuTeardownMemoryDevicesCgroup(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
-int qemuSetupRNGCgroup(virDomainObjPtr vm,
- virDomainRNGDefPtr rng);
-int qemuTeardownRNGCgroup(virDomainObjPtr vm,
- virDomainRNGDefPtr rng);
-int qemuSetupChardevCgroup(virDomainObjPtr vm,
- virDomainChrDefPtr dev);
-int qemuTeardownChardevCgroup(virDomainObjPtr vm,
- virDomainChrDefPtr dev);
-int qemuConnectCgroup(virDomainObjPtr vm);
-int qemuSetupCgroup(virDomainObjPtr vm,
+int qemuSetupMemoryDevicesCgroup(virDomainObj *vm,
+ virDomainMemoryDef *mem);
+int qemuTeardownMemoryDevicesCgroup(virDomainObj *vm,
+ virDomainMemoryDef *mem);
+int qemuSetupRNGCgroup(virDomainObj *vm,
+ virDomainRNGDef *rng);
+int qemuTeardownRNGCgroup(virDomainObj *vm,
+ virDomainRNGDef *rng);
+int qemuSetupChardevCgroup(virDomainObj *vm,
+ virDomainChrDef *dev);
+int qemuTeardownChardevCgroup(virDomainObj *vm,
+ virDomainChrDef *dev);
+int qemuConnectCgroup(virDomainObj *vm);
+int qemuSetupCgroup(virDomainObj *vm,
size_t nnicindexes,
int *nicindexes);
-int qemuSetupCgroupVcpuBW(virCgroupPtr cgroup,
+int qemuSetupCgroupVcpuBW(virCgroup *cgroup,
unsigned long long period,
long long quota);
-int qemuSetupCgroupCpusetCpus(virCgroupPtr cgroup, virBitmapPtr cpumask);
-int qemuSetupGlobalCpuCgroup(virDomainObjPtr vm);
-int qemuSetupCgroupForExtDevices(virDomainObjPtr vm,
- virQEMUDriverPtr driver);
-int qemuRemoveCgroup(virDomainObjPtr vm);
+int qemuSetupCgroupCpusetCpus(virCgroup *cgroup, virBitmap *cpumask);
+int qemuSetupGlobalCpuCgroup(virDomainObj *vm);
+int qemuSetupCgroupForExtDevices(virDomainObj *vm,
+ virQEMUDriver *driver);
+int qemuRemoveCgroup(virDomainObj *vm);
typedef struct _qemuCgroupEmulatorAllNodesData qemuCgroupEmulatorAllNodesData;
-typedef qemuCgroupEmulatorAllNodesData *qemuCgroupEmulatorAllNodesDataPtr;
struct _qemuCgroupEmulatorAllNodesData {
- virCgroupPtr emulatorCgroup;
+ virCgroup *emulatorCgroup;
char *emulatorMemMask;
};
-int qemuCgroupEmulatorAllNodesAllow(virCgroupPtr cgroup,
- qemuCgroupEmulatorAllNodesDataPtr *data);
-void qemuCgroupEmulatorAllNodesRestore(qemuCgroupEmulatorAllNodesDataPtr data);
+int qemuCgroupEmulatorAllNodesAllow(virCgroup *cgroup,
+ qemuCgroupEmulatorAllNodesData **data);
+void qemuCgroupEmulatorAllNodesRestore(qemuCgroupEmulatorAllNodesData *data);
extern const char *const defaultDeviceACL[];
* the checkpoint which was 'current' previously is updated.
*/
static void
-qemuCheckpointSetCurrent(virDomainObjPtr vm,
- virDomainMomentObjPtr newcurrent)
+qemuCheckpointSetCurrent(virDomainObj *vm,
+ virDomainMomentObj *newcurrent)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virDomainMomentObjPtr oldcurrent = virDomainCheckpointGetCurrent(vm->checkpoints);
+ virDomainMomentObj *oldcurrent = virDomainCheckpointGetCurrent(vm->checkpoints);
virDomainCheckpointSetCurrent(vm->checkpoints, newcurrent);
/* Looks up the domain object from checkpoint and unlocks the
* driver. The returned domain object is locked and ref'd and the
* caller must call virDomainObjEndAPI() on it. */
-virDomainObjPtr
+virDomainObj *
qemuDomObjFromCheckpoint(virDomainCheckpointPtr checkpoint)
{
return qemuDomainObjFromDomain(checkpoint->domain);
/* Looks up checkpoint object from VM and name */
-virDomainMomentObjPtr
-qemuCheckpointObjFromName(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuCheckpointObjFromName(virDomainObj *vm,
const char *name)
{
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
chk = virDomainCheckpointFindByName(vm->checkpoints, name);
if (!chk)
virReportError(VIR_ERR_NO_DOMAIN_CHECKPOINT,
/* Looks up checkpoint object from VM and checkpointPtr */
-virDomainMomentObjPtr
-qemuCheckpointObjFromCheckpoint(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuCheckpointObjFromCheckpoint(virDomainObj *vm,
virDomainCheckpointPtr checkpoint)
{
return qemuCheckpointObjFromName(vm, checkpoint->name);
int
-qemuCheckpointWriteMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr checkpoint,
- virDomainXMLOptionPtr xmlopt,
+qemuCheckpointWriteMetadata(virDomainObj *vm,
+ virDomainMomentObj *checkpoint,
+ virDomainXMLOption *xmlopt,
const char *checkpointDir)
{
unsigned int flags = VIR_DOMAIN_CHECKPOINT_FORMAT_SECURE;
- virDomainCheckpointDefPtr def = virDomainCheckpointObjGetDef(checkpoint);
+ virDomainCheckpointDef *def = virDomainCheckpointObjGetDef(checkpoint);
g_autofree char *newxml = NULL;
g_autofree char *chkDir = NULL;
g_autofree char *chkFile = NULL;
int
-qemuCheckpointDiscardDiskBitmaps(virStorageSourcePtr src,
+qemuCheckpointDiscardDiskBitmaps(virStorageSource *src,
GHashTable *blockNamedNodeData,
const char *delbitmap,
- virJSONValuePtr actions,
+ virJSONValue *actions,
const char *diskdst,
GSList **reopenimages)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
bool found = false;
/* find the backing chain entry with bitmap named '@delbitmap' */
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
- qemuBlockNamedNodeDataBitmapPtr bitmapdata;
+ qemuBlockNamedNodeDataBitmap *bitmapdata;
if (!(bitmapdata = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData,
n, delbitmap)))
static int
-qemuCheckpointDiscardBitmaps(virDomainObjPtr vm,
- virDomainCheckpointDefPtr chkdef)
+qemuCheckpointDiscardBitmaps(virDomainObj *vm,
+ virDomainCheckpointDef *chkdef)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
int rc = -1;
g_autoptr(virJSONValue) actions = NULL;
for (i = 0; i < chkdef->ndisks; i++) {
virDomainCheckpointDiskDef *chkdisk = &chkdef->disks[i];
- virDomainDiskDefPtr domdisk = virDomainDiskByTarget(vm->def, chkdisk->name);
+ virDomainDiskDef *domdisk = virDomainDiskByTarget(vm->def, chkdisk->name);
/* domdisk can be missing e.g. when it was unplugged */
if (!domdisk)
/* label any non-top images for read-write access */
for (next = reopenimages; next; next = next->next) {
- virStorageSourcePtr src = next->data;
+ virStorageSource *src = next->data;
if (qemuDomainStorageSourceAccessAllow(driver, vm, src,
false, false, false) < 0)
relabel:
for (next = relabelimages; next; next = next->next) {
- virStorageSourcePtr src = next->data;
+ virStorageSource *src = next->data;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV_REOPEN))
ignore_value(qemuBlockReopenReadOnly(vm, src, QEMU_ASYNC_JOB_NONE));
static int
-qemuCheckpointDiscard(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr chk,
+qemuCheckpointDiscard(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *chk,
bool update_parent,
bool metadata_only)
{
chk->def->name);
if (!metadata_only) {
- virDomainCheckpointDefPtr chkdef = virDomainCheckpointObjGetDef(chk);
+ virDomainCheckpointDef *chkdef = virDomainCheckpointObjGetDef(chk);
if (qemuCheckpointDiscardBitmaps(vm, chkdef) < 0)
return -1;
}
if (chkcurrent) {
- virDomainMomentObjPtr parent = NULL;
+ virDomainMomentObj *parent = NULL;
virDomainCheckpointSetCurrent(vm->checkpoints, NULL);
parent = virDomainCheckpointFindByName(vm->checkpoints,
int
-qemuCheckpointDiscardAllMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuCheckpointDiscardAllMetadata(virQEMUDriver *driver,
+ virDomainObj *vm)
{
virQEMUMomentRemove rem = {
.driver = driver,
/* Called inside job lock */
static int
-qemuCheckpointPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainCheckpointDefPtr def)
+qemuCheckpointPrepare(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainCheckpointDef *def)
{
size_t i;
g_autofree char *xml = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
/* Easiest way to clone inactive portion of vm->def is via
* conversion in and back out of xml. */
return -1;
for (i = 0; i < def->ndisks; i++) {
- virDomainCheckpointDiskDefPtr disk = &def->disks[i];
+ virDomainCheckpointDiskDef *disk = &def->disks[i];
if (disk->type != VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP)
continue;
}
static int
-qemuCheckpointAddActions(virDomainObjPtr vm,
- virJSONValuePtr actions,
- virDomainCheckpointDefPtr def)
+qemuCheckpointAddActions(virDomainObj *vm,
+ virJSONValue *actions,
+ virDomainCheckpointDef *def)
{
size_t i;
for (i = 0; i < def->ndisks; i++) {
virDomainCheckpointDiskDef *chkdisk = &def->disks[i];
- virDomainDiskDefPtr domdisk = virDomainDiskByTarget(vm->def, chkdisk->name);
+ virDomainDiskDef *domdisk = virDomainDiskByTarget(vm->def, chkdisk->name);
/* checkpoint definition validator mandates that the corresponding
* domdisk should exist */
static int
-qemuCheckpointRedefineValidateBitmaps(virDomainObjPtr vm,
- virDomainCheckpointDefPtr chkdef)
+qemuCheckpointRedefineValidateBitmaps(virDomainObj *vm,
+ virDomainCheckpointDef *chkdef)
{
g_autoptr(GHashTable) blockNamedNodeData = NULL;
size_t i;
return -1;
for (i = 0; i < chkdef->ndisks; i++) {
- virDomainCheckpointDiskDefPtr chkdisk = chkdef->disks + i;
- virDomainDiskDefPtr domdisk;
+ virDomainCheckpointDiskDef *chkdisk = chkdef->disks + i;
+ virDomainDiskDef *domdisk;
if (chkdisk->type != VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP)
continue;
}
-static virDomainMomentObjPtr
-qemuCheckpointRedefine(virDomainObjPtr vm,
- virDomainCheckpointDefPtr *def,
+static virDomainMomentObj *
+qemuCheckpointRedefine(virDomainObj *vm,
+ virDomainCheckpointDef **def,
bool *update_current,
bool validate_bitmaps)
{
int
-qemuCheckpointCreateCommon(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainCheckpointDefPtr *def,
- virJSONValuePtr *actions,
- virDomainMomentObjPtr *chk)
+qemuCheckpointCreateCommon(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainCheckpointDef **def,
+ virJSONValue **actions,
+ virDomainMomentObj **chk)
{
g_autoptr(virJSONValue) tmpactions = NULL;
- virDomainMomentObjPtr parent;
+ virDomainMomentObj *parent;
if (qemuCheckpointPrepare(driver, vm, *def) < 0)
return -1;
* If @chk is not null remove the @chk object from the list of checkpoints of @vm.
*/
void
-qemuCheckpointRollbackMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr chk)
+qemuCheckpointRollbackMetadata(virDomainObj *vm,
+ virDomainMomentObj *chk)
{
if (!chk)
return;
}
-static virDomainMomentObjPtr
-qemuCheckpointCreate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainCheckpointDefPtr *def)
+static virDomainMomentObj *
+qemuCheckpointCreate(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainCheckpointDef **def)
{
g_autoptr(virJSONValue) actions = NULL;
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
int rc;
if (qemuCheckpointCreateCommon(driver, vm, def, &actions, &chk) < 0)
int
-qemuCheckpointCreateFinalize(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
- virDomainMomentObjPtr chk,
+qemuCheckpointCreateFinalize(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virQEMUDriverConfig *cfg,
+ virDomainMomentObj *chk,
bool update_current)
{
if (update_current)
virDomainCheckpointPtr
qemuCheckpointCreateXML(virDomainPtr domain,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlDesc,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
- virDomainMomentObjPtr chk = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr checkpoint = NULL;
bool update_current = true;
bool redefine = flags & VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE;
struct qemuCheckpointDiskMap {
- virDomainCheckpointDiskDefPtr chkdisk;
- virDomainDiskDefPtr domdisk;
+ virDomainCheckpointDiskDef *chkdisk;
+ virDomainDiskDef *domdisk;
};
static int
-qemuCheckpointGetXMLDescUpdateSize(virDomainObjPtr vm,
- virDomainCheckpointDefPtr chkdef)
+qemuCheckpointGetXMLDescUpdateSize(virDomainObj *vm,
+ virDomainCheckpointDef *chkdef)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autofree struct qemuCheckpointDiskMap *diskmap = NULL;
g_autoptr(virJSONValue) recoveractions = NULL;
diskmap = g_new0(struct qemuCheckpointDiskMap, chkdef->ndisks);
for (i = 0; i < chkdef->ndisks; i++) {
- virDomainCheckpointDiskDefPtr chkdisk = chkdef->disks + i;
- virDomainDiskDefPtr domdisk;
+ virDomainCheckpointDiskDef *chkdisk = chkdef->disks + i;
+ virDomainDiskDef *domdisk;
chkdisk->size = 0;
chkdisk->sizeValid = false;
/* we need to calculate the merged bitmap to obtain accurate data */
for (i = 0; i < ndisks; i++) {
- virDomainDiskDefPtr domdisk = diskmap[i].domdisk;
+ virDomainDiskDef *domdisk = diskmap[i].domdisk;
g_autoptr(virJSONValue) actions = NULL;
/* possibly delete leftovers from previous cases */
/* update disks */
for (i = 0; i < ndisks; i++) {
- virDomainCheckpointDiskDefPtr chkdisk = diskmap[i].chkdisk;
- virDomainDiskDefPtr domdisk = diskmap[i].domdisk;
- qemuBlockNamedNodeDataBitmapPtr bitmap;
+ virDomainCheckpointDiskDef *chkdisk = diskmap[i].chkdisk;
+ virDomainDiskDef *domdisk = diskmap[i].domdisk;
+ qemuBlockNamedNodeDataBitmap *bitmap;
if ((bitmap = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData, domdisk->src,
"libvirt-tmp-size-xml"))) {
char *
-qemuCheckpointGetXMLDesc(virDomainObjPtr vm,
+qemuCheckpointGetXMLDesc(virDomainObj *vm,
virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
- virDomainMomentObjPtr chk = NULL;
- virDomainCheckpointDefPtr chkdef;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
+ virDomainMomentObj *chk = NULL;
+ virDomainCheckpointDef *chkdef;
unsigned int format_flags;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_XML_SECURE |
struct virQEMUCheckpointReparent {
const char *dir;
- virDomainMomentObjPtr parent;
- virDomainObjPtr vm;
- virDomainXMLOptionPtr xmlopt;
+ virDomainMomentObj *parent;
+ virDomainObj *vm;
+ virDomainXMLOption *xmlopt;
int err;
};
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr moment = payload;
+ virDomainMomentObj *moment = payload;
struct virQEMUCheckpointReparent *rep = data;
if (rep->err < 0)
int
-qemuCheckpointDelete(virDomainObjPtr vm,
+qemuCheckpointDelete(virDomainObj *vm,
virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int ret = -1;
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
virQEMUMomentRemove rem;
struct virQEMUCheckpointReparent rep;
bool metadata_only = !!(flags & VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY);
#include "datatypes.h"
#include "qemu_conf.h"
-virDomainObjPtr
+virDomainObj *
qemuDomObjFromCheckpoint(virDomainCheckpointPtr checkpoint);
-virDomainMomentObjPtr
-qemuCheckpointObjFromCheckpoint(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuCheckpointObjFromCheckpoint(virDomainObj *vm,
virDomainCheckpointPtr checkpoint);
-virDomainMomentObjPtr
-qemuCheckpointObjFromName(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuCheckpointObjFromName(virDomainObj *vm,
const char *name);
int
-qemuCheckpointDiscardAllMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+qemuCheckpointDiscardAllMetadata(virQEMUDriver *driver,
+ virDomainObj *vm);
virDomainCheckpointPtr
qemuCheckpointCreateXML(virDomainPtr domain,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlDesc,
unsigned int flags);
char *
-qemuCheckpointGetXMLDesc(virDomainObjPtr vm,
+qemuCheckpointGetXMLDesc(virDomainObj *vm,
virDomainCheckpointPtr checkpoint,
unsigned int flags);
int
-qemuCheckpointDelete(virDomainObjPtr vm,
+qemuCheckpointDelete(virDomainObj *vm,
virDomainCheckpointPtr checkpoint,
unsigned int flags);
int
-qemuCheckpointCreateCommon(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainCheckpointDefPtr *def,
- virJSONValuePtr *actions,
- virDomainMomentObjPtr *chk);
+qemuCheckpointCreateCommon(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainCheckpointDef **def,
+ virJSONValue **actions,
+ virDomainMomentObj **chk);
int
-qemuCheckpointCreateFinalize(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
- virDomainMomentObjPtr chk,
+qemuCheckpointCreateFinalize(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virQEMUDriverConfig *cfg,
+ virDomainMomentObj *chk,
bool update_current);
void
-qemuCheckpointRollbackMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr chk);
+qemuCheckpointRollbackMetadata(virDomainObj *vm,
+ virDomainMomentObj *chk);
int
-qemuCheckpointDiscardDiskBitmaps(virStorageSourcePtr src,
+qemuCheckpointDiscardDiskBitmaps(virStorageSource *src,
GHashTable *blockNamedNodeData,
const char *delbitmap,
- virJSONValuePtr actions,
+ virJSONValue *actions,
const char *diskdst,
GSList **reopenimages);
int
-qemuCheckpointWriteMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr checkpoint,
- virDomainXMLOptionPtr xmlopt,
+qemuCheckpointWriteMetadata(virDomainObj *vm,
+ virDomainMomentObj *checkpoint,
+ virDomainXMLOption *xmlopt,
const char *checkpointDir);
* Returns 0 on success, -1 w/ error message on failure
*/
static int
-qemuBuildMasterKeyCommandLine(virCommandPtr cmd,
- qemuDomainObjPrivatePtr priv)
+qemuBuildMasterKeyCommandLine(virCommand *cmd,
+ qemuDomainObjPrivate *priv)
{
g_autofree char *alias = NULL;
g_autofree char *path = NULL;
* This function for example returns "set=10,fd=20".
*/
static char *
-qemuVirCommandGetFDSet(virCommandPtr cmd, int fd)
+qemuVirCommandGetFDSet(virCommand *cmd, int fd)
{
int idx = virCommandPassFDGetFDIndex(cmd, fd);
* 'transferred' in a virCommandPassFD() call.
*/
static char *
-qemuVirCommandGetDevSet(virCommandPtr cmd, int fd)
+qemuVirCommandGetDevSet(virCommand *cmd, int fd)
{
int idx = virCommandPassFDGetFDIndex(cmd, fd);
static int
-qemuBuildDeviceAddressStr(virBufferPtr buf,
+qemuBuildDeviceAddressStr(virBuffer *buf,
const virDomainDef *domainDef,
- virDomainDeviceInfoPtr info,
- virQEMUCapsPtr qemuCaps)
+ virDomainDeviceInfo *info,
+ virQEMUCaps *qemuCaps)
{
g_autofree char *devStr = NULL;
const char *contAlias = NULL;
if (!(devStr = virPCIDeviceAddressAsString(&info->addr.pci)))
return -1;
for (i = 0; i < domainDef->ncontrollers; i++) {
- virDomainControllerDefPtr cont = domainDef->controllers[i];
+ virDomainControllerDef *cont = domainDef->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
cont->idx == info->addr.pci.bus) {
/**
* qemuBuildVirtioDevStr
- * @buf: virBufferPtr to append the built string
+ * @buf: virBuffer * to append the built string
* @baseName: qemu virtio device basename string. Ex: virtio-rng for <rng>
* @qemuCaps: virQEMUCapPtr
* @devtype: virDomainDeviceType of the device. Ex: VIR_DOMAIN_DEVICE_TYPE_RNG
- * @devdata: *DefPtr of the device definition
+ * @devdata: *Def * of the device definition
*
* Build the qemu virtio -device name from the passed parameters. Currently
* this is mostly about attaching the correct string prefix to @baseName for
* Returns: -1 on failure, 0 on success
*/
static int
-qemuBuildVirtioDevStr(virBufferPtr buf,
+qemuBuildVirtioDevStr(virBuffer *buf,
const char *baseName,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
virDomainDeviceType devtype,
void *devdata)
{
const char *implName = NULL;
virDomainDeviceDef device = { .type = devtype };
- virDomainDeviceInfoPtr info;
+ virDomainDeviceInfo *info;
bool has_tmodel, has_ntmodel;
virDomainDeviceSetData(&device, devdata);
}
static void
-qemuBuildVirtioOptionsStr(virBufferPtr buf,
- virDomainVirtioOptionsPtr virtio)
+qemuBuildVirtioOptionsStr(virBuffer *buf,
+ virDomainVirtioOptions *virtio)
{
if (!virtio)
return;
}
static int
-qemuBuildRomStr(virBufferPtr buf,
- virDomainDeviceInfoPtr info)
+qemuBuildRomStr(virBuffer *buf,
+ virDomainDeviceInfo *info)
{
if (info->romenabled || info->rombar || info->romfile) {
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
}
static int
-qemuBuildIoEventFdStr(virBufferPtr buf,
+qemuBuildIoEventFdStr(virBuffer *buf,
virTristateSwitch use,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (use && virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
virBufferAsprintf(buf, ",ioeventfd=%s",
* returns -1 on failure error message set.
*/
int
-qemuBuildSecretInfoProps(qemuDomainSecretInfoPtr secinfo,
- virJSONValuePtr *propsret)
+qemuBuildSecretInfoProps(qemuDomainSecretInfo *secinfo,
+ virJSONValue **propsret)
{
g_autofree char *keyid = NULL;
* Returns 0 on success, -1 w/ error message on failure
*/
static int
-qemuBuildObjectSecretCommandLine(virCommandPtr cmd,
- qemuDomainSecretInfoPtr secinfo,
+qemuBuildObjectSecretCommandLine(virCommand *cmd,
+ qemuDomainSecretInfo *secinfo,
virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
* -1 and error message if fail to add secret information
*/
static int
-qemuBuildGeneralSecinfoURI(virURIPtr uri,
- qemuDomainSecretInfoPtr secinfo)
+qemuBuildGeneralSecinfoURI(virURI *uri,
+ qemuDomainSecretInfo *secinfo)
{
if (!secinfo)
return 0;
* -1 and error message if fail to add secret information
*/
static int
-qemuBuildRBDSecinfoURI(virBufferPtr buf,
- qemuDomainSecretInfoPtr secinfo)
+qemuBuildRBDSecinfoURI(virBuffer *buf,
+ qemuDomainSecretInfo *secinfo)
{
g_autofree char *base64secret = NULL;
bool verifypeer,
const char *alias,
const char *secalias,
- virQEMUCapsPtr qemuCaps,
- virJSONValuePtr *propsret)
+ virQEMUCaps *qemuCaps,
+ virJSONValue **propsret)
{
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_TLS_CREDS_X509)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
* Returns 0 on success, -1 on failure with error set.
*/
static int
-qemuBuildTLSx509CommandLine(virCommandPtr cmd,
+qemuBuildTLSx509CommandLine(virCommand *cmd,
const char *tlspath,
bool isListen,
bool verifypeer,
const char *certEncSecretAlias,
const char *alias,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autoptr(virJSONValue) props = NULL;
static char *
-qemuBuildNetworkDriveURI(virStorageSourcePtr src,
- qemuDomainSecretInfoPtr secinfo)
+qemuBuildNetworkDriveURI(virStorageSource *src,
+ qemuDomainSecretInfo *secinfo)
{
g_autoptr(virURI) uri = NULL;
static char *
-qemuBuildNetworkDriveStr(virStorageSourcePtr src,
- qemuDomainSecretInfoPtr secinfo)
+qemuBuildNetworkDriveStr(virStorageSource *src,
+ qemuDomainSecretInfo *secinfo)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
int
-qemuGetDriveSourceString(virStorageSourcePtr src,
- qemuDomainSecretInfoPtr secinfo,
+qemuGetDriveSourceString(virStorageSource *src,
+ qemuDomainSecretInfo *secinfo,
char **source)
{
int actualType = virStorageSourceGetActualType(src);
bool
-qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDefPtr disk)
+qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDef *disk)
{
return !!disk->blkdeviotune.group_name ||
virDomainBlockIoTuneInfoHasAny(&disk->blkdeviotune);
* which automatically enforces FIPS compliance.
*/
bool
-qemuCheckFips(virDomainObjPtr vm)
+qemuCheckFips(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_FIPS))
return false;
* the legacy representation.
*/
static bool
-qemuDiskSourceNeedsProps(virStorageSourcePtr src,
- virQEMUCapsPtr qemuCaps)
+qemuDiskSourceNeedsProps(virStorageSource *src,
+ virQEMUCaps *qemuCaps)
{
int actualType = virStorageSourceGetActualType(src);
* Returns the disk source struct wrapped so that it can be used as disk source
* directly by converting it from json.
*/
-static virJSONValuePtr
-qemuDiskSourceGetProps(virStorageSourcePtr src)
+static virJSONValue *
+qemuDiskSourceGetProps(virStorageSource *src)
{
g_autoptr(virJSONValue) props = NULL;
- virJSONValuePtr ret;
+ virJSONValue *ret;
if (!(props = qemuBlockStorageSourceGetBackendProps(src,
QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_LEGACY)))
static int
-qemuBuildDriveSourcePR(virBufferPtr buf,
- virDomainDiskDefPtr disk)
+qemuBuildDriveSourcePR(virBuffer *buf,
+ virDomainDiskDef *disk)
{
g_autofree char *alias = NULL;
const char *defaultAlias = NULL;
static int
-qemuBuildDriveSourceStr(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
- virBufferPtr buf)
+qemuBuildDriveSourceStr(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
+ virBuffer *buf)
{
int actualType = virStorageSourceGetActualType(disk->src);
- qemuDomainStorageSourcePrivatePtr srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(disk->src);
- qemuDomainSecretInfoPtr secinfo = NULL;
- qemuDomainSecretInfoPtr encinfo = NULL;
+ qemuDomainStorageSourcePrivate *srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(disk->src);
+ qemuDomainSecretInfo *secinfo = NULL;
+ qemuDomainSecretInfo *encinfo = NULL;
g_autoptr(virJSONValue) srcprops = NULL;
g_autofree char *source = NULL;
bool rawluks = false;
static void
-qemuBuildDiskThrottling(virDomainDiskDefPtr disk,
- virBufferPtr buf)
+qemuBuildDiskThrottling(virDomainDiskDef *disk,
+ virBuffer *buf)
{
#define IOTUNE_ADD(_field, _label) \
if (disk->blkdeviotune._field) { \
static void
-qemuBuildDiskFrontendAttributeErrorPolicy(virDomainDiskDefPtr disk,
- virBufferPtr buf)
+qemuBuildDiskFrontendAttributeErrorPolicy(virDomainDiskDef *disk,
+ virBuffer *buf)
{
const char *wpolicy = NULL;
const char *rpolicy = NULL;
static void
-qemuBuildDiskFrontendAttributes(virDomainDiskDefPtr disk,
- virBufferPtr buf)
+qemuBuildDiskFrontendAttributes(virDomainDiskDef *disk,
+ virBuffer *buf)
{
/* generate geometry command string */
if (disk->geometry.cylinders > 0 &&
static char *
-qemuBuildDriveStr(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps)
+qemuBuildDriveStr(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
int detect_zeroes = virDomainDiskGetDetectZeroesMode(disk->discard,
static bool
qemuCheckIOThreads(const virDomainDef *def,
- virDomainDiskDefPtr disk)
+ virDomainDiskDef *disk)
{
/* Right "type" of disk" */
switch ((virDomainDiskBus)disk->bus) {
static int
-qemuBuildDriveDevCacheStr(virDomainDiskDefPtr disk,
- virBufferPtr buf,
- virQEMUCapsPtr qemuCaps)
+qemuBuildDriveDevCacheStr(virDomainDiskDef *disk,
+ virBuffer *buf,
+ virQEMUCaps *qemuCaps)
{
bool wb;
char *
qemuBuildDiskDeviceStr(const virDomainDef *def,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
unsigned int bootindex,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
const char *contAlias;
}
char *
-qemuBuildZPCIDevStr(virDomainDeviceInfoPtr dev)
+qemuBuildZPCIDevStr(virDomainDeviceInfo *dev)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static int
-qemuCommandAddZPCIDevice(virCommandPtr cmd,
- virDomainDeviceInfoPtr dev)
+qemuCommandAddZPCIDevice(virCommand *cmd,
+ virDomainDeviceInfo *dev)
{
g_autofree char *devstr = NULL;
}
static int
-qemuCommandAddExtDevice(virCommandPtr cmd,
- virDomainDeviceInfoPtr dev)
+qemuCommandAddExtDevice(virCommand *cmd,
+ virDomainDeviceInfo *dev)
{
if (dev->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
dev->addr.pci.extFlags == VIR_PCI_ADDRESS_EXTENSION_NONE) {
}
static int
-qemuBuildFloppyCommandLineControllerOptions(virCommandPtr cmd,
+qemuBuildFloppyCommandLineControllerOptions(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int bootFloppy)
{
g_auto(virBuffer) fdc_opts = VIR_BUFFER_INITIALIZER;
g_autofree char *backendAlias = NULL;
g_autofree char *backendStr = NULL;
g_autofree char *bootindexStr = NULL;
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (disk->bus != VIR_DOMAIN_DISK_BUS_FDC)
continue;
static int
-qemuBuildObjectCommandline(virCommandPtr cmd,
- virJSONValuePtr objProps,
+qemuBuildObjectCommandline(virCommand *cmd,
+ virJSONValue *objProps,
virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildBlockStorageSourceAttachDataCommandline(virCommandPtr cmd,
- qemuBlockStorageSourceAttachDataPtr data,
+qemuBuildBlockStorageSourceAttachDataCommandline(virCommand *cmd,
+ qemuBlockStorageSourceAttachData *data,
virQEMUCaps *qemuCaps)
{
char *tmp;
static int
-qemuBuildDiskSourceCommandLine(virCommandPtr cmd,
- virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps)
+qemuBuildDiskSourceCommandLine(virCommand *cmd,
+ virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
g_autoptr(virJSONValue) copyOnReadProps = NULL;
static int
-qemuBuildDiskCommandLine(virCommandPtr cmd,
+qemuBuildDiskCommandLine(virCommand *cmd,
const virDomainDef *def,
- virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
+ virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
unsigned int bootindex)
{
g_autofree char *optstr = NULL;
static int
-qemuBuildDisksCommandLine(virCommandPtr cmd,
+qemuBuildDisksCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
unsigned int bootCD = 0;
return -1;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
unsigned int bootindex = 0;
if (disk->info.bootIndex) {
static int
-qemuBuildVHostUserFsCommandLine(virCommandPtr cmd,
+qemuBuildVHostUserFsCommandLine(virCommand *cmd,
virDomainFSDef *fs,
const virDomainDef *def,
- qemuDomainObjPrivatePtr priv)
+ qemuDomainObjPrivate *priv)
{
g_autofree char *chardev_alias = NULL;
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
static char *
-qemuBuildFSStr(virDomainFSDefPtr fs)
+qemuBuildFSStr(virDomainFSDef *fs)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
const char *wrpolicy = virDomainFSWrpolicyTypeToString(fs->wrpolicy);
static char *
qemuBuildFSDevStr(const virDomainDef *def,
- virDomainFSDefPtr fs,
- virQEMUCapsPtr qemuCaps)
+ virDomainFSDef *fs,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildFSDevCommandLine(virCommandPtr cmd,
- virDomainFSDefPtr fs,
+qemuBuildFSDevCommandLine(virCommand *cmd,
+ virDomainFSDef *fs,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_autofree char *fsdevstr = NULL;
g_autofree char *devicestr = NULL;
static int
-qemuBuildFilesystemCommandLine(virCommandPtr cmd,
+qemuBuildFilesystemCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
- qemuDomainObjPrivatePtr priv)
+ virQEMUCaps *qemuCaps,
+ qemuDomainObjPrivate *priv)
{
size_t i;
static int
qemuBuildUSBControllerDevStr(const virDomainDef *domainDef,
- virDomainControllerDefPtr def,
- virQEMUCapsPtr qemuCaps,
+ virDomainControllerDef *def,
+ virQEMUCaps *qemuCaps,
virBuffer *buf)
{
const char *smodel;
*/
int
qemuBuildControllerDevStr(const virDomainDef *domainDef,
- virDomainControllerDefPtr def,
- virQEMUCapsPtr qemuCaps,
+ virDomainControllerDef *def,
+ virQEMUCaps *qemuCaps,
char **devstr)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildLegacyUSBControllerCommandLine(virCommandPtr cmd,
+qemuBuildLegacyUSBControllerCommandLine(virCommand *cmd,
const virDomainDef *def)
{
size_t i;
size_t nusb = 0;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_USB)
continue;
static int
-qemuBuildControllersByTypeCommandLine(virCommandPtr cmd,
+qemuBuildControllersByTypeCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
virDomainControllerType type)
{
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
g_autofree char *devstr = NULL;
if (cont->type != type)
static int
-qemuBuildControllersCommandLine(virCommandPtr cmd,
+qemuBuildControllersCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
int contOrder[] = {
static int
-qemuBuildMemoryBackendPropsShare(virJSONValuePtr props,
+qemuBuildMemoryBackendPropsShare(virJSONValue *props,
virDomainMemoryAccess memAccess)
{
switch (memAccess) {
static int
-qemuBuildMemoryGetDefaultPagesize(virQEMUDriverConfigPtr cfg,
+qemuBuildMemoryGetDefaultPagesize(virQEMUDriverConfig *cfg,
unsigned long long *pagesize)
{
- virHugeTLBFSPtr p;
+ virHugeTLBFS *p;
if (!cfg->nhugetlbfs) {
virReportError(VIR_ERR_INTERNAL_ERROR,
* -1 on error.
*/
int
-qemuBuildMemoryBackendProps(virJSONValuePtr *backendProps,
+qemuBuildMemoryBackendProps(virJSONValue **backendProps,
const char *alias,
- virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+ virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const virDomainDef *def,
const virDomainMemoryDef *mem,
bool force,
size_t i;
g_autofree char *memPath = NULL;
bool prealloc = false;
- virBitmapPtr nodemask = NULL;
+ virBitmap *nodemask = NULL;
int rc;
g_autoptr(virJSONValue) props = NULL;
bool nodeSpecified = virDomainNumatuneNodeSpecified(def->numa, mem->targetNode);
mode = VIR_DOMAIN_NUMATUNE_MEM_STRICT;
if (pagesize == 0) {
- virDomainHugePagePtr master_hugepage = NULL;
- virDomainHugePagePtr hugepage = NULL;
+ virDomainHugePage *master_hugepage = NULL;
+ virDomainHugePage *hugepage = NULL;
bool thisHugepage = false;
/* Find the huge page size we want to use */
static int
-qemuBuildMemoryCellBackendStr(virDomainDefPtr def,
- virQEMUDriverConfigPtr cfg,
+qemuBuildMemoryCellBackendStr(virDomainDef *def,
+ virQEMUDriverConfig *cfg,
size_t cell,
- qemuDomainObjPrivatePtr priv,
- virBufferPtr buf)
+ qemuDomainObjPrivate *priv,
+ virBuffer *buf)
{
g_autoptr(virJSONValue) props = NULL;
g_autofree char *alias = NULL;
static int
-qemuBuildMemoryDimmBackendStr(virBufferPtr buf,
- virDomainMemoryDefPtr mem,
- virDomainDefPtr def,
- virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv)
+qemuBuildMemoryDimmBackendStr(virBuffer *buf,
+ virDomainMemoryDef *mem,
+ virDomainDef *def,
+ virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv)
{
g_autoptr(virJSONValue) props = NULL;
g_autofree char *alias = NULL;
char *
qemuBuildMemoryDeviceStr(const virDomainDef *def,
- virDomainMemoryDefPtr mem,
- virQEMUCapsPtr qemuCaps)
+ virDomainMemoryDef *mem,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *device = NULL;
static char *
-qemuBuildLegacyNicStr(virDomainNetDefPtr net)
+qemuBuildLegacyNicStr(virDomainNetDef *net)
{
char *str;
char macaddr[VIR_MAC_STRING_BUFLEN];
char *
-qemuBuildNicDevStr(virDomainDefPtr def,
- virDomainNetDefPtr net,
+qemuBuildNicDevStr(virDomainDef *def,
+ virDomainNetDef *net,
unsigned int bootindex,
size_t vhostfdSize,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool usingVirtio = false;
}
-virJSONValuePtr
-qemuBuildHostNetStr(virDomainNetDefPtr net,
+virJSONValue *
+qemuBuildHostNetStr(virDomainNetDef *net,
char **tapfd,
size_t tapfdSize,
char **vhostfd,
char *
qemuBuildWatchdogDevStr(const virDomainDef *def,
- virDomainWatchdogDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainWatchdogDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildWatchdogCommandLine(virCommandPtr cmd,
+qemuBuildWatchdogCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
- virDomainWatchdogDefPtr watchdog = def->watchdog;
+ virDomainWatchdogDef *watchdog = def->watchdog;
g_autofree char *optstr = NULL;
const char *action;
int actualAction;
static int
-qemuBuildMemballoonCommandLine(virCommandPtr cmd,
+qemuBuildMemballoonCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static char *
-qemuBuildNVRAMDevStr(virDomainNVRAMDefPtr dev)
+qemuBuildNVRAMDevStr(virDomainNVRAMDef *dev)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildNVRAMCommandLine(virCommandPtr cmd,
+qemuBuildNVRAMCommandLine(virCommand *cmd,
const virDomainDef *def)
{
g_autofree char *optstr = NULL;
static char *
qemuBuildVirtioInputDevStr(const virDomainDef *def,
- virDomainInputDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainInputDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static char *
qemuBuildUSBInputDevStr(const virDomainDef *def,
- virDomainInputDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainInputDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int
qemuBuildInputDevStr(char **devstr,
const virDomainDef *def,
- virDomainInputDefPtr input,
- virQEMUCapsPtr qemuCaps)
+ virDomainInputDef *input,
+ virQEMUCaps *qemuCaps)
{
switch (input->bus) {
case VIR_DOMAIN_INPUT_BUS_USB:
static int
-qemuBuildInputCommandLine(virCommandPtr cmd,
+qemuBuildInputCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < def->ninputs; i++) {
- virDomainInputDefPtr input = def->inputs[i];
+ virDomainInputDef *input = def->inputs[i];
g_autofree char *devstr = NULL;
if (qemuCommandAddExtDevice(cmd, &input->info) < 0)
static char *
qemuGetAudioIDString(const virDomainDef *def, int id)
{
- virDomainAudioDefPtr audio = virDomainDefFindAudioByID(def, id);
+ virDomainAudioDef *audio = virDomainDefFindAudioByID(def, id);
if (!audio) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unable to find audio backend for sound device"));
static char *
qemuBuildSoundDevStr(const virDomainDef *def,
- virDomainSoundDefPtr sound,
- virQEMUCapsPtr qemuCaps)
+ virDomainSoundDef *sound,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *model = NULL;
static char *
qemuBuildSoundCodecStr(const virDomainDef *def,
- virDomainSoundDefPtr sound,
- virDomainSoundCodecDefPtr codec,
- virQEMUCapsPtr qemuCaps)
+ virDomainSoundDef *sound,
+ virDomainSoundCodecDef *codec,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *stype;
static int
-qemuBuildSoundCommandLine(virCommandPtr cmd,
+qemuBuildSoundCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i, j;
for (i = 0; i < def->nsounds; i++) {
- virDomainSoundDefPtr sound = def->sounds[i];
+ virDomainSoundDef *sound = def->sounds[i];
g_autofree char *str = NULL;
/* Sadly pcspk device doesn't use -device syntax. Fortunately
static char *
qemuBuildDeviceVideoStr(const virDomainDef *def,
- virDomainVideoDefPtr video,
- virQEMUCapsPtr qemuCaps)
+ virDomainVideoDef *video,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *model = NULL;
static int
-qemuBuildVgaVideoCommand(virCommandPtr cmd,
- virDomainVideoDefPtr video,
- virQEMUCapsPtr qemuCaps)
+qemuBuildVgaVideoCommand(virCommand *cmd,
+ virDomainVideoDef *video,
+ virQEMUCaps *qemuCaps)
{
const char *dev;
const char *vgastr = qemuVideoTypeToString(video->type);
static char *
qemuBuildVhostUserChardevStr(const char *alias,
int *fd,
- virCommandPtr cmd)
+ virCommand *cmd)
{
g_autofree char *chardev_alias = qemuDomainGetVhostUserChrAlias(alias);
char *chardev = NULL;
static int
-qemuBuildVideoCommandLine(virCommandPtr cmd,
+qemuBuildVideoCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < def->nvideos; i++) {
g_autofree char *chardev = NULL;
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
if (!(chardev = qemuBuildVhostUserChardevStr(video->info.alias,
for (i = 0; i < def->nvideos; i++) {
g_autofree char *str = NULL;
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->type == VIR_DOMAIN_VIDEO_TYPE_NONE)
continue;
char *
qemuBuildPCIHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
+ virDomainHostdevDef *dev,
unsigned int bootIndex, /* used iff dev->info->bootIndex == 0 */
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
int backend = pcisrc->backend;
- virDomainNetTeamingInfoPtr teaming;
+ virDomainNetTeamingInfo *teaming;
/* caller has to assign proper passthrough backend type */
switch ((virDomainHostdevSubsysPCIBackendType)backend) {
char *
qemuBuildUSBHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
virBufferAddLit(&buf, "usb-host");
if (!dev->missing) {
static char *
qemuBuildHubDevStr(const virDomainDef *def,
- virDomainHubDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainHubDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildHubCommandLine(virCommandPtr cmd,
+qemuBuildHubCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < def->nhubs; i++) {
- virDomainHubDefPtr hub = def->hubs[i];
+ virDomainHubDef *hub = def->hubs[i];
g_autofree char *optstr = NULL;
virCommandAddArg(cmd, "-device");
static char *
-qemuBuildSCSIiSCSIHostdevDrvStr(virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+qemuBuildSCSIiSCSIHostdevDrvStr(virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autofree char *netsource = NULL;
g_autoptr(virJSONValue) srcprops = NULL;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
- qemuDomainStorageSourcePrivatePtr srcPriv =
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
+ qemuDomainStorageSourcePrivate *srcPriv =
QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(iscsisrc->src);
if (qemuDiskSourceNeedsProps(iscsisrc->src, qemuCaps)) {
char *
qemuBuildSCSIVHostHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps,
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps,
char *vhostfdName)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
if (qemuBuildVirtioDevStr(&buf, "vhost-scsi", qemuCaps,
VIR_DOMAIN_DEVICE_HOSTDEV, dev) < 0) {
}
static char *
-qemuBuildSCSIHostdevDrvStr(virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+qemuBuildSCSIHostdevDrvStr(virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autofree char *source = NULL;
g_autofree char *drivealias = NULL;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
if (!(source = qemuBuildSCSIiSCSIHostdevDrvStr(dev, qemuCaps)))
char *
qemuBuildSCSIHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
+ virDomainHostdevDef *dev,
const char *backendAlias)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static int
-qemuBuildChrChardevFileStr(virLogManagerPtr logManager,
- virCommandPtr cmd,
+qemuBuildChrChardevFileStr(virLogManager *logManager,
+ virCommand *cmd,
const virDomainDef *def,
- virBufferPtr buf,
+ virBuffer *buf,
const char *filearg, const char *fileval,
const char *appendarg, int appendval)
{
static void
-qemuBuildChrChardevReconnectStr(virBufferPtr buf,
+qemuBuildChrChardevReconnectStr(virBuffer *buf,
const virDomainChrSourceReconnectDef *def)
{
if (def->enabled == VIR_TRISTATE_BOOL_YES) {
/* This function outputs a -chardev command line option which describes only the
* host side of the character device */
static char *
-qemuBuildChrChardevStr(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildChrChardevStr(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
const virDomainChrSourceDef *dev,
const char *alias,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int cdevflags)
{
- qemuDomainChrSourcePrivatePtr chrSourcePriv = QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);
+ qemuDomainChrSourcePrivate *chrSourcePriv = QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool telnet;
g_autofree char *charAlias = NULL;
virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_FD_PASS)) {
int fd;
- if (qemuSecuritySetSocketLabel(secManager, (virDomainDefPtr)def) < 0)
+ if (qemuSecuritySetSocketLabel(secManager, (virDomainDef *)def) < 0)
return NULL;
fd = qemuOpenChrChardevUNIXSocket(dev);
- if (qemuSecurityClearSocketLabel(secManager, (virDomainDefPtr)def) < 0) {
+ if (qemuSecurityClearSocketLabel(secManager, (virDomainDef *)def) < 0) {
VIR_FORCE_CLOSE(fd);
return NULL;
}
static const char *
-qemuBuildHostdevMdevModelTypeString(virDomainHostdevSubsysMediatedDevPtr mdev)
+qemuBuildHostdevMdevModelTypeString(virDomainHostdevSubsysMediatedDev *mdev)
{
/* when the 'ramfb' attribute is set, we must use the nohotplug variant
* rather than 'vfio-pci' */
char *
qemuBuildHostdevMediatedDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
g_autofree char *mdevPath = NULL;
const char *dev_str = NULL;
qemuBlockStorageSourceAttachData *
-qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps)
+qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps)
{
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
g_autoptr(qemuBlockStorageSourceAttachData) ret = g_new0(qemuBlockStorageSourceAttachData, 1);
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV_HOSTDEV_SCSI)) {
- virStorageSourcePtr src;
- qemuDomainStorageSourcePrivatePtr srcpriv;
+ virStorageSource *src;
+ qemuDomainStorageSourcePrivate *srcpriv;
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE:
qemuBlockStorageSourceAttachData *
-qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDefPtr hostdev,
+qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDef *hostdev,
const char **backendAlias,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
g_autoptr(qemuBlockStorageSourceAttachData) ret = g_new0(qemuBlockStorageSourceAttachData, 1);
- virStorageSourcePtr src = NULL;
+ virStorageSource *src = NULL;
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV_HOSTDEV_SCSI)) {
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
static int
-qemuBuildHostdevSCSICommandLine(virCommandPtr cmd,
+qemuBuildHostdevSCSICommandLine(virCommand *cmd,
const virDomainDef *def,
- virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps)
+ virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
g_autofree char *devstr = NULL;
static int
-qemuBuildHostdevCommandLine(virCommandPtr cmd,
+qemuBuildHostdevCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int *bootHostdevNet)
{
size_t i;
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
- virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &subsys->u.mdev;
+ virDomainHostdevDef *hostdev = def->hostdevs[i];
+ virDomainHostdevSubsys *subsys = &hostdev->source.subsys;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &subsys->u.mdev;
g_autofree char *devstr = NULL;
g_autofree char *vhostfdName = NULL;
unsigned int bootIndex = hostdev->info->bootIndex;
static int
-qemuBuildMonitorCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
- qemuDomainObjPrivatePtr priv)
+qemuBuildMonitorCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
+ virDomainDef *def,
+ qemuDomainObjPrivate *priv)
{
g_autofree char *chrdev = NULL;
unsigned int cdevflags = QEMU_BUILD_CHARDEV_TCP_NOWAIT |
static char *
qemuBuildVirtioSerialPortDevStr(const virDomainDef *def,
- virDomainChrDefPtr dev)
+ virDomainChrDef *dev)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *contAlias;
}
static char *
-qemuBuildSclpDevStr(virDomainChrDefPtr dev)
+qemuBuildSclpDevStr(virDomainChrDef *dev)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE) {
static int
-qemuBuildRNGBackendChrdevStr(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildRNGBackendChrdevStr(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virDomainRNGDefPtr rng,
- virQEMUCapsPtr qemuCaps,
+ virDomainRNGDef *rng,
+ virQEMUCaps *qemuCaps,
char **chr,
bool chardevStdioLogd)
{
int
-qemuBuildRNGBackendProps(virDomainRNGDefPtr rng,
- virJSONValuePtr *props)
+qemuBuildRNGBackendProps(virDomainRNGDef *rng,
+ virJSONValue **props)
{
g_autofree char *objAlias = NULL;
g_autofree char *charBackendAlias = NULL;
char *
qemuBuildRNGDevStr(const virDomainDef *def,
- virDomainRNGDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainRNGDef *dev,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildRNGCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildRNGCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
for (i = 0; i < def->nrngs; i++) {
g_autoptr(virJSONValue) props = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainRNGDefPtr rng = def->rngs[i];
+ virDomainRNGDef *rng = def->rngs[i];
g_autofree char *chardev = NULL;
g_autofree char *devstr = NULL;
int rc;
static char *
-qemuBuildSmbiosBiosStr(virSysinfoBIOSDefPtr def)
+qemuBuildSmbiosBiosStr(virSysinfoBIOSDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static char *
-qemuBuildSmbiosSystemStr(virSysinfoSystemDefPtr def,
+qemuBuildSmbiosSystemStr(virSysinfoSystemDef *def,
bool skip_uuid)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static char *
-qemuBuildSmbiosBaseBoardStr(virSysinfoBaseBoardDefPtr def)
+qemuBuildSmbiosBaseBoardStr(virSysinfoBaseBoardDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static char *
-qemuBuildSmbiosOEMStringsStr(virSysinfoOEMStringsDefPtr def)
+qemuBuildSmbiosOEMStringsStr(virSysinfoOEMStringsDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
static char *
-qemuBuildSmbiosChassisStr(virSysinfoChassisDefPtr def)
+qemuBuildSmbiosChassisStr(virSysinfoChassisDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildSmbiosCommandLine(virCommandPtr cmd,
- virQEMUDriverPtr driver,
+qemuBuildSmbiosCommandLine(virCommand *cmd,
+ virQEMUDriver *driver,
const virDomainDef *def)
{
size_t i;
- virSysinfoDefPtr source = NULL;
+ virSysinfoDef *source = NULL;
bool skip_uuid = false;
if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_NONE ||
static int
-qemuBuildSysinfoCommandLine(virCommandPtr cmd,
+qemuBuildSysinfoCommandLine(virCommand *cmd,
const virDomainDef *def)
{
size_t i;
static int
-qemuBuildVMGenIDCommandLine(virCommandPtr cmd,
+qemuBuildVMGenIDCommandLine(virCommand *cmd,
const virDomainDef *def)
{
g_auto(virBuffer) opts = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildSgaCommandLine(virCommandPtr cmd,
+qemuBuildSgaCommandLine(virCommand *cmd,
const virDomainDef *def)
{
/* Serial graphics adapter */
static char *
-qemuBuildClockArgStr(virDomainClockDefPtr def)
+qemuBuildClockArgStr(virDomainClockDef *def)
{
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
* virDomainDef is not const here.
*/
static int
-qemuBuildClockCommandLine(virCommandPtr cmd,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuBuildClockCommandLine(virCommand *cmd,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
size_t i;
g_autofree char *rtcopt = NULL;
static int
-qemuBuildPMCommandLine(virCommandPtr cmd,
+qemuBuildPMCommandLine(virCommand *cmd,
const virDomainDef *def,
- qemuDomainObjPrivatePtr priv)
+ qemuDomainObjPrivate *priv)
{
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
/* Only add -no-reboot option if each event destroys domain */
if (priv->allowReboot == VIR_TRISTATE_BOOL_NO)
static int
-qemuBuildBootCommandLine(virCommandPtr cmd,
+qemuBuildBootCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) boot_buf = VIR_BUFFER_INITIALIZER;
g_autofree char *boot_opts_str = NULL;
static int
-qemuBuildIOMMUCommandLine(virCommandPtr cmd,
+qemuBuildIOMMUCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const virDomainIOMMUDef *iommu = def->iommu;
static int
-qemuBuildGlobalControllerCommandLine(virCommandPtr cmd,
+qemuBuildGlobalControllerCommandLine(virCommand *cmd,
const virDomainDef *def)
{
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
cont->opts.pciopts.pcihole64) {
const char *hoststr = NULL;
static void
-qemuBuildCpuFeature(virQEMUCapsPtr qemuCaps,
- virBufferPtr buf,
+qemuBuildCpuFeature(virQEMUCaps *qemuCaps,
+ virBuffer *buf,
const char *name,
bool state)
{
static int
-qemuBuildCpuModelArgStr(virQEMUDriverPtr driver,
+qemuBuildCpuModelArgStr(virQEMUDriver *driver,
const virDomainDef *def,
- virBufferPtr buf,
- virQEMUCapsPtr qemuCaps)
+ virBuffer *buf,
+ virQEMUCaps *qemuCaps)
{
size_t i;
- virCPUDefPtr cpu = def->cpu;
+ virCPUDef *cpu = def->cpu;
switch ((virCPUMode) cpu->mode) {
case VIR_CPU_MODE_HOST_PASSTHROUGH:
}
static int
-qemuBuildCpuCommandLine(virCommandPtr cmd,
- virQEMUDriverPtr driver,
+qemuBuildCpuCommandLine(virCommand *cmd,
+ virQEMUDriver *driver,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
virArch hostarch = virArchFromHost();
g_autofree char *cpu = NULL;
/* Handle paravirtual timers */
for (i = 0; i < def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = def->clock.timers[i];
+ virDomainTimerDef *timer = def->clock.timers[i];
switch ((virDomainTimerNameType)timer->name) {
case VIR_DOMAIN_TIMER_NAME_KVMCLOCK:
}
if (def->cpu && def->cpu->cache) {
- virCPUCacheDefPtr cache = def->cpu->cache;
+ virCPUCacheDef *cache = def->cpu->cache;
bool hostOff = false;
bool l3Off = false;
static bool
-qemuAppendKeyWrapMachineParm(virBuffer *buf, virQEMUCapsPtr qemuCaps,
+qemuAppendKeyWrapMachineParm(virBuffer *buf, virQEMUCaps *qemuCaps,
int flag, const char *pname, int pstate)
{
if (pstate != VIR_TRISTATE_SWITCH_ABSENT) {
}
static bool
-qemuAppendKeyWrapMachineParms(virBuffer *buf, virQEMUCapsPtr qemuCaps,
+qemuAppendKeyWrapMachineParms(virBuffer *buf, virQEMUCaps *qemuCaps,
const virDomainKeyWrapDef *keywrap)
{
if (!qemuAppendKeyWrapMachineParm(buf, qemuCaps, QEMU_CAPS_AES_KEY_WRAP,
size_t i = 0;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (disk->info.bootIndex == 1 && disk->info.loadparm) {
virBufferAsprintf(buf, ",loadparm=%s", disk->info.loadparm);
/* Network boot device */
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (net->info.bootIndex == 1 && net->info.loadparm) {
virBufferAsprintf(buf, ",loadparm=%s", net->info.loadparm);
static int
-qemuBuildNameCommandLine(virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildNameCommandLine(virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static int
-qemuBuildMachineCommandLine(virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildMachineCommandLine(virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
- qemuDomainObjPrivatePtr priv)
+ virQEMUCaps *qemuCaps,
+ qemuDomainObjPrivate *priv)
{
virTristateSwitch vmport = def->features[VIR_DOMAIN_FEATURE_VMPORT];
virTristateSwitch smm = def->features[VIR_DOMAIN_FEATURE_SMM];
- virCPUDefPtr cpu = def->cpu;
+ virCPUDef *cpu = def->cpu;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
static void
-qemuBuildTSEGCommandLine(virCommandPtr cmd,
+qemuBuildTSEGCommandLine(virCommand *cmd,
const virDomainDef *def)
{
if (!def->tseg_specified)
static int
-qemuBuildSmpCommandLine(virCommandPtr cmd,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuBuildSmpCommandLine(virCommand *cmd,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
unsigned int nvcpus = 0;
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t i;
/* count non-hotpluggable enabled vcpus. Hotpluggable ones will be added
static int
qemuBuildMemPathStr(const virDomainDef *def,
- virCommandPtr cmd,
- qemuDomainObjPrivatePtr priv)
+ virCommand *cmd,
+ qemuDomainObjPrivate *priv)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
const long system_page_size = virGetSystemPageSizeKB();
static int
-qemuBuildMemCommandLineMemoryDefaultBackend(virCommandPtr cmd,
+qemuBuildMemCommandLineMemoryDefaultBackend(virCommand *cmd,
const virDomainDef *def,
- qemuDomainObjPrivatePtr priv,
+ qemuDomainObjPrivate *priv,
const char *defaultRAMid)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
static int
-qemuBuildMemCommandLine(virCommandPtr cmd,
+qemuBuildMemCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
- qemuDomainObjPrivatePtr priv)
+ virQEMUCaps *qemuCaps,
+ qemuDomainObjPrivate *priv)
{
const char *defaultRAMid = NULL;
static int
-qemuBuildIOThreadCommandLine(virCommandPtr cmd,
+qemuBuildIOThreadCommandLine(virCommand *cmd,
const virDomainDef *def,
virQEMUCaps *qemuCaps)
{
static int
-qemuBuilNumaCellCache(virCommandPtr cmd,
+qemuBuilNumaCellCache(virCommand *cmd,
const virDomainDef *def,
size_t cell)
{
"third-level");
static int
-qemuBuildNumaHMATCommandLine(virCommandPtr cmd,
+qemuBuildNumaHMATCommandLine(virCommand *cmd,
const virDomainDef *def)
{
size_t nlatencies;
static int
-qemuBuildNumaCommandLine(virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
- virCommandPtr cmd,
- qemuDomainObjPrivatePtr priv)
+qemuBuildNumaCommandLine(virQEMUDriverConfig *cfg,
+ virDomainDef *def,
+ virCommand *cmd,
+ qemuDomainObjPrivate *priv)
{
size_t i, j;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
char *next = NULL;
- virBufferPtr nodeBackends = NULL;
+ virBuffer *nodeBackends = NULL;
bool needBackend = false;
bool hmat = false;
int rc;
}
for (i = 0; i < ncells; i++) {
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(def->numa, i);
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(def->numa, i);
ssize_t initiator = virDomainNumaGetNodeInitiator(def->numa, i);
if (needBackend) {
static int
-qemuBuildMemoryDeviceCommandLine(virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
- qemuDomainObjPrivatePtr priv)
+qemuBuildMemoryDeviceCommandLine(virCommand *cmd,
+ virQEMUDriverConfig *cfg,
+ virDomainDef *def,
+ qemuDomainObjPrivate *priv)
{
size_t i;
}
static void
-qemuBuildAudioCommonArg(virBufferPtr buf,
+qemuBuildAudioCommonArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOCommonPtr def)
+ virDomainAudioIOCommon *def)
{
if (def->mixingEngine)
virBufferAsprintf(buf, ",%s.mixing-engine=%s", prefix,
}
static void
-qemuBuildAudioALSAArg(virBufferPtr buf,
+qemuBuildAudioALSAArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOALSAPtr def)
+ virDomainAudioIOALSA *def)
{
if (def->dev)
virBufferAsprintf(buf, ",%s.dev=%s", prefix, def->dev);
}
static void
-qemuBuildAudioCoreAudioArg(virBufferPtr buf,
+qemuBuildAudioCoreAudioArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOCoreAudioPtr def)
+ virDomainAudioIOCoreAudio *def)
{
if (def->bufferCount)
virBufferAsprintf(buf, ",%s.buffer-count=%u", prefix, def->bufferCount);
}
static void
-qemuBuildAudioJackArg(virBufferPtr buf,
+qemuBuildAudioJackArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOJackPtr def)
+ virDomainAudioIOJack *def)
{
if (def->serverName)
virBufferAsprintf(buf, ",%s.server-name=%s", prefix, def->serverName);
}
static void
-qemuBuildAudioOSSArg(virBufferPtr buf,
+qemuBuildAudioOSSArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOOSSPtr def)
+ virDomainAudioIOOSS *def)
{
if (def->dev)
virBufferAsprintf(buf, ",%s.dev=%s", prefix, def->dev);
}
static void
-qemuBuildAudioPulseAudioArg(virBufferPtr buf,
+qemuBuildAudioPulseAudioArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOPulseAudioPtr def)
+ virDomainAudioIOPulseAudio *def)
{
if (def->name)
virBufferAsprintf(buf, ",%s.name=%s", prefix, def->name);
}
static void
-qemuBuildAudioSDLArg(virBufferPtr buf,
+qemuBuildAudioSDLArg(virBuffer *buf,
const char *prefix,
- virDomainAudioIOSDLPtr def)
+ virDomainAudioIOSDL *def)
{
if (def->bufferCount)
virBufferAsprintf(buf, ",%s.buffer-count=%u", prefix, def->bufferCount);
}
static int
-qemuBuildAudioCommandLineArg(virCommandPtr cmd,
- virDomainAudioDefPtr def)
+qemuBuildAudioCommandLineArg(virCommand *cmd,
+ virDomainAudioDef *def)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static int
-qemuBuildAudioCommandLineArgs(virCommandPtr cmd,
- virDomainDefPtr def)
+qemuBuildAudioCommandLineArgs(virCommand *cmd,
+ virDomainDef *def)
{
size_t i;
for (i = 0; i < def->naudios; i++) {
}
static void
-qemuBuildAudioCommonEnv(virCommandPtr cmd,
+qemuBuildAudioCommonEnv(virCommand *cmd,
const char *prefix,
- virDomainAudioIOCommonPtr def)
+ virDomainAudioIOCommon *def)
{
if (def->fixedSettings)
virCommandAddEnvFormat(cmd, "%sFIXED_SETTINGS=%s",
}
static void
-qemuBuildAudioALSAEnv(virCommandPtr cmd,
+qemuBuildAudioALSAEnv(virCommand *cmd,
const char *prefix,
- virDomainAudioIOALSAPtr def)
+ virDomainAudioIOALSA *def)
{
if (def->dev)
virCommandAddEnvFormat(cmd, "%sDEV=%s",
}
static void
-qemuBuildAudioCoreAudioEnv(virCommandPtr cmd,
- virDomainAudioDefPtr def)
+qemuBuildAudioCoreAudioEnv(virCommand *cmd,
+ virDomainAudioDef *def)
{
if (def->backend.coreaudio.output.bufferCount)
virCommandAddEnvFormat(cmd, "QEMU_COREAUDIO_BUFFER_COUNT=%u",
}
static void
-qemuBuildAudioOSSEnv(virCommandPtr cmd,
+qemuBuildAudioOSSEnv(virCommand *cmd,
const char *prefix,
const char *prefix2,
- virDomainAudioIOOSSPtr def)
+ virDomainAudioIOOSS *def)
{
if (def->dev)
virCommandAddEnvFormat(cmd, "%sDEV=%s",
}
static void
-qemuBuildAudioPulseAudioEnv(virCommandPtr cmd,
- virDomainAudioDefPtr def)
+qemuBuildAudioPulseAudioEnv(virCommand *cmd,
+ virDomainAudioDef *def)
{
if (def->backend.pulseaudio.input.name)
virCommandAddEnvPair(cmd, "QEMU_PA_SOURCE",
static int
-qemuBuildAudioCommandLineEnv(virCommandPtr cmd,
- virDomainDefPtr def)
+qemuBuildAudioCommandLineEnv(virCommand *cmd,
+ virDomainDef *def)
{
- virDomainAudioDefPtr audio;
+ virDomainAudioDef *audio;
if (def->naudios != 1)
return 0;
}
static int
-qemuBuildAudioCommandLine(virCommandPtr cmd,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuBuildAudioCommandLine(virCommand *cmd,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_AUDIODEV))
return qemuBuildAudioCommandLineArgs(cmd, def);
static int
-qemuBuildGraphicsSDLCommandLine(virQEMUDriverConfigPtr cfg G_GNUC_UNUSED,
- virCommandPtr cmd,
- virQEMUCapsPtr qemuCaps G_GNUC_UNUSED,
- virDomainGraphicsDefPtr graphics)
+qemuBuildGraphicsSDLCommandLine(virQEMUDriverConfig *cfg G_GNUC_UNUSED,
+ virCommand *cmd,
+ virQEMUCaps *qemuCaps G_GNUC_UNUSED,
+ virDomainGraphicsDef *graphics)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildGraphicsVNCCommandLine(virQEMUDriverConfigPtr cfg,
+qemuBuildGraphicsVNCCommandLine(virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virCommandPtr cmd,
- virQEMUCapsPtr qemuCaps,
- virDomainGraphicsDefPtr graphics)
+ virCommand *cmd,
+ virQEMUCaps *qemuCaps,
+ virDomainGraphicsDef *graphics)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
bool escapeAddr;
if (!(glisten = virDomainGraphicsGetListen(graphics, 0))) {
}
if (cfg->vncTLS) {
- qemuDomainGraphicsPrivatePtr gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
+ qemuDomainGraphicsPrivate *gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
if (gfxPriv->tlsAlias) {
const char *secretAlias = NULL;
static int
-qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfigPtr cfg,
- virCommandPtr cmd,
- virDomainGraphicsDefPtr graphics)
+qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfig *cfg,
+ virCommand *cmd,
+ virDomainGraphicsDef *graphics)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
int port = graphics->data.spice.port;
int tlsPort = graphics->data.spice.tlsPort;
size_t i;
static int
-qemuBuildGraphicsEGLHeadlessCommandLine(virQEMUDriverConfigPtr cfg G_GNUC_UNUSED,
- virCommandPtr cmd,
- virDomainGraphicsDefPtr graphics)
+qemuBuildGraphicsEGLHeadlessCommandLine(virQEMUDriverConfig *cfg G_GNUC_UNUSED,
+ virCommand *cmd,
+ virDomainGraphicsDef *graphics)
{
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
static int
-qemuBuildGraphicsCommandLine(virQEMUDriverConfigPtr cfg,
- virCommandPtr cmd,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuBuildGraphicsCommandLine(virQEMUDriverConfig *cfg,
+ virCommand *cmd,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < def->ngraphics; i++) {
- virDomainGraphicsDefPtr graphics = def->graphics[i];
+ virDomainGraphicsDef *graphics = def->graphics[i];
switch (graphics->type) {
case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
}
static int
-qemuInterfaceVhostuserConnect(virQEMUDriverPtr driver,
- virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virDomainDefPtr def,
- virDomainNetDefPtr net,
- virQEMUCapsPtr qemuCaps,
+qemuInterfaceVhostuserConnect(virQEMUDriver *driver,
+ virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virDomainDef *def,
+ virDomainNetDef *net,
+ virQEMUCaps *qemuCaps,
char **chardev)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
}
static int
-qemuBuildInterfaceCommandLine(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virDomainNetDefPtr net,
- virQEMUCapsPtr qemuCaps,
+qemuBuildInterfaceCommandLine(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virDomainNetDef *net,
+ virQEMUCaps *qemuCaps,
unsigned int bootindex,
virNetDevVPortProfileOp vmop,
bool standalone,
int **nicindexes,
unsigned int flags)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
int ret = -1;
g_autofree char *nic = NULL;
g_autofree char *host = NULL;
virDomainNetType actualType = virDomainNetGetActualType(net);
const virNetDevBandwidth *actualBandwidth;
bool requireNicdev = false;
- qemuSlirpPtr slirp;
+ qemuSlirp *slirp;
size_t i;
g_autoptr(virJSONValue) hostnetprops = NULL;
* API domainSetSecurityTapFDLabel that doesn't use the const format.
*/
static int
-qemuBuildNetCommandLine(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUCapsPtr qemuCaps,
+qemuBuildNetCommandLine(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUCaps *qemuCaps,
virNetDevVPortProfileOp vmop,
bool standalone,
size_t *nnicindexes,
size_t i;
int last_good_net = -1;
virErrorPtr originalError = NULL;
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
if (def->nnets) {
unsigned int bootNet = 0;
}
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (qemuBuildInterfaceCommandLine(driver, vm, logManager, secManager, cmd, net,
qemuCaps, bootNet, vmop,
static int
-qemuBuildSmartcardCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildSmartcardCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
- virDomainSmartcardDefPtr smartcard;
+ virDomainSmartcardDef *smartcard;
g_autofree char *devstr = NULL;
g_auto(virBuffer) opt = VIR_BUFFER_INITIALIZER;
const char *database;
static char *
-qemuBuildShmemDevLegacyStr(virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
- virQEMUCapsPtr qemuCaps)
+qemuBuildShmemDevLegacyStr(virDomainDef *def,
+ virDomainShmemDef *shmem,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
char *
-qemuBuildShmemDevStr(virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
- virQEMUCapsPtr qemuCaps)
+qemuBuildShmemDevStr(virDomainDef *def,
+ virDomainShmemDef *shmem,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
-virJSONValuePtr
-qemuBuildShmemBackendMemProps(virDomainShmemDefPtr shmem)
+virJSONValue *
+qemuBuildShmemBackendMemProps(virDomainShmemDef *shmem)
{
g_autofree char *mem_alias = NULL;
g_autofree char *mem_path = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
mem_path = g_strdup_printf("/dev/shm/%s", shmem->name);
static int
-qemuBuildShmemCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
- virQEMUCapsPtr qemuCaps,
+qemuBuildShmemCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
+ virDomainDef *def,
+ virDomainShmemDef *shmem,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
g_autoptr(virJSONValue) memProps = NULL;
static int
-qemuBuildChrDeviceCommandLine(virCommandPtr cmd,
+qemuBuildChrDeviceCommandLine(virCommand *cmd,
const virDomainDef *def,
- virDomainChrDefPtr chr,
- virQEMUCapsPtr qemuCaps)
+ virDomainChrDef *chr,
+ virQEMUCaps *qemuCaps)
{
g_autofree char *devstr = NULL;
static bool
qemuChrIsPlatformDevice(const virDomainDef *def,
- virDomainChrDefPtr chr)
+ virDomainChrDef *chr)
{
if (def->os.arch == VIR_ARCH_ARMV6L ||
def->os.arch == VIR_ARCH_ARMV7L ||
static int
-qemuBuildSerialCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildSerialCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
}
for (i = 0; i < def->nserials; i++) {
- virDomainChrDefPtr serial = def->serials[i];
+ virDomainChrDef *serial = def->serials[i];
g_autofree char *devstr = NULL;
if (serial->source->type == VIR_DOMAIN_CHR_TYPE_SPICEPORT && !havespice)
static int
-qemuBuildParallelsCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildParallelsCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
cdevflags |= QEMU_BUILD_CHARDEV_FILE_LOGD;
for (i = 0; i < def->nparallels; i++) {
- virDomainChrDefPtr parallel = def->parallels[i];
+ virDomainChrDef *parallel = def->parallels[i];
g_autofree char *devstr = NULL;
if (!(devstr = qemuBuildChrChardevStr(logManager, secManager,
static int
-qemuBuildChannelsCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildChannelsCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd,
unsigned int flags)
{
cdevflags |= QEMU_BUILD_CHARDEV_FILE_LOGD;
for (i = 0; i < def->nchannels; i++) {
- virDomainChrDefPtr channel = def->channels[i];
+ virDomainChrDef *channel = def->channels[i];
g_autofree char *chardevstr = NULL;
g_autoptr(virJSONValue) netdevprops = NULL;
g_autofree char *netdevstr = NULL;
static int
-qemuBuildConsoleCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildConsoleCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
/* Explicit console devices */
for (i = 0; i < def->nconsoles; i++) {
- virDomainChrDefPtr console = def->consoles[i];
+ virDomainChrDef *console = def->consoles[i];
char *devstr;
switch (console->targetType) {
char *
qemuBuildRedirdevDevStr(const virDomainDef *def,
- virDomainRedirdevDefPtr dev,
- virQEMUCapsPtr qemuCaps)
+ virDomainRedirdevDef *dev,
+ virQEMUCaps *qemuCaps)
{
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainRedirFilterDefPtr redirfilter = def->redirfilter;
+ virDomainRedirFilterDef *redirfilter = def->redirfilter;
virBufferAsprintf(&buf, "usb-redir,chardev=char%s,id=%s",
dev->info.alias, dev->info.alias);
virBufferAddLit(&buf, ",filter=");
for (i = 0; i < redirfilter->nusbdevs; i++) {
- virDomainRedirFilterUSBDevDefPtr usbdev = redirfilter->usbdevs[i];
+ virDomainRedirFilterUSBDevDef *usbdev = redirfilter->usbdevs[i];
if (usbdev->usbClass >= 0)
virBufferAsprintf(&buf, "0x%02X:", usbdev->usbClass);
else
static int
-qemuBuildRedirdevCommandLine(virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
+qemuBuildRedirdevCommandLine(virLogManager *logManager,
+ virSecurityManager *secManager,
+ virCommand *cmd,
+ virQEMUDriverConfig *cfg,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
bool chardevStdioLogd)
{
size_t i;
cdevflags |= QEMU_BUILD_CHARDEV_FILE_LOGD;
for (i = 0; i < def->nredirdevs; i++) {
- virDomainRedirdevDefPtr redirdev = def->redirdevs[i];
+ virDomainRedirdevDef *redirdev = def->redirdevs[i];
char *devstr;
if (!(devstr = qemuBuildChrChardevStr(logManager, secManager,
static void
-qemuBuldDomainLoaderPflashCommandLine(virCommandPtr cmd,
- virDomainLoaderDefPtr loader,
- virQEMUCapsPtr qemuCaps)
+qemuBuldDomainLoaderPflashCommandLine(virCommand *cmd,
+ virDomainLoaderDef *loader,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int unit = 0;
static void
-qemuBuildDomainLoaderCommandLine(virCommandPtr cmd,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuBuildDomainLoaderCommandLine(virCommand *cmd,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
- virDomainLoaderDefPtr loader = def->os.loader;
+ virDomainLoaderDef *loader = def->os.loader;
if (!loader)
return;
static char *
qemuBuildTPMDevStr(const virDomainDef *def,
- virDomainTPMDefPtr tpm,
- virQEMUCapsPtr qemuCaps)
+ virDomainTPMDef *tpm,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *model = virDomainTPMModelTypeToString(tpm->model);
static char *
-qemuBuildTPMBackendStr(virCommandPtr cmd,
- virDomainTPMDefPtr tpm,
+qemuBuildTPMBackendStr(virCommand *cmd,
+ virDomainTPMDef *tpm,
int *tpmfd,
int *cancelfd,
char **chardev)
static int
-qemuBuildTPMCommandLine(virCommandPtr cmd,
+qemuBuildTPMCommandLine(virCommand *cmd,
const virDomainDef *def,
- virDomainTPMDefPtr tpm,
- virQEMUCapsPtr qemuCaps)
+ virDomainTPMDef *tpm,
+ virQEMUCaps *qemuCaps)
{
char *optstr;
g_autofree char *chardev = NULL;
static int
-qemuBuildTPMProxyCommandLine(virCommandPtr cmd,
- virDomainTPMDefPtr tpm)
+qemuBuildTPMProxyCommandLine(virCommand *cmd,
+ virDomainTPMDef *tpm)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *filePath = NULL;
static int
-qemuBuildTPMsCommandLine(virCommandPtr cmd,
+qemuBuildTPMsCommandLine(virCommand *cmd,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
static int
-qemuBuildSEVCommandLine(virDomainObjPtr vm, virCommandPtr cmd,
- virDomainSEVDefPtr sev)
+qemuBuildSEVCommandLine(virDomainObj *vm, virCommand *cmd,
+ virDomainSEVDef *sev)
{
g_autoptr(virJSONValue) props = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *dhpath = NULL;
g_autofree char *sessionpath = NULL;
}
static int
-qemuBuildVMCoreInfoCommandLine(virCommandPtr cmd,
+qemuBuildVMCoreInfoCommandLine(virCommand *cmd,
const virDomainDef *def)
{
virTristateSwitch vmci = def->features[VIR_DOMAIN_FEATURE_VMCOREINFO];
static int
-qemuBuildPanicCommandLine(virCommandPtr cmd,
+qemuBuildPanicCommandLine(virCommand *cmd,
const virDomainDef *def)
{
size_t i;
}
-static virJSONValuePtr
+static virJSONValue *
qemuBuildPRManagerInfoPropsInternal(const char *alias,
const char *path)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (qemuMonitorCreateObjectProps(&ret,
"pr-manager-helper", alias,
* Build the JSON properties for the pr-manager object corresponding to the PR
* daemon managed by libvirt.
*/
-virJSONValuePtr
-qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv)
+virJSONValue *
+qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivate *priv)
{
g_autofree char *path = NULL;
*
* Build the JSON properties for the pr-manager object.
*/
-virJSONValuePtr
-qemuBuildPRManagerInfoProps(virStorageSourcePtr src)
+virJSONValue *
+qemuBuildPRManagerInfoProps(virStorageSource *src)
{
return qemuBuildPRManagerInfoPropsInternal(src->pr->mgralias, src->pr->path);
}
static int
-qemuBuildManagedPRCommandLine(virCommandPtr cmd,
+qemuBuildManagedPRCommandLine(virCommand *cmd,
const virDomainDef *def,
- qemuDomainObjPrivatePtr priv)
+ qemuDomainObjPrivate *priv)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autoptr(virJSONValue) props = NULL;
static int
-qemuBuildPflashBlockdevOne(virCommandPtr cmd,
- virStorageSourcePtr src,
- virQEMUCapsPtr qemuCaps)
+qemuBuildPflashBlockdevOne(virCommand *cmd,
+ virStorageSource *src,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
size_t i;
static int
-qemuBuildPflashBlockdevCommandLine(virCommandPtr cmd,
- qemuDomainObjPrivatePtr priv)
+qemuBuildPflashBlockdevCommandLine(virCommand *cmd,
+ qemuDomainObjPrivate *priv)
{
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV))
return 0;
}
-virJSONValuePtr
-qemuBuildDBusVMStateInfoProps(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+virJSONValue *
+qemuBuildDBusVMStateInfoProps(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
const char *alias = qemuDomainGetDBusVMStateAlias();
g_autofree char *addr = qemuDBusGetAddress(driver, vm);
static int
-qemuBuildDBusVMStateCommandLine(virCommandPtr cmd,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuBuildDBusVMStateCommandLine(virCommand *cmd,
+ virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autoptr(virJSONValue) props = NULL;
- qemuDomainObjPrivatePtr priv = QEMU_DOMAIN_PRIVATE(vm);
+ qemuDomainObjPrivate *priv = QEMU_DOMAIN_PRIVATE(vm);
if (!priv->dbusVMStateIds)
return 0;
* Returns 0 on success, returns -1 and messages what the issue is.
*/
static int
-qemuBuildCommandLineValidate(virQEMUDriverPtr driver,
+qemuBuildCommandLineValidate(virQEMUDriver *driver,
const virDomainDef *def)
{
size_t i;
static int
-qemuBuildSeccompSandboxCommandLine(virCommandPtr cmd,
- virQEMUDriverConfigPtr cfg,
- virQEMUCapsPtr qemuCaps G_GNUC_UNUSED)
+qemuBuildSeccompSandboxCommandLine(virCommand *cmd,
+ virQEMUDriverConfig *cfg,
+ virQEMUCaps *qemuCaps G_GNUC_UNUSED)
{
if (cfg->seccompSandbox == 0) {
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX))
char *
-qemuBuildVsockDevStr(virDomainDefPtr def,
- virDomainVsockDefPtr vsock,
- virQEMUCapsPtr qemuCaps,
+qemuBuildVsockDevStr(virDomainDef *def,
+ virDomainVsockDef *vsock,
+ virQEMUCaps *qemuCaps,
const char *fdprefix)
{
- qemuDomainVsockPrivatePtr priv = (qemuDomainVsockPrivatePtr)vsock->privateData;
+ qemuDomainVsockPrivate *priv = (qemuDomainVsockPrivate *)vsock->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (qemuBuildVirtioDevStr(&buf, "vhost-vsock", qemuCaps,
static int
-qemuBuildVsockCommandLine(virCommandPtr cmd,
- virDomainDefPtr def,
- virDomainVsockDefPtr vsock,
- virQEMUCapsPtr qemuCaps)
+qemuBuildVsockCommandLine(virCommand *cmd,
+ virDomainDef *def,
+ virDomainVsockDef *vsock,
+ virQEMUCaps *qemuCaps)
{
- qemuDomainVsockPrivatePtr priv = (qemuDomainVsockPrivatePtr)vsock->privateData;
+ qemuDomainVsockPrivate *priv = (qemuDomainVsockPrivate *)vsock->privateData;
g_autofree char *devstr = NULL;
if (!(devstr = qemuBuildVsockDevStr(def, vsock, qemuCaps, "")))
virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- qemuDomainXmlNsDefPtr nsdata = def->namespaceData;
+ qemuDomainXmlNsDef *nsdata = def->namespaceData;
qemuCommnadDeprecationBehavior behavior = QEMU_COMMAND_DEPRECATION_BEHAVIOR_NONE;
const char *behaviorStr = cfg->deprecationBehavior;
int tmp;
* Constructs a argv suitable for launching qemu with config defined
* for a given virtual machine.
*/
-virCommandPtr
-qemuBuildCommandLine(virQEMUDriverPtr driver,
- virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virDomainObjPtr vm,
+virCommand *
+qemuBuildCommandLine(virQEMUDriver *driver,
+ virLogManager *logManager,
+ virSecurityManager *secManager,
+ virDomainObj *vm,
const char *migrateURI,
- virDomainMomentObjPtr snapshot,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
bool standalone,
bool enableFips,
g_autoptr(virCommand) cmd = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
unsigned int bootHostdevNet = 0;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr def = vm->def;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
bool chardevStdioLogd = priv->chardevStdioLogd;
VIR_DEBUG("driver=%p def=%p mon=%p "
virCommandAddArgList(cmd, "-loadvm", snapshot->def->name, NULL);
if (def->namespaceData) {
- qemuDomainXmlNsDefPtr qemuxmlns;
+ qemuDomainXmlNsDef *qemuxmlns;
qemuxmlns = def->namespaceData;
for (i = 0; i < qemuxmlns->num_args; i++)
static int
qemuBuildSerialChrDeviceStr(char **deviceStr,
const virDomainDef *def,
- virDomainChrDefPtr serial,
- virQEMUCapsPtr qemuCaps)
+ virDomainChrDef *serial,
+ virQEMUCaps *qemuCaps)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virQEMUCapsFlags caps;
static int
qemuBuildParallelChrDeviceStr(char **deviceStr,
- virDomainChrDefPtr chr)
+ virDomainChrDef *chr)
{
*deviceStr = g_strdup_printf("isa-parallel,chardev=char%s,id=%s",
chr->info.alias, chr->info.alias);
}
-virJSONValuePtr
-qemuBuildChannelGuestfwdNetdevProps(virDomainChrDefPtr chr)
+virJSONValue *
+qemuBuildChannelGuestfwdNetdevProps(virDomainChrDef *chr)
{
g_autoptr(virJSONValue) guestfwdarr = virJSONValueNewArray();
g_autoptr(virJSONValue) guestfwdstrobj = virJSONValueNewObject();
g_autofree char *addr = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (!(addr = virSocketAddrFormat(chr->target.addr)))
return NULL;
static int
qemuBuildChannelChrDeviceStr(char **deviceStr,
const virDomainDef *def,
- virDomainChrDefPtr chr)
+ virDomainChrDef *chr)
{
switch ((virDomainChrChannelTargetType)chr->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
static int
qemuBuildConsoleChrDeviceStr(char **deviceStr,
const virDomainDef *def,
- virDomainChrDefPtr chr)
+ virDomainChrDef *chr)
{
switch ((virDomainChrConsoleTargetType)chr->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
int
qemuBuildChrDeviceStr(char **deviceStr,
const virDomainDef *vmdef,
- virDomainChrDefPtr chr,
- virQEMUCapsPtr qemuCaps)
+ virDomainChrDef *chr,
+ virQEMUCaps *qemuCaps)
{
int ret = -1;
}
-virJSONValuePtr
+virJSONValue *
qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu)
{
- qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
+ qemuDomainVcpuPrivate *vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
g_autoptr(virJSONValue) ret = NULL;
if (!(ret = virJSONValueCopy(vcpupriv->props)))
* @qemuCaps: qemu capabilities object
* @driveBoot: bootable flag for disks which don't have -device part
*
- * Prepare qemuBlockStorageSourceAttachDataPtr for use with the old approach
+ * Prepare qemuBlockStorageSourceAttachData *for use with the old approach
* using -drive/drive_add. See qemuBlockStorageSourceAttachPrepareBlockdev.
*/
-qemuBlockStorageSourceAttachDataPtr
-qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps)
+qemuBlockStorageSourceAttachData *
+qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
* qemuBuildStorageSourceAttachPrepareChardev:
* @src: disk source to prepare
*
- * Prepare qemuBlockStorageSourceAttachDataPtr for vhost-user disk
+ * Prepare qemuBlockStorageSourceAttachData *for vhost-user disk
* to be used with -chardev.
*/
-qemuBlockStorageSourceAttachDataPtr
-qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDefPtr disk)
+qemuBlockStorageSourceAttachData *
+qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDef *disk)
{
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
g_auto(virBuffer) chardev = VIR_BUFFER_INITIALIZER;
* secrets/TLS/pr objects etc ...
*/
int
-qemuBuildStorageSourceAttachPrepareCommon(virStorageSourcePtr src,
- qemuBlockStorageSourceAttachDataPtr data,
- virQEMUCapsPtr qemuCaps)
+qemuBuildStorageSourceAttachPrepareCommon(virStorageSource *src,
+ qemuBlockStorageSourceAttachData *data,
+ virQEMUCaps *qemuCaps)
{
- qemuDomainStorageSourcePrivatePtr srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
const char *tlsKeySecretAlias = NULL;
if (src->pr &&
* @disk: disk definition
* @qemuCaps: qemu capabilities object
*
- * Prepares qemuBlockStorageSourceChainDataPtr for attaching @disk via -drive.
+ * Prepares qemuBlockStorageSourceChainData *for attaching @disk via -drive.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps)
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceAttachData) elem = NULL;
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
* qemuBuildStorageSourceChainAttachPrepareChardev:
* @src: disk definition
*
- * Prepares qemuBlockStorageSourceChainDataPtr for attaching a vhost-user
+ * Prepares qemuBlockStorageSourceChainData *for attaching a vhost-user
* disk's backend via -chardev.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDefPtr disk)
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDef *disk)
{
g_autoptr(qemuBlockStorageSourceAttachData) elem = NULL;
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
static int
qemuBuildStorageSourceChainAttachPrepareBlockdevOne(qemuBlockStorageSourceChainData *data,
- virStorageSourcePtr src,
- virStorageSourcePtr backingStore,
- virQEMUCapsPtr qemuCaps)
+ virStorageSource *src,
+ virStorageSource *backingStore,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceAttachData) elem = NULL;
* @top: storage source chain
* @qemuCaps: qemu capabilities object
*
- * Prepares qemuBlockStorageSourceChainDataPtr for attaching the chain of images
+ * Prepares qemuBlockStorageSourceChainData *for attaching the chain of images
* starting at @top via -blockdev.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSourcePtr top,
- virQEMUCapsPtr qemuCaps)
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSource *top,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
- virStorageSourcePtr n;
+ virStorageSource *n;
data = g_new0(qemuBlockStorageSourceChainData, 1);
* @backingStore: a storage source to use as backing of @top
* @qemuCaps: qemu capabilities object
*
- * Prepares qemuBlockStorageSourceChainDataPtr for attaching of @top image only
+ * Prepares qemuBlockStorageSourceChainData *for attaching of @top image only
* via -blockdev.
*/
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSourcePtr top,
- virStorageSourcePtr backingStore,
- virQEMUCapsPtr qemuCaps)
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSource *top,
+ virStorageSource *backingStore,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
QEMU_BUILD_COMMANDLINE_VALIDATE_KEEP_JSON = 1 << 0,
} qemuBuildCommandLineFlags;
-virCommandPtr qemuBuildCommandLine(virQEMUDriverPtr driver,
- virLogManagerPtr logManager,
- virSecurityManagerPtr secManager,
- virDomainObjPtr vm,
+virCommand *qemuBuildCommandLine(virQEMUDriver *driver,
+ virLogManager *logManager,
+ virSecurityManager *secManager,
+ virDomainObj *vm,
const char *migrateURI,
- virDomainMomentObjPtr snapshot,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
bool standalone,
bool enableFips,
unsigned int flags);
/* Generate the object properties for pr-manager */
-virJSONValuePtr qemuBuildPRManagerInfoProps(virStorageSourcePtr src);
-virJSONValuePtr qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv);
+virJSONValue *qemuBuildPRManagerInfoProps(virStorageSource *src);
+virJSONValue *qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivate *priv);
-virJSONValuePtr qemuBuildDBusVMStateInfoProps(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+virJSONValue *qemuBuildDBusVMStateInfoProps(virQEMUDriver *driver,
+ virDomainObj *vm);
/* Generate the object properties for a secret */
-int qemuBuildSecretInfoProps(qemuDomainSecretInfoPtr secinfo,
- virJSONValuePtr *propsret);
+int qemuBuildSecretInfoProps(qemuDomainSecretInfo *secinfo,
+ virJSONValue **propsret);
/* Generate the object properties for a tls-creds-x509 */
int qemuBuildTLSx509BackendProps(const char *tlspath,
bool verifypeer,
const char *alias,
const char *secalias,
- virQEMUCapsPtr qemuCaps,
- virJSONValuePtr *propsret);
+ virQEMUCaps *qemuCaps,
+ virJSONValue **propsret);
/* Open a UNIX socket for chardev FD passing */
int
int
qemuBuildChrDeviceStr(char **deviceStr,
const virDomainDef *vmdef,
- virDomainChrDefPtr chr,
- virQEMUCapsPtr qemuCaps);
+ virDomainChrDef *chr,
+ virQEMUCaps *qemuCaps);
-virJSONValuePtr
-qemuBuildChannelGuestfwdNetdevProps(virDomainChrDefPtr chr);
+virJSONValue *
+qemuBuildChannelGuestfwdNetdevProps(virDomainChrDef *chr);
-virJSONValuePtr qemuBuildHostNetStr(virDomainNetDefPtr net,
+virJSONValue *qemuBuildHostNetStr(virDomainNetDef *net,
char **tapfd,
size_t tapfdSize,
char **vhostfd,
const char *vdpadev);
/* Current, best practice */
-char *qemuBuildNicDevStr(virDomainDefPtr def,
- virDomainNetDefPtr net,
+char *qemuBuildNicDevStr(virDomainDef *def,
+ virDomainNetDef *net,
unsigned int bootindex,
size_t vhostfdSize,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
-char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk);
+char *qemuDeviceDriveHostAlias(virDomainDiskDef *disk);
bool qemuDiskBusIsSD(int bus);
-qemuBlockStorageSourceAttachDataPtr
-qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps);
+qemuBlockStorageSourceAttachData *
+qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps);
-qemuBlockStorageSourceAttachDataPtr
-qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDefPtr disk);
+qemuBlockStorageSourceAttachData *
+qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDef *disk);
int
-qemuBuildStorageSourceAttachPrepareCommon(virStorageSourcePtr src,
- qemuBlockStorageSourceAttachDataPtr data,
- virQEMUCapsPtr qemuCaps);
+qemuBuildStorageSourceAttachPrepareCommon(virStorageSource *src,
+ qemuBlockStorageSourceAttachData *data,
+ virQEMUCaps *qemuCaps);
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps);
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps);
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDefPtr disk);
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDef *disk);
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSourcePtr top,
- virQEMUCapsPtr qemuCaps);
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSource *top,
+ virQEMUCaps *qemuCaps);
-qemuBlockStorageSourceChainDataPtr
-qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSourcePtr top,
- virStorageSourcePtr backingStore,
- virQEMUCapsPtr qemuCaps);
+qemuBlockStorageSourceChainData *
+qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSource *top,
+ virStorageSource *backingStore,
+ virQEMUCaps *qemuCaps);
char
*qemuBuildDiskDeviceStr(const virDomainDef *def,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
unsigned int bootindex,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
/* Current, best practice */
int qemuBuildControllerDevStr(const virDomainDef *domainDef,
- virDomainControllerDefPtr def,
- virQEMUCapsPtr qemuCaps,
+ virDomainControllerDef *def,
+ virQEMUCaps *qemuCaps,
char **devstr);
-int qemuBuildMemoryBackendProps(virJSONValuePtr *backendProps,
+int qemuBuildMemoryBackendProps(virJSONValue **backendProps,
const char *alias,
- virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+ virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const virDomainDef *def,
const virDomainMemoryDef *mem,
bool force,
char *
qemuBuildMemoryDeviceStr(const virDomainDef *def,
- virDomainMemoryDefPtr mem,
- virQEMUCapsPtr qemuCaps);
+ virDomainMemoryDef *mem,
+ virQEMUCaps *qemuCaps);
/* Current, best practice */
char *qemuBuildPCIHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
+ virDomainHostdevDef *dev,
unsigned int bootIndex,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
char *qemuBuildRNGDevStr(const virDomainDef *def,
- virDomainRNGDefPtr dev,
- virQEMUCapsPtr qemuCaps);
-int qemuBuildRNGBackendProps(virDomainRNGDefPtr rng,
- virJSONValuePtr *props);
+ virDomainRNGDef *dev,
+ virQEMUCaps *qemuCaps);
+int qemuBuildRNGBackendProps(virDomainRNGDef *rng,
+ virJSONValue **props);
/* Current, best practice */
char *qemuBuildUSBHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps);
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps);
char *qemuBuildSCSIHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
+ virDomainHostdevDef *dev,
const char *backendAlias);
qemuBlockStorageSourceAttachData *
-qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDefPtr hostdev,
+qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDef *hostdev,
const char **backendAlias,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
qemuBlockStorageSourceAttachData *
-qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps);
+qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps);
char *
qemuBuildSCSIVHostHostdevDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps,
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps,
char *vhostfdName);
char *
qemuBuildHostdevMediatedDevStr(const virDomainDef *def,
- virDomainHostdevDefPtr dev,
- virQEMUCapsPtr qemuCaps);
+ virDomainHostdevDef *dev,
+ virQEMUCaps *qemuCaps);
char *qemuBuildRedirdevDevStr(const virDomainDef *def,
- virDomainRedirdevDefPtr dev,
- virQEMUCapsPtr qemuCaps);
+ virDomainRedirdevDef *dev,
+ virQEMUCaps *qemuCaps);
-char *qemuBuildZPCIDevStr(virDomainDeviceInfoPtr dev);
+char *qemuBuildZPCIDevStr(virDomainDeviceInfo *dev);
-int qemuNetworkPrepareDevices(virDomainDefPtr def);
+int qemuNetworkPrepareDevices(virDomainDef *def);
-int qemuGetDriveSourceString(virStorageSourcePtr src,
- qemuDomainSecretInfoPtr secinfo,
+int qemuGetDriveSourceString(virStorageSource *src,
+ qemuDomainSecretInfo *secinfo,
char **source);
bool
-qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDefPtr disk);
+qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDef *disk);
bool
-qemuCheckFips(virDomainObjPtr vm);
+qemuCheckFips(virDomainObj *vm);
-virJSONValuePtr qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu)
+virJSONValue *qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu)
ATTRIBUTE_NONNULL(1);
-virJSONValuePtr qemuBuildShmemBackendMemProps(virDomainShmemDefPtr shmem)
+virJSONValue *qemuBuildShmemBackendMemProps(virDomainShmemDef *shmem)
ATTRIBUTE_NONNULL(1);
-char *qemuBuildShmemDevStr(virDomainDefPtr def,
- virDomainShmemDefPtr shmem,
- virQEMUCapsPtr qemuCaps)
+char *qemuBuildShmemDevStr(virDomainDef *def,
+ virDomainShmemDef *shmem,
+ virQEMUCaps *qemuCaps)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
char *qemuBuildWatchdogDevStr(const virDomainDef *def,
- virDomainWatchdogDefPtr dev,
- virQEMUCapsPtr qemuCaps);
+ virDomainWatchdogDef *dev,
+ virQEMUCaps *qemuCaps);
int qemuBuildInputDevStr(char **devstr,
const virDomainDef *def,
- virDomainInputDefPtr input,
- virQEMUCapsPtr qemuCaps)
+ virDomainInputDef *input,
+ virQEMUCaps *qemuCaps)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
char *
-qemuBuildVsockDevStr(virDomainDefPtr def,
- virDomainVsockDefPtr vsock,
- virQEMUCapsPtr qemuCaps,
+qemuBuildVsockDevStr(virDomainDef *def,
+ virDomainVsockDef *vsock,
+ virQEMUCaps *qemuCaps,
const char *fdprefix)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
#define QEMU_MIGRATION_PORT_MIN 49152
#define QEMU_MIGRATION_PORT_MAX 49215
-static virClassPtr virQEMUDriverConfigClass;
+static virClass *virQEMUDriverConfigClass;
static void virQEMUDriverConfigDispose(void *obj);
static int virQEMUConfigOnceInit(void)
static void
-qemuDriverLock(virQEMUDriverPtr driver)
+qemuDriverLock(virQEMUDriver *driver)
{
virMutexLock(&driver->lock);
}
static void
-qemuDriverUnlock(virQEMUDriverPtr driver)
+qemuDriverUnlock(virQEMUDriver *driver)
{
virMutexUnlock(&driver->lock);
}
#endif
-virQEMUDriverConfigPtr virQEMUDriverConfigNew(bool privileged,
+virQEMUDriverConfig *virQEMUDriverConfigNew(bool privileged,
const char *root)
{
g_autoptr(virQEMUDriverConfig) cfg = NULL;
static void virQEMUDriverConfigDispose(void *obj)
{
- virQEMUDriverConfigPtr cfg = obj;
+ virQEMUDriverConfig *cfg = obj;
virBitmapFree(cfg->namespaces);
static int
-virQEMUDriverConfigHugeTLBFSInit(virHugeTLBFSPtr hugetlbfs,
+virQEMUDriverConfigHugeTLBFSInit(virHugeTLBFS *hugetlbfs,
const char *path,
bool deflt)
{
static int
-virQEMUDriverConfigLoadDefaultTLSEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadDefaultTLSEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
int rv;
static int
-virQEMUDriverConfigLoadVNCEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadVNCEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
int rv;
static int
-virQEMUDriverConfigLoadNographicsEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadNographicsEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
return virConfGetValueBool(conf, "nographics_allow_host_audio", &cfg->nogfxAllowHostAudio);
}
static int
-virQEMUDriverConfigLoadSPICEEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadSPICEEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
if (virConfGetValueBool(conf, "spice_tls", &cfg->spiceTLS) < 0)
return -1;
static int
-virQEMUDriverConfigLoadSpecificTLSEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadSpecificTLSEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
int rv;
static int
-virQEMUDriverConfigLoadRemoteDisplayEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf,
+virQEMUDriverConfigLoadRemoteDisplayEntry(virQEMUDriverConfig *cfg,
+ virConf *conf,
const char *filename)
{
if (virConfGetValueUInt(conf, "remote_websocket_port_min", &cfg->webSocketPortMin) < 0)
static int
-virQEMUDriverConfigLoadSaveEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadSaveEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
if (virConfGetValueString(conf, "save_image_format", &cfg->saveImageFormat) < 0)
return -1;
static int
-virQEMUDriverConfigLoadProcessEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadProcessEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
g_auto(GStrv) hugetlbfs = NULL;
g_autofree char *stdioHandler = NULL;
static int
-virQEMUDriverConfigLoadDeviceEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadDeviceEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
bool tmp;
int rv;
static int
-virQEMUDriverConfigLoadRPCEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadRPCEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
if (virConfGetValueUInt(conf, "max_queued", &cfg->maxQueuedJobs) < 0)
return -1;
static int
-virQEMUDriverConfigLoadNetworkEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf,
+virQEMUDriverConfigLoadNetworkEntry(virQEMUDriverConfig *cfg,
+ virConf *conf,
const char *filename)
{
if (virConfGetValueUInt(conf, "migration_port_min", &cfg->migrationPortMin) < 0)
static int
-virQEMUDriverConfigLoadLogEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadLogEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
return virConfGetValueBool(conf, "log_timestamp", &cfg->logTimestamp);
}
static int
-virQEMUDriverConfigLoadNVRAMEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf,
+virQEMUDriverConfigLoadNVRAMEntry(virQEMUDriverConfig *cfg,
+ virConf *conf,
bool privileged)
{
g_auto(GStrv) nvram = NULL;
}
cfg->nfirmwares = g_strv_length(nvram);
- cfg->firmwares = g_new0(virFirmwarePtr, cfg->nfirmwares);
+ cfg->firmwares = g_new0(virFirmware *, cfg->nfirmwares);
for (i = 0; nvram[i] != NULL; i++) {
cfg->firmwares[i] = g_new0(virFirmware, 1);
static int
-virQEMUDriverConfigLoadDebugEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadDebugEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
if (virConfGetValueUInt(conf, "gluster_debug_level", &cfg->glusterDebugLevel) < 0)
return -1;
static int
-virQEMUDriverConfigLoadSecurityEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf,
+virQEMUDriverConfigLoadSecurityEntry(virQEMUDriverConfig *cfg,
+ virConf *conf,
bool privileged)
{
g_auto(GStrv) controllers = NULL;
static int
-virQEMUDriverConfigLoadMemoryEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadMemoryEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
g_autofree char *dir = NULL;
int rc;
static int
-virQEMUDriverConfigLoadSWTPMEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadSWTPMEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
g_autofree char *swtpm_user = NULL;
g_autofree char *swtpm_group = NULL;
static int
-virQEMUDriverConfigLoadCapsFiltersEntry(virQEMUDriverConfigPtr cfg,
- virConfPtr conf)
+virQEMUDriverConfigLoadCapsFiltersEntry(virQEMUDriverConfig *cfg,
+ virConf *conf)
{
if (virConfGetValueStringList(conf, "capability_filters", false,
&cfg->capabilityfilters) < 0)
}
-int virQEMUDriverConfigLoadFile(virQEMUDriverConfigPtr cfg,
+int virQEMUDriverConfigLoadFile(virQEMUDriverConfig *cfg,
const char *filename,
bool privileged)
{
* Returns 0 on success, -1 on failure
*/
int
-virQEMUDriverConfigValidate(virQEMUDriverConfigPtr cfg)
+virQEMUDriverConfigValidate(virQEMUDriverConfig *cfg)
{
if (cfg->defaultTLSx509certdirPresent) {
if (!virFileExists(cfg->defaultTLSx509certdir)) {
int
-virQEMUDriverConfigSetDefaults(virQEMUDriverConfigPtr cfg)
+virQEMUDriverConfigSetDefaults(virQEMUDriverConfig *cfg)
{
#define SET_TLS_SECRET_UUID_DEFAULT(val) \
do { \
}
-virQEMUDriverConfigPtr virQEMUDriverGetConfig(virQEMUDriverPtr driver)
+virQEMUDriverConfig *virQEMUDriverGetConfig(virQEMUDriver *driver)
{
- virQEMUDriverConfigPtr conf;
+ virQEMUDriverConfig *conf;
qemuDriverLock(driver);
conf = virObjectRef(driver->config);
qemuDriverUnlock(driver);
return conf;
}
-virDomainXMLOptionPtr
-virQEMUDriverCreateXMLConf(virQEMUDriverPtr driver,
+virDomainXMLOption *
+virQEMUDriverCreateXMLConf(virQEMUDriver *driver,
const char *defsecmodel)
{
virQEMUDriverDomainDefParserConfig.priv = driver;
}
-virCPUDefPtr
-virQEMUDriverGetHostCPU(virQEMUDriverPtr driver)
+virCPUDef *
+virQEMUDriverGetHostCPU(virQEMUDriver *driver)
{
- virCPUDefPtr hostcpu;
+ virCPUDef *hostcpu;
qemuDriverLock(driver);
}
-virCapsPtr virQEMUDriverCreateCapabilities(virQEMUDriverPtr driver)
+virCaps *virQEMUDriverCreateCapabilities(virQEMUDriver *driver)
{
size_t i, j;
g_autoptr(virCaps) caps = NULL;
- g_autofree virSecurityManagerPtr *sec_managers = NULL;
+ g_autofree virSecurityManager **sec_managers = NULL;
/* Security driver data */
const char *doi, *model, *lbl, *type;
const int virtTypes[] = {VIR_DOMAIN_VIRT_KVM,
caps->host.secModels = g_new0(virCapsHostSecModel, caps->host.nsecModels);
for (i = 0; sec_managers[i]; i++) {
- virCapsHostSecModelPtr sm = &caps->host.secModels[i];
+ virCapsHostSecModel *sm = &caps->host.secModels[i];
doi = qemuSecurityGetDOI(sec_managers[i]);
model = qemuSecurityGetModel(sec_managers[i]);
sm->model = g_strdup(model);
/**
* virQEMUDriverGetCapabilities:
*
- * Get a reference to the virCapsPtr instance for the
+ * Get a reference to the virCaps *instance for the
* driver. If @refresh is true, the capabilities will be
* rebuilt first
*
* The caller must release the reference with virObjectUnref
*
- * Returns: a reference to a virCapsPtr instance or NULL
+ * Returns: a reference to a virCaps *instance or NULL
*/
-virCapsPtr virQEMUDriverGetCapabilities(virQEMUDriverPtr driver,
+virCaps *virQEMUDriverGetCapabilities(virQEMUDriver *driver,
bool refresh)
{
- virCapsPtr ret = NULL;
+ virCaps *ret = NULL;
if (refresh) {
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
if ((caps = virQEMUDriverCreateCapabilities(driver)) == NULL)
return NULL;
/**
* virQEMUDriverGetDomainCapabilities:
*
- * Get a reference to the virDomainCapsPtr instance. The caller
+ * Get a reference to the virDomainCaps *instance. The caller
* must release the reference with virObjetUnref().
*
- * Returns: a reference to a virDomainCapsPtr instance or NULL
+ * Returns: a reference to a virDomainCaps *instance or NULL
*/
-virDomainCapsPtr
-virQEMUDriverGetDomainCapabilities(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+virDomainCaps *
+virQEMUDriverGetDomainCapabilities(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *machine,
virArch arch,
virDomainVirtType virttype)
*/
static int
qemuCheckSharedDisk(GHashTable *sharedDevices,
- virDomainDiskDefPtr disk)
+ virDomainDiskDef *disk)
{
int ret;
bool
-qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntryPtr entry,
+qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntry *entry,
const char *name,
int *idx)
{
void
qemuSharedDeviceEntryFree(void *payload)
{
- qemuSharedDeviceEntryPtr entry = payload;
+ qemuSharedDeviceEntry *entry = payload;
size_t i;
if (!entry)
static int
-qemuSharedDeviceEntryInsert(virQEMUDriverPtr driver,
+qemuSharedDeviceEntryInsert(virQEMUDriver *driver,
const char *key,
const char *name)
{
static int
-qemuSharedDeviceEntryRemove(virQEMUDriverPtr driver,
+qemuSharedDeviceEntryRemove(virQEMUDriver *driver,
const char *key,
const char *name)
{
- qemuSharedDeviceEntryPtr entry = NULL;
+ qemuSharedDeviceEntry *entry = NULL;
int idx;
if (!(entry = virHashLookup(driver->sharedDevices, key)))
static int
-qemuSharedDiskAddRemoveInternal(virQEMUDriverPtr driver,
- virDomainDiskDefPtr disk,
+qemuSharedDiskAddRemoveInternal(virQEMUDriver *driver,
+ virDomainDiskDef *disk,
const char *name,
bool addDisk)
{
* already exists, otherwise add a new entry.
*/
int
-qemuAddSharedDisk(virQEMUDriverPtr driver,
- virDomainDiskDefPtr disk,
+qemuAddSharedDisk(virQEMUDriver *driver,
+ virDomainDiskDef *disk,
const char *name)
{
return qemuSharedDiskAddRemoveInternal(driver, disk, name, true);
static bool
-qemuIsSharedHostdev(virDomainHostdevDefPtr hostdev)
+qemuIsSharedHostdev(virDomainHostdevDef *hostdev)
{
return (hostdev->shareable &&
(virHostdevIsSCSIDevice(hostdev) &&
static char *
-qemuGetHostdevPath(virDomainHostdevDefPtr hostdev)
+qemuGetHostdevPath(virDomainHostdevDef *hostdev)
{
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autofree char *dev_name = NULL;
if (!(dev_name = virSCSIDeviceGetDevName(NULL,
static int
-qemuSharedHostdevAddRemoveInternal(virQEMUDriverPtr driver,
- virDomainHostdevDefPtr hostdev,
+qemuSharedHostdevAddRemoveInternal(virQEMUDriver *driver,
+ virDomainHostdevDef *hostdev,
const char *name,
bool addDevice)
{
}
static int
-qemuSharedDeviceAddRemoveInternal(virQEMUDriverPtr driver,
- virDomainDeviceDefPtr dev,
+qemuSharedDeviceAddRemoveInternal(virQEMUDriver *driver,
+ virDomainDeviceDef *dev,
const char *name,
bool addDevice)
{
* already exists, otherwise add a new entry.
*/
int
-qemuAddSharedDevice(virQEMUDriverPtr driver,
- virDomainDeviceDefPtr dev,
+qemuAddSharedDevice(virQEMUDriver *driver,
+ virDomainDeviceDef *dev,
const char *name)
{
return qemuSharedDeviceAddRemoveInternal(driver, dev, name, true);
int
-qemuRemoveSharedDisk(virQEMUDriverPtr driver,
- virDomainDiskDefPtr disk,
+qemuRemoveSharedDisk(virQEMUDriver *driver,
+ virDomainDiskDef *disk,
const char *name)
{
return qemuSharedDiskAddRemoveInternal(driver, disk, name, false);
* 1, otherwise remove the entry.
*/
int
-qemuRemoveSharedDevice(virQEMUDriverPtr driver,
- virDomainDeviceDefPtr dev,
+qemuRemoveSharedDevice(virQEMUDriver *driver,
+ virDomainDeviceDef *dev,
const char *name)
{
return qemuSharedDeviceAddRemoveInternal(driver, dev, name, false);
int
-qemuSetUnprivSGIO(virDomainDeviceDefPtr dev)
+qemuSetUnprivSGIO(virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr disk = NULL;
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainDiskDef *disk = NULL;
+ virDomainHostdevDef *hostdev = NULL;
g_autofree char *sysfs_path = NULL;
const char *path = NULL;
int val = -1;
return 0;
}
-int qemuDriverAllocateID(virQEMUDriverPtr driver)
+int qemuDriverAllocateID(virQEMUDriver *driver)
{
return g_atomic_int_add(&driver->lastvmid, 1) + 1;
}
int
-qemuTranslateSnapshotDiskSourcePool(virDomainSnapshotDiskDefPtr def)
+qemuTranslateSnapshotDiskSourcePool(virDomainSnapshotDiskDef *def)
{
if (def->src->type != VIR_STORAGE_TYPE_VOLUME)
return 0;
}
char *
-qemuGetBaseHugepagePath(virQEMUDriverPtr driver,
- virHugeTLBFSPtr hugepage)
+qemuGetBaseHugepagePath(virQEMUDriver *driver,
+ virHugeTLBFS *hugepage)
{
const char *root = driver->embeddedRoot;
char *ret;
char *
-qemuGetDomainHugepagePath(virQEMUDriverPtr driver,
+qemuGetDomainHugepagePath(virQEMUDriver *driver,
const virDomainDef *def,
- virHugeTLBFSPtr hugepage)
+ virHugeTLBFS *hugepage)
{
g_autofree char *base = qemuGetBaseHugepagePath(driver, hugepage);
g_autofree char *domPath = virDomainDefGetShortName(def);
* -1 otherwise.
*/
int
-qemuGetDomainHupageMemPath(virQEMUDriverPtr driver,
+qemuGetDomainHupageMemPath(virQEMUDriver *driver,
const virDomainDef *def,
unsigned long long pagesize,
char **memPath)
int
-qemuGetMemoryBackingDomainPath(virQEMUDriverPtr driver,
+qemuGetMemoryBackingDomainPath(virQEMUDriver *driver,
const virDomainDef *def,
char **path)
{
* -1 otherwise (with error reported).
*/
int
-qemuGetMemoryBackingPath(virQEMUDriverPtr driver,
+qemuGetMemoryBackingPath(virQEMUDriver *driver,
const virDomainDef *def,
const char *alias,
char **memPath)
#define QEMU_DRIVER_NAME "QEMU"
typedef struct _virQEMUDriver virQEMUDriver;
-typedef virQEMUDriver *virQEMUDriverPtr;
typedef struct _virQEMUDriverConfig virQEMUDriverConfig;
-typedef virQEMUDriverConfig *virQEMUDriverConfigPtr;
/* Main driver config. The data in these object
* instances is immutable, so can be accessed
gid_t group;
bool dynamicOwnership;
- virBitmapPtr namespaces;
+ virBitmap *namespaces;
bool rememberOwner;
int cgroupControllers;
unsigned int webSocketPortMin;
unsigned int webSocketPortMax;
- virHugeTLBFSPtr hugetlbfs;
+ virHugeTLBFS *hugetlbfs;
size_t nhugetlbfs;
char *bridgeHelperName;
bool logTimestamp;
bool stdioLogD;
- virFirmwarePtr *firmwares;
+ virFirmware **firmwares;
size_t nfirmwares;
unsigned int glusterDebugLevel;
bool virtiofsdDebug;
/* Require lock to get reference on 'config',
* then lockless thereafter */
- virQEMUDriverConfigPtr config;
+ virQEMUDriverConfig *config;
/* pid file FD, ensures two copies of the driver can't use the same root */
int lockFD;
/* Immutable pointer, self-locking APIs */
- virThreadPoolPtr workerPool;
+ virThreadPool *workerPool;
/* Atomic increment only */
int lastvmid;
void *inhibitOpaque;
/* Immutable pointer, self-locking APIs */
- virDomainObjListPtr domains;
+ virDomainObjList *domains;
/* Immutable pointer */
char *qemuImgBinary;
/* Require lock to get a reference on the object,
* lockless access thereafter
*/
- virCapsPtr caps;
+ virCaps *caps;
/* Lazy initialized on first use, immutable thereafter.
* Require lock to get the pointer & do optional initialization
*/
- virCPUDefPtr hostcpu;
+ virCPUDef *hostcpu;
/* Immutable value */
virArch hostarch;
/* Immutable pointer, Immutable object */
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
/* Immutable pointer, self-locking APIs */
- virFileCachePtr qemuCapsCache;
+ virFileCache *qemuCapsCache;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr domainEventState;
+ virObjectEventState *domainEventState;
/* Immutable pointer. self-locking APIs */
- virSecurityManagerPtr securityManager;
+ virSecurityManager *securityManager;
- virHostdevManagerPtr hostdevMgr;
+ virHostdevManager *hostdevMgr;
/* Immutable pointer. Unsafe APIs. XXX */
GHashTable *sharedDevices;
/* Immutable pointer, immutable object */
- virPortAllocatorRangePtr remotePorts;
+ virPortAllocatorRange *remotePorts;
/* Immutable pointer, immutable object */
- virPortAllocatorRangePtr webSocketPorts;
+ virPortAllocatorRange *webSocketPorts;
/* Immutable pointer, immutable object */
- virPortAllocatorRangePtr migrationPorts;
+ virPortAllocatorRange *migrationPorts;
/* Immutable pointer, lockless APIs */
- virSysinfoDefPtr hostsysinfo;
+ virSysinfoDef *hostsysinfo;
/* Immutable pointer. lockless access */
- virLockManagerPluginPtr lockManager;
+ virLockManagerPlugin *lockManager;
/* Immutable pointer, self-clocking APIs */
- virCloseCallbacksPtr closeCallbacks;
+ virCloseCallbacks *closeCallbacks;
/* Immutable pointer, self-locking APIs */
- virHashAtomicPtr migrationErrors;
+ virHashAtomic *migrationErrors;
};
-virQEMUDriverConfigPtr virQEMUDriverConfigNew(bool privileged,
+virQEMUDriverConfig *virQEMUDriverConfigNew(bool privileged,
const char *root);
-int virQEMUDriverConfigLoadFile(virQEMUDriverConfigPtr cfg,
+int virQEMUDriverConfigLoadFile(virQEMUDriverConfig *cfg,
const char *filename,
bool privileged);
int
-virQEMUDriverConfigValidate(virQEMUDriverConfigPtr cfg);
+virQEMUDriverConfigValidate(virQEMUDriverConfig *cfg);
int
-virQEMUDriverConfigSetDefaults(virQEMUDriverConfigPtr cfg);
+virQEMUDriverConfigSetDefaults(virQEMUDriverConfig *cfg);
-virQEMUDriverConfigPtr virQEMUDriverGetConfig(virQEMUDriverPtr driver);
+virQEMUDriverConfig *virQEMUDriverGetConfig(virQEMUDriver *driver);
-virCPUDefPtr virQEMUDriverGetHostCPU(virQEMUDriverPtr driver);
-virCapsPtr virQEMUDriverCreateCapabilities(virQEMUDriverPtr driver);
-virCapsPtr virQEMUDriverGetCapabilities(virQEMUDriverPtr driver,
+virCPUDef *virQEMUDriverGetHostCPU(virQEMUDriver *driver);
+virCaps *virQEMUDriverCreateCapabilities(virQEMUDriver *driver);
+virCaps *virQEMUDriverGetCapabilities(virQEMUDriver *driver,
bool refresh);
-virDomainCapsPtr
-virQEMUDriverGetDomainCapabilities(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+virDomainCaps *
+virQEMUDriverGetDomainCapabilities(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *machine,
virArch arch,
virDomainVirtType virttype);
typedef struct _qemuSharedDeviceEntry qemuSharedDeviceEntry;
-typedef qemuSharedDeviceEntry *qemuSharedDeviceEntryPtr;
-bool qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntryPtr entry,
+bool qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntry *entry,
const char *name,
int *idx)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void qemuSharedDeviceEntryFree(void *payload);
-int qemuAddSharedDisk(virQEMUDriverPtr driver,
- virDomainDiskDefPtr disk,
+int qemuAddSharedDisk(virQEMUDriver *driver,
+ virDomainDiskDef *disk,
const char *name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuAddSharedDevice(virQEMUDriverPtr driver,
- virDomainDeviceDefPtr dev,
+int qemuAddSharedDevice(virQEMUDriver *driver,
+ virDomainDeviceDef *dev,
const char *name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuRemoveSharedDevice(virQEMUDriverPtr driver,
- virDomainDeviceDefPtr dev,
+int qemuRemoveSharedDevice(virQEMUDriver *driver,
+ virDomainDeviceDef *dev,
const char *name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuRemoveSharedDisk(virQEMUDriverPtr driver,
- virDomainDiskDefPtr disk,
+int qemuRemoveSharedDisk(virQEMUDriver *driver,
+ virDomainDiskDef *disk,
const char *name)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuSetUnprivSGIO(virDomainDeviceDefPtr dev);
+int qemuSetUnprivSGIO(virDomainDeviceDef *dev);
-int qemuDriverAllocateID(virQEMUDriverPtr driver);
-virDomainXMLOptionPtr virQEMUDriverCreateXMLConf(virQEMUDriverPtr driver,
+int qemuDriverAllocateID(virQEMUDriver *driver);
+virDomainXMLOption *virQEMUDriverCreateXMLConf(virQEMUDriver *driver,
const char *defsecmodel);
-int qemuTranslateSnapshotDiskSourcePool(virDomainSnapshotDiskDefPtr def);
+int qemuTranslateSnapshotDiskSourcePool(virDomainSnapshotDiskDef *def);
-char * qemuGetBaseHugepagePath(virQEMUDriverPtr driver,
- virHugeTLBFSPtr hugepage);
-char * qemuGetDomainHugepagePath(virQEMUDriverPtr driver,
+char * qemuGetBaseHugepagePath(virQEMUDriver *driver,
+ virHugeTLBFS *hugepage);
+char * qemuGetDomainHugepagePath(virQEMUDriver *driver,
const virDomainDef *def,
- virHugeTLBFSPtr hugepage);
+ virHugeTLBFS *hugepage);
-int qemuGetDomainHupageMemPath(virQEMUDriverPtr driver,
+int qemuGetDomainHupageMemPath(virQEMUDriver *driver,
const virDomainDef *def,
unsigned long long pagesize,
char **memPath);
-int qemuGetMemoryBackingDomainPath(virQEMUDriverPtr driver,
+int qemuGetMemoryBackingDomainPath(virQEMUDriver *driver,
const virDomainDef *def,
char **path);
-int qemuGetMemoryBackingPath(virQEMUDriverPtr driver,
+int qemuGetMemoryBackingPath(virQEMUDriver *driver,
const virDomainDef *def,
const char *alias,
char **memPath);
static char *
-qemuDBusCreatePidFilename(virQEMUDriverConfigPtr cfg,
+qemuDBusCreatePidFilename(virQEMUDriverConfig *cfg,
const char *shortName)
{
g_autofree char *name = g_strdup_printf("%s-dbus", shortName);
static char *
-qemuDBusCreateSocketPath(virQEMUDriverConfigPtr cfg,
+qemuDBusCreateSocketPath(virQEMUDriverConfig *cfg,
const char *shortName)
{
return qemuDBusCreateFilename(cfg->dbusStateDir, shortName, ".sock");
static char *
-qemuDBusCreateConfPath(virQEMUDriverConfigPtr cfg,
+qemuDBusCreateConfPath(virQEMUDriverConfig *cfg,
const char *shortName)
{
return qemuDBusCreateFilename(cfg->dbusStateDir, shortName, ".conf");
char *
-qemuDBusGetAddress(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDBusGetAddress(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *shortName = virDomainDefGetShortName(vm->def);
void
-qemuDBusStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDBusStop(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *shortName = NULL;
g_autofree char *pidfile = NULL;
int
-qemuDBusSetupCgroup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCgroupPtr cgroup)
+qemuDBusSetupCgroup(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCgroup *cgroup)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *shortName = NULL;
g_autofree char *pidfile = NULL;
pid_t cpid = -1;
}
int
-qemuDBusStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDBusStart(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCommand) cmd = NULL;
g_autofree char *shortName = NULL;
g_autofree char *pidfile = NULL;
void
-qemuDBusVMStateAdd(virDomainObjPtr vm, const char *id)
+qemuDBusVMStateAdd(virDomainObj *vm, const char *id)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
priv->dbusVMStateIds = g_slist_append(priv->dbusVMStateIds, g_strdup(id));
}
void
-qemuDBusVMStateRemove(virDomainObjPtr vm, const char *id)
+qemuDBusVMStateRemove(virDomainObj *vm, const char *id)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
GSList *next;
for (next = priv->dbusVMStateIds; next; next = next->next) {
#include "qemu_conf.h"
#include "qemu_domain.h"
-char *qemuDBusGetAddress(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+char *qemuDBusGetAddress(virQEMUDriver *driver,
+ virDomainObj *vm);
-int qemuDBusStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+int qemuDBusStart(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDBusStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDBusStop(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDBusVMStateAdd(virDomainObjPtr vm, const char *id);
+void qemuDBusVMStateAdd(virDomainObj *vm, const char *id);
-void qemuDBusVMStateRemove(virDomainObjPtr vm, const char *id);
+void qemuDBusVMStateRemove(virDomainObj *vm, const char *id);
-int qemuDBusSetupCgroup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCgroupPtr cgroup);
+int qemuDBusSetupCgroup(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCgroup *cgroup);
void
-qemuDomainJobPrivateMigrateTempBitmapFree(qemuDomainJobPrivateMigrateTempBitmapPtr bmp)
+qemuDomainJobPrivateMigrateTempBitmapFree(qemuDomainJobPrivateMigrateTempBitmap *bmp)
{
if (!bmp)
return;
static void
qemuJobFreePrivate(void *opaque)
{
- qemuDomainJobPrivatePtr priv = opaque;
+ qemuDomainJobPrivate *priv = opaque;
if (!priv)
return;
static void
qemuJobResetPrivate(void *opaque)
{
- qemuDomainJobPrivatePtr priv = opaque;
+ qemuDomainJobPrivate *priv = opaque;
priv->spiceMigration = false;
priv->spiceMigrated = false;
static int
-qemuDomainObjPrivateXMLFormatNBDMigrationSource(virBufferPtr buf,
- virStorageSourcePtr src,
- virDomainXMLOptionPtr xmlopt)
+qemuDomainObjPrivateXMLFormatNBDMigrationSource(virBuffer *buf,
+ virStorageSource *src,
+ virDomainXMLOption *xmlopt)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static int
-qemuDomainObjPrivateXMLFormatNBDMigration(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormatNBDMigration(virBuffer *buf,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
- virDomainDiskDefPtr disk;
- qemuDomainDiskPrivatePtr diskPriv;
+ virDomainDiskDef *disk;
+ qemuDomainDiskPrivate *diskPriv;
for (i = 0; i < vm->def->ndisks; i++) {
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static void
-qemuDomainObjPrivateXMLFormatMigrateTempBitmap(virBufferPtr buf,
+qemuDomainObjPrivateXMLFormatMigrateTempBitmap(virBuffer *buf,
GSList *bitmaps)
{
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
GSList *next;
for (next = bitmaps; next; next = next->next) {
- qemuDomainJobPrivateMigrateTempBitmapPtr t = next->data;
+ qemuDomainJobPrivateMigrateTempBitmap *t = next->data;
g_auto(virBuffer) bitmapBuf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&bitmapBuf, " name='%s'", t->bitmapname);
static int
-qemuDomainFormatJobPrivate(virBufferPtr buf,
- qemuDomainJobObjPtr job,
- virDomainObjPtr vm)
+qemuDomainFormatJobPrivate(virBuffer *buf,
+ qemuDomainJobObj *job,
+ virDomainObj *vm)
{
- qemuDomainJobPrivatePtr priv = job->privateData;
+ qemuDomainJobPrivate *priv = job->privateData;
if (job->asyncJob == QEMU_ASYNC_JOB_MIGRATION_OUT) {
if (qemuDomainObjPrivateXMLFormatNBDMigration(buf, vm) < 0)
static int
qemuDomainObjPrivateXMLParseJobNBDSource(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainDiskDefPtr disk,
- virDomainXMLOptionPtr xmlopt)
+ virDomainDiskDef *disk,
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
g_autofree char *format = NULL;
g_autofree char *type = NULL;
g_autoptr(virStorageSource) migrSource = NULL;
static int
-qemuDomainObjPrivateXMLParseJobNBD(virDomainObjPtr vm,
+qemuDomainObjPrivateXMLParseJobNBD(virDomainObj *vm,
xmlXPathContextPtr ctxt)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree xmlNodePtr *nodes = NULL;
size_t i;
int n;
n = 0;
}
for (i = 0; i < n; i++) {
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
g_autofree char *dst = NULL;
if ((dst = virXMLPropString(nodes[i], "dev")) &&
static int
-qemuDomainObjPrivateXMLParseMigrateTempBitmap(qemuDomainJobPrivatePtr jobPriv,
+qemuDomainObjPrivateXMLParseMigrateTempBitmap(qemuDomainJobPrivate *jobPriv,
xmlXPathContextPtr ctxt)
{
g_autoslist(qemuDomainJobPrivateMigrateTempBitmap) bitmaps = NULL;
return 0;
for (i = 0; i < n; i++) {
- qemuDomainJobPrivateMigrateTempBitmapPtr bmp;
+ qemuDomainJobPrivateMigrateTempBitmap *bmp;
bmp = g_new0(qemuDomainJobPrivateMigrateTempBitmap, 1);
bmp->nodename = virXMLPropString(nodes[i], "nodename");
static int
qemuDomainParseJobPrivate(xmlXPathContextPtr ctxt,
- qemuDomainJobObjPtr job,
- virDomainObjPtr vm)
+ qemuDomainJobObj *job,
+ virDomainObj *vm)
{
- qemuDomainJobPrivatePtr priv = job->privateData;
+ qemuDomainJobPrivate *priv = job->privateData;
if (qemuDomainObjPrivateXMLParseJobNBD(vm, ctxt) < 0)
return -1;
* qemuDomainObjFromDomain:
* @domain: Domain pointer that has to be looked up
*
- * This function looks up @domain and returns the appropriate virDomainObjPtr
+ * This function looks up @domain and returns the appropriate virDomainObj *
* that has to be released by calling virDomainObjEndAPI().
*
* Returns the domain object with incremented reference counter which is locked
* on success, NULL otherwise.
*/
-virDomainObjPtr
+virDomainObj *
qemuDomainObjFromDomain(virDomainPtr domain)
{
- virDomainObjPtr vm;
- virQEMUDriverPtr driver = domain->conn->privateData;
+ virDomainObj *vm;
+ virQEMUDriver *driver = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
off_t pos;
ino_t inode; /* Only used if manager != NULL */
char *path;
- virLogManagerPtr manager;
+ virLogManager *manager;
};
G_DEFINE_TYPE(qemuDomainLogContext, qemu_domain_log_context, G_TYPE_OBJECT);
-static virClassPtr qemuDomainSaveCookieClass;
+static virClass *qemuDomainSaveCookieClass;
static void qemuDomainLogContextFinalize(GObject *obj);
static void qemuDomainSaveCookieDispose(void *obj);
static void
qemuDomainLogContextFinalize(GObject *object)
{
- qemuDomainLogContextPtr ctxt = QEMU_DOMAIN_LOG_CONTEXT(object);
+ qemuDomainLogContext *ctxt = QEMU_DOMAIN_LOG_CONTEXT(object);
VIR_DEBUG("ctxt=%p", ctxt);
virLogManagerFree(ctxt->manager);
* Returns 0 on success, -1 on failure with error message indicating failure
*/
int
-qemuDomainWriteMasterKeyFile(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainWriteMasterKeyFile(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autofree char *path = NULL;
VIR_AUTOCLOSE fd = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
/* Only gets filled in if we have the capability */
if (!priv->masterKey)
static void
-qemuDomainMasterKeyFree(qemuDomainObjPrivatePtr priv)
+qemuDomainMasterKeyFree(qemuDomainObjPrivate *priv)
{
if (!priv->masterKey)
return;
* -1 on failure with error message indicating failure
*/
int
-qemuDomainMasterKeyReadFile(qemuDomainObjPrivatePtr priv)
+qemuDomainMasterKeyReadFile(qemuDomainObjPrivate *priv)
{
g_autofree char *path = NULL;
int fd = -1;
* delete the file.
*/
void
-qemuDomainMasterKeyRemove(qemuDomainObjPrivatePtr priv)
+qemuDomainMasterKeyRemove(qemuDomainObjPrivate *priv)
{
g_autofree char *path = NULL;
* Returns: 0 on success, -1 w/ error message on failure
*/
int
-qemuDomainMasterKeyCreate(virDomainObjPtr vm)
+qemuDomainMasterKeyCreate(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree uint8_t *key = NULL;
/* If we don't have the capability, then do nothing. */
static void
-qemuDomainSecretPlainClear(qemuDomainSecretPlainPtr secret)
+qemuDomainSecretPlainClear(struct _qemuDomainSecretPlain *secret)
{
VIR_FREE(secret->username);
virSecureErase(secret->secret, secret->secretlen);
static void
-qemuDomainSecretAESClear(qemuDomainSecretAESPtr secret,
+qemuDomainSecretAESClear(struct _qemuDomainSecretAES *secret,
bool keepAlias)
{
if (!keepAlias)
static void
-qemuDomainSecretInfoClear(qemuDomainSecretInfoPtr secinfo,
+qemuDomainSecretInfoClear(qemuDomainSecretInfo *secinfo,
bool keepAlias)
{
if (!secinfo)
void
-qemuDomainSecretInfoFree(qemuDomainSecretInfoPtr secinfo)
+qemuDomainSecretInfoFree(qemuDomainSecretInfo *secinfo)
{
qemuDomainSecretInfoClear(secinfo, false);
g_free(secinfo);
* Removes any data unnecessary for further use, but keeps alias allocated.
*/
void
-qemuDomainSecretInfoDestroy(qemuDomainSecretInfoPtr secinfo)
+qemuDomainSecretInfoDestroy(qemuDomainSecretInfo *secinfo)
{
qemuDomainSecretInfoClear(secinfo, true);
}
-static virClassPtr qemuDomainDiskPrivateClass;
+static virClass *qemuDomainDiskPrivateClass;
static void qemuDomainDiskPrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainDiskPrivate);
-static virObjectPtr
+static virObject *
qemuDomainDiskPrivateNew(void)
{
- qemuDomainDiskPrivatePtr priv;
+ qemuDomainDiskPrivate *priv;
if (qemuDomainDiskPrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainDiskPrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainDiskPrivateDispose(void *obj)
{
- qemuDomainDiskPrivatePtr priv = obj;
+ qemuDomainDiskPrivate *priv = obj;
virObjectUnref(priv->migrSource);
g_free(priv->qomName);
virObjectUnref(priv->blockjob);
}
-static virClassPtr qemuDomainStorageSourcePrivateClass;
+static virClass *qemuDomainStorageSourcePrivateClass;
static void qemuDomainStorageSourcePrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainStorageSourcePrivate);
-virObjectPtr
+virObject *
qemuDomainStorageSourcePrivateNew(void)
{
- qemuDomainStorageSourcePrivatePtr priv;
+ qemuDomainStorageSourcePrivate *priv;
if (qemuDomainStorageSourcePrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainStorageSourcePrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainStorageSourcePrivateDispose(void *obj)
{
- qemuDomainStorageSourcePrivatePtr priv = obj;
+ qemuDomainStorageSourcePrivate *priv = obj;
g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
g_clear_pointer(&priv->encinfo, qemuDomainSecretInfoFree);
}
-qemuDomainStorageSourcePrivatePtr
-qemuDomainStorageSourcePrivateFetch(virStorageSourcePtr src)
+qemuDomainStorageSourcePrivate *
+qemuDomainStorageSourcePrivateFetch(virStorageSource *src)
{
if (!src->privateData)
src->privateData = qemuDomainStorageSourcePrivateNew();
}
-static virClassPtr qemuDomainVcpuPrivateClass;
+static virClass *qemuDomainVcpuPrivateClass;
static void qemuDomainVcpuPrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainVcpuPrivate);
-static virObjectPtr
+static virObject *
qemuDomainVcpuPrivateNew(void)
{
- qemuDomainVcpuPrivatePtr priv;
+ qemuDomainVcpuPrivate *priv;
if (qemuDomainVcpuPrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainVcpuPrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainVcpuPrivateDispose(void *obj)
{
- qemuDomainVcpuPrivatePtr priv = obj;
+ qemuDomainVcpuPrivate *priv = obj;
g_free(priv->type);
g_free(priv->alias);
}
-static virClassPtr qemuDomainChrSourcePrivateClass;
+static virClass *qemuDomainChrSourcePrivateClass;
static void qemuDomainChrSourcePrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainChrSourcePrivate);
-static virObjectPtr
+static virObject *
qemuDomainChrSourcePrivateNew(void)
{
- qemuDomainChrSourcePrivatePtr priv;
+ qemuDomainChrSourcePrivate *priv;
if (qemuDomainChrSourcePrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainChrSourcePrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainChrSourcePrivateDispose(void *obj)
{
- qemuDomainChrSourcePrivatePtr priv = obj;
+ qemuDomainChrSourcePrivate *priv = obj;
g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
}
-static virClassPtr qemuDomainVsockPrivateClass;
+static virClass *qemuDomainVsockPrivateClass;
static void qemuDomainVsockPrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainVsockPrivate);
-static virObjectPtr
+static virObject *
qemuDomainVsockPrivateNew(void)
{
- qemuDomainVsockPrivatePtr priv;
+ qemuDomainVsockPrivate *priv;
if (qemuDomainVsockPrivateInitialize() < 0)
return NULL;
priv->vhostfd = -1;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainVsockPrivateDispose(void *obj G_GNUC_UNUSED)
{
- qemuDomainVsockPrivatePtr priv = obj;
+ qemuDomainVsockPrivate *priv = obj;
VIR_FORCE_CLOSE(priv->vhostfd);
}
-static virClassPtr qemuDomainGraphicsPrivateClass;
+static virClass *qemuDomainGraphicsPrivateClass;
static void qemuDomainGraphicsPrivateDispose(void *obj);
static int
VIR_ONCE_GLOBAL_INIT(qemuDomainGraphicsPrivate);
-static virObjectPtr
+static virObject *
qemuDomainGraphicsPrivateNew(void)
{
- qemuDomainGraphicsPrivatePtr priv;
+ qemuDomainGraphicsPrivate *priv;
if (qemuDomainGraphicsPrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainGraphicsPrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainGraphicsPrivateDispose(void *obj)
{
- qemuDomainGraphicsPrivatePtr priv = obj;
+ qemuDomainGraphicsPrivate *priv = obj;
g_free(priv->tlsAlias);
g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
}
-static virClassPtr qemuDomainNetworkPrivateClass;
+static virClass *qemuDomainNetworkPrivateClass;
static void qemuDomainNetworkPrivateDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(qemuDomainNetworkPrivate);
-static virObjectPtr
+static virObject *
qemuDomainNetworkPrivateNew(void)
{
- qemuDomainNetworkPrivatePtr priv;
+ qemuDomainNetworkPrivate *priv;
if (qemuDomainNetworkPrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainNetworkPrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainNetworkPrivateDispose(void *obj G_GNUC_UNUSED)
{
- qemuDomainNetworkPrivatePtr priv = obj;
+ qemuDomainNetworkPrivate *priv = obj;
qemuSlirpFree(priv->slirp);
}
-static virClassPtr qemuDomainFSPrivateClass;
+static virClass *qemuDomainFSPrivateClass;
static void qemuDomainFSPrivateDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(qemuDomainFSPrivate);
-static virObjectPtr
+static virObject *
qemuDomainFSPrivateNew(void)
{
- qemuDomainFSPrivatePtr priv;
+ qemuDomainFSPrivate *priv;
if (qemuDomainFSPrivateInitialize() < 0)
return NULL;
if (!(priv = virObjectNew(qemuDomainFSPrivateClass)))
return NULL;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainFSPrivateDispose(void *obj)
{
- qemuDomainFSPrivatePtr priv = obj;
+ qemuDomainFSPrivate *priv = obj;
g_free(priv->vhostuser_fs_sock);
}
-static virClassPtr qemuDomainVideoPrivateClass;
+static virClass *qemuDomainVideoPrivateClass;
static void qemuDomainVideoPrivateDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(qemuDomainVideoPrivate);
-static virObjectPtr
+static virObject *
qemuDomainVideoPrivateNew(void)
{
- qemuDomainVideoPrivatePtr priv;
+ qemuDomainVideoPrivate *priv;
if (qemuDomainVideoPrivateInitialize() < 0)
return NULL;
priv->vhost_user_fd = -1;
- return (virObjectPtr) priv;
+ return (virObject *) priv;
}
static void
qemuDomainVideoPrivateDispose(void *obj)
{
- qemuDomainVideoPrivatePtr priv = obj;
+ qemuDomainVideoPrivate *priv = obj;
VIR_FORCE_CLOSE(priv->vhost_user_fd);
}
* Returns 0 on success, -1 on failure with error message
*/
static int
-qemuDomainSecretPlainSetup(qemuDomainSecretInfoPtr secinfo,
+qemuDomainSecretPlainSetup(qemuDomainSecretInfo *secinfo,
virSecretUsageType usageType,
const char *username,
- virSecretLookupTypeDefPtr seclookupdef)
+ virSecretLookupTypeDef *seclookupdef)
{
g_autoptr(virConnect) conn = virGetConnectSecret();
int ret = -1;
*
* Encrypts @secret for use with qemu.
*
- * Returns qemuDomainSecretInfoPtr filled with the necessary information.
+ * Returns qemuDomainSecretInfo *filled with the necessary information.
*/
-static qemuDomainSecretInfoPtr
-qemuDomainSecretAESSetup(qemuDomainObjPrivatePtr priv,
+static qemuDomainSecretInfo *
+qemuDomainSecretAESSetup(qemuDomainObjPrivate *priv,
const char *alias,
const char *username,
uint8_t *secret,
* @seclookupdef: Pointer to seclookupdef data
*
* Looks up a secret in the secret driver based on @usageType and @seclookupdef
- * and builds qemuDomainSecretInfoPtr from it. @use describes the usage of the
+ * and builds qemuDomainSecretInfo *from it. @use describes the usage of the
* secret in case if @srcalias requires more secrets for various usage cases.
*/
-static qemuDomainSecretInfoPtr
-qemuDomainSecretAESSetupFromSecret(qemuDomainObjPrivatePtr priv,
+static qemuDomainSecretInfo *
+qemuDomainSecretAESSetupFromSecret(qemuDomainObjPrivate *priv,
const char *srcalias,
const char *secretuse,
virSecretUsageType usageType,
const char *username,
- virSecretLookupTypeDefPtr seclookupdef)
+ virSecretLookupTypeDef *seclookupdef)
{
g_autoptr(virConnect) conn = virGetConnectSecret();
- qemuDomainSecretInfoPtr secinfo;
+ qemuDomainSecretInfo *secinfo;
g_autofree char *alias = qemuAliasForSecret(srcalias, secretuse);
g_autofree uint8_t *secret = NULL;
size_t secretlen = 0;
* @priv belongs to.
*/
bool
-qemuDomainSupportsEncryptedSecret(qemuDomainObjPrivatePtr priv)
+qemuDomainSupportsEncryptedSecret(qemuDomainObjPrivate *priv)
{
return virCryptoHaveCipher(VIR_CRYPTO_CIPHER_AES256CBC) &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET) &&
* Returns @secinfo on success, NULL on failure. Caller is responsible
* to eventually free @secinfo.
*/
-static qemuDomainSecretInfoPtr
+static qemuDomainSecretInfo *
qemuDomainSecretInfoNewPlain(virSecretUsageType usageType,
const char *username,
- virSecretLookupTypeDefPtr lookupDef)
+ virSecretLookupTypeDef *lookupDef)
{
- qemuDomainSecretInfoPtr secinfo = NULL;
+ qemuDomainSecretInfo *secinfo = NULL;
secinfo = g_new0(qemuDomainSecretInfo, 1);
* @secretUUID: Provide a secretUUID value to look up/create the secretInfo
*
* Using the passed @secretUUID, generate a seclookupdef that can be used
- * to generate the returned qemuDomainSecretInfoPtr for a TLS based secret.
+ * to generate the returned qemuDomainSecretInfo *for a TLS based secret.
*
- * Returns qemuDomainSecretInfoPtr or NULL on error.
+ * Returns qemuDomainSecretInfo *or NULL on error.
*/
-qemuDomainSecretInfoPtr
-qemuDomainSecretInfoTLSNew(qemuDomainObjPrivatePtr priv,
+qemuDomainSecretInfo *
+qemuDomainSecretInfoTLSNew(qemuDomainObjPrivate *priv,
const char *srcAlias,
const char *secretUUID)
{
void
-qemuDomainSecretDiskDestroy(virDomainDiskDefPtr disk)
+qemuDomainSecretDiskDestroy(virDomainDiskDef *disk)
{
- qemuDomainStorageSourcePrivatePtr srcPriv;
- virStorageSourcePtr n;
+ qemuDomainStorageSourcePrivate *srcPriv;
+ virStorageSource *n;
for (n = disk->src; virStorageSourceIsBacking(n); n = n->backingStore) {
if ((srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(n))) {
bool
-qemuDomainStorageSourceHasAuth(virStorageSourcePtr src)
+qemuDomainStorageSourceHasAuth(virStorageSource *src)
{
if (!virStorageSourceIsEmpty(src) &&
virStorageSourceGetActualType(src) == VIR_STORAGE_TYPE_NETWORK &&
static bool
-qemuDomainDiskHasEncryptionSecret(virStorageSourcePtr src)
+qemuDomainDiskHasEncryptionSecret(virStorageSource *src)
{
if (!virStorageSourceIsEmpty(src) && src->encryption &&
src->encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS &&
}
-static qemuDomainSecretInfoPtr
-qemuDomainSecretStorageSourcePrepareCookies(qemuDomainObjPrivatePtr priv,
- virStorageSourcePtr src,
+static qemuDomainSecretInfo *
+qemuDomainSecretStorageSourcePrepareCookies(qemuDomainObjPrivate *priv,
+ virStorageSource *src,
const char *aliasprotocol)
{
g_autofree char *secretalias = qemuAliasForSecret(aliasprotocol, "httpcookie");
* Returns 0 on success; -1 on error while reporting an libvirt error.
*/
static int
-qemuDomainSecretStorageSourcePrepare(qemuDomainObjPrivatePtr priv,
- virStorageSourcePtr src,
+qemuDomainSecretStorageSourcePrepare(qemuDomainObjPrivate *priv,
+ virStorageSource *src,
const char *aliasprotocol,
const char *aliasformat)
{
- qemuDomainStorageSourcePrivatePtr srcPriv;
+ qemuDomainStorageSourcePrivate *srcPriv;
bool iscsiHasPS = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_ISCSI_PASSWORD_SECRET);
bool hasAuth = qemuDomainStorageSourceHasAuth(src);
bool hasEnc = qemuDomainDiskHasEncryptionSecret(src);
void
-qemuDomainSecretHostdevDestroy(virDomainHostdevDefPtr hostdev)
+qemuDomainSecretHostdevDestroy(virDomainHostdevDef *hostdev)
{
- qemuDomainStorageSourcePrivatePtr srcPriv;
+ qemuDomainStorageSourcePrivate *srcPriv;
if (virHostdevIsSCSIDevice(hostdev)) {
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(iscsisrc->src);
void
-qemuDomainSecretChardevDestroy(virDomainChrSourceDefPtr dev)
+qemuDomainSecretChardevDestroy(virDomainChrSourceDef *dev)
{
- qemuDomainChrSourcePrivatePtr chrSourcePriv =
+ qemuDomainChrSourcePrivate *chrSourcePriv =
QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);
if (!chrSourcePriv || !chrSourcePriv->secinfo)
* Returns 0 on success, -1 on failure
*/
int
-qemuDomainSecretChardevPrepare(virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+qemuDomainSecretChardevPrepare(virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const char *chrAlias,
- virDomainChrSourceDefPtr dev)
+ virDomainChrSourceDef *dev)
{
g_autofree char *charAlias = NULL;
if (dev->data.tcp.haveTLS == VIR_TRISTATE_BOOL_YES &&
cfg->chardevTLSx509secretUUID) {
- qemuDomainChrSourcePrivatePtr chrSourcePriv =
+ qemuDomainChrSourcePrivate *chrSourcePriv =
QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);
if (!(charAlias = qemuAliasChardevFromDevAlias(chrAlias)))
static void
-qemuDomainSecretGraphicsDestroy(virDomainGraphicsDefPtr graphics)
+qemuDomainSecretGraphicsDestroy(virDomainGraphicsDef *graphics)
{
- qemuDomainGraphicsPrivatePtr gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
+ qemuDomainGraphicsPrivate *gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
if (!gfxPriv)
return;
static int
-qemuDomainSecretGraphicsPrepare(virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
- virDomainGraphicsDefPtr graphics)
+qemuDomainSecretGraphicsPrepare(virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
+ virDomainGraphicsDef *graphics)
{
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
- qemuDomainGraphicsPrivatePtr gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
+ qemuDomainGraphicsPrivate *gfxPriv = QEMU_DOMAIN_GRAPHICS_PRIVATE(graphics);
if (graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC)
return 0;
* Removes all unnecessary data which was needed to generate 'secret' objects.
*/
void
-qemuDomainSecretDestroy(virDomainObjPtr vm)
+qemuDomainSecretDestroy(virDomainObj *vm)
{
size_t i;
* Returns 0 on success, -1 on failure with error message set
*/
int
-qemuDomainSecretPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainSecretPrepare(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
size_t i;
/* This is the old way of setting up per-domain directories */
static void
-qemuDomainSetPrivatePathsOld(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainSetPrivatePathsOld(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
if (!priv->libDir)
int
-qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainSetPrivatePaths(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *domname = virDomainDefGetShortName(vm->def);
if (!domname)
int
-qemuDomainObjStartWorker(virDomainObjPtr dom)
+qemuDomainObjStartWorker(virDomainObj *dom)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
if (!priv->eventThread) {
g_autofree char *threadName = g_strdup_printf("vm-%s", dom->def->name);
void
-qemuDomainObjStopWorker(virDomainObjPtr dom)
+qemuDomainObjStopWorker(virDomainObj *dom)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
virEventThread *eventThread;
if (!priv->eventThread)
static void *
qemuDomainObjPrivateAlloc(void *opaque)
{
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
priv = g_new0(qemuDomainObjPrivate, 1);
* not running.
*/
void
-qemuDomainObjPrivateDataClear(qemuDomainObjPrivatePtr priv)
+qemuDomainObjPrivateDataClear(qemuDomainObjPrivate *priv)
{
g_strfreev(priv->qemuDevices);
priv->qemuDevices = NULL;
static void
qemuDomainObjPrivateFree(void *data)
{
- qemuDomainObjPrivatePtr priv = data;
+ qemuDomainObjPrivate *priv = data;
qemuDomainObjPrivateDataClear(priv);
static int
-qemuStorageSourcePrivateDataAssignSecinfo(qemuDomainSecretInfoPtr *secinfo,
+qemuStorageSourcePrivateDataAssignSecinfo(qemuDomainSecretInfo **secinfo,
char **alias)
{
if (!*alias)
static int
qemuStorageSourcePrivateDataParse(xmlXPathContextPtr ctxt,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
- qemuDomainStorageSourcePrivatePtr priv;
+ qemuDomainStorageSourcePrivate *priv;
g_autofree char *authalias = NULL;
g_autofree char *encalias = NULL;
g_autofree char *httpcookiealias = NULL;
static void
-qemuStorageSourcePrivateDataFormatSecinfo(virBufferPtr buf,
- qemuDomainSecretInfoPtr secinfo,
+qemuStorageSourcePrivateDataFormatSecinfo(virBuffer *buf,
+ qemuDomainSecretInfo *secinfo,
const char *type)
{
if (!secinfo ||
static int
-qemuStorageSourcePrivateDataFormat(virStorageSourcePtr src,
- virBufferPtr buf)
+qemuStorageSourcePrivateDataFormat(virStorageSource *src,
+ virBuffer *buf)
{
g_auto(virBuffer) tmp = VIR_BUFFER_INIT_CHILD(buf);
- qemuDomainStorageSourcePrivatePtr srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
+ qemuDomainStorageSourcePrivate *srcPriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src);
g_auto(virBuffer) nodenamesChildBuf = VIR_BUFFER_INIT_CHILD(buf);
virBufferEscapeString(&nodenamesChildBuf, "<nodename type='storage' name='%s'/>\n", src->nodestorage);
static int
qemuDomainDiskPrivateParse(xmlXPathContextPtr ctxt,
- virDomainDiskDefPtr disk)
+ virDomainDiskDef *disk)
{
- qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
priv->qomName = virXPathString("string(./qom/@name)", ctxt);
priv->nodeCopyOnRead = virXPathString("string(./nodenames/nodename[@type='copyOnRead']/@name)", ctxt);
static int
-qemuDomainDiskPrivateFormat(virDomainDiskDefPtr disk,
- virBufferPtr buf)
+qemuDomainDiskPrivateFormat(virDomainDiskDef *disk,
+ virBuffer *buf)
{
- qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
virBufferEscapeString(buf, "<qom name='%s'/>\n", priv->qomName);
static void
-qemuDomainObjPrivateXMLFormatVcpus(virBufferPtr buf,
- virDomainDefPtr def)
+qemuDomainObjPrivateXMLFormatVcpus(virBuffer *buf,
+ virDomainDef *def)
{
size_t i;
size_t maxvcpus = virDomainDefGetVcpusMax(def);
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
pid_t tid;
virBufferAddLit(buf, "<vcpus>\n");
static int
-qemuDomainObjPrivateXMLFormatAutomaticPlacement(virBufferPtr buf,
- qemuDomainObjPrivatePtr priv)
+qemuDomainObjPrivateXMLFormatAutomaticPlacement(virBuffer *buf,
+ qemuDomainObjPrivate *priv)
{
g_autofree char *nodeset = NULL;
g_autofree char *cpuset = NULL;
typedef struct qemuDomainPrivateBlockJobFormatData {
- virDomainXMLOptionPtr xmlopt;
- virBufferPtr buf;
+ virDomainXMLOption *xmlopt;
+ virBuffer *buf;
} qemuDomainPrivateBlockJobFormatData;
static int
-qemuDomainObjPrivateXMLFormatBlockjobFormatSource(virBufferPtr buf,
+qemuDomainObjPrivateXMLFormatBlockjobFormatSource(virBuffer *buf,
const char *element,
- virStorageSourcePtr src,
- virDomainXMLOptionPtr xmlopt,
+ virStorageSource *src,
+ virDomainXMLOption *xmlopt,
bool chain)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
static void
-qemuDomainPrivateBlockJobFormatCommit(qemuBlockJobDataPtr job,
- virBufferPtr buf)
+qemuDomainPrivateBlockJobFormatCommit(qemuBlockJobData *job,
+ virBuffer *buf)
{
g_auto(virBuffer) disabledBitmapsBuf = VIR_BUFFER_INIT_CHILD(buf);
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(data->buf);
g_auto(virBuffer) chainsBuf = VIR_BUFFER_INIT_CHILD(&childBuf);
- qemuBlockJobDataPtr job = payload;
+ qemuBlockJobData *job = payload;
const char *state = qemuBlockjobStateTypeToString(job->state);
const char *newstate = NULL;
static int
-qemuDomainObjPrivateXMLFormatBlockjobs(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormatBlockjobs(virBuffer *buf,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
bool bj = qemuDomainHasBlockjob(vm, false);
static int
-qemuDomainObjPrivateXMLFormatBackups(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormatBackups(virBuffer *buf,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
void
-qemuDomainObjPrivateXMLFormatAllowReboot(virBufferPtr buf,
+qemuDomainObjPrivateXMLFormatAllowReboot(virBuffer *buf,
virTristateBool allowReboot)
{
virBufferAsprintf(buf, "<allowReboot value='%s'/>\n",
static void
-qemuDomainObjPrivateXMLFormatPR(virBufferPtr buf,
- qemuDomainObjPrivatePtr priv)
+qemuDomainObjPrivateXMLFormatPR(virBuffer *buf,
+ qemuDomainObjPrivate *priv)
{
if (priv->prDaemonRunning)
virBufferAddLit(buf, "<prDaemon/>\n");
static bool
-qemuDomainHasSlirp(virDomainObjPtr vm)
+qemuDomainHasSlirp(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
if (QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp)
return true;
static bool
-qemuDomainGetSlirpHelperOk(virDomainObjPtr vm)
+qemuDomainGetSlirpHelperOk(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
/* if there is a builtin slirp, prevent slirp-helper */
if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
static int
-qemuDomainObjPrivateXMLFormatSlirp(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormatSlirp(virBuffer *buf,
+ virDomainObj *vm)
{
size_t i;
virBufferAdjustIndent(buf, 2);
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
- qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
+ virDomainNetDef *net = vm->def->nets[i];
+ qemuSlirp *slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
size_t j;
if (!slirp)
}
static int
-qemuDomainObjPrivateXMLFormat(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormat(virBuffer *buf,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
const char *monitorpath;
/* priv->monitor_chr is set only for qemu */
static int
qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
unsigned int idx,
- virDomainDefPtr def)
+ virDomainDef *def)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
g_autofree char *idstr = NULL;
g_autofree char *pidstr = NULL;
unsigned int tmp;
static int
qemuDomainObjPrivateXMLParseAutomaticPlacement(xmlXPathContextPtr ctxt,
- qemuDomainObjPrivatePtr priv)
+ qemuDomainObjPrivate *priv)
{
g_autoptr(virCapsHostNUMA) caps = NULL;
g_autofree char *nodeset = NULL;
* This is necessary because NUMA node IDs are not guaranteed to
* start from 0 or be densely allocated */
for (i = 0; i < caps->cells->len; i++) {
- virCapsHostNUMACellPtr cell =
+ virCapsHostNUMACell *cell =
g_ptr_array_index(caps->cells, i);
nodesetSize = MAX(nodesetSize, cell->num + 1);
}
}
-static virStorageSourcePtr
+static virStorageSource *
qemuDomainObjPrivateXMLParseBlockjobChain(xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
* pointer to it.
* On failure NULL is returned and no error is reported.
*/
-static virStorageSourcePtr
-qemuDomainVirStorageSourceFindByNodeName(virStorageSourcePtr top,
+static virStorageSource *
+qemuDomainVirStorageSourceFindByNodeName(virStorageSource *top,
const char *nodeName)
{
- virStorageSourcePtr tmp;
+ virStorageSource *tmp;
for (tmp = top; virStorageSourceIsBacking(tmp); tmp = tmp->backingStore) {
if ((tmp->nodeformat && STREQ(tmp->nodeformat, nodeName)) ||
static void
-qemuDomainObjPrivateXMLParseBlockjobNodename(qemuBlockJobDataPtr job,
+qemuDomainObjPrivateXMLParseBlockjobNodename(qemuBlockJobData *job,
const char *xpath,
- virStorageSourcePtr *src,
+ virStorageSource **src,
xmlXPathContextPtr ctxt)
{
g_autofree char *nodename = NULL;
static int
-qemuDomainObjPrivateXMLParseBlockjobDataCommit(qemuBlockJobDataPtr job,
+qemuDomainObjPrivateXMLParseBlockjobDataCommit(qemuBlockJobData *job,
xmlXPathContextPtr ctxt)
{
if (job->type == QEMU_BLOCKJOB_TYPE_COMMIT) {
static void
-qemuDomainObjPrivateXMLParseBlockjobDataSpecific(qemuBlockJobDataPtr job,
+qemuDomainObjPrivateXMLParseBlockjobDataSpecific(qemuBlockJobData *job,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
g_autofree char *createmode = NULL;
g_autofree char *shallownew = NULL;
static int
-qemuDomainObjPrivateXMLParseBlockjobData(virDomainObjPtr vm,
+qemuDomainObjPrivateXMLParseBlockjobData(virDomainObj *vm,
xmlNodePtr node,
xmlXPathContextPtr ctxt,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
g_autoptr(qemuBlockJobData) job = NULL;
g_autofree char *name = NULL;
g_autofree char *typestr = NULL;
static int
-qemuDomainObjPrivateXMLParseBlockjobs(virDomainObjPtr vm,
- qemuDomainObjPrivatePtr priv,
+qemuDomainObjPrivateXMLParseBlockjobs(virDomainObj *vm,
+ qemuDomainObjPrivate *priv,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-qemuDomainObjPrivateXMLParseBackups(qemuDomainObjPrivatePtr priv,
+qemuDomainObjPrivateXMLParseBackups(qemuDomainObjPrivate *priv,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
qemuDomainObjPrivateXMLParseSlirpFeatures(xmlNodePtr featuresNode,
xmlXPathContextPtr ctxt,
- qemuSlirpPtr slirp)
+ qemuSlirp *slirp)
{
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree xmlNodePtr *nodes = NULL;
static int
qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
- virDomainObjPtr vm,
- virDomainDefParserConfigPtr config)
+ virDomainObj *vm,
+ virDomainDefParserConfig *config)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = config->priv;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = config->priv;
char *monitorpath;
g_autofree char *tmp = NULL;
int n;
static void *
-qemuDomainObjPrivateXMLGetParseOpaque(virDomainObjPtr vm)
+qemuDomainObjPrivateXMLGetParseOpaque(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
return priv->qemuCaps;
}
static void
-qemuDomainXmlNsDefFree(qemuDomainXmlNsDefPtr def)
+qemuDomainXmlNsDefFree(qemuDomainXmlNsDef *def)
{
if (!def)
return;
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
- qemuDomainXmlNsDefPtr cmd = nsdata;
+ qemuDomainXmlNsDef *cmd = nsdata;
qemuDomainXmlNsDefFree(cmd);
}
static int
-qemuDomainDefNamespaceParseCommandlineArgs(qemuDomainXmlNsDefPtr nsdef,
+qemuDomainDefNamespaceParseCommandlineArgs(qemuDomainXmlNsDef *nsdef,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-qemuDomainDefNamespaceParseCommandlineEnv(qemuDomainXmlNsDefPtr nsdef,
+qemuDomainDefNamespaceParseCommandlineEnv(qemuDomainXmlNsDef *nsdef,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodes = NULL;
static int
-qemuDomainDefNamespaceParseCaps(qemuDomainXmlNsDefPtr nsdef,
+qemuDomainDefNamespaceParseCaps(qemuDomainXmlNsDef *nsdef,
xmlXPathContextPtr ctxt)
{
g_autofree xmlNodePtr *nodesadd = NULL;
qemuDomainDefNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- qemuDomainXmlNsDefPtr nsdata = NULL;
+ qemuDomainXmlNsDef *nsdata = NULL;
int ret = -1;
nsdata = g_new0(qemuDomainXmlNsDef, 1);
static void
-qemuDomainDefNamespaceFormatXMLCommandline(virBufferPtr buf,
- qemuDomainXmlNsDefPtr cmd)
+qemuDomainDefNamespaceFormatXMLCommandline(virBuffer *buf,
+ qemuDomainXmlNsDef *cmd)
{
size_t i;
static void
-qemuDomainDefNamespaceFormatXMLCaps(virBufferPtr buf,
- qemuDomainXmlNsDefPtr xmlns)
+qemuDomainDefNamespaceFormatXMLCaps(virBuffer *buf,
+ qemuDomainXmlNsDef *xmlns)
{
size_t i;
static int
-qemuDomainDefNamespaceFormatXML(virBufferPtr buf,
+qemuDomainDefNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
- qemuDomainXmlNsDefPtr cmd = nsdata;
+ qemuDomainXmlNsDef *cmd = nsdata;
qemuDomainDefNamespaceFormatXMLCommandline(buf, cmd);
qemuDomainDefNamespaceFormatXMLCaps(buf, cmd);
}
static int
-qemuDomainDefAddDefaultAudioBackend(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuDomainDefAddDefaultAudioBackend(virQEMUDriver *driver,
+ virDomainDef *def)
{
size_t i;
bool addAudio = false;
}
for (i = 0; i < def->ngraphics; i++) {
- virDomainGraphicsDefPtr graph = def->graphics[i];
+ virDomainGraphicsDef *graph = def->graphics[i];
switch ((virDomainGraphicsType)graph->type) {
case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
}
}
if (addAudio) {
- virDomainAudioDefPtr audio = g_new0(virDomainAudioDef, 1);
+ virDomainAudioDef *audio = g_new0(virDomainAudioDef, 1);
audio->type = audioBackend;
audio->id = 1;
def->naudios = 1;
- def->audios = g_new0(virDomainAudioDefPtr, def->naudios);
+ def->audios = g_new0(virDomainAudioDef *, def->naudios);
def->audios[0] = audio;
if (audioBackend == VIR_DOMAIN_AUDIO_TYPE_SDL) {
}
static int
-qemuDomainDefAddDefaultDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainDefAddDefaultDevices(virQEMUDriver *driver,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
bool addDefaultUSB = true;
int usbModel = -1; /* "default for machinetype" */
}
if (addDefaultMemballoon && !def->memballoon) {
- virDomainMemballoonDefPtr memballoon;
+ virDomainMemballoonDef *memballoon;
memballoon = g_new0(virDomainMemballoonDef, 1);
memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO;
}
if (j == def->npanics) {
- virDomainPanicDefPtr panic = g_new0(virDomainPanicDef, 1);
+ virDomainPanicDef *panic = g_new0(virDomainPanicDef, 1);
if (VIR_APPEND_ELEMENT_COPY(def->panics,
def->npanics, panic) < 0) {
* enabled and configure default values related to those features.
*/
static void
-qemuDomainDefEnableDefaultFeatures(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainDefEnableDefaultFeatures(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
/* The virt machine type always uses GIC: if the relevant information
* was not included in the domain XML, we need to choose a suitable
static int
-qemuCanonicalizeMachine(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
+qemuCanonicalizeMachine(virDomainDef *def, virQEMUCaps *qemuCaps)
{
const char *canon;
static int
-qemuDomainRecheckInternalPaths(virDomainDefPtr def,
- virQEMUDriverConfigPtr cfg,
+qemuDomainRecheckInternalPaths(virDomainDef *def,
+ virQEMUDriverConfig *cfg,
unsigned int flags)
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < def->ngraphics; ++i) {
- virDomainGraphicsDefPtr graphics = def->graphics[i];
+ virDomainGraphicsDef *graphics = def->graphics[i];
for (j = 0; j < graphics->nListens; ++j) {
- virDomainGraphicsListenDefPtr glisten = &graphics->listens[j];
+ virDomainGraphicsListenDef *glisten = &graphics->listens[j];
/* This will happen only if we parse XML from old libvirts where
* unix socket was available only for VNC graphics. In this
static int
-qemuDomainDefVcpusPostParse(virDomainDefPtr def)
+qemuDomainDefVcpusPostParse(virDomainDef *def)
{
unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
- virDomainVcpuDefPtr vcpu;
- virDomainVcpuDefPtr prevvcpu;
+ virDomainVcpuDef *vcpu;
+ virDomainVcpuDef *prevvcpu;
size_t i;
bool has_order = false;
static int
-qemuDomainDefSetDefaultCPU(virDomainDefPtr def,
+qemuDomainDefSetDefaultCPU(virDomainDef *def,
virArch hostarch,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const char *model;
static int
-qemuDomainDefCPUPostParse(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainDefCPUPostParse(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
- virCPUFeatureDefPtr sveFeature = NULL;
+ virCPUFeatureDef *sveFeature = NULL;
bool sveVectorLengthsProvided = false;
size_t i;
return 0;
if (def->cpu->cache) {
- virCPUCacheDefPtr cache = def->cpu->cache;
+ virCPUCacheDef *cache = def->cpu->cache;
if (!ARCH_IS_X86(def->os.arch)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
for (i = 0; i < def->cpu->nfeatures; i++) {
- virCPUFeatureDefPtr feature = &def->cpu->features[i];
+ virCPUFeatureDef *feature = &def->cpu->features[i];
if (STREQ(feature->name, "sve")) {
sveFeature = feature;
static int
-qemuDomainDefTsegPostParse(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainDefTsegPostParse(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
if (def->features[VIR_DOMAIN_FEATURE_SMM] != VIR_TRISTATE_SWITCH_ON)
return 0;
* Returns: 0 on success, -1 on error
*/
int
-qemuDomainDefNumaCPUsRectify(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
+qemuDomainDefNumaCPUsRectify(virDomainDef *def, virQEMUCaps *qemuCaps)
{
unsigned int vcpusMax, numacpus;
static int
-qemuDomainDefNumaCPUsPostParse(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainDefNumaCPUsPostParse(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
return qemuDomainDefNumaCPUsRectify(def, qemuCaps);
}
static int
-qemuDomainDefTPMsPostParse(virDomainDefPtr def)
+qemuDomainDefTPMsPostParse(virDomainDef *def)
{
- virDomainTPMDefPtr proxyTPM = NULL;
- virDomainTPMDefPtr regularTPM = NULL;
+ virDomainTPMDef *proxyTPM = NULL;
+ virDomainTPMDef *regularTPM = NULL;
size_t i;
for (i = 0; i < def->ntpms; i++) {
- virDomainTPMDefPtr tpm = def->tpms[i];
+ virDomainTPMDef *tpm = def->tpms[i];
/* TPM 1.2 and 2 are not compatible, so we choose a specific version here */
if (tpm->version == VIR_DOMAIN_TPM_VERSION_DEFAULT) {
static int
-qemuDomainDefPostParseBasic(virDomainDefPtr def,
+qemuDomainDefPostParseBasic(virDomainDef *def,
void *opaque G_GNUC_UNUSED)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
/* check for emulator and create a default one if needed */
if (!def->emulator) {
static int
-qemuDomainDefPostParse(virDomainDefPtr def,
+qemuDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags,
void *opaque,
void *parseOpaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
/* Note that qemuCaps may be NULL when this function is called. This
* function shall not fail in that case. It will be re-run on VM startup
int
qemuDomainValidateActualNetDef(const virDomainNetDef *net,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
/*
* Validations that can only be properly checked at runtime (after
int
-qemuDomainValidateStorageSource(virStorageSourcePtr src,
- virQEMUCapsPtr qemuCaps,
+qemuDomainValidateStorageSource(virStorageSource *src,
+ virQEMUCaps *qemuCaps,
bool maskBlockdev)
{
int actualType = virStorageSourceGetActualType(src);
*/
static int
qemuDomainDefaultNetModel(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (ARCH_IS_S390(def->os.arch))
return VIR_DOMAIN_NET_MODEL_VIRTIO;
* the path even if we are not storing it in the XML.
*/
static void
-qemuDomainChrDefDropDefaultPath(virDomainChrDefPtr chr,
- virQEMUDriverPtr driver)
+qemuDomainChrDefDropDefaultPath(virDomainChrDef *chr,
+ virQEMUDriver *driver)
{
g_autoptr(virQEMUDriverConfig) cfg = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-qemuDomainShmemDefPostParse(virDomainShmemDefPtr shm)
+qemuDomainShmemDefPostParse(virDomainShmemDef *shm)
{
/* This was the default since the introduction of this device. */
if (shm->model != VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL && !shm->size)
static int
-qemuDomainControllerDefPostParse(virDomainControllerDefPtr cont,
+qemuDomainControllerDefPostParse(virDomainControllerDef *cont,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
switch ((virDomainControllerType)cont->type) {
}
static int
-qemuDomainChrDefPostParse(virDomainChrDefPtr chr,
+qemuDomainChrDefPostParse(virDomainChrDef *chr,
const virDomainDef *def,
- virQEMUDriverPtr driver,
+ virQEMUDriver *driver,
unsigned int parseFlags)
{
/* Historically, isa-serial and the default matched, so in order to
* Note that qemuCaps should be always present for a status XML.
*/
static int
-qemuDomainDeviceDiskDefPostParseRestoreSecAlias(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDeviceDiskDefPostParseRestoreSecAlias(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
- qemuDomainStorageSourcePrivatePtr priv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(disk->src);
+ qemuDomainStorageSourcePrivate *priv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(disk->src);
bool restoreAuthSecret = false;
bool restoreEncSecret = false;
g_autofree char *authalias = NULL;
static int
-qemuDomainDeviceDiskDefPostParse(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDeviceDiskDefPostParse(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
/* set default disk types and drivers */
static int
-qemuDomainDeviceNetDefPostParse(virDomainNetDefPtr net,
+qemuDomainDeviceNetDefPostParse(virDomainNetDef *net,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (net->type == VIR_DOMAIN_NET_TYPE_VDPA &&
!virDomainNetGetModelString(net))
static int
qemuDomainDefaultVideoDevice(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (ARCH_IS_PPC64(def->os.arch))
return VIR_DOMAIN_VIDEO_TYPE_VGA;
static int
-qemuDomainDeviceVideoDefPostParse(virDomainVideoDefPtr video,
+qemuDomainDeviceVideoDefPostParse(virDomainVideoDef *video,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (video->type == VIR_DOMAIN_VIDEO_TYPE_DEFAULT)
video->type = qemuDomainDefaultVideoDevice(def, qemuCaps);
static int
-qemuDomainDevicePanicDefPostParse(virDomainPanicDefPtr panic,
+qemuDomainDevicePanicDefPostParse(virDomainPanicDef *panic,
const virDomainDef *def)
{
if (panic->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT) {
static int
-qemuDomainVsockDefPostParse(virDomainVsockDefPtr vsock)
+qemuDomainVsockDefPostParse(virDomainVsockDef *vsock)
{
if (vsock->model == VIR_DOMAIN_VSOCK_MODEL_DEFAULT)
vsock->model = VIR_DOMAIN_VSOCK_MODEL_VIRTIO;
* Note that qemuCaps should be always present for a status XML.
*/
static int
-qemuDomainDeviceHostdevDefPostParseRestoreSecAlias(virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDeviceHostdevDefPostParseRestoreSecAlias(virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
- qemuDomainStorageSourcePrivatePtr priv;
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ qemuDomainStorageSourcePrivate *priv;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
g_autofree char *authalias = NULL;
if (!(parseFlags & VIR_DOMAIN_DEF_PARSE_STATUS) ||
* Note that qemuCaps should be always present for a status XML.
*/
static int
-qemuDomainDeviceHostdevDefPostParseRestoreBackendAlias(virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDeviceHostdevDefPostParseRestoreBackendAlias(virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virStorageSourcePtr src;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virStorageSource *src;
if (!(parseFlags & VIR_DOMAIN_DEF_PARSE_STATUS))
return 0;
static int
-qemuDomainHostdevDefMdevPostParse(virDomainHostdevSubsysMediatedDevPtr mdevsrc,
- virQEMUCapsPtr qemuCaps)
+qemuDomainHostdevDefMdevPostParse(virDomainHostdevSubsysMediatedDev *mdevsrc,
+ virQEMUCaps *qemuCaps)
{
/* QEMU 2.12 added support for vfio-pci display type, we default to
* 'display=off' to stay safe from future changes */
static int
-qemuDomainHostdevDefPostParse(virDomainHostdevDefPtr hostdev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainHostdevDefPostParse(virDomainHostdevDef *hostdev,
+ virQEMUCaps *qemuCaps,
unsigned int parseFlags)
{
- virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
+ virDomainHostdevSubsys *subsys = &hostdev->source.subsys;
if (qemuDomainDeviceHostdevDefPostParseRestoreSecAlias(hostdev, qemuCaps,
parseFlags) < 0)
static int
-qemuDomainTPMDefPostParse(virDomainTPMDefPtr tpm,
+qemuDomainTPMDefPostParse(virDomainTPMDef *tpm,
virArch arch)
{
if (tpm->model == VIR_DOMAIN_TPM_MODEL_DEFAULT) {
static int
-qemuDomainNVDimmAlignSizePseries(virDomainMemoryDefPtr mem)
+qemuDomainNVDimmAlignSizePseries(virDomainMemoryDef *mem)
{
/* For NVDIMMs in ppc64 in we want to align down the guest
* visible space, instead of align up, to avoid writing
static int
-qemuDomainMemoryDefPostParse(virDomainMemoryDefPtr mem, virArch arch,
+qemuDomainMemoryDefPostParse(virDomainMemoryDef *mem, virArch arch,
unsigned int parseFlags)
{
/* Memory alignment can't be done for migration or snapshot
static int
-qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+qemuDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags,
void *opaque,
void *parseOpaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
/* Note that qemuCaps may be NULL when this function is called. This
* function shall not fail in that case. It will be re-run on VM startup
* with the capabilities populated. */
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
int ret = -1;
switch ((virDomainDeviceType) dev->type) {
void *opaque,
void *parseOpaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
/* Note that qemuCaps may be NULL when this function is called. This
* function shall not fail in that case. It will be re-run on VM startup
* with the capabilities populated. */
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
bool newDomain = parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
/* Skip address assignment if @qemuCaps is not present. In such case devices
void *opaque,
void **parseOpaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
if (!(*parseOpaque = virQEMUCapsCacheLookup(driver->qemuCapsCache,
def->emulator)))
static void
qemuDomainPostParseDataFree(void *parseOpaque)
{
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
virObjectUnref(qemuCaps);
}
void
-qemuDomainObjSaveStatus(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+qemuDomainObjSaveStatus(virQEMUDriver *driver,
+ virDomainObj *obj)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
void
-qemuDomainSaveStatus(virDomainObjPtr obj)
+qemuDomainSaveStatus(virDomainObj *obj)
{
qemuDomainObjSaveStatus(QEMU_DOMAIN_PRIVATE(obj)->driver, obj);
}
void
-qemuDomainSaveConfig(virDomainObjPtr obj)
+qemuDomainSaveConfig(virDomainObj *obj)
{
- virQEMUDriverPtr driver = QEMU_DOMAIN_PRIVATE(obj)->driver;
+ virQEMUDriver *driver = QEMU_DOMAIN_PRIVATE(obj)->driver;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
if (virDomainObjIsActive(obj))
def = obj->newDef;
* To be followed with qemuDomainObjExitMonitor() once complete
*/
static int
-qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjEnterMonitorInternal(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
if (asyncJob != QEMU_ASYNC_JOB_NONE) {
int ret;
}
static void ATTRIBUTE_NONNULL(1)
-qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+qemuDomainObjExitMonitorInternal(virQEMUDriver *driver,
+ virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
bool hasRefs;
qemuMonitorWatchDispose();
qemuDomainObjEndJob(driver, obj);
}
-void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
+ virDomainObj *obj)
{
ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
QEMU_ASYNC_JOB_NONE));
* and replaced by the persistent definition, so pointers stolen
* from the live definition could no longer be valid.
*/
-int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+int qemuDomainObjExitMonitor(virQEMUDriver *driver,
+ virDomainObj *obj)
{
qemuDomainObjExitMonitorInternal(driver, obj);
if (!virDomainObjIsActive(obj)) {
* in the meantime).
*/
int
-qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob)
{
return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
*
* To be followed with qemuDomainObjExitAgent() once complete
*/
-qemuAgentPtr
-qemuDomainObjEnterAgent(virDomainObjPtr obj)
+qemuAgent *
+qemuDomainObjEnterAgent(virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
- qemuAgentPtr agent = priv->agent;
+ qemuDomainObjPrivate *priv = obj->privateData;
+ qemuAgent *agent = priv->agent;
VIR_DEBUG("Entering agent (agent=%p vm=%p name=%s)",
priv->agent, obj, obj->def->name);
* Should be paired with an earlier qemuDomainObjEnterAgent() call
*/
void
-qemuDomainObjExitAgent(virDomainObjPtr obj, qemuAgentPtr agent)
+qemuDomainObjExitAgent(virDomainObj *obj, qemuAgent *agent)
{
virObjectUnlock(agent);
virObjectUnref(agent);
agent, obj, obj->def->name);
}
-void qemuDomainObjEnterRemote(virDomainObjPtr obj)
+void qemuDomainObjEnterRemote(virDomainObj *obj)
{
VIR_DEBUG("Entering remote (vm=%p name=%s)",
obj, obj->def->name);
int
-qemuDomainObjExitRemote(virDomainObjPtr obj,
+qemuDomainObjExitRemote(virDomainObj *obj,
bool checkActive)
{
virObjectLock(obj);
}
-static virDomainDefPtr
-qemuDomainDefFromXML(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+static virDomainDef *
+qemuDomainDefFromXML(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *xml)
{
- virDomainDefPtr def;
+ virDomainDef *def;
def = virDomainDefParseString(xml, driver->xmlopt, qemuCaps,
VIR_DOMAIN_DEF_PARSE_INACTIVE |
}
-virDomainDefPtr
-qemuDomainDefCopy(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr src,
+virDomainDef *
+qemuDomainDefCopy(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *src,
unsigned int flags)
{
g_autofree char *xml = NULL;
int
-qemuDomainMakeCPUMigratable(virCPUDefPtr cpu)
+qemuDomainMakeCPUMigratable(virCPUDef *cpu)
{
if (cpu->mode == VIR_CPU_MODE_CUSTOM &&
STREQ_NULLABLE(cpu->model, "Icelake-Server")) {
static int
-qemuDomainDefFormatBufInternal(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
- virCPUDefPtr origCPU,
+qemuDomainDefFormatBufInternal(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
+ virCPUDef *origCPU,
unsigned int flags,
virBuffer *buf)
{
if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
size_t i;
int toremove = 0;
- virDomainControllerDefPtr usb = NULL;
- virDomainControllerDefPtr pci = NULL;
+ virDomainControllerDef *usb = NULL;
+ virDomainControllerDef *pci = NULL;
/* If only the default USB controller is present, we can remove it
* and make the XML compatible with older versions of libvirt which
}
if (toremove) {
- virDomainControllerDefPtr *controllers = def->controllers;
+ virDomainControllerDef **controllers = def->controllers;
int ncontrollers = def->ncontrollers;
- def->controllers = g_new0(virDomainControllerDefPtr, ncontrollers - toremove);
+ def->controllers = g_new0(virDomainControllerDef *, ncontrollers - toremove);
def->ncontrollers = 0;
for (i = 0; i < ncontrollers; i++) {
qemuDomainChrDefDropDefaultPath(def->channels[i], driver);
for (i = 0; i < def->nserials; i++) {
- virDomainChrDefPtr serial = def->serials[i];
+ virDomainChrDef *serial = def->serials[i];
/* Historically, the native console type for some machine types
* was not set at all, which means it defaulted to ISA even
int
-qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
+qemuDomainDefFormatBuf(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
unsigned int flags,
- virBufferPtr buf)
+ virBuffer *buf)
{
return qemuDomainDefFormatBufInternal(driver, qemuCaps, def, NULL, flags, buf);
}
static char *
-qemuDomainDefFormatXMLInternal(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
- virCPUDefPtr origCPU,
+qemuDomainDefFormatXMLInternal(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
+ virCPUDef *origCPU,
unsigned int flags)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
char *
-qemuDomainDefFormatXML(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
+qemuDomainDefFormatXML(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
unsigned int flags)
{
return qemuDomainDefFormatXMLInternal(driver, qemuCaps, def, NULL, flags);
}
-char *qemuDomainFormatXML(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+char *qemuDomainFormatXML(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags)
{
- virDomainDefPtr def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virCPUDefPtr origCPU = NULL;
+ virDomainDef *def;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virCPUDef *origCPU = NULL;
if ((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef) {
def = vm->newDef;
}
char *
-qemuDomainDefFormatLive(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
- virCPUDefPtr origCPU,
+qemuDomainDefFormatLive(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
+ virCPUDef *origCPU,
bool inactive,
bool compatible)
{
}
-void qemuDomainObjTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+void qemuDomainObjTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
virDomainTaintFlags taint,
- qemuDomainLogContextPtr logCtxt)
+ qemuDomainLogContext *logCtxt)
{
qemuDomainObjTaintMsg(driver, obj, taint, logCtxt, NULL);
}
-void qemuDomainObjTaintMsg(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+void qemuDomainObjTaintMsg(virQEMUDriver *driver,
+ virDomainObj *obj,
virDomainTaintFlags taint,
- qemuDomainLogContextPtr logCtxt,
+ qemuDomainLogContext *logCtxt,
const char *fmt, ...)
{
virErrorPtr orig_err = NULL;
}
static void
-qemuDomainObjCheckMachineTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- qemuDomainLogContextPtr logCtxt)
+qemuDomainObjCheckMachineTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ qemuDomainLogContext *logCtxt)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ qemuDomainObjPrivate *priv = obj->privateData;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
if (virQEMUCapsIsMachineDeprecated(qemuCaps,
obj->def->virtType,
static void
-qemuDomainObjCheckCPUTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- qemuDomainLogContextPtr logCtxt,
+qemuDomainObjCheckCPUTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ qemuDomainLogContext *logCtxt,
bool incomingMigration)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
+ qemuDomainObjPrivate *priv = obj->privateData;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
switch (obj->def->cpu->mode) {
case VIR_CPU_MODE_HOST_PASSTHROUGH:
}
-void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- qemuDomainLogContextPtr logCtxt,
+void qemuDomainObjCheckTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ qemuDomainLogContext *logCtxt,
bool incomingMigration)
{
size_t i;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
bool custom_hypervisor_feat = false;
if (driver->privileged &&
qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOOK, logCtxt);
if (obj->def->namespaceData) {
- qemuDomainXmlNsDefPtr qemuxmlns = obj->def->namespaceData;
+ qemuDomainXmlNsDef *qemuxmlns = obj->def->namespaceData;
if (qemuxmlns->num_args || qemuxmlns->num_env)
qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_ARGV, logCtxt);
if (qemuxmlns->ncapsadd > 0 || qemuxmlns->ncapsdel > 0)
}
-void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainDiskDefPtr disk,
- qemuDomainLogContextPtr logCtxt)
+void qemuDomainObjCheckDiskTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainDiskDef *disk,
+ qemuDomainLogContext *logCtxt)
{
if (disk->rawio == VIR_TRISTATE_BOOL_YES)
qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
}
-void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainHostdevDefPtr hostdev,
- qemuDomainLogContextPtr logCtxt)
+void qemuDomainObjCheckHostdevTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainHostdevDef *hostdev,
+ qemuDomainLogContext *logCtxt)
{
if (!virHostdevIsSCSIDevice(hostdev))
return;
}
-void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainNetDefPtr net,
- qemuDomainLogContextPtr logCtxt)
+void qemuDomainObjCheckNetTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainNetDef *net,
+ qemuDomainLogContext *logCtxt)
{
/* script is only useful for NET_TYPE_ETHERNET (qemu) and
* NET_TYPE_BRIDGE (xen), but could be (incorrectly) specified for
}
-qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainLogContext *qemuDomainLogContextNew(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainLogContextMode mode)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainLogContextPtr ctxt = QEMU_DOMAIN_LOG_CONTEXT(g_object_new(QEMU_TYPE_DOMAIN_LOG_CONTEXT, NULL));
+ qemuDomainLogContext *ctxt = QEMU_DOMAIN_LOG_CONTEXT(g_object_new(QEMU_TYPE_DOMAIN_LOG_CONTEXT, NULL));
VIR_DEBUG("Context new %p stdioLogD=%d", ctxt, cfg->stdioLogD);
ctxt->writefd = -1;
}
-int qemuDomainLogContextWrite(qemuDomainLogContextPtr ctxt,
+int qemuDomainLogContextWrite(qemuDomainLogContext *ctxt,
const char *fmt, ...)
{
va_list argptr;
}
-ssize_t qemuDomainLogContextRead(qemuDomainLogContextPtr ctxt,
+ssize_t qemuDomainLogContextRead(qemuDomainLogContext *ctxt,
char **msg)
{
char *buf;
* This is a best-effort attempt to add a log message to the qemu log file
* either by using virtlogd or the legacy approach */
int
-qemuDomainLogAppendMessage(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainLogAppendMessage(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *fmt,
...)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virLogManagerPtr manager = NULL;
+ virLogManager *manager = NULL;
va_list ap;
g_autofree char *path = NULL;
int writefd = -1;
}
-int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt)
+int qemuDomainLogContextGetWriteFD(qemuDomainLogContext *ctxt)
{
return ctxt->writefd;
}
-void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt)
+void qemuDomainLogContextMarkPosition(qemuDomainLogContext *ctxt)
{
if (ctxt->manager)
virLogManagerDomainGetLogFilePosition(ctxt->manager,
}
-virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt)
+virLogManager *qemuDomainLogContextGetManager(qemuDomainLogContext *ctxt)
{
return ctxt->manager;
}
/* Locate an appropriate 'qemu-img' binary. */
const char *
-qemuFindQemuImgBinary(virQEMUDriverPtr driver)
+qemuFindQemuImgBinary(virQEMUDriver *driver)
{
if (!driver->qemuImgBinary)
virReportError(VIR_ERR_INTERNAL_ERROR,
}
int
-qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr snapshot,
- virDomainXMLOptionPtr xmlopt,
+qemuDomainSnapshotWriteMetadata(virDomainObj *vm,
+ virDomainMomentObj *snapshot,
+ virDomainXMLOption *xmlopt,
const char *snapshotDir)
{
g_autofree char *newxml = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
unsigned int flags = VIR_DOMAIN_SNAPSHOT_FORMAT_SECURE |
VIR_DOMAIN_SNAPSHOT_FORMAT_INTERNAL;
- virDomainSnapshotDefPtr def = virDomainSnapshotObjGetDef(snapshot);
+ virDomainSnapshotDef *def = virDomainSnapshotObjGetDef(snapshot);
if (virDomainSnapshotGetCurrent(vm->snapshots) == snapshot)
flags |= VIR_DOMAIN_SNAPSHOT_FORMAT_CURRENT;
/* The domain is expected to be locked and inactive. Return -1 on normal
* failure, 1 if we skipped a disk due to try_all. */
static int
-qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+qemuDomainSnapshotForEachQcow2Raw(virQEMUDriver *driver,
+ virDomainDef *def,
const char *name,
const char *op,
bool try_all,
/* The domain is expected to be locked and inactive. Return -1 on normal
* failure, 1 if we skipped a disk due to try_all. */
int
-qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virDomainMomentObjPtr snap,
+qemuDomainSnapshotForEachQcow2(virQEMUDriver *driver,
+ virDomainDef *def,
+ virDomainMomentObj *snap,
const char *op,
bool try_all)
{
/* Discard one snapshot (or its metadata), without reparenting any children. */
int
-qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
+qemuDomainSnapshotDiscard(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap,
bool update_parent,
bool metadata_only)
{
g_autofree char *snapFile = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainMomentObjPtr parentsnap = NULL;
+ qemuDomainObjPrivate *priv;
+ virDomainMomentObj *parentsnap = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
if (!metadata_only) {
/* Prefer action on the disks in use at the time the snapshot was
* created; but fall back to current definition if dealing with a
* snapshot created prior to libvirt 0.9.5. */
- virDomainDefPtr def = snap->def->dom;
+ virDomainDef *def = snap->def->dom;
if (!def)
def = vm->def;
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr moment = payload;
- virQEMUMomentRemovePtr curr = data;
+ virDomainMomentObj *moment = payload;
+ virQEMUMomentRemove *curr = data;
int err;
if (!curr->found && curr->current == moment)
}
int
-qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainSnapshotDiscardAllMetadata(virQEMUDriver *driver,
+ virDomainObj *vm)
{
virQEMUMomentRemove rem = {
.driver = driver,
static void
-qemuDomainRemoveInactiveCommon(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainRemoveInactiveCommon(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *snapDir = NULL;
* The caller must hold a lock to the vm.
*/
void
-qemuDomainRemoveInactive(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainRemoveInactive(virQEMUDriver *driver,
+ virDomainObj *vm)
{
if (vm->persistent) {
/* Short-circuit, we don't want to remove a persistent domain */
* from locked list method.
*/
static void
-qemuDomainRemoveInactiveLocked(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainRemoveInactiveLocked(virQEMUDriver *driver,
+ virDomainObj *vm)
{
if (vm->persistent) {
/* Short-circuit, we don't want to remove a persistent domain */
* qemuDomainRemoveInactive call.
*/
void
-qemuDomainRemoveInactiveJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainRemoveInactiveJob(virQEMUDriver *driver,
+ virDomainObj *vm)
{
bool haveJob;
* also hold the lock @driver->domains
*/
void
-qemuDomainRemoveInactiveJobLocked(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainRemoveInactiveJobLocked(virQEMUDriver *driver,
+ virDomainObj *vm)
{
bool haveJob;
void
-qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainSetFakeReboot(virQEMUDriver *driver,
+ virDomainObj *vm,
bool value)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
if (priv->fakeReboot == value)
}
static void
-qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainCheckRemoveOptionalDisk(virQEMUDriver *driver,
+ virDomainObj *vm,
size_t diskIndex)
{
char uuid[VIR_UUID_STRING_BUFLEN];
- virObjectEventPtr event = NULL;
- virDomainDiskDefPtr disk = vm->def->disks[diskIndex];
+ virObjectEvent *event = NULL;
+ virDomainDiskDef *disk = vm->def->disks[diskIndex];
const char *src = virDomainDiskGetSource(disk);
virUUIDFormat(vm->def->uuid, uuid);
* clears any reported error if 0 is returned.
*/
int
-qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainCheckDiskStartupPolicy(virQEMUDriver *driver,
+ virDomainObj *vm,
size_t diskIndex,
bool cold_boot)
{
* called.
*/
int
-qemuDomainCleanupAdd(virDomainObjPtr vm,
+qemuDomainCleanupAdd(virDomainObj *vm,
qemuDomainCleanupCallback cb)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);
}
void
-qemuDomainCleanupRemove(virDomainObjPtr vm,
+qemuDomainCleanupRemove(virDomainObj *vm,
qemuDomainCleanupCallback cb)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);
}
void
-qemuDomainCleanupRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainCleanupRun(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("driver=%p, vm=%s", driver, vm->def->name);
}
void
-qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr parentSrc,
+qemuDomainGetImageIds(virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *parentSrc,
uid_t *uid, gid_t *gid)
{
- virSecurityLabelDefPtr vmlabel;
- virSecurityDeviceLabelDefPtr disklabel;
+ virSecurityLabelDef *vmlabel;
+ virSecurityDeviceLabelDef *disklabel;
if (uid)
*uid = -1;
int
-qemuDomainStorageFileInit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr parent)
+qemuDomainStorageFileInit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *parent)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
uid_t uid;
* Returns 0 on success and -1 if the chain is too deep. Error is reported.
*/
int
-qemuDomainStorageSourceValidateDepth(virStorageSourcePtr src,
+qemuDomainStorageSourceValidateDepth(virStorageSource *src,
int add,
const char *diskdst)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
size_t nlayers = 0;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore)
*
*/
static void
-qemuDomainPrepareStorageSourceConfig(virStorageSourcePtr src,
- virQEMUDriverConfigPtr cfg,
- virQEMUCapsPtr qemuCaps)
+qemuDomainPrepareStorageSourceConfig(virStorageSource *src,
+ virQEMUDriverConfig *cfg,
+ virQEMUCaps *qemuCaps)
{
if (!cfg)
return;
* in the backing chain are reported.
*/
int
-qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr disksrc,
+qemuDomainDetermineDiskChain(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *disksrc,
bool report_broken)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virStorageSourcePtr src; /* iterator for the backing chain declared in XML */
- virStorageSourcePtr n; /* iterator for the backing chain detected from disk */
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virStorageSource *src; /* iterator for the backing chain declared in XML */
+ virStorageSource *n; /* iterator for the backing chain detected from disk */
+ qemuDomainObjPrivate *priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
bool isSD = qemuDiskBusIsSD(disk->bus);
uid_t uid;
* This must be used only when VIR_QEMU_CAPS_BLOCKDEV is enabled.
*/
const char *
-qemuDomainDiskGetTopNodename(virDomainDiskDefPtr disk)
+qemuDomainDiskGetTopNodename(virDomainDiskDef *disk)
{
- qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *priv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if (virStorageSourceIsEmpty(disk->src))
return NULL;
* Returns 0 on success, -1 on error with libvirt error reported.
*/
int
-qemuDomainDiskGetBackendAlias(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDiskGetBackendAlias(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
char **backendAlias)
{
*backendAlias = NULL;
static int
-qemuDomainStorageSourceAccessModifyNVMe(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuDomainStorageSourceAccessModifyNVMe(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
bool revoke)
{
bool revoke_maxmemlock = false;
* Returns 0 on success and -1 on error. Reports libvirt error.
*/
static int
-qemuDomainStorageSourceAccessModify(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuDomainStorageSourceAccessModify(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
qemuDomainStorageSourceAccessFlags flags)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int
-qemuDomainStorageSourceChainAccessAllow(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuDomainStorageSourceChainAccessAllow(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src)
{
qemuDomainStorageSourceAccessFlags flags = QEMU_DOMAIN_STORAGE_SOURCE_ACCESS_CHAIN |
QEMU_DOMAIN_STORAGE_SOURCE_ACCESS_CHAIN_TOP;
int
-qemuDomainStorageSourceChainAccessRevoke(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuDomainStorageSourceChainAccessRevoke(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src)
{
qemuDomainStorageSourceAccessFlags flags = QEMU_DOMAIN_STORAGE_SOURCE_ACCESS_REVOKE |
QEMU_DOMAIN_STORAGE_SOURCE_ACCESS_CHAIN |
* removes cgroup ACLs for devices and removes locks.
*/
void
-qemuDomainStorageSourceAccessRevoke(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr elem)
+qemuDomainStorageSourceAccessRevoke(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *elem)
{
qemuDomainStorageSourceAccessFlags flags = QEMU_DOMAIN_STORAGE_SOURCE_ACCESS_REVOKE;
* (the base) becomes the top of the chain).
*/
int
-qemuDomainStorageSourceAccessAllow(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr elem,
+qemuDomainStorageSourceAccessAllow(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *elem,
bool readonly,
bool newSource,
bool chainTop)
* taken from the virDomainDiskDefFormat() code.
*/
bool
-qemuDomainDiskChangeSupported(virDomainDiskDefPtr disk,
- virDomainDiskDefPtr orig_disk)
+qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
+ virDomainDiskDef *orig_disk)
{
#define CHECK_EQ(field, field_name, nullable) \
do { \
bool
-qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk)
+qemuDomainDiskBlockJobIsActive(virDomainDiskDef *disk)
{
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if (disk->mirror) {
virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
* disk is involved in a block copy.
* */
bool
-qemuDomainHasBlockjob(virDomainObjPtr vm,
+qemuDomainHasBlockjob(virDomainObj *vm,
bool copy_only)
{
size_t i;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if (!copy_only && diskPriv->blockjob &&
qemuBlockJobIsRunning(diskPriv->blockjob))
int
-qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainUpdateDeviceList(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
char **aliases;
int rc;
int
-qemuDomainUpdateMemoryDeviceInfo(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainUpdateMemoryDeviceInfo(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
GHashTable *meminfo = NULL;
int rc;
size_t i;
return -1;
for (i = 0; i < vm->def->nmems; i++) {
- virDomainMemoryDefPtr mem = vm->def->mems[i];
- qemuMonitorMemoryDeviceInfoPtr dimm;
+ virDomainMemoryDef *mem = vm->def->mems[i];
+ qemuMonitorMemoryDeviceInfo *dimm;
if (!mem->info.alias)
continue;
static bool
-qemuDomainMigratableDefCheckABIStability(virQEMUDriverPtr driver,
- virDomainDefPtr src,
- virDomainDefPtr migratableSrc,
- virDomainDefPtr dst,
- virDomainDefPtr migratableDst)
+qemuDomainMigratableDefCheckABIStability(virQEMUDriver *driver,
+ virDomainDef *src,
+ virDomainDef *migratableSrc,
+ virDomainDef *dst,
+ virDomainDef *migratableDst)
{
if (!virDomainDefCheckABIStabilityFlags(migratableSrc,
migratableDst,
VIR_DOMAIN_XML_MIGRATABLE)
bool
-qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr src,
- virDomainDefPtr dst)
+qemuDomainDefCheckABIStability(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *src,
+ virDomainDef *dst)
{
g_autoptr(virDomainDef) migratableDefSrc = NULL;
g_autoptr(virDomainDef) migratableDefDst = NULL;
bool
-qemuDomainCheckABIStability(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr dst)
+qemuDomainCheckABIStability(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *dst)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virDomainDef) migratableSrc = NULL;
g_autoptr(virDomainDef) migratableDst = NULL;
g_autofree char *xml = NULL;
bool
-qemuDomainAgentAvailable(virDomainObjPtr vm,
+qemuDomainAgentAvailable(virDomainObj *vm,
bool reportError)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
if (reportError) {
int
-qemuDomainAlignMemorySizes(virDomainDefPtr def)
+qemuDomainAlignMemorySizes(virDomainDef *def)
{
unsigned long long maxmemkb = virMemoryMaxValue(false) >> 10;
unsigned long long maxmemcapped = virMemoryMaxValue(true) >> 10;
* size so this should be safe).
*/
int
-qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+qemuDomainMemoryDeviceAlignSize(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
if (mem->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
ARCH_IS_PPC64(def->os.arch)) {
*
* Returns the monitor pointer corresponding to the domain object @vm.
*/
-qemuMonitorPtr
-qemuDomainGetMonitor(virDomainObjPtr vm)
+qemuMonitor *
+qemuDomainGetMonitor(virDomainObj *vm)
{
- return ((qemuDomainObjPrivatePtr) vm->privateData)->mon;
+ return ((qemuDomainObjPrivate *) vm->privateData)->mon;
}
* Returns the pointer to the channel definition that is used to access the
* guest agent if the agent is configured or NULL otherwise.
*/
-virDomainChrDefPtr
-qemuFindAgentConfig(virDomainDefPtr def)
+virDomainChrDef *
+qemuFindAgentConfig(virDomainDef *def)
{
size_t i;
for (i = 0; i < def->nchannels; i++) {
- virDomainChrDefPtr channel = def->channels[i];
+ virDomainChrDef *channel = def->channels[i];
if (channel->targetType != VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO)
continue;
bool
-qemuDomainSupportsPCI(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainSupportsPCI(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
if (def->os.arch != VIR_ARCH_ARMV6L &&
def->os.arch != VIR_ARCH_ARMV7L &&
size_t i;
for (i = 0; i < def->nmems; i++) {
- virDomainMemoryDefPtr tmp = def->mems[i];
+ virDomainMemoryDef *tmp = def->mems[i];
if (tmp == mem ||
tmp->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM)
* recalculates the maximum size to reflect possible changes.
*/
void
-qemuDomainUpdateCurrentMemorySize(virDomainObjPtr vm)
+qemuDomainUpdateCurrentMemorySize(virDomainObj *vm)
{
/* inactive domain doesn't need size update */
if (!virDomainObjIsActive(vm))
* the guest to operate properly.
*/
static unsigned long long
-getPPC64MemLockLimitBytes(virDomainDefPtr def,
+getPPC64MemLockLimitBytes(virDomainDef *def,
bool forceVFIO)
{
unsigned long long memKB = 0;
unsigned long long maxMemory = 0;
unsigned long long passthroughLimit = 0;
size_t i, nPCIHostBridges = 0;
- virPCIDeviceAddressPtr pciAddr;
+ virPCIDeviceAddress *pciAddr;
bool nvlink2Capable = false;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (!virDomainControllerIsPSeriesPHB(cont))
continue;
}
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr dev = def->hostdevs[i];
+ virDomainHostdevDef *dev = def->hostdevs[i];
if (virHostdevIsVFIODevice(dev)) {
* Returns: the memory locking limit, or 0 if setting the limit is not needed
*/
unsigned long long
-qemuDomainGetMemLockLimitBytes(virDomainDefPtr def,
+qemuDomainGetMemLockLimitBytes(virDomainDef *def,
bool forceVFIO)
{
unsigned long long memKB = 0;
* Returns: 0 on success, <0 on failure
*/
int
-qemuDomainAdjustMaxMemLock(virDomainObjPtr vm,
+qemuDomainAdjustMaxMemLock(virDomainObj *vm,
bool forceVFIO)
{
unsigned long long currentMemLock = 0;
* Returns: 0 on success, <0 on failure
*/
int
-qemuDomainAdjustMaxMemLockHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAdjustMaxMemLockHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
int ret = 0;
* Returns true if we were able to successfully detect vCPU pids for the VM.
*/
bool
-qemuDomainHasVcpuPids(virDomainObjPtr vm)
+qemuDomainHasVcpuPids(virDomainObj *vm)
{
size_t i;
size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
for (i = 0; i < maxvcpus; i++) {
vcpu = virDomainDefGetVcpu(vm->def, i);
* Returns the vCPU pid. If @vcpu is offline or out of range 0 is returned.
*/
pid_t
-qemuDomainGetVcpuPid(virDomainObjPtr vm,
+qemuDomainGetVcpuPid(virDomainObj *vm,
unsigned int vcpuid)
{
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;
}
* Returns 0 on success -1 on error.
*/
int
-qemuDomainValidateVcpuInfo(virDomainObjPtr vm)
+qemuDomainValidateVcpuInfo(virDomainObj *vm)
{
size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
size_t i;
if (!qemuDomainHasVcpuPids(vm))
bool
-qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm)
+qemuDomainSupportsNewVcpuHotplug(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
return virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
}
* Returns 0 on success and -1 on fatal error.
*/
int
-qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRefreshVcpuInfo(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
bool state)
{
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
- qemuMonitorCPUInfoPtr info = NULL;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
+ qemuMonitorCPUInfo *info = NULL;
size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
size_t i, j;
bool hotplug;
* Returns the vCPU halted state.
*/
bool
-qemuDomainGetVcpuHalted(virDomainObjPtr vm,
+qemuDomainGetVcpuHalted(virDomainObj *vm,
unsigned int vcpuid)
{
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->halted;
}
* Returns 0 on success and -1 on error
*/
int
-qemuDomainRefreshVcpuHalted(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRefreshVcpuHalted(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
g_autoptr(virBitmap) haltedmap = NULL;
size_t i;
}
bool
-qemuDomainSupportsNicdev(virDomainDefPtr def,
- virDomainNetDefPtr net)
+qemuDomainSupportsNicdev(virDomainDef *def,
+ virDomainNetDef *net)
{
/* non-virtio ARM nics require legacy -net nic */
if (((def->os.arch == VIR_ARCH_ARMV6L) ||
}
-virDomainDiskDefPtr
-qemuDomainDiskByName(virDomainDefPtr def,
+virDomainDiskDef *
+qemuDomainDiskByName(virDomainDef *def,
const char *name)
{
- virDomainDiskDefPtr ret;
+ virDomainDiskDef *ret;
if (!(ret = virDomainDiskByName(def, name, true))) {
virReportError(VIR_ERR_INVALID_ARG,
int
-qemuDomainPrepareChannel(virDomainChrDefPtr channel,
+qemuDomainPrepareChannel(virDomainChrDef *channel,
const char *domainChannelTargetDir)
{
if (channel->targetType != VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO ||
* live XML of a guest.
*/
void
-qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDefPtr source,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDef *source,
+ virQEMUDriverConfig *cfg)
{
if (source->type == VIR_DOMAIN_CHR_TYPE_TCP) {
if (source->data.tcp.haveTLS == VIR_TRISTATE_BOOL_ABSENT) {
* @def: live domain definition
* @cfg: driver configuration
*
- * Iterate through all devices that use virDomainChrSourceDefPtr as host
+ * Iterate through all devices that use virDomainChrSourceDef *as host
* interface part.
*/
void
-qemuDomainPrepareChardevSource(virDomainDefPtr def,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareChardevSource(virDomainDef *def,
+ virQEMUDriverConfig *cfg)
{
size_t i;
static int
-qemuProcessPrepareStorageSourceTLSVxhs(virStorageSourcePtr src,
- virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+qemuProcessPrepareStorageSourceTLSVxhs(virStorageSource *src,
+ virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const char *parentAlias)
{
/* VxHS uses only client certificates and thus has no need for
src->tlsCertdir = g_strdup(cfg->vxhsTLSx509certdir);
if (cfg->vxhsTLSx509secretUUID) {
- qemuDomainStorageSourcePrivatePtr srcpriv = qemuDomainStorageSourcePrivateFetch(src);
+ qemuDomainStorageSourcePrivate *srcpriv = qemuDomainStorageSourcePrivateFetch(src);
if (!(srcpriv->tlsKeySecret = qemuDomainSecretInfoTLSNew(priv, src->tlsAlias,
cfg->vxhsTLSx509secretUUID)))
static int
-qemuProcessPrepareStorageSourceTLSNBD(virStorageSourcePtr src,
- virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+qemuProcessPrepareStorageSourceTLSNBD(virStorageSource *src,
+ virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const char *parentAlias)
{
if (src->haveTLS == VIR_TRISTATE_BOOL_ABSENT) {
src->tlsCertdir = g_strdup(cfg->nbdTLSx509certdir);
if (cfg->nbdTLSx509secretUUID) {
- qemuDomainStorageSourcePrivatePtr srcpriv = qemuDomainStorageSourcePrivateFetch(src);
+ qemuDomainStorageSourcePrivate *srcpriv = qemuDomainStorageSourcePrivateFetch(src);
if (!(srcpriv->tlsKeySecret = qemuDomainSecretInfoTLSNew(priv, src->tlsAlias,
cfg->nbdTLSx509secretUUID)))
* then provide the hypervisor default uid and gid.
*/
static int
-qemuDomainPrepareStorageSourceNFS(virStorageSourcePtr src)
+qemuDomainPrepareStorageSourceNFS(virStorageSource *src)
{
if (virStorageSourceGetActualType(src) != VIR_STORAGE_TYPE_NETWORK)
return 0;
* Returns 0 on success, -1 on bad config/failure
*/
static int
-qemuDomainPrepareStorageSourceTLS(virStorageSourcePtr src,
- virQEMUDriverConfigPtr cfg,
+qemuDomainPrepareStorageSourceTLS(virStorageSource *src,
+ virQEMUDriverConfig *cfg,
const char *parentAlias,
- qemuDomainObjPrivatePtr priv)
+ qemuDomainObjPrivate *priv)
{
if (virStorageSourceGetActualType(src) != VIR_STORAGE_TYPE_NETWORK)
return 0;
void
-qemuDomainPrepareShmemChardev(virDomainShmemDefPtr shmem)
+qemuDomainPrepareShmemChardev(virDomainShmemDef *shmem)
{
if (!shmem->server.enabled ||
shmem->server.chr.data.nix.path)
* with increasing order).
*/
bool
-qemuDomainVcpuHotplugIsInOrder(virDomainDefPtr def)
+qemuDomainVcpuHotplugIsInOrder(virDomainDef *def)
{
size_t maxvcpus = virDomainDefGetVcpusMax(def);
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
unsigned int prevorder = 0;
size_t seenonlinevcpus = 0;
size_t i;
* of all sub entities.
*/
void
-qemuDomainVcpuPersistOrder(virDomainDefPtr def)
+qemuDomainVcpuPersistOrder(virDomainDef *def)
{
size_t maxvcpus = virDomainDefGetVcpusMax(def);
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
unsigned int prevorder = 0;
size_t i;
int
-qemuDomainCheckMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainCheckMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
bool
-qemuDomainSupportsVideoVga(virDomainVideoDefPtr video,
- virQEMUCapsPtr qemuCaps)
+qemuDomainSupportsVideoVga(virDomainVideoDef *video,
+ virQEMUCaps *qemuCaps)
{
if (video->type == VIR_DOMAIN_VIDEO_TYPE_VIRTIO) {
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
* Returns 0 on success, -1 otherwise.
*/
int
-qemuDomainGetHostdevPath(virDomainHostdevDefPtr dev,
+qemuDomainGetHostdevPath(virDomainHostdevDef *dev,
char **path,
int *perms)
{
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
g_autoptr(virUSBDevice) usb = NULL;
g_autoptr(virSCSIDevice) scsi = NULL;
g_autoptr(virSCSIVHostDevice) host = NULL;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
VIR_DEBUG("Not updating /dev for hostdev iSCSI path '%s'", iscsisrc->src->path);
} else {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
scsi = virSCSIDeviceNew(NULL,
scsihostsrc->adapter,
scsihostsrc->bus,
* Optionally fills @src and @idx if provided with the specific backing chain
* element which corresponds to the node name.
*/
-virDomainDiskDefPtr
-qemuDomainDiskLookupByNodename(virDomainDefPtr def,
- virDomainBackupDefPtr backupdef,
+virDomainDiskDef *
+qemuDomainDiskLookupByNodename(virDomainDef *def,
+ virDomainBackupDef *backupdef,
const char *nodename,
- virStorageSourcePtr *src)
+ virStorageSource **src)
{
size_t i;
- virStorageSourcePtr tmp = NULL;
+ virStorageSource *tmp = NULL;
if (!src)
src = &tmp;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr domdisk = def->disks[i];
+ virDomainDiskDef *domdisk = def->disks[i];
if ((*src = qemuDomainVirStorageSourceFindByNodeName(domdisk->src, nodename)))
return domdisk;
if (backupdef) {
for (i = 0; i < backupdef->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = backupdef->disks + i;
+ virDomainBackupDiskDef *backupdisk = backupdef->disks + i;
if (backupdisk->store &&
(*src = qemuDomainVirStorageSourceFindByNodeName(backupdisk->store, nodename)))
* entry for a disk.
*/
char *
-qemuDomainDiskBackingStoreGetName(virDomainDiskDefPtr disk,
+qemuDomainDiskBackingStoreGetName(virDomainDiskDef *disk,
unsigned int idx)
{
if (idx)
}
-virStorageSourcePtr
+virStorageSource *
qemuDomainGetStorageSourceByDevstr(const char *devstr,
- virDomainDefPtr def,
- virDomainBackupDefPtr backupdef)
+ virDomainDef *def,
+ virDomainBackupDef *backupdef)
{
- virDomainDiskDefPtr disk = NULL;
- virStorageSourcePtr n;
+ virDomainDiskDef *disk = NULL;
+ virStorageSource *n;
g_autofree char *target = NULL;
unsigned int idx;
size_t i;
for (i = 0; i < backupdef->ndisks; i++) {
- virDomainBackupDiskDefPtr backupdisk = backupdef->disks + i;
+ virDomainBackupDiskDef *backupdisk = backupdef->disks + i;
if (STRNEQ(target, backupdisk->name))
continue;
static void
qemuDomainSaveCookieDispose(void *obj)
{
- qemuDomainSaveCookiePtr cookie = obj;
+ qemuDomainSaveCookie *cookie = obj;
VIR_DEBUG("cookie=%p", cookie);
}
-qemuDomainSaveCookiePtr
-qemuDomainSaveCookieNew(virDomainObjPtr vm)
+qemuDomainSaveCookie *
+qemuDomainSaveCookieNew(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(qemuDomainSaveCookie) cookie = NULL;
if (qemuDomainInitialize() < 0)
static int
qemuDomainSaveCookieParse(xmlXPathContextPtr ctxt G_GNUC_UNUSED,
- virObjectPtr *obj)
+ virObject **obj)
{
g_autoptr(qemuDomainSaveCookie) cookie = NULL;
cookie->slirpHelper = virXPathBoolean("boolean(./slirpHelper)", ctxt) > 0;
- *obj = (virObjectPtr) g_steal_pointer(&cookie);
+ *obj = (virObject *) g_steal_pointer(&cookie);
return 0;
}
static int
-qemuDomainSaveCookieFormat(virBufferPtr buf,
- virObjectPtr obj)
+qemuDomainSaveCookieFormat(virBuffer *buf,
+ virObject *obj)
{
- qemuDomainSaveCookiePtr cookie = (qemuDomainSaveCookiePtr) obj;
+ qemuDomainSaveCookie *cookie = (qemuDomainSaveCookie *) obj;
if (cookie->cpu &&
virCPUDefFormatBufFull(buf, cookie->cpu, NULL) < 0)
* Returns 0 on success, -1 on error.
*/
int
-qemuDomainUpdateCPU(virDomainObjPtr vm,
- virCPUDefPtr cpu,
- virCPUDefPtr *origCPU)
+qemuDomainUpdateCPU(virDomainObj *vm,
+ virCPUDef *cpu,
+ virCPUDef **origCPU)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
*origCPU = NULL;
* Returns 0 on success, -1 on error.
*/
int
-qemuDomainFixupCPUs(virDomainObjPtr vm,
- virCPUDefPtr *origCPU)
+qemuDomainFixupCPUs(virDomainObj *vm,
+ virCPUDef **origCPU)
{
g_autoptr(virCPUDef) fixedCPU = NULL;
g_autoptr(virCPUDef) fixedOrig = NULL;
char *
-qemuDomainGetMachineName(virDomainObjPtr vm)
+qemuDomainGetMachineName(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
char *ret = NULL;
if (vm->pid > 0) {
bool
qemuDomainCheckCCWS390AddressSupport(const virDomainDef *def,
const virDomainDeviceInfo *info,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
const char *devicename)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
* for detected backing chain members.
*/
void
-qemuDomainPrepareDiskSourceData(virDomainDiskDefPtr disk,
- virStorageSourcePtr src)
+qemuDomainPrepareDiskSourceData(virDomainDiskDef *disk,
+ virStorageSource *src)
{
if (!disk)
return;
static void
-qemuDomainPrepareDiskCachemode(virDomainDiskDefPtr disk)
+qemuDomainPrepareDiskCachemode(virDomainDiskDef *disk)
{
if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DEFAULT &&
disk->src->shared && !disk->src->readonly)
static int
-qemuDomainPrepareStorageSourcePR(virStorageSourcePtr src,
- qemuDomainObjPrivatePtr priv,
+qemuDomainPrepareStorageSourcePR(virStorageSource *src,
+ qemuDomainObjPrivate *priv,
const char *parentalias)
{
if (!src->pr)
* Prepare any disk source relevant data for use with the -drive command line.
*/
static int
-qemuDomainPrepareDiskSourceLegacy(virDomainDiskDefPtr disk,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareDiskSourceLegacy(virDomainDiskDef *disk,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg)
{
if (qemuDomainValidateStorageSource(disk->src, priv->qemuCaps, true) < 0)
return -1;
int
-qemuDomainPrepareStorageSourceBlockdev(virDomainDiskDefPtr disk,
- virStorageSourcePtr src,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareStorageSourceBlockdev(virDomainDiskDef *disk,
+ virStorageSource *src,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg)
{
src->id = qemuDomainStorageIdNew(priv);
static int
-qemuDomainPrepareDiskSourceBlockdev(virDomainDiskDefPtr disk,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareDiskSourceBlockdev(virDomainDiskDef *disk,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg)
{
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- virStorageSourcePtr n;
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virStorageSource *n;
if (disk->copy_on_read == VIR_TRISTATE_SWITCH_ON &&
!diskPriv->nodeCopyOnRead)
int
-qemuDomainPrepareDiskSource(virDomainDiskDefPtr disk,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg)
+qemuDomainPrepareDiskSource(virDomainDiskDef *disk,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg)
{
/* Nothing to prepare as it will use -chardev instead
* of -blockdev/-drive option. */
int
-qemuDomainPrepareHostdev(virDomainHostdevDefPtr hostdev,
- qemuDomainObjPrivatePtr priv)
+qemuDomainPrepareHostdev(virDomainHostdevDef *hostdev,
+ qemuDomainObjPrivate *priv)
{
if (virHostdevIsSCSIDevice(hostdev)) {
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
- virStorageSourcePtr src = NULL;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
+ virStorageSource *src = NULL;
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE:
if (src->auth) {
bool iscsiHasPS = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_ISCSI_PASSWORD_SECRET);
virSecretUsageType usageType = VIR_SECRET_USAGE_TYPE_ISCSI;
- qemuDomainStorageSourcePrivatePtr srcPriv = qemuDomainStorageSourcePrivateFetch(src);
+ qemuDomainStorageSourcePrivate *srcPriv = qemuDomainStorageSourcePrivateFetch(src);
if (!qemuDomainSupportsEncryptedSecret(priv) || !iscsiHasPS) {
srcPriv->secinfo = qemuDomainSecretInfoNewPlain(usageType,
char *
-qemuDomainGetManagedPRSocketPath(qemuDomainObjPrivatePtr priv)
+qemuDomainGetManagedPRSocketPath(qemuDomainObjPrivate *priv)
{
return g_strdup_printf("%s/%s.sock", priv->libDir,
qemuDomainGetManagedPRAlias());
* Generate a new unique id for a storage object. Useful for node name generation.
*/
unsigned int
-qemuDomainStorageIdNew(qemuDomainObjPrivatePtr priv)
+qemuDomainStorageIdNew(qemuDomainObjPrivate *priv)
{
return ++priv->nodenameindex;
}
* for a single instance, so can be reset on VM shutdown.
*/
void
-qemuDomainStorageIdReset(qemuDomainObjPrivatePtr priv)
+qemuDomainStorageIdReset(qemuDomainObjPrivate *priv)
{
priv->nodenameindex = 0;
}
* command line.
*/
bool
-qemuDomainIsUsingNoShutdown(qemuDomainObjPrivatePtr priv)
+qemuDomainIsUsingNoShutdown(qemuDomainObjPrivate *priv)
{
return priv->allowReboot == VIR_TRISTATE_BOOL_YES;
}
bool
-qemuDomainDiskIsMissingLocalOptional(virDomainDiskDefPtr disk)
+qemuDomainDiskIsMissingLocalOptional(virDomainDiskDef *disk)
{
return disk->startupPolicy == VIR_DOMAIN_STARTUP_POLICY_OPTIONAL &&
virStorageSourceIsLocalStorage(disk->src) && disk->src->path &&
void
-qemuDomainNVRAMPathFormat(virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
+qemuDomainNVRAMPathFormat(virQEMUDriverConfig *cfg,
+ virDomainDef *def,
char **path)
{
*path = g_strdup_printf("%s/%s_VARS.fd", cfg->nvramDir, def->name);
void
-qemuDomainNVRAMPathGenerate(virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def)
+qemuDomainNVRAMPathGenerate(virQEMUDriverConfig *cfg,
+ virDomainDef *def)
{
if (virDomainDefHasOldStyleROUEFI(def) &&
!def->os.loader->nvram)
const char *name G_GNUC_UNUSED,
void *opaque)
{
- qemuBlockJobDataPtr job = payload;
+ qemuBlockJobData *job = payload;
bool *hasPR = opaque;
if (job->disk)
* managed persistent reservations.
*/
bool
-qemuDomainDefHasManagedPR(virDomainObjPtr vm)
+qemuDomainDefHasManagedPR(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool jobPR = false;
if (virDomainDefHasManagedPR(vm->def))
* 0 in case everything is supported.
*/
int
-qemuDomainSupportsCheckpointsBlockjobs(virDomainObjPtr vm)
+qemuDomainSupportsCheckpointsBlockjobs(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_INCREMENTAL_BACKUP) &&
virDomainListCheckpoints(vm->checkpoints, NULL, NULL, NULL, 0) > 0) {
* 'libvirt-pflash1-format' for pflash1.
*/
int
-qemuDomainInitializePflashStorageSource(virDomainObjPtr vm)
+qemuDomainInitializePflashStorageSource(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *def = vm->def;
g_autoptr(virStorageSource) pflash0 = NULL;
g_autoptr(virStorageSource) pflash1 = NULL;
* Note that this does not verify whether other block jobs are running etc.
*/
bool
-qemuDomainDiskBlockJobIsSupported(virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainDiskBlockJobIsSupported(virDomainObj *vm,
+ virDomainDiskDef *disk)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
qemuDiskBusIsSD(disk->bus)) {
* qemuDomainStorageFileInit and storage driver APIs if possible.
**/
int
-qemuDomainOpenFile(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainOpenFile(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
int oflags,
bool *needUnlink)
uid_t user = cfg->user;
gid_t group = cfg->group;
bool dynamicOwnership = cfg->dynamicOwnership;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
/* TODO: Take imagelabel into account? */
if (vm &&
int
-qemuDomainFileWrapperFDClose(virDomainObjPtr vm,
- virFileWrapperFdPtr fd)
+qemuDomainFileWrapperFDClose(virDomainObj *vm,
+ virFileWrapperFd *fd)
{
int ret;
* -1 otherwise.
*/
int
-qemuDomainInterfaceSetDefaultQDisc(virQEMUDriverPtr driver,
- virDomainNetDefPtr net)
+qemuDomainInterfaceSetDefaultQDisc(virQEMUDriver *driver,
+ virDomainNetDef *net)
{
virDomainNetType actualType = virDomainNetGetActualType(net);
int
-qemuDomainNamePathsCleanup(virQEMUDriverConfigPtr cfg,
+qemuDomainNamePathsCleanup(virQEMUDriverConfig *cfg,
const char *name,
bool bestEffort)
{
# define QEMU_DOMAIN_MIG_BANDWIDTH_MAX (INT64_MAX / (1024 * 1024))
#endif
-typedef void (*qemuDomainCleanupCallback)(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+typedef void (*qemuDomainCleanupCallback)(virQEMUDriver *driver,
+ virDomainObj *vm);
#define QEMU_DOMAIN_MASTER_KEY_LEN 32 /* 32 bytes for 256 bit random key */
void
-qemuDomainObjSaveStatus(virQEMUDriverPtr driver,
- virDomainObjPtr obj);
+qemuDomainObjSaveStatus(virQEMUDriver *driver,
+ virDomainObj *obj);
-void qemuDomainSaveStatus(virDomainObjPtr obj);
-void qemuDomainSaveConfig(virDomainObjPtr obj);
+void qemuDomainSaveStatus(virDomainObj *obj);
+void qemuDomainSaveConfig(virDomainObj *obj);
/* helper data types for async device unplug */
} qemuDomainUnpluggingDeviceStatus;
typedef struct _qemuDomainUnpluggingDevice qemuDomainUnpluggingDevice;
-typedef qemuDomainUnpluggingDevice *qemuDomainUnpluggingDevicePtr;
struct _qemuDomainUnpluggingDevice {
const char *alias;
qemuDomainUnpluggingDeviceStatus status;
} qemuDomainSecretInfoType;
typedef struct _qemuDomainSecretPlain qemuDomainSecretPlain;
-typedef struct _qemuDomainSecretPlain *qemuDomainSecretPlainPtr;
struct _qemuDomainSecretPlain {
char *username;
uint8_t *secret;
#define QEMU_DOMAIN_AES_IV_LEN 16 /* 16 bytes for 128 bit random */
/* initialization vector */
typedef struct _qemuDomainSecretAES qemuDomainSecretAES;
-typedef struct _qemuDomainSecretAES *qemuDomainSecretAESPtr;
struct _qemuDomainSecretAES {
char *username;
char *alias; /* generated alias for secret */
};
typedef struct _qemuDomainSecretInfo qemuDomainSecretInfo;
-typedef qemuDomainSecretInfo *qemuDomainSecretInfoPtr;
struct _qemuDomainSecretInfo {
qemuDomainSecretInfoType type;
union {
};
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
-typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
struct _qemuDomainObjPrivate {
- virQEMUDriverPtr driver;
+ virQEMUDriver *driver;
qemuDomainJobObj job;
- virBitmapPtr namespaces;
+ virBitmap *namespaces;
virEventThread *eventThread;
- qemuMonitorPtr mon;
- virDomainChrSourceDefPtr monConfig;
+ qemuMonitor *mon;
+ virDomainChrSourceDef *monConfig;
bool monError;
unsigned long long monStart;
int agentTimeout;
- qemuAgentPtr agent;
+ qemuAgent *agent;
bool agentError;
bool beingDestroyed;
char *pidfile;
- virDomainPCIAddressSetPtr pciaddrs;
- virDomainUSBAddressSetPtr usbaddrs;
+ virDomainPCIAddressSet *pciaddrs;
+ virDomainUSBAddressSet *usbaddrs;
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
char *lockState;
bool fakeReboot;
unsigned short migrationPort;
int preMigrationState;
- virChrdevsPtr devs;
+ virChrdevs *devs;
qemuDomainCleanupCallback *cleanupCallbacks;
size_t ncleanupCallbacks;
size_t ncleanupCallbacks_max;
- virCgroupPtr cgroup;
+ virCgroup *cgroup;
- virPerfPtr perf;
+ virPerf *perf;
qemuDomainUnpluggingDevice unplug;
bool hookRun; /* true if there was a hook run over this domain */
/* Bitmaps below hold data from the auto NUMA feature */
- virBitmapPtr autoNodeset;
- virBitmapPtr autoCpuset;
+ virBitmap *autoNodeset;
+ virBitmap *autoCpuset;
bool signalIOError; /* true if the domain condition should be signalled on
I/O error */
/* for migrations using TLS with a secret (not to be saved in our */
/* private XML). */
- qemuDomainSecretInfoPtr migSecinfo;
+ qemuDomainSecretInfo *migSecinfo;
/* CPU def used to start the domain when it differs from the one actually
* provided by QEMU. */
- virCPUDefPtr origCPU;
+ virCPUDef *origCPU;
/* If true virtlogd is used as stdio handler for character devices. */
bool chardevStdioLogd;
/* Migration capabilities. Rechecked on reconnect, not to be saved in
* private XML. */
- virBitmapPtr migrationCaps;
+ virBitmap *migrationCaps;
/* true if qemu-pr-helper process is running for the domain */
bool prDaemonRunning;
/* Until we add full support for backing chains for pflash drives, these
* pointers hold the temporary virStorageSources for creating the -blockdev
* commandline for pflash drives. */
- virStorageSourcePtr pflash0;
- virStorageSourcePtr pflash1;
+ virStorageSource *pflash0;
+ virStorageSource *pflash1;
/* running backup job */
- virDomainBackupDefPtr backup;
+ virDomainBackupDef *backup;
bool dbusDaemonRunning;
};
#define QEMU_DOMAIN_PRIVATE(vm) \
- ((qemuDomainObjPrivatePtr) (vm)->privateData)
+ ((qemuDomainObjPrivate *) (vm)->privateData)
#define QEMU_DOMAIN_DISK_PRIVATE(disk) \
- ((qemuDomainDiskPrivatePtr) (disk)->privateData)
+ ((qemuDomainDiskPrivate *) (disk)->privateData)
typedef struct _qemuDomainDiskPrivate qemuDomainDiskPrivate;
-typedef qemuDomainDiskPrivate *qemuDomainDiskPrivatePtr;
struct _qemuDomainDiskPrivate {
virObject parent;
/* ideally we want a smarter way to interlock block jobs on single qemu disk
* in the future, but for now we just disallow any concurrent job on a
* single disk */
- qemuBlockJobDataPtr blockjob;
+ qemuBlockJobData *blockjob;
bool migrating; /* the disk is being migrated */
- virStorageSourcePtr migrSource; /* disk source object used for NBD migration */
+ virStorageSource *migrSource; /* disk source object used for NBD migration */
/* information about the device */
bool tray; /* device has tray */
};
#define QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src) \
- ((qemuDomainStorageSourcePrivatePtr) (src)->privateData)
+ ((qemuDomainStorageSourcePrivate *) (src)->privateData)
typedef struct _qemuDomainStorageSourcePrivate qemuDomainStorageSourcePrivate;
-typedef qemuDomainStorageSourcePrivate *qemuDomainStorageSourcePrivatePtr;
struct _qemuDomainStorageSourcePrivate {
virObject parent;
/* data required for authentication to the storage source */
- qemuDomainSecretInfoPtr secinfo;
+ qemuDomainSecretInfo *secinfo;
/* data required for decryption of encrypted storage source */
- qemuDomainSecretInfoPtr encinfo;
+ qemuDomainSecretInfo *encinfo;
/* secure passthrough of the http cookie */
- qemuDomainSecretInfoPtr httpcookie;
+ qemuDomainSecretInfo *httpcookie;
/* key for decrypting TLS certificate */
- qemuDomainSecretInfoPtr tlsKeySecret;
+ qemuDomainSecretInfo *tlsKeySecret;
};
-virObjectPtr qemuDomainStorageSourcePrivateNew(void);
-qemuDomainStorageSourcePrivatePtr
-qemuDomainStorageSourcePrivateFetch(virStorageSourcePtr src);
+virObject *qemuDomainStorageSourcePrivateNew(void);
+qemuDomainStorageSourcePrivate *
+qemuDomainStorageSourcePrivateFetch(virStorageSource *src);
typedef struct _qemuDomainVcpuPrivate qemuDomainVcpuPrivate;
-typedef qemuDomainVcpuPrivate *qemuDomainVcpuPrivatePtr;
struct _qemuDomainVcpuPrivate {
virObject parent;
virTristateBool halted;
/* copy of the data that qemu returned */
- virJSONValuePtr props;
+ virJSONValue *props;
/* information for hotpluggable cpus */
char *type;
};
#define QEMU_DOMAIN_VCPU_PRIVATE(vcpu) \
- ((qemuDomainVcpuPrivatePtr) (vcpu)->privateData)
+ ((qemuDomainVcpuPrivate *) (vcpu)->privateData)
struct qemuDomainDiskInfo {
};
#define QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev) \
- ((qemuDomainChrSourcePrivatePtr) (dev)->privateData)
+ ((qemuDomainChrSourcePrivate *) (dev)->privateData)
typedef struct _qemuDomainChrSourcePrivate qemuDomainChrSourcePrivate;
-typedef qemuDomainChrSourcePrivate *qemuDomainChrSourcePrivatePtr;
struct _qemuDomainChrSourcePrivate {
virObject parent;
/* for char devices using secret
* NB: *not* to be written to qemu domain object XML */
- qemuDomainSecretInfoPtr secinfo;
+ qemuDomainSecretInfo *secinfo;
};
typedef struct _qemuDomainVsockPrivate qemuDomainVsockPrivate;
-typedef qemuDomainVsockPrivate *qemuDomainVsockPrivatePtr;
struct _qemuDomainVsockPrivate {
virObject parent;
#define QEMU_DOMAIN_VIDEO_PRIVATE(dev) \
- ((qemuDomainVideoPrivatePtr) (dev)->privateData)
+ ((qemuDomainVideoPrivate *) (dev)->privateData)
typedef struct _qemuDomainVideoPrivate qemuDomainVideoPrivate;
-typedef qemuDomainVideoPrivate *qemuDomainVideoPrivatePtr;
struct _qemuDomainVideoPrivate {
virObject parent;
#define QEMU_DOMAIN_GRAPHICS_PRIVATE(dev) \
- ((qemuDomainGraphicsPrivatePtr) (dev)->privateData)
+ ((qemuDomainGraphicsPrivate *) (dev)->privateData)
typedef struct _qemuDomainGraphicsPrivate qemuDomainGraphicsPrivate;
-typedef qemuDomainGraphicsPrivate *qemuDomainGraphicsPrivatePtr;
struct _qemuDomainGraphicsPrivate {
virObject parent;
char *tlsAlias;
- qemuDomainSecretInfoPtr secinfo;
+ qemuDomainSecretInfo *secinfo;
};
#define QEMU_DOMAIN_NETWORK_PRIVATE(dev) \
- ((qemuDomainNetworkPrivatePtr) (dev)->privateData)
+ ((qemuDomainNetworkPrivate *) (dev)->privateData)
typedef struct _qemuDomainNetworkPrivate qemuDomainNetworkPrivate;
-typedef qemuDomainNetworkPrivate *qemuDomainNetworkPrivatePtr;
struct _qemuDomainNetworkPrivate {
virObject parent;
- qemuSlirpPtr slirp;
+ qemuSlirp *slirp;
};
#define QEMU_DOMAIN_FS_PRIVATE(dev) \
- ((qemuDomainFSPrivatePtr) (dev)->privateData)
+ ((qemuDomainFSPrivate *) (dev)->privateData)
typedef struct _qemuDomainFSPrivate qemuDomainFSPrivate;
-typedef qemuDomainFSPrivate *qemuDomainFSPrivatePtr;
struct _qemuDomainFSPrivate {
virObject parent;
} qemuProcessEventType;
struct qemuProcessEvent {
- virDomainObjPtr vm;
+ virDomainObj *vm;
qemuProcessEventType eventType;
int action;
int status;
#define QEMU_TYPE_DOMAIN_LOG_CONTEXT qemu_domain_log_context_get_type()
G_DECLARE_FINAL_TYPE(qemuDomainLogContext, qemu_domain_log_context, QEMU, DOMAIN_LOG_CONTEXT, GObject);
-typedef qemuDomainLogContext *qemuDomainLogContextPtr;
typedef struct _qemuDomainSaveCookie qemuDomainSaveCookie;
-typedef qemuDomainSaveCookie *qemuDomainSaveCookiePtr;
struct _qemuDomainSaveCookie {
virObject parent;
- virCPUDefPtr cpu;
+ virCPUDef *cpu;
bool slirpHelper;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainSaveCookie, virObjectUnref);
typedef struct _qemuDomainXmlNsDef qemuDomainXmlNsDef;
-typedef qemuDomainXmlNsDef *qemuDomainXmlNsDefPtr;
struct _qemuDomainXmlNsDef {
size_t num_args;
char **args;
typedef struct _qemuDomainJobPrivateMigrateTempBitmap qemuDomainJobPrivateMigrateTempBitmap;
-typedef qemuDomainJobPrivateMigrateTempBitmap *qemuDomainJobPrivateMigrateTempBitmapPtr;
-
struct _qemuDomainJobPrivateMigrateTempBitmap {
char *nodename;
char *bitmapname;
};
void
-qemuDomainJobPrivateMigrateTempBitmapFree(qemuDomainJobPrivateMigrateTempBitmapPtr bmp);
+qemuDomainJobPrivateMigrateTempBitmapFree(qemuDomainJobPrivateMigrateTempBitmap *bmp);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainJobPrivateMigrateTempBitmap, qemuDomainJobPrivateMigrateTempBitmapFree);
typedef struct _qemuDomainJobPrivate qemuDomainJobPrivate;
-typedef qemuDomainJobPrivate *qemuDomainJobPrivatePtr;
struct _qemuDomainJobPrivate {
bool spiceMigration; /* we asked for spice migration and we
* should wait for it to finish */
bool spiceMigrated; /* spice migration completed */
bool dumpCompleted; /* dump completed */
- qemuMigrationParamsPtr migParams;
+ qemuMigrationParams *migParams;
GSList *migTempBitmaps; /* temporary block dirty bitmaps - qemuDomainJobPrivateMigrateTempBitmap */
};
-int qemuDomainObjStartWorker(virDomainObjPtr dom);
-void qemuDomainObjStopWorker(virDomainObjPtr dom);
+int qemuDomainObjStartWorker(virDomainObj *dom);
+void qemuDomainObjStopWorker(virDomainObj *dom);
-virDomainObjPtr qemuDomainObjFromDomain(virDomainPtr domain);
+virDomainObj *qemuDomainObjFromDomain(virDomainPtr domain);
-qemuDomainSaveCookiePtr qemuDomainSaveCookieNew(virDomainObjPtr vm);
+qemuDomainSaveCookie *qemuDomainSaveCookieNew(virDomainObj *vm);
void qemuDomainEventFlush(int timer, void *opaque);
-qemuMonitorPtr qemuDomainGetMonitor(virDomainObjPtr vm)
+qemuMonitor *qemuDomainGetMonitor(virDomainObj *vm)
ATTRIBUTE_NONNULL(1);
-void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
+ virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+int qemuDomainObjExitMonitor(virQEMUDriver *driver,
+ virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-qemuAgentPtr qemuDomainObjEnterAgent(virDomainObjPtr obj)
+qemuAgent *qemuDomainObjEnterAgent(virDomainObj *obj)
ATTRIBUTE_NONNULL(1);
-void qemuDomainObjExitAgent(virDomainObjPtr obj, qemuAgentPtr agent)
+void qemuDomainObjExitAgent(virDomainObj *obj, qemuAgent *agent)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterRemote(virDomainObjPtr obj)
+void qemuDomainObjEnterRemote(virDomainObj *obj)
ATTRIBUTE_NONNULL(1);
-int qemuDomainObjExitRemote(virDomainObjPtr obj,
+int qemuDomainObjExitRemote(virDomainObj *obj,
bool checkActive)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-virDomainDefPtr qemuDomainDefCopy(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr src,
+virDomainDef *qemuDomainDefCopy(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *src,
unsigned int flags);
-int qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr vm,
+int qemuDomainDefFormatBuf(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *vm,
unsigned int flags,
virBuffer *buf);
-char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr vm,
+char *qemuDomainDefFormatXML(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *vm,
unsigned int flags);
-char *qemuDomainFormatXML(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+char *qemuDomainFormatXML(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags);
-char *qemuDomainDefFormatLive(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr def,
- virCPUDefPtr origCPU,
+char *qemuDomainDefFormatLive(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *def,
+ virCPUDef *origCPU,
bool inactive,
bool compatible);
-void qemuDomainObjTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+void qemuDomainObjTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
virDomainTaintFlags taint,
- qemuDomainLogContextPtr logCtxt);
+ qemuDomainLogContext *logCtxt);
-void qemuDomainObjTaintMsg(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+void qemuDomainObjTaintMsg(virQEMUDriver *driver,
+ virDomainObj *obj,
virDomainTaintFlags taint,
- qemuDomainLogContextPtr logCtxt,
+ qemuDomainLogContext *logCtxt,
const char *msg,
...) G_GNUC_PRINTF(5, 6);
-char **qemuDomainObjGetTainting(virQEMUDriverPtr driver,
- virDomainObjPtr obj);
+char **qemuDomainObjGetTainting(virQEMUDriver *driver,
+ virDomainObj *obj);
-void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- qemuDomainLogContextPtr logCtxt,
+void qemuDomainObjCheckTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ qemuDomainLogContext *logCtxt,
bool incomingMigration);
-void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainDiskDefPtr disk,
- qemuDomainLogContextPtr logCtxt);
-void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainHostdevDefPtr disk,
- qemuDomainLogContextPtr logCtxt);
-void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- virDomainNetDefPtr net,
- qemuDomainLogContextPtr logCtxt);
+void qemuDomainObjCheckDiskTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainDiskDef *disk,
+ qemuDomainLogContext *logCtxt);
+void qemuDomainObjCheckHostdevTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainHostdevDef *disk,
+ qemuDomainLogContext *logCtxt);
+void qemuDomainObjCheckNetTaint(virQEMUDriver *driver,
+ virDomainObj *obj,
+ virDomainNetDef *net,
+ qemuDomainLogContext *logCtxt);
typedef enum {
QEMU_DOMAIN_LOG_CONTEXT_MODE_START,
QEMU_DOMAIN_LOG_CONTEXT_MODE_STOP,
} qemuDomainLogContextMode;
-qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainLogContext *qemuDomainLogContextNew(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainLogContextMode mode);
-int qemuDomainLogContextWrite(qemuDomainLogContextPtr ctxt,
+int qemuDomainLogContextWrite(qemuDomainLogContext *ctxt,
const char *fmt, ...) G_GNUC_PRINTF(2, 3);
-ssize_t qemuDomainLogContextRead(qemuDomainLogContextPtr ctxt,
+ssize_t qemuDomainLogContextRead(qemuDomainLogContext *ctxt,
char **msg);
-int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt);
-void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt);
+int qemuDomainLogContextGetWriteFD(qemuDomainLogContext *ctxt);
+void qemuDomainLogContextMarkPosition(qemuDomainLogContext *ctxt);
-virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt);
+virLogManager *qemuDomainLogContextGetManager(qemuDomainLogContext *ctxt);
-int qemuDomainLogAppendMessage(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainLogAppendMessage(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *fmt,
...) G_GNUC_PRINTF(3, 4);
-const char *qemuFindQemuImgBinary(virQEMUDriverPtr driver);
+const char *qemuFindQemuImgBinary(virQEMUDriver *driver);
-int qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
- virDomainMomentObjPtr snapshot,
- virDomainXMLOptionPtr xmlopt,
+int qemuDomainSnapshotWriteMetadata(virDomainObj *vm,
+ virDomainMomentObj *snapshot,
+ virDomainXMLOption *xmlopt,
const char *snapshotDir);
-int qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virDomainMomentObjPtr snap,
+int qemuDomainSnapshotForEachQcow2(virQEMUDriver *driver,
+ virDomainDef *def,
+ virDomainMomentObj *snap,
const char *op,
bool try_all);
-int qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
+int qemuDomainSnapshotDiscard(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap,
bool update_current,
bool metadata_only);
typedef struct _virQEMUMomentRemove virQEMUMomentRemove;
-typedef virQEMUMomentRemove *virQEMUMomentRemovePtr;
struct _virQEMUMomentRemove {
- virQEMUDriverPtr driver;
- virDomainObjPtr vm;
+ virQEMUDriver *driver;
+ virDomainObj *vm;
int err;
bool metadata_only;
- virDomainMomentObjPtr current;
+ virDomainMomentObj *current;
bool found;
- int (*momentDiscard)(virQEMUDriverPtr, virDomainObjPtr,
- virDomainMomentObjPtr, bool, bool);
+ int (*momentDiscard)(virQEMUDriver *, virDomainObj *,
+ virDomainMomentObj *, bool, bool);
};
int qemuDomainMomentDiscardAll(void *payload,
const char *name,
void *data);
-int qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+int qemuDomainSnapshotDiscardAllMetadata(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDomainRemoveInactive(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainRemoveInactive(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuDomainSetFakeReboot(virQEMUDriver *driver,
+ virDomainObj *vm,
bool value);
-int qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainCheckDiskStartupPolicy(virQEMUDriver *driver,
+ virDomainObj *vm,
size_t diskIndex,
bool cold_boot);
-int qemuDomainCheckDiskPresence(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainCheckDiskPresence(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags);
-int qemuDomainStorageSourceValidateDepth(virStorageSourcePtr src,
+int qemuDomainStorageSourceValidateDepth(virStorageSource *src,
int add,
const char *diskdst);
-int qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr disksrc,
+int qemuDomainDetermineDiskChain(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *disksrc,
bool report_broken);
-bool qemuDomainDiskChangeSupported(virDomainDiskDefPtr disk,
- virDomainDiskDefPtr orig_disk);
+bool qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
+ virDomainDiskDef *orig_disk);
-void qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr parentSrc,
+void qemuDomainGetImageIds(virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *parentSrc,
uid_t *uid,
gid_t *gid);
-int qemuDomainStorageFileInit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr parent);
+int qemuDomainStorageFileInit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *parent);
char *qemuDomainStorageAlias(const char *device, int depth);
const char *
-qemuDomainDiskGetTopNodename(virDomainDiskDefPtr disk)
+qemuDomainDiskGetTopNodename(virDomainDiskDef *disk)
ATTRIBUTE_NONNULL(1);
-int qemuDomainDiskGetBackendAlias(virDomainDiskDefPtr disk,
- virQEMUCapsPtr qemuCaps,
+int qemuDomainDiskGetBackendAlias(virDomainDiskDef *disk,
+ virQEMUCaps *qemuCaps,
char **backendAlias)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3) G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainStorageSourceChainAccessAllow(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src);
-int qemuDomainStorageSourceChainAccessRevoke(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src);
-
-void qemuDomainStorageSourceAccessRevoke(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr elem);
-int qemuDomainStorageSourceAccessAllow(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr elem,
+int qemuDomainStorageSourceChainAccessAllow(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src);
+int qemuDomainStorageSourceChainAccessRevoke(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src);
+
+void qemuDomainStorageSourceAccessRevoke(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *elem);
+int qemuDomainStorageSourceAccessAllow(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *elem,
bool readonly,
bool newSource,
bool chainTop);
-int qemuDomainPrepareStorageSourceBlockdev(virDomainDiskDefPtr disk,
- virStorageSourcePtr src,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg);
+int qemuDomainPrepareStorageSourceBlockdev(virDomainDiskDef *disk,
+ virStorageSource *src,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg);
-int qemuDomainCleanupAdd(virDomainObjPtr vm,
+int qemuDomainCleanupAdd(virDomainObj *vm,
qemuDomainCleanupCallback cb);
-void qemuDomainCleanupRemove(virDomainObjPtr vm,
+void qemuDomainCleanupRemove(virDomainObj *vm,
qemuDomainCleanupCallback cb);
-void qemuDomainCleanupRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainCleanupRun(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDomainObjPrivateDataClear(qemuDomainObjPrivatePtr priv);
+void qemuDomainObjPrivateDataClear(qemuDomainObjPrivate *priv);
extern virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks;
extern virXMLNamespace virQEMUDriverDomainXMLNamespace;
extern virDomainABIStability virQEMUDriverDomainABIStability;
extern virSaveCookieCallbacks virQEMUDriverDomainSaveCookie;
-int qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
- virDomainObjPtr vm, int asyncJob);
+int qemuDomainUpdateDeviceList(virQEMUDriver *driver,
+ virDomainObj *vm, int asyncJob);
-int qemuDomainUpdateMemoryDeviceInfo(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainUpdateMemoryDeviceInfo(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob);
-bool qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virDomainDefPtr src,
- virDomainDefPtr dst);
+bool qemuDomainDefCheckABIStability(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virDomainDef *src,
+ virDomainDef *dst);
-bool qemuDomainCheckABIStability(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr dst);
+bool qemuDomainCheckABIStability(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *dst);
-bool qemuDomainAgentAvailable(virDomainObjPtr vm,
+bool qemuDomainAgentAvailable(virDomainObj *vm,
bool reportError);
-bool qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk);
-bool qemuDomainHasBlockjob(virDomainObjPtr vm, bool copy_only)
+bool qemuDomainDiskBlockJobIsActive(virDomainDiskDef *disk);
+bool qemuDomainHasBlockjob(virDomainObj *vm, bool copy_only)
ATTRIBUTE_NONNULL(1);
-int qemuDomainAlignMemorySizes(virDomainDefPtr def);
-int qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
- virDomainMemoryDefPtr mem);
+int qemuDomainAlignMemorySizes(virDomainDef *def);
+int qemuDomainMemoryDeviceAlignSize(virDomainDef *def,
+ virDomainMemoryDef *mem);
-virDomainChrDefPtr qemuFindAgentConfig(virDomainDefPtr def);
+virDomainChrDef *qemuFindAgentConfig(virDomainDef *def);
/* You should normally avoid these functions and use the variant that
* doesn't have "Machine" in the name instead. */
bool qemuDomainHasBuiltinIDE(const virDomainDef *def);
bool qemuDomainHasBuiltinESP(const virDomainDef *def);
bool qemuDomainNeedsFDC(const virDomainDef *def);
-bool qemuDomainSupportsPCI(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps);
+bool qemuDomainSupportsPCI(virDomainDef *def,
+ virQEMUCaps *qemuCaps);
-void qemuDomainUpdateCurrentMemorySize(virDomainObjPtr vm);
+void qemuDomainUpdateCurrentMemorySize(virDomainObj *vm);
-unsigned long long qemuDomainGetMemLockLimitBytes(virDomainDefPtr def,
+unsigned long long qemuDomainGetMemLockLimitBytes(virDomainDef *def,
bool forceVFIO);
-int qemuDomainAdjustMaxMemLock(virDomainObjPtr vm,
+int qemuDomainAdjustMaxMemLock(virDomainObj *vm,
bool forceVFIO);
-int qemuDomainAdjustMaxMemLockHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
+int qemuDomainAdjustMaxMemLockHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
int qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
const virDomainMemoryDef *mem);
-bool qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm);
-bool qemuDomainHasVcpuPids(virDomainObjPtr vm);
-pid_t qemuDomainGetVcpuPid(virDomainObjPtr vm, unsigned int vcpuid);
-int qemuDomainValidateVcpuInfo(virDomainObjPtr vm);
-int qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+bool qemuDomainSupportsNewVcpuHotplug(virDomainObj *vm);
+bool qemuDomainHasVcpuPids(virDomainObj *vm);
+pid_t qemuDomainGetVcpuPid(virDomainObj *vm, unsigned int vcpuid);
+int qemuDomainValidateVcpuInfo(virDomainObj *vm);
+int qemuDomainRefreshVcpuInfo(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
bool state);
-bool qemuDomainGetVcpuHalted(virDomainObjPtr vm, unsigned int vcpu);
-int qemuDomainRefreshVcpuHalted(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+bool qemuDomainGetVcpuHalted(virDomainObj *vm, unsigned int vcpu);
+int qemuDomainRefreshVcpuHalted(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob);
-bool qemuDomainSupportsNicdev(virDomainDefPtr def,
- virDomainNetDefPtr net);
+bool qemuDomainSupportsNicdev(virDomainDef *def,
+ virDomainNetDef *net);
bool qemuDomainNetSupportsMTU(virDomainNetType type);
-int qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+int qemuDomainSetPrivatePaths(virQEMUDriver *driver,
+ virDomainObj *vm);
-virDomainDiskDefPtr qemuDomainDiskByName(virDomainDefPtr def, const char *name);
+virDomainDiskDef *qemuDomainDiskByName(virDomainDef *def, const char *name);
char *qemuDomainGetMasterKeyFilePath(const char *libDir);
-int qemuDomainMasterKeyReadFile(qemuDomainObjPrivatePtr priv);
+int qemuDomainMasterKeyReadFile(qemuDomainObjPrivate *priv);
-int qemuDomainWriteMasterKeyFile(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+int qemuDomainWriteMasterKeyFile(virQEMUDriver *driver,
+ virDomainObj *vm);
-int qemuDomainMasterKeyCreate(virDomainObjPtr vm);
+int qemuDomainMasterKeyCreate(virDomainObj *vm);
-void qemuDomainMasterKeyRemove(qemuDomainObjPrivatePtr priv);
+void qemuDomainMasterKeyRemove(qemuDomainObjPrivate *priv);
-bool qemuDomainSupportsEncryptedSecret(qemuDomainObjPrivatePtr priv);
+bool qemuDomainSupportsEncryptedSecret(qemuDomainObjPrivate *priv);
-void qemuDomainSecretInfoFree(qemuDomainSecretInfoPtr secinfo)
+void qemuDomainSecretInfoFree(qemuDomainSecretInfo *secinfo)
ATTRIBUTE_NONNULL(1);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainSecretInfo, qemuDomainSecretInfoFree);
-void qemuDomainSecretInfoDestroy(qemuDomainSecretInfoPtr secinfo);
+void qemuDomainSecretInfoDestroy(qemuDomainSecretInfo *secinfo);
-void qemuDomainSecretDiskDestroy(virDomainDiskDefPtr disk)
+void qemuDomainSecretDiskDestroy(virDomainDiskDef *disk)
ATTRIBUTE_NONNULL(1);
-bool qemuDomainStorageSourceHasAuth(virStorageSourcePtr src)
+bool qemuDomainStorageSourceHasAuth(virStorageSource *src)
ATTRIBUTE_NONNULL(1);
-qemuDomainSecretInfoPtr
-qemuDomainSecretInfoTLSNew(qemuDomainObjPrivatePtr priv,
+qemuDomainSecretInfo *
+qemuDomainSecretInfoTLSNew(qemuDomainObjPrivate *priv,
const char *srcAlias,
const char *secretUUID);
-void qemuDomainSecretHostdevDestroy(virDomainHostdevDefPtr disk)
+void qemuDomainSecretHostdevDestroy(virDomainHostdevDef *disk)
ATTRIBUTE_NONNULL(1);
-void qemuDomainSecretChardevDestroy(virDomainChrSourceDefPtr dev)
+void qemuDomainSecretChardevDestroy(virDomainChrSourceDef *dev)
ATTRIBUTE_NONNULL(1);
-int qemuDomainSecretChardevPrepare(virQEMUDriverConfigPtr cfg,
- qemuDomainObjPrivatePtr priv,
+int qemuDomainSecretChardevPrepare(virQEMUDriverConfig *cfg,
+ qemuDomainObjPrivate *priv,
const char *chrAlias,
- virDomainChrSourceDefPtr dev)
+ virDomainChrSourceDef *dev)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
-void qemuDomainSecretDestroy(virDomainObjPtr vm)
+void qemuDomainSecretDestroy(virDomainObj *vm)
ATTRIBUTE_NONNULL(1);
-int qemuDomainSecretPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+int qemuDomainSecretPrepare(virQEMUDriver *driver,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuDomainDefValidateDiskLunSource(const virStorageSource *src)
ATTRIBUTE_NONNULL(1);
int qemuDomainDeviceDefValidateDisk(const virDomainDiskDef *disk,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
-int qemuDomainPrepareChannel(virDomainChrDefPtr chr,
+int qemuDomainPrepareChannel(virDomainChrDef *chr,
const char *domainChannelTargetDir)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDefPtr source,
- virQEMUDriverConfigPtr cfg)
+void qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDef *source,
+ virQEMUDriverConfig *cfg)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainPrepareChardevSource(virDomainDefPtr def,
- virQEMUDriverConfigPtr cfg)
+void qemuDomainPrepareChardevSource(virDomainDef *def,
+ virQEMUDriverConfig *cfg)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainPrepareShmemChardev(virDomainShmemDefPtr shmem)
+void qemuDomainPrepareShmemChardev(virDomainShmemDef *shmem)
ATTRIBUTE_NONNULL(1);
-bool qemuDomainVcpuHotplugIsInOrder(virDomainDefPtr def)
+bool qemuDomainVcpuHotplugIsInOrder(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
-void qemuDomainVcpuPersistOrder(virDomainDefPtr def)
+void qemuDomainVcpuPersistOrder(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
-int qemuDomainCheckMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainCheckMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
-bool qemuDomainSupportsVideoVga(virDomainVideoDefPtr video,
- virQEMUCapsPtr qemuCaps);
+bool qemuDomainSupportsVideoVga(virDomainVideoDef *video,
+ virQEMUCaps *qemuCaps);
bool qemuDomainNeedsVFIO(const virDomainDef *def);
-int qemuDomainGetHostdevPath(virDomainHostdevDefPtr dev,
+int qemuDomainGetHostdevPath(virDomainHostdevDef *dev,
char **path,
int *perms);
-virDomainDiskDefPtr qemuDomainDiskLookupByNodename(virDomainDefPtr def,
- virDomainBackupDefPtr backupdef,
+virDomainDiskDef *qemuDomainDiskLookupByNodename(virDomainDef *def,
+ virDomainBackupDef *backupdef,
const char *nodename,
- virStorageSourcePtr *src);
+ virStorageSource **src);
-char *qemuDomainDiskBackingStoreGetName(virDomainDiskDefPtr disk,
+char *qemuDomainDiskBackingStoreGetName(virDomainDiskDef *disk,
unsigned int idx);
-virStorageSourcePtr qemuDomainGetStorageSourceByDevstr(const char *devstr,
- virDomainDefPtr def,
- virDomainBackupDefPtr backupdef);
+virStorageSource *qemuDomainGetStorageSourceByDevstr(const char *devstr,
+ virDomainDef *def,
+ virDomainBackupDef *backupdef);
int
-qemuDomainUpdateCPU(virDomainObjPtr vm,
- virCPUDefPtr cpu,
- virCPUDefPtr *origCPU);
+qemuDomainUpdateCPU(virDomainObj *vm,
+ virCPUDef *cpu,
+ virCPUDef **origCPU);
int
-qemuDomainFixupCPUs(virDomainObjPtr vm,
- virCPUDefPtr *origCPU);
+qemuDomainFixupCPUs(virDomainObj *vm,
+ virCPUDef **origCPU);
char *
-qemuDomainGetMachineName(virDomainObjPtr vm);
+qemuDomainGetMachineName(virDomainObj *vm);
void
-qemuDomainObjPrivateXMLFormatAllowReboot(virBufferPtr buf,
+qemuDomainObjPrivateXMLFormatAllowReboot(virBuffer *buf,
virTristateBool allowReboot);
int
bool
qemuDomainCheckCCWS390AddressSupport(const virDomainDef *def,
const virDomainDeviceInfo *info,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
const char *devicename);
void
-qemuDomainPrepareDiskSourceData(virDomainDiskDefPtr disk,
- virStorageSourcePtr src);
+qemuDomainPrepareDiskSourceData(virDomainDiskDef *disk,
+ virStorageSource *src);
int
-qemuDomainValidateStorageSource(virStorageSourcePtr src,
- virQEMUCapsPtr qemuCaps,
+qemuDomainValidateStorageSource(virStorageSource *src,
+ virQEMUCaps *qemuCaps,
bool maskBlockdev);
int
-qemuDomainPrepareDiskSource(virDomainDiskDefPtr disk,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg);
+qemuDomainPrepareDiskSource(virDomainDiskDef *disk,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg);
int
qemuDomainDiskCachemodeFlags(int cachemode,
bool *noflush);
int
-qemuDomainPrepareHostdev(virDomainHostdevDefPtr hostdev,
- qemuDomainObjPrivatePtr priv);
+qemuDomainPrepareHostdev(virDomainHostdevDef *hostdev,
+ qemuDomainObjPrivate *priv);
-char * qemuDomainGetManagedPRSocketPath(qemuDomainObjPrivatePtr priv);
+char * qemuDomainGetManagedPRSocketPath(qemuDomainObjPrivate *priv);
-bool qemuDomainDefHasManagedPR(virDomainObjPtr vm);
+bool qemuDomainDefHasManagedPR(virDomainObj *vm);
-unsigned int qemuDomainStorageIdNew(qemuDomainObjPrivatePtr priv);
-void qemuDomainStorageIdReset(qemuDomainObjPrivatePtr priv);
+unsigned int qemuDomainStorageIdNew(qemuDomainObjPrivate *priv);
+void qemuDomainStorageIdReset(qemuDomainObjPrivate *priv);
virDomainEventResumedDetailType
qemuDomainRunningReasonToResumeEvent(virDomainRunningReason reason);
bool
-qemuDomainIsUsingNoShutdown(qemuDomainObjPrivatePtr priv);
+qemuDomainIsUsingNoShutdown(qemuDomainObjPrivate *priv);
bool
-qemuDomainDiskIsMissingLocalOptional(virDomainDiskDefPtr disk);
+qemuDomainDiskIsMissingLocalOptional(virDomainDiskDef *disk);
void
-qemuDomainNVRAMPathFormat(virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def,
+qemuDomainNVRAMPathFormat(virQEMUDriverConfig *cfg,
+ virDomainDef *def,
char **path);
void
-qemuDomainNVRAMPathGenerate(virQEMUDriverConfigPtr cfg,
- virDomainDefPtr def);
+qemuDomainNVRAMPathGenerate(virQEMUDriverConfig *cfg,
+ virDomainDef *def);
virDomainEventSuspendedDetailType
qemuDomainPausedReasonToSuspendedEvent(virDomainPausedReason reason);
int
qemuDomainValidateActualNetDef(const virDomainNetDef *net,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
int
-qemuDomainSupportsCheckpointsBlockjobs(virDomainObjPtr vm)
+qemuDomainSupportsCheckpointsBlockjobs(virDomainObj *vm)
G_GNUC_WARN_UNUSED_RESULT;
int
-qemuDomainMakeCPUMigratable(virCPUDefPtr cpu);
+qemuDomainMakeCPUMigratable(virCPUDef *cpu);
int
-qemuDomainInitializePflashStorageSource(virDomainObjPtr vm);
+qemuDomainInitializePflashStorageSource(virDomainObj *vm);
bool
-qemuDomainDiskBlockJobIsSupported(virDomainObjPtr vm,
- virDomainDiskDefPtr disk);
+qemuDomainDiskBlockJobIsSupported(virDomainObj *vm,
+ virDomainDiskDef *disk);
int
-qemuDomainDefNumaCPUsRectify(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps);
+qemuDomainDefNumaCPUsRectify(virDomainDef *def,
+ virQEMUCaps *qemuCaps);
-void qemuDomainRemoveInactiveJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainRemoveInactiveJob(virQEMUDriver *driver,
+ virDomainObj *vm);
-void qemuDomainRemoveInactiveJobLocked(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainRemoveInactiveJobLocked(virQEMUDriver *driver,
+ virDomainObj *vm);
int virQEMUFileOpenAs(uid_t fallback_uid,
gid_t fallback_gid,
bool *needUnlink);
int
-qemuDomainOpenFile(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainOpenFile(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
int oflags,
bool *needUnlink);
int
-qemuDomainFileWrapperFDClose(virDomainObjPtr vm,
- virFileWrapperFdPtr fd);
+qemuDomainFileWrapperFDClose(virDomainObj *vm,
+ virFileWrapperFd *fd);
int
-qemuDomainInterfaceSetDefaultQDisc(virQEMUDriverPtr driver,
- virDomainNetDefPtr net);
+qemuDomainInterfaceSetDefaultQDisc(virQEMUDriver *driver,
+ virDomainNetDef *net);
int
-qemuDomainNamePathsCleanup(virQEMUDriverConfigPtr cfg,
+qemuDomainNamePathsCleanup(virQEMUDriverConfig *cfg,
const char *name,
bool bestEffort);
int
qemuDomainGetSCSIControllerModel(const virDomainDef *def,
const virDomainControllerDef *cont,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (cont->model > 0)
return cont->model;
*/
int
qemuDomainSetSCSIControllerModel(const virDomainDef *def,
- virDomainControllerDefPtr cont,
- virQEMUCapsPtr qemuCaps)
+ virDomainControllerDef *cont,
+ virQEMUCaps *qemuCaps)
{
int model = qemuDomainGetSCSIControllerModel(def, cont, qemuCaps);
*/
int
qemuDomainFindSCSIControllerModel(const virDomainDef *def,
- virDomainDeviceInfoPtr info)
+ virDomainDeviceInfo *info)
{
- virDomainControllerDefPtr cont;
+ virDomainControllerDef *cont;
if (!(cont = virDomainDeviceFindSCSIController(def, &info->addr.drive))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static int
-qemuDomainAssignVirtioSerialAddresses(virDomainDefPtr def)
+qemuDomainAssignVirtioSerialAddresses(virDomainDef *def)
{
int ret = -1;
size_t i;
- virDomainVirtioSerialAddrSetPtr addrs = NULL;
+ virDomainVirtioSerialAddrSet *addrs = NULL;
if (!(addrs = virDomainVirtioSerialAddrSetCreateFromDomain(def)))
goto cleanup;
VIR_DEBUG("Finished reserving existing ports");
for (i = 0; i < def->nconsoles; i++) {
- virDomainChrDefPtr chr = def->consoles[i];
+ virDomainChrDef *chr = def->consoles[i];
if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO &&
!virDomainVirtioSerialAddrIsComplete(&chr->info) &&
}
for (i = 0; i < def->nchannels; i++) {
- virDomainChrDefPtr chr = def->channels[i];
+ virDomainChrDef *chr = def->channels[i];
if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO &&
!virDomainVirtioSerialAddrIsComplete(&chr->info) &&
static int
-qemuDomainSpaprVIOFindByReg(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info, void *opaque)
+qemuDomainSpaprVIOFindByReg(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info, void *opaque)
{
- virDomainDeviceInfoPtr target = opaque;
+ virDomainDeviceInfo *target = opaque;
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
return 0;
static int
-qemuDomainAssignSpaprVIOAddress(virDomainDefPtr def,
- virDomainDeviceInfoPtr info,
+qemuDomainAssignSpaprVIOAddress(virDomainDef *def,
+ virDomainDeviceInfo *info,
unsigned long long default_reg)
{
bool user_reg;
static int
-qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def)
+qemuDomainAssignSpaprVIOAddresses(virDomainDef *def)
{
size_t i;
/* Default values match QEMU. See spapr_(llan|vscsi|vty).c */
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (net->model == VIR_DOMAIN_NET_MODEL_SPAPR_VLAN)
net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
}
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI &&
cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
}
for (i = 0; i < def->ntpms; i++) {
- virDomainTPMDefPtr tpm = def->tpms[i];
+ virDomainTPMDef *tpm = def->tpms[i];
if (tpm->model != VIR_DOMAIN_TPM_MODEL_SPAPR_PROXY &&
qemuDomainIsPSeries(def))
static void
-qemuDomainPrimeVfioDeviceAddresses(virDomainDefPtr def,
+qemuDomainPrimeVfioDeviceAddresses(virDomainDef *def,
virDomainDeviceAddressType type)
{
size_t i;
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevSubsysPtr subsys = &def->hostdevs[i]->source.subsys;
+ virDomainHostdevSubsys *subsys = &def->hostdevs[i]->source.subsys;
if (virHostdevIsMdevDevice(def->hostdevs[i]) &&
subsys->u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_CCW &&
static void
-qemuDomainPrimeVirtioDeviceAddresses(virDomainDefPtr def,
+qemuDomainPrimeVirtioDeviceAddresses(virDomainDef *def,
virDomainDeviceAddressType type)
{
/*
}
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (virDomainNetIsVirtioModel(net) &&
net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
}
for (i = 0; i < def->nvideos; i++) {
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
video->type == VIR_DOMAIN_VIDEO_TYPE_VIRTIO)
}
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if ((cont->type == VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL ||
cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) &&
* 3. Assign defaults to the rest
*/
static int
-qemuDomainAssignS390Addresses(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainAssignS390Addresses(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
int ret = -1;
- virDomainCCWAddressSetPtr addrs = NULL;
+ virDomainCCWAddressSet *addrs = NULL;
if (qemuDomainIsS390CCW(def) &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW)) {
static int
-qemuDomainHasVirtioMMIODevicesCallback(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+qemuDomainHasVirtioMMIODevicesCallback(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO) {
* Returns: true if there are any, false otherwise
*/
static bool
-qemuDomainHasVirtioMMIODevices(virDomainDefPtr def)
+qemuDomainHasVirtioMMIODevices(virDomainDef *def)
{
bool result = false;
static void
-qemuDomainAssignVirtioMMIOAddresses(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainAssignVirtioMMIOAddresses(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
if (def->os.arch != VIR_ARCH_ARMV6L &&
def->os.arch != VIR_ARCH_ARMV7L &&
static bool
-qemuDomainDeviceSupportZPCI(virDomainDeviceDefPtr device)
+qemuDomainDeviceSupportZPCI(virDomainDeviceDef *device)
{
switch ((virDomainDeviceType)device->type) {
case VIR_DOMAIN_DEVICE_CHR:
static virPCIDeviceAddressExtensionFlags
-qemuDomainDeviceCalculatePCIAddressExtensionFlags(virQEMUCapsPtr qemuCaps,
- virDomainDeviceDefPtr dev)
+qemuDomainDeviceCalculatePCIAddressExtensionFlags(virQEMUCaps *qemuCaps,
+ virDomainDeviceDef *dev)
{
virPCIDeviceAddressExtensionFlags extFlags = 0;
* is no failure.
*/
static virDomainPCIConnectFlags
-qemuDomainDeviceCalculatePCIConnectFlags(virDomainDeviceDefPtr dev,
+qemuDomainDeviceCalculatePCIConnectFlags(virDomainDeviceDef *dev,
virDomainPCIConnectFlags pcieFlags,
virDomainPCIConnectFlags virtioFlags)
{
switch ((virDomainDeviceType)dev->type) {
case VIR_DOMAIN_DEVICE_CONTROLLER: {
- virDomainControllerDefPtr cont = dev->data.controller;
+ virDomainControllerDef *cont = dev->data.controller;
switch ((virDomainControllerType)cont->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_PCI:
return 0;
case VIR_DOMAIN_DEVICE_NET: {
- virDomainNetDefPtr net = dev->data.net;
+ virDomainNetDef *net = dev->data.net;
/* NB: a type='hostdev' will use PCI, but its
* address is assigned when we're assigning the
break;
case VIR_DOMAIN_DEVICE_HOSTDEV: {
- virDomainHostdevDefPtr hostdev = dev->data.hostdev;
+ virDomainHostdevDef *hostdev = dev->data.hostdev;
g_autoptr(virPCIDevice) pciDev = NULL;
- virPCIDeviceAddressPtr hostAddr = &hostdev->source.subsys.u.pci.addr;
+ virPCIDeviceAddress *hostAddr = &hostdev->source.subsys.u.pci.addr;
if (!virHostdevIsMdevDevice(hostdev) &&
(hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
typedef struct {
virDomainPCIConnectFlags virtioFlags;
virDomainPCIConnectFlags pcieFlags;
- virQEMUDriverPtr driver;
+ virQEMUDriver *driver;
} qemuDomainFillDevicePCIConnectFlagsIterData;
* qemuDomainCalculateDevicePCIConnectFlags().
*/
static void
-qemuDomainFillDevicePCIConnectFlagsIterInit(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver,
+qemuDomainFillDevicePCIConnectFlagsIterInit(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver,
qemuDomainFillDevicePCIConnectFlagsIterData *data)
{
data->driver = driver;
* Always returns 0 - there is no failure.
*/
static int
-qemuDomainFillDevicePCIConnectFlagsIter(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
+qemuDomainFillDevicePCIConnectFlagsIter(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
void *opaque)
{
qemuDomainFillDevicePCIConnectFlagsIterData *data = opaque;
* virDomainDeviceInfoIterate())
*/
static int
-qemuDomainFillAllPCIConnectFlags(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver)
+qemuDomainFillAllPCIConnectFlags(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver)
{
qemuDomainFillDevicePCIConnectFlagsIterData data;
* Always returns 0 - there is no failure.
*/
static int
-qemuDomainFillDevicePCIExtensionFlagsIter(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
+qemuDomainFillDevicePCIExtensionFlagsIter(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virQEMUCapsPtr qemuCaps = opaque;
+ virQEMUCaps *qemuCaps = opaque;
info->pciAddrExtFlags =
qemuDomainDeviceCalculatePCIAddressExtensionFlags(qemuCaps, dev);
* virDomainDeviceInfoIterate())
*/
static int
-qemuDomainFillAllPCIExtensionFlags(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainFillAllPCIExtensionFlags(virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
return virDomainDeviceInfoIterate(def,
qemuDomainFillDevicePCIExtensionFlagsIter,
* Return: 0 if the isolation group is not used by the device, <1 otherwise.
*/
static int
-qemuDomainFindUnusedIsolationGroupIter(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+qemuDomainFindUnusedIsolationGroupIter(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
unsigned int *isolationGroup = opaque;
* Return: unused isolation group
*/
static unsigned int
-qemuDomainFindUnusedIsolationGroup(virDomainDefPtr def)
+qemuDomainFindUnusedIsolationGroup(virDomainDef *def)
{
unsigned int isolationGroup = UINT_MAX;
* Fill isolation group information for a single device.
*/
void
-qemuDomainFillDeviceIsolationGroup(virDomainDefPtr def,
- virDomainDeviceDefPtr dev)
+qemuDomainFillDeviceIsolationGroup(virDomainDef *def,
+ virDomainDeviceDef *dev)
{
/* Only host devices need their isolation group to be different from
* the default. Interfaces of type hostdev are just host devices in
* each such interface a corresponding hostdev is also added to the
* guest configuration */
if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
- virDomainHostdevDefPtr hostdev = dev->data.hostdev;
- virDomainDeviceInfoPtr info = hostdev->info;
- virPCIDeviceAddressPtr hostAddr;
+ virDomainHostdevDef *hostdev = dev->data.hostdev;
+ virDomainDeviceInfo *info = hostdev->info;
+ virPCIDeviceAddress *hostAddr;
int tmp;
/* Only PCI host devices are subject to isolation */
info->isolationGroup);
} else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
- virDomainNetDefPtr iface = dev->data.net;
- virDomainDeviceInfoPtr info = &iface->info;
+ virDomainNetDef *iface = dev->data.net;
+ virDomainDeviceInfo *info = &iface->info;
unsigned int tmp;
/* Network interfaces can ultimately result in the guest being
* Return: 0 on success, <0 on failure
*/
static int
-qemuDomainFillDeviceIsolationGroupIter(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info G_GNUC_UNUSED,
+qemuDomainFillDeviceIsolationGroupIter(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
qemuDomainFillDeviceIsolationGroup(def, dev);
* Return: 0 on success, <0 on failure
*/
static int
-qemuDomainSetupIsolationGroups(virDomainDefPtr def)
+qemuDomainSetupIsolationGroups(virDomainDef *def)
{
int idx;
* No return value.
*/
static void
-qemuDomainFillDevicePCIConnectFlags(virDomainDefPtr def,
- virDomainDeviceDefPtr dev,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver)
+qemuDomainFillDevicePCIConnectFlags(virDomainDef *def,
+ virDomainDeviceDef *dev,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver)
{
- virDomainDeviceInfoPtr info = virDomainDeviceGetInfo(dev);
+ virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
if (info) {
/* qemuDomainDeviceCalculatePCIConnectFlags() is called with
* No return value.
*/
static void
-qemuDomainFillDevicePCIExtensionFlags(virDomainDeviceDefPtr dev,
- virDomainDeviceInfoPtr info,
- virQEMUCapsPtr qemuCaps)
+qemuDomainFillDevicePCIExtensionFlags(virDomainDeviceDef *dev,
+ virDomainDeviceInfo *info,
+ virQEMUCaps *qemuCaps)
{
info->pciAddrExtFlags =
qemuDomainDeviceCalculatePCIAddressExtensionFlags(qemuCaps, dev);
static int
-qemuDomainPCIAddressReserveNextAddr(virDomainPCIAddressSetPtr addrs,
- virDomainDeviceInfoPtr dev)
+qemuDomainPCIAddressReserveNextAddr(virDomainPCIAddressSet *addrs,
+ virDomainDeviceInfo *dev)
{
return virDomainPCIAddressReserveNextAddr(addrs, dev,
dev->pciConnectFlags, -1);
static int
-qemuDomainAssignPCIAddressExtension(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+qemuDomainAssignPCIAddressExtension(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virDomainPCIAddressSetPtr addrs = opaque;
- virPCIDeviceAddressPtr addr = &info->addr.pci;
+ virDomainPCIAddressSet *addrs = opaque;
+ virPCIDeviceAddress *addr = &info->addr.pci;
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
addr->extFlags = info->pciAddrExtFlags;
}
static int
-qemuDomainCollectPCIAddress(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device,
- virDomainDeviceInfoPtr info,
+qemuDomainCollectPCIAddress(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virDomainPCIAddressSetPtr addrs = opaque;
- virPCIDeviceAddressPtr addr = &info->addr.pci;
+ virDomainPCIAddressSet *addrs = opaque;
+ virPCIDeviceAddress *addr = &info->addr.pci;
if (!virDeviceInfoPCIAddressIsPresent(info) ||
((device->type == VIR_DOMAIN_DEVICE_HOSTDEV) &&
*/
if (device->type == VIR_DOMAIN_DEVICE_CONTROLLER && addr->domain == 0 &&
addr->bus == 0 && addr->slot == 1) {
- virDomainControllerDefPtr cont = device->data.controller;
+ virDomainControllerDef *cont = device->data.controller;
if ((cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE && cont->idx == 0 &&
addr->function == 1) ||
}
static int
-qemuDomainCollectPCIAddressExtension(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device,
- virDomainDeviceInfoPtr info,
+qemuDomainCollectPCIAddressExtension(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virDomainPCIAddressSetPtr addrs = opaque;
- virPCIDeviceAddressPtr addr = &info->addr.pci;
+ virDomainPCIAddressSet *addrs = opaque;
+ virPCIDeviceAddress *addr = &info->addr.pci;
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
addr->extFlags = info->pciAddrExtFlags;
return virDomainPCIAddressExtensionReserveAddr(addrs, addr);
}
-static virDomainPCIAddressSetPtr
-qemuDomainPCIAddressSetCreate(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
+static virDomainPCIAddressSet *
+qemuDomainPCIAddressSetCreate(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
unsigned int nbuses,
bool dryRun)
{
- virDomainPCIAddressSetPtr addrs;
+ virDomainPCIAddressSet *addrs;
size_t i;
bool hasPCIeRoot = false;
virDomainControllerModelPCI defaultModel;
addrs->isPCIeToPCIBridgeSupported = true;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
size_t idx = cont->idx;
bool allowHotplug = false;
static int
-qemuDomainValidateDevicePCISlotsPIIX3(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virDomainPCIAddressSetPtr addrs)
+qemuDomainValidateDevicePCISlotsPIIX3(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virDomainPCIAddressSet *addrs)
{
size_t i;
virPCIDeviceAddress tmp_addr;
/* Verify that first IDE and USB controllers (if any) is on the PIIX3, fn 1 */
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
virPCIDeviceAddress primaryIDEAddr = {.domain = 0, .bus = 0,
.slot = 1, .function = 1};
virPCIDeviceAddress piix3USBAddr = {.domain = 0, .bus = 0,
* device added after integrated devices), it *always* ends up
* at slot 2.
*/
- virDomainVideoDefPtr primaryVideo = def->videos[0];
+ virDomainVideoDef *primaryVideo = def->videos[0];
virPCIDeviceAddress primaryCardAddr = {.domain = 0, .bus = 0,
.slot = 2, .function = 0};
static int
-qemuDomainValidateDevicePCISlotsQ35(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virDomainPCIAddressSetPtr addrs)
+qemuDomainValidateDevicePCISlotsQ35(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virDomainPCIAddressSet *addrs)
{
size_t i;
virPCIDeviceAddress tmp_addr;
virDomainPCIConnectFlags flags = VIR_PCI_CONNECT_TYPE_PCIE_DEVICE;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
virPCIDeviceAddress primarySATAAddr = {.domain = 0, .bus = 0,
.slot = 0x1F, .function = 2};
* slot 1 (which was used up by the integrated PIIX3 devices
* on pc machinetypes).
*/
- virDomainVideoDefPtr primaryVideo = def->videos[0];
+ virDomainVideoDef *primaryVideo = def->videos[0];
if (virDeviceInfoPCIAddressIsWanted(&primaryVideo->info)) {
memset(&tmp_addr, 0, sizeof(tmp_addr));
tmp_addr.slot = 1;
* normal device addressing assign something later.
*/
for (i = 0; i < def->nsounds; i++) {
- virDomainSoundDefPtr sound = def->sounds[i];
+ virDomainSoundDef *sound = def->sounds[i];
if (sound->model != VIR_DOMAIN_SOUND_MODEL_ICH9 ||
!virDeviceInfoPCIAddressIsWanted(&sound->info)) {
static int
-qemuDomainValidateDevicePCISlotsChipsets(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virDomainPCIAddressSetPtr addrs)
+qemuDomainValidateDevicePCISlotsChipsets(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virDomainPCIAddressSet *addrs)
{
if (qemuDomainIsI440FX(def) &&
qemuDomainValidateDevicePCISlotsPIIX3(def, qemuCaps, addrs) < 0) {
* skip over info.type == PCI
*/
static int
-qemuDomainAssignDevicePCISlots(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virDomainPCIAddressSetPtr addrs)
+qemuDomainAssignDevicePCISlots(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virDomainPCIAddressSet *addrs)
{
size_t i, j;
/* PCI controllers */
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
virDomainControllerModelPCI model = cont->model;
/* Network interfaces */
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
/* type='hostdev' network devices might be USB, and are also
* in hostdevs list anyway, so handle them with other hostdevs
/* Sound cards */
for (i = 0; i < def->nsounds; i++) {
- virDomainSoundDefPtr sound = def->sounds[i];
+ virDomainSoundDef *sound = def->sounds[i];
if (!virDeviceInfoPCIAddressIsWanted(&sound->info))
continue;
/* Device controllers (SCSI, USB, but not IDE, FDC or CCID) */
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
/* PCI controllers have been dealt with earlier */
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI)
/* Host PCI devices */
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevSubsysPtr subsys = &def->hostdevs[i]->source.subsys;
+ virDomainHostdevSubsys *subsys = &def->hostdevs[i]->source.subsys;
if (!virDeviceInfoPCIAddressIsWanted(def->hostdevs[i]->info))
continue;
if (def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
/* Nada - none are PCI based (yet) */
}
for (i = 0; i < def->nserials; i++) {
- virDomainChrDefPtr chr = def->serials[i];
+ virDomainChrDef *chr = def->serials[i];
if (chr->targetType != VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_PCI ||
!virDeviceInfoPCIAddressIsWanted(&chr->info))
}
for (i = 0; i < def->nmems; i++) {
- virDomainMemoryDefPtr mem = def->mems[i];
+ virDomainMemoryDef *mem = def->mems[i];
if (mem->model != VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM ||
!virDeviceInfoPCIAddressIsWanted(&mem->info))
static void
-qemuDomainPCIControllerSetDefaultModelName(virDomainControllerDefPtr cont,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps)
+qemuDomainPCIControllerSetDefaultModelName(virDomainControllerDef *cont,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps)
{
int *modelName = &cont->opts.pciopts.modelName;
* indexes are already taken.
*/
static int
-qemuDomainAddressFindNewTargetIndex(virDomainDefPtr def)
+qemuDomainAddressFindNewTargetIndex(virDomainDef *def)
{
int targetIndex;
int ret = -1;
size_t i;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
/* Skip everything but PHBs */
if (!virDomainControllerIsPSeriesPHB(cont))
static int
-qemuDomainAddressFindNewBusNr(virDomainDefPtr def)
+qemuDomainAddressFindNewBusNr(virDomainDef *def)
{
/* Try to find a nice default for busNr for a new pci-expander-bus.
* This is a bit tricky, since you need to satisfy the following:
int lowestBusNr = 256;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
int thisBusNr = cont->opts.pciopts.busNr;
static int
-qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+qemuDomainAssignPCIAddresses(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver,
+ virDomainObj *obj)
{
int ret = -1;
- virDomainPCIAddressSetPtr addrs = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ virDomainPCIAddressSet *addrs = NULL;
+ qemuDomainObjPrivate *priv = NULL;
int max_idx = -1;
int nbuses = 0;
size_t i;
int rv;
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
if ((int)cont->idx > max_idx)
for (i = 1; i < addrs->nbuses; i++) {
virDomainDeviceDef dev;
int contIndex;
- virDomainPCIAddressBusPtr bus = &addrs->buses[i];
+ virDomainPCIAddressBus *bus = &addrs->buses[i];
if ((rv = virDomainDefMaybeAddController(
def, VIR_DOMAIN_CONTROLLER_TYPE_PCI,
virDomainPCIAddressSetAllMulti(def);
for (i = 0; i < def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = def->controllers[i];
+ virDomainControllerDef *cont = def->controllers[i];
int idx = cont->idx;
- virPCIDeviceAddressPtr addr;
- virDomainPCIControllerOptsPtr options;
+ virPCIDeviceAddress *addr;
+ virDomainPCIControllerOpts *options;
if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_PCI)
continue;
struct qemuAssignUSBIteratorInfo {
- virDomainUSBAddressSetPtr addrs;
+ virDomainUSBAddressSet *addrs;
size_t count;
};
static int
-qemuDomainAssignUSBPortsIterator(virDomainDeviceInfoPtr info,
+qemuDomainAssignUSBPortsIterator(virDomainDeviceInfo *info,
void *opaque)
{
struct qemuAssignUSBIteratorInfo *data = opaque;
static int
-qemuDomainAssignUSBHubs(virDomainUSBAddressSetPtr addrs,
- virDomainDefPtr def)
+qemuDomainAssignUSBHubs(virDomainUSBAddressSet *addrs,
+ virDomainDef *def)
{
size_t i;
for (i = 0; i < def->nhubs; i++) {
- virDomainHubDefPtr hub = def->hubs[i];
+ virDomainHubDef *hub = def->hubs[i];
if (hub->type != VIR_DOMAIN_HUB_TYPE_USB)
continue;
static int
-qemuDomainAssignUSBPorts(virDomainUSBAddressSetPtr addrs,
- virDomainDefPtr def)
+qemuDomainAssignUSBPorts(virDomainUSBAddressSet *addrs,
+ virDomainDef *def)
{
struct qemuAssignUSBIteratorInfo data = { .addrs = addrs };
static int
-qemuDomainAssignUSBPortsCounter(virDomainDeviceInfoPtr info G_GNUC_UNUSED,
+qemuDomainAssignUSBPortsCounter(virDomainDeviceInfo *info G_GNUC_UNUSED,
void *opaque)
{
struct qemuAssignUSBIteratorInfo *data = opaque;
static int
-qemuDomainUSBAddressAddHubs(virDomainDefPtr def)
+qemuDomainUSBAddressAddHubs(virDomainDef *def)
{
struct qemuAssignUSBIteratorInfo data = { .count = 0 };
- virDomainHubDefPtr hub = NULL;
+ virDomainHubDef *hub = NULL;
size_t available_ports;
size_t hubs_needed = 0;
int ret = -1;
}
-static virBitmapPtr
+static virBitmap *
qemuDomainGetMemorySlotMap(const virDomainDef *def)
{
- virBitmapPtr ret = virBitmapNew(def->mem.memory_slots);
- virDomainMemoryDefPtr mem;
+ virBitmap *ret = virBitmapNew(def->mem.memory_slots);
+ virDomainMemoryDef *mem;
size_t i;
for (i = 0; i < def->nmems; i++) {
static int
-qemuAssignMemoryDeviceSlot(virDomainMemoryDefPtr mem,
- virBitmapPtr slotmap)
+qemuAssignMemoryDeviceSlot(virDomainMemoryDef *mem,
+ virBitmap *slotmap)
{
ssize_t nextslot = -1;
int
-qemuDomainAssignMemoryDeviceSlot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainAssignMemoryDeviceSlot(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
g_autoptr(virBitmap) slotmap = NULL;
virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_MEMORY, .data.memory = mem};
void
-qemuDomainReleaseMemoryDeviceSlot(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainReleaseMemoryDeviceSlot(virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
static int
-qemuDomainAssignMemorySlots(virDomainDefPtr def)
+qemuDomainAssignMemorySlots(virDomainDef *def)
{
- virBitmapPtr slotmap = NULL;
+ virBitmap *slotmap = NULL;
int ret = -1;
size_t i;
return -1;
for (i = 0; i < def->nmems; i++) {
- virDomainMemoryDefPtr mem = def->mems[i];
+ virDomainMemoryDef *mem = def->mems[i];
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
static int
-qemuDomainAssignUSBAddresses(virDomainDefPtr def,
- virDomainObjPtr obj,
+qemuDomainAssignUSBAddresses(virDomainDef *def,
+ virDomainObj *obj,
bool newDomain)
{
int ret = -1;
- virDomainUSBAddressSetPtr addrs = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ virDomainUSBAddressSet *addrs = NULL;
+ qemuDomainObjPrivate *priv = NULL;
if (!newDomain) {
/* only create the address cache for:
int
-qemuDomainAssignAddresses(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainAssignAddresses(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver,
+ virDomainObj *obj,
bool newDomain)
{
if (qemuDomainAssignVirtioSerialAddresses(def) < 0)
/**
* qemuDomainEnsurePCIAddress:
*
- * @obj: the virDomainObjPtr for the domain. This will include
+ * @obj: the virDomainObj *f or the domain. This will include
* qemuCaps and address cache (if there is one)
*
* @dev: the device that we need to ensure has a PCI address
* returns 0 on success -1 on failure.
*/
int
-qemuDomainEnsurePCIAddress(virDomainObjPtr obj,
- virDomainDeviceDefPtr dev,
- virQEMUDriverPtr driver)
+qemuDomainEnsurePCIAddress(virDomainObj *obj,
+ virDomainDeviceDef *dev,
+ virQEMUDriver *driver)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
- virDomainDeviceInfoPtr info = virDomainDeviceGetInfo(dev);
+ qemuDomainObjPrivate *priv = obj->privateData;
+ virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
if (!info)
return 0;
}
void
-qemuDomainReleaseDeviceAddress(virDomainObjPtr vm,
- virDomainDeviceInfoPtr info)
+qemuDomainReleaseDeviceAddress(virDomainObj *vm,
+ virDomainDeviceInfo *info)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virDeviceInfoPCIAddressIsPresent(info)) {
virDomainPCIAddressReleaseAddr(priv->pciaddrs, &info->addr.pci);
int
qemuDomainEnsureVirtioAddress(bool *releaseAddr,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev,
const char *devicename)
{
- virDomainDeviceInfoPtr info = virDomainDeviceGetInfo(dev);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainCCWAddressSetPtr ccwaddrs = NULL;
- virQEMUDriverPtr driver = priv->driver;
+ virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainCCWAddressSet *ccwaddrs = NULL;
+ virQEMUDriver *driver = priv->driver;
int ret = -1;
if (!info->type) {
int qemuDomainGetSCSIControllerModel(const virDomainDef *def,
const virDomainControllerDef *cont,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
int qemuDomainSetSCSIControllerModel(const virDomainDef *def,
- virDomainControllerDefPtr cont,
- virQEMUCapsPtr qemuCaps);
+ virDomainControllerDef *cont,
+ virQEMUCaps *qemuCaps);
int qemuDomainFindSCSIControllerModel(const virDomainDef *def,
- virDomainDeviceInfoPtr info);
+ virDomainDeviceInfo *info);
-int qemuDomainAssignAddresses(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
- virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainAssignAddresses(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
+ virQEMUDriver *driver,
+ virDomainObj *obj,
bool newDomain)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuDomainEnsurePCIAddress(virDomainObjPtr obj,
- virDomainDeviceDefPtr dev,
- virQEMUDriverPtr driver)
+int qemuDomainEnsurePCIAddress(virDomainObj *obj,
+ virDomainDeviceDef *dev,
+ virQEMUDriver *driver)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void qemuDomainFillDeviceIsolationGroup(virDomainDefPtr def,
- virDomainDeviceDefPtr dev)
+void qemuDomainFillDeviceIsolationGroup(virDomainDef *def,
+ virDomainDeviceDef *dev)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainReleaseDeviceAddress(virDomainObjPtr vm,
- virDomainDeviceInfoPtr info);
+void qemuDomainReleaseDeviceAddress(virDomainObj *vm,
+ virDomainDeviceInfo *info);
-int qemuDomainAssignMemoryDeviceSlot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
+int qemuDomainAssignMemoryDeviceSlot(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem);
-void qemuDomainReleaseMemoryDeviceSlot(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
+void qemuDomainReleaseMemoryDeviceSlot(virDomainObj *vm,
+ virDomainMemoryDef *mem);
int qemuDomainEnsureVirtioAddress(bool *releaseAddr,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev,
const char *devicename);
void
-qemuDomainJobInfoFree(qemuDomainJobInfoPtr info)
+qemuDomainJobInfoFree(qemuDomainJobInfo *info)
{
g_free(info->errmsg);
g_free(info);
}
-qemuDomainJobInfoPtr
-qemuDomainJobInfoCopy(qemuDomainJobInfoPtr info)
+qemuDomainJobInfo *
+qemuDomainJobInfoCopy(qemuDomainJobInfo *info)
{
- qemuDomainJobInfoPtr ret = g_new0(qemuDomainJobInfo, 1);
+ qemuDomainJobInfo *ret = g_new0(qemuDomainJobInfo, 1);
memcpy(ret, info, sizeof(*info));
}
void
-qemuDomainEventEmitJobCompleted(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuDomainEventEmitJobCompleted(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virObjectEvent *event;
virTypedParameterPtr params = NULL;
int nparams = 0;
int type;
int
-qemuDomainObjInitJob(qemuDomainJobObjPtr job,
- qemuDomainObjPrivateJobCallbacksPtr cb)
+qemuDomainObjInitJob(qemuDomainJobObj *job,
+ qemuDomainObjPrivateJobCallbacks *cb)
{
memset(job, 0, sizeof(*job));
job->cb = cb;
static void
-qemuDomainObjResetJob(qemuDomainJobObjPtr job)
+qemuDomainObjResetJob(qemuDomainJobObj *job)
{
job->active = QEMU_JOB_NONE;
job->owner = 0;
static void
-qemuDomainObjResetAgentJob(qemuDomainJobObjPtr job)
+qemuDomainObjResetAgentJob(qemuDomainJobObj *job)
{
job->agentActive = QEMU_AGENT_JOB_NONE;
job->agentOwner = 0;
static void
-qemuDomainObjResetAsyncJob(qemuDomainJobObjPtr job)
+qemuDomainObjResetAsyncJob(qemuDomainJobObj *job)
{
job->asyncJob = QEMU_ASYNC_JOB_NONE;
job->asyncOwner = 0;
}
int
-qemuDomainObjRestoreJob(virDomainObjPtr obj,
- qemuDomainJobObjPtr job)
+qemuDomainObjRestoreJob(virDomainObj *obj,
+ qemuDomainJobObj *job)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
memset(job, 0, sizeof(*job));
job->active = priv->job.active;
}
void
-qemuDomainObjClearJob(qemuDomainJobObjPtr job)
+qemuDomainObjClearJob(qemuDomainJobObj *job)
{
if (!job->cb)
return;
int
-qemuDomainJobInfoUpdateTime(qemuDomainJobInfoPtr jobInfo)
+qemuDomainJobInfoUpdateTime(qemuDomainJobInfo *jobInfo)
{
unsigned long long now;
}
int
-qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfoPtr jobInfo)
+qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfo *jobInfo)
{
unsigned long long now;
}
int
-qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
+qemuDomainJobInfoToInfo(qemuDomainJobInfo *jobInfo,
virDomainJobInfoPtr info)
{
info->type = qemuDomainJobStatusToType(jobInfo->status);
static int
-qemuDomainMigrationJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
+qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
int *type,
virTypedParameterPtr *params,
int *nparams)
{
qemuMonitorMigrationStats *stats = &jobInfo->stats.mig;
- qemuDomainMirrorStatsPtr mirrorStats = &jobInfo->mirrorStats;
+ qemuDomainMirrorStats *mirrorStats = &jobInfo->mirrorStats;
virTypedParameterPtr par = NULL;
int maxpar = 0;
int npar = 0;
static int
-qemuDomainDumpJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
+qemuDomainDumpJobInfoToParams(qemuDomainJobInfo *jobInfo,
int *type,
virTypedParameterPtr *params,
int *nparams)
static int
-qemuDomainBackupJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
+qemuDomainBackupJobInfoToParams(qemuDomainJobInfo *jobInfo,
int *type,
virTypedParameterPtr *params,
int *nparams)
int
-qemuDomainJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
+qemuDomainJobInfoToParams(qemuDomainJobInfo *jobInfo,
int *type,
virTypedParameterPtr *params,
int *nparams)
void
-qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjSetJobPhase(virQEMUDriver *driver,
+ virDomainObj *obj,
int phase)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
unsigned long long me = virThreadSelfID();
if (!priv->job.asyncJob)
}
void
-qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
+qemuDomainObjSetAsyncJobMask(virDomainObj *obj,
unsigned long long allowedJobs)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
if (!priv->job.asyncJob)
return;
}
void
-qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
+qemuDomainObjDiscardAsyncJob(virQEMUDriver *driver, virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
qemuDomainObjResetJob(&priv->job);
}
void
-qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj)
+qemuDomainObjReleaseAsyncJob(virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
VIR_DEBUG("Releasing ownership of '%s' async job",
qemuDomainAsyncJobTypeToString(priv->job.asyncJob));
}
static bool
-qemuDomainNestedJobAllowed(qemuDomainJobObjPtr jobs, qemuDomainJob newJob)
+qemuDomainNestedJobAllowed(qemuDomainJobObj *jobs, qemuDomainJob newJob)
{
return !jobs->asyncJob ||
newJob == QEMU_JOB_NONE ||
}
bool
-qemuDomainJobAllowed(qemuDomainJobObjPtr jobs, qemuDomainJob newJob)
+qemuDomainJobAllowed(qemuDomainJobObj *jobs, qemuDomainJob newJob)
{
return !jobs->active && qemuDomainNestedJobAllowed(jobs, newJob);
}
static bool
-qemuDomainObjCanSetJob(qemuDomainJobObjPtr job,
+qemuDomainObjCanSetJob(qemuDomainJobObj *job,
qemuDomainJob newJob,
qemuDomainAgentJob newAgentJob)
{
* -1 otherwise.
*/
static int ATTRIBUTE_NONNULL(1)
-qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjBeginJobInternal(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainJob job,
qemuDomainAgentJob agentJob,
qemuDomainAsyncJob asyncJob,
bool nowait)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
unsigned long long now;
unsigned long long then;
bool nested = job == QEMU_JOB_ASYNC_NESTED;
*
* Successful calls must be followed by EndJob eventually
*/
-int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainJob job)
{
if (qemuDomainObjBeginJobInternal(driver, obj, job,
* To end job call qemuDomainObjEndAgentJob.
*/
int
-qemuDomainObjBeginAgentJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjBeginAgentJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAgentJob agentJob)
{
return qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_NONE,
QEMU_ASYNC_JOB_NONE, false);
}
-int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginAsyncJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob,
virDomainJobOperation operation,
unsigned long apiFlags)
{
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
if (qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
QEMU_AGENT_JOB_NONE,
}
int
-qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjBeginNestedJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
if (asyncJob != priv->job.asyncJob) {
virReportError(VIR_ERR_INTERNAL_ERROR,
* Returns: see qemuDomainObjBeginJobInternal
*/
int
-qemuDomainObjBeginJobNowait(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+qemuDomainObjBeginJobNowait(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainJob job)
{
return qemuDomainObjBeginJobInternal(driver, obj, job,
* earlier qemuDomainBeginJob() call
*/
void
-qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
+qemuDomainObjEndJob(virQEMUDriver *driver, virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
qemuDomainJob job = priv->job.active;
priv->jobs_queued--;
}
void
-qemuDomainObjEndAgentJob(virDomainObjPtr obj)
+qemuDomainObjEndAgentJob(virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
qemuDomainAgentJob agentJob = priv->job.agentActive;
priv->jobs_queued--;
}
void
-qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
+qemuDomainObjEndAsyncJob(virQEMUDriver *driver, virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
priv->jobs_queued--;
}
void
-qemuDomainObjAbortAsyncJob(virDomainObjPtr obj)
+qemuDomainObjAbortAsyncJob(virDomainObj *obj)
{
- qemuDomainObjPrivatePtr priv = obj->privateData;
+ qemuDomainObjPrivate *priv = obj->privateData;
VIR_DEBUG("Requesting abort of async job: %s (vm=%p name=%s)",
qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
}
int
-qemuDomainObjPrivateXMLFormatJob(virBufferPtr buf,
- virDomainObjPtr vm)
+qemuDomainObjPrivateXMLFormatJob(virBuffer *buf,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
qemuDomainJob job = priv->job.active;
int
-qemuDomainObjPrivateXMLParseJob(virDomainObjPtr vm,
+qemuDomainObjPrivateXMLParseJob(virDomainObj *vm,
xmlXPathContextPtr ctxt)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobObjPtr job = &priv->job;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobObj *job = &priv->job;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *tmp = NULL;
typedef struct _qemuDomainMirrorStats qemuDomainMirrorStats;
-typedef qemuDomainMirrorStats *qemuDomainMirrorStatsPtr;
struct _qemuDomainMirrorStats {
unsigned long long transferred;
unsigned long long total;
};
typedef struct _qemuDomainJobInfo qemuDomainJobInfo;
-typedef qemuDomainJobInfo *qemuDomainJobInfoPtr;
struct _qemuDomainJobInfo {
qemuDomainJobStatus status;
virDomainJobOperation operation;
};
void
-qemuDomainJobInfoFree(qemuDomainJobInfoPtr info);
+qemuDomainJobInfoFree(qemuDomainJobInfo *info);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainJobInfo, qemuDomainJobInfoFree);
-qemuDomainJobInfoPtr
-qemuDomainJobInfoCopy(qemuDomainJobInfoPtr info);
+qemuDomainJobInfo *
+qemuDomainJobInfoCopy(qemuDomainJobInfo *info);
typedef struct _qemuDomainJobObj qemuDomainJobObj;
-typedef qemuDomainJobObj *qemuDomainJobObjPtr;
typedef void *(*qemuDomainObjPrivateJobAlloc)(void);
typedef void (*qemuDomainObjPrivateJobFree)(void *);
typedef void (*qemuDomainObjPrivateJobReset)(void *);
-typedef int (*qemuDomainObjPrivateJobFormat)(virBufferPtr,
- qemuDomainJobObjPtr,
- virDomainObjPtr);
+typedef int (*qemuDomainObjPrivateJobFormat)(virBuffer *,
+ qemuDomainJobObj *,
+ virDomainObj *);
typedef int (*qemuDomainObjPrivateJobParse)(xmlXPathContextPtr,
- qemuDomainJobObjPtr,
- virDomainObjPtr);
+ qemuDomainJobObj *,
+ virDomainObj *);
typedef struct _qemuDomainObjPrivateJobCallbacks qemuDomainObjPrivateJobCallbacks;
-typedef qemuDomainObjPrivateJobCallbacks *qemuDomainObjPrivateJobCallbacksPtr;
struct _qemuDomainObjPrivateJobCallbacks {
qemuDomainObjPrivateJobAlloc allocJobPrivate;
qemuDomainObjPrivateJobFree freeJobPrivate;
unsigned long long asyncStarted; /* When the current async job started */
int phase; /* Job phase (mainly for migrations) */
unsigned long long mask; /* Jobs allowed during async job */
- qemuDomainJobInfoPtr current; /* async job progress data */
- qemuDomainJobInfoPtr completed; /* statistics data of a recently completed job */
+ qemuDomainJobInfo *current; /* async job progress data */
+ qemuDomainJobInfo *completed; /* statistics data of a recently completed job */
bool abortJob; /* abort of the job requested */
char *error; /* job event completion error */
unsigned long apiFlags; /* flags passed to the API which started the async job */
void *privateData; /* job specific collection of data */
- qemuDomainObjPrivateJobCallbacksPtr cb;
+ qemuDomainObjPrivateJobCallbacks *cb;
};
const char *qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
int qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
const char *phase);
-void qemuDomainEventEmitJobCompleted(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainEventEmitJobCompleted(virQEMUDriver *driver,
+ virDomainObj *vm);
-int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginAgentJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginAgentJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAgentJob agentJob)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginAsyncJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob,
virDomainJobOperation operation,
unsigned long apiFlags)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginNestedJob(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainAsyncJob asyncJob)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginJobNowait(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+int qemuDomainObjBeginJobNowait(virQEMUDriver *driver,
+ virDomainObj *obj,
qemuDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuDomainObjEndJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj);
-void qemuDomainObjEndAgentJob(virDomainObjPtr obj);
-void qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj);
-void qemuDomainObjAbortAsyncJob(virDomainObjPtr obj);
-void qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
+void qemuDomainObjEndJob(virQEMUDriver *driver,
+ virDomainObj *obj);
+void qemuDomainObjEndAgentJob(virDomainObj *obj);
+void qemuDomainObjEndAsyncJob(virQEMUDriver *driver,
+ virDomainObj *obj);
+void qemuDomainObjAbortAsyncJob(virDomainObj *obj);
+void qemuDomainObjSetJobPhase(virQEMUDriver *driver,
+ virDomainObj *obj,
int phase);
-void qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
+void qemuDomainObjSetAsyncJobMask(virDomainObj *obj,
unsigned long long allowedJobs);
-int qemuDomainObjRestoreJob(virDomainObjPtr obj,
- qemuDomainJobObjPtr job);
-void qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver,
- virDomainObjPtr obj);
-void qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj);
+int qemuDomainObjRestoreJob(virDomainObj *obj,
+ qemuDomainJobObj *job);
+void qemuDomainObjDiscardAsyncJob(virQEMUDriver *driver,
+ virDomainObj *obj);
+void qemuDomainObjReleaseAsyncJob(virDomainObj *obj);
-int qemuDomainJobInfoUpdateTime(qemuDomainJobInfoPtr jobInfo)
+int qemuDomainJobInfoUpdateTime(qemuDomainJobInfo *jobInfo)
ATTRIBUTE_NONNULL(1);
-int qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfoPtr jobInfo)
+int qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfo *jobInfo)
ATTRIBUTE_NONNULL(1);
-int qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
+int qemuDomainJobInfoToInfo(qemuDomainJobInfo *jobInfo,
virDomainJobInfoPtr info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
+int qemuDomainJobInfoToParams(qemuDomainJobInfo *jobInfo,
int *type,
virTypedParameterPtr *params,
int *nparams)
bool qemuDomainTrackJob(qemuDomainJob job);
-void qemuDomainObjClearJob(qemuDomainJobObjPtr job);
+void qemuDomainObjClearJob(qemuDomainJobObj *job);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(qemuDomainJobObj, qemuDomainObjClearJob);
int
-qemuDomainObjInitJob(qemuDomainJobObjPtr job,
- qemuDomainObjPrivateJobCallbacksPtr cb);
+qemuDomainObjInitJob(qemuDomainJobObj *job,
+ qemuDomainObjPrivateJobCallbacks *cb);
-bool qemuDomainJobAllowed(qemuDomainJobObjPtr jobs, qemuDomainJob newJob);
+bool qemuDomainJobAllowed(qemuDomainJobObj *jobs, qemuDomainJob newJob);
int
-qemuDomainObjPrivateXMLFormatJob(virBufferPtr buf,
- virDomainObjPtr vm);
+qemuDomainObjPrivateXMLFormatJob(virBuffer *buf,
+ virDomainObj *vm);
int
-qemuDomainObjPrivateXMLParseJob(virDomainObjPtr vm,
+qemuDomainObjPrivateXMLParseJob(virDomainObj *vm,
xmlXPathContextPtr ctxt);
static int qemuStateCleanup(void);
static int qemuDomainObjStart(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags,
qemuDomainAsyncJob asyncJob);
-static int qemuDomainManagedSaveLoad(virDomainObjPtr vm,
+static int qemuDomainManagedSaveLoad(virDomainObj *vm,
void *opaque);
-static virQEMUDriverPtr qemu_driver;
+static virQEMUDriver *qemu_driver;
/* Looks up the domain object from snapshot and unlocks the
* driver. The returned domain object is locked and ref'd and the
* caller must call virDomainObjEndAPI() on it. */
-static virDomainObjPtr
+static virDomainObj *
qemuDomObjFromSnapshot(virDomainSnapshotPtr snapshot)
{
return qemuDomainObjFromDomain(snapshot->domain);
static int
-qemuAutostartDomain(virDomainObjPtr vm,
+qemuAutostartDomain(virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
int flags = 0;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int ret = -1;
static void
-qemuAutostartDomains(virQEMUDriverPtr driver)
+qemuAutostartDomains(virQEMUDriver *driver)
{
virDomainObjListForEach(driver->domains, false, qemuAutostartDomain, driver);
}
static int
-qemuSecurityInit(virQEMUDriverPtr driver)
+qemuSecurityInit(virQEMUDriver *driver)
{
char **names;
- virSecurityManagerPtr mgr = NULL;
- virSecurityManagerPtr stack = NULL;
+ virSecurityManager *mgr = NULL;
+ virSecurityManager *stack = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
unsigned int flags = 0;
static int
-qemuDomainSnapshotLoad(virDomainObjPtr vm,
+qemuDomainSnapshotLoad(virDomainObj *vm,
void *data)
{
char *baseDir = (char *)data;
g_autofree char *snapDir = NULL;
g_autoptr(DIR) dir = NULL;
struct dirent *entry;
- virDomainSnapshotDefPtr def = NULL;
- virDomainMomentObjPtr snap = NULL;
- virDomainMomentObjPtr current = NULL;
+ virDomainSnapshotDef *def = NULL;
+ virDomainMomentObj *snap = NULL;
+ virDomainMomentObj *current = NULL;
bool cur;
unsigned int flags = (VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE |
VIR_DOMAIN_SNAPSHOT_PARSE_DISKS |
VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL);
int ret = -1;
int direrr;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virObjectLock(vm);
static int
-qemuDomainCheckpointLoad(virDomainObjPtr vm,
+qemuDomainCheckpointLoad(virDomainObj *vm,
void *data)
{
char *baseDir = (char *)data;
g_autofree char *chkDir = NULL;
g_autoptr(DIR) dir = NULL;
struct dirent *entry;
- virDomainCheckpointDefPtr def = NULL;
- virDomainMomentObjPtr chk = NULL;
- virDomainMomentObjPtr current = NULL;
+ virDomainCheckpointDef *def = NULL;
+ virDomainMomentObj *chk = NULL;
+ virDomainMomentObj *current = NULL;
unsigned int flags = VIR_DOMAIN_CHECKPOINT_PARSE_REDEFINE;
int ret = -1;
int direrr;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virObjectLock(vm);
priv = vm->privateData;
static int
-qemuDomainNetsRestart(virDomainObjPtr vm,
+qemuDomainNetsRestart(virDomainObj *vm,
void *data G_GNUC_UNUSED)
{
size_t i;
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
virObjectLock(vm);
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT &&
virDomainNetGetActualDirectMode(net) == VIR_NETDEV_MACVLAN_MODE_VEPA) {
VIR_DEBUG("VEPA mode device %s active in domain %s. Reassociating.",
static int
-qemuDomainFindMaxID(virDomainObjPtr vm,
+qemuDomainFindMaxID(virDomainObj *vm,
void *data)
{
int *driver_maxid = data;
void *opaque)
{
g_autofree char *driverConf = NULL;
- virQEMUDriverConfigPtr cfg;
+ virQEMUDriverConfig *cfg;
uid_t run_uid = -1;
gid_t run_gid = -1;
bool autostart = true;
size_t i;
const char *defsecmodel = NULL;
- g_autofree virSecurityManagerPtr *sec_managers = NULL;
+ g_autofree virSecurityManager **sec_managers = NULL;
qemu_driver = g_new0(virQEMUDriver, 1);
return VIR_DRV_STATE_INIT_ERROR;
}
-static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
+static void qemuNotifyLoadDomain(virDomainObj *vm, int newVM, void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
if (newVM) {
- virObjectEventPtr event =
+ virObjectEvent *event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
VIR_DOMAIN_EVENT_DEFINED_ADDED);
static int
-qemuDomainObjStopWorkerIter(virDomainObjPtr vm,
+qemuDomainObjStopWorkerIter(virDomainObj *vm,
void *opaque G_GNUC_UNUSED)
{
virObjectLock(vm);
static virDrvOpenStatus qemuConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int qemuConnectClose(virConnectPtr conn)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
/* Get rid of callbacks registered for this conn */
virCloseCallbacksRun(driver->closeCallbacks, conn, driver->domains, driver);
static char *
qemuConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
static char *qemuConnectGetCapabilities(virConnectPtr conn) {
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virCaps) caps = NULL;
if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
static int
-qemuDomainHelperGetVcpus(virDomainObjPtr vm,
+qemuDomainHelperGetVcpus(virDomainObj *vm,
virVcpuInfoPtr info,
unsigned long long *cpuwait,
unsigned long long *cpudelay,
memset(cpumaps, 0, sizeof(*cpumaps) * maxinfo);
for (i = 0; i < virDomainDefGetVcpusMax(vm->def) && ncpuinfo < maxinfo; i++) {
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, i);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, i);
pid_t vcpupid = qemuDomainGetVcpuPid(vm, i);
virVcpuInfoPtr vcpuinfo = info + ncpuinfo;
if (cpumaps) {
unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, ncpuinfo);
- virBitmapPtr map = NULL;
+ virBitmap *map = NULL;
if (!(map = virProcessGetAffinity(vcpupid)))
return -1;
static virDomainPtr qemuDomainLookupByID(virConnectPtr conn,
int id)
{
- virQEMUDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByID(driver->domains, id);
static virDomainPtr qemuDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virQEMUDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByUUID(driver->domains, uuid);
static virDomainPtr qemuDomainLookupByName(virConnectPtr conn,
const char *name)
{
- virQEMUDriverPtr driver = conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = conn->privateData;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vm = virDomainObjListFindByName(driver->domains, name);
static int qemuDomainIsActive(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = qemuDomainObjFromDomain(dom)))
static int qemuDomainIsPersistent(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = qemuDomainObjFromDomain(dom)))
static int qemuDomainIsUpdated(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = qemuDomainObjFromDomain(dom)))
static int qemuConnectGetVersion(virConnectPtr conn, unsigned long *version)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
unsigned int qemuVersion = 0;
g_autoptr(virCaps) caps = NULL;
static int qemuConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectListDomainsEnsureACL(conn) < 0)
return -1;
static int qemuConnectNumOfDomains(virConnectPtr conn)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectNumOfDomainsEnsureACL(conn) < 0)
return -1;
const char *xml,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virDomainDef) def = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
- virObjectEventPtr event = NULL;
- virObjectEventPtr event2 = NULL;
+ virObjectEvent *event = NULL;
+ virObjectEvent *event2 = NULL;
unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE |
VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
static int qemuDomainSuspend(virDomainPtr dom)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virDomainPausedReason reason;
int state;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
static int qemuDomainResume(virDomainPtr dom)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
int state;
int reason;
static int
-qemuDomainShutdownFlagsAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainShutdownFlagsAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
bool isReboot,
bool reportError)
{
int ret = -1;
- qemuAgentPtr agent;
+ qemuAgent *agent;
int agentFlag = isReboot ? QEMU_AGENT_SHUTDOWN_REBOOT :
QEMU_AGENT_SHUTDOWN_POWERDOWN;
static int
-qemuDomainShutdownFlagsMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainShutdownFlagsMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
bool isReboot)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
priv = vm->privateData;
static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
bool useAgent = false, agentRequested, acpiRequested;
bool isReboot = false;
bool agentForced;
static int
-qemuDomainRebootAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRebootAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
bool isReboot,
bool agentForced)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int ret = -1;
int agentFlag = QEMU_AGENT_SHUTDOWN_REBOOT;
static int
-qemuDomainRebootMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRebootMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
bool isReboot)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
if (qemuDomainObjBeginJob(driver, vm,
static int
qemuDomainReboot(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
bool useAgent = false, agentRequested, acpiRequested;
bool isReboot = true;
bool agentForced;
static int
qemuDomainReset(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virDomainState state;
virCheckFlags(0, -1);
qemuDomainDestroyFlags(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- virObjectEventPtr event = NULL;
- qemuDomainObjPrivatePtr priv;
+ virObjectEvent *event = NULL;
+ qemuDomainObjPrivate *priv;
unsigned int stopFlags = 0;
int state;
int reason;
}
static char *qemuDomainGetOSType(virDomainPtr dom) {
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *type = NULL;
if (!(vm = qemuDomainObjFromDomain(dom)))
static unsigned long long
qemuDomainGetMaxMemory(virDomainPtr dom)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned long long ret = 0;
if (!(vm = qemuDomainObjFromDomain(dom)))
static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1, r;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
static int qemuDomainSetMemoryStatsPeriod(virDomainPtr dom, int period,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1, r;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = domain->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(0, -1);
int nkeycodes,
unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = domain->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(0, -1);
virDomainInfoPtr info)
{
unsigned long long maxmem;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
int *reason,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
virDomainControlInfoPtr info,
unsigned int flags)
{
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(0, -1);
* this returns (whether returning success or failure).
*/
static int
-qemuDomainSaveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm, const char *path,
- int compressed, virCommandPtr compressor,
+qemuDomainSaveInternal(virQEMUDriver *driver,
+ virDomainObj *vm, const char *path,
+ int compressed, virCommand *compressor,
const char *xmlin, unsigned int flags)
{
g_autofree char *xml = NULL;
bool was_running = false;
int ret = -1;
- virObjectEventPtr event = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUSaveDataPtr data = NULL;
+ virObjectEvent *event = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUSaveData *data = NULL;
g_autoptr(qemuDomainSaveCookie) cookie = NULL;
if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
qemuDomainSaveFlags(virDomainPtr dom, const char *path, const char *dxml,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
int compressed;
g_autoptr(virCommand) compressor = NULL;
int ret = -1;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
}
static char *
-qemuDomainManagedSavePath(virQEMUDriverPtr driver, virDomainObjPtr vm)
+qemuDomainManagedSavePath(virQEMUDriver *driver, virDomainObj *vm)
{
char *ret;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static int
qemuDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
int compressed;
g_autoptr(virCommand) compressor = NULL;
- virDomainObjPtr vm;
+ virDomainObj *vm;
g_autofree char *name = NULL;
int ret = -1;
}
static int
-qemuDomainManagedSaveLoad(virDomainObjPtr vm,
+qemuDomainManagedSaveLoad(virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
g_autofree char *name = NULL;
int ret = -1;
static int
qemuDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int
qemuDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
g_autofree char *name = NULL;
* Returns 0 on success, -1 on failure
*/
static int
-qemuDumpWaitForCompletion(virDomainObjPtr vm)
+qemuDumpWaitForCompletion(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
VIR_DEBUG("Waiting for dump completion");
while (!jobPriv->dumpCompleted && !priv->job.abortJob) {
static int
-qemuDumpToFd(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDumpToFd(virQEMUDriver *driver,
+ virDomainObj *vm,
int fd,
qemuDomainAsyncJob asyncJob,
const char *dumpformat)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool detach = false;
int ret = -1;
static int
-doCoreDump(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+doCoreDump(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
unsigned int dump_flags,
unsigned int dumpformat)
int fd = -1;
int ret = -1;
int rc = -1;
- virFileWrapperFdPtr wrapperFd = NULL;
+ virFileWrapperFd *wrapperFd = NULL;
int directFlag = 0;
unsigned int flags = VIR_FILE_WRAPPER_NON_BLOCKING;
const char *memory_dump_format = NULL;
unsigned int dumpformat,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv = NULL;
bool resume = false, paused = false;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virCheckFlags(VIR_DUMP_LIVE | VIR_DUMP_CRASH |
VIR_DUMP_BYPASS_CACHE | VIR_DUMP_RESET |
unsigned int screen,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
g_autofree char *tmp = NULL;
int tmp_fd = -1;
size_t i;
}
static char *
-getAutoDumpPath(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+getAutoDumpPath(virQEMUDriver *driver,
+ virDomainObj *vm)
{
const char *root = driver->embeddedRoot;
g_autofree char *domname = virDomainDefGetShortName(vm->def);
}
static void
-processWatchdogEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processWatchdogEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
int action)
{
int ret;
}
static int
-doCoreDumpToAutoDumpPath(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+doCoreDumpToAutoDumpPath(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags)
{
int ret = -1;
static void
-qemuProcessGuestPanicEventInfo(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMonitorEventPanicInfoPtr info)
+qemuProcessGuestPanicEventInfo(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMonitorEventPanicInfo *info)
{
g_autofree char *msg = qemuMonitorGuestPanicEventInfoFormatMsg(info);
g_autofree char *timestamp = virTimeStringNow();
static void
-processGuestPanicEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processGuestPanicEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
int action,
- qemuMonitorEventPanicInfoPtr info)
+ qemuMonitorEventPanicInfo *info)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
bool removeInactive = false;
unsigned long flags = VIR_DUMP_MEMORY_ONLY;
static void
-processDeviceDeletedEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processDeviceDeletedEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *devAlias)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static void
-syncNicRxFilterMacAddr(char *ifname, virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+syncNicRxFilterMacAddr(char *ifname, virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
char newMacStr[VIR_MAC_STRING_BUFLEN];
static void
-syncNicRxFilterGuestMulticast(char *ifname, virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+syncNicRxFilterGuestMulticast(char *ifname, virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
size_t i, j;
bool found;
static void
-syncNicRxFilterHostMulticast(char *ifname, virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+syncNicRxFilterHostMulticast(char *ifname, virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
size_t i, j;
bool found;
static void
syncNicRxFilterPromiscMode(char *ifname,
- virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+ virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
bool promisc;
bool setpromisc = false;
static void
-syncNicRxFilterMultiMode(char *ifname, virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+syncNicRxFilterMultiMode(char *ifname, virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
if (hostFilter->multicast.mode != guestFilter->multicast.mode ||
(guestFilter->multicast.overflow &&
static void
-syncNicRxFilterDeviceOptions(char *ifname, virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+syncNicRxFilterDeviceOptions(char *ifname, virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
syncNicRxFilterPromiscMode(ifname, guestFilter, hostFilter);
syncNicRxFilterMultiMode(ifname, guestFilter, hostFilter);
static void
syncNicRxFilterMulticast(char *ifname,
- virNetDevRxFilterPtr guestFilter,
- virNetDevRxFilterPtr hostFilter)
+ virNetDevRxFilter *guestFilter,
+ virNetDevRxFilter *hostFilter)
{
syncNicRxFilterGuestMulticast(ifname, guestFilter, hostFilter);
syncNicRxFilterHostMulticast(ifname, guestFilter, hostFilter);
}
static void
-processNicRxFilterChangedEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processNicRxFilterChangedEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *devAlias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev;
- virDomainNetDefPtr def;
- virNetDevRxFilterPtr guestFilter = NULL;
- virNetDevRxFilterPtr hostFilter = NULL;
+ virDomainNetDef *def;
+ virNetDevRxFilter *guestFilter = NULL;
+ virNetDevRxFilter *hostFilter = NULL;
int ret;
VIR_DEBUG("Received NIC_RX_FILTER_CHANGED event for device %s "
static void
-processSerialChangedEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processSerialChangedEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *devAlias,
bool connected)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virDomainChrDeviceState newstate;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virDomainDeviceDef dev;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (connected)
newstate = VIR_DOMAIN_CHR_DEVICE_STATE_CONNECTED;
static void
-processBlockJobEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+processBlockJobEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *diskAlias,
int type,
int status)
{
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
g_autoptr(qemuBlockJobData) job = NULL;
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
static void
-processJobStatusChangeEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job)
+processJobStatusChangeEvent(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job)
{
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
return;
static void
-processMonitorEOFEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+processMonitorEOFEvent(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int eventReason = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
int stopReason = VIR_DOMAIN_SHUTOFF_SHUTDOWN;
const char *auditReason = "shutdown";
unsigned int stopFlags = 0;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (qemuProcessBeginStopJob(driver, vm, QEMU_JOB_DESTROY, true) < 0)
return;
static void
-processPRDisconnectEvent(virDomainObjPtr vm)
+processPRDisconnectEvent(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virDomainObjIsActive(vm))
return;
static void
-processRdmaGidStatusChangedEvent(virDomainObjPtr vm,
- qemuMonitorRdmaGidStatusPtr info)
+processRdmaGidStatusChangedEvent(virDomainObj *vm,
+ qemuMonitorRdmaGidStatus *info)
{
unsigned int prefix_len;
virSocketAddr addr;
static void
-processGuestCrashloadedEvent(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+processGuestCrashloadedEvent(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_CRASHED,
static void qemuProcessEventHandler(void *data, void *opaque)
{
struct qemuProcessEvent *processEvent = data;
- virDomainObjPtr vm = processEvent->vm;
- virQEMUDriverPtr driver = opaque;
+ virDomainObj *vm = processEvent->vm;
+ virQEMUDriver *driver = opaque;
VIR_DEBUG("vm=%p, event=%d", vm, processEvent->eventType);
static int
-qemuDomainSetVcpusAgent(virDomainObjPtr vm,
+qemuDomainSetVcpusAgent(virDomainObj *vm,
unsigned int nvcpus)
{
- qemuAgentCPUInfoPtr cpuinfo = NULL;
- qemuAgentPtr agent;
+ qemuAgentCPUInfo *cpuinfo = NULL;
+ qemuAgent *agent;
int ncpuinfo;
int ret = -1;
static int
-qemuDomainSetVcpusMax(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr def,
- virDomainDefPtr persistentDef,
+qemuDomainSetVcpusMax(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *def,
+ virDomainDef *persistentDef,
unsigned int nvcpus)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned int topologycpus;
if (def) {
unsigned int nvcpus,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
bool hotpluggable = !!(flags & VIR_DOMAIN_VCPU_HOTPLUGGABLE);
bool useAgent = !!(flags & VIR_DOMAIN_VCPU_GUEST);
int ret = -1;
static int
-qemuDomainPinVcpuLive(virDomainObjPtr vm,
- virDomainDefPtr def,
+qemuDomainPinVcpuLive(virDomainObj *vm,
+ virDomainDef *def,
int vcpu,
- virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virBitmapPtr cpumap)
+ virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virBitmap *cpumap)
{
- virBitmapPtr tmpmap = NULL;
- virDomainVcpuDefPtr vcpuinfo;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virBitmap *tmpmap = NULL;
+ virDomainVcpuDef *vcpuinfo;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCgroup) cgroup_vcpu = NULL;
g_autofree char *str = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
char paramField[VIR_TYPED_PARAM_FIELD_LENGTH] = "";
virTypedParameterPtr eventParams = NULL;
int eventNparams = 0;
int maplen,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
- virBitmapPtr pcpumap = NULL;
- virDomainVcpuDefPtr vcpuinfo = NULL;
+ virBitmap *pcpumap = NULL;
+ virDomainVcpuDef *vcpuinfo = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
int maplen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
bool live;
int ret = -1;
g_autoptr(virBitmap) hostcpus = NULL;
- virBitmapPtr autoCpuset = NULL;
+ virBitmap *autoCpuset = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int maplen,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autoptr(virCgroup) cgroup_emulator = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
- virBitmapPtr pcpumap = NULL;
+ qemuDomainObjPrivate *priv;
+ virBitmap *pcpumap = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autofree char *str = NULL;
virTypedParameterPtr eventParams = NULL;
int eventNparams = 0;
int maplen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
bool live;
int ret = -1;
- virBitmapPtr cpumask = NULL;
+ virBitmap *cpumask = NULL;
g_autoptr(virBitmap) bitmap = NULL;
- virBitmapPtr autoCpuset = NULL;
+ virBitmap *autoCpuset = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
unsigned char *cpumaps,
int maplen)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
static int
qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virDomainDef *def;
int ret = -1;
- qemuAgentCPUInfoPtr cpuinfo = NULL;
- qemuAgentPtr agent;
+ qemuAgentCPUInfo *cpuinfo = NULL;
+ qemuAgent *agent;
int ncpuinfo = -1;
size_t i;
static int
-qemuDomainGetIOThreadsMon(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMonitorIOThreadInfoPtr **iothreads,
+qemuDomainGetIOThreadsMon(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMonitorIOThreadInfo ***iothreads,
int *niothreads)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
qemuDomainObjEnterMonitor(driver, vm);
static int
-qemuDomainGetIOThreadsLive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainGetIOThreadsLive(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainIOThreadInfoPtr **info)
{
- qemuDomainObjPrivatePtr priv;
- qemuMonitorIOThreadInfoPtr *iothreads = NULL;
+ qemuDomainObjPrivate *priv;
+ qemuMonitorIOThreadInfo **iothreads = NULL;
virDomainIOThreadInfoPtr *info_ret = NULL;
int niothreads = 0;
size_t i;
info_ret = g_new0(virDomainIOThreadInfoPtr, niothreads);
for (i = 0; i < niothreads; i++) {
- virBitmapPtr map = NULL;
+ virBitmap *map = NULL;
info_ret[i] = g_new0(virDomainIOThreadInfo, 1);
info_ret[i]->iothread_id = iothreads[i]->iothread_id;
}
static int
-qemuDomainGetIOThreadsConfig(virDomainDefPtr targetDef,
+qemuDomainGetIOThreadsConfig(virDomainDef *targetDef,
virDomainIOThreadInfoPtr **info)
{
virDomainIOThreadInfoPtr *info_ret = NULL;
- virBitmapPtr bitmap = NULL;
- virBitmapPtr cpumask = NULL;
+ virBitmap *bitmap = NULL;
+ virBitmap *cpumask = NULL;
size_t i;
int ret = -1;
virDomainIOThreadInfoPtr **info,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainDefPtr targetDef = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virDomainDef *targetDef = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
unsigned int flags)
{
int ret = -1;
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virDomainObjPtr vm;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
- virBitmapPtr pcpumap = NULL;
- qemuDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
+ virBitmap *pcpumap = NULL;
+ qemuDomainObjPrivate *priv;
g_autoptr(virCgroup) cgroup_iothread = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
char paramField[VIR_TYPED_PARAM_FIELD_LENGTH] = "";
g_autofree char *str = NULL;
virTypedParameterPtr eventParams = NULL;
}
if (def) {
- virDomainIOThreadIDDefPtr iothrid;
- virBitmapPtr cpumask;
+ virDomainIOThreadIDDef *iothrid;
+ virBitmap *cpumask;
if (!(iothrid = virDomainIOThreadIDFind(def, iothread_id))) {
virReportError(VIR_ERR_INVALID_ARG,
}
if (persistentDef) {
- virDomainIOThreadIDDefPtr iothrid;
- virBitmapPtr cpumask;
+ virDomainIOThreadIDDef *iothrid;
+ virBitmap *cpumask;
if (!(iothrid = virDomainIOThreadIDFind(persistentDef, iothread_id))) {
virReportError(VIR_ERR_INVALID_ARG,
}
static int
-qemuDomainHotplugAddIOThread(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainHotplugAddIOThread(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int iothread_id)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *alias = NULL;
size_t idx;
int ret = -1;
unsigned int orig_niothreads = vm->def->niothreadids;
unsigned int exp_niothreads = vm->def->niothreadids;
int new_niothreads = 0;
- qemuMonitorIOThreadInfoPtr *new_iothreads = NULL;
- virDomainIOThreadIDDefPtr iothrid;
- virJSONValuePtr props = NULL;
+ qemuMonitorIOThreadInfo **new_iothreads = NULL;
+ virDomainIOThreadIDDef *iothrid;
+ virJSONValue *props = NULL;
if (!(alias = g_strdup_printf("iothread%u", iothread_id)))
return -1;
static int
-qemuDomainHotplugModIOThread(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainHotplugModIOThread(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMonitorIOThreadInfo iothread)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rc;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_IOTHREAD_POLLING)) {
static int
-qemuDomainHotplugDelIOThread(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainHotplugDelIOThread(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int iothread_id)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t idx;
g_autofree char *alias = NULL;
int rc = -1;
unsigned int orig_niothreads = vm->def->niothreadids;
unsigned int exp_niothreads = vm->def->niothreadids;
int new_niothreads = 0;
- qemuMonitorIOThreadInfoPtr *new_iothreads = NULL;
+ qemuMonitorIOThreadInfo **new_iothreads = NULL;
if (!(alias = g_strdup_printf("iothread%u", iothread_id)))
return -1;
static int
-qemuDomainAddIOThreadCheck(virDomainDefPtr def,
+qemuDomainAddIOThreadCheck(virDomainDef *def,
unsigned int iothread_id)
{
if (virDomainIOThreadIDFind(def, iothread_id)) {
static int
-qemuDomainDelIOThreadCheck(virDomainDefPtr def,
+qemuDomainDelIOThreadCheck(virDomainDef *def,
unsigned int iothread_id)
{
size_t i;
static int
qemuDomainIOThreadParseParams(virTypedParameterPtr params,
int nparams,
- qemuMonitorIOThreadInfoPtr iothread)
+ qemuMonitorIOThreadInfo *iothread)
{
int rc;
} virDomainIOThreadAction;
static int
-qemuDomainChgIOThread(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainChgIOThread(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMonitorIOThreadInfo iothread,
virDomainIOThreadAction action,
unsigned int flags)
{
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ qemuDomainObjPrivate *priv;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
cfg = virQEMUDriverGetConfig(driver);
unsigned int iothread_id,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
qemuMonitorIOThreadInfo iothread = {0};
int ret = -1;
unsigned int iothread_id,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
qemuMonitorIOThreadInfo iothread = {0};
int ret = -1;
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
qemuMonitorIOThreadInfo iothread = {0};
int ret = -1;
static int qemuDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
memset(seclabel, 0, sizeof(*seclabel));
*
* Comment from Dan Berrange:
*
- * Well the PID as stored in the virDomainObjPtr can't be changed
+ * Well the PID as stored in the virDomainObj *can't be changed
* because you've got a locked object. The OS level PID could have
* exited, though and in extreme circumstances have cycled through all
* PIDs back to ours. We could sanity check that our PID still exists
static int qemuDomainGetSecurityLabelList(virDomainPtr dom,
virSecurityLabelPtr* seclabels)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
size_t i;
int ret = -1;
ret = 0;
} else {
int len = 0;
- virSecurityManagerPtr* mgrs = qemuSecurityGetNested(driver->securityManager);
+ virSecurityManager ** mgrs = qemuSecurityGetNested(driver->securityManager);
if (!mgrs)
goto cleanup;
static int qemuNodeGetSecurityModel(virConnectPtr conn,
virSecurityModelPtr secmodel)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virCaps) caps = NULL;
memset(secmodel, 0, sizeof(*secmodel));
const char *dxml,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
- qemuDomainObjPrivatePtr priv = NULL;
+ virQEMUDriver *driver = conn->privateData;
+ qemuDomainObjPrivate *priv = NULL;
g_autoptr(virDomainDef) def = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
g_autofree char *xmlout = NULL;
const char *newxml = dxml;
int fd = -1;
int ret = -1;
- virQEMUSaveDataPtr data = NULL;
- virFileWrapperFdPtr wrapperFd = NULL;
+ virQEMUSaveData *data = NULL;
+ virFileWrapperFd *wrapperFd = NULL;
bool hook_taint = false;
virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
}
if (newxml) {
- virDomainDefPtr tmp;
+ virDomainDef *tmp;
if (!(tmp = qemuSaveImageUpdateDef(driver, def, newxml)))
goto cleanup;
qemuDomainSaveImageGetXMLDesc(virConnectPtr conn, const char *path,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
char *ret = NULL;
g_autoptr(virDomainDef) def = NULL;
int fd = -1;
- virQEMUSaveDataPtr data = NULL;
+ virQEMUSaveData *data = NULL;
virCheckFlags(VIR_DOMAIN_SAVE_IMAGE_XML_SECURE, NULL);
qemuDomainSaveImageDefineXML(virConnectPtr conn, const char *path,
const char *dxml, unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
int ret = -1;
g_autoptr(virDomainDef) def = NULL;
g_autoptr(virDomainDef) newdef = NULL;
int fd = -1;
- virQEMUSaveDataPtr data = NULL;
+ virQEMUSaveData *data = NULL;
int state = -1;
virCheckFlags(VIR_DOMAIN_SAVE_RUNNING |
static char *
qemuDomainManagedSaveGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autofree char *path = NULL;
char *ret = NULL;
g_autoptr(virDomainDef) def = NULL;
int fd = -1;
- virQEMUSaveDataPtr data = NULL;
- qemuDomainObjPrivatePtr priv;
+ virQEMUSaveData *data = NULL;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_SAVE_IMAGE_XML_SECURE, NULL);
qemuDomainManagedSaveDefineXML(virDomainPtr dom, const char *dxml,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
virConnectPtr conn = dom->conn;
- virDomainObjPtr vm;
+ virDomainObj *vm;
g_autofree char *path = NULL;
int ret = -1;
* and -1 on failure with error raised. */
static int
qemuDomainObjRestore(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
bool start_paused,
bool bypass_cache,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(virDomainDef) def = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int fd = -1;
int ret = -1;
g_autofree char *xmlout = NULL;
- virQEMUSaveDataPtr data = NULL;
- virFileWrapperFdPtr wrapperFd = NULL;
+ virQEMUSaveData *data = NULL;
+ virFileWrapperFd *wrapperFd = NULL;
fd = qemuSaveImageOpen(driver, NULL, path, &def, &data,
bypass_cache, &wrapperFd, false, true);
goto cleanup;
if (hookret == 0 && !virStringIsEmpty(xmlout)) {
- virDomainDefPtr tmp;
+ virDomainDef *tmp;
VIR_DEBUG("Using hook-filtered domain XML: %s", xmlout);
*qemuDomainGetXMLDesc(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS | VIR_DOMAIN_XML_UPDATE_CPU,
static int
-qemuConnectDomainXMLToNativePrepareHostHostdev(virDomainHostdevDefPtr hostdev)
+qemuConnectDomainXMLToNativePrepareHostHostdev(virDomainHostdevDef *hostdev)
{
if (virHostdevIsSCSIDevice(hostdev)) {
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
- virStorageSourcePtr src = scsisrc->u.host.src;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
+ virStorageSource *src = scsisrc->u.host.src;
g_autofree char *devstr = NULL;
if (!(devstr = virSCSIDeviceGetSgName(NULL,
static int
-qemuConnectDomainXMLToNativePrepareHost(virDomainObjPtr vm)
+qemuConnectDomainXMLToNativePrepareHost(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
+ virDomainHostdevDef *hostdev = vm->def->hostdevs[i];
if (qemuConnectDomainXMLToNativePrepareHostHostdev(hostdev) < 0)
return -1;
const char *xmlData,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
- virDomainObjPtr vm = NULL;
- virCommandPtr cmd = NULL;
+ virQEMUDriver *driver = conn->privateData;
+ virDomainObj *vm = NULL;
+ virCommand *cmd = NULL;
char *ret = NULL;
size_t i;
* config and assume the user has suitable 'ifup-qemu' scripts
*/
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
- virDomainNetDefPtr newNet = virDomainNetDefNew(driver->xmlopt);
+ virDomainNetDef *net = vm->def->nets[i];
+ virDomainNetDef *newNet = virDomainNetDefNew(driver->xmlopt);
if (!newNet)
goto cleanup;
static int qemuConnectListDefinedDomains(virConnectPtr conn,
char **const names, int nnames) {
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int qemuConnectNumOfDefinedDomains(virConnectPtr conn)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int
qemuDomainObjStart(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags,
qemuDomainAsyncJob asyncJob)
{
bool bypass_cache = (flags & VIR_DOMAIN_START_BYPASS_CACHE) != 0;
bool force_boot = (flags & VIR_DOMAIN_START_FORCE_BOOT) != 0;
unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
start_flags |= start_paused ? VIR_QEMU_PROCESS_START_PAUSED : 0;
start_flags |= autodestroy ? VIR_QEMU_PROCESS_START_AUTODESTROY : 0;
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags);
virDomainAuditStart(vm, "booted", ret >= 0);
if (ret >= 0) {
- virObjectEventPtr event =
+ virObjectEvent *event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
static int
qemuDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(VIR_DOMAIN_START_PAUSED |
const char *xml,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virDomainDef) def = NULL;
g_autoptr(virDomainDef) oldDef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE |
VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
qemuDomainUndefineFlags(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virObjectEvent *event = NULL;
g_autofree char *name = NULL;
int ret = -1;
int nsnapshots;
}
static int
-qemuDomainAttachDeviceLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
- virQEMUDriverPtr driver)
+qemuDomainAttachDeviceLive(virDomainObj *vm,
+ virDomainDeviceDef *dev,
+ virQEMUDriver *driver)
{
int ret = -1;
const char *alias = NULL;
/* queue the event before the alias has a chance to get freed
* if the domain disappears while qemuDomainUpdateDeviceList
* is in monitor */
- virObjectEventPtr event;
+ virObjectEvent *event;
event = virDomainEventDeviceAddedNewFromObj(vm, alias);
virObjectEventStateQueue(driver->domainEventState, event);
}
static int
-qemuDomainChangeDiskLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
- virQEMUDriverPtr driver,
+qemuDomainChangeDiskLive(virDomainObj *vm,
+ virDomainDeviceDef *dev,
+ virQEMUDriver *driver,
bool force)
{
- virDomainDiskDefPtr disk = dev->data.disk;
- virDomainDiskDefPtr orig_disk = NULL;
+ virDomainDiskDef *disk = dev->data.disk;
+ virDomainDiskDef *orig_disk = NULL;
virDomainDeviceDef oldDev = { .type = dev->type };
if (!(orig_disk = virDomainDiskByTarget(vm->def, disk->dst))) {
}
static int
-qemuDomainUpdateDeviceLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+qemuDomainUpdateDeviceLive(virDomainObj *vm,
+ virDomainDeviceDef *dev,
virDomainPtr dom,
bool force)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
virDomainDeviceDef oldDev = { .type = dev->type };
int ret = -1;
int idx;
static int
-qemuDomainAttachDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainAttachDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev,
+ virQEMUCaps *qemuCaps,
unsigned int parse_flags,
- virDomainXMLOptionPtr xmlopt)
-{
- virDomainDiskDefPtr disk;
- virDomainNetDefPtr net;
- virDomainSoundDefPtr sound;
- virDomainHostdevDefPtr hostdev;
- virDomainLeaseDefPtr lease;
- virDomainControllerDefPtr controller;
- virDomainFSDefPtr fs;
- virDomainRedirdevDefPtr redirdev;
- virDomainShmemDefPtr shmem;
+ virDomainXMLOption *xmlopt)
+{
+ virDomainDiskDef *disk;
+ virDomainNetDef *net;
+ virDomainSoundDef *sound;
+ virDomainHostdevDef *hostdev;
+ virDomainLeaseDef *lease;
+ virDomainControllerDef *controller;
+ virDomainFSDef *fs;
+ virDomainRedirdevDef *redirdev;
+ virDomainShmemDef *shmem;
switch ((virDomainDeviceType)dev->type) {
case VIR_DOMAIN_DEVICE_DISK:
static int
-qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainDetachDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev,
+ virQEMUCaps *qemuCaps,
unsigned int parse_flags,
- virDomainXMLOptionPtr xmlopt)
-{
- virDomainDiskDefPtr disk;
- virDomainDiskDefPtr det_disk;
- virDomainNetDefPtr net;
- virDomainSoundDefPtr sound;
- virDomainHostdevDefPtr hostdev;
- virDomainHostdevDefPtr det_hostdev;
- virDomainLeaseDefPtr lease;
- virDomainLeaseDefPtr det_lease;
- virDomainControllerDefPtr cont;
- virDomainControllerDefPtr det_cont;
- virDomainChrDefPtr chr;
- virDomainFSDefPtr fs;
- virDomainMemoryDefPtr mem;
+ virDomainXMLOption *xmlopt)
+{
+ virDomainDiskDef *disk;
+ virDomainDiskDef *det_disk;
+ virDomainNetDef *net;
+ virDomainSoundDef *sound;
+ virDomainHostdevDef *hostdev;
+ virDomainHostdevDef *det_hostdev;
+ virDomainLeaseDef *lease;
+ virDomainLeaseDef *det_lease;
+ virDomainControllerDef *cont;
+ virDomainControllerDef *det_cont;
+ virDomainChrDef *chr;
+ virDomainFSDef *fs;
+ virDomainMemoryDef *mem;
int idx;
switch ((virDomainDeviceType)dev->type) {
}
static int
-qemuDomainUpdateDeviceConfig(virDomainDefPtr vmdef,
- virDomainDeviceDefPtr dev,
- virQEMUCapsPtr qemuCaps,
+qemuDomainUpdateDeviceConfig(virDomainDef *vmdef,
+ virDomainDeviceDef *dev,
+ virQEMUCaps *qemuCaps,
unsigned int parse_flags,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainDiskDefPtr newDisk;
- virDomainGraphicsDefPtr newGraphics;
- virDomainNetDefPtr net;
+ virDomainDiskDef *newDisk;
+ virDomainGraphicsDef *newGraphics;
+ virDomainNetDef *net;
virDomainDeviceDef oldDev = { .type = dev->type };
int pos;
static void
qemuDomainAttachDeviceLiveAndConfigHomogenize(const virDomainDeviceDef *devConf,
- virDomainDeviceDefPtr devLive)
+ virDomainDeviceDef *devLive)
{
/*
* Fixup anything that needs to be identical in the live and
static int
-qemuDomainAttachDeviceLiveAndConfig(virDomainObjPtr vm,
- virQEMUDriverPtr driver,
+qemuDomainAttachDeviceLiveAndConfig(virDomainObj *vm,
+ virQEMUDriver *driver,
const char *xml,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virDomainDef) vmdef = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
g_autoptr(virDomainDeviceDef) devConf = NULL;
const char *xml,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
virNWFilterReadLockFilterUpdates();
const char *xml,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
g_autoptr(virDomainDef) vmdef = NULL;
g_autoptr(virDomainDeviceDef) dev = NULL;
- virDomainDeviceDefPtr dev_copy = NULL;
+ virDomainDeviceDef *dev_copy = NULL;
bool force = (flags & VIR_DOMAIN_DEVICE_MODIFY_FORCE) != 0;
int ret = -1;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
}
static int
-qemuDomainDetachDeviceLiveAndConfig(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainDetachDeviceLiveAndConfig(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *xml,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
g_autoptr(virDomainDeviceDef) dev = NULL;
- virDomainDeviceDefPtr dev_copy = NULL;
+ virDomainDeviceDef *dev_copy = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE;
g_autoptr(virDomainDef) vmdef = NULL;
int ret = -1;
static int
-qemuDomainDetachDeviceAliasLiveAndConfig(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainDetachDeviceAliasLiveAndConfig(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *alias,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
g_autoptr(virDomainDef) vmdef = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE;
const char *xml,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
const char *alias,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
static int qemuDomainGetAutostart(virDomainPtr dom,
int *autostart)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
static int qemuDomainSetAutostart(virDomainPtr dom,
int autostart)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autofree char *configFile = NULL;
g_autofree char *autostartLink = NULL;
int ret = -1;
int *nparams)
{
char *ret = NULL;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv;
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
+ virQEMUDriver *driver = dom->conn->privateData;
if (!(vm = qemuDomainObjFromDomain(dom)))
goto cleanup;
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int maxparams = QEMU_NB_BLKIO_PARAM;
unsigned int val;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
+ virDomainObj *vm = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
unsigned long long swap_hard_limit, mem_hard_limit, mem_soft_limit;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
#undef QEMU_ASSIGN_MEM_PARAM
static int
-qemuDomainSetNumaParamsLive(virDomainObjPtr vm,
- virBitmapPtr nodeset)
+qemuDomainSetNumaParamsLive(virDomainObj *vm,
+ virBitmap *nodeset)
{
g_autoptr(virCgroup) cgroup_thread = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *nodeset_str = NULL;
virDomainNumatuneMemMode mode;
size_t i = 0;
for (i = 0; i < virDomainDefGetVcpusMax(vm->def); i++) {
g_autoptr(virCgroup) cgroup_vcpu = NULL;
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, i);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, i);
if (!vcpu->online)
continue;
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
size_t i;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
- virDomainObjPtr vm = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
+ virDomainObj *vm = NULL;
int ret = -1;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
- virBitmapPtr nodeset = NULL;
+ qemuDomainObjPrivate *priv;
+ virBitmap *nodeset = NULL;
virDomainNumatuneMemMode config_mode;
int mode = -1;
unsigned int flags)
{
size_t i;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainNumatuneMemMode tmpmode = VIR_DOMAIN_NUMATUNE_MEM_STRICT;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
g_autofree char *nodeset = NULL;
int ret = -1;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
bool live = false;
- virBitmapPtr autoNodeset = NULL;
+ virBitmap *autoNodeset = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
}
static int
-qemuSetGlobalBWLive(virCgroupPtr cgroup, unsigned long long period,
+qemuSetGlobalBWLive(virCgroup *cgroup, unsigned long long period,
long long quota)
{
if (period == 0 && quota == 0)
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
size_t i;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ qemuDomainObjPrivate *priv;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
virPerfEventType type;
bool enabled;
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainDefPtr def;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
+ virDomainDef *def;
virTypedParameterPtr par = NULL;
int maxpar = 0;
int npar = 0;
}
static int
-qemuSetVcpusBWLive(virDomainObjPtr vm, virCgroupPtr cgroup,
+qemuSetVcpusBWLive(virDomainObj *vm, virCgroup *cgroup,
unsigned long long period, long long quota)
{
size_t i;
for (i = 0; i < virDomainDefGetVcpusMax(vm->def); i++) {
g_autoptr(virCgroup) cgroup_vcpu = NULL;
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, i);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, i);
if (!vcpu->online)
continue;
}
static int
-qemuSetEmulatorBandwidthLive(virCgroupPtr cgroup,
+qemuSetEmulatorBandwidthLive(virCgroup *cgroup,
unsigned long long period,
long long quota)
{
static int
-qemuSetIOThreadsBWLive(virDomainObjPtr vm, virCgroupPtr cgroup,
+qemuSetIOThreadsBWLive(virDomainObj *vm, virCgroup *cgroup,
unsigned long long period, long long quota)
{
size_t i;
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
size_t i;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
g_autoptr(virDomainDef) persistentDefCopy = NULL;
unsigned long long value_ul;
long long value_l;
int ret = -1;
int rc;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuDomainObjPrivatePtr priv;
- virObjectEventPtr event = NULL;
+ qemuDomainObjPrivate *priv;
+ virObjectEvent *event = NULL;
virTypedParameterPtr eventParams = NULL;
int eventNparams = 0;
int eventMaxNparams = 0;
}
static int
-qemuGetVcpuBWLive(virCgroupPtr cgroup, unsigned long long *period,
+qemuGetVcpuBWLive(virCgroup *cgroup, unsigned long long *period,
long long *quota)
{
return virCgroupGetCpuPeriodQuota(cgroup, period, quota);
}
static int
-qemuGetVcpusBWLive(virDomainObjPtr vm,
+qemuGetVcpusBWLive(virDomainObj *vm,
unsigned long long *period, long long *quota)
{
g_autoptr(virCgroup) cgroup_vcpu = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
int rc;
priv = vm->privateData;
}
static int
-qemuGetEmulatorBandwidthLive(virCgroupPtr cgroup,
+qemuGetEmulatorBandwidthLive(virCgroup *cgroup,
unsigned long long *period,
long long *quota)
{
}
static int
-qemuGetIOThreadsBWLive(virDomainObjPtr vm,
+qemuGetIOThreadsBWLive(virDomainObj *vm,
unsigned long long *period, long long *quota)
{
g_autoptr(virCgroup) cgroup_iothread = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
int rc;
priv = vm->privateData;
static int
-qemuGetGlobalBWLive(virCgroupPtr cgroup, unsigned long long *period,
+qemuGetGlobalBWLive(virCgroup *cgroup, unsigned long long *period,
long long *quota)
{
if (qemuGetVcpuBWLive(cgroup, period, quota) < 0)
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
virDomainCputune data = {0};
int ret = -1;
bool cpu_bw_status = true;
- virDomainDefPtr persistentDef;
- virDomainDefPtr def;
- qemuDomainObjPrivatePtr priv;
+ virDomainDef *persistentDef;
+ virDomainDef *def;
+ qemuDomainObjPrivate *priv;
int maxparams = *nparams;
*nparams = 0;
unsigned long long size,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
int ret = -1;
g_autofree char *device = NULL;
const char *nodename = NULL;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
virCheckFlags(VIR_DOMAIN_BLOCK_RESIZE_BYTES, -1);
static void
-qemuDomainBlockStatsGatherTotals(qemuBlockStatsPtr data,
- qemuBlockStatsPtr total)
+qemuDomainBlockStatsGatherTotals(qemuBlockStats *data,
+ qemuBlockStats *total)
{
total->wr_bytes += data->wr_bytes;
total->wr_req += data->wr_req;
* Returns -1 on error; number of filled block statistics on success.
*/
static int
-qemuDomainBlocksStatsGather(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainBlocksStatsGather(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
bool capacity,
- qemuBlockStatsPtr *retstats)
+ qemuBlockStats **retstats)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
GHashTable *blockstats = NULL;
- qemuBlockStatsPtr stats;
+ qemuBlockStats *stats;
size_t i;
int nstats;
int rc = 0;
if (blockdev) {
/* capacity are reported only per node-name so we need to transfer them */
- qemuBlockStatsPtr capstats;
+ qemuBlockStats *capstats;
if (disk && disk->src &&
(capstats = virHashLookup(blockstats, disk->src->nodeformat))) {
const char *path,
virDomainBlockStatsPtr stats)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuBlockStatsPtr blockstats = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuBlockStats *blockstats = NULL;
int ret = -1;
- virDomainObjPtr vm;
+ virDomainObj *vm;
if (!(vm = qemuDomainObjFromDomain(dom)))
goto cleanup;
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuBlockStatsPtr blockstats = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuBlockStats *blockstats = NULL;
int nstats;
int ret = -1;
const char *device,
virDomainInterfaceStatsPtr stats)
{
- virDomainObjPtr vm;
- virDomainNetDefPtr net = NULL;
+ virDomainObj *vm;
+ virDomainNetDef *net = NULL;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(dom)))
if (virNetDevOpenvswitchInterfaceStats(net->ifname, stats) < 0)
goto cleanup;
} else if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
- virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);
- virPCIDeviceAddressPtr vfAddr;
+ virDomainHostdevDef *hostdev = virDomainNetGetActualHostdev(net);
+ virPCIDeviceAddress *vfAddr;
if (!hostdev) {
virReportError(VIR_ERR_INTERNAL_ERROR,
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
size_t i;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1;
- virDomainNetDefPtr net = NULL;
- virDomainNetDefPtr persistentNet = NULL;
+ virDomainNetDef *net = NULL;
+ virDomainNetDef *persistentNet = NULL;
g_autoptr(virNetDevBandwidth) bandwidth = NULL;
g_autoptr(virNetDevBandwidth) newBandwidth = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
unsigned int flags)
{
size_t i;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainNetDefPtr net = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainNetDef *net = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
/* This functions assumes that job QEMU_JOB_QUERY is started by a caller */
static int
-qemuDomainMemoryStatsInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainMemoryStatsInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainMemoryStatPtr stats,
unsigned int nr_stats)
unsigned int nr_stats,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
void *buffer,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainDiskDefPtr disk = NULL;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainDiskDef *disk = NULL;
+ virDomainObj *vm;
g_autofree char *tmpbuf = NULL;
ssize_t nread;
int ret = -1;
void *buffer,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autofree char *tmp = NULL;
int fd = -1, ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
virCheckFlags(VIR_MEMORY_VIRTUAL | VIR_MEMORY_PHYSICAL, -1);
* reported) or -1 otherwise (errors are reported).
*/
static int
-qemuDomainStorageOpenStat(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuDomainStorageOpenStat(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virStorageSource *src,
int *ret_fd,
struct stat *ret_sb,
bool skipInaccessible)
* else remote, then tear down the storage driver backend connection.
*/
static void
-qemuDomainStorageCloseStat(virStorageSourcePtr src,
+qemuDomainStorageCloseStat(virStorageSource *src,
int *fd)
{
if (virStorageSourceIsLocalStorage(src))
* reported but are reset (thus only logged)).
*/
static int
-qemuDomainStorageUpdatePhysical(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuDomainStorageUpdatePhysical(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virStorageSource *src)
{
int ret;
int fd = -1;
* are reported).
*/
static int
-qemuStorageLimitsRefresh(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuStorageLimitsRefresh(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virStorageSource *src,
bool skipInaccessible)
{
int rc;
virDomainBlockInfoPtr info,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- qemuBlockStatsPtr entry = NULL;
+ qemuBlockStats *entry = NULL;
virCheckFlags(0, -1);
void *opaque,
virFreeCallback freecb)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectDomainEventRegisterEnsureACL(conn) < 0)
return -1;
qemuConnectDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectDomainEventDeregisterEnsureACL(conn) < 0)
return -1;
void *opaque,
virFreeCallback freecb)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
int ret = -1;
if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
qemuConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
unsigned long resource G_GNUC_UNUSED,
const char *dom_xml)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virDomainDef) def = NULL;
g_autofree char *origname = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
unsigned long resource G_GNUC_UNUSED,
const char *dom_xml)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virDomainDef) def = NULL;
g_autofree char *origname = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
const char *dname,
unsigned long resource)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
const char *dconnuri = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
unsigned long flags,
int retcode)
{
- virQEMUDriverPtr driver = dconn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dconn->privateData;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
const char *dname,
unsigned long resource G_GNUC_UNUSED)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
const char *dname = NULL;
g_autofree const char **migrate_disks = NULL;
int nmigrate_disks;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
if (virTypedParamsValidate(params, nparams, QEMU_MIGRATION_PARAMETERS) < 0)
unsigned long resource G_GNUC_UNUSED,
const char *dom_xml)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virDomainDef) def = NULL;
g_autofree char *origname = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
char **uri_out,
unsigned int flags)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virDomainDef) def = NULL;
const char *dom_xml = NULL;
unsigned long resource G_GNUC_UNUSED,
const char *dom_xml)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virDomainDef) def = NULL;
g_autofree char *origname = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
int *cookieoutlen,
unsigned int flags)
{
- virQEMUDriverPtr driver = dconn->privateData;
+ virQEMUDriver *driver = dconn->privateData;
g_autoptr(virDomainDef) def = NULL;
const char *dom_xml = NULL;
const char *dname = NULL;
const char *dname,
unsigned long resource)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
int *cookieoutlen,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
const char *dom_xml = NULL;
const char *persist_xml = NULL;
const char *dname = NULL;
unsigned long flags,
int cancelled)
{
- virQEMUDriverPtr driver = dconn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dconn->privateData;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
unsigned int flags,
int cancelled)
{
- virQEMUDriverPtr driver = dconn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dconn->privateData;
+ virDomainObj *vm;
const char *dname = NULL;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
unsigned long flags,
int cancelled)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
unsigned int flags,
int cancelled)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
const char *driverName,
unsigned int flags)
{
- virQEMUDriverPtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virQEMUDriver *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virCheckFlags(0, -1);
static int
qemuNodeDeviceReAttach(virNodeDevicePtr dev)
{
- virQEMUDriverPtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virQEMUDriver *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
/* virNodeDeviceReAttachEnsureACL() is being called by
* virDomainDriverNodeDeviceReAttach() */
static int
qemuNodeDeviceReset(virNodeDevicePtr dev)
{
- virQEMUDriverPtr driver = dev->conn->privateData;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virQEMUDriver *driver = dev->conn->privateData;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
/* virNodeDeviceResetEnsureACL() is being called by
* virDomainDriverNodeDeviceReset() */
const char *xmlDesc,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virCPUDef) cpu = NULL;
bool failIncompatible;
bool validateXML;
static virCPUCompareResult
-qemuConnectCPUModelComparison(virQEMUCapsPtr qemuCaps,
+qemuConnectCPUModelComparison(virQEMUCaps *qemuCaps,
const char *libDir,
uid_t runUid,
gid_t runGid,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
bool failIncompatible)
{
g_autoptr(qemuProcessQMP) proc = NULL;
unsigned int flags)
{
int ret = VIR_CPU_COMPARE_ERROR;
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virQEMUCaps) qemuCaps = NULL;
bool failIncompatible;
bool validateXML;
- virCPUDefPtr hvCPU;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *hvCPU;
+ virCPUDef *cpu = NULL;
virArch arch;
virDomainVirtType virttype;
unsigned int ncpus,
unsigned int flags)
{
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr baseline = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *baseline = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
* failure), @src is freed.
*/
static int
-qemuConnectStealCPUModelFromInfo(virCPUDefPtr dst,
- qemuMonitorCPUModelInfoPtr *src)
+qemuConnectStealCPUModelFromInfo(virCPUDef *dst,
+ qemuMonitorCPUModelInfo **src)
{
- qemuMonitorCPUModelInfoPtr info;
+ qemuMonitorCPUModelInfo *info;
size_t i;
int ret = -1;
}
-static virCPUDefPtr
-qemuConnectCPUModelBaseline(virQEMUCapsPtr qemuCaps,
+static virCPUDef *
+qemuConnectCPUModelBaseline(virQEMUCaps *qemuCaps,
const char *libDir,
uid_t runUid,
gid_t runGid,
bool expand_features,
- virCPUDefPtr *cpus,
+ virCPUDef **cpus,
int ncpus,
- virDomainCapsCPUModelsPtr cpuModels)
+ virDomainCapsCPUModels *cpuModels)
{
g_autoptr(qemuProcessQMP) proc = NULL;
g_autoptr(virCPUDef) baseline = NULL;
- qemuMonitorCPUModelInfoPtr result = NULL;
+ qemuMonitorCPUModelInfo *result = NULL;
qemuMonitorCPUModelExpansionType expansion_type;
size_t i;
unsigned int ncpus,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virCPUDefPtr *cpus = NULL;
+ virCPUDef **cpus = NULL;
g_autoptr(virQEMUCaps) qemuCaps = NULL;
virArch arch;
virDomainVirtType virttype;
g_autoptr(virDomainCapsCPUModels) cpuModels = NULL;
bool migratable;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
char **features = NULL;
static int
-qemuDomainGetJobInfoMigrationStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainJobInfoPtr jobInfo)
+qemuDomainGetJobInfoMigrationStats(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuDomainJobInfo *jobInfo)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
if (jobInfo->status == QEMU_DOMAIN_JOB_STATUS_ACTIVE ||
static int
-qemuDomainGetJobInfoDumpStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainJobInfoPtr jobInfo)
+qemuDomainGetJobInfoDumpStats(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuDomainJobInfo *jobInfo)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorDumpStats stats = { 0 };
int rc;
static int
-qemuDomainGetJobStatsInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainGetJobStatsInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
bool completed,
- qemuDomainJobInfoPtr *jobInfo)
+ qemuDomainJobInfo **jobInfo)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
*jobInfo = NULL;
qemuDomainGetJobInfo(virDomainPtr dom,
virDomainJobInfoPtr info)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(qemuDomainJobInfo) jobInfo = NULL;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
memset(info, 0, sizeof(*info));
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
g_autoptr(qemuDomainJobInfo) jobInfo = NULL;
bool completed = !!(flags & VIR_DOMAIN_JOB_STATS_COMPLETED);
int ret = -1;
static int
-qemuDomainAbortJobMigration(virDomainObjPtr vm)
+qemuDomainAbortJobMigration(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
VIR_DEBUG("Cancelling migration job at client request");
static int qemuDomainAbortJob(virDomainPtr dom)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
int reason;
if (!(vm = qemuDomainObjFromDomain(dom)))
unsigned long long downtime,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
int rc;
unsigned long long *downtime,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
int rc;
unsigned long long *cacheSize,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
int rc;
unsigned long long cacheSize,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
int rc;
unsigned long bandwidth,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
g_autoptr(qemuMigrationParams) migParams = NULL;
bool bwParam;
static int
-qemuDomainMigrationGetPostcopyBandwidth(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainMigrationGetPostcopyBandwidth(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned long *bandwidth)
{
g_autoptr(qemuMigrationParams) migParams = NULL;
unsigned long *bandwidth,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
int ret = -1;
qemuDomainMigrateStartPostCopy(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(0, -1);
const char *xmlDesc,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainSnapshotPtr snapshot = NULL;
if (!(vm = qemuDomainObjFromDomain(domain)))
int nameslen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
qemuDomainSnapshotNum(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
int nameslen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
qemuDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
const char *name,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr snapshot = NULL;
virCheckFlags(0, NULL);
qemuDomainHasCurrentSnapshot(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
qemuDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr parent = NULL;
virCheckFlags(0, NULL);
qemuDomainSnapshotCurrent(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainSnapshotPtr snapshot = NULL;
const char *name;
qemuDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = snapshot->domain->conn->privateData;
+ virDomainObj *vm = NULL;
char *xml = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virCheckFlags(VIR_DOMAIN_SNAPSHOT_XML_SECURE, NULL);
qemuDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
virCheckFlags(0, -1);
qemuDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
virCheckFlags(0, -1);
qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virNWFilterReadLockFilterUpdates();
qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
if (!(vm = qemuDomObjFromSnapshot(snapshot)))
const char *xmlDesc,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainCheckpointPtr checkpoint = NULL;
if (!(vm = qemuDomainObjFromDomain(domain)))
virDomainCheckpointPtr **chks,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_LIST_ROOTS |
virDomainCheckpointPtr **chks,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *chk = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS |
const char *name,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr checkpoint = NULL;
virCheckFlags(0, NULL);
qemuDomainCheckpointGetParent(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr parent = NULL;
virCheckFlags(0, NULL);
qemuDomainCheckpointGetXMLDesc(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
char *xml = NULL;
if (!(vm = qemuDomObjFromCheckpoint(checkpoint)))
qemuDomainCheckpointDelete(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
if (!(vm = qemuDomObjFromCheckpoint(checkpoint)))
const char *checkpointXML,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(domain)))
qemuDomainBackupGetXMLDesc(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
char *ret = NULL;
if (!(vm = qemuDomainObjFromDomain(domain)))
static int qemuDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd,
char **result, unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = domain->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
bool hmp;
virCheckFlags(VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP, -1);
virStreamPtr st,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
size_t i;
- virDomainChrDefPtr chr = NULL;
- qemuDomainObjPrivatePtr priv;
+ virDomainChrDef *chr = NULL;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_CONSOLE_SAFE |
VIR_DOMAIN_CONSOLE_FORCE, -1);
virStreamPtr st,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
size_t i;
- virDomainChrDefPtr chr = NULL;
- qemuDomainObjPrivatePtr priv;
+ virDomainChrDef *chr = NULL;
+ qemuDomainObjPrivate *priv;
virCheckFlags(VIR_DOMAIN_CHANNEL_FORCE, -1);
* abort with pivot; this updates the VM definition as appropriate, on
* either success or failure. */
static int
-qemuDomainBlockPivot(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuBlockJobDataPtr job,
- virDomainDiskDefPtr disk)
+qemuDomainBlockPivot(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuBlockJobData *job,
+ virDomainDiskDef *disk)
{
g_autoptr(qemuBlockStorageSourceChainData) chainattachdata = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
g_autoptr(virJSONValue) bitmapactions = NULL;
g_autoptr(virJSONValue) reopenactions = NULL;
/* bandwidth in MiB/s per public API. Caller must lock vm beforehand,
* and not access it afterwards. */
static int
-qemuDomainBlockPullCommon(virDomainObjPtr vm,
+qemuDomainBlockPullCommon(virDomainObj *vm,
const char *path,
const char *base,
unsigned long bandwidth,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
const char *device = NULL;
const char *jobname = NULL;
- virDomainDiskDefPtr disk;
- virStorageSourcePtr baseSource = NULL;
+ virDomainDiskDef *disk;
+ virStorageSource *baseSource = NULL;
g_autofree char *basePath = NULL;
g_autofree char *backingPath = NULL;
unsigned long long speed = bandwidth;
- qemuBlockJobDataPtr job = NULL;
+ qemuBlockJobData *job = NULL;
bool persistjob = false;
const char *nodebase = NULL;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
const char *path,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainDiskDefPtr disk = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainDiskDef *disk = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
bool pivot = !!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT);
bool async = !!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC);
g_autoptr(qemuBlockJobData) job = NULL;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv = NULL;
+ virDomainObj *vm;
+ qemuDomainObjPrivate *priv = NULL;
bool blockdev = false;
int ret = -1;
static int
-qemuBlockJobInfoTranslate(qemuMonitorBlockJobInfoPtr rawInfo,
+qemuBlockJobInfoTranslate(qemuMonitorBlockJobInfo *rawInfo,
virDomainBlockJobInfoPtr info,
- qemuBlockJobDataPtr job,
+ qemuBlockJobData *job,
bool reportBytes)
{
info->type = job->type;
virDomainBlockJobInfoPtr info,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- virDomainDiskDefPtr disk;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ virDomainDiskDef *disk;
int ret = -1;
- qemuMonitorBlockJobInfoPtr rawInfo;
+ qemuMonitorBlockJobInfo *rawInfo;
g_autoptr(qemuBlockJobData) job = NULL;
g_autoptr(GHashTable) blockjobstats = NULL;
unsigned long bandwidth,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainDiskDefPtr disk;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainDiskDef *disk;
int ret = -1;
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned long long speed = bandwidth;
g_autoptr(qemuBlockJobData) job = NULL;
static int
-qemuDomainBlockCopyValidateMirror(virStorageSourcePtr mirror,
+qemuDomainBlockCopyValidateMirror(virStorageSource *mirror,
const char *dst,
bool *reuse)
{
* 4) if deep copy is requested, there's no chain
*/
static int
-qemuDomainBlockCopyCommonValidateUserMirrorBackingStore(virStorageSourcePtr mirror,
+qemuDomainBlockCopyCommonValidateUserMirrorBackingStore(virStorageSource *mirror,
bool shallow,
bool blockdev)
{
/* bandwidth in bytes/s. Caller must lock vm beforehand, and not
* access mirror afterwards. */
static int
-qemuDomainBlockCopyCommon(virDomainObjPtr vm,
+qemuDomainBlockCopyCommon(virDomainObj *vm,
virConnectPtr conn,
const char *path,
- virStorageSourcePtr mirrorsrc,
+ virStorageSource *mirrorsrc,
unsigned long long bandwidth,
unsigned int granularity,
unsigned long long buf_size,
unsigned int flags,
bool keepParentLabel)
{
- virQEMUDriverPtr driver = conn->privateData;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDiskDefPtr disk = NULL;
+ virQEMUDriver *driver = conn->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDiskDef *disk = NULL;
int ret = -1;
bool need_unlink = false;
bool need_revoke = false;
bool mirror_reuse = !!(flags & VIR_DOMAIN_BLOCK_COPY_REUSE_EXT);
bool mirror_shallow = !!(flags & VIR_DOMAIN_BLOCK_COPY_SHALLOW);
bool existing = mirror_reuse;
- qemuBlockJobDataPtr job = NULL;
+ qemuBlockJobData *job = NULL;
g_autoptr(virStorageSource) mirror = mirrorsrc;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
bool supports_create = false;
bool supports_detect = false;
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
g_autoptr(qemuBlockStorageSourceChainData) crdata = NULL;
- virStorageSourcePtr n;
- virStorageSourcePtr mirrorBacking = NULL;
+ virStorageSource *n;
+ virStorageSource *mirrorBacking = NULL;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
int rc = 0;
qemuDomainBlockRebase(virDomainPtr dom, const char *path, const char *base,
unsigned long bandwidth, unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
unsigned long long speed = bandwidth;
g_autoptr(virStorageSource) dest = NULL;
virTypedParameterPtr params, int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
unsigned long long bandwidth = 0;
unsigned int granularity = 0;
unsigned long long buf_size = 0;
- virDomainDiskDefPtr diskdef = NULL;
- virStorageSourcePtr dest = NULL;
+ virDomainDiskDef *diskdef = NULL;
+ virStorageSource *dest = NULL;
size_t i;
virCheckFlags(VIR_DOMAIN_BLOCK_COPY_SHALLOW |
qemuDomainBlockPull(virDomainPtr dom, const char *path, unsigned long bandwidth,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES, -1);
if (!(vm = qemuDomainObjFromDomain(dom)))
unsigned long bandwidth,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm = NULL;
const char *device = NULL;
const char *jobname = NULL;
int ret = -1;
- virDomainDiskDefPtr disk = NULL;
- virStorageSourcePtr topSource;
- virStorageSourcePtr baseSource = NULL;
- virStorageSourcePtr top_parent = NULL;
+ virDomainDiskDef *disk = NULL;
+ virStorageSource *topSource;
+ virStorageSource *baseSource = NULL;
+ virStorageSource *top_parent = NULL;
bool clean_access = false;
g_autofree char *topPath = NULL;
g_autofree char *basePath = NULL;
g_autofree char *backingPath = NULL;
unsigned long long speed = bandwidth;
- qemuBlockJobDataPtr job = NULL;
+ qemuBlockJobData *job = NULL;
g_autoptr(virStorageSource) mirror = NULL;
const char *nodetop = NULL;
const char *nodebase = NULL;
int fd,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
const char *protocol;
virCheckFlags(VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH, -1);
unsigned int idx,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
const char *protocol;
int pair[2] = {-1, -1};
static bool
-qemuDomainDiskBlockIoTuneIsSupported(virStorageSourcePtr src)
+qemuDomainDiskBlockIoTuneIsSupported(virStorageSource *src)
{
if (virStorageSourceGetActualType(src) == VIR_STORAGE_TYPE_VHOST_USER) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
/* If the user didn't specify bytes limits, inherit previous values;
* likewise if the user didn't specify iops limits. */
static int
-qemuDomainSetBlockIoTuneDefaults(virDomainBlockIoTuneInfoPtr newinfo,
- virDomainBlockIoTuneInfoPtr oldinfo,
+qemuDomainSetBlockIoTuneDefaults(virDomainBlockIoTuneInfo *newinfo,
+ virDomainBlockIoTuneInfo *oldinfo,
qemuBlockIoTuneSetFlags set_fields)
{
#define SET_IOTUNE_DEFAULTS(BOOL, FIELD) \
static void
-qemuDomainSetGroupBlockIoTune(virDomainDefPtr def,
- virDomainBlockIoTuneInfoPtr iotune)
+qemuDomainSetGroupBlockIoTune(virDomainDef *def,
+ virDomainBlockIoTuneInfo *iotune)
{
size_t i;
return;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr d = def->disks[i];
+ virDomainDiskDef *d = def->disks[i];
if (STREQ_NULLABLE(d->blkdeviotune.group_name, iotune->group_name)) {
VIR_FREE(d->blkdeviotune.group_name);
}
-static virDomainBlockIoTuneInfoPtr
-qemuDomainFindGroupBlockIoTune(virDomainDefPtr def,
- virDomainDiskDefPtr disk,
- virDomainBlockIoTuneInfoPtr newiotune)
+static virDomainBlockIoTuneInfo *
+qemuDomainFindGroupBlockIoTune(virDomainDef *def,
+ virDomainDiskDef *disk,
+ virDomainBlockIoTuneInfo *newiotune)
{
size_t i;
return &disk->blkdeviotune;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr d = def->disks[i];
+ virDomainDiskDef *d = def->disks[i];
if (STREQ_NULLABLE(newiotune->group_name, d->blkdeviotune.group_name))
return &d->blkdeviotune;
static int
-qemuDomainCheckBlockIoTuneReset(virDomainDiskDefPtr disk,
- virDomainBlockIoTuneInfoPtr newiotune)
+qemuDomainCheckBlockIoTuneReset(virDomainDiskDef *disk,
+ virDomainBlockIoTuneInfo *newiotune)
{
if (virDomainBlockIoTuneInfoHasAny(newiotune))
return 0;
int nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
virDomainBlockIoTuneInfo info;
virDomainBlockIoTuneInfo conf_info;
g_autofree char *drivealias = NULL;
const char *qdevid = NULL;
int ret = -1;
size_t i;
- virDomainDiskDefPtr conf_disk = NULL;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *conf_disk = NULL;
+ virDomainDiskDef *disk;
qemuBlockIoTuneSetFlags set_fields = 0;
bool supportMaxOptions = true;
bool supportGroupNameOption = true;
bool supportMaxLengthOptions = true;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virTypedParameterPtr eventParams = NULL;
int eventNparams = 0;
int eventMaxparams = 0;
- virDomainBlockIoTuneInfoPtr cur_info;
- virDomainBlockIoTuneInfoPtr conf_cur_info;
+ virDomainBlockIoTuneInfo *cur_info;
+ virDomainBlockIoTuneInfo *conf_cur_info;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
int *nparams,
unsigned int flags)
{
- virDomainDiskDefPtr disk;
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainDiskDef *disk;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
virDomainBlockIoTuneInfo reply = {0};
g_autofree char *drivealias = NULL;
const char *qdevid = NULL;
unsigned int nerrors,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
GHashTable *table = NULL;
bool blockdev = false;
int ret = -1;
for (i = n = 0; i < vm->def->ndisks; i++) {
struct qemuDomainDiskInfo *info;
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
const char *entryname = disk->info.alias;
if (blockdev && diskPriv->qomName)
const char *uri,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
int ret = -1;
cfg->configDir, flags);
if (ret == 0) {
- virObjectEventPtr ev = NULL;
+ virObjectEvent *ev = NULL;
ev = virDomainEventMetadataChangeNewFromObj(vm, type, uri);
virObjectEventStateQueue(driver->domainEventState, ev);
}
const char *uri,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = qemuDomainObjFromDomain(dom)))
unsigned int ncpus,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
- virBitmapPtr guestvcpus = NULL;
+ qemuDomainObjPrivate *priv;
+ virBitmap *guestvcpus = NULL;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
static int
-qemuDomainProbeQMPCurrentMachine(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainProbeQMPCurrentMachine(virQEMUDriver *driver,
+ virDomainObj *vm,
bool *wakeupSupported)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorCurrentMachineInfo info = { 0 };
int rv;
/* returns -1 on error, or if query is not supported, 0 if query was successful */
static int
-qemuDomainQueryWakeupSuspendSupport(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainQueryWakeupSuspendSupport(virQEMUDriver *driver,
+ virDomainObj *vm,
bool *wakeupSupported)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_CURRENT_MACHINE))
static int
-qemuDomainPMSuspendAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainPMSuspendAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int target)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int ret = -1;
if (qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) < 0)
unsigned long long duration,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
bool wakeupSupported;
qemuDomainPMWakeup(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virCheckFlags(0, -1);
virDomainPtr **domains,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
int timeout,
unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = domain->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
char *result = NULL;
- qemuAgentPtr agent;
+ qemuAgent *agent;
virCheckFlags(0, NULL);
virFreeCallback freecb,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
int ret = -1;
if (virConnectDomainQemuMonitorEventRegisterEnsureACL(conn) < 0)
qemuConnectDomainQemuMonitorEventDeregister(virConnectPtr conn,
int callbackID)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
if (virConnectDomainQemuMonitorEventDeregisterEnsureACL(conn) < 0)
return -1;
unsigned long long minimum,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuAgent *agent;
int ret = -1;
virCheckFlags(0, -1);
static int
-qemuDomainGetHostnameAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainGetHostnameAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
char **hostname)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int ret = -1;
if (qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_QUERY) < 0)
static int
-qemuDomainGetHostnameLease(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainGetHostnameLease(virQEMUDriver *driver,
+ virDomainObj *vm,
char **hostname)
{
char macaddr[VIR_MAC_STRING_BUFLEN];
for (i = 0; i < vm->def->nnets; i++) {
g_autoptr(virNetwork) network = NULL;
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
if (net->type != VIR_DOMAIN_NET_TYPE_NETWORK)
continue;
qemuDomainGetHostname(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
char *hostname = NULL;
virCheckFlags(VIR_DOMAIN_GET_HOSTNAME_LEASE |
unsigned int *nseconds,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
int ret = -1;
int rv;
static int
-qemuDomainSetTimeAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainSetTimeAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
long long seconds,
unsigned int nseconds,
bool rtcSync)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int ret = -1;
if (qemuDomainObjBeginAgentJob(driver, vm, QEMU_AGENT_JOB_MODIFY) < 0)
unsigned int nseconds,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm;
bool rtcSync = flags & VIR_DOMAIN_TIME_SYNC;
int ret = -1;
int rv;
unsigned int nmountpoints,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
unsigned int nmountpoints,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
const char *virttype_str,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virQEMUCaps) qemuCaps = NULL;
virArch arch;
virDomainVirtType virttype;
static int
-qemuDomainGetStatsState(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsState(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags G_GNUC_UNUSED)
{
if (virTypedParamListAddInt(params, dom->state.state, "state.state") < 0)
typedef struct _virQEMUResctrlMonData virQEMUResctrlMonData;
-typedef virQEMUResctrlMonData *virQEMUResctrlMonDataPtr;
struct _virQEMUResctrlMonData {
char *name;
char *vcpus;
- virResctrlMonitorStatsPtr *stats;
+ virResctrlMonitorStats **stats;
size_t nstats;
};
static void
-qemuDomainFreeResctrlMonData(virQEMUResctrlMonDataPtr resdata)
+qemuDomainFreeResctrlMonData(virQEMUResctrlMonData *resdata)
{
size_t i = 0;
* qemuDomainGetResctrlMonData:
* @dom: Pointer for the domain that the resctrl monitors reside in
* @driver: Pointer to qemu driver
- * @resdata: Pointer of virQEMUResctrlMonDataPtr pointer for receiving the
- * virQEMUResctrlMonDataPtr array. Caller is responsible for
- * freeing the array.
- * @nresdata: Pointer of size_t to report the size virQEMUResctrlMonDataPtr
+ * @resdata: Pointer of virQEMUResctrlMonData * pointer for receiving the
+ * virQEMUResctrlMonData *array. Caller is responsible for
+ * freeing the array.
+ * @nresdata: Pointer of size_t to report the size virQEMUResctrlMonData *
* array to caller. If *@nresdata is not 0, even if function
* returns an error, the caller is also required to call
* qemuDomainFreeResctrlMonData to free each element in the
* Returns -1 on failure, or 0 on success.
*/
static int
-qemuDomainGetResctrlMonData(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virQEMUResctrlMonDataPtr **resdata,
+qemuDomainGetResctrlMonData(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virQEMUResctrlMonData ***resdata,
size_t *nresdata,
virResctrlMonitorType tag)
{
- virDomainResctrlDefPtr resctrl = NULL;
- virQEMUResctrlMonDataPtr res = NULL;
+ virDomainResctrlDef *resctrl = NULL;
+ virQEMUResctrlMonData *res = NULL;
char **features = NULL;
g_autoptr(virCaps) caps = NULL;
size_t i = 0;
resctrl = dom->def->resctrls[i];
for (j = 0; j < resctrl->nmonitors; j++) {
- virDomainResctrlMonDefPtr domresmon = NULL;
- virResctrlMonitorPtr monitor = NULL;
+ virDomainResctrlMonDef *domresmon = NULL;
+ virResctrlMonitor *monitor = NULL;
domresmon = resctrl->monitors[j];
monitor = domresmon->instance;
static int
-qemuDomainGetStatsMemoryBandwidth(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params)
+qemuDomainGetStatsMemoryBandwidth(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params)
{
- virQEMUResctrlMonDataPtr *resdata = NULL;
+ virQEMUResctrlMonData **resdata = NULL;
char **features = NULL;
size_t nresdata = 0;
size_t i = 0;
static int
-qemuDomainGetStatsCpuCache(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params)
+qemuDomainGetStatsCpuCache(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params)
{
- virQEMUResctrlMonDataPtr *resdata = NULL;
+ virQEMUResctrlMonData **resdata = NULL;
size_t nresdata = 0;
size_t i = 0;
size_t j = 0;
static int
-qemuDomainGetStatsCpuCgroup(virDomainObjPtr dom,
- virTypedParamListPtr params)
+qemuDomainGetStatsCpuCgroup(virDomainObj *dom,
+ virTypedParamList *params)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
unsigned long long cpu_time = 0;
unsigned long long user_time = 0;
unsigned long long sys_time = 0;
static int
-qemuDomainGetStatsCpu(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsCpu(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags G_GNUC_UNUSED)
{
if (qemuDomainGetStatsCpuCgroup(dom, params) < 0)
static int
-qemuDomainGetStatsMemory(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsMemory(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags G_GNUC_UNUSED)
{
static int
-qemuDomainGetStatsBalloon(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsBalloon(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags)
{
virDomainMemoryStatStruct stats[VIR_DOMAIN_MEMORY_STAT_NR];
static int
-qemuDomainGetStatsVcpu(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsVcpu(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags)
{
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
size_t i;
int ret = -1;
virVcpuInfoPtr cpuinfo = NULL;
return -1;
static int
-qemuDomainGetStatsInterface(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsInterface(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags G_GNUC_UNUSED)
{
size_t i;
/* Check the path is one of the domain's network interfaces. */
for (i = 0; i < dom->def->nnets; i++) {
- virDomainNetDefPtr net = dom->def->nets[i];
+ virDomainNetDef *net = dom->def->nets[i];
virDomainNetType actualType;
if (!net->ifname)
/* refresh information by opening images on the disk */
static int
-qemuDomainGetStatsOneBlockFallback(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
- virStorageSourcePtr src,
+qemuDomainGetStatsOneBlockFallback(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *dom,
+ virTypedParamList *params,
+ virStorageSource *src,
size_t block_idx)
{
if (virStorageSourceIsEmpty(src))
* @stats: hash table containing stats for all disks
* @nodedata: reply containing 'query-named-block-nodes' data
*
- * Refresh disk block stats data (qemuBlockStatsPtr) which are present only
+ * Refresh disk block stats data (qemuBlockStats *) which are present only
* in the reply of 'query-named-block-nodes' in cases when the data was gathered
* by using query-block originally.
*/
static void
-qemuDomainGetStatsOneBlockRefreshNamed(virStorageSourcePtr src,
+qemuDomainGetStatsOneBlockRefreshNamed(virStorageSource *src,
const char *alias,
GHashTable *stats,
GHashTable *nodedata)
{
- qemuBlockStatsPtr entry;
+ qemuBlockStats *entry;
- virJSONValuePtr data;
+ virJSONValue *data;
unsigned long long tmp;
if (!nodedata || !src->nodestorage)
static int
-qemuDomainGetStatsOneBlock(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsOneBlock(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *dom,
+ virTypedParamList *params,
const char *entryname,
- virStorageSourcePtr src,
+ virStorageSource *src,
size_t block_idx,
GHashTable *stats)
{
qemuDomainGetStatsBlockExportBackendStorage(const char *entryname,
GHashTable *stats,
size_t recordnr,
- virTypedParamListPtr params)
+ virTypedParamList *params)
{
qemuBlockStats *entry;
qemuDomainGetStatsBlockExportFrontend(const char *frontendname,
GHashTable *stats,
size_t idx,
- virTypedParamListPtr par)
+ virTypedParamList *par)
{
qemuBlockStats *en;
static int
-qemuDomainGetStatsBlockExportHeader(virDomainDiskDefPtr disk,
- virStorageSourcePtr src,
+qemuDomainGetStatsBlockExportHeader(virDomainDiskDef *disk,
+ virStorageSource *src,
size_t recordnr,
- virTypedParamListPtr params)
+ virTypedParamList *params)
{
if (virTypedParamListAddString(params, disk->dst, "block.%zu.name", recordnr) < 0)
return -1;
static int
-qemuDomainGetStatsBlockExportDisk(virDomainDiskDefPtr disk,
+qemuDomainGetStatsBlockExportDisk(virDomainDiskDef *disk,
GHashTable *stats,
GHashTable *nodestats,
- virTypedParamListPtr params,
+ virTypedParamList *params,
size_t *recordnr,
bool visitBacking,
- virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr dom,
+ virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *dom,
bool blockdev)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
const char *frontendalias;
const char *backendalias;
const char *backendstoragealias;
static int
-qemuDomainGetStatsBlock(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsBlock(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags)
{
size_t i;
int rc;
GHashTable *stats = NULL;
GHashTable *nodestats = NULL;
- virJSONValuePtr nodedata = NULL;
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ virJSONValue *nodedata = NULL;
+ qemuDomainObjPrivate *priv = dom->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
bool fetchnodedata = virQEMUCapsGet(priv->qemuCaps,
static int
-qemuDomainGetStatsIOThread(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsIOThread(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
size_t i;
- qemuMonitorIOThreadInfoPtr *iothreads = NULL;
+ qemuMonitorIOThreadInfo **iothreads = NULL;
int niothreads = 0;
int ret = -1;
static int
-qemuDomainGetStatsPerfOneEvent(virPerfPtr perf,
+qemuDomainGetStatsPerfOneEvent(virPerf *perf,
virPerfEventType type,
- virTypedParamListPtr params)
+ virTypedParamList *params)
{
uint64_t value = 0;
}
static int
-qemuDomainGetStatsPerf(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
+qemuDomainGetStatsPerf(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *dom,
+ virTypedParamList *params,
unsigned int privflags G_GNUC_UNUSED)
{
size_t i;
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
for (i = 0; i < VIR_PERF_EVENT_LAST; i++) {
if (!virPerfEventIsEnabled(priv->perf, i))
}
static int
-qemuDomainGetStatsDirtyRateMon(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMonitorDirtyRateInfoPtr info)
+qemuDomainGetStatsDirtyRateMon(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMonitorDirtyRateInfo *info)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
qemuDomainObjEnterMonitor(driver, vm);
}
static int
-qemuDomainGetStatsDirtyRate(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr params,
- unsigned int privflags)
+qemuDomainGetStatsDirtyRate(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *params,
+ unsigned int privflags)
{
qemuMonitorDirtyRateInfo info;
}
typedef int
-(*qemuDomainGetStatsFunc)(virQEMUDriverPtr driver,
- virDomainObjPtr dom,
- virTypedParamListPtr list,
+(*qemuDomainGetStatsFunc)(virQEMUDriver *driver,
+ virDomainObj *dom,
+ virTypedParamList *list,
unsigned int flags);
struct qemuDomainGetStatsWorker {
static int
qemuDomainGetStats(virConnectPtr conn,
- virDomainObjPtr dom,
+ virDomainObj *dom,
unsigned int stats,
virDomainStatsRecordPtr *record,
unsigned int flags)
virDomainStatsRecordPtr **retStats,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
virErrorPtr orig_err = NULL;
- virDomainObjPtr *vms = NULL;
- virDomainObjPtr vm;
+ virDomainObj **vms = NULL;
+ virDomainObj *vm;
size_t nvms;
virDomainStatsRecordPtr *tmpstats = NULL;
bool enforce = !!(flags & VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS);
}
static int
-qemuDomainGetFSInfoAgent(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuAgentFSInfoPtr **info)
+qemuDomainGetFSInfoAgent(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuAgentFSInfo ***info)
{
int ret = -1;
- qemuAgentPtr agent;
+ qemuAgent *agent;
if (qemuDomainObjBeginAgentJob(driver, vm,
QEMU_AGENT_JOB_QUERY) < 0)
}
static virDomainFSInfoPtr
-qemuAgentFSInfoToPublic(qemuAgentFSInfoPtr agent,
- virDomainDefPtr vmdef)
+qemuAgentFSInfoToPublic(qemuAgentFSInfo *agent,
+ virDomainDef *vmdef)
{
virDomainFSInfoPtr ret = NULL;
size_t i;
ret->devAlias = g_new0(char *, agent->ndisks);
for (i = 0; i < agent->ndisks; i++) {
- qemuAgentDiskAddressPtr agentdisk = agent->disks[i];
- virDomainDiskDefPtr diskDef;
+ qemuAgentDiskAddress *agentdisk = agent->disks[i];
+ virDomainDiskDef *diskDef;
diskDef = virDomainDiskByAddress(vmdef,
&agentdisk->pci_controller,
* -1 otherwise
*/
static int
-virDomainFSInfoFormat(qemuAgentFSInfoPtr *agentinfo,
+virDomainFSInfoFormat(qemuAgentFSInfo **agentinfo,
int nagentinfo,
- virDomainDefPtr vmdef,
+ virDomainDef *vmdef,
virDomainFSInfoPtr **info)
{
int ret = -1;
virDomainFSInfoPtr **info,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuAgentFSInfoPtr *agentinfo = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuAgentFSInfo **agentinfo = NULL;
int ret = -1;
int nfs = 0;
unsigned int source,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
int ret = -1;
virCheckFlags(0, -1);
const char *password,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm;
+ qemuAgent *agent;
int ret = -1;
int rv;
struct qemuDomainMomentWriteMetadataData {
- virQEMUDriverPtr driver;
- virDomainObjPtr vm;
+ virQEMUDriver *driver;
+ virDomainObj *vm;
};
void *opaque)
{
struct qemuDomainMomentWriteMetadataData *data = opaque;
- virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(data->driver);
+ virQEMUDriverConfig *cfg = virQEMUDriverGetConfig(data->driver);
int ret;
ret = qemuDomainSnapshotWriteMetadata(data->vm, payload,
void *opaque)
{
struct qemuDomainMomentWriteMetadataData *data = opaque;
- virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(data->driver);
+ virQEMUDriverConfig *cfg = virQEMUDriverGetConfig(data->driver);
int ret;
ret = qemuCheckpointWriteMetadata(data->vm, payload,
static int
-qemuDomainRenameCallback(virDomainObjPtr vm,
+qemuDomainRenameCallback(virDomainObj *vm,
const char *new_name,
unsigned int flags,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virObjectEventPtr event_new = NULL;
- virObjectEventPtr event_old = NULL;
+ virObjectEvent *event_new = NULL;
+ virObjectEvent *event_old = NULL;
int ret = -1;
virErrorPtr err = NULL;
g_autofree char *new_dom_name = NULL;
const char *new_name,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, ret);
static int
qemuDomainGetGuestVcpusParams(virTypedParameterPtr *params,
unsigned int *nparams,
- qemuAgentCPUInfoPtr info,
+ qemuAgentCPUInfo *info,
int ninfo)
{
virTypedParameterPtr par = NULL;
int npar = 0;
int maxpar = 0;
- virBitmapPtr vcpus = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
- virBitmapPtr online = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
- virBitmapPtr offlinable = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
+ virBitmap *vcpus = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
+ virBitmap *online = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
+ virBitmap *offlinable = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
g_autofree char *tmp = NULL;
size_t i;
int ret = -1;
unsigned int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
- qemuAgentCPUInfoPtr info = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
+ qemuAgentCPUInfo *info = NULL;
int ninfo = 0;
int ret = -1;
int state,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virBitmapPtr map = NULL;
- qemuAgentCPUInfoPtr info = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virBitmap *map = NULL;
+ qemuAgentCPUInfo *info = NULL;
+ qemuAgent *agent;
int ninfo = 0;
size_t i;
int ret = -1;
int state,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
- virBitmapPtr map = NULL;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
+ virBitmap *map = NULL;
ssize_t lastvcpu;
int ret = -1;
unsigned long long threshold,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm = NULL;
- virStorageSourcePtr src;
+ virQEMUDriver *driver = dom->conn->privateData;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm = NULL;
+ virStorageSource *src;
g_autofree char *nodename = NULL;
int rc;
int ret = -1;
static void
-qemuDomainModifyLifecycleAction(virDomainDefPtr def,
+qemuDomainModifyLifecycleAction(virDomainDef *def,
virDomainLifecycle type,
virDomainLifecycleAction action)
{
unsigned int action,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ qemuDomainObjPrivate *priv;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
static int
-qemuGetSEVInfoToParams(virQEMUCapsPtr qemuCaps,
+qemuGetSEVInfoToParams(virQEMUCaps *qemuCaps,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
{
int maxpar = 0;
int n = 0;
- virSEVCapabilityPtr sev = virQEMUCapsGetSEVCapabilities(qemuCaps);
+ virSEVCapability *sev = virQEMUCapsGetSEVCapabilities(qemuCaps);
virTypedParameterPtr sevParams = NULL;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virQEMUCaps) qemucaps = NULL;
if (virNodeGetSevInfoEnsureACL(conn) < 0)
static int
-qemuDomainGetSEVMeasurement(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainGetSEVMeasurement(virQEMUDriver *driver,
+ virDomainObj *vm,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr vm;
+ virQEMUDriver *driver = domain->conn->privateData;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = qemuDomainObjFromDomain(domain)))
static void
-qemuAgentDiskInfoFormatParams(qemuAgentDiskInfoPtr *info,
+qemuAgentDiskInfoFormatParams(qemuAgentDiskInfo **info,
int ndisks,
- virDomainDefPtr vmdef,
+ virDomainDef *vmdef,
virTypedParameterPtr *params,
int *nparams, int *maxparams)
{
}
if (info[i]->address) {
- virDomainDiskDefPtr diskdef = NULL;
+ virDomainDiskDef *diskdef = NULL;
/* match the disk to the target in the vm definition */
diskdef = virDomainDiskByAddress(vmdef,
static void
-qemuAgentFSInfoFormatParams(qemuAgentFSInfoPtr *fsinfo,
+qemuAgentFSInfoFormatParams(qemuAgentFSInfo **fsinfo,
int nfs,
- virDomainDefPtr vmdef,
+ virDomainDef *vmdef,
virTypedParameterPtr *params,
int *nparams, int *maxparams)
{
param_name, fsinfo[i]->ndisks) < 0)
return;
for (j = 0; j < fsinfo[i]->ndisks; j++) {
- virDomainDiskDefPtr diskdef = NULL;
- qemuAgentDiskAddressPtr d = fsinfo[i]->disks[j];
+ virDomainDiskDef *diskdef = NULL;
+ qemuAgentDiskAddress *d = fsinfo[i]->disks[j];
/* match the disk to the target in the vm definition */
diskdef = virDomainDiskByAddress(vmdef,
&d->pci_controller,
int *nparams,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
int ret = -1;
int maxparams = 0;
g_autofree char *hostname = NULL;
bool report_unsupported = types != 0;
int rc;
size_t nfs = 0;
- qemuAgentFSInfoPtr *agentfsinfo = NULL;
+ qemuAgentFSInfo **agentfsinfo = NULL;
size_t ndisks = 0;
- qemuAgentDiskInfoPtr *agentdiskinfo = NULL;
+ qemuAgentDiskInfo **agentdiskinfo = NULL;
size_t i;
virCheckFlags(0, -1);
int timeout,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
+ virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
char ***keys,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
int rv = -1;
virCheckFlags(0, -1);
unsigned int nkeys,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- qemuAgentPtr agent;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuAgent *agent;
const bool append = flags & VIR_DOMAIN_AUTHORIZED_SSH_KEYS_SET_APPEND;
const bool remove = flags & VIR_DOMAIN_AUTHORIZED_SSH_KEYS_SET_REMOVE;
int rv = -1;
char ***msgs,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int rv = -1;
size_t i, n;
int nmsgs;
int seconds,
unsigned int flags)
{
- virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ qemuDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(0, -1);
VIR_LOG_INIT("qemu.qemu_extdevice");
int
-qemuExtDeviceLogCommand(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+qemuExtDeviceLogCommand(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
const char *info)
{
g_autofree char *timestamp = virTimeStringNow();
* changes.
*/
static int
-qemuExtDevicesInitPaths(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuExtDevicesInitPaths(virQEMUDriver *driver,
+ virDomainDef *def)
{
if (def->ntpms > 0)
return qemuExtTPMInitPaths(driver, def);
* Code that modifies live XML of a domain which is about to start.
*/
int
-qemuExtDevicesPrepareDomain(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuExtDevicesPrepareDomain(virQEMUDriver *driver,
+ virDomainObj *vm)
{
int ret = 0;
size_t i;
for (i = 0; i < vm->def->nvideos; i++) {
- virDomainVideoDefPtr video = vm->def->videos[i];
+ virDomainVideoDef *video = vm->def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
if ((ret = qemuExtVhostUserGPUPrepareDomain(driver, video)) < 0)
}
for (i = 0; i < vm->def->nfss; i++) {
- virDomainFSDefPtr fs = vm->def->fss[i];
+ virDomainFSDef *fs = vm->def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS) {
if (qemuVirtioFSPrepareDomain(driver, fs) < 0)
* Prepare host storage paths for external devices.
*/
int
-qemuExtDevicesPrepareHost(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuExtDevicesPrepareHost(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
size_t i;
if (qemuExtDevicesInitPaths(driver, def) < 0)
return -1;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
- qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
+ virDomainNetDef *net = def->nets[i];
+ qemuSlirp *slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp && qemuSlirpOpen(slirp, driver, def) < 0)
return -1;
void
-qemuExtDevicesCleanupHost(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuExtDevicesCleanupHost(virQEMUDriver *driver,
+ virDomainDef *def)
{
if (qemuExtDevicesInitPaths(driver, def) < 0)
return;
int
-qemuExtDevicesStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virLogManagerPtr logManager,
+qemuExtDevicesStart(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virLogManager *logManager,
bool incomingMigration)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
size_t i;
for (i = 0; i < def->nvideos; i++) {
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
if (qemuExtVhostUserGPUStart(driver, vm, video) < 0)
return -1;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
- qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
+ virDomainNetDef *net = def->nets[i];
+ qemuSlirp *slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp &&
qemuSlirpStart(slirp, vm, driver, net, incomingMigration) < 0)
}
for (i = 0; i < def->nfss; i++) {
- virDomainFSDefPtr fs = def->fss[i];
+ virDomainFSDef *fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS) {
if (qemuVirtioFSStart(logManager, driver, vm, fs) < 0)
void
-qemuExtDevicesStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuExtDevicesStop(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
size_t i;
if (qemuExtDevicesInitPaths(driver, def) < 0)
return;
for (i = 0; i < def->nvideos; i++) {
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER)
qemuExtVhostUserGPUStop(driver, vm, video);
qemuExtTPMStop(driver, vm);
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
virDomainNetType actualType = virDomainNetGetActualType(net);
- qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
+ qemuSlirp *slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp)
qemuSlirpStop(slirp, vm, driver, net);
}
for (i = 0; i < def->nfss; i++) {
- virDomainFSDefPtr fs = def->fss[i];
+ virDomainFSDef *fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS)
qemuVirtioFSStop(driver, vm, fs);
bool
-qemuExtDevicesHasDevice(virDomainDefPtr def)
+qemuExtDevicesHasDevice(virDomainDef *def)
{
size_t i;
}
for (i = 0; i < def->nfss; i++) {
- virDomainFSDefPtr fs = def->fss[i];
+ virDomainFSDef *fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS)
return true;
int
-qemuExtDevicesSetupCgroup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCgroupPtr cgroup)
+qemuExtDevicesSetupCgroup(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCgroup *cgroup)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
size_t i;
if (qemuDBusSetupCgroup(driver, vm, cgroup) < 0)
return -1;
for (i = 0; i < def->nvideos; i++) {
- virDomainVideoDefPtr video = def->videos[i];
+ virDomainVideoDef *video = def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER &&
qemuExtVhostUserGPUSetupCgroup(driver, def, video, cgroup) < 0)
}
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
- qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
+ virDomainNetDef *net = def->nets[i];
+ qemuSlirp *slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp && qemuSlirpSetupCgroup(slirp, cgroup) < 0)
return -1;
return -1;
for (i = 0; i < def->nfss; i++) {
- virDomainFSDefPtr fs = def->fss[i];
+ virDomainFSDef *fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS &&
qemuVirtioFSSetupCgroup(vm, fs, cgroup) < 0)
#include "qemu_conf.h"
#include "qemu_domain.h"
-int qemuExtDeviceLogCommand(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+int qemuExtDeviceLogCommand(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
const char *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuExtDevicesPrepareDomain(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+int qemuExtDevicesPrepareDomain(virQEMUDriver *driver,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuExtDevicesPrepareHost(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+int qemuExtDevicesPrepareHost(virQEMUDriver *driver,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuExtDevicesCleanupHost(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+void qemuExtDevicesCleanupHost(virQEMUDriver *driver,
+ virDomainDef *def)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuExtDevicesStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virLogManagerPtr logManager,
+int qemuExtDevicesStart(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virLogManager *logManager,
bool incomingMigration)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuExtDevicesStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+void qemuExtDevicesStop(virQEMUDriver *driver,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-bool qemuExtDevicesHasDevice(virDomainDefPtr def);
+bool qemuExtDevicesHasDevice(virDomainDef *def);
-int qemuExtDevicesSetupCgroup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCgroupPtr cgroup);
+int qemuExtDevicesSetupCgroup(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCgroup *cgroup);
typedef struct _qemuFirmwareFlashFile qemuFirmwareFlashFile;
-typedef qemuFirmwareFlashFile *qemuFirmwareFlashFilePtr;
struct _qemuFirmwareFlashFile {
char *filename;
char *format;
typedef struct _qemuFirmwareMappingFlash qemuFirmwareMappingFlash;
-typedef qemuFirmwareMappingFlash *qemuFirmwareMappingFlashPtr;
struct _qemuFirmwareMappingFlash {
qemuFirmwareFlashFile executable;
qemuFirmwareFlashFile nvram_template;
typedef struct _qemuFirmwareMappingKernel qemuFirmwareMappingKernel;
-typedef qemuFirmwareMappingKernel *qemuFirmwareMappingKernelPtr;
struct _qemuFirmwareMappingKernel {
char *filename;
};
typedef struct _qemuFirmwareMappingMemory qemuFirmwareMappingMemory;
-typedef qemuFirmwareMappingMemory *qemuFirmwareMappingMemoryPtr;
struct _qemuFirmwareMappingMemory {
char *filename;
};
typedef struct _qemuFirmwareMapping qemuFirmwareMapping;
-typedef qemuFirmwareMapping *qemuFirmwareMappingPtr;
struct _qemuFirmwareMapping {
qemuFirmwareDevice device;
typedef struct _qemuFirmwareTarget qemuFirmwareTarget;
-typedef qemuFirmwareTarget *qemuFirmwareTargetPtr;
struct _qemuFirmwareTarget {
virArch architecture;
size_t nmachines;
qemuFirmwareMapping mapping;
size_t ntargets;
- qemuFirmwareTargetPtr *targets;
+ qemuFirmwareTarget **targets;
size_t nfeatures;
qemuFirmwareFeature *features;
static void
-qemuFirmwareFlashFileFreeContent(qemuFirmwareFlashFilePtr flash)
+qemuFirmwareFlashFileFreeContent(qemuFirmwareFlashFile *flash)
{
g_free(flash->filename);
g_free(flash->format);
static void
-qemuFirmwareMappingFlashFreeContent(qemuFirmwareMappingFlashPtr flash)
+qemuFirmwareMappingFlashFreeContent(qemuFirmwareMappingFlash *flash)
{
qemuFirmwareFlashFileFreeContent(&flash->executable);
qemuFirmwareFlashFileFreeContent(&flash->nvram_template);
static void
-qemuFirmwareMappingKernelFreeContent(qemuFirmwareMappingKernelPtr kernel)
+qemuFirmwareMappingKernelFreeContent(qemuFirmwareMappingKernel *kernel)
{
g_free(kernel->filename);
}
static void
-qemuFirmwareMappingMemoryFreeContent(qemuFirmwareMappingMemoryPtr memory)
+qemuFirmwareMappingMemoryFreeContent(qemuFirmwareMappingMemory *memory)
{
g_free(memory->filename);
}
static void
-qemuFirmwareMappingFreeContent(qemuFirmwareMappingPtr mapping)
+qemuFirmwareMappingFreeContent(qemuFirmwareMapping *mapping)
{
switch (mapping->device) {
case QEMU_FIRMWARE_DEVICE_FLASH:
static void
-qemuFirmwareTargetFree(qemuFirmwareTargetPtr target)
+qemuFirmwareTargetFree(qemuFirmwareTarget *target)
{
if (!target)
return;
void
-qemuFirmwareFree(qemuFirmwarePtr fw)
+qemuFirmwareFree(qemuFirmware *fw)
{
size_t i;
static int
qemuFirmwareInterfaceParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+ virJSONValue *doc,
+ qemuFirmware *fw)
{
- virJSONValuePtr interfacesJSON;
+ virJSONValue *interfacesJSON;
g_autoptr(qemuFirmwareOSInterface) interfaces = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t ninterfaces;
interfaces = g_new0(qemuFirmwareOSInterface, ninterfaces);
for (i = 0; i < ninterfaces; i++) {
- virJSONValuePtr item = virJSONValueArrayGet(interfacesJSON, i);
+ virJSONValue *item = virJSONValueArrayGet(interfacesJSON, i);
const char *tmpStr = virJSONValueGetString(item);
int tmp;
static int
qemuFirmwareFlashFileParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwareFlashFilePtr flash)
+ virJSONValue *doc,
+ qemuFirmwareFlashFile *flash)
{
const char *filename;
const char *format;
static int
qemuFirmwareMappingFlashParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwareMappingFlashPtr flash)
+ virJSONValue *doc,
+ qemuFirmwareMappingFlash *flash)
{
- virJSONValuePtr executable;
- virJSONValuePtr nvram_template;
+ virJSONValue *executable;
+ virJSONValue *nvram_template;
if (!(executable = virJSONValueObjectGet(doc, "executable"))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static int
qemuFirmwareMappingKernelParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwareMappingKernelPtr kernel)
+ virJSONValue *doc,
+ qemuFirmwareMappingKernel *kernel)
{
const char *filename;
static int
qemuFirmwareMappingMemoryParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwareMappingMemoryPtr memory)
+ virJSONValue *doc,
+ qemuFirmwareMappingMemory *memory)
{
const char *filename;
static int
qemuFirmwareMappingParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+ virJSONValue *doc,
+ qemuFirmware *fw)
{
- virJSONValuePtr mapping;
+ virJSONValue *mapping;
const char *deviceStr;
int tmp;
static int
qemuFirmwareTargetParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+ virJSONValue *doc,
+ qemuFirmware *fw)
{
- virJSONValuePtr targetsJSON;
- qemuFirmwareTargetPtr *targets = NULL;
+ virJSONValue *targetsJSON;
+ qemuFirmwareTarget **targets = NULL;
size_t ntargets;
size_t i;
int ret = -1;
ntargets = virJSONValueArraySize(targetsJSON);
- targets = g_new0(qemuFirmwareTargetPtr, ntargets);
+ targets = g_new0(qemuFirmwareTarget *, ntargets);
for (i = 0; i < ntargets; i++) {
- virJSONValuePtr item = virJSONValueArrayGet(targetsJSON, i);
- virJSONValuePtr machines;
+ virJSONValue *item = virJSONValueArrayGet(targetsJSON, i);
+ virJSONValue *machines;
g_autoptr(qemuFirmwareTarget) t = NULL;
const char *architectureStr = NULL;
size_t nmachines;
t->machines = g_new0(char *, nmachines);
for (j = 0; j < nmachines; j++) {
- virJSONValuePtr machine = virJSONValueArrayGet(machines, j);
+ virJSONValue *machine = virJSONValueArrayGet(machines, j);
g_autofree char *machineStr = NULL;
machineStr = g_strdup(virJSONValueGetString(machine));
static int
qemuFirmwareFeatureParse(const char *path,
- virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+ virJSONValue *doc,
+ qemuFirmware *fw)
{
- virJSONValuePtr featuresJSON;
+ virJSONValue *featuresJSON;
g_autoptr(qemuFirmwareFeature) features = NULL;
size_t nfeatures;
size_t i;
features = g_new0(qemuFirmwareFeature, nfeatures);
for (i = 0; i < nfeatures; i++) {
- virJSONValuePtr item = virJSONValueArrayGet(featuresJSON, i);
+ virJSONValue *item = virJSONValueArrayGet(featuresJSON, i);
const char *tmpStr = virJSONValueGetString(item);
int tmp;
/* 1MiB should be enough for everybody (TM) */
#define DOCUMENT_SIZE (1024 * 1024)
-qemuFirmwarePtr
+qemuFirmware *
qemuFirmwareParse(const char *path)
{
g_autofree char *cont = NULL;
static int
-qemuFirmwareInterfaceFormat(virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+qemuFirmwareInterfaceFormat(virJSONValue *doc,
+ qemuFirmware *fw)
{
g_autoptr(virJSONValue) interfacesJSON = NULL;
size_t i;
}
-static virJSONValuePtr
+static virJSONValue *
qemuFirmwareFlashFileFormat(qemuFirmwareFlashFile flash)
{
g_autoptr(virJSONValue) json = virJSONValueNewObject();
- virJSONValuePtr ret;
+ virJSONValue *ret;
if (virJSONValueObjectAppendString(json,
"filename",
static int
-qemuFirmwareMappingFlashFormat(virJSONValuePtr mapping,
- qemuFirmwareMappingFlashPtr flash)
+qemuFirmwareMappingFlashFormat(virJSONValue *mapping,
+ qemuFirmwareMappingFlash *flash)
{
g_autoptr(virJSONValue) executable = NULL;
g_autoptr(virJSONValue) nvram_template = NULL;
static int
-qemuFirmwareMappingKernelFormat(virJSONValuePtr mapping,
- qemuFirmwareMappingKernelPtr kernel)
+qemuFirmwareMappingKernelFormat(virJSONValue *mapping,
+ qemuFirmwareMappingKernel *kernel)
{
if (virJSONValueObjectAppendString(mapping,
"filename",
static int
-qemuFirmwareMappingMemoryFormat(virJSONValuePtr mapping,
- qemuFirmwareMappingMemoryPtr memory)
+qemuFirmwareMappingMemoryFormat(virJSONValue *mapping,
+ qemuFirmwareMappingMemory *memory)
{
if (virJSONValueObjectAppendString(mapping,
"filename",
static int
-qemuFirmwareMappingFormat(virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+qemuFirmwareMappingFormat(virJSONValue *doc,
+ qemuFirmware *fw)
{
g_autoptr(virJSONValue) mapping = virJSONValueNewObject();
static int
-qemuFirmwareTargetFormat(virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+qemuFirmwareTargetFormat(virJSONValue *doc,
+ qemuFirmware *fw)
{
g_autoptr(virJSONValue) targetsJSON = NULL;
size_t i;
targetsJSON = virJSONValueNewArray();
for (i = 0; i < fw->ntargets; i++) {
- qemuFirmwareTargetPtr t = fw->targets[i];
+ qemuFirmwareTarget *t = fw->targets[i];
g_autoptr(virJSONValue) target = virJSONValueNewObject();
g_autoptr(virJSONValue) machines = NULL;
size_t j;
static int
-qemuFirmwareFeatureFormat(virJSONValuePtr doc,
- qemuFirmwarePtr fw)
+qemuFirmwareFeatureFormat(virJSONValue *doc,
+ qemuFirmware *fw)
{
g_autoptr(virJSONValue) featuresJSON = NULL;
size_t i;
char *
-qemuFirmwareFormat(qemuFirmwarePtr fw)
+qemuFirmwareFormat(qemuFirmware *fw)
{
g_autoptr(virJSONValue) doc = virJSONValueNewObject();
static int
-qemuFirmwareEnableFeatures(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+qemuFirmwareEnableFeatures(virQEMUDriver *driver,
+ virDomainDef *def,
const qemuFirmware *fw)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static ssize_t
qemuFirmwareFetchParsedConfigs(bool privileged,
- qemuFirmwarePtr **firmwaresRet,
+ qemuFirmware ***firmwaresRet,
char ***pathsRet)
{
g_auto(GStrv) paths = NULL;
size_t npaths;
- qemuFirmwarePtr *firmwares = NULL;
+ qemuFirmware **firmwares = NULL;
size_t i;
if (qemuFirmwareFetchConfigs(&paths, privileged) < 0)
npaths = g_strv_length(paths);
- firmwares = g_new0(qemuFirmwarePtr, npaths);
+ firmwares = g_new0(qemuFirmware *, npaths);
for (i = 0; i < npaths; i++) {
if (!(firmwares[i] = qemuFirmwareParse(paths[i])))
int
-qemuFirmwareFillDomain(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+qemuFirmwareFillDomain(virQEMUDriver *driver,
+ virDomainDef *def,
unsigned int flags)
{
g_auto(GStrv) paths = NULL;
- qemuFirmwarePtr *firmwares = NULL;
+ qemuFirmware **firmwares = NULL;
ssize_t nfirmwares = 0;
const qemuFirmware *theone = NULL;
bool needResult = true;
bool privileged,
uint64_t *supported,
bool *secure,
- virFirmwarePtr **fws,
+ virFirmware ***fws,
size_t *nfws)
{
- qemuFirmwarePtr *firmwares = NULL;
+ qemuFirmware **firmwares = NULL;
ssize_t nfirmwares = 0;
size_t i;
return -1;
for (i = 0; i < nfirmwares; i++) {
- qemuFirmwarePtr fw = firmwares[i];
+ qemuFirmware *fw = firmwares[i];
const qemuFirmwareMappingFlash *flash = &fw->mapping.data.flash;
const qemuFirmwareMappingMemory *memory = &fw->mapping.data.memory;
const char *fwpath = NULL;
#include "virfirmware.h"
typedef struct _qemuFirmware qemuFirmware;
-typedef qemuFirmware *qemuFirmwarePtr;
void
-qemuFirmwareFree(qemuFirmwarePtr fw);
+qemuFirmwareFree(qemuFirmware *fw);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuFirmware, qemuFirmwareFree);
-qemuFirmwarePtr
+qemuFirmware *
qemuFirmwareParse(const char *path);
char *
-qemuFirmwareFormat(qemuFirmwarePtr fw);
+qemuFirmwareFormat(qemuFirmware *fw);
int
qemuFirmwareFetchConfigs(char ***firmwares,
bool privileged);
int
-qemuFirmwareFillDomain(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+qemuFirmwareFillDomain(virQEMUDriver *driver,
+ virDomainDef *def,
unsigned int flags);
int
bool privileged,
uint64_t *supported,
bool *secure,
- virFirmwarePtr **fws,
+ virFirmware ***fws,
size_t *nfws);
G_STATIC_ASSERT(VIR_DOMAIN_OS_DEF_FIRMWARE_LAST <= 64);
int
-qemuHostdevUpdateActivePCIDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActivePCIDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
- virHostdevManagerPtr mgr = driver->hostdevMgr;
+ virHostdevManager *mgr = driver->hostdevMgr;
if (!def->nhostdevs)
return 0;
}
int
-qemuHostdevUpdateActiveUSBDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActiveUSBDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
- virHostdevManagerPtr mgr = driver->hostdevMgr;
+ virHostdevManager *mgr = driver->hostdevMgr;
if (!def->nhostdevs)
return 0;
}
int
-qemuHostdevUpdateActiveSCSIDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActiveSCSIDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
- virHostdevManagerPtr mgr = driver->hostdevMgr;
+ virHostdevManager *mgr = driver->hostdevMgr;
if (!def->nhostdevs)
return 0;
int
-qemuHostdevUpdateActiveMediatedDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActiveMediatedDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
- virHostdevManagerPtr mgr = driver->hostdevMgr;
+ virHostdevManager *mgr = driver->hostdevMgr;
if (!def->nhostdevs)
return 0;
int
-qemuHostdevUpdateActiveNVMeDisks(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActiveNVMeDisks(virQEMUDriver *driver,
+ virDomainDef *def)
{
return virHostdevUpdateActiveNVMeDevices(driver->hostdevMgr,
QEMU_DRIVER_NAME,
int
-qemuHostdevUpdateActiveDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevUpdateActiveDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
if (!def->nhostdevs && !def->ndisks)
return 0;
static bool
-qemuHostdevPreparePCIDevicesCheckSupport(virDomainHostdevDefPtr *hostdevs,
+qemuHostdevPreparePCIDevicesCheckSupport(virDomainHostdevDef **hostdevs,
size_t nhostdevs,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
bool supportsPassthroughVFIO = qemuHostdevHostSupportsPassthroughVFIO();
size_t i;
/* assign defaults for hostdev passthrough */
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virDomainHostdevDef *hostdev = hostdevs[i];
int *backend = &hostdev->source.subsys.u.pci.backend;
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
}
int
-qemuHostdevPrepareOneNVMeDisk(virQEMUDriverPtr driver,
+qemuHostdevPrepareOneNVMeDisk(virQEMUDriver *driver,
const char *name,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
return virHostdevPrepareOneNVMeDevice(driver->hostdevMgr,
QEMU_DRIVER_NAME,
}
int
-qemuHostdevPrepareNVMeDisks(virQEMUDriverPtr driver,
+qemuHostdevPrepareNVMeDisks(virQEMUDriver *driver,
const char *name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks)
{
return virHostdevPrepareNVMeDevices(driver->hostdevMgr,
}
int
-qemuHostdevPreparePCIDevices(virQEMUDriverPtr driver,
+qemuHostdevPreparePCIDevices(virQEMUDriver *driver,
const char *name,
const unsigned char *uuid,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int flags)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
if (!qemuHostdevPreparePCIDevicesCheckSupport(hostdevs, nhostdevs, qemuCaps))
return -1;
}
int
-qemuHostdevPrepareUSBDevices(virQEMUDriverPtr driver,
+qemuHostdevPrepareUSBDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
return virHostdevPrepareUSBDevices(hostdev_mgr, QEMU_DRIVER_NAME, name,
hostdevs, nhostdevs, flags);
}
int
-qemuHostdevPrepareSCSIDevices(virQEMUDriverPtr driver,
+qemuHostdevPrepareSCSIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
/* Loop 1: Add the shared scsi host device to shared device
* table.
}
int
-qemuHostdevPrepareSCSIVHostDevices(virQEMUDriverPtr driver,
+qemuHostdevPrepareSCSIVHostDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
return virHostdevPrepareSCSIVHostDevices(hostdev_mgr, QEMU_DRIVER_NAME,
name, hostdevs, nhostdevs);
}
int
-qemuHostdevPrepareMediatedDevices(virQEMUDriverPtr driver,
+qemuHostdevPrepareMediatedDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
bool supportsVFIO;
size_t i;
}
int
-qemuHostdevPrepareDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
+qemuHostdevPrepareDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps,
unsigned int flags)
{
if (!def->nhostdevs && !def->ndisks)
}
void
-qemuHostdevReAttachOneNVMeDisk(virQEMUDriverPtr driver,
+qemuHostdevReAttachOneNVMeDisk(virQEMUDriver *driver,
const char *name,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
virHostdevReAttachOneNVMeDevice(driver->hostdevMgr,
QEMU_DRIVER_NAME,
}
void
-qemuHostdevReAttachNVMeDisks(virQEMUDriverPtr driver,
+qemuHostdevReAttachNVMeDisks(virQEMUDriver *driver,
const char *name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks)
{
virHostdevReAttachNVMeDevices(driver->hostdevMgr,
}
void
-qemuHostdevReAttachPCIDevices(virQEMUDriverPtr driver,
+qemuHostdevReAttachPCIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virHostdevReAttachPCIDevices(hostdev_mgr, QEMU_DRIVER_NAME, name,
hostdevs, nhostdevs);
}
void
-qemuHostdevReAttachUSBDevices(virQEMUDriverPtr driver,
+qemuHostdevReAttachUSBDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virHostdevReAttachUSBDevices(hostdev_mgr, QEMU_DRIVER_NAME,
name, hostdevs, nhostdevs);
}
void
-qemuHostdevReAttachSCSIDevices(virQEMUDriverPtr driver,
+qemuHostdevReAttachSCSIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
size_t i;
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
for (i = 0; i < nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = hostdevs[i];
+ virDomainHostdevDef *hostdev = hostdevs[i];
virDomainDeviceDef dev;
dev.type = VIR_DOMAIN_DEVICE_HOSTDEV;
}
void
-qemuHostdevReAttachSCSIVHostDevices(virQEMUDriverPtr driver,
+qemuHostdevReAttachSCSIVHostDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virHostdevReAttachSCSIVHostDevices(hostdev_mgr, QEMU_DRIVER_NAME,
name, hostdevs, nhostdevs);
}
void
-qemuHostdevReAttachMediatedDevices(virQEMUDriverPtr driver,
+qemuHostdevReAttachMediatedDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs)
{
- virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+ virHostdevManager *hostdev_mgr = driver->hostdevMgr;
virHostdevReAttachMediatedDevices(hostdev_mgr, QEMU_DRIVER_NAME,
name, hostdevs, nhostdevs);
}
void
-qemuHostdevReAttachDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuHostdevReAttachDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def)
{
if (!def->nhostdevs && !def->ndisks)
return;
bool qemuHostdevHostSupportsPassthroughVFIO(void);
-int qemuHostdevUpdateActiveNVMeDisks(virQEMUDriverPtr driver,
- virDomainDefPtr def);
-int qemuHostdevUpdateActiveMediatedDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
-int qemuHostdevUpdateActivePCIDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
-int qemuHostdevUpdateActiveUSBDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
-int qemuHostdevUpdateActiveSCSIDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
-int qemuHostdevUpdateActiveDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
+int qemuHostdevUpdateActiveNVMeDisks(virQEMUDriver *driver,
+ virDomainDef *def);
+int qemuHostdevUpdateActiveMediatedDevices(virQEMUDriver *driver,
+ virDomainDef *def);
+int qemuHostdevUpdateActivePCIDevices(virQEMUDriver *driver,
+ virDomainDef *def);
+int qemuHostdevUpdateActiveUSBDevices(virQEMUDriver *driver,
+ virDomainDef *def);
+int qemuHostdevUpdateActiveSCSIDevices(virQEMUDriver *driver,
+ virDomainDef *def);
+int qemuHostdevUpdateActiveDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def);
-int qemuHostdevPrepareOneNVMeDisk(virQEMUDriverPtr driver,
+int qemuHostdevPrepareOneNVMeDisk(virQEMUDriver *driver,
const char *name,
- virStorageSourcePtr src);
-int qemuHostdevPrepareNVMeDisks(virQEMUDriverPtr driver,
+ virStorageSource *src);
+int qemuHostdevPrepareNVMeDisks(virQEMUDriver *driver,
const char *name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks);
-int qemuHostdevPreparePCIDevices(virQEMUDriverPtr driver,
+int qemuHostdevPreparePCIDevices(virQEMUDriver *driver,
const char *name,
const unsigned char *uuid,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
unsigned int flags);
-int qemuHostdevPrepareUSBDevices(virQEMUDriverPtr driver,
+int qemuHostdevPrepareUSBDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs,
unsigned int flags);
-int qemuHostdevPrepareSCSIDevices(virQEMUDriverPtr driver,
+int qemuHostdevPrepareSCSIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-int qemuHostdevPrepareSCSIVHostDevices(virQEMUDriverPtr driver,
+int qemuHostdevPrepareSCSIVHostDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-int qemuHostdevPrepareMediatedDevices(virQEMUDriverPtr driver,
+int qemuHostdevPrepareMediatedDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-int qemuHostdevPrepareDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
+int qemuHostdevPrepareDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def,
+ virQEMUCaps *qemuCaps,
unsigned int flags);
-void qemuHostdevReAttachOneNVMeDisk(virQEMUDriverPtr driver,
+void qemuHostdevReAttachOneNVMeDisk(virQEMUDriver *driver,
const char *name,
- virStorageSourcePtr src);
-void qemuHostdevReAttachNVMeDisks(virQEMUDriverPtr driver,
+ virStorageSource *src);
+void qemuHostdevReAttachNVMeDisks(virQEMUDriver *driver,
const char *name,
- virDomainDiskDefPtr *disks,
+ virDomainDiskDef **disks,
size_t ndisks);
-void qemuHostdevReAttachPCIDevices(virQEMUDriverPtr driver,
+void qemuHostdevReAttachPCIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-void qemuHostdevReAttachUSBDevices(virQEMUDriverPtr driver,
+void qemuHostdevReAttachUSBDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-void qemuHostdevReAttachSCSIDevices(virQEMUDriverPtr driver,
+void qemuHostdevReAttachSCSIDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-void qemuHostdevReAttachSCSIVHostDevices(virQEMUDriverPtr driver,
+void qemuHostdevReAttachSCSIVHostDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-void qemuHostdevReAttachMediatedDevices(virQEMUDriverPtr driver,
+void qemuHostdevReAttachMediatedDevices(virQEMUDriver *driver,
const char *name,
- virDomainHostdevDefPtr *hostdevs,
+ virDomainHostdevDef **hostdevs,
int nhostdevs);
-void qemuHostdevReAttachDomainDevices(virQEMUDriverPtr driver,
- virDomainDefPtr def);
+void qemuHostdevReAttachDomainDevices(virQEMUDriver *driver,
+ virDomainDef *def);
static void
-qemuDomainResetDeviceRemoval(virDomainObjPtr vm);
+qemuDomainResetDeviceRemoval(virDomainObj *vm);
/**
* qemuDomainDeleteDevice:
* -1 otherwise.
*/
static int
-qemuDomainDeleteDevice(virDomainObjPtr vm,
+qemuDomainDeleteDevice(virDomainObj *vm,
const char *alias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
int rc;
qemuDomainObjEnterMonitor(driver, vm);
static int
-qemuDomainAttachZPCIDevice(qemuMonitorPtr mon,
- virDomainDeviceInfoPtr info)
+qemuDomainAttachZPCIDevice(qemuMonitor *mon,
+ virDomainDeviceInfo *info)
{
g_autofree char *devstr_zpci = NULL;
static int
-qemuDomainDetachZPCIDevice(qemuMonitorPtr mon,
- virDomainDeviceInfoPtr info)
+qemuDomainDetachZPCIDevice(qemuMonitor *mon,
+ virDomainDeviceInfo *info)
{
g_autofree char *zpciAlias = NULL;
static int
-qemuDomainAttachExtensionDevice(qemuMonitorPtr mon,
- virDomainDeviceInfoPtr info)
+qemuDomainAttachExtensionDevice(qemuMonitor *mon,
+ virDomainDeviceInfo *info)
{
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
info->addr.pci.extFlags == VIR_PCI_ADDRESS_EXTENSION_NONE) {
static int
-qemuDomainDetachExtensionDevice(qemuMonitorPtr mon,
- virDomainDeviceInfoPtr info)
+qemuDomainDetachExtensionDevice(qemuMonitor *mon,
+ virDomainDeviceInfo *info)
{
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
info->addr.pci.extFlags == VIR_PCI_ADDRESS_EXTENSION_NONE) {
static int
-qemuHotplugWaitForTrayEject(virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuHotplugWaitForTrayEject(virDomainObj *vm,
+ virDomainDiskDef *disk)
{
unsigned long long now;
int rc;
* Returns 0 on success, -1 on error and reports libvirt error
*/
static int
-qemuDomainChangeMediaLegacy(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc,
+qemuDomainChangeMediaLegacy(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc,
bool force)
{
int rc;
g_autofree char *driveAlias = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
const char *format = NULL;
g_autofree char *sourcestr = NULL;
* Returns: 0 on success, -1 on error.
*/
int
-qemuHotplugAttachDBusVMState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuHotplugAttachDBusVMState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virJSONValue) props = NULL;
int ret;
* Returns: 0 on success, -1 on error.
*/
int
-qemuHotplugRemoveDBusVMState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuHotplugRemoveDBusVMState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (!priv->dbusVMState)
* Returns: 0 on success, -1 on error.
*/
static int
-qemuHotplugAttachManagedPR(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuHotplugAttachManagedPR(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virJSONValuePtr props = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virJSONValue *props = NULL;
bool daemonStarted = false;
int ret = -1;
int rc;
* it any more.
*/
static int
-qemuHotplugRemoveManagedPR(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuHotplugRemoveManagedPR(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
int ret = -1;
* Returns 0 on success, -1 on error and reports libvirt error
*/
static int
-qemuDomainChangeMediaBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr oldsrc,
- virStorageSourcePtr newsrc,
+qemuDomainChangeMediaBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *oldsrc,
+ virStorageSource *newsrc,
bool force)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
g_autoptr(qemuBlockStorageSourceChainData) newbackend = NULL;
g_autoptr(qemuBlockStorageSourceChainData) oldbackend = NULL;
g_autofree char *nodename = NULL;
* Returns 0 on success, -1 on error and reports libvirt error
*/
int
-qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc,
+qemuDomainChangeEjectableMedia(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc,
bool force)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virStorageSourcePtr oldsrc = disk->src;
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virStorageSource *oldsrc = disk->src;
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
bool sharedAdded = false;
bool managedpr = virStorageSourceChainHasManagedPR(oldsrc) ||
virStorageSourceChainHasManagedPR(newsrc);
* Attaches disk to a VM. This function aggregates common code for all bus types.
* In cases when the VM crashed while adding the disk, -2 is returned. */
static int
-qemuDomainAttachDiskGeneric(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainAttachDiskGeneric(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk)
{
g_autoptr(qemuBlockStorageSourceChainData) data = NULL;
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *devstr = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virJSONValue) corProps = NULL;
*/
if (blockdev &&
qemuDiskConfigBlkdeviotuneEnabled(disk)) {
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if (qemuMonitorSetBlockIoThrottle(priv->mon, NULL, diskPriv->qomName,
&disk->blkdeviotune,
true, true, true) < 0)
static int
-qemuDomainAttachVirtioDiskDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainAttachVirtioDiskDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk)
{
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_DISK, { .disk = disk } };
bool releaseaddr = false;
}
-int qemuDomainAttachControllerDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainControllerDefPtr controller)
+int qemuDomainAttachControllerDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainControllerDef *controller)
{
int ret = -1;
const char* type = virDomainControllerTypeToString(controller->type);
g_autofree char *devstr = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_CONTROLLER,
{ .controller = controller } };
bool releaseaddr = false;
return ret;
}
-static virDomainControllerDefPtr
-qemuDomainFindOrCreateSCSIDiskController(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+static virDomainControllerDef *
+qemuDomainFindOrCreateSCSIDiskController(virQEMUDriver *driver,
+ virDomainObj *vm,
int controller)
{
size_t i;
- virDomainControllerDefPtr cont;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainControllerDef *cont;
+ qemuDomainObjPrivate *priv = vm->privateData;
int model = -1;
for (i = 0; i < vm->def->ncontrollers; i++) {
static int
-qemuDomainAttachSCSIDisk(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainAttachSCSIDisk(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk)
{
size_t i;
static int
-qemuDomainAttachUSBMassStorageDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainAttachUSBMassStorageDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virDomainUSBAddressEnsure(priv->usbaddrs, &disk->info) < 0)
return -1;
static int
-qemuDomainAttachDeviceDiskLiveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+qemuDomainAttachDeviceDiskLiveInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
size_t i;
- virDomainDiskDefPtr disk = dev->data.disk;
+ virDomainDiskDef *disk = dev->data.disk;
int ret = -1;
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM ||
* to the VM.
*/
int
-qemuDomainAttachDeviceDiskLive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+qemuDomainAttachDeviceDiskLive(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virDomainDiskDefPtr disk = dev->data.disk;
- virDomainDiskDefPtr orig_disk = NULL;
+ virDomainDiskDef *disk = dev->data.disk;
+ virDomainDiskDef *orig_disk = NULL;
/* this API overloads media change semantics on disk hotplug
* for devices supporting media changes */
static void
-qemuDomainNetDeviceVportRemove(virDomainNetDefPtr net)
+qemuDomainNetDeviceVportRemove(virDomainNetDef *net)
{
const virNetDevVPortProfile *vport = virDomainNetGetActualVirtPortProfile(net);
const char *brname;
int
-qemuDomainAttachNetDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net)
+qemuDomainAttachNetDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_NET, { .net = net } };
virErrorPtr originalError = NULL;
g_autofree char *slirpfdName = NULL;
virDomainNetType actualType;
const virNetDevBandwidth *actualBandwidth;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virDomainCCWAddressSetPtr ccwaddrs = NULL;
+ virDomainCCWAddressSet *ccwaddrs = NULL;
size_t i;
g_autofree char *charDevAlias = NULL;
bool charDevPlugged = false;
case VIR_DOMAIN_NET_TYPE_USER:
if (!priv->disableSlirp &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
- qemuSlirpPtr slirp = NULL;
+ qemuSlirp *slirp = NULL;
int rv = qemuInterfacePrepareSlirp(driver, net, &slirp);
if (rv == -1)
static int
-qemuDomainAttachHostPCIDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachHostPCIDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_HOSTDEV,
{ .hostdev = hostdev } };
- virDomainDeviceInfoPtr info = hostdev->info;
+ virDomainDeviceInfo *info = hostdev->info;
int ret;
g_autofree char *devstr = NULL;
bool releaseaddr = false;
void
-qemuDomainDelTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainDelTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
const char *secAlias,
const char *tlsAlias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
if (!tlsAlias && !secAlias)
int
-qemuDomainAddTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainAddTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virJSONValuePtr *secProps,
- virJSONValuePtr *tlsProps)
+ virJSONValue **secProps,
+ virJSONValue **tlsProps)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
g_autofree char *secAlias = NULL;
int
-qemuDomainGetTLSObjects(virQEMUCapsPtr qemuCaps,
- qemuDomainSecretInfoPtr secinfo,
+qemuDomainGetTLSObjects(virQEMUCaps *qemuCaps,
+ qemuDomainSecretInfo *secinfo,
const char *tlsCertdir,
bool tlsListen,
bool tlsVerify,
const char *alias,
- virJSONValuePtr *tlsProps,
- virJSONValuePtr *secProps)
+ virJSONValue **tlsProps,
+ virJSONValue **secProps)
{
const char *secAlias = NULL;
static int
-qemuDomainAddChardevTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrSourceDefPtr dev,
+qemuDomainAddChardevTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrSourceDef *dev,
char *devAlias,
char *charAlias,
char **tlsAlias,
{
int ret = -1;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainChrSourcePrivatePtr chrSourcePriv;
- qemuDomainSecretInfoPtr secinfo = NULL;
- virJSONValuePtr tlsProps = NULL;
- virJSONValuePtr secProps = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainChrSourcePrivate *chrSourcePriv;
+ qemuDomainSecretInfo *secinfo = NULL;
+ virJSONValue *tlsProps = NULL;
+ virJSONValue *secProps = NULL;
/* NB: This may alter haveTLS based on cfg */
qemuDomainPrepareChardevSourceTLS(dev, cfg);
static int
-qemuDomainDelChardevTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrSourceDefPtr dev,
+qemuDomainDelChardevTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrSourceDef *dev,
const char *inAlias)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *tlsAlias = NULL;
g_autofree char *secAlias = NULL;
}
-int qemuDomainAttachRedirdevDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRedirdevDefPtr redirdev)
+int qemuDomainAttachRedirdevDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRedirdevDef *redirdev)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *def = vm->def;
g_autofree char *charAlias = NULL;
g_autofree char *devstr = NULL;
bool chardevAdded = false;
}
static int
-qemuDomainChrPreInsert(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+qemuDomainChrPreInsert(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
if (vmdef->nserials == 0 && vmdef->nconsoles == 0 &&
chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
if (!vmdef->consoles)
- vmdef->consoles = g_new0(virDomainChrDefPtr, 1);
+ vmdef->consoles = g_new0(virDomainChrDef *, 1);
/* We'll be dealing with serials[0] directly, so NULL is fine here. */
if (!(vmdef->consoles[0] = virDomainChrDefNew(NULL))) {
}
static void
-qemuDomainChrInsertPreAlloced(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+qemuDomainChrInsertPreAlloced(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
virDomainChrInsertPreAlloced(vmdef, chr);
if (vmdef->nserials == 1 && vmdef->nconsoles == 0 &&
}
static void
-qemuDomainChrInsertPreAllocCleanup(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+qemuDomainChrInsertPreAllocCleanup(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
/* Remove the stub console added by qemuDomainChrPreInsert */
if (vmdef->nserials == 0 && vmdef->nconsoles == 1 &&
}
int
-qemuDomainChrInsert(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+qemuDomainChrInsert(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
if (qemuDomainChrPreInsert(vmdef, chr) < 0) {
qemuDomainChrInsertPreAllocCleanup(vmdef, chr);
return 0;
}
-virDomainChrDefPtr
-qemuDomainChrRemove(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr)
+virDomainChrDef *
+qemuDomainChrRemove(virDomainDef *vmdef,
+ virDomainChrDef *chr)
{
- virDomainChrDefPtr ret;
+ virDomainChrDef *ret;
bool removeCompat;
if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
* 0 otherwise
*/
static int
-qemuDomainAttachChrDeviceAssignAddr(virDomainObjPtr vm,
- virDomainChrDefPtr chr,
- virQEMUDriverPtr driver)
+qemuDomainAttachChrDeviceAssignAddr(virDomainObj *vm,
+ virDomainChrDef *chr,
+ virQEMUDriver *driver)
{
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_CHR, { .chr = chr } };
if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
return 0;
}
-int qemuDomainAttachChrDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr)
+int qemuDomainAttachChrDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr)
{
int ret = -1, rc;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
- virDomainDefPtr vmdef = vm->def;
+ virDomainDef *vmdef = vm->def;
g_autofree char *devstr = NULL;
g_autoptr(virJSONValue) netdevprops = NULL;
- virDomainChrSourceDefPtr dev = chr->source;
+ virDomainChrSourceDef *dev = chr->source;
g_autofree char *charAlias = NULL;
bool chardevAttached = false;
bool teardowncgroup = false;
int
-qemuDomainAttachRNGDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuDomainAttachRNGDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRNGDef *rng)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_RNG, { .rng = rng } };
virErrorPtr orig_err;
g_autofree char *devstr = NULL;
bool teardowncgroup = false;
bool teardowndevice = false;
bool chardevAdded = false;
- virJSONValuePtr props = NULL;
+ virJSONValue *props = NULL;
int ret = -1;
if (qemuAssignDeviceRNGAlias(vm->def, rng) < 0)
* Returns 0 on success -1 on error.
*/
int
-qemuDomainAttachMemory(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainAttachMemory(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
unsigned long long oldmem = virDomainDefGetMemoryTotal(vm->def);
bool teardownlabel = false;
bool teardowncgroup = false;
bool teardowndevice = false;
- virJSONValuePtr props = NULL;
- virObjectEventPtr event;
+ virJSONValue *props = NULL;
+ virObjectEvent *event;
int id;
int ret = -1;
static int
-qemuDomainAttachHostUSBDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachHostUSBDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *devstr = NULL;
bool added = false;
bool teardowncgroup = false;
static int
-qemuDomainAttachHostSCSIDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachHostSCSIDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
size_t i;
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
const char *backendalias = NULL;
}
static int
-qemuDomainAttachSCSIVHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachSCSIVHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_HOSTDEV,
{ .hostdev = hostdev } };
- virDomainCCWAddressSetPtr ccwaddrs = NULL;
+ virDomainCCWAddressSet *ccwaddrs = NULL;
g_autofree char *vhostfdName = NULL;
int vhostfd = -1;
g_autofree char *devstr = NULL;
static int
-qemuDomainAttachMediatedDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachMediatedDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
int ret = -1;
g_autofree char *devstr = NULL;
bool teardownlabel = false;
bool teardowndevice = false;
bool teardownmemlock = false;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_HOSTDEV,
{ .hostdev = hostdev } };
int
-qemuDomainAttachHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainAttachHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
int
-qemuDomainAttachShmemDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainShmemDefPtr shmem)
+qemuDomainAttachShmemDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainShmemDef *shmem)
{
int ret = -1;
g_autofree char *shmstr = NULL;
bool release_backing = false;
bool release_address = true;
virErrorPtr orig_err = NULL;
- virJSONValuePtr props = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virJSONValue *props = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_SHMEM, { .shmem = shmem } };
switch ((virDomainShmemModel)shmem->model) {
int
-qemuDomainAttachWatchdog(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainWatchdogDefPtr watchdog)
+qemuDomainAttachWatchdog(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainWatchdogDef *watchdog)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_WATCHDOG, { .watchdog = watchdog } };
virDomainWatchdogAction actualAction = watchdog->action;
const char *actionStr = NULL;
int
-qemuDomainAttachInputDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainInputDefPtr input)
+qemuDomainAttachInputDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainInputDef *input)
{
int ret = -1;
g_autofree char *devstr = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_INPUT,
{ .input = input } };
virErrorPtr originalError = NULL;
int
-qemuDomainAttachVsockDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainVsockDefPtr vsock)
+qemuDomainAttachVsockDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainVsockDef *vsock)
{
- qemuDomainVsockPrivatePtr vsockPriv = (qemuDomainVsockPrivatePtr)vsock->privateData;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainVsockPrivate *vsockPriv = (qemuDomainVsockPrivate *)vsock->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev = { VIR_DOMAIN_DEVICE_VSOCK,
{ .vsock = vsock } };
virErrorPtr originalError = NULL;
int
-qemuDomainAttachLease(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainLeaseDefPtr lease)
+qemuDomainAttachLease(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainLeaseDef *lease)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static int
-qemuDomainChangeNetBridge(virDomainObjPtr vm,
- virDomainNetDefPtr olddev,
- virDomainNetDefPtr newdev)
+qemuDomainChangeNetBridge(virDomainObj *vm,
+ virDomainNetDef *olddev,
+ virDomainNetDef *newdev)
{
int ret = -1;
const char *oldbridge = virDomainNetGetActualBridgeName(olddev);
}
static int
-qemuDomainChangeNetFilter(virDomainObjPtr vm,
- virDomainNetDefPtr olddev,
- virDomainNetDefPtr newdev)
+qemuDomainChangeNetFilter(virDomainObj *vm,
+ virDomainNetDef *olddev,
+ virDomainNetDef *newdev)
{
/* make sure this type of device supports filters. */
switch (virDomainNetGetActualType(newdev)) {
return 0;
}
-int qemuDomainChangeNetLinkState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr dev,
+int qemuDomainChangeNetLinkState(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *dev,
int linkstate)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!dev->info.alias) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
}
int
-qemuDomainChangeNet(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+qemuDomainChangeNet(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainNetDefPtr newdev = dev->data.net;
- virDomainNetDefPtr *devslot = NULL;
- virDomainNetDefPtr olddev;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainNetDef *newdev = dev->data.net;
+ virDomainNetDef **devslot = NULL;
+ virDomainNetDef *olddev;
virDomainNetType oldType, newType;
bool needReconnect = false;
bool needBridgeChange = false;
return ret;
}
-static virDomainGraphicsDefPtr
-qemuDomainFindGraphics(virDomainObjPtr vm,
- virDomainGraphicsDefPtr dev)
+static virDomainGraphicsDef *
+qemuDomainFindGraphics(virDomainObj *vm,
+ virDomainGraphicsDef *dev)
{
size_t i;
}
int
-qemuDomainFindGraphicsIndex(virDomainDefPtr def,
- virDomainGraphicsDefPtr dev)
+qemuDomainFindGraphicsIndex(virDomainDef *def,
+ virDomainGraphicsDef *dev)
{
size_t i;
int
-qemuDomainChangeGraphicsPasswords(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainChangeGraphicsPasswords(virQEMUDriver *driver,
+ virDomainObj *vm,
int type,
- virDomainGraphicsAuthDefPtr auth,
+ virDomainGraphicsAuthDef *auth,
const char *defaultPasswd,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
time_t now = time(NULL);
const char *expire;
g_autofree char *validTo = NULL;
int
-qemuDomainChangeGraphics(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainGraphicsDefPtr dev)
+qemuDomainChangeGraphics(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainGraphicsDef *dev)
{
- virDomainGraphicsDefPtr olddev = qemuDomainFindGraphics(vm, dev);
+ virDomainGraphicsDef *olddev = qemuDomainFindGraphics(vm, dev);
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
const char *type = virDomainGraphicsTypeToString(dev->type);
size_t i;
}
for (i = 0; i < dev->nListens; i++) {
- virDomainGraphicsListenDefPtr newlisten = &dev->listens[i];
- virDomainGraphicsListenDefPtr oldlisten = &olddev->listens[i];
+ virDomainGraphicsListenDef *newlisten = &dev->listens[i];
+ virDomainGraphicsListenDef *oldlisten = &olddev->listens[i];
if (newlisten->type != oldlisten->type) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
}
-static int qemuComparePCIDevice(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr device G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info1,
+static int qemuComparePCIDevice(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *device G_GNUC_UNUSED,
+ virDomainDeviceInfo *info1,
void *opaque)
{
- virDomainDeviceInfoPtr info2 = opaque;
+ virDomainDeviceInfo *info2 = opaque;
if (info1->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
info2->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
return 0;
}
-static bool qemuIsMultiFunctionDevice(virDomainDefPtr def,
- virDomainDeviceInfoPtr info)
+static bool qemuIsMultiFunctionDevice(virDomainDef *def,
+ virDomainDeviceInfo *info)
{
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
return false;
static int
-qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk)
+qemuDomainRemoveDiskDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk)
{
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
g_autoptr(qemuBlockStorageSourceChainData) diskBackend = NULL;
virDomainDeviceDef dev;
size_t i;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *corAlias = NULL;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
int ret = -1;
static int
-qemuDomainRemoveControllerDevice(virDomainObjPtr vm,
- virDomainControllerDefPtr controller)
+qemuDomainRemoveControllerDevice(virDomainObj *vm,
+ virDomainControllerDef *controller)
{
size_t i;
static int
-qemuDomainRemoveMemoryDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainRemoveMemoryDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned long long oldmem = virDomainDefGetMemoryTotal(vm->def);
unsigned long long newmem = oldmem - mem->size;
g_autofree char *backendAlias = NULL;
static void
-qemuDomainRemovePCIHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemovePCIHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
qemuHostdevReAttachPCIDevices(driver, vm->def->name, &hostdev, 1);
qemuDomainReleaseDeviceAddress(vm, hostdev->info);
}
static void
-qemuDomainRemoveUSBHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemoveUSBHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
qemuHostdevReAttachUSBDevices(driver, vm->def->name, &hostdev, 1);
qemuDomainReleaseDeviceAddress(vm, hostdev->info);
}
static void
-qemuDomainRemoveSCSIHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemoveSCSIHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
qemuHostdevReAttachSCSIDevices(driver, vm->def->name, &hostdev, 1);
}
static void
-qemuDomainRemoveSCSIVHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemoveSCSIVHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
qemuHostdevReAttachSCSIVHostDevices(driver, vm->def->name, &hostdev, 1);
}
static void
-qemuDomainRemoveMediatedDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemoveMediatedDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
qemuHostdevReAttachMediatedDevices(driver, vm->def->name, &hostdev, 1);
qemuDomainReleaseDeviceAddress(vm, hostdev->info);
static int
-qemuDomainRemoveHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainRemoveHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
size_t i;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Removing host device %s from domain %p %s",
hostdev->info->alias, vm, vm->def->name);
static int
-qemuDomainRemoveNetDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net)
+qemuDomainRemoveNetDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *hostnet_name = NULL;
g_autofree char *charDevAlias = NULL;
size_t i;
if (qemuMonitorQueryFdsets(priv->mon, &fdsets) == 0) {
for (i = 0; i < fdsets->nfdsets && vdpafdset < 0; i++) {
size_t j;
- qemuMonitorFdsetInfoPtr set = &fdsets->fdsets[i];
+ qemuMonitorFdsetInfo *set = &fdsets->fdsets[i];
for (j = 0; j < set->nfds; j++) {
- qemuMonitorFdsetFdInfoPtr fdinfo = &set->fds[j];
+ qemuMonitorFdsetFdInfo *fdinfo = &set->fds[j];
if (STREQ_NULLABLE(fdinfo->opaque, net->data.vdpa.devicepath)) {
vdpafdset = set->id;
break;
static int
-qemuDomainRemoveChrDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr,
+qemuDomainRemoveChrDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr,
bool monitor)
{
- virObjectEventPtr event;
+ virObjectEvent *event;
g_autofree char *charAlias = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rc = 0;
VIR_DEBUG("Removing character device %s from domain %p %s",
static int
-qemuDomainRemoveRNGDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuDomainRemoveRNGDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRNGDef *rng)
{
g_autofree char *charAlias = NULL;
g_autofree char *objAlias = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
ssize_t idx;
int rc = 0;
static int
-qemuDomainRemoveShmemDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainShmemDefPtr shmem)
+qemuDomainRemoveShmemDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainShmemDef *shmem)
{
int rc;
ssize_t idx = -1;
g_autofree char *charAlias = NULL;
g_autofree char *memAlias = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Removing shmem device %s from domain %p %s",
shmem->info.alias, vm, vm->def->name);
static int
-qemuDomainRemoveWatchdog(virDomainObjPtr vm,
- virDomainWatchdogDefPtr watchdog)
+qemuDomainRemoveWatchdog(virDomainObj *vm,
+ virDomainWatchdogDef *watchdog)
{
VIR_DEBUG("Removing watchdog %s from domain %p %s",
watchdog->info.alias, vm, vm->def->name);
static int
-qemuDomainRemoveInputDevice(virDomainObjPtr vm,
- virDomainInputDefPtr dev)
+qemuDomainRemoveInputDevice(virDomainObj *vm,
+ virDomainInputDef *dev)
{
size_t i;
static int
-qemuDomainRemoveVsockDevice(virDomainObjPtr vm,
- virDomainVsockDefPtr dev)
+qemuDomainRemoveVsockDevice(virDomainObj *vm,
+ virDomainVsockDef *dev)
{
VIR_DEBUG("Removing vsock device %s from domain %p %s",
dev->info.alias, vm, vm->def->name);
static int
-qemuDomainRemoveRedirdevDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRedirdevDefPtr dev)
+qemuDomainRemoveRedirdevDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRedirdevDef *dev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *charAlias = NULL;
ssize_t idx;
static void
-qemuDomainRemoveAuditDevice(virDomainObjPtr vm,
- virDomainDeviceDefPtr detach,
+qemuDomainRemoveAuditDevice(virDomainObj *vm,
+ virDomainDeviceDef *detach,
bool success)
{
switch ((virDomainDeviceType)detach->type) {
int
-qemuDomainRemoveDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+qemuDomainRemoveDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
- virDomainDeviceInfoPtr info;
- virObjectEventPtr event;
+ virDomainDeviceInfo *info;
+ virObjectEvent *event;
g_autofree char *alias = NULL;
/*
static void
-qemuDomainMarkDeviceAliasForRemoval(virDomainObjPtr vm,
+qemuDomainMarkDeviceAliasForRemoval(virDomainObj *vm,
const char *alias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
memset(&priv->unplug, 0, sizeof(priv->unplug));
static void
-qemuDomainMarkDeviceForRemoval(virDomainObjPtr vm,
- virDomainDeviceInfoPtr info)
+qemuDomainMarkDeviceForRemoval(virDomainObj *vm,
+ virDomainDeviceInfo *info)
{
qemuDomainMarkDeviceAliasForRemoval(vm, info->alias);
static void
-qemuDomainResetDeviceRemoval(virDomainObjPtr vm)
+qemuDomainResetDeviceRemoval(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
priv->unplug.alias = NULL;
priv->unplug.eventSeen = false;
}
unsigned long long G_GNUC_NO_INLINE
-qemuDomainGetUnplugTimeout(virDomainObjPtr vm)
+qemuDomainGetUnplugTimeout(virDomainObj *vm)
{
if (qemuDomainIsPSeries(vm->def))
return QEMU_UNPLUG_TIMEOUT_PPC64;
* - we failed to reliably wait for the event and thus use fallback behavior
*/
static int
-qemuDomainWaitForDeviceRemoval(virDomainObjPtr vm)
+qemuDomainWaitForDeviceRemoval(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned long long until;
int rc;
* finishing the removal to a new thread
*/
bool
-qemuDomainSignalDeviceRemoval(virDomainObjPtr vm,
+qemuDomainSignalDeviceRemoval(virDomainObj *vm,
const char *devAlias,
qemuDomainUnpluggingDeviceStatus status)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (STREQ_NULLABLE(priv->unplug.alias, devAlias)) {
VIR_DEBUG("Removal of device '%s' continues in waiting thread", devAlias);
static int
-qemuFindDisk(virDomainDefPtr def, const char *dst)
+qemuFindDisk(virDomainDef *def, const char *dst)
{
size_t i;
}
static int
-qemuDomainDetachPrepDisk(virDomainObjPtr vm,
- virDomainDiskDefPtr match,
- virDomainDiskDefPtr *detach)
+qemuDomainDetachPrepDisk(virDomainObj *vm,
+ virDomainDiskDef *match,
+ virDomainDiskDef **detach)
{
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
int idx;
if ((idx = qemuFindDisk(vm->def, match->dst)) < 0) {
static bool
-qemuDomainDiskControllerIsBusy(virDomainObjPtr vm,
- virDomainControllerDefPtr detach)
+qemuDomainDiskControllerIsBusy(virDomainObj *vm,
+ virDomainControllerDef *detach)
{
size_t i;
- virDomainDiskDefPtr disk;
- virDomainHostdevDefPtr hostdev;
+ virDomainDiskDef *disk;
+ virDomainHostdevDef *hostdev;
for (i = 0; i < vm->def->ndisks; i++) {
disk = vm->def->disks[i];
static bool
-qemuDomainControllerIsBusy(virDomainObjPtr vm,
- virDomainControllerDefPtr detach)
+qemuDomainControllerIsBusy(virDomainObj *vm,
+ virDomainControllerDef *detach)
{
switch ((virDomainControllerType) detach->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
static int
-qemuDomainDetachPrepController(virDomainObjPtr vm,
- virDomainControllerDefPtr match,
- virDomainControllerDefPtr *detach)
+qemuDomainDetachPrepController(virDomainObj *vm,
+ virDomainControllerDef *match,
+ virDomainControllerDef **detach)
{
int idx;
- virDomainControllerDefPtr controller = NULL;
+ virDomainControllerDef *controller = NULL;
if (match->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
/* search for a hostdev matching dev and detach it */
static int
-qemuDomainDetachPrepHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr match,
- virDomainHostdevDefPtr *detach)
+qemuDomainDetachPrepHostdev(virDomainObj *vm,
+ virDomainHostdevDef *match,
+ virDomainHostdevDef **detach)
{
- virDomainHostdevSubsysPtr subsys = &match->source.subsys;
- virDomainHostdevSubsysUSBPtr usbsrc = &subsys->u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &subsys->u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &subsys->u.scsi;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &subsys->u.mdev;
- virDomainHostdevDefPtr hostdev = NULL;
+ virDomainHostdevSubsys *subsys = &match->source.subsys;
+ virDomainHostdevSubsysUSB *usbsrc = &subsys->u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &subsys->u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &subsys->u.scsi;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &subsys->u.mdev;
+ virDomainHostdevDef *hostdev = NULL;
int idx;
if (match->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
if (scsisrc->protocol ==
VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
- virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
+ virDomainHostdevSubsysSCSIiSCSI *iscsisrc = &scsisrc->u.iscsi;
virReportError(VIR_ERR_DEVICE_MISSING,
_("host scsi iSCSI path %s not found"),
iscsisrc->src->path);
} else {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc =
+ virDomainHostdevSubsysSCSIHost *scsihostsrc =
&scsisrc->u.host;
virReportError(VIR_ERR_DEVICE_MISSING,
_("host scsi device %s:%u:%u.%llu not found"),
static int
-qemuDomainDetachPrepShmem(virDomainObjPtr vm,
- virDomainShmemDefPtr match,
- virDomainShmemDefPtr *detach)
+qemuDomainDetachPrepShmem(virDomainObj *vm,
+ virDomainShmemDef *match,
+ virDomainShmemDef **detach)
{
ssize_t idx = -1;
- virDomainShmemDefPtr shmem = NULL;
+ virDomainShmemDef *shmem = NULL;
if ((idx = virDomainShmemDefFind(vm->def, match)) < 0) {
virReportError(VIR_ERR_DEVICE_MISSING,
static int
-qemuDomainDetachPrepWatchdog(virDomainObjPtr vm,
- virDomainWatchdogDefPtr match,
- virDomainWatchdogDefPtr *detach)
+qemuDomainDetachPrepWatchdog(virDomainObj *vm,
+ virDomainWatchdogDef *match,
+ virDomainWatchdogDef **detach)
{
- virDomainWatchdogDefPtr watchdog;
+ virDomainWatchdogDef *watchdog;
*detach = watchdog = vm->def->watchdog;
static int
-qemuDomainDetachPrepRedirdev(virDomainObjPtr vm,
- virDomainRedirdevDefPtr match,
- virDomainRedirdevDefPtr *detach)
+qemuDomainDetachPrepRedirdev(virDomainObj *vm,
+ virDomainRedirdevDef *match,
+ virDomainRedirdevDef **detach)
{
ssize_t idx;
static int
-qemuDomainDetachPrepNet(virDomainObjPtr vm,
- virDomainNetDefPtr match,
- virDomainNetDefPtr *detach)
+qemuDomainDetachPrepNet(virDomainObj *vm,
+ virDomainNetDef *match,
+ virDomainNetDef **detach)
{
int detachidx;
static int
-qemuDomainDetachDeviceChr(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr,
+qemuDomainDetachDeviceChr(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr,
bool async)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr vmdef = vm->def;
- virDomainChrDefPtr tmpChr;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *vmdef = vm->def;
+ virDomainChrDef *tmpChr;
bool guestfwd = false;
if (!(tmpChr = virDomainChrFind(vmdef, chr))) {
static int
-qemuDomainDetachPrepRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr match,
- virDomainRNGDefPtr *detach)
+qemuDomainDetachPrepRNG(virDomainObj *vm,
+ virDomainRNGDef *match,
+ virDomainRNGDef **detach)
{
ssize_t idx;
static int
-qemuDomainDetachPrepMemory(virDomainObjPtr vm,
- virDomainMemoryDefPtr match,
- virDomainMemoryDefPtr *detach)
+qemuDomainDetachPrepMemory(virDomainObj *vm,
+ virDomainMemoryDef *match,
+ virDomainMemoryDef **detach)
{
int idx;
static int
-qemuDomainDetachPrepInput(virDomainObjPtr vm,
- virDomainInputDefPtr match,
- virDomainInputDefPtr *detach)
+qemuDomainDetachPrepInput(virDomainObj *vm,
+ virDomainInputDef *match,
+ virDomainInputDef **detach)
{
- virDomainInputDefPtr input;
+ virDomainInputDef *input;
int idx;
if ((idx = virDomainInputDefFind(vm->def, match)) < 0) {
static int
-qemuDomainDetachPrepVsock(virDomainObjPtr vm,
- virDomainVsockDefPtr match,
- virDomainVsockDefPtr *detach)
+qemuDomainDetachPrepVsock(virDomainObj *vm,
+ virDomainVsockDef *match,
+ virDomainVsockDef **detach)
{
- virDomainVsockDefPtr vsock;
+ virDomainVsockDef *vsock;
*detach = vsock = vm->def->vsock;
if (!vsock ||
static int
-qemuDomainDetachDeviceLease(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainLeaseDefPtr lease)
+qemuDomainDetachDeviceLease(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainLeaseDef *lease)
{
- virDomainLeaseDefPtr det_lease;
+ virDomainLeaseDef *det_lease;
int idx;
if ((idx = virDomainLeaseIndex(vm->def, lease)) < 0) {
int
-qemuDomainDetachDeviceLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr match,
- virQEMUDriverPtr driver,
+qemuDomainDetachDeviceLive(virDomainObj *vm,
+ virDomainDeviceDef *match,
+ virQEMUDriver *driver,
bool async)
{
virDomainDeviceDef detach = { .type = match->type };
- virDomainDeviceInfoPtr info = NULL;
+ virDomainDeviceInfo *info = NULL;
int ret = -1;
switch ((virDomainDeviceType)match->type) {
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
- virDomainControllerDefPtr controller;
+ virDomainControllerDef *controller;
int controllerIdx = virDomainControllerFind(vm->def,
VIR_DOMAIN_CONTROLLER_TYPE_PCI,
info->addr.pci.bus);
static int
-qemuDomainRemoveVcpu(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRemoveVcpu(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int vcpu)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
- qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainVcpuDef *vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
+ qemuDomainVcpuPrivate *vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
int oldvcpus = virDomainDefGetVcpus(vm->def);
unsigned int nvcpus = vcpupriv->vcpus;
virErrorPtr save_error = NULL;
void
-qemuDomainRemoveVcpuAlias(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuDomainRemoveVcpuAlias(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *alias)
{
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
size_t i;
for (i = 0; i < virDomainDefGetVcpusMax(vm->def); i++) {
static int
-qemuDomainHotplugDelVcpu(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuDomainHotplugDelVcpu(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
unsigned int vcpu)
{
- virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
- qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
+ virDomainVcpuDef *vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
+ qemuDomainVcpuPrivate *vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
int oldvcpus = virDomainDefGetVcpus(vm->def);
unsigned int nvcpus = vcpupriv->vcpus;
int rc;
static int
-qemuDomainHotplugAddVcpu(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuDomainHotplugAddVcpu(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
unsigned int vcpu)
{
- virJSONValuePtr vcpuprops = NULL;
- virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
- qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
+ virJSONValue *vcpuprops = NULL;
+ virDomainVcpuDef *vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
+ qemuDomainVcpuPrivate *vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
unsigned int nvcpus = vcpupriv->vcpus;
bool newhotplug = qemuDomainSupportsNewVcpuHotplug(vm);
int ret = -1;
*
* Returns the bitmap of vcpus to modify on success, NULL on error.
*/
-static virBitmapPtr
-qemuDomainSelectHotplugVcpuEntities(virDomainDefPtr def,
+static virBitmap *
+qemuDomainSelectHotplugVcpuEntities(virDomainDef *def,
unsigned int nvcpus,
bool *enable)
{
- virBitmapPtr ret = NULL;
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virBitmap *ret = NULL;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
unsigned int curvcpus = virDomainDefGetVcpus(def);
ssize_t i;
static int
-qemuDomainSetVcpusLive(virQEMUDriverPtr driver,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
- virBitmapPtr vcpumap,
+qemuDomainSetVcpusLive(virQEMUDriver *driver,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
+ virBitmap *vcpumap,
bool enable)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuCgroupEmulatorAllNodesDataPtr emulatorCgroup = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuCgroupEmulatorAllNodesData *emulatorCgroup = NULL;
ssize_t nextvcpu = -1;
int ret = -1;
* - fix hotpluggable state
*/
static void
-qemuDomainSetVcpusConfig(virDomainDefPtr def,
+qemuDomainSetVcpusConfig(virDomainDef *def,
unsigned int nvcpus,
bool hotpluggable)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t curvcpus = virDomainDefGetVcpus(def);
size_t maxvcpus = virDomainDefGetVcpusMax(def);
size_t i;
int
-qemuDomainSetVcpusInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr def,
- virDomainDefPtr persistentDef,
+qemuDomainSetVcpusInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *def,
+ virDomainDef *persistentDef,
unsigned int nvcpus,
bool hotpluggable)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virBitmapPtr vcpumap = NULL;
+ virBitmap *vcpumap = NULL;
bool enable;
int ret = -1;
static void
-qemuDomainSetVcpuConfig(virDomainDefPtr def,
- virBitmapPtr map,
+qemuDomainSetVcpuConfig(virDomainDef *def,
+ virBitmap *map,
bool state)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
ssize_t next = -1;
def->individualvcpus = true;
* Returns a bitmap of hotpluggable vcpu entities that correspond to the logical
* vcpus requested in @vcpus.
*/
-static virBitmapPtr
-qemuDomainFilterHotplugVcpuEntities(virDomainDefPtr def,
- virBitmapPtr vcpus,
+static virBitmap *
+qemuDomainFilterHotplugVcpuEntities(virDomainDef *def,
+ virBitmap *vcpus,
bool state)
{
- qemuDomainVcpuPrivatePtr vcpupriv;
- virDomainVcpuDefPtr vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
+ virDomainVcpuDef *vcpu;
g_autoptr(virBitmap) map = virBitmapNewCopy(vcpus);
ssize_t next = -1;
size_t i;
static int
-qemuDomainVcpuValidateConfig(virDomainDefPtr def,
- virBitmapPtr map)
+qemuDomainVcpuValidateConfig(virDomainDef *def,
+ virBitmap *map)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t maxvcpus = virDomainDefGetVcpusMax(def);
ssize_t next;
ssize_t firstvcpu = -1;
int
-qemuDomainSetVcpuInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr def,
- virDomainDefPtr persistentDef,
- virBitmapPtr map,
+qemuDomainSetVcpuInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *def,
+ virDomainDef *persistentDef,
+ virBitmap *map,
bool state)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virBitmapPtr livevcpus = NULL;
+ virBitmap *livevcpus = NULL;
int ret = -1;
if (def) {
#include "qemu_domain.h"
#include "domain_conf.h"
-int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virStorageSourcePtr newsrc,
+int qemuDomainChangeEjectableMedia(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virStorageSource *newsrc,
bool force);
-void qemuDomainDelTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuDomainDelTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
const char *secAlias,
const char *tlsAlias);
-int qemuDomainAddTLSObjects(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuDomainAddTLSObjects(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virJSONValuePtr *secProps,
- virJSONValuePtr *tlsProps);
+ virJSONValue **secProps,
+ virJSONValue **tlsProps);
-int qemuDomainGetTLSObjects(virQEMUCapsPtr qemuCaps,
- qemuDomainSecretInfoPtr secinfo,
+int qemuDomainGetTLSObjects(virQEMUCaps *qemuCaps,
+ qemuDomainSecretInfo *secinfo,
const char *tlsCertdir,
bool tlsListen,
bool tlsVerify,
const char *alias,
- virJSONValuePtr *tlsProps,
- virJSONValuePtr *secProps);
-
-int qemuDomainAttachControllerDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainControllerDefPtr controller);
-int qemuDomainAttachDeviceDiskLive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev);
-int qemuDomainAttachNetDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr net);
-int qemuDomainAttachRedirdevDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRedirdevDefPtr hostdev);
-int qemuDomainAttachHostDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
-int qemuDomainAttachShmemDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainShmemDefPtr shmem);
-int qemuDomainAttachWatchdog(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainWatchdogDefPtr watchdog);
-int qemuDomainFindGraphicsIndex(virDomainDefPtr def,
- virDomainGraphicsDefPtr dev);
-int qemuDomainAttachMemory(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
-int qemuDomainChangeGraphics(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainGraphicsDefPtr dev);
-int qemuDomainChangeGraphicsPasswords(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virJSONValue **tlsProps,
+ virJSONValue **secProps);
+
+int qemuDomainAttachControllerDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainControllerDef *controller);
+int qemuDomainAttachDeviceDiskLive(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev);
+int qemuDomainAttachNetDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *net);
+int qemuDomainAttachRedirdevDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRedirdevDef *hostdev);
+int qemuDomainAttachHostDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
+int qemuDomainAttachShmemDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainShmemDef *shmem);
+int qemuDomainAttachWatchdog(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainWatchdogDef *watchdog);
+int qemuDomainFindGraphicsIndex(virDomainDef *def,
+ virDomainGraphicsDef *dev);
+int qemuDomainAttachMemory(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem);
+int qemuDomainChangeGraphics(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainGraphicsDef *dev);
+int qemuDomainChangeGraphicsPasswords(virQEMUDriver *driver,
+ virDomainObj *vm,
int type,
- virDomainGraphicsAuthDefPtr auth,
+ virDomainGraphicsAuthDef *auth,
const char *defaultPasswd,
int asyncJob);
-int qemuDomainChangeNet(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev);
-int qemuDomainChangeNetLinkState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainNetDefPtr dev,
+int qemuDomainChangeNet(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev);
+int qemuDomainChangeNetLinkState(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainNetDef *dev,
int linkstate);
-int qemuDomainAttachInputDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainInputDefPtr input);
-
-int qemuDomainAttachVsockDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainVsockDefPtr vsock);
-
-int qemuDomainAttachLease(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainLeaseDefPtr lease);
-int qemuDomainAttachChrDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr);
-int qemuDomainAttachRNGDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainRNGDefPtr rng);
-
-int qemuDomainDetachDeviceLive(virDomainObjPtr vm,
- virDomainDeviceDefPtr match,
- virQEMUDriverPtr driver,
+int qemuDomainAttachInputDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainInputDef *input);
+
+int qemuDomainAttachVsockDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainVsockDef *vsock);
+
+int qemuDomainAttachLease(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainLeaseDef *lease);
+int qemuDomainAttachChrDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr);
+int qemuDomainAttachRNGDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainRNGDef *rng);
+
+int qemuDomainDetachDeviceLive(virDomainObj *vm,
+ virDomainDeviceDef *match,
+ virQEMUDriver *driver,
bool async);
-void qemuDomainRemoveVcpuAlias(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuDomainRemoveVcpuAlias(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *alias);
int
-qemuDomainChrInsert(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr);
-virDomainChrDefPtr
-qemuDomainChrRemove(virDomainDefPtr vmdef,
- virDomainChrDefPtr chr);
+qemuDomainChrInsert(virDomainDef *vmdef,
+ virDomainChrDef *chr);
+virDomainChrDef *
+qemuDomainChrRemove(virDomainDef *vmdef,
+ virDomainChrDef *chr);
-int qemuDomainRemoveDevice(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDeviceDefPtr dev);
+int qemuDomainRemoveDevice(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDeviceDef *dev);
-bool qemuDomainSignalDeviceRemoval(virDomainObjPtr vm,
+bool qemuDomainSignalDeviceRemoval(virDomainObj *vm,
const char *devAlias,
qemuDomainUnpluggingDeviceStatus status);
-int qemuDomainSetVcpusInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr def,
- virDomainDefPtr persistentDef,
+int qemuDomainSetVcpusInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *def,
+ virDomainDef *persistentDef,
unsigned int nvcpus,
bool hotpluggable);
-int qemuDomainSetVcpuInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDefPtr def,
- virDomainDefPtr persistentDef,
- virBitmapPtr vcpus,
+int qemuDomainSetVcpuInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDef *def,
+ virDomainDef *persistentDef,
+ virBitmap *vcpus,
bool state);
-unsigned long long qemuDomainGetUnplugTimeout(virDomainObjPtr vm) G_GNUC_NO_INLINE;
+unsigned long long qemuDomainGetUnplugTimeout(virDomainObj *vm) G_GNUC_NO_INLINE;
-int qemuHotplugAttachDBusVMState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuHotplugAttachDBusVMState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
-int qemuHotplugRemoveDBusVMState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuHotplugRemoveDBusVMState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
* the rest of the network.
*/
int
-qemuInterfaceStartDevice(virDomainNetDefPtr net)
+qemuInterfaceStartDevice(virDomainNetDef *net)
{
virDomainNetType actualType = virDomainNetGetActualType(net);
* Set all ifaces associated with this domain to the online state.
*/
int
-qemuInterfaceStartDevices(virDomainDefPtr def)
+qemuInterfaceStartDevices(virDomainDef *def)
{
size_t i;
* it from the rest of the network.
*/
int
-qemuInterfaceStopDevice(virDomainNetDefPtr net)
+qemuInterfaceStopDevice(virDomainNetDef *net)
{
virDomainNetType actualType = virDomainNetGetActualType(net);
* the rest of the network.
*/
int
-qemuInterfaceStopDevices(virDomainDefPtr def)
+qemuInterfaceStopDevices(virDomainDef *def)
{
size_t i;
* Returns 0 on success or -1 in case of error.
*/
int
-qemuInterfaceDirectConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+qemuInterfaceDirectConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t tapfdSize,
virNetDevVPortProfileOp vmop)
* Returns 0 in case of success or -1 on failure
*/
static int
-qemuCreateInBridgePortWithHelper(virQEMUDriverConfigPtr cfg,
+qemuCreateInBridgePortWithHelper(virQEMUDriverConfig *cfg,
const char *brname,
char **ifname,
int *tapfd,
unsigned int flags)
{
- virCommandPtr cmd;
+ virCommand *cmd;
char *errbuf = NULL, *cmdstr = NULL;
int pair[2] = { -1, -1 };
* (i.e. if the connection is made with a tap device)
*/
int
-qemuInterfaceEthernetConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+qemuInterfaceEthernetConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t tapfdSize)
{
* device connecting to a bridge device)
*/
int
-qemuInterfaceBridgeConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+qemuInterfaceBridgeConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t *tapfdSize)
{
* Called *only* called if actualType is VIR_DOMAIN_NET_TYPE_VDPA
*/
int
-qemuInterfaceVDPAConnect(virDomainNetDefPtr net)
+qemuInterfaceVDPAConnect(virDomainNetDef *net)
{
int fd;
* Returns: -1 on error, 0 if slirp isn't available, 1 on succcess
*/
int
-qemuInterfacePrepareSlirp(virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
- qemuSlirpPtr *slirpret)
+qemuInterfacePrepareSlirp(virQEMUDriver *driver,
+ virDomainNetDef *net,
+ qemuSlirp **slirpret)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(qemuSlirp) slirp = NULL;
* -1 on failure
*/
int
-qemuInterfaceOpenVhostNet(virDomainDefPtr def,
- virDomainNetDefPtr net,
+qemuInterfaceOpenVhostNet(virDomainDef *def,
+ virDomainNetDef *net,
int *vhostfd,
size_t *vhostfdSize)
{
#include "qemu_domain.h"
#include "qemu_slirp.h"
-int qemuInterfaceStartDevice(virDomainNetDefPtr net);
-int qemuInterfaceStartDevices(virDomainDefPtr def);
-int qemuInterfaceStopDevice(virDomainNetDefPtr net);
-int qemuInterfaceStopDevices(virDomainDefPtr def);
-
-int qemuInterfaceDirectConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+int qemuInterfaceStartDevice(virDomainNetDef *net);
+int qemuInterfaceStartDevices(virDomainDef *def);
+int qemuInterfaceStopDevice(virDomainNetDef *net);
+int qemuInterfaceStopDevices(virDomainDef *def);
+
+int qemuInterfaceDirectConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t tapfdSize,
virNetDevVPortProfileOp vmop);
-int qemuInterfaceEthernetConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+int qemuInterfaceEthernetConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t tapfdSize);
-int qemuInterfaceBridgeConnect(virDomainDefPtr def,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+int qemuInterfaceBridgeConnect(virDomainDef *def,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
int *tapfd,
size_t *tapfdSize)
ATTRIBUTE_NONNULL(2);
-int qemuInterfaceOpenVhostNet(virDomainDefPtr def,
- virDomainNetDefPtr net,
+int qemuInterfaceOpenVhostNet(virDomainDef *def,
+ virDomainNetDef *net,
int *vhostfd,
size_t *vhostfdSize) G_GNUC_NO_INLINE;
-int qemuInterfacePrepareSlirp(virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
- qemuSlirpPtr *slirp);
+int qemuInterfacePrepareSlirp(virQEMUDriver *driver,
+ virDomainNetDef *net,
+ qemuSlirp **slirp);
-int qemuInterfaceVDPAConnect(virDomainNetDefPtr net) G_GNUC_NO_INLINE;
+int qemuInterfaceVDPAConnect(virDomainNetDef *net) G_GNUC_NO_INLINE;
g_autofree char *xdgConfig = NULL;
g_autofree char *sysLocation = virFileBuildPath(QEMU_SYSTEM_LOCATION, name, NULL);
g_autofree char *etcLocation = virFileBuildPath(QEMU_ETC_LOCATION, name, NULL);
- g_autofree virHashKeyValuePairPtr pairs = NULL;
+ g_autofree virHashKeyValuePair *pairs = NULL;
size_t npairs;
- virHashKeyValuePairPtr tmp = NULL;
+ virHashKeyValuePair *tmp = NULL;
size_t nconfigs = 0;
*configs = NULL;
);
static int
-qemuMigrationJobStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobStart(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob job,
unsigned long apiFlags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
static void
-qemuMigrationJobSetPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobSetPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMigrationJobPhase phase)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
static void
-qemuMigrationJobStartPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobStartPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMigrationJobPhase phase)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
static void
-qemuMigrationJobContinue(virDomainObjPtr obj)
+qemuMigrationJobContinue(virDomainObj *obj)
ATTRIBUTE_NONNULL(1);
static bool
-qemuMigrationJobIsActive(virDomainObjPtr vm,
+qemuMigrationJobIsActive(virDomainObj *vm,
qemuDomainAsyncJob job)
ATTRIBUTE_NONNULL(1);
static void
-qemuMigrationJobFinish(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+qemuMigrationJobFinish(virQEMUDriver *driver,
+ virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
static void
-qemuMigrationSrcStoreDomainState(virDomainObjPtr vm)
+qemuMigrationSrcStoreDomainState(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
priv->preMigrationState = virDomainObjGetState(vm, NULL);
VIR_DEBUG("Storing pre-migration state=%d domain=%p",
/* Returns true if the domain was resumed, false otherwise */
static bool
-qemuMigrationSrcRestoreDomainState(virQEMUDriverPtr driver, virDomainObjPtr vm)
+qemuMigrationSrcRestoreDomainState(virQEMUDriver *driver, virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int reason;
virDomainState state = virDomainObjGetState(vm, &reason);
bool ret = false;
static int
qemuMigrationDstPrecreateDisk(virConnectPtr *conn,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
unsigned long long capacity)
{
int ret = -1;
static int
-qemuMigrationDstPrecreateStorage(virDomainObjPtr vm,
- qemuMigrationCookieNBDPtr nbd,
+qemuMigrationDstPrecreateStorage(virDomainObj *vm,
+ qemuMigrationCookieNBD *nbd,
size_t nmigrate_disks,
const char **migrate_disks,
bool incremental)
return 0;
for (i = 0; i < nbd->ndisks; i++) {
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
const char *diskSrcPath;
g_autofree char *nvmePath = NULL;
* Returns 0 on success, -1 otherwise.
*/
static int
-qemuMigrationDstStartNBDServer(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationDstStartNBDServer(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *listenAddr,
size_t nmigrate_disks,
const char **migrate_disks,
const char *tls_alias)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
virStorageNetHostDef server = {
.name = (char *)listenAddr, /* cast away const */
}
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
g_autofree char *diskAlias = NULL;
/* check whether disk should be migrated */
static int
-qemuMigrationDstStopNBDServer(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMigrationCookiePtr mig)
+qemuMigrationDstStopNBDServer(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMigrationCookie *mig)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!mig->nbd)
return 0;
static void
-qemuMigrationNBDReportMirrorError(qemuBlockJobDataPtr job,
+qemuMigrationNBDReportMirrorError(qemuBlockJobData *job,
const char *diskdst)
{
if (job->errmsg) {
* -1 on error.
*/
static int
-qemuMigrationSrcNBDStorageCopyReady(virDomainObjPtr vm,
+qemuMigrationSrcNBDStorageCopyReady(virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
size_t i;
size_t notReady = 0;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuBlockJobDataPtr job;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuBlockJobData *job;
if (!diskPriv->migrating)
continue;
* -2 all mirrors are gone but some of them failed.
*/
static int
-qemuMigrationSrcNBDCopyCancelled(virDomainObjPtr vm,
+qemuMigrationSrcNBDCopyCancelled(virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
bool check)
{
retry:
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuBlockJobDataPtr job;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuBlockJobData *job;
if (!diskPriv->migrating)
continue;
* -1 on error or when job failed and failNoJob is true.
*/
static int
-qemuMigrationSrcNBDCopyCancelOne(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- qemuBlockJobDataPtr job,
+qemuMigrationSrcNBDCopyCancelOne(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
+ qemuBlockJobData *job,
bool failNoJob,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
qemuBlockJobUpdate(vm, job, asyncJob);
* Returns 0 on success, -1 otherwise.
*/
static int
-qemuMigrationSrcNBDCopyCancel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcNBDCopyCancel(virQEMUDriver *driver,
+ virDomainObj *vm,
bool check,
qemuDomainAsyncJob asyncJob,
virConnectPtr dconn)
VIR_DEBUG("Cancelling drive mirrors for domain %s", vm->def->name);
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuBlockJobDataPtr job;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuBlockJobData *job;
if (!(job = qemuBlockJobDiskGetJob(disk)) ||
!qemuBlockJobIsRunning(job))
}
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if (!diskPriv->migrSource)
continue;
static int
-qemuMigrationSrcCancelRemoveTempBitmaps(virDomainObjPtr vm,
+qemuMigrationSrcCancelRemoveTempBitmaps(virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
GSList *next;
for (next = jobPriv->migTempBitmaps; next; next = next->next) {
- qemuDomainJobPrivateMigrateTempBitmapPtr t = next->data;
+ qemuDomainJobPrivateMigrateTempBitmap *t = next->data;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1;
}
-static virStorageSourcePtr
-qemuMigrationSrcNBDStorageCopyBlockdevPrepareSource(virDomainDiskDefPtr disk,
+static virStorageSource *
+qemuMigrationSrcNBDStorageCopyBlockdevPrepareSource(virDomainDiskDef *disk,
const char *host,
int port,
const char *socket,
static int
-qemuMigrationSrcNBDStorageCopyBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuMigrationSrcNBDStorageCopyBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
const char *jobname,
const char *sourcename,
bool persistjob,
const char *tlsAlias)
{
g_autoptr(qemuBlockStorageSourceAttachData) data = NULL;
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
int mon_ret = 0;
g_autoptr(virStorageSource) copysrc = NULL;
static int
-qemuMigrationSrcNBDStorageCopyDriveMirror(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcNBDStorageCopyDriveMirror(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *diskAlias,
const char *host,
int port,
static int
-qemuMigrationSrcNBDStorageCopyOne(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
+qemuMigrationSrcNBDStorageCopyOne(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainDiskDef *disk,
const char *host,
int port,
const char *socket,
const char *tlsAlias,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuBlockJobDataPtr job = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuBlockJobData *job = NULL;
char *diskAlias = NULL;
const char *jobname = NULL;
const char *sourcename = NULL;
* -1 otherwise.
*/
static int
-qemuMigrationSrcNBDStorageCopy(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMigrationCookiePtr mig,
+qemuMigrationSrcNBDStorageCopy(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMigrationCookie *mig,
const char *host,
unsigned long speed,
unsigned int *migrate_flags,
const char *nbdURI,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int port;
size_t i;
unsigned long long mirror_speed = speed;
}
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
/* check whether disk should be migrated */
if (!qemuMigrationAnyCopyDisk(disk, nmigrate_disks, migrate_disks))
/* Migration with USB host devices is allowed, all other devices are
* forbidden. */
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = def->hostdevs[i];
+ virDomainHostdevDef *hostdev = def->hostdevs[i];
switch ((virDomainHostdevMode)hostdev->mode) {
case VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES:
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
* false otherwise.
*/
bool
-qemuMigrationSrcIsAllowed(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcIsAllowed(virQEMUDriver *driver,
+ virDomainObj *vm,
bool remote,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int nsnapshots;
int pauseReason;
size_t i;
bool block = true;
for (i = 0; i < vm->def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = vm->def->clock.timers[i];
+ virDomainTimerDef *timer = vm->def->clock.timers[i];
if (timer->name == VIR_DOMAIN_TIMER_NAME_TSC &&
timer->frequency > 0) {
/* Verify that memory device config can be transferred reliably */
for (i = 0; i < vm->def->nmems; i++) {
- virDomainMemoryDefPtr mem = vm->def->mems[i];
+ virDomainMemoryDef *mem = vm->def->mems[i];
if (mem->model == VIR_DOMAIN_MEMORY_MODEL_DIMM &&
mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM) {
}
for (i = 0; i < vm->def->nshmems; i++) {
- virDomainShmemDefPtr shmem = vm->def->shmems[i];
+ virDomainShmemDef *shmem = vm->def->shmems[i];
if (shmem->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
}
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
- qemuSlirpPtr slirp;
+ virDomainNetDef *net = vm->def->nets[i];
+ qemuSlirp *slirp;
if (net->type == VIR_DOMAIN_NET_TYPE_VDPA) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
}
for (i = 0; i < vm->def->nfss; i++) {
- virDomainFSDefPtr fs = vm->def->fss[i];
+ virDomainFSDef *fs = vm->def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
}
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
if (disk->transient) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
}
static bool
-qemuMigrationSrcIsSafe(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
+qemuMigrationSrcIsSafe(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
size_t nmigrate_disks,
const char **migrate_disks,
unsigned int flags)
int rc;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
const char *src = virDomainDiskGetSource(disk);
int actualType = virStorageSourceGetActualType(disk->src);
bool unsafe = false;
void
-qemuMigrationAnyPostcopyFailed(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuMigrationAnyPostcopyFailed(virQEMUDriver *driver,
+ virDomainObj *vm)
{
virDomainState state;
int reason;
static int
-qemuMigrationSrcWaitForSpice(virDomainObjPtr vm)
+qemuMigrationSrcWaitForSpice(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
if (!jobPriv->spiceMigration)
return 0;
static void
-qemuMigrationUpdateJobType(qemuDomainJobInfoPtr jobInfo)
+qemuMigrationUpdateJobType(qemuDomainJobInfo *jobInfo)
{
switch ((qemuMonitorMigrationStatus) jobInfo->stats.mig.status) {
case QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY:
int
-qemuMigrationAnyFetchStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationAnyFetchStats(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuDomainJobInfoPtr jobInfo,
+ qemuDomainJobInfo *jobInfo,
char **error)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorMigrationStats stats;
int rv;
static const char *
-qemuMigrationJobName(virDomainObjPtr vm)
+qemuMigrationJobName(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
switch (priv->job.asyncJob) {
case QEMU_ASYNC_JOB_MIGRATION_OUT:
static int
-qemuMigrationJobCheckStatus(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobCheckStatus(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobInfoPtr jobInfo = priv->job.current;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobInfo *jobInfo = priv->job.current;
g_autofree char *error = NULL;
bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
* -2 something else failed, we need to cancel migration.
*/
static int
-qemuMigrationAnyCompleted(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationAnyCompleted(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
virConnectPtr dconn,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobInfoPtr jobInfo = priv->job.current;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobInfo *jobInfo = priv->job.current;
int pauseReason;
if (qemuMigrationJobCheckStatus(driver, vm, asyncJob) < 0)
* QEMU reports failed migration.
*/
static int
-qemuMigrationSrcWaitForCompletion(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcWaitForCompletion(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
virConnectPtr dconn,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobInfoPtr jobInfo = priv->job.current;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobInfo *jobInfo = priv->job.current;
bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
int rv;
static int
-qemuMigrationDstWaitForCompletion(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationDstWaitForCompletion(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
bool postcopy)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned int flags = 0;
int rv;
static int
-qemuMigrationSrcGraphicsRelocate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMigrationCookiePtr cookie,
+qemuMigrationSrcGraphicsRelocate(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMigrationCookie *cookie,
const char *graphicsuri)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
const char *listenAddress = NULL;
virSocketAddr addr;
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
int type = -1;
int port = -1;
int tlsPort = -1;
port = uri->port;
for (i = 0; i < uri->paramsCount; i++) {
- virURIParamPtr param = uri->params + i;
+ virURIParam *param = uri->params + i;
if (STRCASEEQ(param->name, "tlsPort")) {
if (virStrToLong_i(param->value, NULL, 10, &tlsPort) < 0) {
if (qemuDomainObjEnterMonitorAsync(driver, vm,
QEMU_ASYNC_JOB_MIGRATION_OUT) == 0) {
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
ret = qemuMonitorGraphicsRelocate(priv->mon, type, listenAddress,
port, tlsPort, tlsSubject);
static int
-qemuMigrationDstOPDRelocate(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr vm,
- qemuMigrationCookiePtr cookie)
+qemuMigrationDstOPDRelocate(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *vm,
+ qemuMigrationCookie *cookie)
{
- virDomainNetDefPtr netptr;
+ virDomainNetDef *netptr;
size_t i;
for (i = 0; i < cookie->network->nnets; i++) {
int
-qemuMigrationDstCheckProtocol(virQEMUCapsPtr qemuCaps,
+qemuMigrationDstCheckProtocol(virQEMUCaps *qemuCaps,
const char *migrateFrom)
{
if (STRPREFIX(migrateFrom, "rdma")) {
int
-qemuMigrationDstRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationDstRun(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *uri,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rv;
VIR_DEBUG("Setting up incoming migration with URI %s", uri);
* qemuDomainMigratePerform3 and qemuDomainMigrateConfirm3.
*/
static void
-qemuMigrationSrcCleanup(virDomainObjPtr vm,
+qemuMigrationSrcCleanup(virDomainObj *vm,
virConnectPtr conn,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
VIR_DEBUG("vm=%s, conn=%p, asyncJob=%s, phase=%s",
vm->def->name, conn,
* and fills them into @mig to be offered to the destination.
*/
static int
-qemuMigrationSrcBeginPhaseBlockDirtyBitmaps(qemuMigrationCookiePtr mig,
- virDomainObjPtr vm,
+qemuMigrationSrcBeginPhaseBlockDirtyBitmaps(qemuMigrationCookie *mig,
+ virDomainObj *vm,
const char **migrate_disks,
size_t nmigrate_disks)
{
GSList *disks = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk;
+ qemuMigrationBlockDirtyBitmapsDisk *disk;
GSList *bitmaps = NULL;
- virDomainDiskDefPtr diskdef = vm->def->disks[i];
- qemuBlockNamedNodeDataPtr nodedata = virHashLookup(blockNamedNodeData, diskdef->src->nodeformat);
+ virDomainDiskDef *diskdef = vm->def->disks[i];
+ qemuBlockNamedNodeData *nodedata = virHashLookup(blockNamedNodeData, diskdef->src->nodeformat);
size_t j;
if (!nodedata)
}
for (j = 0; j < nodedata->nbitmaps; j++) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap;
if (!qemuBlockBitmapChainIsValid(diskdef->src,
nodedata->bitmaps[j]->name,
/* The caller is supposed to lock the vm and start a migration job. */
static char *
-qemuMigrationSrcBeginPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcBeginPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *xmlin,
const char *dname,
char **cookieout,
{
g_autoptr(qemuMigrationCookie) mig = NULL;
g_autoptr(virDomainDef) def = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned int cookieFlags = QEMU_MIGRATION_COOKIE_LOCKSTATE;
VIR_DEBUG("driver=%p, vm=%p, xmlin=%s, dname=%s,"
char *
qemuMigrationSrcBegin(virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *dname,
char **cookieout,
const char **migrate_disks,
unsigned long flags)
{
- virQEMUDriverPtr driver = conn->privateData;
+ virQEMUDriver *driver = conn->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
char *xml = NULL;
qemuDomainAsyncJob asyncJob;
*/
static void
-qemuMigrationDstPrepareCleanup(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuMigrationDstPrepareCleanup(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("driver=%p, vm=%s, job=%s, asyncJob=%s",
driver,
qemuDomainObjDiscardAsyncJob(driver, vm);
}
-static qemuProcessIncomingDefPtr
-qemuMigrationDstPrepare(virDomainObjPtr vm,
+static qemuProcessIncomingDef *
+qemuMigrationDstPrepare(virDomainObj *vm,
bool tunnel,
const char *protocol,
const char *listenAddress,
unsigned short port,
int fd)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *migrateFrom = NULL;
if (tunnel) {
* source.
*/
static int
-qemuMigrationDstPrepareAnyBlockDirtyBitmaps(virDomainObjPtr vm,
- qemuMigrationCookiePtr mig,
- qemuMigrationParamsPtr migParams,
+qemuMigrationDstPrepareAnyBlockDirtyBitmaps(virDomainObj *vm,
+ qemuMigrationCookie *mig,
+ qemuMigrationParams *migParams,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virJSONValue) mapping = NULL;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
GSList *nextdisk;
return -1;
for (nextdisk = mig->blockDirtyBitmaps; nextdisk; nextdisk = nextdisk->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = nextdisk->data;
- qemuBlockNamedNodeDataPtr nodedata;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = nextdisk->data;
+ qemuBlockNamedNodeData *nodedata;
GSList *nextbitmap;
if (!(nodedata = virHashLookup(blockNamedNodeData, disk->nodename))) {
}
for (nextbitmap = disk->bitmaps; nextbitmap; nextbitmap = nextbitmap->next) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap = nextbitmap->data;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap = nextbitmap->data;
size_t k;
/* don't migrate into existing bitmaps */
static int
-qemuMigrationDstPrepareAny(virQEMUDriverPtr driver,
+qemuMigrationDstPrepareAny(virQEMUDriver *driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
char **cookieout,
int *cookieoutlen,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *origname,
virStreamPtr st,
const char *protocol,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virDomainObjPtr vm = NULL;
- virObjectEventPtr event = NULL;
+ virDomainObj *vm = NULL;
+ virObjectEvent *event = NULL;
virErrorPtr origErr;
int ret = -1;
int dataFD[2] = { -1, -1 };
- qemuDomainObjPrivatePtr priv = NULL;
- qemuMigrationCookiePtr mig = NULL;
- qemuDomainJobPrivatePtr jobPriv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
+ qemuMigrationCookie *mig = NULL;
+ qemuDomainJobPrivate *jobPriv = NULL;
bool tunnel = !!st;
g_autofree char *xmlout = NULL;
unsigned int cookieFlags;
unsigned int startFlags;
- qemuProcessIncomingDefPtr incoming = NULL;
+ qemuProcessIncomingDef *incoming = NULL;
bool taint_hook = false;
bool stopProcess = false;
bool relabel = false;
* sets up the corresponding virStream to handle the incoming data.
*/
int
-qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver,
+qemuMigrationDstPrepareTunnel(virQEMUDriver *driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
char **cookieout,
int *cookieoutlen,
virStreamPtr st,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *origname,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags)
{
VIR_DEBUG("driver=%p, dconn=%p, cookiein=%s, cookieinlen=%d, "
}
-static virURIPtr
+static virURI *
qemuMigrationAnyParseURI(const char *uri, bool *wellFormed)
{
char *tmp = NULL;
- virURIPtr parsed;
+ virURI *parsed;
/* For compatibility reasons tcp://... URIs are sent as tcp:...
* We need to transform them to a well-formed URI before parsing. */
int
-qemuMigrationDstPrepareDirect(virQEMUDriverPtr driver,
+qemuMigrationDstPrepareDirect(virQEMUDriver *driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
int *cookieoutlen,
const char *uri_in,
char **uri_out,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *origname,
const char *listenAddress,
size_t nmigrate_disks,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags)
{
unsigned short port = 0;
}
-virDomainDefPtr
-qemuMigrationAnyPrepareDef(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+virDomainDef *
+qemuMigrationAnyPrepareDef(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *dom_xml,
const char *dname,
char **origname)
{
- virDomainDefPtr def;
+ virDomainDef *def;
char *name = NULL;
if (!dom_xml) {
static int
-qemuMigrationSrcConfirmPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcConfirmPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *cookiein,
int cookieinlen,
unsigned int flags,
int retcode)
{
g_autoptr(qemuMigrationCookie) mig = NULL;
- virObjectEventPtr event;
+ virObjectEvent *event;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
- qemuDomainJobInfoPtr jobInfo = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
+ qemuDomainJobInfo *jobInfo = NULL;
VIR_DEBUG("driver=%p, vm=%p, cookiein=%s, cookieinlen=%d, "
"flags=0x%x, retcode=%d",
}
int
-qemuMigrationSrcConfirm(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcConfirm(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *cookiein,
int cookieinlen,
unsigned int flags,
};
typedef struct _qemuMigrationSpec qemuMigrationSpec;
-typedef qemuMigrationSpec *qemuMigrationSpecPtr;
struct _qemuMigrationSpec {
enum qemuMigrationDestinationType destType;
union {
#define TUNNEL_SEND_BUF_SIZE 65536
typedef struct _qemuMigrationIOThread qemuMigrationIOThread;
-typedef qemuMigrationIOThread *qemuMigrationIOThreadPtr;
struct _qemuMigrationIOThread {
virThread thread;
virStreamPtr st;
static void qemuMigrationSrcIOFunc(void *arg)
{
- qemuMigrationIOThreadPtr data = arg;
+ qemuMigrationIOThread *data = arg;
char *buffer = NULL;
struct pollfd fds[2];
int timeout = -1;
}
-static qemuMigrationIOThreadPtr
+static qemuMigrationIOThread *
qemuMigrationSrcStartTunnel(virStreamPtr st,
int sock)
{
- qemuMigrationIOThreadPtr io = NULL;
+ qemuMigrationIOThread *io = NULL;
int wakeupFD[2] = { -1, -1 };
if (virPipe(wakeupFD) < 0)
}
static int
-qemuMigrationSrcStopTunnel(qemuMigrationIOThreadPtr io, bool error)
+qemuMigrationSrcStopTunnel(qemuMigrationIOThread *io, bool error)
{
int rv = -1;
char stop = error ? 1 : 0;
}
static int
-qemuMigrationSrcConnect(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMigrationSpecPtr spec)
+qemuMigrationSrcConnect(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMigrationSpec *spec)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
g_autofree char *port = NULL;
int fd_qemu = -1;
int ret = -1;
static int
-qemuMigrationSrcContinue(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcContinue(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMonitorMigrationStatus status,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
static int
-qemuMigrationSetDBusVMState(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuMigrationSetDBusVMState(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->dbusVMStateIds) {
int rv;
* bitmaps for deletion on failed migration.
*/
static int
-qemuMigrationSrcRunPrepareBlockDirtyBitmapsMerge(virDomainObjPtr vm,
- qemuMigrationCookiePtr mig)
+qemuMigrationSrcRunPrepareBlockDirtyBitmapsMerge(virDomainObj *vm,
+ qemuMigrationCookie *mig)
{
g_autoslist(qemuDomainJobPrivateMigrateTempBitmap) tmpbitmaps = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virJSONValue) actions = virJSONValueNewArray();
g_autoptr(GHashTable) blockNamedNodeData = NULL;
GSList *nextdisk;
return -1;
for (nextdisk = mig->blockDirtyBitmaps; nextdisk; nextdisk = nextdisk->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = nextdisk->data;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = nextdisk->data;
GSList *nextbitmap;
/* if a disk doesn't have a backing chain we don't need the code below */
continue;
for (nextbitmap = disk->bitmaps; nextbitmap; nextbitmap = nextbitmap->next) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap = nextbitmap->data;
- qemuDomainJobPrivateMigrateTempBitmapPtr tmpbmp;
- virStorageSourcePtr n;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap = nextbitmap->data;
+ qemuDomainJobPrivateMigrateTempBitmap *tmpbmp;
+ virStorageSource *n;
unsigned long long granularity = 0;
g_autoptr(virJSONValue) merge = virJSONValueNewArray();
for (n = disk->disk->src; virStorageSourceIsBacking(n); n = n->backingStore) {
- qemuBlockNamedNodeDataBitmapPtr b;
+ qemuBlockNamedNodeDataBitmap *b;
if (!(b = qemuBlockNamedNodeDataGetBitmapByName(blockNamedNodeData, n,
bitmap->bitmapname)))
* for bitmaps.
*/
static int
-qemuMigrationSrcRunPrepareBlockDirtyBitmaps(virDomainObjPtr vm,
- qemuMigrationCookiePtr mig,
- qemuMigrationParamsPtr migParams,
+qemuMigrationSrcRunPrepareBlockDirtyBitmaps(virDomainObj *vm,
+ qemuMigrationCookie *mig,
+ qemuMigrationParams *migParams,
unsigned int flags)
{
static int
-qemuMigrationSrcRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcRun(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *persist_xml,
const char *cookiein,
int cookieinlen,
int *cookieoutlen,
unsigned long flags,
unsigned long resource,
- qemuMigrationSpecPtr spec,
+ qemuMigrationSpec *spec,
virConnectPtr dconn,
const char *graphicsuri,
size_t nmigrate_disks,
const char **migrate_disks,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *nbdURI)
{
int ret = -1;
unsigned int migrate_flags = QEMU_MONITOR_MIGRATE_BACKGROUND;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(qemuMigrationCookie) mig = NULL;
g_autofree char *tlsAlias = NULL;
- qemuMigrationIOThreadPtr iothread = NULL;
+ qemuMigrationIOThread *iothread = NULL;
VIR_AUTOCLOSE fd = -1;
unsigned long migrate_speed = resource ? resource : priv->migMaxBandwidth;
virErrorPtr orig_err = NULL;
NULL, NULL)))
goto error;
} else {
- virDomainDefPtr def = vm->newDef ? vm->newDef : vm->def;
+ virDomainDef *def = vm->newDef ? vm->newDef : vm->def;
if (!(persistDef = qemuDomainDefCopy(driver, priv->qemuCaps, def,
VIR_DOMAIN_XML_SECURE |
VIR_DOMAIN_XML_MIGRATABLE)))
}
if (iothread) {
- qemuMigrationIOThreadPtr io;
+ qemuMigrationIOThread *io;
io = g_steal_pointer(&iothread);
if (qemuMigrationSrcStopTunnel(io, false) < 0)
* not encrypted obviously
*/
static int
-qemuMigrationSrcPerformNative(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcPerformNative(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *persist_xml,
const char *uri,
const char *cookiein,
const char *graphicsuri,
size_t nmigrate_disks,
const char **migrate_disks,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *nbdURI)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virURI) uribits = NULL;
int ret = -1;
qemuMigrationSpec spec;
static int
-qemuMigrationSrcPerformTunnel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcPerformTunnel(virQEMUDriver *driver,
+ virDomainObj *vm,
virStreamPtr st,
const char *persist_xml,
const char *cookiein,
const char *graphicsuri,
size_t nmigrate_disks,
const char **migrate_disks,
- qemuMigrationParamsPtr migParams)
+ qemuMigrationParams *migParams)
{
int ret = -1;
qemuMigrationSpec spec;
* instead of client app context & also adding in tunnel
* handling */
static int
-qemuMigrationSrcPerformPeer2Peer2(virQEMUDriverPtr driver,
+qemuMigrationSrcPerformPeer2Peer2(virQEMUDriver *driver,
virConnectPtr sconn,
virConnectPtr dconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *dconnuri,
unsigned long flags,
const char *dname,
unsigned long resource,
- qemuMigrationParamsPtr migParams)
+ qemuMigrationParams *migParams)
{
virDomainPtr ddomain = NULL;
char *uri_out = NULL;
* instead of client app context & also adding in tunnel
* handling */
static int
-qemuMigrationSrcPerformPeer2Peer3(virQEMUDriverPtr driver,
+qemuMigrationSrcPerformPeer2Peer3(virQEMUDriver *driver,
virConnectPtr sconn,
virConnectPtr dconn,
const char *dconnuri,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *persist_xml,
const char *dname,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long long bandwidth,
bool useParams,
unsigned long flags)
int reason,
void *opaque)
{
- virDomainObjPtr vm = opaque;
+ virDomainObj *vm = opaque;
VIR_DEBUG("conn=%p, reason=%d, vm=%s", conn, reason, vm->def->name);
virDomainObjBroadcast(vm);
static int
-qemuMigrationSrcPerformPeer2Peer(virQEMUDriverPtr driver,
+qemuMigrationSrcPerformPeer2Peer(virQEMUDriver *driver,
virConnectPtr sconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *persist_xml,
const char *dconnuri,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags,
const char *dname,
unsigned long resource,
* perform phase of v2 non-peer2peer migration.
*/
static int
-qemuMigrationSrcPerformJob(virQEMUDriverPtr driver,
+qemuMigrationSrcPerformJob(virQEMUDriver *driver,
virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *persist_xml,
const char *dconnuri,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *cookiein,
int cookieinlen,
char **cookieout,
unsigned long resource,
bool v3proto)
{
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
int ret = -1;
virErrorPtr orig_err = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
if (qemuMigrationJobStart(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT,
flags) < 0)
* This implements perform phase of v3 migration protocol.
*/
static int
-qemuMigrationSrcPerformPhase(virQEMUDriverPtr driver,
+qemuMigrationSrcPerformPhase(virQEMUDriver *driver,
virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *persist_xml,
const char *uri,
const char *graphicsuri,
size_t nmigrate_disks,
const char **migrate_disks,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *cookiein,
int cookieinlen,
char **cookieout,
unsigned long resource,
const char *nbdURI)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
int ret = -1;
/* If we didn't start the job in the begin phase, start it now. */
}
int
-qemuMigrationSrcPerform(virQEMUDriverPtr driver,
+qemuMigrationSrcPerform(virQEMUDriver *driver,
virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *persist_xml,
const char *dconnuri,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *cookiein,
int cookieinlen,
char **cookieout,
}
static int
-qemuMigrationDstVPAssociatePortProfiles(virDomainDefPtr def)
+qemuMigrationDstVPAssociatePortProfiles(virDomainDef *def)
{
size_t i;
int last_good_net = -1;
- virDomainNetDefPtr net;
+ virDomainNetDef *net;
for (i = 0; i < def->nnets; i++) {
net = def->nets[i];
static int
-qemuMigrationDstPersist(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuMigrationCookiePtr mig,
+qemuMigrationDstPersist(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuMigrationCookie *mig,
bool ignoreSaveError)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr vmdef;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *vmdef;
g_autoptr(virDomainDef) oldDef = NULL;
unsigned int oldPersist = vm->persistent;
- virObjectEventPtr event;
+ virObjectEvent *event;
vm->persistent = 1;
oldDef = vm->newDef;
virDomainPtr
-qemuMigrationDstFinish(virQEMUDriverPtr driver,
+qemuMigrationDstFinish(virQEMUDriver *driver,
virConnectPtr dconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *cookiein,
int cookieinlen,
char **cookieout,
g_autoptr(qemuMigrationCookie) mig = NULL;
virErrorPtr orig_err = NULL;
int cookie_flags = 0;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
unsigned short port;
unsigned long long timeReceived = 0;
- virObjectEventPtr event;
- qemuDomainJobInfoPtr jobInfo = NULL;
+ virObjectEvent *event;
+ qemuDomainJobInfo *jobInfo = NULL;
bool inPostCopy = false;
bool doKill = true;
/* Helper function called while vm is active. */
int
-qemuMigrationSrcToFile(virQEMUDriverPtr driver, virDomainObjPtr vm,
+qemuMigrationSrcToFile(virQEMUDriver *driver, virDomainObj *vm,
int fd,
- virCommandPtr compressor,
+ virCommand *compressor,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool bwParam = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_PARAM_BANDWIDTH);
int rc;
int ret = -1;
int
-qemuMigrationSrcCancel(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuMigrationSrcCancel(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool storage = false;
size_t i;
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuBlockJobDataPtr job;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuBlockJobData *job;
if (!(job = qemuBlockJobDiskGetJob(disk)) ||
!qemuBlockJobIsRunning(job))
static int
-qemuMigrationJobStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobStart(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob job,
unsigned long apiFlags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainJobOperation op;
unsigned long long mask;
}
static void
-qemuMigrationJobSetPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobSetPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMigrationJobPhase phase)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (phase < priv->job.phase) {
VIR_ERROR(_("migration protocol going backwards %s => %s"),
}
static void
-qemuMigrationJobStartPhase(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationJobStartPhase(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuMigrationJobPhase phase)
{
qemuMigrationJobSetPhase(driver, vm, phase);
}
static void
-qemuMigrationJobContinue(virDomainObjPtr vm)
+qemuMigrationJobContinue(virDomainObj *vm)
{
qemuDomainObjReleaseAsyncJob(vm);
}
static bool
-qemuMigrationJobIsActive(virDomainObjPtr vm,
+qemuMigrationJobIsActive(virDomainObj *vm,
qemuDomainAsyncJob job)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->job.asyncJob != job) {
const char *msg;
}
static void
-qemuMigrationJobFinish(virQEMUDriverPtr driver, virDomainObjPtr vm)
+qemuMigrationJobFinish(virQEMUDriver *driver, virDomainObj *vm)
{
qemuDomainObjEndAsyncJob(driver, vm);
}
}
int
-qemuMigrationDstErrorInit(virQEMUDriverPtr driver)
+qemuMigrationDstErrorInit(virQEMUDriver *driver)
{
driver->migrationErrors = virHashAtomicNew(qemuMigrationDstErrorFree);
if (driver->migrationErrors)
* invalid after calling this function.
*/
void
-qemuMigrationDstErrorSave(virQEMUDriverPtr driver,
+qemuMigrationDstErrorSave(virQEMUDriver *driver,
const char *name,
virErrorPtr err)
{
}
void
-qemuMigrationDstErrorReport(virQEMUDriverPtr driver,
+qemuMigrationDstErrorReport(virQEMUDriver *driver,
const char *name)
{
virErrorPtr err;
int
-qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuDomainJobInfoPtr jobInfo)
+ qemuDomainJobInfo *jobInfo)
{
size_t i;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool nbd = false;
GHashTable *blockinfo = NULL;
- qemuDomainMirrorStatsPtr stats = &jobInfo->mirrorStats;
+ qemuDomainMirrorStats *stats = &jobInfo->mirrorStats;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
if (QEMU_DOMAIN_DISK_PRIVATE(disk)->migrating) {
nbd = true;
break;
memset(stats, 0, sizeof(*stats));
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
- qemuMonitorBlockJobInfoPtr data;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ qemuMonitorBlockJobInfo *data;
if (!diskPriv->migrating ||
!(data = virHashLookup(blockinfo, disk->info.alias)))
char *
qemuMigrationSrcBegin(virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *dname,
char **cookieout,
const char **migrate_disks,
unsigned long flags);
-virDomainDefPtr
-qemuMigrationAnyPrepareDef(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+virDomainDef *
+qemuMigrationAnyPrepareDef(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *dom_xml,
const char *dname,
char **origname);
int
-qemuMigrationDstPrepareTunnel(virQEMUDriverPtr driver,
+qemuMigrationDstPrepareTunnel(virQEMUDriver *driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
char **cookieout,
int *cookieoutlen,
virStreamPtr st,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *origname,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags);
int
-qemuMigrationDstPrepareDirect(virQEMUDriverPtr driver,
+qemuMigrationDstPrepareDirect(virQEMUDriver *driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
int *cookieoutlen,
const char *uri_in,
char **uri_out,
- virDomainDefPtr *def,
+ virDomainDef **def,
const char *origname,
const char *listenAddress,
size_t nmigrate_disks,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
unsigned long flags);
int
-qemuMigrationSrcPerform(virQEMUDriverPtr driver,
+qemuMigrationSrcPerform(virQEMUDriver *driver,
virConnectPtr conn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlin,
const char *persist_xml,
const char *dconnuri,
const char **migrate_disks,
int nbdPort,
const char *nbdURI,
- qemuMigrationParamsPtr migParams,
+ qemuMigrationParams *migParams,
const char *cookiein,
int cookieinlen,
char **cookieout,
bool v3proto);
virDomainPtr
-qemuMigrationDstFinish(virQEMUDriverPtr driver,
+qemuMigrationDstFinish(virQEMUDriver *driver,
virConnectPtr dconn,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *cookiein,
int cookieinlen,
char **cookieout,
bool v3proto);
int
-qemuMigrationSrcConfirm(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcConfirm(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *cookiein,
int cookieinlen,
unsigned int flags,
int cancelled);
bool
-qemuMigrationSrcIsAllowed(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcIsAllowed(virQEMUDriver *driver,
+ virDomainObj *vm,
bool remote,
unsigned int flags);
int
-qemuMigrationSrcToFile(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcToFile(virQEMUDriver *driver,
+ virDomainObj *vm,
int fd,
- virCommandPtr compressor,
+ virCommand *compressor,
qemuDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int
-qemuMigrationSrcCancel(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+qemuMigrationSrcCancel(virQEMUDriver *driver,
+ virDomainObj *vm);
int
-qemuMigrationAnyFetchStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationAnyFetchStats(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuDomainJobInfoPtr jobInfo,
+ qemuDomainJobInfo *jobInfo,
char **error);
int
-qemuMigrationDstErrorInit(virQEMUDriverPtr driver);
+qemuMigrationDstErrorInit(virQEMUDriver *driver);
void
-qemuMigrationDstErrorSave(virQEMUDriverPtr driver,
+qemuMigrationDstErrorSave(virQEMUDriver *driver,
const char *name,
virErrorPtr err);
void
-qemuMigrationDstErrorReport(virQEMUDriverPtr driver,
+qemuMigrationDstErrorReport(virQEMUDriver *driver,
const char *name);
int
-qemuMigrationDstCheckProtocol(virQEMUCapsPtr qemuCaps,
+qemuMigrationDstCheckProtocol(virQEMUCaps *qemuCaps,
const char *migrateFrom);
char *
int migrateFd);
int
-qemuMigrationDstRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationDstRun(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *uri,
qemuDomainAsyncJob asyncJob);
void
-qemuMigrationAnyPostcopyFailed(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+qemuMigrationAnyPostcopyFailed(virQEMUDriver *driver,
+ virDomainObj *vm);
int
-qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuDomainJobInfoPtr jobInfo);
+ qemuDomainJobInfo *jobInfo);
static void
-qemuMigrationCookieGraphicsFree(qemuMigrationCookieGraphicsPtr grap)
+qemuMigrationCookieGraphicsFree(qemuMigrationCookieGraphics *grap)
{
if (!grap)
return;
static void
-qemuMigrationCookieNetworkFree(qemuMigrationCookieNetworkPtr network)
+qemuMigrationCookieNetworkFree(qemuMigrationCookieNetwork *network)
{
size_t i;
qemuMigrationCookieNetworkFree);
static void
-qemuMigrationCookieNBDFree(qemuMigrationCookieNBDPtr nbd)
+qemuMigrationCookieNBDFree(qemuMigrationCookieNBD *nbd)
{
if (!nbd)
return;
qemuMigrationCookieNBDFree);
static void
-qemuMigrationCookieCapsFree(qemuMigrationCookieCapsPtr caps)
+qemuMigrationCookieCapsFree(qemuMigrationCookieCaps *caps)
{
if (!caps)
return;
qemuMigrationCookieCapsFree);
static void
-qemuMigrationBlockDirtyBitmapsDiskBitmapFree(qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bmp)
+qemuMigrationBlockDirtyBitmapsDiskBitmapFree(qemuMigrationBlockDirtyBitmapsDiskBitmap *bmp)
{
if (!bmp)
return;
static void
-qemuMigrationBlockDirtyBitmapsDiskFree(qemuMigrationBlockDirtyBitmapsDiskPtr dsk)
+qemuMigrationBlockDirtyBitmapsDiskFree(qemuMigrationBlockDirtyBitmapsDisk *dsk)
{
if (!dsk)
return;
void
-qemuMigrationCookieFree(qemuMigrationCookiePtr mig)
+qemuMigrationCookieFree(qemuMigrationCookie *mig)
{
if (!mig)
return;
}
-static qemuMigrationCookieGraphicsPtr
-qemuMigrationCookieGraphicsSpiceAlloc(virQEMUDriverPtr driver,
- virDomainGraphicsDefPtr def,
- virDomainGraphicsListenDefPtr glisten)
+static qemuMigrationCookieGraphics *
+qemuMigrationCookieGraphicsSpiceAlloc(virQEMUDriver *driver,
+ virDomainGraphicsDef *def,
+ virDomainGraphicsListenDef *glisten)
{
g_autoptr(qemuMigrationCookieGraphics) mig = g_new0(qemuMigrationCookieGraphics, 1);
const char *listenAddr;
}
-static qemuMigrationCookieNetworkPtr
-qemuMigrationCookieNetworkAlloc(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainDefPtr def)
+static qemuMigrationCookieNetwork *
+qemuMigrationCookieNetworkAlloc(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainDef *def)
{
g_autoptr(qemuMigrationCookieNetwork) mig = g_new0(qemuMigrationCookieNetwork, 1);
size_t i;
mig->net = g_new0(qemuMigrationCookieNetData, def->nnets);
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr netptr;
+ virDomainNetDef *netptr;
const virNetDevVPortProfile *vport;
netptr = def->nets[i];
}
-qemuMigrationCookiePtr
+qemuMigrationCookie *
qemuMigrationCookieNew(const virDomainDef *def,
const char *origname)
{
- qemuMigrationCookiePtr mig = NULL;
+ qemuMigrationCookie *mig = NULL;
unsigned char localHostUUID[VIR_UUID_BUFLEN];
g_autofree char *localHostname = NULL;
static int
-qemuMigrationCookieAddGraphics(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr dom)
+qemuMigrationCookieAddGraphics(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *dom)
{
size_t i = 0;
for (i = 0; i < dom->def->ngraphics; i++) {
if (dom->def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
- virDomainGraphicsListenDefPtr glisten =
+ virDomainGraphicsListenDef *glisten =
virDomainGraphicsGetListen(dom->def->graphics[i], 0);
if (!glisten) {
static int
-qemuMigrationCookieAddLockstate(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr dom)
+qemuMigrationCookieAddLockstate(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *dom)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
if (mig->flags & QEMU_MIGRATION_COOKIE_LOCKSTATE) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
int
-qemuMigrationCookieAddPersistent(qemuMigrationCookiePtr mig,
- virDomainDefPtr *def)
+qemuMigrationCookieAddPersistent(qemuMigrationCookie *mig,
+ virDomainDef **def)
{
if (mig->flags & QEMU_MIGRATION_COOKIE_PERSISTENT) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-virDomainDefPtr
-qemuMigrationCookieGetPersistent(qemuMigrationCookiePtr mig)
+virDomainDef *
+qemuMigrationCookieGetPersistent(qemuMigrationCookie *mig)
{
- virDomainDefPtr def = mig->persistent;
+ virDomainDef *def = mig->persistent;
mig->persistent = NULL;
mig->flags &= ~QEMU_MIGRATION_COOKIE_PERSISTENT;
static int
-qemuMigrationCookieAddNetwork(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr dom)
+qemuMigrationCookieAddNetwork(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *dom)
{
if (mig->flags & QEMU_MIGRATION_COOKIE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
-qemuMigrationCookieAddNBD(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuMigrationCookieAddNBD(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) stats = virHashNew(g_free);
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
size_t i;
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
qemuBlockStats *entry;
if (blockdev) {
static int
-qemuMigrationCookieAddStatistics(qemuMigrationCookiePtr mig,
- virDomainObjPtr vm)
+qemuMigrationCookieAddStatistics(qemuMigrationCookie *mig,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!priv->job.completed)
return 0;
static int
-qemuMigrationCookieAddCPU(qemuMigrationCookiePtr mig,
- virDomainObjPtr vm)
+qemuMigrationCookieAddCPU(qemuMigrationCookie *mig,
+ virDomainObj *vm)
{
if (mig->cpu)
return 0;
static void
-qemuMigrationCookieAddAllowReboot(qemuMigrationCookiePtr mig,
- virDomainObjPtr vm)
+qemuMigrationCookieAddAllowReboot(qemuMigrationCookie *mig,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
mig->allowReboot = priv->allowReboot;
static int
-qemuMigrationCookieAddCaps(qemuMigrationCookiePtr mig,
- virDomainObjPtr vm,
+qemuMigrationCookieAddCaps(qemuMigrationCookie *mig,
+ virDomainObj *vm,
qemuMigrationParty party)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
qemuMigrationCookieCapsFree(mig->caps);
mig->caps = g_new0(qemuMigrationCookieCaps, 1);
static void
-qemuMigrationCookieGraphicsXMLFormat(virBufferPtr buf,
- qemuMigrationCookieGraphicsPtr grap)
+qemuMigrationCookieGraphicsXMLFormat(virBuffer *buf,
+ qemuMigrationCookieGraphics *grap)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-qemuMigrationCookieNetworkXMLFormat(virBufferPtr buf,
- qemuMigrationCookieNetworkPtr optr)
+qemuMigrationCookieNetworkXMLFormat(virBuffer *buf,
+ qemuMigrationCookieNetwork *optr)
{
g_auto(virBuffer) interfaceBuf = VIR_BUFFER_INIT_CHILD(buf);
size_t i;
static void
-qemuMigrationCookieStatisticsXMLFormat(virBufferPtr buf,
- qemuDomainJobInfoPtr jobInfo)
+qemuMigrationCookieStatisticsXMLFormat(virBuffer *buf,
+ qemuDomainJobInfo *jobInfo)
{
qemuMonitorMigrationStats *stats = &jobInfo->stats.mig;
static void
-qemuMigrationCookieCapsXMLFormat(virBufferPtr buf,
- qemuMigrationCookieCapsPtr caps)
+qemuMigrationCookieCapsXMLFormat(virBuffer *buf,
+ qemuMigrationCookieCaps *caps)
{
qemuMigrationCapability cap;
static void
-qemuMigrationCookieNBDXMLFormat(qemuMigrationCookieNBDPtr nbd,
- virBufferPtr buf)
+qemuMigrationCookieNBDXMLFormat(qemuMigrationCookieNBD *nbd,
+ virBuffer *buf)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childBuf = VIR_BUFFER_INIT_CHILD(buf);
static void
-qemuMigrationCookieBlockDirtyBitmapsFormat(virBufferPtr buf,
+qemuMigrationCookieBlockDirtyBitmapsFormat(virBuffer *buf,
GSList *bitmaps)
{
g_auto(virBuffer) disksBuf = VIR_BUFFER_INIT_CHILD(buf);
GSList *nextdisk;
for (nextdisk = bitmaps; nextdisk; nextdisk = nextdisk->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = nextdisk->data;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = nextdisk->data;
g_auto(virBuffer) diskAttrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) diskChildBuf = VIR_BUFFER_INIT_CHILD(&disksBuf);
bool hasBitmaps = false;
continue;
for (nextbitmap = disk->bitmaps; nextbitmap; nextbitmap = nextbitmap->next) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap = nextbitmap->data;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap = nextbitmap->data;
if (bitmap->skip)
continue;
int
-qemuMigrationCookieXMLFormat(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virBufferPtr buf,
- qemuMigrationCookiePtr mig)
+qemuMigrationCookieXMLFormat(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virBuffer *buf,
+ qemuMigrationCookie *mig)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
char hostuuidstr[VIR_UUID_STRING_BUFLEN];
}
-static qemuMigrationCookieGraphicsPtr
+static qemuMigrationCookieGraphics *
qemuMigrationCookieGraphicsXMLParse(xmlXPathContextPtr ctxt)
{
g_autoptr(qemuMigrationCookieGraphics) grap = g_new0(qemuMigrationCookieGraphics, 1);
}
-static qemuMigrationCookieNetworkPtr
+static qemuMigrationCookieNetwork *
qemuMigrationCookieNetworkXMLParse(xmlXPathContextPtr ctxt)
{
g_autoptr(qemuMigrationCookieNetwork) optr = g_new0(qemuMigrationCookieNetwork, 1);
}
-static qemuMigrationCookieNBDPtr
+static qemuMigrationCookieNBD *
qemuMigrationCookieNBDXMLParse(xmlXPathContextPtr ctxt)
{
g_autoptr(qemuMigrationCookieNBD) ret = g_new0(qemuMigrationCookieNBD, 1);
}
-static qemuDomainJobInfoPtr
+static qemuDomainJobInfo *
qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
{
- qemuDomainJobInfoPtr jobInfo = NULL;
+ qemuDomainJobInfo *jobInfo = NULL;
qemuMonitorMigrationStats *stats;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
}
-static qemuMigrationCookieCapsPtr
+static qemuMigrationCookieCaps *
qemuMigrationCookieCapsXMLParse(xmlXPathContextPtr ctxt)
{
g_autoptr(qemuMigrationCookieCaps) caps = g_new0(qemuMigrationCookieCaps, 1);
static int
qemuMigrationCookieBlockDirtyBitmapsParse(xmlXPathContextPtr ctxt,
- qemuMigrationCookiePtr mig)
+ qemuMigrationCookie *mig)
{
g_autoslist(qemuMigrationBlockDirtyBitmapsDisk) disks = NULL;
g_autofree xmlNodePtr *disknodes = NULL;
for (i = 0; i < ndisknodes; i++) {
g_autoslist(qemuMigrationBlockDirtyBitmapsDiskBitmap) bitmaps = NULL;
- qemuMigrationBlockDirtyBitmapsDiskPtr disk;
+ qemuMigrationBlockDirtyBitmapsDisk *disk;
g_autofree xmlNodePtr *bitmapnodes = NULL;
int nbitmapnodes;
size_t j;
return -1;
for (j = 0; j < nbitmapnodes; j++) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap;
bitmap = g_new0(qemuMigrationBlockDirtyBitmapsDiskBitmap, 1);
bitmap->bitmapname = virXMLPropString(bitmapnodes[j], "name");
static int
-qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+qemuMigrationCookieXMLParse(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
xmlDocPtr doc,
xmlXPathContextPtr ctxt,
unsigned int flags)
static int
-qemuMigrationCookieXMLParseStr(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+qemuMigrationCookieXMLParseStr(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *xml,
unsigned int flags)
{
int
-qemuMigrationCookieFormat(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr dom,
+qemuMigrationCookieFormat(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *dom,
qemuMigrationParty party,
char **cookieout,
int *cookieoutlen,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = dom->privateData;
+ qemuDomainObjPrivate *priv = dom->privateData;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (!cookieout || !cookieoutlen)
}
-qemuMigrationCookiePtr
-qemuMigrationCookieParse(virQEMUDriverPtr driver,
+qemuMigrationCookie *
+qemuMigrationCookieParse(virQEMUDriver *driver,
const virDomainDef *def,
const char *origname,
- qemuDomainObjPrivatePtr priv,
+ qemuDomainObjPrivate *priv,
const char *cookiein,
int cookieinlen,
unsigned int flags)
/**
* qemuMigrationCookieBlockDirtyBitmapsMatchDisks:
* @def: domain definition
- * @disks: list of qemuMigrationBlockDirtyBitmapsDiskPtr
+ * @disks: list of qemuMigrationBlockDirtyBitmapsDisk *
*
* Matches all of the @disks to the actual domain disk definition objects
* by looking up the target.
*/
int
-qemuMigrationCookieBlockDirtyBitmapsMatchDisks(virDomainDefPtr def,
+qemuMigrationCookieBlockDirtyBitmapsMatchDisks(virDomainDef *def,
GSList *disks)
{
GSList *next;
for (next = disks; next; next = next->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = next->data;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = next->data;
if (!(disk->disk = virDomainDiskByTarget(def, disk->target))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
*/
int
qemuMigrationCookieBlockDirtyBitmapsToParams(GSList *disks,
- virJSONValuePtr *mapping)
+ virJSONValue **mapping)
{
g_autoptr(virJSONValue) map = virJSONValueNewArray();
bool hasDisks = false;
GSList *nextdisk;
for (nextdisk = disks; nextdisk; nextdisk = nextdisk->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = nextdisk->data;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = nextdisk->data;
g_autoptr(virJSONValue) jsondisk = NULL;
g_autoptr(virJSONValue) jsonbitmaps = virJSONValueNewArray();
bool hasBitmaps = false;
continue;
for (nextbitmap = disk->bitmaps; nextbitmap; nextbitmap = nextbitmap->next) {
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap = nextbitmap->data;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap = nextbitmap->data;
g_autoptr(virJSONValue) jsonbitmap = NULL;
g_autoptr(virJSONValue) transform = NULL;
const char *bitmapname = bitmap->sourcebitmap;
} qemuMigrationCookieFeatures;
typedef struct _qemuMigrationCookieGraphics qemuMigrationCookieGraphics;
-typedef qemuMigrationCookieGraphics *qemuMigrationCookieGraphicsPtr;
struct _qemuMigrationCookieGraphics {
int type;
int port;
};
typedef struct _qemuMigrationCookieNetData qemuMigrationCookieNetData;
-typedef qemuMigrationCookieNetData *qemuMigrationCookieNetDataPtr;
struct _qemuMigrationCookieNetData {
int vporttype; /* enum virNetDevVPortProfile */
};
typedef struct _qemuMigrationCookieNetwork qemuMigrationCookieNetwork;
-typedef qemuMigrationCookieNetwork *qemuMigrationCookieNetworkPtr;
struct _qemuMigrationCookieNetwork {
/* How many virtual NICs are we saving data for? */
int nnets;
- qemuMigrationCookieNetDataPtr net;
+ qemuMigrationCookieNetData *net;
};
struct qemuMigrationCookieNBDDisk {
};
typedef struct _qemuMigrationCookieNBD qemuMigrationCookieNBD;
-typedef qemuMigrationCookieNBD *qemuMigrationCookieNBDPtr;
struct _qemuMigrationCookieNBD {
int port; /* on which port does NBD server listen for incoming data */
};
typedef struct _qemuMigrationCookieCaps qemuMigrationCookieCaps;
-typedef qemuMigrationCookieCaps *qemuMigrationCookieCapsPtr;
struct _qemuMigrationCookieCaps {
- virBitmapPtr supported;
- virBitmapPtr automatic;
+ virBitmap *supported;
+ virBitmap *automatic;
};
typedef struct _qemuMigrationBlockDirtyBitmapsDiskBitmap qemuMigrationBlockDirtyBitmapsDiskBitmap;
-typedef qemuMigrationBlockDirtyBitmapsDiskBitmap *qemuMigrationBlockDirtyBitmapsDiskBitmapPtr;
struct _qemuMigrationBlockDirtyBitmapsDiskBitmap {
/* config */
char *bitmapname;
typedef struct _qemuMigrationBlockDirtyBitmapsDisk qemuMigrationBlockDirtyBitmapsDisk;
-typedef qemuMigrationBlockDirtyBitmapsDisk *qemuMigrationBlockDirtyBitmapsDiskPtr;
struct _qemuMigrationBlockDirtyBitmapsDisk {
char *target;
GSList *bitmaps;
/* runtime data */
- virDomainDiskDefPtr disk; /* disk object corresponding to 'target' */
+ virDomainDiskDef *disk; /* disk object corresponding to 'target' */
const char *nodename; /* nodename of the top level source of 'disk' */
bool skip; /* omit this disk */
};
typedef struct _qemuMigrationCookie qemuMigrationCookie;
-typedef qemuMigrationCookie *qemuMigrationCookiePtr;
struct _qemuMigrationCookie {
unsigned int flags;
unsigned int flagsMandatory;
char *lockDriver;
/* If (flags & QEMU_MIGRATION_COOKIE_GRAPHICS) */
- qemuMigrationCookieGraphicsPtr graphics;
+ qemuMigrationCookieGraphics *graphics;
/* If (flags & QEMU_MIGRATION_COOKIE_PERSISTENT) */
- virDomainDefPtr persistent;
+ virDomainDef *persistent;
/* If (flags & QEMU_MIGRATION_COOKIE_NETWORK) */
- qemuMigrationCookieNetworkPtr network;
+ qemuMigrationCookieNetwork *network;
/* If (flags & QEMU_MIGRATION_COOKIE_NBD) */
- qemuMigrationCookieNBDPtr nbd;
+ qemuMigrationCookieNBD *nbd;
/* If (flags & QEMU_MIGRATION_COOKIE_STATS) */
- qemuDomainJobInfoPtr jobInfo;
+ qemuDomainJobInfo *jobInfo;
/* If flags & QEMU_MIGRATION_COOKIE_CPU */
- virCPUDefPtr cpu;
+ virCPUDef *cpu;
/* If flags & QEMU_MIGRATION_COOKIE_ALLOW_REBOOT */
virTristateBool allowReboot;
/* If flags & QEMU_MIGRATION_COOKIE_CAPS */
- qemuMigrationCookieCapsPtr caps;
+ qemuMigrationCookieCaps *caps;
/* If flags & QEMU_MIGRATION_COOKIE_BLOCK_DIRTY_BITMAPS */
GSList *blockDirtyBitmaps;
};
-qemuMigrationCookiePtr
+qemuMigrationCookie *
qemuMigrationCookieNew(const virDomainDef *def,
const char *origname);
int
-qemuMigrationCookieFormat(qemuMigrationCookiePtr mig,
- virQEMUDriverPtr driver,
- virDomainObjPtr dom,
+qemuMigrationCookieFormat(qemuMigrationCookie *mig,
+ virQEMUDriver *driver,
+ virDomainObj *dom,
qemuMigrationParty party,
char **cookieout,
int *cookieoutlen,
unsigned int flags);
-qemuMigrationCookiePtr
-qemuMigrationCookieParse(virQEMUDriverPtr driver,
+qemuMigrationCookie *
+qemuMigrationCookieParse(virQEMUDriver *driver,
const virDomainDef *def,
const char *origname,
- qemuDomainObjPrivatePtr priv,
+ qemuDomainObjPrivate *priv,
const char *cookiein,
int cookieinlen,
unsigned int flags);
void
-qemuMigrationCookieFree(qemuMigrationCookiePtr mig);
+qemuMigrationCookieFree(qemuMigrationCookie *mig);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMigrationCookie, qemuMigrationCookieFree);
int
-qemuMigrationCookieAddPersistent(qemuMigrationCookiePtr mig,
- virDomainDefPtr *def);
+qemuMigrationCookieAddPersistent(qemuMigrationCookie *mig,
+ virDomainDef **def);
-virDomainDefPtr
-qemuMigrationCookieGetPersistent(qemuMigrationCookiePtr mig);
+virDomainDef *
+qemuMigrationCookieGetPersistent(qemuMigrationCookie *mig);
/* qemuMigrationCookieXMLFormat is exported for test use only! */
int
-qemuMigrationCookieXMLFormat(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
- virBufferPtr buf,
- qemuMigrationCookiePtr mig);
+qemuMigrationCookieXMLFormat(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
+ virBuffer *buf,
+ qemuMigrationCookie *mig);
int
-qemuMigrationCookieBlockDirtyBitmapsMatchDisks(virDomainDefPtr def,
+qemuMigrationCookieBlockDirtyBitmapsMatchDisks(virDomainDef *def,
GSList *disks);
int
qemuMigrationCookieBlockDirtyBitmapsToParams(GSList *disks,
- virJSONValuePtr *mapping);
+ virJSONValue **mapping);
} qemuMigrationParamType;
typedef struct _qemuMigrationParamValue qemuMigrationParamValue;
-typedef qemuMigrationParamValue *qemuMigrationParamValuePtr;
struct _qemuMigrationParamValue {
bool set;
union {
struct _qemuMigrationParams {
unsigned long long compMethods; /* bit-wise OR of qemuMigrationCompressMethod */
- virBitmapPtr caps;
+ virBitmap *caps;
qemuMigrationParamValue params[QEMU_MIGRATION_PARAM_LAST];
- virJSONValuePtr blockDirtyBitmapMapping;
+ virJSONValue *blockDirtyBitmapMapping;
};
typedef enum {
G_STATIC_ASSERT(G_N_ELEMENTS(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST);
-virBitmapPtr
+virBitmap *
qemuMigrationParamsGetAlwaysOnCaps(qemuMigrationParty party)
{
- virBitmapPtr caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
+ virBitmap *caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
size_t i;
for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsAlwaysOn); i++) {
}
-qemuMigrationParamsPtr
+qemuMigrationParams *
qemuMigrationParamsNew(void)
{
g_autoptr(qemuMigrationParams) params = NULL;
void
-qemuMigrationParamsFree(qemuMigrationParamsPtr migParams)
+qemuMigrationParamsFree(qemuMigrationParams *migParams)
{
size_t i;
static int
-qemuMigrationParamsGetTPInt(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsGetTPInt(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
static int
-qemuMigrationParamsSetTPInt(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetTPInt(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr *params,
int *nparams,
static int
-qemuMigrationParamsGetTPULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsGetTPULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
static int
-qemuMigrationParamsSetTPULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetTPULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr *params,
int *nparams,
static int
-qemuMigrationParamsGetTPString(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsGetTPString(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr params,
int nparams,
static int
-qemuMigrationParamsSetTPString(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetTPString(qemuMigrationParams *migParams,
qemuMigrationParam param,
virTypedParameterPtr *params,
int *nparams,
qemuMigrationParamsSetCompression(virTypedParameterPtr params,
int nparams,
unsigned long flags,
- qemuMigrationParamsPtr migParams)
+ qemuMigrationParams *migParams)
{
size_t i;
int method;
void
-qemuMigrationParamsSetBlockDirtyBitmapMapping(qemuMigrationParamsPtr migParams,
- virJSONValuePtr *params)
+qemuMigrationParamsSetBlockDirtyBitmapMapping(qemuMigrationParams *migParams,
+ virJSONValue **params)
{
virJSONValueFree(migParams->blockDirtyBitmapMapping);
migParams->blockDirtyBitmapMapping = g_steal_pointer(params);
}
-qemuMigrationParamsPtr
+qemuMigrationParams *
qemuMigrationParamsFromFlags(virTypedParameterPtr params,
int nparams,
unsigned long flags,
int
-qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsDump(qemuMigrationParams *migParams,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
}
-qemuMigrationParamsPtr
-qemuMigrationParamsFromJSON(virJSONValuePtr params)
+qemuMigrationParams *
+qemuMigrationParamsFromJSON(virJSONValue *params)
{
g_autoptr(qemuMigrationParams) migParams = NULL;
- qemuMigrationParamValuePtr pv;
+ qemuMigrationParamValue *pv;
const char *name;
const char *str;
size_t i;
}
-virJSONValuePtr
-qemuMigrationParamsToJSON(qemuMigrationParamsPtr migParams)
+virJSONValue *
+qemuMigrationParamsToJSON(qemuMigrationParams *migParams)
{
g_autoptr(virJSONValue) params = virJSONValueNewObject();
size_t i;
for (i = 0; i < QEMU_MIGRATION_PARAM_LAST; i++) {
const char *name = qemuMigrationParamTypeToString(i);
- qemuMigrationParamValuePtr pv = &migParams->params[i];
+ qemuMigrationParamValue *pv = &migParams->params[i];
int rc = 0;
if (!pv->set)
}
-virJSONValuePtr
-qemuMigrationCapsToJSON(virBitmapPtr caps,
- virBitmapPtr states)
+virJSONValue *
+qemuMigrationCapsToJSON(virBitmap *caps,
+ virBitmap *states)
{
g_autoptr(virJSONValue) json = virJSONValueNewArray();
qemuMigrationCapability bit;
* Returns 0 on success, -1 on failure.
*/
int
-qemuMigrationParamsApply(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsApply(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr migParams)
+ qemuMigrationParams *migParams)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool xbzrleCacheSize_old = false;
g_autoptr(virJSONValue) params = NULL;
g_autoptr(virJSONValue) caps = NULL;
* success and -1 on error. Libvirt error is reported.
*/
static int
-qemuMigrationParamsSetString(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetString(qemuMigrationParams *migParams,
qemuMigrationParam param,
const char *value)
{
* Returns 0 on success, -1 on failure
*/
int
-qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsEnableTLS(virQEMUDriver *driver,
+ virDomainObj *vm,
bool tlsListen,
int asyncJob,
char **tlsAlias,
const char *hostname,
- qemuMigrationParamsPtr migParams)
+ qemuMigrationParams *migParams)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
g_autoptr(virJSONValue) tlsProps = NULL;
g_autoptr(virJSONValue) secProps = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
* Returns 0 on success, -1 on failure
*/
int
-qemuMigrationParamsDisableTLS(virDomainObjPtr vm,
- qemuMigrationParamsPtr migParams)
+qemuMigrationParamsDisableTLS(virDomainObj *vm,
+ qemuMigrationParams *migParams)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
if (!jobPriv->migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set)
return 0;
bool
-qemuMigrationParamsTLSHostnameIsSet(qemuMigrationParamsPtr migParams)
+qemuMigrationParamsTLSHostnameIsSet(qemuMigrationParams *migParams)
{
int param = QEMU_MIGRATION_PARAM_TLS_HOSTNAME;
return (migParams->params[param].set &&
* security objects and free the secinfo
*/
static void
-qemuMigrationParamsResetTLS(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsResetTLS(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr origParams,
+ qemuMigrationParams *origParams,
unsigned long apiFlags)
{
g_autofree char *tlsAlias = NULL;
int
-qemuMigrationParamsFetch(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsFetch(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr *migParams)
+ qemuMigrationParams **migParams)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virJSONValue) jsonParams = NULL;
int rc;
int
-qemuMigrationParamsSetULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
unsigned long long value)
{
* 1 if the parameter is not supported by QEMU.
*/
int
-qemuMigrationParamsGetULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsGetULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
unsigned long long *value)
{
* are unsupported by QEMU.
*/
int
-qemuMigrationParamsCheck(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsCheck(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr migParams,
- virBitmapPtr remoteCaps)
+ qemuMigrationParams *migParams,
+ virBitmap *remoteCaps)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainJobPrivatePtr jobPriv = priv->job.privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuDomainJobPrivate *jobPriv = priv->job.privateData;
qemuMigrationCapability cap;
qemuMigrationParty party;
size_t i;
* migration (save, managedsave, snapshots, dump) will not try to use them.
*/
void
-qemuMigrationParamsReset(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsReset(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr origParams,
+ qemuMigrationParams *origParams,
unsigned long apiFlags)
{
virErrorPtr err;
void
-qemuMigrationParamsFormat(virBufferPtr buf,
- qemuMigrationParamsPtr migParams)
+qemuMigrationParamsFormat(virBuffer *buf,
+ qemuMigrationParams *migParams)
{
- qemuMigrationParamValuePtr pv;
+ qemuMigrationParamValue *pv;
size_t i;
virBufferAddLit(buf, "<migParams>\n");
int
qemuMigrationParamsParse(xmlXPathContextPtr ctxt,
- qemuMigrationParamsPtr *migParams)
+ qemuMigrationParams **migParams)
{
g_autoptr(qemuMigrationParams) params = NULL;
- qemuMigrationParamValuePtr pv;
+ qemuMigrationParamValue *pv;
g_autofree xmlNodePtr *nodes = NULL;
size_t i;
int rc;
int
-qemuMigrationCapsCheck(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationCapsCheck(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virBitmap) migEvent = NULL;
g_autoptr(virJSONValue) json = NULL;
g_auto(GStrv) caps = NULL;
bool
-qemuMigrationCapsGet(virDomainObjPtr vm,
+qemuMigrationCapsGet(virDomainObj *vm,
qemuMigrationCapability cap)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool enabled = false;
if (priv->migrationCaps)
} qemuMigrationParam;
typedef struct _qemuMigrationParams qemuMigrationParams;
-typedef qemuMigrationParams *qemuMigrationParamsPtr;
typedef enum {
QEMU_MIGRATION_SOURCE = (1 << 0),
} qemuMigrationParty;
-virBitmapPtr
+virBitmap *
qemuMigrationParamsGetAlwaysOnCaps(qemuMigrationParty party);
-qemuMigrationParamsPtr
+qemuMigrationParams *
qemuMigrationParamsFromFlags(virTypedParameterPtr params,
int nparams,
unsigned long flags,
qemuMigrationParty party);
int
-qemuMigrationParamsDump(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsDump(qemuMigrationParams *migParams,
virTypedParameterPtr *params,
int *nparams,
int *maxparams,
unsigned long *flags);
-qemuMigrationParamsPtr
+qemuMigrationParams *
qemuMigrationParamsNew(void);
void
-qemuMigrationParamsFree(qemuMigrationParamsPtr migParams);
+qemuMigrationParamsFree(qemuMigrationParams *migParams);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMigrationParams, qemuMigrationParamsFree);
int
-qemuMigrationParamsApply(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsApply(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr migParams);
+ qemuMigrationParams *migParams);
int
-qemuMigrationParamsEnableTLS(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsEnableTLS(virQEMUDriver *driver,
+ virDomainObj *vm,
bool tlsListen,
int asyncJob,
char **tlsAlias,
const char *hostname,
- qemuMigrationParamsPtr migParams);
+ qemuMigrationParams *migParams);
int
-qemuMigrationParamsDisableTLS(virDomainObjPtr vm,
- qemuMigrationParamsPtr migParams);
+qemuMigrationParamsDisableTLS(virDomainObj *vm,
+ qemuMigrationParams *migParams);
bool
-qemuMigrationParamsTLSHostnameIsSet(qemuMigrationParamsPtr migParams);
+qemuMigrationParamsTLSHostnameIsSet(qemuMigrationParams *migParams);
int
-qemuMigrationParamsFetch(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsFetch(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr *migParams);
+ qemuMigrationParams **migParams);
int
-qemuMigrationParamsSetULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsSetULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
unsigned long long value);
int
-qemuMigrationParamsGetULL(qemuMigrationParamsPtr migParams,
+qemuMigrationParamsGetULL(qemuMigrationParams *migParams,
qemuMigrationParam param,
unsigned long long *value);
void
-qemuMigrationParamsSetBlockDirtyBitmapMapping(qemuMigrationParamsPtr migParams,
- virJSONValuePtr *params);
+qemuMigrationParamsSetBlockDirtyBitmapMapping(qemuMigrationParams *migParams,
+ virJSONValue **params);
int
-qemuMigrationParamsCheck(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsCheck(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr migParams,
- virBitmapPtr remoteCaps);
+ qemuMigrationParams *migParams,
+ virBitmap *remoteCaps);
void
-qemuMigrationParamsReset(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationParamsReset(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuMigrationParamsPtr origParams,
+ qemuMigrationParams *origParams,
unsigned long apiFlags);
void
-qemuMigrationParamsFormat(virBufferPtr buf,
- qemuMigrationParamsPtr migParams);
+qemuMigrationParamsFormat(virBuffer *buf,
+ qemuMigrationParams *migParams);
int
qemuMigrationParamsParse(xmlXPathContextPtr ctxt,
- qemuMigrationParamsPtr *migParams);
+ qemuMigrationParams **migParams);
int
-qemuMigrationCapsCheck(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMigrationCapsCheck(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob);
bool
-qemuMigrationCapsGet(virDomainObjPtr vm,
+qemuMigrationCapsGet(virDomainObj *vm,
qemuMigrationCapability cap);
#pragma once
-virJSONValuePtr
-qemuMigrationParamsToJSON(qemuMigrationParamsPtr migParams);
+virJSONValue *
+qemuMigrationParamsToJSON(qemuMigrationParams *migParams);
-qemuMigrationParamsPtr
-qemuMigrationParamsFromJSON(virJSONValuePtr params);
+qemuMigrationParams *
+qemuMigrationParamsFromJSON(virJSONValue *params);
-virJSONValuePtr
-qemuMigrationCapsToJSON(virBitmapPtr caps,
- virBitmapPtr states);
+virJSONValue *
+qemuMigrationCapsToJSON(virBitmap *caps,
+ virBitmap *states);
GSocket *socket;
GSource *watch;
- virDomainObjPtr vm;
+ virDomainObj *vm;
- qemuMonitorCallbacksPtr cb;
+ qemuMonitorCallbacks *cb;
void *callbackOpaque;
/* If there's a command being processed this will be
* non-NULL */
- qemuMonitorMessagePtr msg;
+ qemuMonitorMessage *msg;
/* Buffer incoming data ready for Text/QMP monitor
* code to process & find message boundaries */
#define QEMU_CHECK_MONITOR_GOTO(mon, label) \
QEMU_CHECK_MONITOR_FULL(mon, goto label)
-static virClassPtr qemuMonitorClass;
+static virClass *qemuMonitorClass;
static __thread bool qemuMonitorDisposed;
static void qemuMonitorDispose(void *obj);
static void
qemuMonitorDispose(void *obj)
{
- qemuMonitorPtr mon = obj;
+ qemuMonitor *mon = obj;
VIR_DEBUG("mon=%p", mon);
qemuMonitorDisposed = true;
* replies/errors.
*/
static int
-qemuMonitorIOProcess(qemuMonitorPtr mon)
+qemuMonitorIOProcess(qemuMonitor *mon)
{
int len;
- qemuMonitorMessagePtr msg = NULL;
+ qemuMonitorMessage *msg = NULL;
/* See if there's a message & whether its ready for its reply
* ie whether its completed writing all its data */
/* Call this function while holding the monitor lock. */
static int
-qemuMonitorIOWriteWithFD(qemuMonitorPtr mon,
+qemuMonitorIOWriteWithFD(qemuMonitor *mon,
const char *data,
size_t len,
int fd)
* Call this function while holding the monitor lock.
*/
static int
-qemuMonitorIOWrite(qemuMonitorPtr mon)
+qemuMonitorIOWrite(qemuMonitor *mon)
{
int done;
char *buf;
* Returns -1 on error, or number of bytes read
*/
static int
-qemuMonitorIORead(qemuMonitorPtr mon)
+qemuMonitorIORead(qemuMonitor *mon)
{
size_t avail = mon->bufferLength - mon->bufferOffset;
int ret = 0;
static void
-qemuMonitorUpdateWatch(qemuMonitorPtr mon)
+qemuMonitorUpdateWatch(qemuMonitor *mon)
{
qemuMonitorUnregister(mon);
if (mon->socket)
GIOCondition cond,
gpointer opaque)
{
- qemuMonitorPtr mon = opaque;
+ qemuMonitor *mon = opaque;
bool error = false;
bool eof = false;
bool hangup = false;
/* We have to unlock to avoid deadlock against command thread,
* but is this safe ? I think it is, because the callback
- * will try to acquire the virDomainObjPtr mutex next */
+ * will try to acquire the virDomainObj *mutex next */
if (eof) {
qemuMonitorEofNotifyCallback eofNotify = mon->cb->eofNotify;
- virDomainObjPtr vm = mon->vm;
+ virDomainObj *vm = mon->vm;
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
virObjectUnref(mon);
} else if (error) {
qemuMonitorErrorNotifyCallback errorNotify = mon->cb->errorNotify;
- virDomainObjPtr vm = mon->vm;
+ virDomainObj *vm = mon->vm;
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
}
-static qemuMonitorPtr
-qemuMonitorOpenInternal(virDomainObjPtr vm,
+static qemuMonitor *
+qemuMonitorOpenInternal(virDomainObj *vm,
int fd,
GMainContext *context,
- qemuMonitorCallbacksPtr cb,
+ qemuMonitorCallbacks *cb,
void *opaque)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorPtr mon;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitor *mon;
g_autoptr(GError) gerr = NULL;
if (!cb->eofNotify) {
cleanup:
/* We don't want the 'destroy' callback invoked during
* cleanup from construction failure, because that can
- * give a double-unref on virDomainObjPtr in the caller,
+ * give a double-unref on virDomainObj *in the caller,
* so kill the callbacks now.
*/
mon->cb = NULL;
*
* Returns monitor object, NULL on error.
*/
-qemuMonitorPtr
-qemuMonitorOpen(virDomainObjPtr vm,
- virDomainChrSourceDefPtr config,
+qemuMonitor *
+qemuMonitorOpen(virDomainObj *vm,
+ virDomainChrSourceDef *config,
bool retry,
unsigned long long timeout,
GMainContext *context,
- qemuMonitorCallbacksPtr cb,
+ qemuMonitorCallbacks *cb,
void *opaque)
{
int fd = -1;
- qemuMonitorPtr ret = NULL;
+ qemuMonitor *ret = NULL;
timeout += QEMU_DEFAULT_MONITOR_WAIT;
* lock for @mon.
*/
void
-qemuMonitorRegister(qemuMonitorPtr mon)
+qemuMonitorRegister(qemuMonitor *mon)
{
GIOCondition cond = 0;
* must be locked before calling this function.
*/
void
-qemuMonitorUnregister(qemuMonitorPtr mon)
+qemuMonitorUnregister(qemuMonitor *mon)
{
if (mon->watch) {
g_source_destroy(mon->watch);
}
void
-qemuMonitorClose(qemuMonitorPtr mon)
+qemuMonitorClose(qemuMonitor *mon)
{
if (!mon)
return;
char *
-qemuMonitorNextCommandID(qemuMonitorPtr mon)
+qemuMonitorNextCommandID(qemuMonitor *mon)
{
char *id;
/* for use only in the test suite */
void
-qemuMonitorResetCommandID(qemuMonitorPtr mon)
+qemuMonitorResetCommandID(qemuMonitor *mon)
{
mon->nextSerial = 0;
}
int
-qemuMonitorSend(qemuMonitorPtr mon,
- qemuMonitorMessagePtr msg)
+qemuMonitorSend(qemuMonitor *mon,
+ qemuMonitorMessage *msg)
{
int ret = -1;
* for freeing it.
*/
virErrorPtr
-qemuMonitorLastError(qemuMonitorPtr mon)
+qemuMonitorLastError(qemuMonitor *mon)
{
if (mon->lastError.code == VIR_ERR_OK)
return NULL;
* This feature was added to QEMU 1.5.
*/
static void
-qemuMonitorInitBalloonObjectPath(qemuMonitorPtr mon,
- virDomainMemballoonDefPtr balloon)
+qemuMonitorInitBalloonObjectPath(qemuMonitor *mon,
+ virDomainMemballoonDef *balloon)
{
ssize_t i, nprops = 0;
char *path = NULL;
const char *name;
- qemuMonitorJSONListPathPtr *bprops = NULL;
+ qemuMonitorJSONListPath **bprops = NULL;
if (mon->balloonpath) {
return;
* Returns 0 on success, -1 on failure and sets proper error message.
*/
int
-qemuMonitorUpdateVideoMemorySize(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+qemuMonitorUpdateVideoMemorySize(qemuMonitor *mon,
+ virDomainVideoDef *video,
const char *videoName)
{
int rc = -1;
* Returns 0 on success, -1 on failure and sets proper error message.
*/
int
-qemuMonitorUpdateVideoVram64Size(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+qemuMonitorUpdateVideoVram64Size(qemuMonitor *mon,
+ virDomainVideoDef *video,
const char *videoName)
{
int rc = -1;
int
-qemuMonitorEmitEvent(qemuMonitorPtr mon, const char *event,
+qemuMonitorEmitEvent(qemuMonitor *mon, const char *event,
long long seconds, unsigned int micros,
const char *details)
{
int
-qemuMonitorEmitShutdown(qemuMonitorPtr mon, virTristateBool guest)
+qemuMonitorEmitShutdown(qemuMonitor *mon, virTristateBool guest)
{
int ret = -1;
VIR_DEBUG("mon=%p guest=%u", mon, guest);
int
-qemuMonitorEmitReset(qemuMonitorPtr mon)
+qemuMonitorEmitReset(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitPowerdown(qemuMonitorPtr mon)
+qemuMonitorEmitPowerdown(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitStop(qemuMonitorPtr mon)
+qemuMonitorEmitStop(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitResume(qemuMonitorPtr mon)
+qemuMonitorEmitResume(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitGuestPanic(qemuMonitorPtr mon,
- qemuMonitorEventPanicInfoPtr info)
+qemuMonitorEmitGuestPanic(qemuMonitor *mon,
+ qemuMonitorEventPanicInfo *info)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset)
+qemuMonitorEmitRTCChange(qemuMonitor *mon, long long offset)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action)
+qemuMonitorEmitWatchdog(qemuMonitor *mon, int action)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitIOError(qemuMonitorPtr mon,
+qemuMonitorEmitIOError(qemuMonitor *mon,
const char *diskAlias,
const char *nodename,
int action,
int
-qemuMonitorEmitGraphics(qemuMonitorPtr mon,
+qemuMonitorEmitGraphics(qemuMonitor *mon,
int phase,
int localFamily,
const char *localNode,
int
-qemuMonitorEmitTrayChange(qemuMonitorPtr mon,
+qemuMonitorEmitTrayChange(qemuMonitor *mon,
const char *devAlias,
const char *devid,
int reason)
int
-qemuMonitorEmitPMWakeup(qemuMonitorPtr mon)
+qemuMonitorEmitPMWakeup(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitPMSuspend(qemuMonitorPtr mon)
+qemuMonitorEmitPMSuspend(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitPMSuspendDisk(qemuMonitorPtr mon)
+qemuMonitorEmitPMSuspendDisk(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
+qemuMonitorEmitBlockJob(qemuMonitor *mon,
const char *diskAlias,
int type,
int status,
int
-qemuMonitorEmitJobStatusChange(qemuMonitorPtr mon,
+qemuMonitorEmitJobStatusChange(qemuMonitor *mon,
const char *jobname,
qemuMonitorJobStatus status)
{
int
-qemuMonitorEmitBalloonChange(qemuMonitorPtr mon,
+qemuMonitorEmitBalloonChange(qemuMonitor *mon,
unsigned long long actual)
{
int ret = -1;
int
-qemuMonitorEmitDeviceDeleted(qemuMonitorPtr mon,
+qemuMonitorEmitDeviceDeleted(qemuMonitor *mon,
const char *devAlias)
{
int ret = -1;
int
-qemuMonitorEmitNicRxFilterChanged(qemuMonitorPtr mon,
+qemuMonitorEmitNicRxFilterChanged(qemuMonitor *mon,
const char *devAlias)
{
int ret = -1;
int
-qemuMonitorEmitSerialChange(qemuMonitorPtr mon,
+qemuMonitorEmitSerialChange(qemuMonitor *mon,
const char *devAlias,
bool connected)
{
int
-qemuMonitorEmitSpiceMigrated(qemuMonitorPtr mon)
+qemuMonitorEmitSpiceMigrated(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorEmitMemoryFailure(qemuMonitorPtr mon,
- qemuMonitorEventMemoryFailurePtr mfp)
+qemuMonitorEmitMemoryFailure(qemuMonitor *mon,
+ qemuMonitorEventMemoryFailure *mfp)
{
int ret = -1;
int
-qemuMonitorEmitMigrationStatus(qemuMonitorPtr mon,
+qemuMonitorEmitMigrationStatus(qemuMonitor *mon,
int status)
{
int ret = -1;
int
-qemuMonitorEmitMigrationPass(qemuMonitorPtr mon,
+qemuMonitorEmitMigrationPass(qemuMonitor *mon,
int pass)
{
int ret = -1;
int
-qemuMonitorEmitAcpiOstInfo(qemuMonitorPtr mon,
+qemuMonitorEmitAcpiOstInfo(qemuMonitor *mon,
const char *alias,
const char *slotType,
const char *slot,
int
-qemuMonitorEmitBlockThreshold(qemuMonitorPtr mon,
+qemuMonitorEmitBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold,
unsigned long long excess)
int
-qemuMonitorEmitDumpCompleted(qemuMonitorPtr mon,
+qemuMonitorEmitDumpCompleted(qemuMonitor *mon,
int status,
- qemuMonitorDumpStatsPtr stats,
+ qemuMonitorDumpStats *stats,
const char *error)
{
int ret = -1;
int
-qemuMonitorEmitPRManagerStatusChanged(qemuMonitorPtr mon,
+qemuMonitorEmitPRManagerStatusChanged(qemuMonitor *mon,
const char *prManager,
bool connected)
{
int
-qemuMonitorEmitRdmaGidStatusChanged(qemuMonitorPtr mon,
+qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor *mon,
const char *netdev,
bool gid_status,
unsigned long long subnet_prefix,
int
-qemuMonitorEmitGuestCrashloaded(qemuMonitorPtr mon)
+qemuMonitorEmitGuestCrashloaded(qemuMonitor *mon)
{
int ret = -1;
VIR_DEBUG("mon=%p", mon);
int
-qemuMonitorSetCapabilities(qemuMonitorPtr mon)
+qemuMonitorSetCapabilities(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorStartCPUs(qemuMonitorPtr mon)
+qemuMonitorStartCPUs(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorStopCPUs(qemuMonitorPtr mon)
+qemuMonitorStopCPUs(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorCheck(qemuMonitorPtr mon)
+qemuMonitorCheck(qemuMonitor *mon)
{
bool running;
return qemuMonitorGetStatus(mon, &running, NULL);
int
-qemuMonitorGetStatus(qemuMonitorPtr mon,
+qemuMonitorGetStatus(qemuMonitor *mon,
bool *running,
virDomainPausedReason *reason)
{
int
-qemuMonitorSystemPowerdown(qemuMonitorPtr mon)
+qemuMonitorSystemPowerdown(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorSystemReset(qemuMonitorPtr mon)
+qemuMonitorSystemReset(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
static void
-qemuMonitorCPUInfoClear(qemuMonitorCPUInfoPtr cpus,
+qemuMonitorCPUInfoClear(qemuMonitorCPUInfo *cpus,
size_t ncpus)
{
size_t i;
void
-qemuMonitorCPUInfoFree(qemuMonitorCPUInfoPtr cpus,
+qemuMonitorCPUInfoFree(qemuMonitorCPUInfo *cpus,
size_t ncpus)
{
if (!cpus)
static void
qemuMonitorGetCPUInfoLegacy(struct qemuMonitorQueryCpusEntry *cpuentries,
size_t ncpuentries,
- qemuMonitorCPUInfoPtr vcpus,
+ qemuMonitorCPUInfo *vcpus,
size_t maxvcpus)
{
size_t i;
size_t nhotplugvcpus,
struct qemuMonitorQueryCpusEntry *cpuentries,
size_t ncpuentries,
- qemuMonitorCPUInfoPtr vcpus,
+ qemuMonitorCPUInfo *vcpus,
size_t maxvcpus)
{
char *tmp;
* -1 on error (reports libvirt error).
*/
int
-qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
- qemuMonitorCPUInfoPtr *vcpus,
+qemuMonitorGetCPUInfo(qemuMonitor *mon,
+ qemuMonitorCPUInfo **vcpus,
size_t maxvcpus,
bool hotplug,
bool fast)
size_t ncpuentries = 0;
int ret = -1;
int rc;
- qemuMonitorCPUInfoPtr info = NULL;
+ qemuMonitorCPUInfo *info = NULL;
QEMU_CHECK_MONITOR(mon);
* Returns a bitmap of vcpu id's that are halted. The id's correspond to the
* 'CPU' field as reported by query-cpus[-fast]'.
*/
-virBitmapPtr
-qemuMonitorGetCpuHalted(qemuMonitorPtr mon,
+virBitmap *
+qemuMonitorGetCpuHalted(qemuMonitor *mon,
size_t maxvcpus,
bool fast)
{
size_t ncpuentries = 0;
size_t i;
int rc;
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorSetLink(qemuMonitorPtr mon,
+qemuMonitorSetLink(qemuMonitor *mon,
const char *name,
virDomainNetInterfaceLinkState state)
{
* or -1 on failure
*/
int
-qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
+qemuMonitorGetBalloonInfo(qemuMonitor *mon,
unsigned long long *currmem)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorGetMemoryStats(qemuMonitorPtr mon,
- virDomainMemballoonDefPtr balloon,
+qemuMonitorGetMemoryStats(qemuMonitor *mon,
+ virDomainMemballoonDef *balloon,
virDomainMemoryStatPtr stats,
unsigned int nr_stats)
{
* Returns 0 on success and -1 on error, but does *not* set an error.
*/
int
-qemuMonitorSetMemoryStatsPeriod(qemuMonitorPtr mon,
- virDomainMemballoonDefPtr balloon,
+qemuMonitorSetMemoryStatsPeriod(qemuMonitor *mon,
+ virDomainMemballoonDef *balloon,
int period)
{
int ret = -1;
GHashTable *
-qemuMonitorGetBlockInfo(qemuMonitorPtr mon)
+qemuMonitorGetBlockInfo(qemuMonitor *mon)
{
int ret;
GHashTable *table;
*
* Returns data from a call to 'query-blockstats'.
*/
-virJSONValuePtr
-qemuMonitorQueryBlockstats(qemuMonitorPtr mon)
+virJSONValue *
+qemuMonitorQueryBlockstats(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
* Returns < 0 on error, count of supported block stats fields on success.
*/
int
-qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
+qemuMonitorGetAllBlockStatsInfo(qemuMonitor *mon,
GHashTable **ret_stats,
bool backingChain)
{
/* Updates "stats" to fill virtual and physical size of the image */
int
-qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
+qemuMonitorBlockStatsUpdateCapacity(qemuMonitor *mon,
GHashTable *stats,
bool backingChain)
{
int
-qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
+qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
GHashTable *stats)
{
VIR_DEBUG("stats=%p", stats);
* @supports_flat: don't query data for backing store
*
* Uses 'query-named-block-nodes' to retrieve information about individual
- * storage nodes and returns them in a hash table of qemuBlockNamedNodeDataPtrs
+ * storage nodes and returns them in a hash table of qemuBlockNamedNodeData *s
* filled with the data. The hash table keys are node names.
*/
GHashTable *
-qemuMonitorBlockGetNamedNodeData(qemuMonitorPtr mon,
+qemuMonitorBlockGetNamedNodeData(qemuMonitor *mon,
bool supports_flat)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorBlockResize(qemuMonitorPtr mon,
+qemuMonitorBlockResize(qemuMonitor *mon,
const char *device,
const char *nodename,
unsigned long long size)
int
-qemuMonitorSetPassword(qemuMonitorPtr mon,
+qemuMonitorSetPassword(qemuMonitor *mon,
int type,
const char *password,
const char *action_if_connected)
int
-qemuMonitorExpirePassword(qemuMonitorPtr mon,
+qemuMonitorExpirePassword(qemuMonitor *mon,
int type,
const char *expire_time)
{
* or -1 on failure
*/
int
-qemuMonitorSetBalloon(qemuMonitorPtr mon,
+qemuMonitorSetBalloon(qemuMonitor *mon,
unsigned long long newmem)
{
VIR_DEBUG("newmem=%llu", newmem);
* Returns: 0 if CPU modification was successful or -1 on failure
*/
int
-qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, bool online)
+qemuMonitorSetCPU(qemuMonitor *mon, int cpu, bool online)
{
VIR_DEBUG("cpu=%d online=%d", cpu, online);
int
-qemuMonitorEjectMedia(qemuMonitorPtr mon,
+qemuMonitorEjectMedia(qemuMonitor *mon,
const char *dev_name,
bool force)
{
int
-qemuMonitorChangeMedia(qemuMonitorPtr mon,
+qemuMonitorChangeMedia(qemuMonitor *mon,
const char *dev_name,
const char *newmedia,
const char *format)
int
-qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
+qemuMonitorSaveVirtualMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path)
int
-qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
+qemuMonitorSavePhysicalMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path)
int
-qemuMonitorSetDBusVMStateIdList(qemuMonitorPtr mon,
+qemuMonitorSetDBusVMStateIdList(qemuMonitor *mon,
GSList *list)
{
g_autofree char *path = NULL;
int
-qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
+qemuMonitorSetMigrationSpeed(qemuMonitor *mon,
unsigned long bandwidth)
{
VIR_DEBUG("bandwidth=%lu", bandwidth);
int
-qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon,
+qemuMonitorSetMigrationDowntime(qemuMonitor *mon,
unsigned long long downtime)
{
VIR_DEBUG("downtime=%llu", downtime);
int
-qemuMonitorGetMigrationCacheSize(qemuMonitorPtr mon,
+qemuMonitorGetMigrationCacheSize(qemuMonitor *mon,
unsigned long long *cacheSize)
{
VIR_DEBUG("cacheSize=%p", cacheSize);
int
-qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon,
+qemuMonitorSetMigrationCacheSize(qemuMonitor *mon,
unsigned long long cacheSize)
{
VIR_DEBUG("cacheSize=%llu", cacheSize);
* Returns 0 on success, -1 on error.
*/
int
-qemuMonitorGetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params)
+qemuMonitorGetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params)
{
QEMU_CHECK_MONITOR(mon);
* Returns 0 on success, -1 on error.
*/
int
-qemuMonitorSetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params)
+qemuMonitorSetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorGetMigrationStats(qemuMonitorPtr mon,
- qemuMonitorMigrationStatsPtr stats,
+qemuMonitorGetMigrationStats(qemuMonitor *mon,
+ qemuMonitorMigrationStats *stats,
char **error)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorMigrateToFd(qemuMonitorPtr mon,
+qemuMonitorMigrateToFd(qemuMonitor *mon,
unsigned int flags,
int fd)
{
int
-qemuMonitorMigrateToHost(qemuMonitorPtr mon,
+qemuMonitorMigrateToHost(qemuMonitor *mon,
unsigned int flags,
const char *protocol,
const char *hostname,
int
-qemuMonitorMigrateToSocket(qemuMonitorPtr mon,
+qemuMonitorMigrateToSocket(qemuMonitor *mon,
unsigned int flags,
const char *socketPath)
{
int
-qemuMonitorMigrateCancel(qemuMonitorPtr mon)
+qemuMonitorMigrateCancel(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorQueryDump(qemuMonitorPtr mon,
- qemuMonitorDumpStatsPtr stats)
+qemuMonitorQueryDump(qemuMonitor *mon,
+ qemuMonitorDumpStats *stats)
{
QEMU_CHECK_MONITOR(mon);
* Returns 1 if @capability is supported, 0 if it's not, or -1 on error.
*/
int
-qemuMonitorGetDumpGuestMemoryCapability(qemuMonitorPtr mon,
+qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor *mon,
const char *capability)
{
VIR_DEBUG("capability=%s", capability);
int
-qemuMonitorDumpToFd(qemuMonitorPtr mon,
+qemuMonitorDumpToFd(qemuMonitor *mon,
int fd,
const char *dumpformat,
bool detach)
int
-qemuMonitorGraphicsRelocate(qemuMonitorPtr mon,
+qemuMonitorGraphicsRelocate(qemuMonitor *mon,
int type,
const char *hostname,
int port,
* via the file path /dev/fdset/$FDSETID
* Returns 0 if ok, and -1 on failure */
int
-qemuMonitorAddFileHandleToSet(qemuMonitorPtr mon,
+qemuMonitorAddFileHandleToSet(qemuMonitor *mon,
int fd,
int fdset,
const char *opaque,
- qemuMonitorAddFdInfoPtr info)
+ qemuMonitorAddFdInfo *info)
{
VIR_DEBUG("fd=%d,fdset=%i,opaque=%s", fd, fdset, opaque);
* Attempts to remove a fdset from qemu and close associated file descriptors
* Returns 0 if ok, and -1 on failure */
int
-qemuMonitorRemoveFdset(qemuMonitorPtr mon,
+qemuMonitorRemoveFdset(qemuMonitor *mon,
int fdset)
{
VIR_DEBUG("fdset=%d", fdset);
}
-void qemuMonitorFdsetsFree(qemuMonitorFdsetsPtr fdsets)
+void qemuMonitorFdsetsFree(qemuMonitorFdsets *fdsets)
{
size_t i;
for (i = 0; i < fdsets->nfdsets; i++) {
size_t j;
- qemuMonitorFdsetInfoPtr set = &fdsets->fdsets[i];
+ qemuMonitorFdsetInfo *set = &fdsets->fdsets[i];
for (j = 0; j < set->nfds; j++)
g_free(set->fds[j].opaque);
*
* Returns 0 if ok, and -1 on failure */
int
-qemuMonitorQueryFdsets(qemuMonitorPtr mon,
- qemuMonitorFdsetsPtr *fdsets)
+qemuMonitorQueryFdsets(qemuMonitor *mon,
+ qemuMonitorFdsets **fdsets)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorSendFileHandle(qemuMonitorPtr mon,
+qemuMonitorSendFileHandle(qemuMonitor *mon,
const char *fdname,
int fd)
{
int
-qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
+qemuMonitorCloseFileHandle(qemuMonitor *mon,
const char *fdname)
{
int ret = -1;
int
-qemuMonitorAddNetdev(qemuMonitorPtr mon,
- virJSONValuePtr *props,
+qemuMonitorAddNetdev(qemuMonitor *mon,
+ virJSONValue **props,
int *tapfd, char **tapfdName, int tapfdSize,
int *vhostfd, char **vhostfdName, int vhostfdSize,
int slirpfd, char *slirpfdName)
int
-qemuMonitorRemoveNetdev(qemuMonitorPtr mon,
+qemuMonitorRemoveNetdev(qemuMonitor *mon,
const char *alias)
{
VIR_DEBUG("alias=%s", alias);
int
-qemuMonitorQueryRxFilter(qemuMonitorPtr mon, const char *alias,
- virNetDevRxFilterPtr *filter)
+qemuMonitorQueryRxFilter(qemuMonitor *mon, const char *alias,
+ virNetDevRxFilter **filter)
{
VIR_DEBUG("alias=%s filter=%p", alias, filter);
void
qemuMonitorChardevInfoFree(void *data)
{
- qemuMonitorChardevInfoPtr info = data;
+ qemuMonitorChardevInfo *info = data;
g_free(info->ptyPath);
g_free(info);
int
-qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
+qemuMonitorGetChardevInfo(qemuMonitor *mon,
GHashTable **retinfo)
{
int ret;
* Attempts to remove a host drive.
* Returns 1 if unsupported, 0 if ok, and -1 on other failure */
int
-qemuMonitorDriveDel(qemuMonitorPtr mon,
+qemuMonitorDriveDel(qemuMonitor *mon,
const char *drivestr)
{
VIR_DEBUG("drivestr=%s", drivestr);
* -1 otherwise (error reported)
*/
int
-qemuMonitorDelDevice(qemuMonitorPtr mon,
+qemuMonitorDelDevice(qemuMonitor *mon,
const char *devalias)
{
VIR_DEBUG("devalias=%s", devalias);
int
-qemuMonitorAddDeviceWithFd(qemuMonitorPtr mon,
+qemuMonitorAddDeviceWithFd(qemuMonitor *mon,
const char *devicestr,
int fd,
const char *fdname)
int
-qemuMonitorAddDevice(qemuMonitorPtr mon,
+qemuMonitorAddDevice(qemuMonitor *mon,
const char *devicestr)
{
return qemuMonitorAddDeviceWithFd(mon, devicestr, -1, NULL);
* Returns 0 on success -1 on error.
*/
int
-qemuMonitorAddDeviceArgs(qemuMonitorPtr mon,
- virJSONValuePtr args)
+qemuMonitorAddDeviceArgs(qemuMonitor *mon,
+ virJSONValue *args)
{
QEMU_CHECK_MONITOR(mon);
* Returns a JSONValue containing everything on success and NULL on error.
*/
int
-qemuMonitorCreateObjectProps(virJSONValuePtr *propsret,
+qemuMonitorCreateObjectProps(virJSONValue **propsret,
const char *type,
const char *alias,
...)
* Returns 0 on success -1 on error.
*/
int
-qemuMonitorAddObject(qemuMonitorPtr mon,
- virJSONValuePtr *props,
+qemuMonitorAddObject(qemuMonitor *mon,
+ virJSONValue **props,
char **alias)
{
g_autoptr(virJSONValue) pr = NULL;
int
-qemuMonitorDelObject(qemuMonitorPtr mon,
+qemuMonitorDelObject(qemuMonitor *mon,
const char *objalias,
bool report_error)
{
int
-qemuMonitorAddDrive(qemuMonitorPtr mon,
+qemuMonitorAddDrive(qemuMonitor *mon,
const char *drivestr)
{
VIR_DEBUG("drive=%s", drivestr);
int
-qemuMonitorCreateSnapshot(qemuMonitorPtr mon, const char *name)
+qemuMonitorCreateSnapshot(qemuMonitor *mon, const char *name)
{
VIR_DEBUG("name=%s", name);
}
int
-qemuMonitorLoadSnapshot(qemuMonitorPtr mon, const char *name)
+qemuMonitorLoadSnapshot(qemuMonitor *mon, const char *name)
{
VIR_DEBUG("name=%s", name);
int
-qemuMonitorDeleteSnapshot(qemuMonitorPtr mon, const char *name)
+qemuMonitorDeleteSnapshot(qemuMonitor *mon, const char *name)
{
VIR_DEBUG("name=%s", name);
/* Start a drive-mirror block job. bandwidth is in bytes/sec. */
int
-qemuMonitorDriveMirror(qemuMonitorPtr mon,
+qemuMonitorDriveMirror(qemuMonitor *mon,
const char *device, const char *file,
const char *format, unsigned long long bandwidth,
unsigned int granularity, unsigned long long buf_size,
int
-qemuMonitorBlockdevMirror(qemuMonitorPtr mon,
+qemuMonitorBlockdevMirror(qemuMonitor *mon,
const char *jobname,
bool persistjob,
const char *device,
/* Use the transaction QMP command to run atomic snapshot commands. */
int
-qemuMonitorTransaction(qemuMonitorPtr mon, virJSONValuePtr *actions)
+qemuMonitorTransaction(qemuMonitor *mon, virJSONValue **actions)
{
VIR_DEBUG("actions=%p", *actions);
/* Start a block-commit block job. bandwidth is in bytes/sec. */
int
-qemuMonitorBlockCommit(qemuMonitorPtr mon,
+qemuMonitorBlockCommit(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
/* Probe whether active commits are supported by a given qemu binary. */
bool
-qemuMonitorSupportsActiveCommit(qemuMonitorPtr mon)
+qemuMonitorSupportsActiveCommit(qemuMonitor *mon)
{
if (!mon)
return false;
/* Determine the name that qemu is using for tracking the backing
* element TARGET within the chain starting at TOP. */
char *
-qemuMonitorDiskNameLookup(qemuMonitorPtr mon,
+qemuMonitorDiskNameLookup(qemuMonitor *mon,
const char *device,
- virStorageSourcePtr top,
- virStorageSourcePtr target)
+ virStorageSource *top,
+ virStorageSource *target)
{
QEMU_CHECK_MONITOR_NULL(mon);
/* Use the block-job-complete monitor command to pivot a block copy job. */
int
-qemuMonitorDrivePivot(qemuMonitorPtr mon,
+qemuMonitorDrivePivot(qemuMonitor *mon,
const char *jobname)
{
VIR_DEBUG("jobname=%s", jobname);
int
-qemuMonitorArbitraryCommand(qemuMonitorPtr mon,
+qemuMonitorArbitraryCommand(qemuMonitor *mon,
const char *cmd,
char **reply,
bool hmp)
int
-qemuMonitorInjectNMI(qemuMonitorPtr mon)
+qemuMonitorInjectNMI(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorSendKey(qemuMonitorPtr mon,
+qemuMonitorSendKey(qemuMonitor *mon,
unsigned int holdtime,
unsigned int *keycodes,
unsigned int nkeycodes)
int
-qemuMonitorScreendump(qemuMonitorPtr mon,
+qemuMonitorScreendump(qemuMonitor *mon,
const char *device,
unsigned int head,
const char *file)
/* bandwidth is in bytes/sec */
int
-qemuMonitorBlockStream(qemuMonitorPtr mon,
+qemuMonitorBlockStream(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
int
-qemuMonitorBlockJobCancel(qemuMonitorPtr mon,
+qemuMonitorBlockJobCancel(qemuMonitor *mon,
const char *jobname)
{
VIR_DEBUG("jobname=%s", jobname);
int
-qemuMonitorBlockJobSetSpeed(qemuMonitorPtr mon,
+qemuMonitorBlockJobSetSpeed(qemuMonitor *mon,
const char *jobname,
unsigned long long bandwidth)
{
GHashTable *
-qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon,
+qemuMonitorGetAllBlockJobInfo(qemuMonitor *mon,
bool rawjobname)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorJobDismiss(qemuMonitorPtr mon,
+qemuMonitorJobDismiss(qemuMonitor *mon,
const char *jobname)
{
VIR_DEBUG("jobname=%s", jobname);
int
-qemuMonitorJobCancel(qemuMonitorPtr mon,
+qemuMonitorJobCancel(qemuMonitor *mon,
const char *jobname,
bool quiet)
{
int
-qemuMonitorJobComplete(qemuMonitorPtr mon,
+qemuMonitorJobComplete(qemuMonitor *mon,
const char *jobname)
{
VIR_DEBUG("jobname=%s", jobname);
int
-qemuMonitorSetBlockIoThrottle(qemuMonitorPtr mon,
+qemuMonitorSetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qomid,
- virDomainBlockIoTuneInfoPtr info,
+ virDomainBlockIoTuneInfo *info,
bool supportMaxOptions,
bool supportGroupNameOption,
bool supportMaxLengthOptions)
int
-qemuMonitorGetBlockIoThrottle(qemuMonitorPtr mon,
+qemuMonitorGetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qdevid,
- virDomainBlockIoTuneInfoPtr reply)
+ virDomainBlockIoTuneInfo *reply)
{
VIR_DEBUG("drivealias=%s, qdevid=%s, reply=%p",
NULLSTR(drivealias), NULLSTR(qdevid), reply);
int
-qemuMonitorOpenGraphics(qemuMonitorPtr mon,
+qemuMonitorOpenGraphics(qemuMonitor *mon,
const char *protocol,
int fd,
const char *fdname,
int
-qemuMonitorSystemWakeup(qemuMonitorPtr mon)
+qemuMonitorSystemWakeup(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorGetVersion(qemuMonitorPtr mon,
+qemuMonitorGetVersion(qemuMonitor *mon,
int *major,
int *minor,
int *micro,
int
-qemuMonitorGetMachines(qemuMonitorPtr mon,
- qemuMonitorMachineInfoPtr **machines)
+qemuMonitorGetMachines(qemuMonitor *mon,
+ qemuMonitorMachineInfo ***machines)
{
VIR_DEBUG("machines=%p", machines);
void
-qemuMonitorMachineInfoFree(qemuMonitorMachineInfoPtr machine)
+qemuMonitorMachineInfoFree(qemuMonitorMachineInfo *machine)
{
if (!machine)
return;
int
-qemuMonitorGetCPUDefinitions(qemuMonitorPtr mon,
- qemuMonitorCPUDefsPtr *cpuDefs)
+qemuMonitorGetCPUDefinitions(qemuMonitor *mon,
+ qemuMonitorCPUDefs **cpuDefs)
{
VIR_DEBUG("cpuDefs=%p", cpuDefs);
void
-qemuMonitorCPUDefsFree(qemuMonitorCPUDefsPtr defs)
+qemuMonitorCPUDefsFree(qemuMonitorCPUDefs *defs)
{
size_t i;
}
-qemuMonitorCPUDefsPtr
+qemuMonitorCPUDefs *
qemuMonitorCPUDefsNew(size_t count)
{
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
}
-qemuMonitorCPUDefsPtr
-qemuMonitorCPUDefsCopy(qemuMonitorCPUDefsPtr src)
+qemuMonitorCPUDefs *
+qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs *src)
{
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
size_t i;
defs = qemuMonitorCPUDefsNew(src->ncpus);
for (i = 0; i < src->ncpus; i++) {
- qemuMonitorCPUDefInfoPtr cpuDst = defs->cpus + i;
- qemuMonitorCPUDefInfoPtr cpuSrc = src->cpus + i;
+ qemuMonitorCPUDefInfo *cpuDst = defs->cpus + i;
+ qemuMonitorCPUDefInfo *cpuSrc = src->cpus + i;
cpuDst->usable = cpuSrc->usable;
cpuDst->name = g_strdup(cpuSrc->name);
int
-qemuMonitorGetCPUModelExpansion(qemuMonitorPtr mon,
+qemuMonitorGetCPUModelExpansion(qemuMonitor *mon,
qemuMonitorCPUModelExpansionType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable,
bool fail_no_props,
- qemuMonitorCPUModelInfoPtr *model_info)
+ qemuMonitorCPUModelInfo **model_info)
{
VIR_DEBUG("type=%d cpu=%p migratable=%d", type, cpu, migratable);
int
-qemuMonitorGetCPUModelBaseline(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
- qemuMonitorCPUModelInfoPtr *baseline)
+qemuMonitorGetCPUModelBaseline(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
+ qemuMonitorCPUModelInfo **baseline)
{
VIR_DEBUG("cpu_a=%p cpu_b=%p", cpu_a, cpu_b);
int
-qemuMonitorGetCPUModelComparison(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
+qemuMonitorGetCPUModelComparison(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
char **result)
{
VIR_DEBUG("cpu_a=%p cpu_b=%p", cpu_a, cpu_b);
void
-qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfoPtr model_info)
+qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo *model_info)
{
size_t i;
}
-qemuMonitorCPUModelInfoPtr
+qemuMonitorCPUModelInfo *
qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo *orig)
{
- qemuMonitorCPUModelInfoPtr copy;
+ qemuMonitorCPUModelInfo *copy;
size_t i;
copy = g_new0(qemuMonitorCPUModelInfo, 1);
int
-qemuMonitorGetCommands(qemuMonitorPtr mon,
+qemuMonitorGetCommands(qemuMonitor *mon,
char ***commands)
{
VIR_DEBUG("commands=%p", commands);
int
-qemuMonitorGetEvents(qemuMonitorPtr mon,
+qemuMonitorGetEvents(qemuMonitor *mon,
char ***events)
{
VIR_DEBUG("events=%p", events);
GHashTable *
-qemuMonitorGetCommandLineOptions(qemuMonitorPtr mon)
+qemuMonitorGetCommandLineOptions(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorGetKVMState(qemuMonitorPtr mon,
+qemuMonitorGetKVMState(qemuMonitor *mon,
bool *enabled,
bool *present)
{
int
-qemuMonitorGetObjectTypes(qemuMonitorPtr mon,
+qemuMonitorGetObjectTypes(qemuMonitor *mon,
char ***types)
{
VIR_DEBUG("types=%p", types);
GHashTable *
-qemuMonitorGetDeviceProps(qemuMonitorPtr mon,
+qemuMonitorGetDeviceProps(qemuMonitor *mon,
const char *device)
{
VIR_DEBUG("device=%s", device);
int
-qemuMonitorGetObjectProps(qemuMonitorPtr mon,
+qemuMonitorGetObjectProps(qemuMonitor *mon,
const char *object,
char ***props)
{
char *
-qemuMonitorGetTargetArch(qemuMonitorPtr mon)
+qemuMonitorGetTargetArch(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon,
+qemuMonitorGetMigrationCapabilities(qemuMonitor *mon,
char ***capabilities)
{
QEMU_CHECK_MONITOR(mon);
* Returns 0 on success, -1 on error.
*/
int
-qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon,
- virJSONValuePtr *caps)
+qemuMonitorSetMigrationCapabilities(qemuMonitor *mon,
+ virJSONValue **caps)
{
QEMU_CHECK_MONITOR(mon);
* See qemuMonitorJSONGetGICCapabilities().
*/
int
-qemuMonitorGetGICCapabilities(qemuMonitorPtr mon,
+qemuMonitorGetGICCapabilities(qemuMonitor *mon,
virGICCapability **capabilities)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorGetSEVCapabilities(qemuMonitorPtr mon,
+qemuMonitorGetSEVCapabilities(qemuMonitor *mon,
virSEVCapability **capabilities)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorNBDServerStart(qemuMonitorPtr mon,
+qemuMonitorNBDServerStart(qemuMonitor *mon,
const virStorageNetHostDef *server,
const char *tls_alias)
{
int
-qemuMonitorNBDServerAdd(qemuMonitorPtr mon,
+qemuMonitorNBDServerAdd(qemuMonitor *mon,
const char *deviceID,
const char *export,
bool writable,
int
-qemuMonitorNBDServerStop(qemuMonitorPtr mon)
+qemuMonitorNBDServerStop(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorBlockExportAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorBlockExportAdd(qemuMonitor *mon,
+ virJSONValue **props)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorGetTPMModels(qemuMonitorPtr mon,
+qemuMonitorGetTPMModels(qemuMonitor *mon,
char ***tpmmodels)
{
VIR_DEBUG("tpmmodels=%p", tpmmodels);
int
-qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
+qemuMonitorGetTPMTypes(qemuMonitor *mon,
char ***tpmtypes)
{
VIR_DEBUG("tpmtypes=%p", tpmtypes);
int
-qemuMonitorAttachCharDev(qemuMonitorPtr mon,
+qemuMonitorAttachCharDev(qemuMonitor *mon,
const char *chrID,
- virDomainChrSourceDefPtr chr)
+ virDomainChrSourceDef *chr)
{
VIR_DEBUG("chrID=%s chr=%p", chrID, chr);
int
-qemuMonitorDetachCharDev(qemuMonitorPtr mon,
+qemuMonitorDetachCharDev(qemuMonitor *mon,
const char *chrID)
{
VIR_DEBUG("chrID=%s", chrID);
int
-qemuMonitorGetDeviceAliases(qemuMonitorPtr mon,
+qemuMonitorGetDeviceAliases(qemuMonitor *mon,
char ***aliases)
{
VIR_DEBUG("aliases=%p", aliases);
* locked already!
*/
void
-qemuMonitorSetDomainLogLocked(qemuMonitorPtr mon,
+qemuMonitorSetDomainLogLocked(qemuMonitor *mon,
qemuMonitorReportDomainLogError func,
void *opaque,
virFreeCallback destroy)
* unlocked.
*/
void
-qemuMonitorSetDomainLog(qemuMonitorPtr mon,
+qemuMonitorSetDomainLog(qemuMonitor *mon,
qemuMonitorReportDomainLogError func,
void *opaque,
virFreeCallback destroy)
* -1 on other errors.
*/
int
-qemuMonitorGetGuestCPUx86(qemuMonitorPtr mon,
- virCPUDataPtr *data,
- virCPUDataPtr *disabled)
+qemuMonitorGetGuestCPUx86(qemuMonitor *mon,
+ virCPUData **data,
+ virCPUData **disabled)
{
VIR_DEBUG("data=%p disabled=%p", data, disabled);
* Returns 0 on success, -1 on error.
*/
int
-qemuMonitorGetGuestCPU(qemuMonitorPtr mon,
+qemuMonitorGetGuestCPU(qemuMonitor *mon,
virArch arch,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr *enabled,
- virCPUDataPtr *disabled)
+ virCPUData **enabled,
+ virCPUData **disabled)
{
VIR_DEBUG("arch=%s translate=%p opaque=%p enabled=%p disabled=%p",
virArchToString(arch), translate, opaque, enabled, disabled);
* -1 on error.
*/
int
-qemuMonitorRTCResetReinjection(qemuMonitorPtr mon)
+qemuMonitorRTCResetReinjection(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
* -1 on error.
*/
int
-qemuMonitorGetIOThreads(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr **iothreads,
+qemuMonitorGetIOThreads(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo ***iothreads,
int *niothreads)
{
VIR_DEBUG("iothreads=%p", iothreads);
* Alter the specified IOThread's IOThreadInfo values.
*/
int
-qemuMonitorSetIOThread(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr iothreadInfo)
+qemuMonitorSetIOThread(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo *iothreadInfo)
{
VIR_DEBUG("iothread=%p", iothreadInfo);
* other errors returns -1.
*/
int
-qemuMonitorGetMemoryDeviceInfo(qemuMonitorPtr mon,
+qemuMonitorGetMemoryDeviceInfo(qemuMonitor *mon,
GHashTable **info)
{
int ret;
int
-qemuMonitorMigrateIncoming(qemuMonitorPtr mon,
+qemuMonitorMigrateIncoming(qemuMonitor *mon,
const char *uri)
{
VIR_DEBUG("uri=%s", uri);
int
-qemuMonitorMigrateStartPostCopy(qemuMonitorPtr mon)
+qemuMonitorMigrateStartPostCopy(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorMigrateContinue(qemuMonitorPtr mon,
+qemuMonitorMigrateContinue(qemuMonitor *mon,
qemuMonitorMigrationStatus status)
{
VIR_DEBUG("status=%s", qemuMonitorMigrationStatusTypeToString(status));
int
-qemuMonitorGetRTCTime(qemuMonitorPtr mon,
+qemuMonitorGetRTCTime(qemuMonitor *mon,
struct tm *tm)
{
QEMU_CHECK_MONITOR(mon);
}
-virJSONValuePtr
-qemuMonitorQueryQMPSchema(qemuMonitorPtr mon)
+virJSONValue *
+qemuMonitorQueryQMPSchema(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorSetBlockThreshold(qemuMonitorPtr mon,
+qemuMonitorSetBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold)
{
}
-virJSONValuePtr
-qemuMonitorQueryNamedBlockNodes(qemuMonitorPtr mon)
+virJSONValue *
+qemuMonitorQueryNamedBlockNodes(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
char *
-qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfoPtr info)
+qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo *info)
{
char *ret = NULL;
void
-qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfoPtr info)
+qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo *info)
{
if (!info)
return;
void
-qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatusPtr info)
+qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus *info)
{
if (!info)
return;
int
-qemuMonitorSetWatchdogAction(qemuMonitorPtr mon,
+qemuMonitorSetWatchdogAction(qemuMonitor *mon,
const char *action)
{
VIR_DEBUG("watchdogAction=%s", action);
* accessed after calling this function.
*/
int
-qemuMonitorBlockdevCreate(qemuMonitorPtr mon,
+qemuMonitorBlockdevCreate(qemuMonitor *mon,
const char *jobname,
- virJSONValuePtr props)
+ virJSONValue *props)
{
VIR_DEBUG("jobname=%s props=%p", jobname, props);
* and set to NULL on success.
*/
int
-qemuMonitorBlockdevAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorBlockdevAdd(qemuMonitor *mon,
+ virJSONValue **props)
{
VIR_DEBUG("props=%p (node-name=%s)", *props,
NULLSTR(virJSONValueObjectGetString(*props, "node-name")));
int
-qemuMonitorBlockdevReopen(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorBlockdevReopen(qemuMonitor *mon,
+ virJSONValue **props)
{
VIR_DEBUG("props=%p (node-name=%s)", *props,
NULLSTR(virJSONValueObjectGetString(*props, "node-name")));
int
-qemuMonitorBlockdevDel(qemuMonitorPtr mon,
+qemuMonitorBlockdevDel(qemuMonitor *mon,
const char *nodename)
{
VIR_DEBUG("nodename=%s", nodename);
}
int
-qemuMonitorBlockdevTrayOpen(qemuMonitorPtr mon,
+qemuMonitorBlockdevTrayOpen(qemuMonitor *mon,
const char *id,
bool force)
{
int
-qemuMonitorBlockdevTrayClose(qemuMonitorPtr mon,
+qemuMonitorBlockdevTrayClose(qemuMonitor *mon,
const char *id)
{
VIR_DEBUG("id=%s", id);
int
-qemuMonitorBlockdevMediumRemove(qemuMonitorPtr mon,
+qemuMonitorBlockdevMediumRemove(qemuMonitor *mon,
const char *id)
{
VIR_DEBUG("id=%s", id);
int
-qemuMonitorBlockdevMediumInsert(qemuMonitorPtr mon,
+qemuMonitorBlockdevMediumInsert(qemuMonitor *mon,
const char *id,
const char *nodename)
{
char *
-qemuMonitorGetSEVMeasurement(qemuMonitorPtr mon)
+qemuMonitorGetSEVMeasurement(qemuMonitor *mon)
{
QEMU_CHECK_MONITOR_NULL(mon);
int
-qemuMonitorGetPRManagerInfo(qemuMonitorPtr mon,
+qemuMonitorGetPRManagerInfo(qemuMonitor *mon,
GHashTable **retinfo)
{
int ret = -1;
int
-qemuMonitorGetCurrentMachineInfo(qemuMonitorPtr mon,
- qemuMonitorCurrentMachineInfoPtr info)
+qemuMonitorGetCurrentMachineInfo(qemuMonitor *mon,
+ qemuMonitorCurrentMachineInfo *info)
{
QEMU_CHECK_MONITOR(mon);
void
-qemuMonitorJobInfoFree(qemuMonitorJobInfoPtr job)
+qemuMonitorJobInfoFree(qemuMonitorJobInfo *job)
{
if (!job)
return;
int
-qemuMonitorGetJobInfo(qemuMonitorPtr mon,
- qemuMonitorJobInfoPtr **jobs,
+qemuMonitorGetJobInfo(qemuMonitor *mon,
+ qemuMonitorJobInfo ***jobs,
size_t *njobs)
{
QEMU_CHECK_MONITOR(mon);
* 0 on success (@migratable is set accordingly).
*/
int
-qemuMonitorGetCPUMigratable(qemuMonitorPtr mon,
+qemuMonitorGetCPUMigratable(qemuMonitor *mon,
bool *migratable)
{
QEMU_CHECK_MONITOR(mon);
int
-qemuMonitorTransactionBitmapAdd(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapAdd(virJSONValue *actions,
const char *node,
const char *name,
bool persistent,
int
-qemuMonitorTransactionBitmapRemove(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapRemove(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorBitmapRemove(qemuMonitorPtr mon,
+qemuMonitorBitmapRemove(qemuMonitor *mon,
const char *node,
const char *name)
{
int
-qemuMonitorTransactionBitmapEnable(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapEnable(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorTransactionBitmapDisable(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapDisable(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorTransactionBitmapMerge(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapMerge(virJSONValue *actions,
const char *node,
const char *target,
- virJSONValuePtr *sources)
+ virJSONValue **sources)
{
return qemuMonitorJSONTransactionBitmapMerge(actions, node, target, sources);
}
int
-qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValuePtr sources,
+qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
const char *sourcenode,
const char *sourcebitmap)
{
int
-qemuMonitorTransactionSnapshotLegacy(virJSONValuePtr actions,
+qemuMonitorTransactionSnapshotLegacy(virJSONValue *actions,
const char *device,
const char *path,
const char *format,
int
-qemuMonitorTransactionSnapshotBlockdev(virJSONValuePtr actions,
+qemuMonitorTransactionSnapshotBlockdev(virJSONValue *actions,
const char *node,
const char *overlay)
{
int
-qemuMonitorTransactionBackup(virJSONValuePtr actions,
+qemuMonitorTransactionBackup(virJSONValue *actions,
const char *device,
const char *jobname,
const char *target,
int
-qemuMonitorStartDirtyRateCalc(qemuMonitorPtr mon,
+qemuMonitorStartDirtyRateCalc(qemuMonitor *mon,
int seconds)
{
VIR_DEBUG("seconds=%d", seconds);
int
-qemuMonitorQueryDirtyRate(qemuMonitorPtr mon,
- qemuMonitorDirtyRateInfoPtr info)
+qemuMonitorQueryDirtyRate(qemuMonitor *mon,
+ qemuMonitorDirtyRateInfo *info)
{
VIR_DEBUG("info=%p", info);
#include "virenum.h"
typedef struct _qemuMonitor qemuMonitor;
-typedef qemuMonitor *qemuMonitorPtr;
typedef struct _qemuMonitorMessage qemuMonitorMessage;
-typedef qemuMonitorMessage *qemuMonitorMessagePtr;
-
struct _qemuMonitorMessage {
int txFD;
} qemuMonitorEventPanicInfoType;
typedef struct _qemuMonitorEventPanicInfoHyperv qemuMonitorEventPanicInfoHyperv;
-typedef qemuMonitorEventPanicInfoHyperv *qemuMonitorEventPanicInfoHypervPtr;
struct _qemuMonitorEventPanicInfoHyperv {
/* Hyper-V specific guest panic information (HV crash MSRs) */
unsigned long long arg1;
};
typedef struct _qemuMonitorEventPanicInfoS390 qemuMonitorEventPanicInfoS390;
-typedef qemuMonitorEventPanicInfoS390 *qemuMonitorEventPanicInfoS390Ptr;
struct _qemuMonitorEventPanicInfoS390 {
/* S390 specific guest panic information */
int core;
};
typedef struct _qemuMonitorEventPanicInfo qemuMonitorEventPanicInfo;
-typedef qemuMonitorEventPanicInfo *qemuMonitorEventPanicInfoPtr;
struct _qemuMonitorEventPanicInfo {
qemuMonitorEventPanicInfoType type;
union {
typedef struct _qemuMonitorRdmaGidStatus qemuMonitorRdmaGidStatus;
-typedef qemuMonitorRdmaGidStatus *qemuMonitorRdmaGidStatusPtr;
struct _qemuMonitorRdmaGidStatus {
char *netdev;
bool gid_status;
VIR_ENUM_DECL(qemuMonitorJobStatus);
typedef struct _qemuMonitorJobInfo qemuMonitorJobInfo;
-typedef qemuMonitorJobInfo *qemuMonitorJobInfoPtr;
struct _qemuMonitorJobInfo {
char *id;
qemuMonitorJobType type;
};
-char *qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfoPtr info);
-void qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfoPtr info);
-void qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatusPtr info);
+char *qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo *info);
+void qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo *info);
+void qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus *info);
-typedef void (*qemuMonitorDestroyCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef void (*qemuMonitorDestroyCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef void (*qemuMonitorEofNotifyCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef void (*qemuMonitorEofNotifyCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef void (*qemuMonitorErrorNotifyCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef void (*qemuMonitorErrorNotifyCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainEventCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainEventCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *event,
long long seconds,
unsigned int micros,
const char *details,
void *opaque);
-typedef int (*qemuMonitorDomainShutdownCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainShutdownCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
virTristateBool guest,
void *opaque);
-typedef int (*qemuMonitorDomainResetCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainResetCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainPowerdownCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainPowerdownCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainStopCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainStopCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainResumeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainResumeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainRTCChangeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainRTCChangeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
long long offset,
void *opaque);
-typedef int (*qemuMonitorDomainWatchdogCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainWatchdogCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
int action,
void *opaque);
-typedef int (*qemuMonitorDomainIOErrorCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainIOErrorCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *diskAlias,
const char *nodename,
int action,
const char *reason,
void *opaque);
-typedef int (*qemuMonitorDomainGraphicsCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainGraphicsCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
int phase,
int localFamily,
const char *localNode,
const char *x509dname,
const char *saslUsername,
void *opaque);
-typedef int (*qemuMonitorDomainBlockJobCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainBlockJobCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *diskAlias,
int type,
int status,
const char *error,
void *opaque);
-typedef int (*qemuMonitorDomainJobStatusChangeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainJobStatusChangeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *jobname,
int status,
void *opaque);
-typedef int (*qemuMonitorDomainTrayChangeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainTrayChangeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *devAlias,
const char *devid,
int reason,
void *opaque);
-typedef int (*qemuMonitorDomainPMWakeupCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainPMWakeupCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainPMSuspendCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainPMSuspendCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainBalloonChangeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainBalloonChangeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
unsigned long long actual,
void *opaque);
-typedef int (*qemuMonitorDomainPMSuspendDiskCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainPMSuspendDiskCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainGuestPanicCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
- qemuMonitorEventPanicInfoPtr info,
+typedef int (*qemuMonitorDomainGuestPanicCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
+ qemuMonitorEventPanicInfo *info,
void *opaque);
-typedef int (*qemuMonitorDomainDeviceDeletedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainDeviceDeletedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *devAlias,
void *opaque);
-typedef int (*qemuMonitorDomainNicRxFilterChangedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainNicRxFilterChangedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *devAlias,
void *opaque);
-typedef int (*qemuMonitorDomainSerialChangeCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainSerialChangeCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *devAlias,
bool connected,
void *opaque);
-typedef int (*qemuMonitorDomainSpiceMigratedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainSpiceMigratedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
-typedef int (*qemuMonitorDomainMigrationStatusCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainMigrationStatusCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
int status,
void *opaque);
-typedef int (*qemuMonitorDomainMigrationPassCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainMigrationPassCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
int pass,
void *opaque);
-typedef int (*qemuMonitorDomainAcpiOstInfoCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainAcpiOstInfoCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *alias,
const char *slotType,
const char *slot,
void *opaque);
-typedef int (*qemuMonitorDomainBlockThresholdCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainBlockThresholdCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *nodename,
unsigned long long threshold,
unsigned long long excess,
VIR_ENUM_DECL(qemuMonitorDumpStatus);
typedef struct _qemuMonitorDumpStats qemuMonitorDumpStats;
-typedef qemuMonitorDumpStats *qemuMonitorDumpStatsPtr;
struct _qemuMonitorDumpStats {
int status; /* qemuMonitorDumpStatus */
unsigned long long completed; /* bytes written */
unsigned long long total; /* total bytes to be written */
};
-typedef int (*qemuMonitorDomainDumpCompletedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainDumpCompletedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
int status,
- qemuMonitorDumpStatsPtr stats,
+ qemuMonitorDumpStats *stats,
const char *error,
void *opaque);
-typedef int (*qemuMonitorDomainPRManagerStatusChangedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainPRManagerStatusChangedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *prManager,
bool connected,
void *opaque);
-typedef int (*qemuMonitorDomainRdmaGidStatusChangedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainRdmaGidStatusChangedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
const char *netdev,
bool gid_status,
unsigned long long subnet_prefix,
unsigned long long interface_id,
void *opaque);
-typedef int (*qemuMonitorDomainGuestCrashloadedCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+typedef int (*qemuMonitorDomainGuestCrashloadedCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque);
typedef enum {
VIR_ENUM_DECL(qemuMonitorMemoryFailureAction);
typedef struct _qemuMonitorEventMemoryFailure qemuMonitorEventMemoryFailure;
-typedef qemuMonitorEventMemoryFailure *qemuMonitorEventMemoryFailurePtr;
struct _qemuMonitorEventMemoryFailure {
qemuMonitorMemoryFailureRecipient recipient;
qemuMonitorMemoryFailureAction action;
bool recursive;
};
-typedef int (*qemuMonitorDomainMemoryFailureCallback)(qemuMonitorPtr mon,
- virDomainObjPtr vm,
- qemuMonitorEventMemoryFailurePtr mfp,
+typedef int (*qemuMonitorDomainMemoryFailureCallback)(qemuMonitor *mon,
+ virDomainObj *vm,
+ qemuMonitorEventMemoryFailure *mfp,
void *opaque);
typedef struct _qemuMonitorCallbacks qemuMonitorCallbacks;
-typedef qemuMonitorCallbacks *qemuMonitorCallbacksPtr;
struct _qemuMonitorCallbacks {
qemuMonitorDestroyCallback destroy;
qemuMonitorEofNotifyCallback eofNotify;
qemuMonitorDomainMemoryFailureCallback domainMemoryFailure;
};
-qemuMonitorPtr qemuMonitorOpen(virDomainObjPtr vm,
- virDomainChrSourceDefPtr config,
+qemuMonitor *qemuMonitorOpen(virDomainObj *vm,
+ virDomainChrSourceDef *config,
bool retry,
unsigned long long timeout,
GMainContext *context,
- qemuMonitorCallbacksPtr cb,
+ qemuMonitorCallbacks *cb,
void *opaque)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
void qemuMonitorWatchDispose(void);
bool qemuMonitorWasDisposed(void);
-void qemuMonitorRegister(qemuMonitorPtr mon)
+void qemuMonitorRegister(qemuMonitor *mon)
ATTRIBUTE_NONNULL(1);
-void qemuMonitorUnregister(qemuMonitorPtr mon)
+void qemuMonitorUnregister(qemuMonitor *mon)
ATTRIBUTE_NONNULL(1);
-void qemuMonitorClose(qemuMonitorPtr mon);
+void qemuMonitorClose(qemuMonitor *mon);
-virErrorPtr qemuMonitorLastError(qemuMonitorPtr mon);
+virErrorPtr qemuMonitorLastError(qemuMonitor *mon);
-int qemuMonitorSetCapabilities(qemuMonitorPtr mon);
+int qemuMonitorSetCapabilities(qemuMonitor *mon);
-int qemuMonitorSetLink(qemuMonitorPtr mon,
+int qemuMonitorSetLink(qemuMonitor *mon,
const char *name,
virDomainNetInterfaceLinkState state)
ATTRIBUTE_NONNULL(2);
/* These APIs are for use by the internal Text/JSON monitor impl code only */
-char *qemuMonitorNextCommandID(qemuMonitorPtr mon);
-int qemuMonitorSend(qemuMonitorPtr mon,
- qemuMonitorMessagePtr msg) G_GNUC_NO_INLINE;
-int qemuMonitorUpdateVideoMemorySize(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+char *qemuMonitorNextCommandID(qemuMonitor *mon);
+int qemuMonitorSend(qemuMonitor *mon,
+ qemuMonitorMessage *msg) G_GNUC_NO_INLINE;
+int qemuMonitorUpdateVideoMemorySize(qemuMonitor *mon,
+ virDomainVideoDef *video,
const char *videoName)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorUpdateVideoVram64Size(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+int qemuMonitorUpdateVideoVram64Size(qemuMonitor *mon,
+ virDomainVideoDef *video,
const char *videoName)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorEmitEvent(qemuMonitorPtr mon, const char *event,
+int qemuMonitorEmitEvent(qemuMonitor *mon, const char *event,
long long seconds, unsigned int micros,
const char *details);
-int qemuMonitorEmitShutdown(qemuMonitorPtr mon, virTristateBool guest);
-int qemuMonitorEmitReset(qemuMonitorPtr mon);
-int qemuMonitorEmitPowerdown(qemuMonitorPtr mon);
-int qemuMonitorEmitStop(qemuMonitorPtr mon);
-int qemuMonitorEmitResume(qemuMonitorPtr mon);
-int qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset);
-int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action);
-int qemuMonitorEmitIOError(qemuMonitorPtr mon,
+int qemuMonitorEmitShutdown(qemuMonitor *mon, virTristateBool guest);
+int qemuMonitorEmitReset(qemuMonitor *mon);
+int qemuMonitorEmitPowerdown(qemuMonitor *mon);
+int qemuMonitorEmitStop(qemuMonitor *mon);
+int qemuMonitorEmitResume(qemuMonitor *mon);
+int qemuMonitorEmitRTCChange(qemuMonitor *mon, long long offset);
+int qemuMonitorEmitWatchdog(qemuMonitor *mon, int action);
+int qemuMonitorEmitIOError(qemuMonitor *mon,
const char *diskAlias,
const char *nodename,
int action,
const char *reason);
-int qemuMonitorEmitGraphics(qemuMonitorPtr mon,
+int qemuMonitorEmitGraphics(qemuMonitor *mon,
int phase,
int localFamily,
const char *localNode,
const char *authScheme,
const char *x509dname,
const char *saslUsername);
-int qemuMonitorEmitTrayChange(qemuMonitorPtr mon,
+int qemuMonitorEmitTrayChange(qemuMonitor *mon,
const char *devAlias,
const char *devid,
int reason);
-int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon);
-int qemuMonitorEmitPMSuspend(qemuMonitorPtr mon);
-int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
+int qemuMonitorEmitPMWakeup(qemuMonitor *mon);
+int qemuMonitorEmitPMSuspend(qemuMonitor *mon);
+int qemuMonitorEmitBlockJob(qemuMonitor *mon,
const char *diskAlias,
int type,
int status,
const char *error);
-int qemuMonitorEmitJobStatusChange(qemuMonitorPtr mon,
+int qemuMonitorEmitJobStatusChange(qemuMonitor *mon,
const char *jobname,
qemuMonitorJobStatus status);
-int qemuMonitorEmitBalloonChange(qemuMonitorPtr mon,
+int qemuMonitorEmitBalloonChange(qemuMonitor *mon,
unsigned long long actual);
-int qemuMonitorEmitPMSuspendDisk(qemuMonitorPtr mon);
-int qemuMonitorEmitGuestPanic(qemuMonitorPtr mon,
- qemuMonitorEventPanicInfoPtr info);
-int qemuMonitorEmitDeviceDeleted(qemuMonitorPtr mon,
+int qemuMonitorEmitPMSuspendDisk(qemuMonitor *mon);
+int qemuMonitorEmitGuestPanic(qemuMonitor *mon,
+ qemuMonitorEventPanicInfo *info);
+int qemuMonitorEmitDeviceDeleted(qemuMonitor *mon,
const char *devAlias);
-int qemuMonitorEmitNicRxFilterChanged(qemuMonitorPtr mon,
+int qemuMonitorEmitNicRxFilterChanged(qemuMonitor *mon,
const char *devAlias);
-int qemuMonitorEmitSerialChange(qemuMonitorPtr mon,
+int qemuMonitorEmitSerialChange(qemuMonitor *mon,
const char *devAlias,
bool connected);
-int qemuMonitorEmitSpiceMigrated(qemuMonitorPtr mon);
+int qemuMonitorEmitSpiceMigrated(qemuMonitor *mon);
-int qemuMonitorEmitMemoryFailure(qemuMonitorPtr mon,
- qemuMonitorEventMemoryFailurePtr mfp);
+int qemuMonitorEmitMemoryFailure(qemuMonitor *mon,
+ qemuMonitorEventMemoryFailure *mfp);
-int qemuMonitorEmitMigrationStatus(qemuMonitorPtr mon,
+int qemuMonitorEmitMigrationStatus(qemuMonitor *mon,
int status);
-int qemuMonitorEmitMigrationPass(qemuMonitorPtr mon,
+int qemuMonitorEmitMigrationPass(qemuMonitor *mon,
int pass);
-int qemuMonitorEmitAcpiOstInfo(qemuMonitorPtr mon,
+int qemuMonitorEmitAcpiOstInfo(qemuMonitor *mon,
const char *alias,
const char *slotType,
const char *slot,
unsigned int source,
unsigned int status);
-int qemuMonitorEmitBlockThreshold(qemuMonitorPtr mon,
+int qemuMonitorEmitBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold,
unsigned long long excess);
-int qemuMonitorEmitDumpCompleted(qemuMonitorPtr mon,
+int qemuMonitorEmitDumpCompleted(qemuMonitor *mon,
int status,
- qemuMonitorDumpStatsPtr stats,
+ qemuMonitorDumpStats *stats,
const char *error);
-int qemuMonitorEmitPRManagerStatusChanged(qemuMonitorPtr mon,
+int qemuMonitorEmitPRManagerStatusChanged(qemuMonitor *mon,
const char *prManager,
bool connected);
-int qemuMonitorEmitRdmaGidStatusChanged(qemuMonitorPtr mon,
+int qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor *mon,
const char *netdev,
bool gid_status,
unsigned long long subnet_prefix,
unsigned long long interface_id);
-int qemuMonitorEmitGuestCrashloaded(qemuMonitorPtr mon);
+int qemuMonitorEmitGuestCrashloaded(qemuMonitor *mon);
-int qemuMonitorStartCPUs(qemuMonitorPtr mon);
-int qemuMonitorStopCPUs(qemuMonitorPtr mon);
+int qemuMonitorStartCPUs(qemuMonitor *mon);
+int qemuMonitorStopCPUs(qemuMonitor *mon);
typedef enum {
QEMU_MONITOR_VM_STATUS_DEBUG,
VIR_ENUM_DECL(qemuMonitorVMStatus);
int qemuMonitorVMStatusToPausedReason(const char *status);
-int qemuMonitorCheck(qemuMonitorPtr mon);
-int qemuMonitorGetStatus(qemuMonitorPtr mon,
+int qemuMonitorCheck(qemuMonitor *mon);
+int qemuMonitorGetStatus(qemuMonitor *mon,
bool *running,
virDomainPausedReason *reason)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorSystemReset(qemuMonitorPtr mon);
-int qemuMonitorSystemPowerdown(qemuMonitorPtr mon);
+int qemuMonitorSystemReset(qemuMonitor *mon);
+int qemuMonitorSystemPowerdown(qemuMonitor *mon);
struct qemuMonitorQueryCpusEntry {
int qemu_id; /* id of the cpu as reported by qemu */
char *alias; /* device alias, may be NULL for non-hotpluggable entities */
/* verbatim copy of the JSON data representing the CPU which must be used for hotplug */
- virJSONValuePtr props;
+ virJSONValue *props;
/* topology information -1 if qemu didn't report given parameter */
int node_id;
char *type;
/* verbatim copy of the returned data from qemu which should be used when plugging */
- virJSONValuePtr props;
+ virJSONValue *props;
/* alias of an hotpluggable entry. Entries with alias can be hot-unplugged */
char *alias;
bool halted;
};
typedef struct _qemuMonitorCPUInfo qemuMonitorCPUInfo;
-typedef qemuMonitorCPUInfo *qemuMonitorCPUInfoPtr;
-void qemuMonitorCPUInfoFree(qemuMonitorCPUInfoPtr list,
+void qemuMonitorCPUInfoFree(qemuMonitorCPUInfo *list,
size_t nitems);
-int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
- qemuMonitorCPUInfoPtr *vcpus,
+int qemuMonitorGetCPUInfo(qemuMonitor *mon,
+ qemuMonitorCPUInfo **vcpus,
size_t maxvcpus,
bool hotplug,
bool fast);
-virBitmapPtr qemuMonitorGetCpuHalted(qemuMonitorPtr mon,
+virBitmap *qemuMonitorGetCpuHalted(qemuMonitor *mon,
size_t maxvcpus,
bool fast);
-int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
+int qemuMonitorGetBalloonInfo(qemuMonitor *mon,
unsigned long long *currmem);
-int qemuMonitorGetMemoryStats(qemuMonitorPtr mon,
- virDomainMemballoonDefPtr balloon,
+int qemuMonitorGetMemoryStats(qemuMonitor *mon,
+ virDomainMemballoonDef *balloon,
virDomainMemoryStatPtr stats,
unsigned int nr_stats);
-int qemuMonitorSetMemoryStatsPeriod(qemuMonitorPtr mon,
- virDomainMemballoonDefPtr balloon,
+int qemuMonitorSetMemoryStatsPeriod(qemuMonitor *mon,
+ virDomainMemballoonDef *balloon,
int period);
int qemuMonitorBlockIOStatusToError(const char *status);
-GHashTable *qemuMonitorGetBlockInfo(qemuMonitorPtr mon);
+GHashTable *qemuMonitorGetBlockInfo(qemuMonitor *mon);
-virJSONValuePtr qemuMonitorQueryBlockstats(qemuMonitorPtr mon);
+virJSONValue *qemuMonitorQueryBlockstats(qemuMonitor *mon);
typedef struct _qemuBlockStats qemuBlockStats;
-typedef qemuBlockStats *qemuBlockStatsPtr;
struct _qemuBlockStats {
unsigned long long rd_req;
unsigned long long rd_bytes;
unsigned long long write_threshold;
};
-int qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
+int qemuMonitorGetAllBlockStatsInfo(qemuMonitor *mon,
GHashTable **ret_stats,
bool backingChain)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
+int qemuMonitorBlockStatsUpdateCapacity(qemuMonitor *mon,
GHashTable *stats,
bool backingChain)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
+int qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
GHashTable *stats)
ATTRIBUTE_NONNULL(2);
typedef struct _qemuBlockNamedNodeDataBitmap qemuBlockNamedNodeDataBitmap;
-typedef qemuBlockNamedNodeDataBitmap *qemuBlockNamedNodeDataBitmapPtr;
struct _qemuBlockNamedNodeDataBitmap {
char *name;
bool recording;
};
typedef struct _qemuBlockNamedNodeData qemuBlockNamedNodeData;
-typedef qemuBlockNamedNodeData *qemuBlockNamedNodeDataPtr;
struct _qemuBlockNamedNodeData {
unsigned long long capacity;
unsigned long long physical;
- qemuBlockNamedNodeDataBitmapPtr *bitmaps;
+ qemuBlockNamedNodeDataBitmap **bitmaps;
size_t nbitmaps;
/* the cluster size of the image is valid only when > 0 */
};
GHashTable *
-qemuMonitorBlockGetNamedNodeData(qemuMonitorPtr mon,
+qemuMonitorBlockGetNamedNodeData(qemuMonitor *mon,
bool supports_flat);
-int qemuMonitorBlockResize(qemuMonitorPtr mon,
+int qemuMonitorBlockResize(qemuMonitor *mon,
const char *device,
const char *nodename,
unsigned long long size);
-int qemuMonitorSetPassword(qemuMonitorPtr mon,
+int qemuMonitorSetPassword(qemuMonitor *mon,
int type,
const char *password,
const char *action_if_connected);
-int qemuMonitorExpirePassword(qemuMonitorPtr mon,
+int qemuMonitorExpirePassword(qemuMonitor *mon,
int type,
const char *expire_time);
-int qemuMonitorSetBalloon(qemuMonitorPtr mon,
+int qemuMonitorSetBalloon(qemuMonitor *mon,
unsigned long long newmem);
-int qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, bool online);
+int qemuMonitorSetCPU(qemuMonitor *mon, int cpu, bool online);
-/* XXX should we pass the virDomainDiskDefPtr instead
+/* XXX should we pass the virDomainDiskDef *instead
* and hide dev_name details inside monitor. Reconsider
* this when doing the QMP implementation
*/
-int qemuMonitorEjectMedia(qemuMonitorPtr mon,
+int qemuMonitorEjectMedia(qemuMonitor *mon,
const char *dev_name,
bool force);
-int qemuMonitorChangeMedia(qemuMonitorPtr mon,
+int qemuMonitorChangeMedia(qemuMonitor *mon,
const char *dev_name,
const char *newmedia,
const char *format);
-int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
+int qemuMonitorSaveVirtualMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path);
-int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
+int qemuMonitorSavePhysicalMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path);
-int qemuMonitorSetDBusVMStateIdList(qemuMonitorPtr mon,
+int qemuMonitorSetDBusVMStateIdList(qemuMonitor *mon,
GSList *list);
-int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
+int qemuMonitorSetMigrationSpeed(qemuMonitor *mon,
unsigned long bandwidth);
-int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon,
+int qemuMonitorSetMigrationDowntime(qemuMonitor *mon,
unsigned long long downtime);
-int qemuMonitorGetMigrationCacheSize(qemuMonitorPtr mon,
+int qemuMonitorGetMigrationCacheSize(qemuMonitor *mon,
unsigned long long *cacheSize);
-int qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon,
+int qemuMonitorSetMigrationCacheSize(qemuMonitor *mon,
unsigned long long cacheSize);
-int qemuMonitorGetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params);
-int qemuMonitorSetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params);
+int qemuMonitorGetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params);
+int qemuMonitorSetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params);
typedef enum {
QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
VIR_ENUM_DECL(qemuMonitorMigrationStatus);
typedef struct _qemuMonitorMigrationStats qemuMonitorMigrationStats;
-typedef qemuMonitorMigrationStats *qemuMonitorMigrationStatsPtr;
struct _qemuMonitorMigrationStats {
int status; /* qemuMonitorMigrationStatus */
unsigned long long total_time;
int cpu_throttle_percentage;
};
-int qemuMonitorGetMigrationStats(qemuMonitorPtr mon,
- qemuMonitorMigrationStatsPtr stats,
+int qemuMonitorGetMigrationStats(qemuMonitor *mon,
+ qemuMonitorMigrationStats *stats,
char **error);
-int qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon,
+int qemuMonitorGetMigrationCapabilities(qemuMonitor *mon,
char ***capabilities);
-int qemuMonitorSetMigrationCapabilities(qemuMonitorPtr mon,
- virJSONValuePtr *caps);
+int qemuMonitorSetMigrationCapabilities(qemuMonitor *mon,
+ virJSONValue **caps);
-int qemuMonitorGetGICCapabilities(qemuMonitorPtr mon,
+int qemuMonitorGetGICCapabilities(qemuMonitor *mon,
virGICCapability **capabilities);
-int qemuMonitorGetSEVCapabilities(qemuMonitorPtr mon,
+int qemuMonitorGetSEVCapabilities(qemuMonitor *mon,
virSEVCapability **capabilities);
typedef enum {
QEMU_MONITOR_MIGRATION_FLAGS_LAST
} QEMU_MONITOR_MIGRATE;
-int qemuMonitorMigrateToFd(qemuMonitorPtr mon,
+int qemuMonitorMigrateToFd(qemuMonitor *mon,
unsigned int flags,
int fd);
-int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
+int qemuMonitorMigrateToHost(qemuMonitor *mon,
unsigned int flags,
const char *protocol,
const char *hostname,
int port);
-int qemuMonitorMigrateToSocket(qemuMonitorPtr mon,
+int qemuMonitorMigrateToSocket(qemuMonitor *mon,
unsigned int flags,
const char *socketPath);
-int qemuMonitorMigrateCancel(qemuMonitorPtr mon);
+int qemuMonitorMigrateCancel(qemuMonitor *mon);
-int qemuMonitorGetDumpGuestMemoryCapability(qemuMonitorPtr mon,
+int qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor *mon,
const char *capability);
-int qemuMonitorQueryDump(qemuMonitorPtr mon,
- qemuMonitorDumpStatsPtr stats);
+int qemuMonitorQueryDump(qemuMonitor *mon,
+ qemuMonitorDumpStats *stats);
-int qemuMonitorDumpToFd(qemuMonitorPtr mon,
+int qemuMonitorDumpToFd(qemuMonitor *mon,
int fd,
const char *dumpformat,
bool detach);
-int qemuMonitorGraphicsRelocate(qemuMonitorPtr mon,
+int qemuMonitorGraphicsRelocate(qemuMonitor *mon,
int type,
const char *hostname,
int port,
const char *tlsSubject);
typedef struct _qemuMonitorAddFdInfo qemuMonitorAddFdInfo;
-typedef qemuMonitorAddFdInfo *qemuMonitorAddFdInfoPtr;
struct _qemuMonitorAddFdInfo {
int fd;
int fdset;
};
int
-qemuMonitorAddFileHandleToSet(qemuMonitorPtr mon,
+qemuMonitorAddFileHandleToSet(qemuMonitor *mon,
int fd,
int fdset,
const char *opaque,
- qemuMonitorAddFdInfoPtr info);
+ qemuMonitorAddFdInfo *info);
int
-qemuMonitorRemoveFdset(qemuMonitorPtr mon,
+qemuMonitorRemoveFdset(qemuMonitor *mon,
int fdset);
typedef struct _qemuMonitorFdsetFdInfo qemuMonitorFdsetFdInfo;
-typedef qemuMonitorFdsetFdInfo *qemuMonitorFdsetFdInfoPtr;
struct _qemuMonitorFdsetFdInfo {
int fd;
char *opaque;
};
typedef struct _qemuMonitorFdsetInfo qemuMonitorFdsetInfo;
-typedef qemuMonitorFdsetInfo *qemuMonitorFdsetInfoPtr;
struct _qemuMonitorFdsetInfo {
int id;
- qemuMonitorFdsetFdInfoPtr fds;
+ qemuMonitorFdsetFdInfo *fds;
int nfds;
};
typedef struct _qemuMonitorFdsets qemuMonitorFdsets;
-typedef qemuMonitorFdsets *qemuMonitorFdsetsPtr;
struct _qemuMonitorFdsets {
- qemuMonitorFdsetInfoPtr fdsets;
+ qemuMonitorFdsetInfo *fdsets;
int nfdsets;
};
-void qemuMonitorFdsetsFree(qemuMonitorFdsetsPtr fdsets);
+void qemuMonitorFdsetsFree(qemuMonitorFdsets *fdsets);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorFdsets, qemuMonitorFdsetsFree);
-int qemuMonitorQueryFdsets(qemuMonitorPtr mon,
- qemuMonitorFdsetsPtr *fdsets);
+int qemuMonitorQueryFdsets(qemuMonitor *mon,
+ qemuMonitorFdsets **fdsets);
-int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
+int qemuMonitorSendFileHandle(qemuMonitor *mon,
const char *fdname,
int fd);
/* This function preserves previous error and only set their own
* error if no error was set before.
*/
-int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
+int qemuMonitorCloseFileHandle(qemuMonitor *mon,
const char *fdname);
-int qemuMonitorAddNetdev(qemuMonitorPtr mon,
- virJSONValuePtr *props,
+int qemuMonitorAddNetdev(qemuMonitor *mon,
+ virJSONValue **props,
int *tapfd, char **tapfdName, int tapfdSize,
int *vhostfd, char **vhostfdName, int vhostfdSize,
int slirpfd, char *slirpfdName);
-int qemuMonitorRemoveNetdev(qemuMonitorPtr mon,
+int qemuMonitorRemoveNetdev(qemuMonitor *mon,
const char *alias);
-int qemuMonitorQueryRxFilter(qemuMonitorPtr mon, const char *alias,
- virNetDevRxFilterPtr *filter);
+int qemuMonitorQueryRxFilter(qemuMonitor *mon, const char *alias,
+ virNetDevRxFilter **filter);
typedef struct _qemuMonitorChardevInfo qemuMonitorChardevInfo;
-typedef qemuMonitorChardevInfo *qemuMonitorChardevInfoPtr;
struct _qemuMonitorChardevInfo {
char *ptyPath;
virDomainChrDeviceState state;
};
void qemuMonitorChardevInfoFree(void *data);
-int qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
+int qemuMonitorGetChardevInfo(qemuMonitor *mon,
GHashTable **retinfo);
-int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
+int qemuMonitorAttachPCIDiskController(qemuMonitor *mon,
const char *bus,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorAddDeviceArgs(qemuMonitorPtr mon,
- virJSONValuePtr args);
-int qemuMonitorAddDevice(qemuMonitorPtr mon,
+int qemuMonitorAddDeviceArgs(qemuMonitor *mon,
+ virJSONValue *args);
+int qemuMonitorAddDevice(qemuMonitor *mon,
const char *devicestr);
-int qemuMonitorAddDeviceWithFd(qemuMonitorPtr mon,
+int qemuMonitorAddDeviceWithFd(qemuMonitor *mon,
const char *devicestr,
int fd,
const char *fdname);
-int qemuMonitorDelDevice(qemuMonitorPtr mon,
+int qemuMonitorDelDevice(qemuMonitor *mon,
const char *devalias);
-int qemuMonitorCreateObjectProps(virJSONValuePtr *propsret,
+int qemuMonitorCreateObjectProps(virJSONValue **propsret,
const char *type,
const char *alias,
...);
-int qemuMonitorAddObject(qemuMonitorPtr mon,
- virJSONValuePtr *props,
+int qemuMonitorAddObject(qemuMonitor *mon,
+ virJSONValue **props,
char **alias)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorDelObject(qemuMonitorPtr mon,
+int qemuMonitorDelObject(qemuMonitor *mon,
const char *objalias,
bool report_error);
-int qemuMonitorAddDrive(qemuMonitorPtr mon,
+int qemuMonitorAddDrive(qemuMonitor *mon,
const char *drivestr);
-int qemuMonitorDriveDel(qemuMonitorPtr mon,
+int qemuMonitorDriveDel(qemuMonitor *mon,
const char *drivestr);
-int qemuMonitorCreateSnapshot(qemuMonitorPtr mon, const char *name);
-int qemuMonitorLoadSnapshot(qemuMonitorPtr mon, const char *name);
-int qemuMonitorDeleteSnapshot(qemuMonitorPtr mon, const char *name);
+int qemuMonitorCreateSnapshot(qemuMonitor *mon, const char *name);
+int qemuMonitorLoadSnapshot(qemuMonitor *mon, const char *name);
+int qemuMonitorDeleteSnapshot(qemuMonitor *mon, const char *name);
-int qemuMonitorTransaction(qemuMonitorPtr mon, virJSONValuePtr *actions)
+int qemuMonitorTransaction(qemuMonitor *mon, virJSONValue **actions)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorDriveMirror(qemuMonitorPtr mon,
+int qemuMonitorDriveMirror(qemuMonitor *mon,
const char *device,
const char *file,
const char *format,
bool shallow,
bool reuse)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorBlockdevMirror(qemuMonitorPtr mon,
+int qemuMonitorBlockdevMirror(qemuMonitor *mon,
const char *jobname,
bool persistjob,
const char *device,
unsigned long long buf_size,
bool shallow)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
-int qemuMonitorDrivePivot(qemuMonitorPtr mon,
+int qemuMonitorDrivePivot(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorBlockCommit(qemuMonitorPtr mon,
+int qemuMonitorBlockCommit(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
const char *backingName,
unsigned long long bandwidth)
ATTRIBUTE_NONNULL(2);
-bool qemuMonitorSupportsActiveCommit(qemuMonitorPtr mon);
-char *qemuMonitorDiskNameLookup(qemuMonitorPtr mon,
+bool qemuMonitorSupportsActiveCommit(qemuMonitor *mon);
+char *qemuMonitorDiskNameLookup(qemuMonitor *mon,
const char *device,
- virStorageSourcePtr top,
- virStorageSourcePtr target)
+ virStorageSource *top,
+ virStorageSource *target)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-int qemuMonitorArbitraryCommand(qemuMonitorPtr mon,
+int qemuMonitorArbitraryCommand(qemuMonitor *mon,
const char *cmd,
char **reply,
bool hmp);
-int qemuMonitorInjectNMI(qemuMonitorPtr mon);
+int qemuMonitorInjectNMI(qemuMonitor *mon);
-int qemuMonitorScreendump(qemuMonitorPtr mon,
+int qemuMonitorScreendump(qemuMonitor *mon,
const char *device,
unsigned int head,
const char *file);
-int qemuMonitorSendKey(qemuMonitorPtr mon,
+int qemuMonitorSendKey(qemuMonitor *mon,
unsigned int holdtime,
unsigned int *keycodes,
unsigned int nkeycodes);
-int qemuMonitorBlockStream(qemuMonitorPtr mon,
+int qemuMonitorBlockStream(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
unsigned long long bandwidth)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorBlockJobCancel(qemuMonitorPtr mon,
+int qemuMonitorBlockJobCancel(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorBlockJobSetSpeed(qemuMonitorPtr mon,
+int qemuMonitorBlockJobSetSpeed(qemuMonitor *mon,
const char *jobname,
unsigned long long bandwidth);
typedef struct _qemuMonitorBlockJobInfo qemuMonitorBlockJobInfo;
-typedef qemuMonitorBlockJobInfo *qemuMonitorBlockJobInfoPtr;
struct _qemuMonitorBlockJobInfo {
int type; /* virDomainBlockJobType */
unsigned long long bandwidth; /* in bytes/s */
bool ready;
};
-GHashTable *qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon,
+GHashTable *qemuMonitorGetAllBlockJobInfo(qemuMonitor *mon,
bool rawjobname);
-int qemuMonitorJobDismiss(qemuMonitorPtr mon,
+int qemuMonitorJobDismiss(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJobCancel(qemuMonitorPtr mon,
+int qemuMonitorJobCancel(qemuMonitor *mon,
const char *jobname,
bool quiet)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJobComplete(qemuMonitorPtr mon,
+int qemuMonitorJobComplete(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorOpenGraphics(qemuMonitorPtr mon,
+int qemuMonitorOpenGraphics(qemuMonitor *mon,
const char *protocol,
int fd,
const char *fdname,
bool skipauth);
-int qemuMonitorSetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorSetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qomid,
- virDomainBlockIoTuneInfoPtr info,
+ virDomainBlockIoTuneInfo *info,
bool supportMaxOptions,
bool supportGroupNameOption,
bool supportMaxLengthOptions);
-int qemuMonitorGetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorGetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qdevid,
- virDomainBlockIoTuneInfoPtr reply);
+ virDomainBlockIoTuneInfo *reply);
-int qemuMonitorSystemWakeup(qemuMonitorPtr mon);
+int qemuMonitorSystemWakeup(qemuMonitor *mon);
-int qemuMonitorGetVersion(qemuMonitorPtr mon,
+int qemuMonitorGetVersion(qemuMonitor *mon,
int *major,
int *minor,
int *micro,
typedef struct _qemuMonitorMachineInfo qemuMonitorMachineInfo;
-typedef qemuMonitorMachineInfo *qemuMonitorMachineInfoPtr;
-
struct _qemuMonitorMachineInfo {
char *name;
bool isDefault;
bool deprecated;
};
-int qemuMonitorGetMachines(qemuMonitorPtr mon,
- qemuMonitorMachineInfoPtr **machines);
+int qemuMonitorGetMachines(qemuMonitor *mon,
+ qemuMonitorMachineInfo ***machines);
-void qemuMonitorMachineInfoFree(qemuMonitorMachineInfoPtr machine);
+void qemuMonitorMachineInfoFree(qemuMonitorMachineInfo *machine);
typedef struct _qemuMonitorCPUDefInfo qemuMonitorCPUDefInfo;
-typedef qemuMonitorCPUDefInfo *qemuMonitorCPUDefInfoPtr;
-
struct _qemuMonitorCPUDefInfo {
virDomainCapsCPUUsable usable;
char *name;
};
typedef struct _qemuMonitorCPUDefs qemuMonitorCPUDefs;
-typedef qemuMonitorCPUDefs *qemuMonitorCPUDefsPtr;
struct _qemuMonitorCPUDefs {
size_t ncpus;
- qemuMonitorCPUDefInfoPtr cpus;
+ qemuMonitorCPUDefInfo *cpus;
};
-int qemuMonitorGetCPUDefinitions(qemuMonitorPtr mon,
- qemuMonitorCPUDefsPtr *cpuDefs);
-qemuMonitorCPUDefsPtr qemuMonitorCPUDefsNew(size_t count);
-qemuMonitorCPUDefsPtr qemuMonitorCPUDefsCopy(qemuMonitorCPUDefsPtr src);
-void qemuMonitorCPUDefsFree(qemuMonitorCPUDefsPtr defs);
+int qemuMonitorGetCPUDefinitions(qemuMonitor *mon,
+ qemuMonitorCPUDefs **cpuDefs);
+qemuMonitorCPUDefs *qemuMonitorCPUDefsNew(size_t count);
+qemuMonitorCPUDefs *qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs *src);
+void qemuMonitorCPUDefsFree(qemuMonitorCPUDefs *defs);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorCPUDefs, qemuMonitorCPUDefsFree);
VIR_ENUM_DECL(qemuMonitorCPUProperty);
typedef struct _qemuMonitorCPUProperty qemuMonitorCPUProperty;
-typedef qemuMonitorCPUProperty *qemuMonitorCPUPropertyPtr;
struct _qemuMonitorCPUProperty {
char *name;
qemuMonitorCPUPropertyType type;
};
typedef struct _qemuMonitorCPUModelInfo qemuMonitorCPUModelInfo;
-typedef qemuMonitorCPUModelInfo *qemuMonitorCPUModelInfoPtr;
-
struct _qemuMonitorCPUModelInfo {
char *name;
size_t nprops;
- qemuMonitorCPUPropertyPtr props;
+ qemuMonitorCPUProperty *props;
bool migratability;
};
QEMU_MONITOR_CPU_MODEL_EXPANSION_FULL,
} qemuMonitorCPUModelExpansionType;
-int qemuMonitorGetCPUModelExpansion(qemuMonitorPtr mon,
+int qemuMonitorGetCPUModelExpansion(qemuMonitor *mon,
qemuMonitorCPUModelExpansionType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable,
bool fail_no_props,
- qemuMonitorCPUModelInfoPtr *model_info);
+ qemuMonitorCPUModelInfo **model_info);
-void qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfoPtr model_info);
+void qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo *model_info);
-int qemuMonitorGetCPUModelBaseline(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
- qemuMonitorCPUModelInfoPtr *baseline);
+int qemuMonitorGetCPUModelBaseline(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
+ qemuMonitorCPUModelInfo **baseline);
-int qemuMonitorGetCPUModelComparison(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
+int qemuMonitorGetCPUModelComparison(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
char **result);
-qemuMonitorCPUModelInfoPtr
+qemuMonitorCPUModelInfo *
qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo *orig);
-int qemuMonitorGetCommands(qemuMonitorPtr mon,
+int qemuMonitorGetCommands(qemuMonitor *mon,
char ***commands);
-int qemuMonitorGetEvents(qemuMonitorPtr mon,
+int qemuMonitorGetEvents(qemuMonitor *mon,
char ***events);
-GHashTable *qemuMonitorGetCommandLineOptions(qemuMonitorPtr mon);
+GHashTable *qemuMonitorGetCommandLineOptions(qemuMonitor *mon);
-int qemuMonitorGetKVMState(qemuMonitorPtr mon,
+int qemuMonitorGetKVMState(qemuMonitor *mon,
bool *enabled,
bool *present);
-int qemuMonitorGetObjectTypes(qemuMonitorPtr mon,
+int qemuMonitorGetObjectTypes(qemuMonitor *mon,
char ***types);
-GHashTable *qemuMonitorGetDeviceProps(qemuMonitorPtr mon,
+GHashTable *qemuMonitorGetDeviceProps(qemuMonitor *mon,
const char *device);
-int qemuMonitorGetObjectProps(qemuMonitorPtr mon,
+int qemuMonitorGetObjectProps(qemuMonitor *mon,
const char *object,
char ***props);
-char *qemuMonitorGetTargetArch(qemuMonitorPtr mon);
+char *qemuMonitorGetTargetArch(qemuMonitor *mon);
-int qemuMonitorNBDServerStart(qemuMonitorPtr mon,
+int qemuMonitorNBDServerStart(qemuMonitor *mon,
const virStorageNetHostDef *server,
const char *tls_alias)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorNBDServerAdd(qemuMonitorPtr mon,
+int qemuMonitorNBDServerAdd(qemuMonitor *mon,
const char *deviceID,
const char *export,
bool writable,
const char *bitmap);
-int qemuMonitorNBDServerStop(qemuMonitorPtr);
+int qemuMonitorNBDServerStop(qemuMonitor *);
-int qemuMonitorBlockExportAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorBlockExportAdd(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorGetTPMModels(qemuMonitorPtr mon,
+int qemuMonitorGetTPMModels(qemuMonitor *mon,
char ***tpmmodels);
-int qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
+int qemuMonitorGetTPMTypes(qemuMonitor *mon,
char ***tpmtypes);
-int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
+int qemuMonitorAttachCharDev(qemuMonitor *mon,
const char *chrID,
- virDomainChrSourceDefPtr chr);
-int qemuMonitorDetachCharDev(qemuMonitorPtr mon,
+ virDomainChrSourceDef *chr);
+int qemuMonitorDetachCharDev(qemuMonitor *mon,
const char *chrID);
-int qemuMonitorGetDeviceAliases(qemuMonitorPtr mon,
+int qemuMonitorGetDeviceAliases(qemuMonitor *mon,
char ***aliases);
-typedef void (*qemuMonitorReportDomainLogError)(qemuMonitorPtr mon,
+typedef void (*qemuMonitorReportDomainLogError)(qemuMonitor *mon,
const char *msg,
void *opaque);
-void qemuMonitorSetDomainLogLocked(qemuMonitorPtr mon,
+void qemuMonitorSetDomainLogLocked(qemuMonitor *mon,
qemuMonitorReportDomainLogError func,
void *opaque,
virFreeCallback destroy);
-void qemuMonitorSetDomainLog(qemuMonitorPtr mon,
+void qemuMonitorSetDomainLog(qemuMonitor *mon,
qemuMonitorReportDomainLogError func,
void *opaque,
virFreeCallback destroy);
-int qemuMonitorGetGuestCPUx86(qemuMonitorPtr mon,
- virCPUDataPtr *data,
- virCPUDataPtr *disabled);
+int qemuMonitorGetGuestCPUx86(qemuMonitor *mon,
+ virCPUData **data,
+ virCPUData **disabled);
typedef const char *(*qemuMonitorCPUFeatureTranslationCallback)(const char *name,
void *opaque);
-int qemuMonitorGetGuestCPU(qemuMonitorPtr mon,
+int qemuMonitorGetGuestCPU(qemuMonitor *mon,
virArch arch,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr *enabled,
- virCPUDataPtr *disabled);
+ virCPUData **enabled,
+ virCPUData **disabled);
-int qemuMonitorRTCResetReinjection(qemuMonitorPtr mon);
+int qemuMonitorRTCResetReinjection(qemuMonitor *mon);
typedef struct _qemuMonitorIOThreadInfo qemuMonitorIOThreadInfo;
-typedef qemuMonitorIOThreadInfo *qemuMonitorIOThreadInfoPtr;
-
struct _qemuMonitorIOThreadInfo {
unsigned int iothread_id;
int thread_id;
bool set_poll_grow;
bool set_poll_shrink;
};
-int qemuMonitorGetIOThreads(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr **iothreads,
+int qemuMonitorGetIOThreads(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo ***iothreads,
int *niothreads);
-int qemuMonitorSetIOThread(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr iothreadInfo);
+int qemuMonitorSetIOThread(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo *iothreadInfo);
typedef struct _qemuMonitorMemoryDeviceInfo qemuMonitorMemoryDeviceInfo;
-typedef qemuMonitorMemoryDeviceInfo *qemuMonitorMemoryDeviceInfoPtr;
-
struct _qemuMonitorMemoryDeviceInfo {
unsigned long long address;
unsigned int slot;
bool hotpluggable;
};
-int qemuMonitorGetMemoryDeviceInfo(qemuMonitorPtr mon,
+int qemuMonitorGetMemoryDeviceInfo(qemuMonitor *mon,
GHashTable **info)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorMigrateIncoming(qemuMonitorPtr mon,
+int qemuMonitorMigrateIncoming(qemuMonitor *mon,
const char *uri);
-int qemuMonitorMigrateStartPostCopy(qemuMonitorPtr mon);
+int qemuMonitorMigrateStartPostCopy(qemuMonitor *mon);
-int qemuMonitorMigrateContinue(qemuMonitorPtr mon,
+int qemuMonitorMigrateContinue(qemuMonitor *mon,
qemuMonitorMigrationStatus status);
-int qemuMonitorGetRTCTime(qemuMonitorPtr mon,
+int qemuMonitorGetRTCTime(qemuMonitor *mon,
struct tm *tm);
-virJSONValuePtr qemuMonitorQueryQMPSchema(qemuMonitorPtr mon);
+virJSONValue *qemuMonitorQueryQMPSchema(qemuMonitor *mon);
-int qemuMonitorSetBlockThreshold(qemuMonitorPtr mon,
+int qemuMonitorSetBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold);
-virJSONValuePtr qemuMonitorQueryNamedBlockNodes(qemuMonitorPtr mon);
+virJSONValue *qemuMonitorQueryNamedBlockNodes(qemuMonitor *mon);
-int qemuMonitorSetWatchdogAction(qemuMonitorPtr mon,
+int qemuMonitorSetWatchdogAction(qemuMonitor *mon,
const char *action);
-int qemuMonitorBlockdevCreate(qemuMonitorPtr mon,
+int qemuMonitorBlockdevCreate(qemuMonitor *mon,
const char *jobname,
- virJSONValuePtr props);
+ virJSONValue *props);
-int qemuMonitorBlockdevAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorBlockdevAdd(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorBlockdevReopen(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorBlockdevReopen(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorBlockdevDel(qemuMonitorPtr mon,
+int qemuMonitorBlockdevDel(qemuMonitor *mon,
const char *nodename);
-int qemuMonitorBlockdevTrayOpen(qemuMonitorPtr mon,
+int qemuMonitorBlockdevTrayOpen(qemuMonitor *mon,
const char *id,
bool force);
-int qemuMonitorBlockdevTrayClose(qemuMonitorPtr mon,
+int qemuMonitorBlockdevTrayClose(qemuMonitor *mon,
const char *id);
-int qemuMonitorBlockdevMediumRemove(qemuMonitorPtr mon,
+int qemuMonitorBlockdevMediumRemove(qemuMonitor *mon,
const char *id);
-int qemuMonitorBlockdevMediumInsert(qemuMonitorPtr mon,
+int qemuMonitorBlockdevMediumInsert(qemuMonitor *mon,
const char *id,
const char *nodename);
char *
-qemuMonitorGetSEVMeasurement(qemuMonitorPtr mon);
+qemuMonitorGetSEVMeasurement(qemuMonitor *mon);
typedef struct _qemuMonitorPRManagerInfo qemuMonitorPRManagerInfo;
-typedef qemuMonitorPRManagerInfo *qemuMonitorPRManagerInfoPtr;
struct _qemuMonitorPRManagerInfo {
bool connected;
};
-int qemuMonitorGetPRManagerInfo(qemuMonitorPtr mon,
+int qemuMonitorGetPRManagerInfo(qemuMonitor *mon,
GHashTable **retinfo);
typedef struct _qemuMonitorCurrentMachineInfo qemuMonitorCurrentMachineInfo;
-typedef qemuMonitorCurrentMachineInfo *qemuMonitorCurrentMachineInfoPtr;
struct _qemuMonitorCurrentMachineInfo {
bool wakeupSuspendSupport;
};
-int qemuMonitorGetCurrentMachineInfo(qemuMonitorPtr mon,
- qemuMonitorCurrentMachineInfoPtr info);
-void qemuMonitorJobInfoFree(qemuMonitorJobInfoPtr job);
+int qemuMonitorGetCurrentMachineInfo(qemuMonitor *mon,
+ qemuMonitorCurrentMachineInfo *info);
+void qemuMonitorJobInfoFree(qemuMonitorJobInfo *job);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorJobInfo, qemuMonitorJobInfoFree);
-int qemuMonitorGetJobInfo(qemuMonitorPtr mon,
- qemuMonitorJobInfoPtr **jobs,
+int qemuMonitorGetJobInfo(qemuMonitor *mon,
+ qemuMonitorJobInfo ***jobs,
size_t *njobs);
int
-qemuMonitorGetCPUMigratable(qemuMonitorPtr mon,
+qemuMonitorGetCPUMigratable(qemuMonitor *mon,
bool *migratable);
int
-qemuMonitorTransactionBitmapAdd(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapAdd(virJSONValue *actions,
const char *node,
const char *name,
bool persistent,
bool disabled,
unsigned long long granularity);
int
-qemuMonitorTransactionBitmapRemove(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapRemove(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorBitmapRemove(qemuMonitorPtr mon,
+qemuMonitorBitmapRemove(qemuMonitor *mon,
const char *node,
const char *name);
int
-qemuMonitorTransactionBitmapEnable(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapEnable(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorTransactionBitmapDisable(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapDisable(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorTransactionBitmapMerge(virJSONValuePtr actions,
+qemuMonitorTransactionBitmapMerge(virJSONValue *actions,
const char *node,
const char *target,
- virJSONValuePtr *sources);
+ virJSONValue **sources);
int
-qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValuePtr sources,
+qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
const char *sourcenode,
const char *sourcebitmap);
int
-qemuMonitorTransactionSnapshotLegacy(virJSONValuePtr actions,
+qemuMonitorTransactionSnapshotLegacy(virJSONValue *actions,
const char *device,
const char *path,
const char *format,
bool existing);
int
-qemuMonitorTransactionSnapshotBlockdev(virJSONValuePtr actions,
+qemuMonitorTransactionSnapshotBlockdev(virJSONValue *actions,
const char *node,
const char *overlay);
} qemuMonitorTransactionBackupSyncMode;
int
-qemuMonitorTransactionBackup(virJSONValuePtr actions,
+qemuMonitorTransactionBackup(virJSONValue *actions,
const char *device,
const char *jobname,
const char *target,
qemuMonitorTransactionBackupSyncMode syncmode);
int
-qemuMonitorStartDirtyRateCalc(qemuMonitorPtr mon,
+qemuMonitorStartDirtyRateCalc(qemuMonitor *mon,
int seconds);
typedef struct _qemuMonitorDirtyRateInfo qemuMonitorDirtyRateInfo;
-typedef qemuMonitorDirtyRateInfo *qemuMonitorDirtyRateInfoPtr;
-
struct _qemuMonitorDirtyRateInfo {
int status; /* the status of last dirtyrate calculation,
one of virDomainDirtyRateStatus */
};
int
-qemuMonitorQueryDirtyRate(qemuMonitorPtr mon,
- qemuMonitorDirtyRateInfoPtr info);
+qemuMonitorQueryDirtyRate(qemuMonitor *mon,
+ qemuMonitorDirtyRateInfo *info);
"undefined",
"null");
-static void qemuMonitorJSONHandleShutdown(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleReset(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandlePowerdown(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleStop(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleResume(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleRTCChange(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleVNCConnect(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleVNCInitialize(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleSPICEConnect(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleSPICEInitialize(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleSPICEDisconnect(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleTrayChange(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandlePMSuspend(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleBlockJobCompleted(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleBlockJobCanceled(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleBlockJobReady(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleJobStatusChange(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleBalloonChange(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandlePMSuspendDisk(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleGuestCrashloaded(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleGuestPanic(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleDeviceDeleted(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleNicRxFilterChanged(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleSerialChange(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleSpiceMigrated(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleMigrationStatus(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleMigrationPass(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleAcpiOstInfo(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleBlockThreshold(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleDumpCompleted(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandlePRManagerStatusChanged(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleRdmaGidStatusChanged(qemuMonitorPtr mon, virJSONValuePtr data);
-static void qemuMonitorJSONHandleMemoryFailure(qemuMonitorPtr mon, virJSONValuePtr data);
+static void qemuMonitorJSONHandleShutdown(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleReset(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandlePowerdown(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleStop(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleResume(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleRTCChange(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleWatchdog(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleIOError(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleVNCConnect(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleVNCInitialize(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleSPICEConnect(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleSPICEInitialize(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleSPICEDisconnect(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleTrayChange(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandlePMWakeup(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandlePMSuspend(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleBlockJobCompleted(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleBlockJobCanceled(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleBlockJobReady(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleJobStatusChange(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleBalloonChange(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandlePMSuspendDisk(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleGuestCrashloaded(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleGuestPanic(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleDeviceDeleted(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleNicRxFilterChanged(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleSerialChange(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleSpiceMigrated(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleMigrationStatus(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleMigrationPass(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleAcpiOstInfo(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleBlockThreshold(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleDumpCompleted(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandlePRManagerStatusChanged(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleRdmaGidStatusChanged(qemuMonitor *mon, virJSONValue *data);
+static void qemuMonitorJSONHandleMemoryFailure(qemuMonitor *mon, virJSONValue *data);
typedef struct {
const char *type;
- void (*handler)(qemuMonitorPtr mon, virJSONValuePtr data);
+ void (*handler)(qemuMonitor *mon, virJSONValue *data);
} qemuEventHandler;
static qemuEventHandler eventHandlers[] = {
}
static int
-qemuMonitorJSONIOProcessEvent(qemuMonitorPtr mon,
- virJSONValuePtr obj)
+qemuMonitorJSONIOProcessEvent(qemuMonitor *mon,
+ virJSONValue *obj)
{
const char *type;
qemuEventHandler *handler;
- virJSONValuePtr data;
+ virJSONValue *data;
char *details = NULL;
- virJSONValuePtr timestamp;
+ virJSONValue *timestamp;
long long seconds = -1;
unsigned int micros = 0;
}
int
-qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon,
+qemuMonitorJSONIOProcessLine(qemuMonitor *mon,
const char *line,
- qemuMonitorMessagePtr msg)
+ qemuMonitorMessage *msg)
{
- virJSONValuePtr obj = NULL;
+ virJSONValue *obj = NULL;
int ret = -1;
VIR_DEBUG("Line [%s]", line);
return ret;
}
-int qemuMonitorJSONIOProcess(qemuMonitorPtr mon,
+int qemuMonitorJSONIOProcess(qemuMonitor *mon,
const char *data,
size_t len,
- qemuMonitorMessagePtr msg)
+ qemuMonitorMessage *msg)
{
int used = 0;
/*VIR_DEBUG("Data %d bytes [%s]", len, data);*/
}
static int
-qemuMonitorJSONCommandWithFd(qemuMonitorPtr mon,
- virJSONValuePtr cmd,
+qemuMonitorJSONCommandWithFd(qemuMonitor *mon,
+ virJSONValue *cmd,
int scm_fd,
- virJSONValuePtr *reply)
+ virJSONValue **reply)
{
int ret = -1;
qemuMonitorMessage msg;
static int
-qemuMonitorJSONCommand(qemuMonitorPtr mon,
- virJSONValuePtr cmd,
- virJSONValuePtr *reply)
+qemuMonitorJSONCommand(qemuMonitor *mon,
+ virJSONValue *cmd,
+ virJSONValue **reply)
{
return qemuMonitorJSONCommandWithFd(mon, cmd, -1, reply);
}
* XXX see qerror.h for different klasses & fill out useful params
*/
static const char *
-qemuMonitorJSONStringifyError(virJSONValuePtr error)
+qemuMonitorJSONStringifyError(virJSONValue *error)
{
const char *klass = virJSONValueObjectGetString(error, "class");
const char *detail = NULL;
}
static const char *
-qemuMonitorJSONCommandName(virJSONValuePtr cmd)
+qemuMonitorJSONCommandName(virJSONValue *cmd)
{
const char *name = virJSONValueObjectGetString(cmd, "execute");
if (name)
}
static int
-qemuMonitorJSONCheckErrorFull(virJSONValuePtr cmd,
- virJSONValuePtr reply,
+qemuMonitorJSONCheckErrorFull(virJSONValue *cmd,
+ virJSONValue *reply,
bool report)
{
if (virJSONValueObjectHasKey(reply, "error")) {
- virJSONValuePtr error = virJSONValueObjectGet(reply, "error");
+ virJSONValue *error = virJSONValueObjectGet(reply, "error");
g_autofree char *cmdstr = virJSONValueToString(cmd, false);
g_autofree char *replystr = virJSONValueToString(reply, false);
static int
-qemuMonitorJSONCheckError(virJSONValuePtr cmd,
- virJSONValuePtr reply)
+qemuMonitorJSONCheckError(virJSONValue *cmd,
+ virJSONValue *reply)
{
return qemuMonitorJSONCheckErrorFull(cmd, reply, true);
}
static int
-qemuMonitorJSONCheckReply(virJSONValuePtr cmd,
- virJSONValuePtr reply,
+qemuMonitorJSONCheckReply(virJSONValue *cmd,
+ virJSONValue *reply,
virJSONType type)
{
- virJSONValuePtr data;
+ virJSONValue *data;
if (qemuMonitorJSONCheckError(cmd, reply) < 0)
return -1;
static bool
-qemuMonitorJSONErrorIsClass(virJSONValuePtr error,
+qemuMonitorJSONErrorIsClass(virJSONValue *error,
const char *klass)
{
return STREQ_NULLABLE(virJSONValueObjectGetString(error, "class"), klass);
static bool
-qemuMonitorJSONHasError(virJSONValuePtr reply,
+qemuMonitorJSONHasError(virJSONValue *reply,
const char *klass)
{
- virJSONValuePtr error;
+ virJSONValue *error;
if (!(error = virJSONValueObjectGet(reply, "error")))
return false;
* Returns 0 on success and -1 on error.
*/
static int
-qemuMonitorJSONTransactionAdd(virJSONValuePtr actions,
+qemuMonitorJSONTransactionAdd(virJSONValue *actions,
const char *cmdname,
...)
{
*
* Note that @arguments is consumed and cleared.
*/
-static virJSONValuePtr
+static virJSONValue *
qemuMonitorJSONMakeCommandInternal(const char *cmdname,
- virJSONValuePtr *arguments)
+ virJSONValue **arguments)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
ignore_value(virJSONValueObjectCreate(&ret,
"s:execute", cmdname,
}
-static virJSONValuePtr G_GNUC_NULL_TERMINATED
+static virJSONValue *G_GNUC_NULL_TERMINATED
qemuMonitorJSONMakeCommand(const char *cmdname,
...)
{
- virJSONValuePtr obj = NULL;
+ virJSONValue *obj = NULL;
g_autoptr(virJSONValue) jargs = NULL;
va_list args;
}
-static virJSONValuePtr
+static virJSONValue *
qemuMonitorJSONKeywordStringToJSON(const char *str, const char *firstkeyword)
{
- virJSONValuePtr ret = virJSONValueNewObject();
+ virJSONValue *ret = virJSONValueNewObject();
char **keywords = NULL;
char **values = NULL;
int nkeywords = 0;
}
-static void qemuMonitorJSONHandleShutdown(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleShutdown(qemuMonitor *mon, virJSONValue *data)
{
bool guest = false;
virTristateBool guest_initiated = VIR_TRISTATE_BOOL_ABSENT;
qemuMonitorEmitShutdown(mon, guest_initiated);
}
-static void qemuMonitorJSONHandleReset(qemuMonitorPtr mon, virJSONValuePtr data G_GNUC_UNUSED)
+static void qemuMonitorJSONHandleReset(qemuMonitor *mon, virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitReset(mon);
}
-static void qemuMonitorJSONHandlePowerdown(qemuMonitorPtr mon, virJSONValuePtr data G_GNUC_UNUSED)
+static void qemuMonitorJSONHandlePowerdown(qemuMonitor *mon, virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitPowerdown(mon);
}
-static void qemuMonitorJSONHandleStop(qemuMonitorPtr mon, virJSONValuePtr data G_GNUC_UNUSED)
+static void qemuMonitorJSONHandleStop(qemuMonitor *mon, virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitStop(mon);
}
-static void qemuMonitorJSONHandleResume(qemuMonitorPtr mon, virJSONValuePtr data G_GNUC_UNUSED)
+static void qemuMonitorJSONHandleResume(qemuMonitor *mon, virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitResume(mon);
}
-static qemuMonitorEventPanicInfoPtr
-qemuMonitorJSONGuestPanicExtractInfoHyperv(virJSONValuePtr data)
+static qemuMonitorEventPanicInfo *
+qemuMonitorJSONGuestPanicExtractInfoHyperv(virJSONValue *data)
{
- qemuMonitorEventPanicInfoPtr ret;
+ qemuMonitorEventPanicInfo *ret;
ret = g_new0(qemuMonitorEventPanicInfo, 1);
return NULL;
}
-static qemuMonitorEventPanicInfoPtr
-qemuMonitorJSONGuestPanicExtractInfoS390(virJSONValuePtr data)
+static qemuMonitorEventPanicInfo *
+qemuMonitorJSONGuestPanicExtractInfoS390(virJSONValue *data)
{
- qemuMonitorEventPanicInfoPtr ret;
+ qemuMonitorEventPanicInfo *ret;
int core;
unsigned long long psw_mask, psw_addr;
const char *reason = NULL;
return NULL;
}
-static qemuMonitorEventPanicInfoPtr
-qemuMonitorJSONGuestPanicExtractInfo(virJSONValuePtr data)
+static qemuMonitorEventPanicInfo *
+qemuMonitorJSONGuestPanicExtractInfo(virJSONValue *data)
{
const char *type = virJSONValueObjectGetString(data, "type");
static void
-qemuMonitorJSONHandleGuestPanic(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleGuestPanic(qemuMonitor *mon,
+ virJSONValue *data)
{
- virJSONValuePtr infojson = virJSONValueObjectGetObject(data, "info");
- qemuMonitorEventPanicInfoPtr info = NULL;
+ virJSONValue *infojson = virJSONValueObjectGetObject(data, "info");
+ qemuMonitorEventPanicInfo *info = NULL;
if (infojson)
info = qemuMonitorJSONGuestPanicExtractInfo(infojson);
}
-static void qemuMonitorJSONHandleRTCChange(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleRTCChange(qemuMonitor *mon, virJSONValue *data)
{
long long offset = 0;
if (virJSONValueObjectGetNumberLong(data, "offset", &offset) < 0) {
"none", "pause", "reset", "poweroff", "shutdown", "debug", "inject-nmi",
);
-static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleWatchdog(qemuMonitor *mon, virJSONValue *data)
{
const char *action;
int actionID;
static void
-qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data)
+qemuMonitorJSONHandleIOError(qemuMonitor *mon, virJSONValue *data)
{
const char *device;
const char *nodename;
);
static void
-qemuMonitorJSONHandleGraphicsVNC(qemuMonitorPtr mon,
- virJSONValuePtr data,
+qemuMonitorJSONHandleGraphicsVNC(qemuMonitor *mon,
+ virJSONValue *data,
int phase)
{
const char *localNode, *localService, *localFamily;
const char *remoteNode, *remoteService, *remoteFamily;
const char *authScheme, *saslUsername, *x509dname;
int localFamilyID, remoteFamilyID;
- virJSONValuePtr client;
- virJSONValuePtr server;
+ virJSONValue *client;
+ virJSONValue *server;
if (!(client = virJSONValueObjectGetObject(data, "client"))) {
VIR_WARN("missing client info in VNC event");
authScheme, x509dname, saslUsername);
}
-static void qemuMonitorJSONHandleVNCConnect(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleVNCConnect(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsVNC(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_CONNECT);
}
-static void qemuMonitorJSONHandleVNCInitialize(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleVNCInitialize(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsVNC(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE);
}
-static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsVNC(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT);
}
static void
-qemuMonitorJSONHandleGraphicsSPICE(qemuMonitorPtr mon,
- virJSONValuePtr data,
+qemuMonitorJSONHandleGraphicsSPICE(qemuMonitor *mon,
+ virJSONValue *data,
int phase)
{
const char *lhost, *lport, *lfamily;
const char *rhost, *rport, *rfamily;
const char *auth = "";
int lfamilyID, rfamilyID;
- virJSONValuePtr client;
- virJSONValuePtr server;
+ virJSONValue *client;
+ virJSONValue *server;
if (!(client = virJSONValueObjectGetObject(data, "client")) ||
!(server = virJSONValueObjectGetObject(data, "server"))) {
}
-static void qemuMonitorJSONHandleSPICEConnect(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleSPICEConnect(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsSPICE(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_CONNECT);
}
-static void qemuMonitorJSONHandleSPICEInitialize(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleSPICEInitialize(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsSPICE(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE);
}
-static void qemuMonitorJSONHandleSPICEDisconnect(qemuMonitorPtr mon, virJSONValuePtr data)
+static void qemuMonitorJSONHandleSPICEDisconnect(qemuMonitor *mon, virJSONValue *data)
{
qemuMonitorJSONHandleGraphicsSPICE(mon, data, VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT);
}
static void
-qemuMonitorJSONHandleBlockJobImpl(qemuMonitorPtr mon,
- virJSONValuePtr data,
+qemuMonitorJSONHandleBlockJobImpl(qemuMonitor *mon,
+ virJSONValue *data,
int event)
{
const char *device;
static void
-qemuMonitorJSONHandleJobStatusChange(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleJobStatusChange(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *jobname = virJSONValueObjectGetString(data, "id");
const char *statusstr = virJSONValueObjectGetString(data, "status");
static void
-qemuMonitorJSONHandleTrayChange(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleTrayChange(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *devAlias = virJSONValueObjectGetString(data, "device");
const char *devid = virJSONValueObjectGetString(data, "id");
}
static void
-qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon,
- virJSONValuePtr data G_GNUC_UNUSED)
+qemuMonitorJSONHandlePMWakeup(qemuMonitor *mon,
+ virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitPMWakeup(mon);
}
static void
-qemuMonitorJSONHandlePMSuspend(qemuMonitorPtr mon,
- virJSONValuePtr data G_GNUC_UNUSED)
+qemuMonitorJSONHandlePMSuspend(qemuMonitor *mon,
+ virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitPMSuspend(mon);
}
static void
-qemuMonitorJSONHandleBlockJobCompleted(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleBlockJobCompleted(qemuMonitor *mon,
+ virJSONValue *data)
{
qemuMonitorJSONHandleBlockJobImpl(mon, data,
VIR_DOMAIN_BLOCK_JOB_COMPLETED);
}
static void
-qemuMonitorJSONHandleBlockJobCanceled(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleBlockJobCanceled(qemuMonitor *mon,
+ virJSONValue *data)
{
qemuMonitorJSONHandleBlockJobImpl(mon, data,
VIR_DOMAIN_BLOCK_JOB_CANCELED);
}
static void
-qemuMonitorJSONHandleBlockJobReady(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleBlockJobReady(qemuMonitor *mon,
+ virJSONValue *data)
{
qemuMonitorJSONHandleBlockJobImpl(mon, data,
VIR_DOMAIN_BLOCK_JOB_READY);
}
static void
-qemuMonitorJSONHandleBalloonChange(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleBalloonChange(qemuMonitor *mon,
+ virJSONValue *data)
{
unsigned long long actual = 0;
if (virJSONValueObjectGetNumberUlong(data, "actual", &actual) < 0) {
}
static void
-qemuMonitorJSONHandlePMSuspendDisk(qemuMonitorPtr mon,
- virJSONValuePtr data G_GNUC_UNUSED)
+qemuMonitorJSONHandlePMSuspendDisk(qemuMonitor *mon,
+ virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitPMSuspendDisk(mon);
}
static void
-qemuMonitorJSONHandleDeviceDeleted(qemuMonitorPtr mon, virJSONValuePtr data)
+qemuMonitorJSONHandleDeviceDeleted(qemuMonitor *mon, virJSONValue *data)
{
const char *device;
static void
-qemuMonitorJSONHandleNicRxFilterChanged(qemuMonitorPtr mon, virJSONValuePtr data)
+qemuMonitorJSONHandleNicRxFilterChanged(qemuMonitor *mon, virJSONValue *data)
{
const char *name;
static void
-qemuMonitorJSONHandleSerialChange(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleSerialChange(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *name;
bool connected;
static void
-qemuMonitorJSONHandleSpiceMigrated(qemuMonitorPtr mon,
- virJSONValuePtr data G_GNUC_UNUSED)
+qemuMonitorJSONHandleSpiceMigrated(qemuMonitor *mon,
+ virJSONValue *data G_GNUC_UNUSED)
{
qemuMonitorEmitSpiceMigrated(mon);
}
static void
-qemuMonitorJSONHandleMemoryFailure(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleMemoryFailure(qemuMonitor *mon,
+ virJSONValue *data)
{
- virJSONValuePtr flagsjson = virJSONValueObjectGetObject(data, "flags");
+ virJSONValue *flagsjson = virJSONValueObjectGetObject(data, "flags");
const char *str;
int recipient;
int action;
static void
-qemuMonitorJSONHandleMigrationStatus(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleMigrationStatus(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *str;
int status;
static void
-qemuMonitorJSONHandleMigrationPass(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleMigrationPass(qemuMonitor *mon,
+ virJSONValue *data)
{
int pass;
static void
-qemuMonitorJSONHandleAcpiOstInfo(qemuMonitorPtr mon, virJSONValuePtr data)
+qemuMonitorJSONHandleAcpiOstInfo(qemuMonitor *mon, virJSONValue *data)
{
- virJSONValuePtr info;
+ virJSONValue *info;
const char *alias;
const char *slotType;
const char *slot;
static void
-qemuMonitorJSONHandleBlockThreshold(qemuMonitorPtr mon, virJSONValuePtr data)
+qemuMonitorJSONHandleBlockThreshold(qemuMonitor *mon, virJSONValue *data)
{
const char *nodename;
unsigned long long threshold;
static int
-qemuMonitorJSONExtractDumpStats(virJSONValuePtr result,
- qemuMonitorDumpStatsPtr ret)
+qemuMonitorJSONExtractDumpStats(virJSONValue *result,
+ qemuMonitorDumpStats *ret)
{
const char *statusstr;
static void
-qemuMonitorJSONHandleDumpCompleted(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleDumpCompleted(qemuMonitor *mon,
+ virJSONValue *data)
{
- virJSONValuePtr result;
+ virJSONValue *result;
int status;
qemuMonitorDumpStats stats = { 0 };
const char *error = NULL;
}
-static void qemuMonitorJSONHandlePRManagerStatusChanged(qemuMonitorPtr mon,
- virJSONValuePtr data)
+static void qemuMonitorJSONHandlePRManagerStatusChanged(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *name;
bool connected;
}
-static void qemuMonitorJSONHandleRdmaGidStatusChanged(qemuMonitorPtr mon,
- virJSONValuePtr data)
+static void qemuMonitorJSONHandleRdmaGidStatusChanged(qemuMonitor *mon,
+ virJSONValue *data)
{
const char *netdev;
bool gid_status;
static void
-qemuMonitorJSONHandleGuestCrashloaded(qemuMonitorPtr mon,
- virJSONValuePtr data)
+qemuMonitorJSONHandleGuestCrashloaded(qemuMonitor *mon,
+ virJSONValue *data)
{
VIR_DEBUG("qemuMonitorJSONHandleGuestCrashloaded event, mon %p, data %p", mon, data);
int
-qemuMonitorJSONHumanCommand(qemuMonitorPtr mon,
+qemuMonitorJSONHumanCommand(qemuMonitor *mon,
const char *cmd_str,
char **reply_str)
{
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr obj;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *obj;
int ret = -1;
cmd = qemuMonitorJSONMakeCommand("human-monitor-command",
int
-qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon)
+qemuMonitorJSONSetCapabilities(qemuMonitor *mon)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONStartCPUs(qemuMonitorPtr mon)
+qemuMonitorJSONStartCPUs(qemuMonitor *mon)
{
int ret;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("cont", NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("cont", NULL);
+ virJSONValue *reply = NULL;
size_t i = 0;
int timeout = 3;
if (!cmd)
int
-qemuMonitorJSONStopCPUs(qemuMonitorPtr mon)
+qemuMonitorJSONStopCPUs(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("stop", NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("stop", NULL);
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
int
-qemuMonitorJSONGetStatus(qemuMonitorPtr mon,
+qemuMonitorJSONGetStatus(qemuMonitor *mon,
bool *running,
virDomainPausedReason *reason)
{
int ret = -1;
const char *status;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
if (reason)
*reason = VIR_DOMAIN_PAUSED_UNKNOWN;
}
-int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon)
+int qemuMonitorJSONSystemPowerdown(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("system_powerdown", NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("system_powerdown", NULL);
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
return ret;
}
-int qemuMonitorJSONSetLink(qemuMonitorPtr mon,
+int qemuMonitorJSONSetLink(qemuMonitor *mon,
const char *name,
virDomainNetInterfaceLinkState state)
{
int ret = -1;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("set_link",
+ virJSONValue *reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("set_link",
"s:name", name,
"b:up", state != VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN,
NULL);
return ret;
}
-int qemuMonitorJSONSystemReset(qemuMonitorPtr mon)
+int qemuMonitorJSONSystemReset(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("system_reset", NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("system_reset", NULL);
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
*
*/
static void
-qemuMonitorJSONExtractCPUS390Info(virJSONValuePtr jsoncpu,
+qemuMonitorJSONExtractCPUS390Info(virJSONValue *jsoncpu,
struct qemuMonitorQueryCpusEntry *cpu)
{
const char *cpu_state = virJSONValueObjectGetString(jsoncpu, "cpu-state");
* "query-cpus-fast" command is replaced by "target".
*/
static int
-qemuMonitorJSONExtractCPUInfo(virJSONValuePtr data,
+qemuMonitorJSONExtractCPUInfo(virJSONValue *data,
struct qemuMonitorQueryCpusEntry **entries,
size_t *nentries,
bool fast)
cpus = g_new0(struct qemuMonitorQueryCpusEntry, ncpus);
for (i = 0; i < ncpus; i++) {
- virJSONValuePtr entry = virJSONValueArrayGet(data, i);
+ virJSONValue *entry = virJSONValueArrayGet(data, i);
int cpuid = -1;
int thread = 0;
bool halted = false;
* query failed gracefully.
*/
int
-qemuMonitorJSONQueryCPUs(qemuMonitorPtr mon,
+qemuMonitorJSONQueryCPUs(qemuMonitor *mon,
struct qemuMonitorQueryCpusEntry **entries,
size_t *nentries,
bool force,
bool fast)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
if (fast)
cmd = qemuMonitorJSONMakeCommand("query-cpus-fast", NULL);
* Return 0 on success, -1 on failure and set proper error message.
*/
int
-qemuMonitorJSONUpdateVideoMemorySize(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+qemuMonitorJSONUpdateVideoMemorySize(qemuMonitor *mon,
+ virDomainVideoDef *video,
char *path)
{
qemuMonitorJSONObjectProperty prop = {
* Return 0 on success, -1 on failure and set proper error message.
*/
int
-qemuMonitorJSONUpdateVideoVram64Size(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+qemuMonitorJSONUpdateVideoVram64Size(qemuMonitor *mon,
+ virDomainVideoDef *video,
char *path)
{
qemuMonitorJSONObjectProperty prop = {
int
-qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetBalloonInfo(qemuMonitor *mon,
unsigned long long *currmem)
{
int ret = -1;
- virJSONValuePtr data;
+ virJSONValue *data;
unsigned long long mem;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-balloon",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("query-balloon",
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
*currmem = 0;
}
-int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
+int qemuMonitorJSONGetMemoryStats(qemuMonitor *mon,
char *balloonpath,
virDomainMemoryStatPtr stats,
unsigned int nr_stats)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
- virJSONValuePtr statsdata;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
+ virJSONValue *statsdata;
unsigned long long mem;
int got = 0;
* collection interval property to enable statistics gathering.
*/
int
-qemuMonitorJSONSetMemoryStatsPeriod(qemuMonitorPtr mon,
+qemuMonitorJSONSetMemoryStatsPeriod(qemuMonitor *mon,
char *balloonpath,
int period)
{
int
-qemuMonitorJSONSetDBusVMStateIdList(qemuMonitorPtr mon,
+qemuMonitorJSONSetDBusVMStateIdList(qemuMonitor *mon,
const char *vmstatepath,
const char *idstr)
{
*
* Returns: NULL on error, reply on success
*/
-static virJSONValuePtr
-qemuMonitorJSONQueryBlock(qemuMonitorPtr mon)
+static virJSONValue *
+qemuMonitorJSONQueryBlock(qemuMonitor *mon)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr devices = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *devices = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-block", NULL)))
return NULL;
}
-static virJSONValuePtr
-qemuMonitorJSONGetBlockDev(virJSONValuePtr devices,
+static virJSONValue *
+qemuMonitorJSONGetBlockDev(virJSONValue *devices,
size_t idx)
{
- virJSONValuePtr dev = virJSONValueArrayGet(devices, idx);
+ virJSONValue *dev = virJSONValueArrayGet(devices, idx);
if (!dev || virJSONValueGetType(dev) != VIR_JSON_TYPE_OBJECT) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static const char *
-qemuMonitorJSONGetBlockDevDevice(virJSONValuePtr dev)
+qemuMonitorJSONGetBlockDevDevice(virJSONValue *dev)
{
const char *thisdev;
}
-int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetBlockInfo(qemuMonitor *mon,
GHashTable *table)
{
int ret = -1;
size_t i;
- virJSONValuePtr devices;
+ virJSONValue *devices;
if (!(devices = qemuMonitorJSONQueryBlock(mon)))
return -1;
for (i = 0; i < virJSONValueArraySize(devices); i++) {
- virJSONValuePtr dev;
- virJSONValuePtr image;
+ virJSONValue *dev;
+ virJSONValue *image;
struct qemuDomainDiskInfo info = { false };
const char *thisdev;
const char *status;
}
-static qemuBlockStatsPtr
-qemuMonitorJSONBlockStatsCollectData(virJSONValuePtr dev,
+static qemuBlockStats *
+qemuMonitorJSONBlockStatsCollectData(virJSONValue *dev,
int *nstats)
{
- g_autofree qemuBlockStatsPtr bstats = NULL;
- virJSONValuePtr parent;
- virJSONValuePtr parentstats;
- virJSONValuePtr stats;
+ g_autofree qemuBlockStats *bstats = NULL;
+ virJSONValue *parent;
+ virJSONValue *parentstats;
+ virJSONValue *stats;
if ((stats = virJSONValueObjectGetObject(dev, "stats")) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
-qemuMonitorJSONAddOneBlockStatsInfo(qemuBlockStatsPtr bstats,
+qemuMonitorJSONAddOneBlockStatsInfo(qemuBlockStats *bstats,
const char *name,
GHashTable *stats)
{
- qemuBlockStatsPtr copy = NULL;
+ qemuBlockStats *copy = NULL;
copy = g_new0(qemuBlockStats, 1);
static int
-qemuMonitorJSONGetOneBlockStatsInfo(virJSONValuePtr dev,
+qemuMonitorJSONGetOneBlockStatsInfo(virJSONValue *dev,
const char *dev_name,
int depth,
GHashTable *hash,
bool backingChain)
{
- g_autofree qemuBlockStatsPtr bstats = NULL;
+ g_autofree qemuBlockStats *bstats = NULL;
int nstats = 0;
const char *qdevname = NULL;
const char *nodename = NULL;
g_autofree char *devicename = NULL;
- virJSONValuePtr backing;
+ virJSONValue *backing;
if (dev_name &&
!(devicename = qemuDomainStorageAlias(dev_name, depth)))
}
-virJSONValuePtr
-qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon)
+virJSONValue *
+qemuMonitorJSONQueryBlockstats(qemuMonitor *mon)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *ret = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-blockstats", NULL)))
return NULL;
int
-qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitor *mon,
GHashTable *hash,
bool backingChain)
{
return -1;
for (i = 0; i < virJSONValueArraySize(devices); i++) {
- virJSONValuePtr dev = virJSONValueArrayGet(devices, i);
+ virJSONValue *dev = virJSONValueArrayGet(devices, i);
const char *dev_name;
if (!dev || virJSONValueGetType(dev) != VIR_JSON_TYPE_OBJECT) {
static int
-qemuMonitorJSONBlockStatsUpdateCapacityData(virJSONValuePtr image,
+qemuMonitorJSONBlockStatsUpdateCapacityData(virJSONValue *image,
const char *name,
GHashTable *stats,
- qemuBlockStatsPtr *entry)
+ qemuBlockStats **entry)
{
- qemuBlockStatsPtr bstats;
+ qemuBlockStats *bstats;
if (!(bstats = virHashLookup(stats, name))) {
bstats = g_new0(qemuBlockStats, 1);
static int
-qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValuePtr image,
+qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValue *image,
const char *dev_name,
int depth,
GHashTable *stats,
{
int ret = -1;
char *entry_name = qemuDomainStorageAlias(dev_name, depth);
- virJSONValuePtr backing;
+ virJSONValue *backing;
if (qemuMonitorJSONBlockStatsUpdateCapacityData(image, entry_name,
stats, NULL) < 0)
int
-qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon,
+qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitor *mon,
GHashTable *stats,
bool backingChain)
{
int ret = -1;
size_t i;
- virJSONValuePtr devices;
+ virJSONValue *devices;
if (!(devices = qemuMonitorJSONQueryBlock(mon)))
return -1;
for (i = 0; i < virJSONValueArraySize(devices); i++) {
- virJSONValuePtr dev;
- virJSONValuePtr inserted;
- virJSONValuePtr image;
+ virJSONValue *dev;
+ virJSONValue *inserted;
+ virJSONValue *image;
const char *dev_name;
if (!(dev = qemuMonitorJSONGetBlockDev(devices, i)))
static int
qemuMonitorJSONBlockStatsUpdateCapacityBlockdevWorker(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr val,
+ virJSONValue *val,
void *opaque)
{
GHashTable *stats = opaque;
- virJSONValuePtr image;
+ virJSONValue *image;
const char *nodename;
- qemuBlockStatsPtr entry;
+ qemuBlockStats *entry;
if (!(nodename = virJSONValueObjectGetString(val, "node-name")) ||
!(image = virJSONValueObjectGetObject(val, "image"))) {
int
-qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
+qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
GHashTable *stats)
{
- virJSONValuePtr nodes;
+ virJSONValue *nodes;
int ret = -1;
if (!(nodes = qemuMonitorJSONQueryNamedBlockNodes(mon, false)))
static void
-qemuMonitorJSONBlockNamedNodeDataBitmapFree(qemuBlockNamedNodeDataBitmapPtr bitmap)
+qemuMonitorJSONBlockNamedNodeDataBitmapFree(qemuBlockNamedNodeDataBitmap *bitmap)
{
if (!bitmap)
return;
static void
-qemuMonitorJSONBlockNamedNodeDataFree(qemuBlockNamedNodeDataPtr data)
+qemuMonitorJSONBlockNamedNodeDataFree(qemuBlockNamedNodeData *data)
{
size_t i;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockNamedNodeData, qemuMonitorJSONBlockNamedNodeDataFree);
-static qemuBlockNamedNodeDataBitmapPtr
-qemuMonitorJSONBlockGetNamedNodeDataBitmapOne(virJSONValuePtr val)
+static qemuBlockNamedNodeDataBitmap *
+qemuMonitorJSONBlockGetNamedNodeDataBitmapOne(virJSONValue *val)
{
g_autoptr(qemuBlockNamedNodeDataBitmap) bitmap = NULL;
const char *name;
static void
-qemuMonitorJSONBlockGetNamedNodeDataBitmaps(virJSONValuePtr bitmaps,
- qemuBlockNamedNodeDataPtr data)
+qemuMonitorJSONBlockGetNamedNodeDataBitmaps(virJSONValue *bitmaps,
+ qemuBlockNamedNodeData *data)
{
size_t nbitmaps = virJSONValueArraySize(bitmaps);
size_t i;
- data->bitmaps = g_new0(qemuBlockNamedNodeDataBitmapPtr, nbitmaps);
+ data->bitmaps = g_new0(qemuBlockNamedNodeDataBitmap *, nbitmaps);
for (i = 0; i < nbitmaps; i++) {
- virJSONValuePtr bitmap = virJSONValueArrayGet(bitmaps, i);
- qemuBlockNamedNodeDataBitmapPtr tmp;
+ virJSONValue *bitmap = virJSONValueArrayGet(bitmaps, i);
+ qemuBlockNamedNodeDataBitmap *tmp;
if (!bitmap)
continue;
static int
qemuMonitorJSONBlockGetNamedNodeDataWorker(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr val,
+ virJSONValue *val,
void *opaque)
{
GHashTable *nodes = opaque;
- virJSONValuePtr img;
- virJSONValuePtr bitmaps;
- virJSONValuePtr format_specific;
+ virJSONValue *img;
+ virJSONValue *bitmaps;
+ virJSONValue *format_specific;
const char *nodename;
g_autoptr(qemuBlockNamedNodeData) ent = NULL;
/* query qcow2 format specific props */
if ((format_specific = virJSONValueObjectGetObject(img, "format-specific")) &&
STREQ_NULLABLE(virJSONValueObjectGetString(format_specific, "type"), "qcow2")) {
- virJSONValuePtr qcow2props = virJSONValueObjectGetObject(format_specific, "data");
+ virJSONValue *qcow2props = virJSONValueObjectGetObject(format_specific, "data");
if (qcow2props &&
STREQ_NULLABLE(virJSONValueObjectGetString(qcow2props, "compat"), "0.10"))
GHashTable *
-qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes)
+qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValue *nodes)
{
g_autoptr(GHashTable) ret = NULL;
GHashTable *
-qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon,
+qemuMonitorJSONBlockGetNamedNodeData(qemuMonitor *mon,
bool supports_flat)
{
g_autoptr(virJSONValue) nodes = NULL;
}
-int qemuMonitorJSONBlockResize(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockResize(qemuMonitor *mon,
const char *device,
const char *nodename,
unsigned long long size)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("block_resize",
"S:device", device,
}
-int qemuMonitorJSONSetPassword(qemuMonitorPtr mon,
+int qemuMonitorJSONSetPassword(qemuMonitor *mon,
const char *protocol,
const char *password,
const char *action_if_connected)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("set_password",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("set_password",
"s:protocol", protocol,
"s:password", password,
"s:connected", action_if_connected,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
return ret;
}
-int qemuMonitorJSONExpirePassword(qemuMonitorPtr mon,
+int qemuMonitorJSONExpirePassword(qemuMonitor *mon,
const char *protocol,
const char *expire_time)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("expire_password",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("expire_password",
"s:protocol", protocol,
"s:time", expire_time,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
int
-qemuMonitorJSONSetBalloon(qemuMonitorPtr mon,
+qemuMonitorJSONSetBalloon(qemuMonitor *mon,
unsigned long long newmem)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("balloon",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("balloon",
"U:value", newmem * 1024,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
}
-int qemuMonitorJSONSetCPU(qemuMonitorPtr mon,
+int qemuMonitorJSONSetCPU(qemuMonitor *mon,
int cpu, bool online)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
if (online) {
cmd = qemuMonitorJSONMakeCommand("cpu-add",
* -1 on error
* 0 on success
*/
-int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon,
+int qemuMonitorJSONEjectMedia(qemuMonitor *mon,
const char *dev_name,
bool force)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("eject",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("eject",
"s:device", dev_name,
"b:force", force ? 1 : 0,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
}
-int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon,
+int qemuMonitorJSONChangeMedia(qemuMonitor *mon,
const char *dev_name,
const char *newmedia,
const char *format)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("change",
"s:device", dev_name,
}
-static int qemuMonitorJSONSaveMemory(qemuMonitorPtr mon,
+static int qemuMonitorJSONSaveMemory(qemuMonitor *mon,
const char *cmdtype,
unsigned long long offset,
unsigned long long length,
const char *path)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand(cmdtype,
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand(cmdtype,
"U:val", offset,
"U:size", length,
"s:filename", path,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
}
-int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon,
+int qemuMonitorJSONSaveVirtualMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path)
return qemuMonitorJSONSaveMemory(mon, "memsave", offset, length, path);
}
-int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon,
+int qemuMonitorJSONSavePhysicalMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path)
}
-int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMigrationSpeed(qemuMonitor *mon,
unsigned long bandwidth)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("migrate_set_speed",
"U:value", bandwidth * 1024ULL * 1024ULL,
NULL);
}
-int qemuMonitorJSONSetMigrationDowntime(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMigrationDowntime(qemuMonitor *mon,
unsigned long long downtime)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("migrate_set_downtime",
"d:value", downtime / 1000.0,
int
-qemuMonitorJSONGetMigrationCacheSize(qemuMonitorPtr mon,
+qemuMonitorJSONGetMigrationCacheSize(qemuMonitor *mon,
unsigned long long *cacheSize)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
*cacheSize = 0;
int
-qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon,
+qemuMonitorJSONSetMigrationCacheSize(qemuMonitor *mon,
unsigned long long cacheSize)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("migrate-set-cache-size",
"U:value", cacheSize,
int
-qemuMonitorJSONGetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params)
+qemuMonitorJSONGetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
*params = NULL;
}
int
-qemuMonitorJSONSetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params)
+qemuMonitorJSONSetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
static int
-qemuMonitorJSONGetMigrationStatsReply(virJSONValuePtr reply,
- qemuMonitorMigrationStatsPtr stats,
+qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
+ qemuMonitorMigrationStats *stats,
char **error)
{
- virJSONValuePtr ret;
- virJSONValuePtr ram;
- virJSONValuePtr disk;
- virJSONValuePtr comp;
+ virJSONValue *ret;
+ virJSONValue *ram;
+ virJSONValue *disk;
+ virJSONValue *comp;
const char *statusstr;
int rc;
double mbps;
}
-int qemuMonitorJSONGetMigrationStats(qemuMonitorPtr mon,
- qemuMonitorMigrationStatsPtr stats,
+int qemuMonitorJSONGetMigrationStats(qemuMonitor *mon,
+ qemuMonitorMigrationStats *stats,
char **error)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-migrate",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("query-migrate",
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
memset(stats, 0, sizeof(*stats));
}
-int qemuMonitorJSONMigrate(qemuMonitorPtr mon,
+int qemuMonitorJSONMigrate(qemuMonitor *mon,
unsigned int flags,
const char *uri)
{
int ret = -1;
- virJSONValuePtr cmd =
+ virJSONValue *cmd =
qemuMonitorJSONMakeCommand("migrate",
"b:detach", flags & QEMU_MONITOR_MIGRATE_BACKGROUND ? 1 : 0,
"b:blk", flags & QEMU_MONITOR_MIGRATE_NON_SHARED_DISK ? 1 : 0,
"b:inc", flags & QEMU_MONITOR_MIGRATE_NON_SHARED_INC ? 1 : 0,
"s:uri", uri,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
return ret;
}
-int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon)
+int qemuMonitorJSONMigrateCancel(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("migrate_cancel", NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("migrate_cancel", NULL);
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
* Returns: 0 on success, -1 on failure
*/
int
-qemuMonitorJSONQueryDump(qemuMonitorPtr mon,
- qemuMonitorDumpStatsPtr stats)
+qemuMonitorJSONQueryDump(qemuMonitor *mon,
+ qemuMonitorDumpStats *stats)
{
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-dump", NULL);
- virJSONValuePtr reply = NULL;
- virJSONValuePtr result = NULL;
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("query-dump", NULL);
+ virJSONValue *reply = NULL;
+ virJSONValue *result = NULL;
int ret = -1;
if (!cmd)
int
-qemuMonitorJSONGetDumpGuestMemoryCapability(qemuMonitorPtr mon,
+qemuMonitorJSONGetDumpGuestMemoryCapability(qemuMonitor *mon,
const char *capability)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr caps;
- virJSONValuePtr formats;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *caps;
+ virJSONValue *formats;
size_t i;
if (!(cmd = qemuMonitorJSONMakeCommand("query-dump-guest-memory-capability",
}
for (i = 0; i < virJSONValueArraySize(formats); i++) {
- virJSONValuePtr dumpformat = virJSONValueArrayGet(formats, i);
+ virJSONValue *dumpformat = virJSONValueArrayGet(formats, i);
if (!dumpformat || virJSONValueGetType(dumpformat) != VIR_JSON_TYPE_STRING) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
int
-qemuMonitorJSONDump(qemuMonitorPtr mon,
+qemuMonitorJSONDump(qemuMonitor *mon,
const char *protocol,
const char *dumpformat,
bool detach)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("dump-guest-memory",
"b:paging", false,
return ret;
}
-int qemuMonitorJSONGraphicsRelocate(qemuMonitorPtr mon,
+int qemuMonitorJSONGraphicsRelocate(qemuMonitor *mon,
int type,
const char *hostname,
int port,
const char *tlsSubject)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("client_migrate_info",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("client_migrate_info",
"s:protocol",
(type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE ? "spice" : "vnc"),
"s:hostname", hostname,
"i:tls-port", tlsPort,
"S:cert-subject", tlsSubject,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
static int
-qemuAddfdInfoParse(virJSONValuePtr msg,
- qemuMonitorAddFdInfoPtr fdinfo)
+qemuAddfdInfoParse(virJSONValue *msg,
+ qemuMonitorAddFdInfo *fdinfo)
{
- virJSONValuePtr returnObj;
+ virJSONValue *returnObj;
if (!(returnObj = virJSONValueObjectGetObject(msg, "return"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
/* if fdset is negative, qemu will create a new fdset and add the fd to that */
-int qemuMonitorJSONAddFileHandleToSet(qemuMonitorPtr mon,
+int qemuMonitorJSONAddFileHandleToSet(qemuMonitor *mon,
int fd,
int fdset,
const char *opaque,
- qemuMonitorAddFdInfoPtr fdinfo)
+ qemuMonitorAddFdInfo *fdinfo)
{
g_autoptr(virJSONValue) args = NULL;
g_autoptr(virJSONValue) reply = NULL;
}
static int
-qemuMonitorJSONQueryFdsetsParse(virJSONValuePtr msg,
- qemuMonitorFdsetsPtr *fdsets)
+qemuMonitorJSONQueryFdsetsParse(virJSONValue *msg,
+ qemuMonitorFdsets **fdsets)
{
- virJSONValuePtr returnArray;
- virJSONValuePtr entry;
+ virJSONValue *returnArray;
+ virJSONValue *entry;
size_t i;
g_autoptr(qemuMonitorFdsets) sets = g_new0(qemuMonitorFdsets, 1);
int ninfo;
for (i = 0; i < ninfo; i++) {
size_t j;
const char *tmp;
- virJSONValuePtr fdarray;
- qemuMonitorFdsetInfoPtr fdsetinfo = &sets->fdsets[i];
+ virJSONValue *fdarray;
+ qemuMonitorFdsetInfo *fdsetinfo = &sets->fdsets[i];
if (!(entry = virJSONValueArrayGet(returnArray, i))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
fdsetinfo->fds = g_new0(qemuMonitorFdsetFdInfo, fdsetinfo->nfds);
for (j = 0; j < fdsetinfo->nfds; j++) {
- qemuMonitorFdsetFdInfoPtr fdinfo = &fdsetinfo->fds[j];
- virJSONValuePtr fdentry;
+ qemuMonitorFdsetFdInfo *fdinfo = &fdsetinfo->fds[j];
+ virJSONValue *fdentry;
if (!(fdentry = virJSONValueArrayGet(fdarray, j))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-int qemuMonitorJSONQueryFdsets(qemuMonitorPtr mon,
- qemuMonitorFdsetsPtr *fdsets)
+int qemuMonitorJSONQueryFdsets(qemuMonitor *mon,
+ qemuMonitorFdsets **fdsets)
{
g_autoptr(virJSONValue) reply = NULL;
g_autoptr(virJSONValue) cmd = qemuMonitorJSONMakeCommand("query-fdsets",
}
-int qemuMonitorJSONRemoveFdset(qemuMonitorPtr mon,
+int qemuMonitorJSONRemoveFdset(qemuMonitor *mon,
int fdset)
{
g_autoptr(virJSONValue) reply = NULL;
}
-int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon,
+int qemuMonitorJSONSendFileHandle(qemuMonitor *mon,
const char *fdname,
int fd)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("getfd",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("getfd",
"s:fdname", fdname,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
}
-int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon,
+int qemuMonitorJSONCloseFileHandle(qemuMonitor *mon,
const char *fdname)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("closefd",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("closefd",
"s:fdname", fdname,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
int
-qemuMonitorJSONAddNetdev(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorJSONAddNetdev(qemuMonitor *mon,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONRemoveNetdev(qemuMonitorPtr mon,
+qemuMonitorJSONRemoveNetdev(qemuMonitor *mon,
const char *alias)
{
g_autoptr(virJSONValue) cmd = qemuMonitorJSONMakeCommand("netdev_del",
static int
-qemuMonitorJSONQueryRxFilterParse(virJSONValuePtr msg,
- virNetDevRxFilterPtr *filter)
+qemuMonitorJSONQueryRxFilterParse(virJSONValue *msg,
+ virNetDevRxFilter **filter)
{
int ret = -1;
const char *tmp;
- virJSONValuePtr returnArray;
- virJSONValuePtr entry;
- virJSONValuePtr table;
- virJSONValuePtr element;
+ virJSONValue *returnArray;
+ virJSONValue *entry;
+ virJSONValue *table;
+ virJSONValue *element;
size_t nTable;
size_t i;
- virNetDevRxFilterPtr fil = virNetDevRxFilterNew();
+ virNetDevRxFilter *fil = virNetDevRxFilterNew();
if (!fil)
goto cleanup;
int
-qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, const char *alias,
- virNetDevRxFilterPtr *filter)
+qemuMonitorJSONQueryRxFilter(qemuMonitor *mon, const char *alias,
+ virNetDevRxFilter **filter)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-rx-filter",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("query-rx-filter",
"s:name", alias,
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
goto cleanup;
*
*/
static int
-qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply,
+qemuMonitorJSONExtractChardevInfo(virJSONValue *reply,
GHashTable *info)
{
- virJSONValuePtr data;
+ virJSONValue *data;
int ret = -1;
size_t i;
- qemuMonitorChardevInfoPtr entry = NULL;
+ qemuMonitorChardevInfo *entry = NULL;
data = virJSONValueObjectGetArray(reply, "return");
for (i = 0; i < virJSONValueArraySize(data); i++) {
- virJSONValuePtr chardev = virJSONValueArrayGet(data, i);
+ virJSONValue *chardev = virJSONValueArrayGet(data, i);
const char *type;
const char *alias;
bool connected;
int
-qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetChardevInfo(qemuMonitor *mon,
GHashTable *info)
{
int ret = -1;
- virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-chardev",
+ virJSONValue *cmd = qemuMonitorJSONMakeCommand("query-chardev",
NULL);
- virJSONValuePtr reply = NULL;
+ virJSONValue *reply = NULL;
if (!cmd)
return -1;
}
-int qemuMonitorJSONDelDevice(qemuMonitorPtr mon,
+int qemuMonitorJSONDelDevice(qemuMonitor *mon,
const char *devalias)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("device_del",
"s:id", devalias,
int
-qemuMonitorJSONAddDeviceArgs(qemuMonitorPtr mon,
- virJSONValuePtr args)
+qemuMonitorJSONAddDeviceArgs(qemuMonitor *mon,
+ virJSONValue *args)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("device_add", NULL)))
goto cleanup;
int
-qemuMonitorJSONAddDevice(qemuMonitorPtr mon,
+qemuMonitorJSONAddDevice(qemuMonitor *mon,
const char *devicestr)
{
- virJSONValuePtr args;
+ virJSONValue *args;
if (!(args = qemuMonitorJSONKeywordStringToJSON(devicestr, "driver")))
return -1;
int
-qemuMonitorJSONAddObject(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorJSONAddObject(qemuMonitor *mon,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONDelObject(qemuMonitorPtr mon,
+qemuMonitorJSONDelObject(qemuMonitor *mon,
const char *objalias,
bool report_error)
{
/* speed is in bytes/sec */
int
-qemuMonitorJSONDriveMirror(qemuMonitorPtr mon,
+qemuMonitorJSONDriveMirror(qemuMonitor *mon,
const char *device, const char *file,
const char *format, unsigned long long speed,
unsigned int granularity,
int
-qemuMonitorJSONBlockdevMirror(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevMirror(qemuMonitor *mon,
const char *jobname,
bool persistjob,
const char *device,
int
-qemuMonitorJSONTransaction(qemuMonitorPtr mon, virJSONValuePtr *actions)
+qemuMonitorJSONTransaction(qemuMonitor *mon, virJSONValue **actions)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("transaction",
"a:actions", actions,
* and base. The probe return is true if active commit is detected or false
* if not supported or on any error */
bool
-qemuMonitorJSONSupportsActiveCommit(qemuMonitorPtr mon)
+qemuMonitorJSONSupportsActiveCommit(qemuMonitor *mon)
{
bool ret = false;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("block-commit", "s:device",
"bogus", NULL)))
/* speed is in bytes/sec. Returns 0 on success, -1 with error message
* emitted on failure. */
int
-qemuMonitorJSONBlockCommit(qemuMonitorPtr mon,
+qemuMonitorJSONBlockCommit(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
unsigned long long speed)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
virTristateBool autofinalize = VIR_TRISTATE_BOOL_ABSENT;
virTristateBool autodismiss = VIR_TRISTATE_BOOL_ABSENT;
static char *
-qemuMonitorJSONDiskNameLookupOne(virJSONValuePtr image,
- virStorageSourcePtr top,
- virStorageSourcePtr target)
+qemuMonitorJSONDiskNameLookupOne(virJSONValue *image,
+ virStorageSource *top,
+ virStorageSource *target)
{
- virJSONValuePtr backing;
+ virJSONValue *backing;
char *ret;
/* The caller will report a generic message if we return NULL
char *
-qemuMonitorJSONDiskNameLookup(qemuMonitorPtr mon,
+qemuMonitorJSONDiskNameLookup(qemuMonitor *mon,
const char *device,
- virStorageSourcePtr top,
- virStorageSourcePtr target)
+ virStorageSource *top,
+ virStorageSource *target)
{
char *ret = NULL;
- virJSONValuePtr devices;
+ virJSONValue *devices;
size_t i;
if (!(devices = qemuMonitorJSONQueryBlock(mon)))
return NULL;
for (i = 0; i < virJSONValueArraySize(devices); i++) {
- virJSONValuePtr dev;
- virJSONValuePtr inserted;
- virJSONValuePtr image;
+ virJSONValue *dev;
+ virJSONValue *inserted;
+ virJSONValue *image;
const char *thisdev;
if (!(dev = qemuMonitorJSONGetBlockDev(devices, i)))
}
-int qemuMonitorJSONArbitraryCommand(qemuMonitorPtr mon,
+int qemuMonitorJSONArbitraryCommand(qemuMonitor *mon,
const char *cmd_str,
char **reply_str)
{
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = virJSONValueFromString(cmd_str)))
return ret;
}
-int qemuMonitorJSONInjectNMI(qemuMonitorPtr mon)
+int qemuMonitorJSONInjectNMI(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("inject-nmi", NULL);
if (!cmd)
return ret;
}
-int qemuMonitorJSONSendKey(qemuMonitorPtr mon,
+int qemuMonitorJSONSendKey(qemuMonitor *mon,
unsigned int holdtime,
unsigned int *keycodes,
unsigned int nkeycodes)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr keys = NULL;
- virJSONValuePtr key = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *keys = NULL;
+ virJSONValue *key = NULL;
size_t i;
/* create the key data array */
return ret;
}
-int qemuMonitorJSONScreendump(qemuMonitorPtr mon,
+int qemuMonitorJSONScreendump(qemuMonitor *mon,
const char *device,
unsigned int head,
const char *file)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("screendump",
"s:filename", file,
static int
qemuMonitorJSONParseBlockJobInfo(GHashTable *blockJobs,
- virJSONValuePtr entry,
+ virJSONValue *entry,
bool rawjobname)
{
- qemuMonitorBlockJobInfoPtr info = NULL;
+ qemuMonitorBlockJobInfo *info = NULL;
const char *device;
const char *type;
}
GHashTable *
-qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetAllBlockJobInfo(qemuMonitor *mon,
bool rawjobname)
{
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
size_t nr_results;
size_t i;
GHashTable *blockJobs = NULL;
goto cleanup;
for (i = 0; i < nr_results; i++) {
- virJSONValuePtr entry = virJSONValueArrayGet(data, i);
+ virJSONValue *entry = virJSONValueArrayGet(data, i);
if (!entry) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("missing array element"));
static int
-qemuMonitorJSONBlockJobError(virJSONValuePtr cmd,
- virJSONValuePtr reply,
+qemuMonitorJSONBlockJobError(virJSONValue *cmd,
+ virJSONValue *reply,
const char *jobname)
{
- virJSONValuePtr error;
+ virJSONValue *error;
if ((error = virJSONValueObjectGet(reply, "error")) &&
(qemuMonitorJSONErrorIsClass(error, "DeviceNotActive"))) {
/* speed is in bytes/sec */
int
-qemuMonitorJSONBlockStream(qemuMonitorPtr mon,
+qemuMonitorJSONBlockStream(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
unsigned long long speed)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
virTristateBool autofinalize = VIR_TRISTATE_BOOL_ABSENT;
virTristateBool autodismiss = VIR_TRISTATE_BOOL_ABSENT;
int
-qemuMonitorJSONBlockJobCancel(qemuMonitorPtr mon,
+qemuMonitorJSONBlockJobCancel(qemuMonitor *mon,
const char *jobname)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("block-job-cancel",
"s:device", jobname,
int
-qemuMonitorJSONBlockJobSetSpeed(qemuMonitorPtr mon,
+qemuMonitorJSONBlockJobSetSpeed(qemuMonitor *mon,
const char *jobname,
unsigned long long speed)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("block-job-set-speed",
"s:device", jobname,
int
-qemuMonitorJSONDrivePivot(qemuMonitorPtr mon,
+qemuMonitorJSONDrivePivot(qemuMonitor *mon,
const char *jobname)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("block-job-complete",
"s:device", jobname,
int
-qemuMonitorJSONJobDismiss(qemuMonitorPtr mon,
+qemuMonitorJSONJobDismiss(qemuMonitor *mon,
const char *jobname)
{
g_autoptr(virJSONValue) cmd = NULL;
int
-qemuMonitorJSONJobCancel(qemuMonitorPtr mon,
+qemuMonitorJSONJobCancel(qemuMonitor *mon,
const char *jobname,
bool quiet)
{
int
-qemuMonitorJSONJobComplete(qemuMonitorPtr mon,
+qemuMonitorJSONJobComplete(qemuMonitor *mon,
const char *jobname)
{
g_autoptr(virJSONValue) cmd = NULL;
}
-int qemuMonitorJSONOpenGraphics(qemuMonitorPtr mon,
+int qemuMonitorJSONOpenGraphics(qemuMonitor *mon,
const char *protocol,
const char *fdname,
bool skipauth)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("add_client",
"s:protocol", protocol,
return -1; \
}
static int
-qemuMonitorJSONBlockIoThrottleInfo(virJSONValuePtr io_throttle,
+qemuMonitorJSONBlockIoThrottleInfo(virJSONValue *io_throttle,
const char *drivealias,
const char *qdevid,
- virDomainBlockIoTuneInfoPtr reply)
+ virDomainBlockIoTuneInfo *reply)
{
size_t i;
bool found = false;
for (i = 0; i < virJSONValueArraySize(io_throttle); i++) {
- virJSONValuePtr temp_dev = virJSONValueArrayGet(io_throttle, i);
- virJSONValuePtr inserted;
+ virJSONValue *temp_dev = virJSONValueArrayGet(io_throttle, i);
+ virJSONValue *inserted;
const char *current_drive;
const char *current_qdev;
#undef GET_THROTTLE_STATS
#undef GET_THROTTLE_STATS_OPTIONAL
-int qemuMonitorJSONSetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorJSONSetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qomid,
- virDomainBlockIoTuneInfoPtr info,
+ virDomainBlockIoTuneInfo *info,
bool supportMaxOptions,
bool supportGroupNameOption,
bool supportMaxLengthOptions)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr result = NULL;
- virJSONValuePtr args = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *result = NULL;
+ virJSONValue *args = NULL;
const char *errdev = drivealias;
if (!errdev)
virReportError(VIR_ERR_OPERATION_INVALID,
_("Operation is not supported for device: %s"), errdev);
} else {
- virJSONValuePtr error = virJSONValueObjectGet(result, "error");
+ virJSONValue *error = virJSONValueObjectGet(result, "error");
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unable to execute '%s', unexpected error: '%s'"),
qemuMonitorJSONCommandName(cmd),
return ret;
}
-int qemuMonitorJSONGetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorJSONGetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qdevid,
- virDomainBlockIoTuneInfoPtr reply)
+ virDomainBlockIoTuneInfo *reply)
{
int ret = -1;
- virJSONValuePtr devices = NULL;
+ virJSONValue *devices = NULL;
if (!(devices = qemuMonitorJSONQueryBlock(mon)))
return -1;
return ret;
}
-int qemuMonitorJSONSystemWakeup(qemuMonitorPtr mon)
+int qemuMonitorJSONSystemWakeup(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
cmd = qemuMonitorJSONMakeCommand("system_wakeup", NULL);
if (!cmd)
return ret;
}
-int qemuMonitorJSONGetVersion(qemuMonitorPtr mon,
+int qemuMonitorJSONGetVersion(qemuMonitor *mon,
int *major,
int *minor,
int *micro,
char **package)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
- virJSONValuePtr qemu;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
+ virJSONValue *qemu;
*major = *minor = *micro = 0;
if (package)
}
-int qemuMonitorJSONGetMachines(qemuMonitorPtr mon,
- qemuMonitorMachineInfoPtr **machines)
+int qemuMonitorJSONGetMachines(qemuMonitor *mon,
+ qemuMonitorMachineInfo ***machines)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
- qemuMonitorMachineInfoPtr *infolist = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
+ qemuMonitorMachineInfo **infolist = NULL;
size_t n = 0;
size_t i;
n = virJSONValueArraySize(data);
/* null-terminated list */
- infolist = g_new0(qemuMonitorMachineInfoPtr, n + 1);
+ infolist = g_new0(qemuMonitorMachineInfo *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
- qemuMonitorMachineInfoPtr info;
+ qemuMonitorMachineInfo *info;
info = g_new0(qemuMonitorMachineInfo, 1);
int
-qemuMonitorJSONGetCPUDefinitions(qemuMonitorPtr mon,
- qemuMonitorCPUDefsPtr *cpuDefs)
+qemuMonitorJSONGetCPUDefinitions(qemuMonitor *mon,
+ qemuMonitorCPUDefs **cpuDefs)
{
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *data;
size_t ncpus;
size_t i;
return -1;
for (i = 0; i < defs->ncpus; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
- qemuMonitorCPUDefInfoPtr cpu = defs->cpus + i;
+ qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
if (!(tmp = virJSONValueObjectGetString(child, "name"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
virJSONValue *value,
void *opaque)
{
- qemuMonitorCPUModelInfoPtr machine_model = opaque;
- qemuMonitorCPUPropertyPtr prop;
+ qemuMonitorCPUModelInfo *machine_model = opaque;
+ qemuMonitorCPUProperty *prop;
prop = machine_model->props + machine_model->nprops;
}
-static virJSONValuePtr
-qemuMonitorJSONMakeCPUModel(virCPUDefPtr cpu,
+static virJSONValue *
+qemuMonitorJSONMakeCPUModel(virCPUDef *cpu,
bool migratable)
{
- virJSONValuePtr model = virJSONValueNewObject();
- virJSONValuePtr props = NULL;
+ virJSONValue *model = virJSONValueNewObject();
+ virJSONValue *props = NULL;
size_t i;
if (virJSONValueObjectAppendString(model, "name", cpu->model) < 0)
static int
-qemuMonitorJSONParseCPUModelData(virJSONValuePtr data,
+qemuMonitorJSONParseCPUModelData(virJSONValue *data,
const char *cmd_name,
bool fail_no_props,
- virJSONValuePtr *cpu_model,
- virJSONValuePtr *cpu_props,
+ virJSONValue **cpu_model,
+ virJSONValue **cpu_props,
const char **cpu_name)
{
if (!(*cpu_model = virJSONValueObjectGetObject(data, "model"))) {
static int
qemuMonitorJSONParseCPUModel(const char *cpu_name,
- virJSONValuePtr cpu_props,
- qemuMonitorCPUModelInfoPtr *model_info)
+ virJSONValue *cpu_props,
+ qemuMonitorCPUModelInfo **model_info)
{
- qemuMonitorCPUModelInfoPtr machine_model = NULL;
+ qemuMonitorCPUModelInfo *machine_model = NULL;
int ret = -1;
machine_model = g_new0(qemuMonitorCPUModelInfo, 1);
int
-qemuMonitorJSONGetCPUModelExpansion(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUModelExpansion(qemuMonitor *mon,
qemuMonitorCPUModelExpansionType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable,
bool fail_no_props,
- qemuMonitorCPUModelInfoPtr *model_info)
+ qemuMonitorCPUModelInfo **model_info)
{
g_autoptr(virJSONValue) model = NULL;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data;
- virJSONValuePtr cpu_model;
- virJSONValuePtr cpu_props = NULL;
+ virJSONValue *data;
+ virJSONValue *cpu_model;
+ virJSONValue *cpu_props = NULL;
const char *cpu_name = "";
const char *typeStr = "";
int
-qemuMonitorJSONGetCPUModelBaseline(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
- qemuMonitorCPUModelInfoPtr *baseline)
+qemuMonitorJSONGetCPUModelBaseline(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
+ qemuMonitorCPUModelInfo **baseline)
{
g_autoptr(virJSONValue) model_a = NULL;
g_autoptr(virJSONValue) model_b = NULL;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data;
- virJSONValuePtr cpu_model;
- virJSONValuePtr cpu_props = NULL;
+ virJSONValue *data;
+ virJSONValue *cpu_model;
+ virJSONValue *cpu_props = NULL;
const char *cpu_name = "";
if (!(model_a = qemuMonitorJSONMakeCPUModel(cpu_a, true)) ||
int
-qemuMonitorJSONGetCPUModelComparison(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
+qemuMonitorJSONGetCPUModelComparison(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
char **result)
{
g_autoptr(virJSONValue) model_a = NULL;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
const char *data_result;
- virJSONValuePtr data;
+ virJSONValue *data;
if (!(model_a = qemuMonitorJSONMakeCPUModel(cpu_a, true)) ||
!(model_b = qemuMonitorJSONMakeCPUModel(cpu_b, true)))
}
-int qemuMonitorJSONGetCommands(qemuMonitorPtr mon,
+int qemuMonitorJSONGetCommands(qemuMonitor *mon,
char ***commands)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
char **commandlist = NULL;
size_t n = 0;
size_t i;
commandlist = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
if (!(tmp = virJSONValueObjectGetString(child, "name"))) {
}
-int qemuMonitorJSONGetEvents(qemuMonitorPtr mon,
+int qemuMonitorJSONGetEvents(qemuMonitor *mon,
char ***events)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
char **eventlist = NULL;
size_t n = 0;
size_t i;
eventlist = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
if (!(tmp = virJSONValueObjectGetString(child, "name"))) {
static int
qemuMonitorJSONGetCommandLineOptionsWorker(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
const char *name = virJSONValueObjectGetString(item, "option");
GHashTable *
-qemuMonitorJSONGetCommandLineOptions(qemuMonitorPtr mon)
+qemuMonitorJSONGetCommandLineOptions(qemuMonitor *mon)
{
g_autoptr(GHashTable) ret = virHashNew(virJSONValueHashFree);
g_autoptr(virJSONValue) cmd = NULL;
}
-int qemuMonitorJSONGetKVMState(qemuMonitorPtr mon,
+int qemuMonitorJSONGetKVMState(qemuMonitor *mon,
bool *enabled,
bool *present)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *data = NULL;
/* Safe defaults */
*enabled = *present = false;
}
-int qemuMonitorJSONGetObjectTypes(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectTypes(qemuMonitor *mon,
char ***types)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
char **typelist = NULL;
size_t n = 0;
size_t i;
typelist = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
if (!(tmp = virJSONValueObjectGetString(child, "name"))) {
}
-int qemuMonitorJSONGetObjectListPaths(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectListPaths(qemuMonitor *mon,
const char *path,
- qemuMonitorJSONListPathPtr **paths)
+ qemuMonitorJSONListPath ***paths)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
- qemuMonitorJSONListPathPtr *pathlist = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
+ qemuMonitorJSONListPath **pathlist = NULL;
size_t n = 0;
size_t i;
n = virJSONValueArraySize(data);
/* null-terminated list */
- pathlist = g_new0(qemuMonitorJSONListPathPtr, n + 1);
+ pathlist = g_new0(qemuMonitorJSONListPath *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
- qemuMonitorJSONListPathPtr info;
+ qemuMonitorJSONListPath *info;
info = g_new0(qemuMonitorJSONListPath, 1);
return ret;
}
-void qemuMonitorJSONListPathFree(qemuMonitorJSONListPathPtr paths)
+void qemuMonitorJSONListPathFree(qemuMonitorJSONListPath *paths)
{
if (!paths)
return;
}
-int qemuMonitorJSONGetObjectProperty(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectProperty(qemuMonitor *mon,
const char *path,
const char *property,
- qemuMonitorJSONObjectPropertyPtr prop)
+ qemuMonitorJSONObjectProperty *prop)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
const char *tmp;
if (!(cmd = qemuMonitorJSONMakeCommand("qom-get",
static int
-qemuMonitorJSONGetStringListProperty(qemuMonitorPtr mon,
+qemuMonitorJSONGetStringListProperty(qemuMonitor *mon,
const char *path,
const char *property,
char ***strList)
"s:property", property, \
STRING, VALUE, \
NULL)
-int qemuMonitorJSONSetObjectProperty(qemuMonitorPtr mon,
+int qemuMonitorJSONSetObjectProperty(qemuMonitor *mon,
const char *path,
const char *property,
- qemuMonitorJSONObjectPropertyPtr prop)
+ qemuMonitorJSONObjectProperty *prop)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
switch ((qemuMonitorJSONObjectPropertyType) prop->type) {
/* Simple cases of boolean, int, long, uint, ulong, double, and string
static int
-qemuMonitorJSONParsePropsList(virJSONValuePtr cmd,
- virJSONValuePtr reply,
+qemuMonitorJSONParsePropsList(virJSONValue *cmd,
+ virJSONValue *reply,
const char *type,
char ***props)
{
- virJSONValuePtr data;
+ virJSONValue *data;
char **proplist = NULL;
size_t n = 0;
size_t count = 0;
proplist = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
if (type &&
static int
qemuMonitorJSONGetDevicePropsWorker(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
const char *name = virJSONValueObjectGetString(item, "name");
GHashTable *
-qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon,
+qemuMonitorJSONGetDeviceProps(qemuMonitor *mon,
const char *device)
{
g_autoptr(GHashTable) props = virHashNew(virJSONValueHashFree);
int
-qemuMonitorJSONGetObjectProps(qemuMonitorPtr mon,
+qemuMonitorJSONGetObjectProps(qemuMonitor *mon,
const char *object,
char ***props)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
*props = NULL;
char *
-qemuMonitorJSONGetTargetArch(qemuMonitorPtr mon)
+qemuMonitorJSONGetTargetArch(qemuMonitor *mon)
{
char *ret = NULL;
const char *arch;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
if (!(cmd = qemuMonitorJSONMakeCommand("query-target", NULL)))
return NULL;
int
-qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon,
+qemuMonitorJSONGetMigrationCapabilities(qemuMonitor *mon,
char ***capabilities)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr caps;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *caps;
char **list = NULL;
size_t i;
size_t n;
list = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr cap = virJSONValueArrayGet(caps, i);
+ virJSONValue *cap = virJSONValueArrayGet(caps, i);
const char *name;
if (!cap || virJSONValueGetType(cap) != VIR_JSON_TYPE_OBJECT) {
int
-qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon,
- virJSONValuePtr *caps)
+qemuMonitorJSONSetMigrationCapabilities(qemuMonitor *mon,
+ virJSONValue **caps)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
* <0 on failure
*/
int
-qemuMonitorJSONGetGICCapabilities(qemuMonitorPtr mon,
+qemuMonitorJSONGetGICCapabilities(qemuMonitor *mon,
virGICCapability **capabilities)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr caps;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *caps;
virGICCapability *list = NULL;
size_t i;
size_t n;
list = g_new0(virGICCapability, n);
for (i = 0; i < n; i++) {
- virJSONValuePtr cap = virJSONValueArrayGet(caps, i);
+ virJSONValue *cap = virJSONValueArrayGet(caps, i);
int version;
bool kernel;
bool emulated;
* the platform.
*/
int
-qemuMonitorJSONGetSEVCapabilities(qemuMonitorPtr mon,
+qemuMonitorJSONGetSEVCapabilities(qemuMonitor *mon,
virSEVCapability **capabilities)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr caps;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *caps;
const char *pdh = NULL;
const char *cert_chain = NULL;
unsigned int cbitpos;
return ret;
}
-static virJSONValuePtr
+static virJSONValue *
qemuMonitorJSONBuildInetSocketAddress(const char *host,
const char *port)
{
- virJSONValuePtr addr = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *addr = NULL;
+ virJSONValue *data = NULL;
if (virJSONValueObjectCreate(&data, "s:host", host,
"s:port", port, NULL) < 0)
return addr;
}
-static virJSONValuePtr
+static virJSONValue *
qemuMonitorJSONBuildUnixSocketAddress(const char *path)
{
- virJSONValuePtr addr = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *addr = NULL;
+ virJSONValue *data = NULL;
if (virJSONValueObjectCreate(&data, "s:path", path, NULL) < 0)
return NULL;
}
int
-qemuMonitorJSONNBDServerStart(qemuMonitorPtr mon,
+qemuMonitorJSONNBDServerStart(qemuMonitor *mon,
const virStorageNetHostDef *server,
const char *tls_alias)
{
int ret = -1;
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr addr = NULL;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *addr = NULL;
char *port_str = NULL;
switch ((virStorageNetHostTransport)server->transport) {
}
int
-qemuMonitorJSONNBDServerAdd(qemuMonitorPtr mon,
+qemuMonitorJSONNBDServerAdd(qemuMonitor *mon,
const char *deviceID,
const char *export,
bool writable,
const char *bitmap)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
/* Note: bitmap must be NULL if QEMU_CAPS_NBD_BITMAP is lacking */
if (!(cmd = qemuMonitorJSONMakeCommand("nbd-server-add",
}
int
-qemuMonitorJSONNBDServerStop(qemuMonitorPtr mon)
+qemuMonitorJSONNBDServerStop(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("nbd-server-stop",
NULL)))
int
-qemuMonitorJSONBlockExportAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorJSONBlockExportAdd(qemuMonitor *mon,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
static int
-qemuMonitorJSONGetStringArray(qemuMonitorPtr mon, const char *qmpCmd,
+qemuMonitorJSONGetStringArray(qemuMonitor *mon, const char *qmpCmd,
char ***array)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
*array = NULL;
return ret;
}
-int qemuMonitorJSONGetTPMModels(qemuMonitorPtr mon,
+int qemuMonitorJSONGetTPMModels(qemuMonitor *mon,
char ***tpmmodels)
{
return qemuMonitorJSONGetStringArray(mon, "query-tpm-models", tpmmodels);
}
-int qemuMonitorJSONGetTPMTypes(qemuMonitorPtr mon,
+int qemuMonitorJSONGetTPMTypes(qemuMonitor *mon,
char ***tpmtypes)
{
return qemuMonitorJSONGetStringArray(mon, "query-tpm-types", tpmtypes);
}
static int
-qemuMonitorJSONBuildChrChardevReconnect(virJSONValuePtr object,
+qemuMonitorJSONBuildChrChardevReconnect(virJSONValue *object,
const virDomainChrSourceReconnectDef *def)
{
if (def->enabled != VIR_TRISTATE_BOOL_YES)
return virJSONValueObjectAppendNumberUint(object, "reconnect", def->timeout);
}
-static virJSONValuePtr
+static virJSONValue *
qemuMonitorJSONAttachCharDevCommand(const char *chrID,
const virDomainChrSourceDef *chr)
{
- virJSONValuePtr ret = NULL;
- virJSONValuePtr backend = virJSONValueNewObject();
- virJSONValuePtr data = virJSONValueNewObject();
- virJSONValuePtr addr = NULL;
+ virJSONValue *ret = NULL;
+ virJSONValue *backend = virJSONValueNewObject();
+ virJSONValue *data = virJSONValueNewObject();
+ virJSONValue *addr = NULL;
const char *backend_type = NULL;
const char *host;
const char *port;
int
-qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
+qemuMonitorJSONAttachCharDev(qemuMonitor *mon,
const char *chrID,
- virDomainChrSourceDefPtr chr)
+ virDomainChrSourceDef *chr)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONAttachCharDevCommand(chrID, chr)))
return ret;
}
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
- virJSONValuePtr data = virJSONValueObjectGetObject(reply, "return");
+ virJSONValue *data = virJSONValueObjectGetObject(reply, "return");
const char *path;
if (!(path = virJSONValueObjectGetString(data, "pty"))) {
}
int
-qemuMonitorJSONDetachCharDev(qemuMonitorPtr mon,
+qemuMonitorJSONDetachCharDev(qemuMonitor *mon,
const char *chrID)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("chardev-remove",
"s:id", chrID,
int
-qemuMonitorJSONGetDeviceAliases(qemuMonitorPtr mon,
+qemuMonitorJSONGetDeviceAliases(qemuMonitor *mon,
char ***aliases)
{
- qemuMonitorJSONListPathPtr *paths = NULL;
+ qemuMonitorJSONListPath **paths = NULL;
char **alias;
int ret = -1;
size_t i;
static int
-qemuMonitorJSONParseCPUx86FeatureWord(virJSONValuePtr data,
+qemuMonitorJSONParseCPUx86FeatureWord(virJSONValue *data,
virCPUx86CPUID *cpuid)
{
const char *reg;
}
-static virCPUDataPtr
-qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data)
+static virCPUData *
+qemuMonitorJSONParseCPUx86Features(virJSONValue *data)
{
- virCPUDataPtr cpudata = NULL;
+ virCPUData *cpudata = NULL;
virCPUx86DataItem item = { 0 };
size_t i;
int
-qemuMonitorJSONGetCPUx86Data(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUx86Data(qemuMonitor *mon,
const char *property,
- virCPUDataPtr *cpudata)
+ virCPUData **cpudata)
{
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("qom-get",
* of a guest CPU, and 1 if the feature is supported.
*/
static int
-qemuMonitorJSONCheckCPUx86(qemuMonitorPtr mon)
+qemuMonitorJSONCheckCPUx86(qemuMonitor *mon)
{
- virJSONValuePtr cmd = NULL;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd = NULL;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
size_t i;
size_t n;
int ret = -1;
n = virJSONValueArraySize(data);
for (i = 0; i < n; i++) {
- virJSONValuePtr element = virJSONValueArrayGet(data, i);
+ virJSONValue *element = virJSONValueArrayGet(data, i);
if (STREQ_NULLABLE(virJSONValueObjectGetString(element, "name"),
"feature-words"))
break;
* -1 on other errors.
*/
int
-qemuMonitorJSONGetGuestCPUx86(qemuMonitorPtr mon,
- virCPUDataPtr *data,
- virCPUDataPtr *disabled)
+qemuMonitorJSONGetGuestCPUx86(qemuMonitor *mon,
+ virCPUData **data,
+ virCPUData **disabled)
{
- virCPUDataPtr cpuEnabled = NULL;
- virCPUDataPtr cpuDisabled = NULL;
+ virCPUData *cpuEnabled = NULL;
+ virCPUData *cpuDisabled = NULL;
int rc;
if ((rc = qemuMonitorJSONCheckCPUx86(mon)) < 0)
static int
-qemuMonitorJSONGetCPUProperties(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUProperties(qemuMonitor *mon,
char ***props)
{
g_autoptr(virJSONValue) cmd = NULL;
static int
-qemuMonitorJSONGetCPUData(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUData(qemuMonitor *mon,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr data)
+ virCPUData *data)
{
qemuMonitorJSONObjectProperty prop = { .type = QEMU_MONITOR_OBJECT_PROPERTY_BOOLEAN };
g_auto(GStrv) props = NULL;
static int
-qemuMonitorJSONGetCPUDataDisabled(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUDataDisabled(qemuMonitor *mon,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr data)
+ virCPUData *data)
{
g_auto(GStrv) props = NULL;
char **p;
* Returns 0 on success, -1 on error.
*/
int
-qemuMonitorJSONGetGuestCPU(qemuMonitorPtr mon,
+qemuMonitorJSONGetGuestCPU(qemuMonitor *mon,
virArch arch,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr *enabled,
- virCPUDataPtr *disabled)
+ virCPUData **enabled,
+ virCPUData **disabled)
{
- virCPUDataPtr cpuEnabled = NULL;
- virCPUDataPtr cpuDisabled = NULL;
+ virCPUData *cpuEnabled = NULL;
+ virCPUData *cpuDisabled = NULL;
int ret = -1;
if (!(cpuEnabled = virCPUDataNew(arch)) ||
int
-qemuMonitorJSONRTCResetReinjection(qemuMonitorPtr mon)
+qemuMonitorJSONRTCResetReinjection(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("rtc-reset-reinjection",
NULL)))
* {u'id': u'iothread2', u'thread-id': 30993}]}
*/
int
-qemuMonitorJSONGetIOThreads(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr **iothreads,
+qemuMonitorJSONGetIOThreads(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo ***iothreads,
int *niothreads)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
- qemuMonitorIOThreadInfoPtr *infolist = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
+ qemuMonitorIOThreadInfo **infolist = NULL;
size_t n = 0;
size_t i;
n = virJSONValueArraySize(data);
/* null-terminated list */
- infolist = g_new0(qemuMonitorIOThreadInfoPtr, n + 1);
+ infolist = g_new0(qemuMonitorIOThreadInfo *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
- qemuMonitorIOThreadInfoPtr info;
+ qemuMonitorIOThreadInfo *info;
if (!(tmp = virJSONValueObjectGetString(child, "id"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
int
-qemuMonitorJSONSetIOThread(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr iothreadInfo)
+qemuMonitorJSONSetIOThread(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo *iothreadInfo)
{
int ret = -1;
char *path = NULL;
int
-qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitor *mon,
GHashTable *info)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data = NULL;
- qemuMonitorMemoryDeviceInfoPtr meminfo = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data = NULL;
+ qemuMonitorMemoryDeviceInfo *meminfo = NULL;
size_t i;
if (!(cmd = qemuMonitorJSONMakeCommand("query-memory-devices", NULL)))
data = virJSONValueObjectGetArray(reply, "return");
for (i = 0; i < virJSONValueArraySize(data); i++) {
- virJSONValuePtr elem = virJSONValueArrayGet(data, i);
+ virJSONValue *elem = virJSONValueArrayGet(data, i);
const char *type;
if (!(type = virJSONValueObjectGetString(elem, "type"))) {
/* dimm memory devices */
if (STREQ(type, "dimm")) {
- virJSONValuePtr dimminfo;
+ virJSONValue *dimminfo;
const char *devalias;
if (!(dimminfo = virJSONValueObjectGetObject(elem, "data"))) {
* -2 - Not found
*/
static int
-qemuMonitorJSONFindObjectPathByAlias(qemuMonitorPtr mon,
+qemuMonitorJSONFindObjectPathByAlias(qemuMonitor *mon,
const char *name,
const char *alias,
char **path)
{
- qemuMonitorJSONListPathPtr *paths = NULL;
+ qemuMonitorJSONListPath **paths = NULL;
char *child = NULL;
int npaths;
int ret = -1;
* -2 - Not found
*/
static int
-qemuMonitorJSONFindObjectPathByName(qemuMonitorPtr mon,
+qemuMonitorJSONFindObjectPathByName(qemuMonitor *mon,
const char *curpath,
const char *name,
char **path)
ssize_t i, npaths = 0;
int ret = -2;
char *nextpath = NULL;
- qemuMonitorJSONListPathPtr *paths = NULL;
+ qemuMonitorJSONListPath **paths = NULL;
VIR_DEBUG("Searching for '%s' Object Path starting at '%s'", name, curpath);
* -2 - Not found
*/
int
-qemuMonitorJSONFindLinkPath(qemuMonitorPtr mon,
+qemuMonitorJSONFindLinkPath(qemuMonitor *mon,
const char *name,
const char *alias,
char **path)
int
-qemuMonitorJSONMigrateIncoming(qemuMonitorPtr mon,
+qemuMonitorJSONMigrateIncoming(qemuMonitor *mon,
const char *uri)
{
g_autoptr(virJSONValue) cmd = NULL;
int
-qemuMonitorJSONMigrateStartPostCopy(qemuMonitorPtr mon)
+qemuMonitorJSONMigrateStartPostCopy(qemuMonitor *mon)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("migrate-start-postcopy", NULL)))
return -1;
int
-qemuMonitorJSONMigrateContinue(qemuMonitorPtr mon,
+qemuMonitorJSONMigrateContinue(qemuMonitor *mon,
qemuMonitorMigrationStatus status)
{
const char *statusStr = qemuMonitorMigrationStatusTypeToString(status);
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("migrate-continue",
"s:state", statusStr,
int
-qemuMonitorJSONGetRTCTime(qemuMonitorPtr mon,
+qemuMonitorJSONGetRTCTime(qemuMonitor *mon,
struct tm *tm)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
if (!(cmd = qemuMonitorJSONMakeCommand("qom-get",
"s:path", "/machine",
* ]
*/
static int
-qemuMonitorJSONProcessHotpluggableCpusReply(virJSONValuePtr vcpu,
+qemuMonitorJSONProcessHotpluggableCpusReply(virJSONValue *vcpu,
struct qemuMonitorQueryHotpluggableCpusEntry *entry)
{
- virJSONValuePtr props;
+ virJSONValue *props;
const char *tmp;
if (!(tmp = virJSONValueObjectGetString(vcpu, "type"))) {
int
-qemuMonitorJSONGetHotpluggableCPUs(qemuMonitorPtr mon,
+qemuMonitorJSONGetHotpluggableCPUs(qemuMonitor *mon,
struct qemuMonitorQueryHotpluggableCpusEntry **entries,
size_t *nentries)
{
size_t ninfo = 0;
int ret = -1;
size_t i;
- virJSONValuePtr data;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr vcpu;
+ virJSONValue *data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *vcpu;
if (!(cmd = qemuMonitorJSONMakeCommand("query-hotpluggable-cpus", NULL)))
return -1;
}
-virJSONValuePtr
-qemuMonitorJSONQueryQMPSchema(qemuMonitorPtr mon)
+virJSONValue *
+qemuMonitorJSONQueryQMPSchema(qemuMonitor *mon)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr ret = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *ret = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-qmp-schema", NULL)))
return NULL;
int
-qemuMonitorJSONSetBlockThreshold(qemuMonitorPtr mon,
+qemuMonitorJSONSetBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("block-set-write-threshold",
}
-virJSONValuePtr
-qemuMonitorJSONQueryNamedBlockNodes(qemuMonitorPtr mon,
+virJSONValue *
+qemuMonitorJSONQueryNamedBlockNodes(qemuMonitor *mon,
bool flat)
{
g_autoptr(virJSONValue) cmd = NULL;
int
-qemuMonitorJSONSetWatchdogAction(qemuMonitorPtr mon,
+qemuMonitorJSONSetWatchdogAction(qemuMonitor *mon,
const char *action)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("watchdog-set-action",
int
-qemuMonitorJSONBlockdevCreate(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevCreate(qemuMonitor *mon,
const char *jobname,
- virJSONValuePtr props)
+ virJSONValue *props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONBlockdevAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorJSONBlockdevAdd(qemuMonitor *mon,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONBlockdevReopen(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+qemuMonitorJSONBlockdevReopen(qemuMonitor *mon,
+ virJSONValue **props)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
int
-qemuMonitorJSONBlockdevDel(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevDel(qemuMonitor *mon,
const char *nodename)
{
g_autoptr(virJSONValue) cmd = NULL;
int
-qemuMonitorJSONBlockdevTrayOpen(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevTrayOpen(qemuMonitor *mon,
const char *id,
bool force)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("blockdev-open-tray",
int
-qemuMonitorJSONBlockdevTrayClose(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevTrayClose(qemuMonitor *mon,
const char *id)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("blockdev-close-tray",
int
-qemuMonitorJSONBlockdevMediumRemove(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevMediumRemove(qemuMonitor *mon,
const char *id)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("blockdev-remove-medium",
int
-qemuMonitorJSONBlockdevMediumInsert(qemuMonitorPtr mon,
+qemuMonitorJSONBlockdevMediumInsert(qemuMonitor *mon,
const char *id,
const char *nodename)
{
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
int ret = -1;
if (!(cmd = qemuMonitorJSONMakeCommand("blockdev-insert-medium",
* { "return" : { "data" : "4l8LXeNlSPUDlXPJG5966/8%YZ" } }
*/
char *
-qemuMonitorJSONGetSEVMeasurement(qemuMonitorPtr mon)
+qemuMonitorJSONGetSEVMeasurement(qemuMonitor *mon)
{
const char *tmp;
char *measurement = NULL;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
- virJSONValuePtr data;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
+ virJSONValue *data;
if (!(cmd = qemuMonitorJSONMakeCommand("query-sev-launch-measure", NULL)))
return NULL;
* ]
*/
static int
-qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr reply,
+qemuMonitorJSONExtractPRManagerInfo(virJSONValue *reply,
GHashTable *info)
{
- qemuMonitorPRManagerInfoPtr entry = NULL;
- virJSONValuePtr data;
+ qemuMonitorPRManagerInfo *entry = NULL;
+ virJSONValue *data;
int ret = -1;
size_t i;
data = virJSONValueObjectGetArray(reply, "return");
for (i = 0; i < virJSONValueArraySize(data); i++) {
- virJSONValuePtr prManager = virJSONValueArrayGet(data, i);
+ virJSONValue *prManager = virJSONValueArrayGet(data, i);
const char *alias;
if (!(alias = virJSONValueObjectGetString(prManager, "id")))
int
-qemuMonitorJSONGetPRManagerInfo(qemuMonitorPtr mon,
+qemuMonitorJSONGetPRManagerInfo(qemuMonitor *mon,
GHashTable *info)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-pr-managers",
NULL)))
static int
-qemuMonitorJSONExtractCurrentMachineInfo(virJSONValuePtr reply,
- qemuMonitorCurrentMachineInfoPtr info)
+qemuMonitorJSONExtractCurrentMachineInfo(virJSONValue *reply,
+ qemuMonitorCurrentMachineInfo *info)
{
- virJSONValuePtr data;
+ virJSONValue *data;
data = virJSONValueObjectGetObject(reply, "return");
if (!data)
int
-qemuMonitorJSONGetCurrentMachineInfo(qemuMonitorPtr mon,
- qemuMonitorCurrentMachineInfoPtr info)
+qemuMonitorJSONGetCurrentMachineInfo(qemuMonitor *mon,
+ qemuMonitorCurrentMachineInfo *info)
{
int ret = -1;
- virJSONValuePtr cmd;
- virJSONValuePtr reply = NULL;
+ virJSONValue *cmd;
+ virJSONValue *reply = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-current-machine",
NULL)))
int
-qemuMonitorJSONTransactionBitmapAdd(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapAdd(virJSONValue *actions,
const char *node,
const char *name,
bool persistent,
int
-qemuMonitorJSONTransactionBitmapRemove(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapRemove(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorJSONBitmapRemove(qemuMonitorPtr mon,
+qemuMonitorJSONBitmapRemove(qemuMonitor *mon,
const char *node,
const char *name)
{
int
-qemuMonitorJSONTransactionBitmapEnable(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapEnable(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorJSONTransactionBitmapDisable(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapDisable(virJSONValue *actions,
const char *node,
const char *name)
{
int
-qemuMonitorJSONTransactionBitmapMerge(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapMerge(virJSONValue *actions,
const char *node,
const char *target,
- virJSONValuePtr *sources)
+ virJSONValue **sources)
{
return qemuMonitorJSONTransactionAdd(actions,
"block-dirty-bitmap-merge",
int
-qemuMonitorJSONTransactionBitmapMergeSourceAddBitmap(virJSONValuePtr sources,
+qemuMonitorJSONTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
const char *sourcenode,
const char *sourcebitmap)
{
int
-qemuMonitorJSONTransactionSnapshotLegacy(virJSONValuePtr actions,
+qemuMonitorJSONTransactionSnapshotLegacy(virJSONValue *actions,
const char *device,
const char *path,
const char *format,
int
-qemuMonitorJSONTransactionSnapshotBlockdev(virJSONValuePtr actions,
+qemuMonitorJSONTransactionSnapshotBlockdev(virJSONValue *actions,
const char *node,
const char *overlay)
{
"full");
int
-qemuMonitorJSONTransactionBackup(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBackup(virJSONValue *actions,
const char *device,
const char *jobname,
const char *target,
}
-static qemuMonitorJobInfoPtr
-qemuMonitorJSONGetJobInfoOne(virJSONValuePtr data)
+static qemuMonitorJobInfo *
+qemuMonitorJSONGetJobInfoOne(virJSONValue *data)
{
const char *id = virJSONValueObjectGetString(data, "id");
const char *type = virJSONValueObjectGetString(data, "type");
int
-qemuMonitorJSONGetJobInfo(qemuMonitorPtr mon,
- qemuMonitorJobInfoPtr **jobs,
+qemuMonitorJSONGetJobInfo(qemuMonitor *mon,
+ qemuMonitorJobInfo ***jobs,
size_t *njobs)
{
- virJSONValuePtr data;
+ virJSONValue *data;
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
size_t i;
data = virJSONValueObjectGetArray(reply, "return");
for (i = 0; i < virJSONValueArraySize(data); i++) {
- qemuMonitorJobInfoPtr job = NULL;
+ qemuMonitorJobInfo *job = NULL;
if (!(job = qemuMonitorJSONGetJobInfoOne(virJSONValueArrayGet(data, i))))
return -1;
int
-qemuMonitorJSONGetCPUMigratable(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUMigratable(qemuMonitor *mon,
bool *migratable)
{
g_autoptr(virJSONValue) cmd = NULL;
int
-qemuMonitorJSONStartDirtyRateCalc(qemuMonitorPtr mon,
+qemuMonitorJSONStartDirtyRateCalc(qemuMonitor *mon,
int seconds)
{
g_autoptr(virJSONValue) cmd = NULL;
"measured");
static int
-qemuMonitorJSONExtractDirtyRateInfo(virJSONValuePtr data,
- qemuMonitorDirtyRateInfoPtr info)
+qemuMonitorJSONExtractDirtyRateInfo(virJSONValue *data,
+ qemuMonitorDirtyRateInfo *info)
{
const char *statusstr;
int status;
int
-qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
- qemuMonitorDirtyRateInfoPtr info)
+qemuMonitorJSONQueryDirtyRate(qemuMonitor *mon,
+ qemuMonitorDirtyRateInfo *info)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr data = NULL;
+ virJSONValue *data = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-dirty-rate", NULL)))
return -1;
#include "cpu/cpu.h"
#include "util/virgic.h"
-int qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon,
+int qemuMonitorJSONIOProcessLine(qemuMonitor *mon,
const char *line,
- qemuMonitorMessagePtr msg) G_GNUC_NO_INLINE;
+ qemuMonitorMessage *msg) G_GNUC_NO_INLINE;
-int qemuMonitorJSONIOProcess(qemuMonitorPtr mon,
+int qemuMonitorJSONIOProcess(qemuMonitor *mon,
const char *data,
size_t len,
- qemuMonitorMessagePtr msg);
+ qemuMonitorMessage *msg);
-int qemuMonitorJSONHumanCommand(qemuMonitorPtr mon,
+int qemuMonitorJSONHumanCommand(qemuMonitor *mon,
const char *cmd,
char **reply);
-int qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon);
+int qemuMonitorJSONSetCapabilities(qemuMonitor *mon);
-int qemuMonitorJSONStartCPUs(qemuMonitorPtr mon);
-int qemuMonitorJSONStopCPUs(qemuMonitorPtr mon);
-int qemuMonitorJSONGetStatus(qemuMonitorPtr mon,
+int qemuMonitorJSONStartCPUs(qemuMonitor *mon);
+int qemuMonitorJSONStopCPUs(qemuMonitor *mon);
+int qemuMonitorJSONGetStatus(qemuMonitor *mon,
bool *running,
virDomainPausedReason *reason);
-int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon);
-int qemuMonitorJSONSystemReset(qemuMonitorPtr mon);
+int qemuMonitorJSONSystemPowerdown(qemuMonitor *mon);
+int qemuMonitorJSONSystemReset(qemuMonitor *mon);
-int qemuMonitorJSONQueryCPUs(qemuMonitorPtr mon,
+int qemuMonitorJSONQueryCPUs(qemuMonitor *mon,
struct qemuMonitorQueryCpusEntry **entries,
size_t *nentries,
bool force,
bool fast);
-int qemuMonitorJSONUpdateVideoMemorySize(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+int qemuMonitorJSONUpdateVideoMemorySize(qemuMonitor *mon,
+ virDomainVideoDef *video,
char *path);
-int qemuMonitorJSONUpdateVideoVram64Size(qemuMonitorPtr mon,
- virDomainVideoDefPtr video,
+int qemuMonitorJSONUpdateVideoVram64Size(qemuMonitor *mon,
+ virDomainVideoDef *video,
char *path);
-int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetBalloonInfo(qemuMonitor *mon,
unsigned long long *currmem);
-int qemuMonitorJSONGetMemoryStats(qemuMonitorPtr mon,
+int qemuMonitorJSONGetMemoryStats(qemuMonitor *mon,
char *balloonpath,
virDomainMemoryStatPtr stats,
unsigned int nr_stats);
-int qemuMonitorJSONSetMemoryStatsPeriod(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMemoryStatsPeriod(qemuMonitor *mon,
char *balloonpath,
int period);
-int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetBlockInfo(qemuMonitor *mon,
GHashTable *table);
-virJSONValuePtr qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon);
-int qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon,
+virJSONValue *qemuMonitorJSONQueryBlockstats(qemuMonitor *mon);
+int qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitor *mon,
GHashTable *hash,
bool backingChain);
-int qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitor *mon,
GHashTable *stats,
bool backingChain);
-int qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
GHashTable *stats);
GHashTable *
-qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes);
+qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValue *nodes);
GHashTable *
-qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon,
+qemuMonitorJSONBlockGetNamedNodeData(qemuMonitor *mon,
bool supports_flat);
-int qemuMonitorJSONBlockResize(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockResize(qemuMonitor *mon,
const char *device,
const char *nodename,
unsigned long long size);
-int qemuMonitorJSONSetPassword(qemuMonitorPtr mon,
+int qemuMonitorJSONSetPassword(qemuMonitor *mon,
const char *protocol,
const char *password,
const char *action_if_connected);
-int qemuMonitorJSONExpirePassword(qemuMonitorPtr mon,
+int qemuMonitorJSONExpirePassword(qemuMonitor *mon,
const char *protocol,
const char *expire_time);
-int qemuMonitorJSONSetBalloon(qemuMonitorPtr mon,
+int qemuMonitorJSONSetBalloon(qemuMonitor *mon,
unsigned long long newmem);
-int qemuMonitorJSONSetCPU(qemuMonitorPtr mon, int cpu, bool online);
+int qemuMonitorJSONSetCPU(qemuMonitor *mon, int cpu, bool online);
-int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon,
+int qemuMonitorJSONEjectMedia(qemuMonitor *mon,
const char *dev_name,
bool force);
-int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon,
+int qemuMonitorJSONChangeMedia(qemuMonitor *mon,
const char *dev_name,
const char *newmedia,
const char *format);
-int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon,
+int qemuMonitorJSONSaveVirtualMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path);
-int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon,
+int qemuMonitorJSONSavePhysicalMemory(qemuMonitor *mon,
unsigned long long offset,
unsigned long long length,
const char *path);
-int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMigrationSpeed(qemuMonitor *mon,
unsigned long bandwidth);
-int qemuMonitorJSONSetMigrationDowntime(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMigrationDowntime(qemuMonitor *mon,
unsigned long long downtime);
-int qemuMonitorJSONGetMigrationCacheSize(qemuMonitorPtr mon,
+int qemuMonitorJSONGetMigrationCacheSize(qemuMonitor *mon,
unsigned long long *cacheSize);
-int qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon,
+int qemuMonitorJSONSetMigrationCacheSize(qemuMonitor *mon,
unsigned long long cacheSize);
-int qemuMonitorJSONGetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params);
-int qemuMonitorJSONSetMigrationParams(qemuMonitorPtr mon,
- virJSONValuePtr *params);
+int qemuMonitorJSONGetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params);
+int qemuMonitorJSONSetMigrationParams(qemuMonitor *mon,
+ virJSONValue **params);
-int qemuMonitorJSONGetMigrationStats(qemuMonitorPtr mon,
- qemuMonitorMigrationStatsPtr stats,
+int qemuMonitorJSONGetMigrationStats(qemuMonitor *mon,
+ qemuMonitorMigrationStats *stats,
char **error);
-int qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon,
+int qemuMonitorJSONGetMigrationCapabilities(qemuMonitor *mon,
char ***capabilities);
-int qemuMonitorJSONSetMigrationCapabilities(qemuMonitorPtr mon,
- virJSONValuePtr *caps);
+int qemuMonitorJSONSetMigrationCapabilities(qemuMonitor *mon,
+ virJSONValue **caps);
-int qemuMonitorJSONGetGICCapabilities(qemuMonitorPtr mon,
+int qemuMonitorJSONGetGICCapabilities(qemuMonitor *mon,
virGICCapability **capabilities);
-int qemuMonitorJSONGetSEVCapabilities(qemuMonitorPtr mon,
+int qemuMonitorJSONGetSEVCapabilities(qemuMonitor *mon,
virSEVCapability **capabilities);
-int qemuMonitorJSONMigrate(qemuMonitorPtr mon,
+int qemuMonitorJSONMigrate(qemuMonitor *mon,
unsigned int flags,
const char *uri);
-int qemuMonitorJSONGetSpiceMigrationStatus(qemuMonitorPtr mon,
+int qemuMonitorJSONGetSpiceMigrationStatus(qemuMonitor *mon,
bool *spice_migrated);
-int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon);
+int qemuMonitorJSONMigrateCancel(qemuMonitor *mon);
-int qemuMonitorJSONQueryDump(qemuMonitorPtr mon,
- qemuMonitorDumpStatsPtr stats);
+int qemuMonitorJSONQueryDump(qemuMonitor *mon,
+ qemuMonitorDumpStats *stats);
-int qemuMonitorJSONGetDumpGuestMemoryCapability(qemuMonitorPtr mon,
+int qemuMonitorJSONGetDumpGuestMemoryCapability(qemuMonitor *mon,
const char *capability);
-int qemuMonitorJSONDump(qemuMonitorPtr mon,
+int qemuMonitorJSONDump(qemuMonitor *mon,
const char *protocol,
const char *dumpformat,
bool detach);
-int qemuMonitorJSONGraphicsRelocate(qemuMonitorPtr mon,
+int qemuMonitorJSONGraphicsRelocate(qemuMonitor *mon,
int type,
const char *hostname,
int port,
int tlsPort,
const char *tlsSubject);
-int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon,
+int qemuMonitorJSONAddPCIHostDevice(qemuMonitor *mon,
virPCIDeviceAddress *hostAddr,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon,
+int qemuMonitorJSONAddPCIDisk(qemuMonitor *mon,
const char *path,
const char *bus,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon,
+int qemuMonitorJSONAddPCINetwork(qemuMonitor *mon,
const char *nicstr,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon,
+int qemuMonitorJSONRemovePCIDevice(qemuMonitor *mon,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorJSONAddFileHandleToSet(qemuMonitorPtr mon,
+int qemuMonitorJSONAddFileHandleToSet(qemuMonitor *mon,
int fd,
int fdset,
const char *opaque,
- qemuMonitorAddFdInfoPtr info);
+ qemuMonitorAddFdInfo *info);
-int qemuMonitorJSONRemoveFdset(qemuMonitorPtr mon,
+int qemuMonitorJSONRemoveFdset(qemuMonitor *mon,
int fdset);
-int qemuMonitorJSONQueryFdsets(qemuMonitorPtr mon,
- qemuMonitorFdsetsPtr *fdsets);
+int qemuMonitorJSONQueryFdsets(qemuMonitor *mon,
+ qemuMonitorFdsets **fdsets);
-int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon,
+int qemuMonitorJSONSendFileHandle(qemuMonitor *mon,
const char *fdname,
int fd);
-int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon,
+int qemuMonitorJSONCloseFileHandle(qemuMonitor *mon,
const char *fdname);
-int qemuMonitorJSONAddNetdev(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorJSONAddNetdev(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorJSONRemoveNetdev(qemuMonitorPtr mon,
+int qemuMonitorJSONRemoveNetdev(qemuMonitor *mon,
const char *alias);
-int qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, const char *alias,
- virNetDevRxFilterPtr *filter);
+int qemuMonitorJSONQueryRxFilter(qemuMonitor *mon, const char *alias,
+ virNetDevRxFilter **filter);
-int qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetChardevInfo(qemuMonitor *mon,
GHashTable *info);
-int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon,
+int qemuMonitorJSONAttachPCIDiskController(qemuMonitor *mon,
const char *bus,
virPCIDeviceAddress *guestAddr);
-int qemuMonitorJSONAddDeviceArgs(qemuMonitorPtr mon,
- virJSONValuePtr args);
-int qemuMonitorJSONAddDevice(qemuMonitorPtr mon,
+int qemuMonitorJSONAddDeviceArgs(qemuMonitor *mon,
+ virJSONValue *args);
+int qemuMonitorJSONAddDevice(qemuMonitor *mon,
const char *devicestr);
-int qemuMonitorJSONDelDevice(qemuMonitorPtr mon,
+int qemuMonitorJSONDelDevice(qemuMonitor *mon,
const char *devalias);
-int qemuMonitorJSONAddObject(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorJSONAddObject(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorJSONDelObject(qemuMonitorPtr mon,
+int qemuMonitorJSONDelObject(qemuMonitor *mon,
const char *objalias,
bool report_error);
-int qemuMonitorJSONTransaction(qemuMonitorPtr mon, virJSONValuePtr *actions)
+int qemuMonitorJSONTransaction(qemuMonitor *mon, virJSONValue **actions)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONDriveMirror(qemuMonitorPtr mon,
+int qemuMonitorJSONDriveMirror(qemuMonitor *mon,
const char *device,
const char *file,
const char *format,
bool shallow,
bool reuse)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorJSONBlockdevMirror(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevMirror(qemuMonitor *mon,
const char *jobname,
bool persistjob,
const char *device,
unsigned long long buf_size,
bool shallow)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
-int qemuMonitorJSONDrivePivot(qemuMonitorPtr mon,
+int qemuMonitorJSONDrivePivot(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-bool qemuMonitorJSONSupportsActiveCommit(qemuMonitorPtr mon)
+bool qemuMonitorJSONSupportsActiveCommit(qemuMonitor *mon)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONBlockCommit(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockCommit(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
unsigned long long bandwidth)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-char *qemuMonitorJSONDiskNameLookup(qemuMonitorPtr mon,
+char *qemuMonitorJSONDiskNameLookup(qemuMonitor *mon,
const char *device,
- virStorageSourcePtr top,
- virStorageSourcePtr target)
+ virStorageSource *top,
+ virStorageSource *target)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4);
-int qemuMonitorJSONArbitraryCommand(qemuMonitorPtr mon,
+int qemuMonitorJSONArbitraryCommand(qemuMonitor *mon,
const char *cmd_str,
char **reply_str);
-int qemuMonitorJSONInjectNMI(qemuMonitorPtr mon);
+int qemuMonitorJSONInjectNMI(qemuMonitor *mon);
-int qemuMonitorJSONSendKey(qemuMonitorPtr mon,
+int qemuMonitorJSONSendKey(qemuMonitor *mon,
unsigned int holdtime,
unsigned int *keycodes,
unsigned int nkeycodes);
-int qemuMonitorJSONScreendump(qemuMonitorPtr mon,
+int qemuMonitorJSONScreendump(qemuMonitor *mon,
const char *device,
unsigned int head,
const char *file);
-int qemuMonitorJSONBlockStream(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockStream(qemuMonitor *mon,
const char *device,
const char *jobname,
bool persistjob,
unsigned long long speed)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockJobCancel(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockJobCancel(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-qemuMonitorJSONGetJobInfo(qemuMonitorPtr mon,
- qemuMonitorJobInfoPtr **jobs,
+qemuMonitorJSONGetJobInfo(qemuMonitor *mon,
+ qemuMonitorJobInfo ***jobs,
size_t *njobs);
-int qemuMonitorJSONBlockJobSetSpeed(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockJobSetSpeed(qemuMonitor *mon,
const char *jobname,
unsigned long long speed)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-GHashTable *qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
+GHashTable *qemuMonitorJSONGetAllBlockJobInfo(qemuMonitor *mon,
bool rawjobname)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONJobDismiss(qemuMonitorPtr mon,
+int qemuMonitorJSONJobDismiss(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONJobCancel(qemuMonitorPtr mon,
+int qemuMonitorJSONJobCancel(qemuMonitor *mon,
const char *jobname,
bool quiet)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONJobComplete(qemuMonitorPtr mon,
+int qemuMonitorJSONJobComplete(qemuMonitor *mon,
const char *jobname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONSetLink(qemuMonitorPtr mon,
+int qemuMonitorJSONSetLink(qemuMonitor *mon,
const char *name,
virDomainNetInterfaceLinkState state);
-int qemuMonitorJSONOpenGraphics(qemuMonitorPtr mon,
+int qemuMonitorJSONOpenGraphics(qemuMonitor *mon,
const char *protocol,
const char *fdname,
bool skipauth);
-int qemuMonitorJSONSetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorJSONSetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qomid,
- virDomainBlockIoTuneInfoPtr info,
+ virDomainBlockIoTuneInfo *info,
bool supportMaxOptions,
bool supportGroupNameOption,
bool supportMaxLengthOptions);
-int qemuMonitorJSONGetBlockIoThrottle(qemuMonitorPtr mon,
+int qemuMonitorJSONGetBlockIoThrottle(qemuMonitor *mon,
const char *drivealias,
const char *qdevid,
- virDomainBlockIoTuneInfoPtr reply);
+ virDomainBlockIoTuneInfo *reply);
-int qemuMonitorJSONSystemWakeup(qemuMonitorPtr mon);
+int qemuMonitorJSONSystemWakeup(qemuMonitor *mon);
-char *qemuMonitorJSONGetSEVMeasurement(qemuMonitorPtr mon);
+char *qemuMonitorJSONGetSEVMeasurement(qemuMonitor *mon);
-int qemuMonitorJSONGetVersion(qemuMonitorPtr mon,
+int qemuMonitorJSONGetVersion(qemuMonitor *mon,
int *major,
int *minor,
int *micro,
char **package)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-int qemuMonitorJSONGetMachines(qemuMonitorPtr mon,
- qemuMonitorMachineInfoPtr **machines)
+int qemuMonitorJSONGetMachines(qemuMonitor *mon,
+ qemuMonitorMachineInfo ***machines)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetCPUDefinitions(qemuMonitorPtr mon,
- qemuMonitorCPUDefsPtr *cpuDefs)
+int qemuMonitorJSONGetCPUDefinitions(qemuMonitor *mon,
+ qemuMonitorCPUDefs **cpuDefs)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetCPUModelExpansion(qemuMonitorPtr mon,
+int qemuMonitorJSONGetCPUModelExpansion(qemuMonitor *mon,
qemuMonitorCPUModelExpansionType type,
- virCPUDefPtr cpu,
+ virCPUDef *cpu,
bool migratable,
bool fail_no_props,
- qemuMonitorCPUModelInfoPtr *model_info)
+ qemuMonitorCPUModelInfo **model_info)
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(6);
-int qemuMonitorJSONGetCPUModelBaseline(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
- qemuMonitorCPUModelInfoPtr *baseline)
+int qemuMonitorJSONGetCPUModelBaseline(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
+ qemuMonitorCPUModelInfo **baseline)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-int qemuMonitorJSONGetCPUModelComparison(qemuMonitorPtr mon,
- virCPUDefPtr cpu_a,
- virCPUDefPtr cpu_b,
+int qemuMonitorJSONGetCPUModelComparison(qemuMonitor *mon,
+ virCPUDef *cpu_a,
+ virCPUDef *cpu_b,
char **result)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorJSONGetCommands(qemuMonitorPtr mon,
+int qemuMonitorJSONGetCommands(qemuMonitor *mon,
char ***commands)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetEvents(qemuMonitorPtr mon,
+int qemuMonitorJSONGetEvents(qemuMonitor *mon,
char ***events)
ATTRIBUTE_NONNULL(2);
-GHashTable *qemuMonitorJSONGetCommandLineOptions(qemuMonitorPtr mon);
+GHashTable *qemuMonitorJSONGetCommandLineOptions(qemuMonitor *mon);
-int qemuMonitorJSONGetKVMState(qemuMonitorPtr mon,
+int qemuMonitorJSONGetKVMState(qemuMonitor *mon,
bool *enabled,
bool *present)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorJSONGetObjectTypes(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectTypes(qemuMonitor *mon,
char ***types)
ATTRIBUTE_NONNULL(2);
/* ListPath structures and API's are public only for qemumonitorjsontest */
typedef struct _qemuMonitorJSONListPath qemuMonitorJSONListPath;
-typedef qemuMonitorJSONListPath *qemuMonitorJSONListPathPtr;
-
struct _qemuMonitorJSONListPath {
char *name;
char *type;
};
-int qemuMonitorJSONGetObjectListPaths(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectListPaths(qemuMonitor *mon,
const char *path,
- qemuMonitorJSONListPathPtr **paths)
+ qemuMonitorJSONListPath ***paths)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void qemuMonitorJSONListPathFree(qemuMonitorJSONListPathPtr paths);
+void qemuMonitorJSONListPathFree(qemuMonitorJSONListPath *paths);
/* ObjectProperty structures and Get/Set API's are public only
* for qemumonitorjsontest
} qemuMonitorJSONObjectPropertyType;
typedef struct _qemuMonitorJSONObjectProperty qemuMonitorJSONObjectProperty;
-typedef qemuMonitorJSONObjectProperty *qemuMonitorJSONObjectPropertyPtr;
struct _qemuMonitorJSONObjectProperty {
int type; /* qemuMonitorJSONObjectPropertyType */
union {
} val;
};
-int qemuMonitorJSONGetObjectProperty(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectProperty(qemuMonitor *mon,
const char *path,
const char *property,
- qemuMonitorJSONObjectPropertyPtr prop)
+ qemuMonitorJSONObjectProperty *prop)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-int qemuMonitorJSONSetObjectProperty(qemuMonitorPtr mon,
+int qemuMonitorJSONSetObjectProperty(qemuMonitor *mon,
const char *path,
const char *property,
- qemuMonitorJSONObjectPropertyPtr prop)
+ qemuMonitorJSONObjectProperty *prop)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-GHashTable *qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon,
+GHashTable *qemuMonitorJSONGetDeviceProps(qemuMonitor *mon,
const char *device)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetObjectProps(qemuMonitorPtr mon,
+int qemuMonitorJSONGetObjectProps(qemuMonitor *mon,
const char *object,
char ***props)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-char *qemuMonitorJSONGetTargetArch(qemuMonitorPtr mon);
+char *qemuMonitorJSONGetTargetArch(qemuMonitor *mon);
-int qemuMonitorJSONNBDServerStart(qemuMonitorPtr mon,
+int qemuMonitorJSONNBDServerStart(qemuMonitor *mon,
const virStorageNetHostDef *server,
const char *tls_alias);
-int qemuMonitorJSONNBDServerAdd(qemuMonitorPtr mon,
+int qemuMonitorJSONNBDServerAdd(qemuMonitor *mon,
const char *deviceID,
const char *export,
bool writable,
const char *bitmap);
-int qemuMonitorJSONNBDServerStop(qemuMonitorPtr mon);
+int qemuMonitorJSONNBDServerStop(qemuMonitor *mon);
-int qemuMonitorJSONBlockExportAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props);
+int qemuMonitorJSONBlockExportAdd(qemuMonitor *mon,
+ virJSONValue **props);
-int qemuMonitorJSONGetTPMModels(qemuMonitorPtr mon,
+int qemuMonitorJSONGetTPMModels(qemuMonitor *mon,
char ***tpmmodels)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetTPMTypes(qemuMonitorPtr mon,
+int qemuMonitorJSONGetTPMTypes(qemuMonitor *mon,
char ***tpmtypes)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
+int qemuMonitorJSONAttachCharDev(qemuMonitor *mon,
const char *chrID,
- virDomainChrSourceDefPtr chr);
-int qemuMonitorJSONDetachCharDev(qemuMonitorPtr mon,
+ virDomainChrSourceDef *chr);
+int qemuMonitorJSONDetachCharDev(qemuMonitor *mon,
const char *chrID);
-int qemuMonitorJSONGetDeviceAliases(qemuMonitorPtr mon,
+int qemuMonitorJSONGetDeviceAliases(qemuMonitor *mon,
char ***aliases);
-int qemuMonitorJSONGetCPUx86Data(qemuMonitorPtr mon,
+int qemuMonitorJSONGetCPUx86Data(qemuMonitor *mon,
const char *property,
- virCPUDataPtr *cpudata);
+ virCPUData **cpudata);
-int qemuMonitorJSONGetGuestCPUx86(qemuMonitorPtr mon,
- virCPUDataPtr *data,
- virCPUDataPtr *disabled);
+int qemuMonitorJSONGetGuestCPUx86(qemuMonitor *mon,
+ virCPUData **data,
+ virCPUData **disabled);
-int qemuMonitorJSONGetGuestCPU(qemuMonitorPtr mon,
+int qemuMonitorJSONGetGuestCPU(qemuMonitor *mon,
virArch arch,
qemuMonitorCPUFeatureTranslationCallback translate,
void *opaque,
- virCPUDataPtr *enabled,
- virCPUDataPtr *disabled);
+ virCPUData **enabled,
+ virCPUData **disabled);
-int qemuMonitorJSONRTCResetReinjection(qemuMonitorPtr mon);
+int qemuMonitorJSONRTCResetReinjection(qemuMonitor *mon);
-int qemuMonitorJSONGetIOThreads(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr **iothreads,
+int qemuMonitorJSONGetIOThreads(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo ***iothreads,
int *niothreads)
ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONSetIOThread(qemuMonitorPtr mon,
- qemuMonitorIOThreadInfoPtr iothreadInfo)
+int qemuMonitorJSONSetIOThread(qemuMonitor *mon,
+ qemuMonitorIOThreadInfo *iothreadInfo)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitor *mon,
GHashTable *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONFindLinkPath(qemuMonitorPtr mon,
+int qemuMonitorJSONFindLinkPath(qemuMonitor *mon,
const char *name,
const char *alias,
char **path)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4);
-int qemuMonitorJSONMigrateIncoming(qemuMonitorPtr mon,
+int qemuMonitorJSONMigrateIncoming(qemuMonitor *mon,
const char *uri)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONMigrateStartPostCopy(qemuMonitorPtr mon)
+int qemuMonitorJSONMigrateStartPostCopy(qemuMonitor *mon)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONMigrateContinue(qemuMonitorPtr mon,
+int qemuMonitorJSONMigrateContinue(qemuMonitor *mon,
qemuMonitorMigrationStatus status)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONGetRTCTime(qemuMonitorPtr mon,
+int qemuMonitorJSONGetRTCTime(qemuMonitor *mon,
struct tm *tm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONGetHotpluggableCPUs(qemuMonitorPtr mon,
+int qemuMonitorJSONGetHotpluggableCPUs(qemuMonitor *mon,
struct qemuMonitorQueryHotpluggableCpusEntry **entries,
size_t *nentries)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-virJSONValuePtr qemuMonitorJSONQueryQMPSchema(qemuMonitorPtr mon)
+virJSONValue *qemuMonitorJSONQueryQMPSchema(qemuMonitor *mon)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONSetBlockThreshold(qemuMonitorPtr mon,
+int qemuMonitorJSONSetBlockThreshold(qemuMonitor *mon,
const char *nodename,
unsigned long long threshold)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-virJSONValuePtr qemuMonitorJSONQueryNamedBlockNodes(qemuMonitorPtr mon,
+virJSONValue *qemuMonitorJSONQueryNamedBlockNodes(qemuMonitor *mon,
bool flat)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONSetWatchdogAction(qemuMonitorPtr mon,
+int qemuMonitorJSONSetWatchdogAction(qemuMonitor *mon,
const char *action)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONBlockdevCreate(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevCreate(qemuMonitor *mon,
const char *jobname,
- virJSONValuePtr props)
+ virJSONValue *props)
ATTRIBUTE_NONNULL(1);
-int qemuMonitorJSONBlockdevAdd(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+int qemuMonitorJSONBlockdevAdd(qemuMonitor *mon,
+ virJSONValue **props)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevReopen(qemuMonitorPtr mon,
- virJSONValuePtr *props)
+int qemuMonitorJSONBlockdevReopen(qemuMonitor *mon,
+ virJSONValue **props)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevDel(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevDel(qemuMonitor *mon,
const char *nodename)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevTrayOpen(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevTrayOpen(qemuMonitor *mon,
const char *id,
bool force)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevTrayClose(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevTrayClose(qemuMonitor *mon,
const char *id)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevMediumRemove(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevMediumRemove(qemuMonitor *mon,
const char *id)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuMonitorJSONBlockdevMediumInsert(qemuMonitorPtr mon,
+int qemuMonitorJSONBlockdevMediumInsert(qemuMonitor *mon,
const char *id,
const char *nodename)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int qemuMonitorJSONGetPRManagerInfo(qemuMonitorPtr mon,
+int qemuMonitorJSONGetPRManagerInfo(qemuMonitor *mon,
GHashTable *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-qemuMonitorJSONGetCurrentMachineInfo(qemuMonitorPtr mon,
- qemuMonitorCurrentMachineInfoPtr info)
+qemuMonitorJSONGetCurrentMachineInfo(qemuMonitor *mon,
+ qemuMonitorCurrentMachineInfo *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-qemuMonitorJSONTransactionBitmapAdd(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapAdd(virJSONValue *actions,
const char *node,
const char *name,
bool persistent,
bool disabled,
unsigned long long granularity);
int
-qemuMonitorJSONTransactionBitmapRemove(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapRemove(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorJSONBitmapRemove(qemuMonitorPtr mon,
+qemuMonitorJSONBitmapRemove(qemuMonitor *mon,
const char *node,
const char *name);
int
-qemuMonitorJSONTransactionBitmapEnable(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapEnable(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorJSONTransactionBitmapDisable(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapDisable(virJSONValue *actions,
const char *node,
const char *name);
int
-qemuMonitorJSONTransactionBitmapMerge(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBitmapMerge(virJSONValue *actions,
const char *node,
const char *target,
- virJSONValuePtr *sources);
+ virJSONValue **sources);
int
-qemuMonitorJSONTransactionBitmapMergeSourceAddBitmap(virJSONValuePtr sources,
+qemuMonitorJSONTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
const char *sourcenode,
const char *sourcebitmap);
int
-qemuMonitorJSONTransactionSnapshotLegacy(virJSONValuePtr actions,
+qemuMonitorJSONTransactionSnapshotLegacy(virJSONValue *actions,
const char *device,
const char *path,
const char *format,
bool existing);
int
-qemuMonitorJSONTransactionSnapshotBlockdev(virJSONValuePtr actions,
+qemuMonitorJSONTransactionSnapshotBlockdev(virJSONValue *actions,
const char *node,
const char *overlay);
int
-qemuMonitorJSONTransactionBackup(virJSONValuePtr actions,
+qemuMonitorJSONTransactionBackup(virJSONValue *actions,
const char *device,
const char *jobname,
const char *target,
const char *bitmap,
qemuMonitorTransactionBackupSyncMode syncmode);
-int qemuMonitorJSONSetDBusVMStateIdList(qemuMonitorPtr mon,
+int qemuMonitorJSONSetDBusVMStateIdList(qemuMonitor *mon,
const char *vmstatepath,
const char *idstr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
-qemuMonitorJSONGetCPUMigratable(qemuMonitorPtr mon,
+qemuMonitorJSONGetCPUMigratable(qemuMonitor *mon,
bool *migratable);
int
-qemuMonitorJSONStartDirtyRateCalc(qemuMonitorPtr mon,
+qemuMonitorJSONStartDirtyRateCalc(qemuMonitor *mon,
int seconds);
int
-qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
- qemuMonitorDirtyRateInfoPtr info);
+qemuMonitorJSONQueryDirtyRate(qemuMonitor *mon,
+ qemuMonitorDirtyRateInfo *info);
#include "qemu_monitor.h"
void
-qemuMonitorResetCommandID(qemuMonitorPtr mon);
+qemuMonitorResetCommandID(qemuMonitor *mon);
VIR_LOG_INIT("qemu.qemu_monitor_text");
-int qemuMonitorTextAddDrive(qemuMonitorPtr mon,
+int qemuMonitorTextAddDrive(qemuMonitor *mon,
const char *drivestr)
{
g_autofree char *cmd = NULL;
}
-int qemuMonitorTextDriveDel(qemuMonitorPtr mon,
+int qemuMonitorTextDriveDel(qemuMonitor *mon,
const char *drivestr)
{
g_autofree char *cmd = NULL;
}
int
-qemuMonitorTextCreateSnapshot(qemuMonitorPtr mon,
+qemuMonitorTextCreateSnapshot(qemuMonitor *mon,
const char *name)
{
g_autofree char *cmd = NULL;
return 0;
}
-int qemuMonitorTextLoadSnapshot(qemuMonitorPtr mon, const char *name)
+int qemuMonitorTextLoadSnapshot(qemuMonitor *mon, const char *name)
{
g_autofree char *cmd = NULL;
g_autofree char *reply = NULL;
return 0;
}
-int qemuMonitorTextDeleteSnapshot(qemuMonitorPtr mon, const char *name)
+int qemuMonitorTextDeleteSnapshot(qemuMonitor *mon, const char *name)
{
g_autofree char *cmd = NULL;
g_autofree char *reply = NULL;
#include "qemu_monitor.h"
-int qemuMonitorTextAddDrive(qemuMonitorPtr mon,
+int qemuMonitorTextAddDrive(qemuMonitor *mon,
const char *drivestr);
-int qemuMonitorTextDriveDel(qemuMonitorPtr mon,
+int qemuMonitorTextDriveDel(qemuMonitor *mon,
const char *drivestr);
-int qemuMonitorTextCreateSnapshot(qemuMonitorPtr mon, const char *name);
-int qemuMonitorTextLoadSnapshot(qemuMonitorPtr mon, const char *name);
-int qemuMonitorTextDeleteSnapshot(qemuMonitorPtr mon, const char *name);
+int qemuMonitorTextCreateSnapshot(qemuMonitor *mon, const char *name);
+int qemuMonitorTextLoadSnapshot(qemuMonitor *mon, const char *name);
+int qemuMonitorTextDeleteSnapshot(qemuMonitor *mon, const char *name);
* NULL on failure.
*/
static char *
-qemuDomainGetPreservedMountPath(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuDomainGetPreservedMountPath(virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
const char *mountpoint)
{
char *path = NULL;
* Returns 0 on success, -1 otherwise (with error reported)
*/
static int
-qemuDomainGetPreservedMounts(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuDomainGetPreservedMounts(virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
char ***devPath,
char ***devSavePath,
size_t *ndevPath)
static int
-qemuDomainPopulateDevices(virQEMUDriverConfigPtr cfg,
+qemuDomainPopulateDevices(virQEMUDriverConfig *cfg,
GSList **paths)
{
const char *const *devices = (const char *const *) cfg->cgroupDeviceACL;
static int
-qemuDomainSetupDev(virSecurityManagerPtr mgr,
- virDomainObjPtr vm,
+qemuDomainSetupDev(virSecurityManager *mgr,
+ virDomainObj *vm,
const char *path)
{
g_autofree char *mount_options = NULL;
static int
-qemuDomainSetupDisk(virStorageSourcePtr src,
+qemuDomainSetupDisk(virStorageSource *src,
GSList **paths)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
bool hasNVMe = false;
for (next = src; virStorageSourceIsBacking(next); next = next->backingStore) {
static int
-qemuDomainSetupAllDisks(virDomainObjPtr vm,
+qemuDomainSetupAllDisks(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev,
+qemuDomainSetupHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev,
bool hotplug,
GSList **paths)
{
static int
-qemuDomainSetupAllHostdevs(virDomainObjPtr vm,
+qemuDomainSetupAllHostdevs(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupMemory(virDomainMemoryDefPtr mem,
+qemuDomainSetupMemory(virDomainMemoryDef *mem,
GSList **paths)
{
if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
static int
-qemuDomainSetupAllMemories(virDomainObjPtr vm,
+qemuDomainSetupAllMemories(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupChardev(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrDefPtr dev,
+qemuDomainSetupChardev(virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrDef *dev,
void *opaque)
{
GSList **paths = opaque;
static int
-qemuDomainSetupAllChardevs(virDomainObjPtr vm,
+qemuDomainSetupAllChardevs(virDomainObj *vm,
GSList **paths)
{
VIR_DEBUG("Setting up chardevs");
static int
-qemuDomainSetupTPM(virDomainTPMDefPtr dev,
+qemuDomainSetupTPM(virDomainTPMDef *dev,
GSList **paths)
{
switch (dev->type) {
static int
-qemuDomainSetupAllTPMs(virDomainObjPtr vm,
+qemuDomainSetupAllTPMs(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupGraphics(virDomainGraphicsDefPtr gfx,
+qemuDomainSetupGraphics(virDomainGraphicsDef *gfx,
GSList **paths)
{
const char *rendernode = virDomainGraphicsGetRenderNode(gfx);
static int
-qemuDomainSetupAllGraphics(virDomainObjPtr vm,
+qemuDomainSetupAllGraphics(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupInput(virDomainInputDefPtr input,
+qemuDomainSetupInput(virDomainInputDef *input,
GSList **paths)
{
const char *path = virDomainInputDefGetPath(input);
static int
-qemuDomainSetupAllInputs(virDomainObjPtr vm,
+qemuDomainSetupAllInputs(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupRNG(virDomainRNGDefPtr rng,
+qemuDomainSetupRNG(virDomainRNGDef *rng,
GSList **paths)
{
switch ((virDomainRNGBackend) rng->backend) {
static int
-qemuDomainSetupAllRNGs(virDomainObjPtr vm,
+qemuDomainSetupAllRNGs(virDomainObj *vm,
GSList **paths)
{
size_t i;
static int
-qemuDomainSetupLoader(virDomainObjPtr vm,
+qemuDomainSetupLoader(virDomainObj *vm,
GSList **paths)
{
- virDomainLoaderDefPtr loader = vm->def->os.loader;
+ virDomainLoaderDef *loader = vm->def->os.loader;
VIR_DEBUG("Setting up loader");
static int
-qemuDomainSetupLaunchSecurity(virDomainObjPtr vm,
+qemuDomainSetupLaunchSecurity(virDomainObj *vm,
GSList **paths)
{
- virDomainSEVDefPtr sev = vm->def->sev;
+ virDomainSEVDef *sev = vm->def->sev;
if (!sev || sev->sectype != VIR_DOMAIN_LAUNCH_SECURITY_SEV)
return 0;
static int
-qemuNamespaceMknodPaths(virDomainObjPtr vm,
+qemuNamespaceMknodPaths(virDomainObj *vm,
GSList *paths);
int
-qemuDomainBuildNamespace(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm)
+qemuDomainBuildNamespace(virQEMUDriverConfig *cfg,
+ virDomainObj *vm)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainUnshareNamespace(virQEMUDriverConfigPtr cfg,
- virSecurityManagerPtr mgr,
- virDomainObjPtr vm)
+qemuDomainUnshareNamespace(virQEMUDriverConfig *cfg,
+ virSecurityManager *mgr,
+ virDomainObj *vm)
{
const char *devPath = NULL;
char **devMountsPath = NULL, **devMountsSavePath = NULL;
bool
-qemuDomainNamespaceEnabled(virDomainObjPtr vm,
+qemuDomainNamespaceEnabled(virDomainObj *vm,
qemuDomainNamespace ns)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
return priv->namespaces &&
virBitmapIsBitSet(priv->namespaces, ns);
int
-qemuDomainEnableNamespace(virDomainObjPtr vm,
+qemuDomainEnableNamespace(virDomainObj *vm,
qemuDomainNamespace ns)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!priv->namespaces)
priv->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST);
static void
-qemuDomainDisableNamespace(virDomainObjPtr vm,
+qemuDomainDisableNamespace(virDomainObj *vm,
qemuDomainNamespace ns)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->namespaces) {
ignore_value(virBitmapClearBit(priv->namespaces, ns));
void
-qemuDomainDestroyNamespace(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr vm)
+qemuDomainDestroyNamespace(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *vm)
{
if (qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
qemuDomainDisableNamespace(vm, QEMU_DOMAIN_NS_MOUNT);
typedef struct _qemuNamespaceMknodItem qemuNamespaceMknodItem;
-typedef qemuNamespaceMknodItem *qemuNamespaceMknodItemPtr;
struct _qemuNamespaceMknodItem {
char *file;
char *target;
};
typedef struct _qemuNamespaceMknodData qemuNamespaceMknodData;
-typedef qemuNamespaceMknodData *qemuNamespaceMknodDataPtr;
struct _qemuNamespaceMknodData {
- virQEMUDriverPtr driver;
- virDomainObjPtr vm;
- qemuNamespaceMknodItemPtr items;
+ virQEMUDriver *driver;
+ virDomainObj *vm;
+ qemuNamespaceMknodItem *items;
size_t nitems;
};
static void
-qemuNamespaceMknodItemClear(qemuNamespaceMknodItemPtr item)
+qemuNamespaceMknodItemClear(qemuNamespaceMknodItem *item)
{
VIR_FREE(item->file);
VIR_FREE(item->target);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(qemuNamespaceMknodItem, qemuNamespaceMknodItemClear);
static void
-qemuNamespaceMknodDataClear(qemuNamespaceMknodDataPtr data)
+qemuNamespaceMknodDataClear(qemuNamespaceMknodData *data)
{
size_t i;
for (i = 0; i < data->nitems; i++) {
- qemuNamespaceMknodItemPtr item = &data->items[i];
+ qemuNamespaceMknodItem *item = &data->items[i];
qemuNamespaceMknodItemClear(item);
}
/* Our way of creating devices is highly linux specific */
#if defined(__linux__)
static int
-qemuNamespaceMknodOne(qemuNamespaceMknodItemPtr data)
+qemuNamespaceMknodOne(qemuNamespaceMknodItem *data)
{
int ret = -1;
bool delDevice = false;
qemuNamespaceMknodHelper(pid_t pid G_GNUC_UNUSED,
void *opaque)
{
- qemuNamespaceMknodDataPtr data = opaque;
+ qemuNamespaceMknodData *data = opaque;
size_t i;
int ret = -1;
static int
-qemuNamespaceMknodItemInit(qemuNamespaceMknodItemPtr item,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuNamespaceMknodItemInit(qemuNamespaceMknodItem *item,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
const char *file)
{
g_autofree char *target = NULL;
static int
-qemuNamespacePrepareOneItem(qemuNamespaceMknodDataPtr data,
- virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm,
+qemuNamespacePrepareOneItem(qemuNamespaceMknodData *data,
+ virQEMUDriverConfig *cfg,
+ virDomainObj *vm,
const char *file,
char * const *devMountsPath,
size_t ndevMountsPath)
static int
-qemuNamespaceMknodPaths(virDomainObjPtr vm,
+qemuNamespaceMknodPaths(virDomainObj *vm,
GSList *paths)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
char **devMountsPath = NULL;
size_t ndevMountsPath = 0;
}
for (i = 0; i < data.nitems; i++) {
- qemuNamespaceMknodItemPtr item = &data.items[i];
+ qemuNamespaceMknodItem *item = &data.items[i];
if (item->target &&
qemuNamespaceMknodItemNeedsBindMount(item->sb.st_mode)) {
if (virFileBindMountDevice(item->file, item->target) < 0)
static int
-qemuNamespaceMknodPaths(virDomainObjPtr vm G_GNUC_UNUSED,
+qemuNamespaceMknodPaths(virDomainObj *vm G_GNUC_UNUSED,
GSList *paths G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
static int
-qemuNamespaceUnlinkPaths(virDomainObjPtr vm,
+qemuNamespaceUnlinkPaths(virDomainObj *vm,
GSList *paths)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
g_auto(GStrv) devMountsPath = NULL;
g_autoptr(virGSListString) unlinkPaths = NULL;
int
-qemuDomainNamespaceSetupDisk(virDomainObjPtr vm,
- virStorageSourcePtr src)
+qemuDomainNamespaceSetupDisk(virDomainObj *vm,
+ virStorageSource *src)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceTeardownDisk(virDomainObjPtr vm G_GNUC_UNUSED,
- virStorageSourcePtr src G_GNUC_UNUSED)
+qemuDomainNamespaceTeardownDisk(virDomainObj *vm G_GNUC_UNUSED,
+ virStorageSource *src G_GNUC_UNUSED)
{
/* While in hotplug case we create the whole backing chain,
* here we must limit ourselves. The disk we want to remove
* -1 otherwise.
*/
int
-qemuDomainNamespaceSetupHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainNamespaceSetupHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
g_autoptr(virGSListString) paths = NULL;
* -1 otherwise.
*/
int
-qemuDomainNamespaceTeardownHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuDomainNamespaceTeardownHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceSetupMemory(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainNamespaceSetupMemory(virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceTeardownMemory(virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuDomainNamespaceTeardownMemory(virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceSetupChardev(virDomainObjPtr vm,
- virDomainChrDefPtr chr)
+qemuDomainNamespaceSetupChardev(virDomainObj *vm,
+ virDomainChrDef *chr)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceTeardownChardev(virDomainObjPtr vm,
- virDomainChrDefPtr chr)
+qemuDomainNamespaceTeardownChardev(virDomainObj *vm,
+ virDomainChrDef *chr)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceSetupRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuDomainNamespaceSetupRNG(virDomainObj *vm,
+ virDomainRNGDef *rng)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceTeardownRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr rng)
+qemuDomainNamespaceTeardownRNG(virDomainObj *vm,
+ virDomainRNGDef *rng)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceSetupInput(virDomainObjPtr vm,
- virDomainInputDefPtr input)
+qemuDomainNamespaceSetupInput(virDomainObj *vm,
+ virDomainInputDef *input)
{
g_autoptr(virGSListString) paths = NULL;
int
-qemuDomainNamespaceTeardownInput(virDomainObjPtr vm,
- virDomainInputDefPtr input)
+qemuDomainNamespaceTeardownInput(virDomainObj *vm,
+ virDomainInputDef *input)
{
g_autoptr(virGSListString) paths = NULL;
} qemuDomainNamespace;
VIR_ENUM_DECL(qemuDomainNamespace);
-int qemuDomainEnableNamespace(virDomainObjPtr vm,
+int qemuDomainEnableNamespace(virDomainObj *vm,
qemuDomainNamespace ns);
-bool qemuDomainNamespaceEnabled(virDomainObjPtr vm,
+bool qemuDomainNamespaceEnabled(virDomainObj *vm,
qemuDomainNamespace ns);
-int qemuDomainUnshareNamespace(virQEMUDriverConfigPtr cfg,
- virSecurityManagerPtr mgr,
- virDomainObjPtr vm);
+int qemuDomainUnshareNamespace(virQEMUDriverConfig *cfg,
+ virSecurityManager *mgr,
+ virDomainObj *vm);
-int qemuDomainBuildNamespace(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm);
+int qemuDomainBuildNamespace(virQEMUDriverConfig *cfg,
+ virDomainObj *vm);
-void qemuDomainDestroyNamespace(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuDomainDestroyNamespace(virQEMUDriver *driver,
+ virDomainObj *vm);
bool qemuDomainNamespaceAvailable(qemuDomainNamespace ns);
-int qemuDomainNamespaceSetupDisk(virDomainObjPtr vm,
- virStorageSourcePtr src);
+int qemuDomainNamespaceSetupDisk(virDomainObj *vm,
+ virStorageSource *src);
-int qemuDomainNamespaceTeardownDisk(virDomainObjPtr vm,
- virStorageSourcePtr src);
+int qemuDomainNamespaceTeardownDisk(virDomainObj *vm,
+ virStorageSource *src);
-int qemuDomainNamespaceSetupHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
+int qemuDomainNamespaceSetupHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
-int qemuDomainNamespaceTeardownHostdev(virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
+int qemuDomainNamespaceTeardownHostdev(virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
-int qemuDomainNamespaceSetupMemory(virDomainObjPtr vm,
- virDomainMemoryDefPtr memory);
+int qemuDomainNamespaceSetupMemory(virDomainObj *vm,
+ virDomainMemoryDef *memory);
-int qemuDomainNamespaceTeardownMemory(virDomainObjPtr vm,
- virDomainMemoryDefPtr memory);
+int qemuDomainNamespaceTeardownMemory(virDomainObj *vm,
+ virDomainMemoryDef *memory);
-int qemuDomainNamespaceSetupChardev(virDomainObjPtr vm,
- virDomainChrDefPtr chr);
+int qemuDomainNamespaceSetupChardev(virDomainObj *vm,
+ virDomainChrDef *chr);
-int qemuDomainNamespaceTeardownChardev(virDomainObjPtr vm,
- virDomainChrDefPtr chr);
+int qemuDomainNamespaceTeardownChardev(virDomainObj *vm,
+ virDomainChrDef *chr);
-int qemuDomainNamespaceSetupRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr rng);
+int qemuDomainNamespaceSetupRNG(virDomainObj *vm,
+ virDomainRNGDef *rng);
-int qemuDomainNamespaceTeardownRNG(virDomainObjPtr vm,
- virDomainRNGDefPtr rng);
+int qemuDomainNamespaceTeardownRNG(virDomainObj *vm,
+ virDomainRNGDef *rng);
-int qemuDomainNamespaceSetupInput(virDomainObjPtr vm,
- virDomainInputDefPtr input);
+int qemuDomainNamespaceSetupInput(virDomainObj *vm,
+ virDomainInputDef *input);
-int qemuDomainNamespaceTeardownInput(virDomainObjPtr vm,
- virDomainInputDefPtr input);
+int qemuDomainNamespaceTeardownInput(virDomainObj *vm,
+ virDomainInputDef *input);
* remove all state files of a domain from statedir
*/
static void
-qemuProcessRemoveDomainStatus(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessRemoveDomainStatus(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autofree char *file = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
file = g_strdup_printf("%s/%s.xml", cfg->stateDir, vm->def->name);
/*
- * This is a callback registered with a qemuAgentPtr instance,
+ * This is a callback registered with a qemuAgent *instance,
* and to be invoked when the agent console hits an end of file
* condition, or error, thus indicating VM shutdown should be
* performed
*/
static void
-qemuProcessHandleAgentEOF(qemuAgentPtr agent,
- virDomainObjPtr vm)
+qemuProcessHandleAgentEOF(qemuAgent *agent,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
VIR_DEBUG("Received EOF from agent on %p '%s'", vm, vm->def->name);
* allowed
*/
static void
-qemuProcessHandleAgentError(qemuAgentPtr agent G_GNUC_UNUSED,
- virDomainObjPtr vm)
+qemuProcessHandleAgentError(qemuAgent *agent G_GNUC_UNUSED,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
VIR_DEBUG("Received error from agent on %p '%s'", vm, vm->def->name);
virObjectUnlock(vm);
}
-static void qemuProcessHandleAgentDestroy(qemuAgentPtr agent,
- virDomainObjPtr vm)
+static void qemuProcessHandleAgentDestroy(qemuAgent *agent,
+ virDomainObj *vm)
{
VIR_DEBUG("Received destroy agent=%p vm=%p", agent, vm);
int
-qemuConnectAgent(virQEMUDriverPtr driver, virDomainObjPtr vm)
+qemuConnectAgent(virQEMUDriver *driver, virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuAgentPtr agent = NULL;
- virDomainChrDefPtr config = qemuFindAgentConfig(vm->def);
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuAgent *agent = NULL;
+ virDomainChrDef *config = qemuFindAgentConfig(vm->def);
if (!config)
return 0;
/*
- * This is a callback registered with a qemuMonitorPtr instance,
+ * This is a callback registered with a qemuMonitor *instance,
* and to be invoked when the monitor console hits an end of file
* condition, or error, thus indicating VM shutdown should be
* performed
*/
static void
-qemuProcessHandleMonitorEOF(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+qemuProcessHandleMonitorEOF(qemuMonitor *mon,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv;
struct qemuProcessEvent *processEvent;
virObjectLock(vm);
* allowed
*/
static void
-qemuProcessHandleMonitorError(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleMonitorError(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
virObjectLock(vm);
- ((qemuDomainObjPrivatePtr) vm->privateData)->monError = true;
+ ((qemuDomainObjPrivate *) vm->privateData)->monError = true;
event = virDomainEventControlErrorNewFromObj(vm);
virObjectEventStateQueue(driver->domainEventState, event);
*
* Returns a disk from @vm or NULL if it could not be found.
*/
-virDomainDiskDefPtr
-qemuProcessFindDomainDiskByAliasOrQOM(virDomainObjPtr vm,
+virDomainDiskDef *
+qemuProcessFindDomainDiskByAliasOrQOM(virDomainObj *vm,
const char *alias,
const char *qomid)
{
alias = qemuAliasDiskDriveSkipPrefix(alias);
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
if ((disk->info.alias && STREQ_NULLABLE(disk->info.alias, alias)) ||
(diskPriv->qomName && STREQ_NULLABLE(diskPriv->qomName, qomid)))
static int
-qemuProcessHandleReset(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleReset(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event;
+ qemuDomainObjPrivate *priv;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int ret = -1;
static void
qemuProcessFakeReboot(void *opaque)
{
- virDomainObjPtr vm = opaque;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ virDomainObj *vm = opaque;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virDomainRunningReason reason = VIR_DOMAIN_RUNNING_BOOTED;
int ret = -1, rc;
void
-qemuProcessShutdownOrReboot(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessShutdownOrReboot(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->fakeReboot) {
g_autofree char *name = g_strdup_printf("reboot-%s", vm->def->name);
static int
-qemuProcessHandleEvent(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleEvent(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *eventName,
long long seconds,
unsigned int micros,
const char *details,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
VIR_DEBUG("vm=%p", vm);
static int
-qemuProcessHandleShutdown(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleShutdown(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
virTristateBool guest_initiated,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int detail = 0;
static int
-qemuProcessHandleStop(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
virDomainPausedReason reason;
virDomainEventSuspendedDetailType detail;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virObjectLock(vm);
static int
-qemuProcessHandleResume(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleResume(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
virDomainRunningReason reason = VIR_DOMAIN_RUNNING_UNPAUSED;
virDomainEventResumedDetailType eventDetail;
}
static int
-qemuProcessHandleRTCChange(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleRTCChange(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
long long offset,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
static int
-qemuProcessHandleWatchdog(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleWatchdog(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
int action,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr watchdogEvent = NULL;
- virObjectEventPtr lifecycleEvent = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *watchdogEvent = NULL;
+ virObjectEvent *lifecycleEvent = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE &&
virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Transitioned guest %s to paused state due to watchdog", vm->def->name);
virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_WATCHDOG);
static int
-qemuProcessHandleIOError(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleIOError(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *diskAlias,
const char *nodename,
int action,
const char *reason,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr ioErrorEvent = NULL;
- virObjectEventPtr ioErrorEvent2 = NULL;
- virObjectEventPtr lifecycleEvent = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *ioErrorEvent = NULL;
+ virObjectEvent *ioErrorEvent2 = NULL;
+ virObjectEvent *lifecycleEvent = NULL;
const char *srcPath;
const char *devAlias;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
if (action == VIR_DOMAIN_EVENT_IO_ERROR_PAUSE &&
virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Transitioned guest %s to paused state due to IO error", vm->def->name);
if (priv->signalIOError)
}
static int
-qemuProcessHandleBlockJob(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleBlockJob(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *diskAlias,
int type,
int status,
const char *error,
void *opaque)
{
- qemuDomainObjPrivatePtr priv;
- virQEMUDriverPtr driver = opaque;
+ qemuDomainObjPrivate *priv;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent = NULL;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
g_autoptr(qemuBlockJobData) job = NULL;
char *data = NULL;
static int
-qemuProcessHandleJobStatusChange(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleJobStatusChange(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *jobname,
int status,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv;
struct qemuProcessEvent *processEvent = NULL;
- qemuBlockJobDataPtr job = NULL;
+ qemuBlockJobData *job = NULL;
int jobnewstate;
virObjectLock(vm);
static int
-qemuProcessHandleGraphics(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleGraphics(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
int phase,
int localFamily,
const char *localNode,
const char *saslUsername,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event;
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
virDomainEventGraphicsSubjectPtr subject = NULL;
}
static int
-qemuProcessHandleTrayChange(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleTrayChange(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *devAlias,
const char *devid,
int reason,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
- virDomainDiskDefPtr disk;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
+ virDomainDiskDef *disk;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
}
static int
-qemuProcessHandlePMWakeup(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandlePMWakeup(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
- virObjectEventPtr lifecycleEvent = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
+ virObjectEvent *lifecycleEvent = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
}
static int
-qemuProcessHandlePMSuspend(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandlePMSuspend(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
- virObjectEventPtr lifecycleEvent = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
+ virObjectEvent *lifecycleEvent = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
event = virDomainEventPMSuspendNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Transitioned guest %s to pmsuspended state due to "
"QMP suspend event", vm->def->name);
}
static int
-qemuProcessHandleBalloonChange(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleBalloonChange(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
unsigned long long actual,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
}
static int
-qemuProcessHandlePMSuspendDisk(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandlePMSuspendDisk(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
- virObjectEventPtr lifecycleEvent = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
+ virObjectEvent *lifecycleEvent = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
event = virDomainEventPMSuspendDiskNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Transitioned guest %s to pmsuspended state due to "
"QMP suspend_disk event", vm->def->name);
static int
-qemuProcessHandleGuestPanic(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
- qemuMonitorEventPanicInfoPtr info,
+qemuProcessHandleGuestPanic(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
+ qemuMonitorEventPanicInfo *info,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent;
virObjectLock(vm);
int
-qemuProcessHandleDeviceDeleted(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleDeviceDeleted(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *devAlias,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent = NULL;
char *data;
* devices.
*/
static int
-qemuProcessHandleAcpiOstInfo(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleAcpiOstInfo(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *alias,
const char *slotType,
const char *slot,
unsigned int status,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
virObjectLock(vm);
static int
-qemuProcessHandleBlockThreshold(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleBlockThreshold(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *nodename,
unsigned long long threshold,
unsigned long long excess,
void *opaque)
{
- qemuDomainObjPrivatePtr priv;
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr eventSource = NULL;
- virObjectEventPtr eventDevice = NULL;
- virDomainDiskDefPtr disk;
- virStorageSourcePtr src;
+ qemuDomainObjPrivate *priv;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *eventSource = NULL;
+ virObjectEvent *eventDevice = NULL;
+ virDomainDiskDef *disk;
+ virStorageSource *src;
const char *path = NULL;
virObjectLock(vm);
static int
-qemuProcessHandleNicRxFilterChanged(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleNicRxFilterChanged(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *devAlias,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent = NULL;
char *data;
static int
-qemuProcessHandleSerialChanged(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleSerialChanged(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *devAlias,
bool connected,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent = NULL;
char *data;
static int
-qemuProcessHandleSpiceMigrated(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleSpiceMigrated(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque G_GNUC_UNUSED)
{
- qemuDomainObjPrivatePtr priv;
- qemuDomainJobPrivatePtr jobPriv;
+ qemuDomainObjPrivate *priv;
+ qemuDomainJobPrivate *jobPriv;
virObjectLock(vm);
static int
-qemuProcessHandleMigrationStatus(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
int status,
void *opaque)
{
- qemuDomainObjPrivatePtr priv;
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ qemuDomainObjPrivate *priv;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int reason;
static int
-qemuProcessHandleMigrationPass(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleMigrationPass(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
int pass,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv;
virObjectLock(vm);
static int
-qemuProcessHandleDumpCompleted(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleDumpCompleted(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
int status,
- qemuMonitorDumpStatsPtr stats,
+ qemuMonitorDumpStats *stats,
const char *error,
void *opaque G_GNUC_UNUSED)
{
- qemuDomainObjPrivatePtr priv;
- qemuDomainJobPrivatePtr jobPriv;
+ qemuDomainObjPrivate *priv;
+ qemuDomainJobPrivate *jobPriv;
virObjectLock(vm);
static int
-qemuProcessHandlePRManagerStatusChanged(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandlePRManagerStatusChanged(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *prManager,
bool connected,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv;
struct qemuProcessEvent *processEvent = NULL;
const char *managedAlias = qemuDomainGetManagedPRAlias();
int ret = -1;
static int
-qemuProcessHandleRdmaGidStatusChanged(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleRdmaGidStatusChanged(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
const char *netdev,
bool gid_status,
unsigned long long subnet_prefix,
unsigned long long interface_id,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent = NULL;
- qemuMonitorRdmaGidStatusPtr info = NULL;
+ qemuMonitorRdmaGidStatus *info = NULL;
int ret = -1;
virObjectLock(vm);
static int
-qemuProcessHandleGuestCrashloaded(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
+qemuProcessHandleGuestCrashloaded(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
struct qemuProcessEvent *processEvent;
virObjectLock(vm);
static int
-qemuProcessHandleMemoryFailure(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm,
- qemuMonitorEventMemoryFailurePtr mfp,
+qemuProcessHandleMemoryFailure(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm,
+ qemuMonitorEventMemoryFailure *mfp,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ virObjectEvent *event = NULL;
virDomainMemoryFailureRecipientType recipient;
virDomainMemoryFailureActionType action;
unsigned int flags = 0;
};
static void
-qemuProcessMonitorReportLogError(qemuMonitorPtr mon,
+qemuProcessMonitorReportLogError(qemuMonitor *mon,
const char *msg,
void *opaque);
static void
qemuProcessMonitorLogFree(void *opaque)
{
- qemuDomainLogContextPtr logCtxt = opaque;
+ qemuDomainLogContext *logCtxt = opaque;
g_clear_object(&logCtxt);
}
static int
-qemuProcessInitMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessInitMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
int ret;
static int
-qemuConnectMonitor(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob,
- bool retry, qemuDomainLogContextPtr logCtxt)
+qemuConnectMonitor(virQEMUDriver *driver, virDomainObj *vm, int asyncJob,
+ bool retry, qemuDomainLogContext *logCtxt)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorPtr mon = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitor *mon = NULL;
unsigned long long timeout = 0;
if (qemuSecuritySetDaemonSocketLabel(driver->securityManager, vm->def) < 0) {
* Returns 0 on success or -1 on error
*/
static int
-qemuProcessReadLog(qemuDomainLogContextPtr logCtxt,
+qemuProcessReadLog(qemuDomainLogContext *logCtxt,
char **msg,
size_t max)
{
static int
-qemuProcessReportLogError(qemuDomainLogContextPtr logCtxt,
+qemuProcessReportLogError(qemuDomainLogContext *logCtxt,
const char *msgprefix)
{
g_autofree char *logmsg = NULL;
static void
-qemuProcessMonitorReportLogError(qemuMonitorPtr mon G_GNUC_UNUSED,
+qemuProcessMonitorReportLogError(qemuMonitor *mon G_GNUC_UNUSED,
const char *msg,
void *opaque)
{
- qemuDomainLogContextPtr logCtxt = opaque;
+ qemuDomainLogContext *logCtxt = opaque;
qemuProcessReportLogError(logCtxt, msg);
}
static int
-qemuProcessLookupPTYs(virDomainChrDefPtr *devices,
+qemuProcessLookupPTYs(virDomainChrDef **devices,
int count,
GHashTable *info)
{
for (i = 0; i < count; i++) {
g_autofree char *id = NULL;
- virDomainChrDefPtr chr = devices[i];
+ virDomainChrDef *chr = devices[i];
if (chr->source->type == VIR_DOMAIN_CHR_TYPE_PTY) {
- qemuMonitorChardevInfoPtr entry;
+ qemuMonitorChardevInfo *entry;
id = g_strdup_printf("char%s", chr->info.alias);
}
static int
-qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
+qemuProcessFindCharDevicePTYsMonitor(virDomainObj *vm,
GHashTable *info)
{
size_t i = 0;
/* For historical reasons, console[0] can be just an alias
* for serial[0]. That's why we need to update it as well. */
if (vm->def->nconsoles) {
- virDomainChrDefPtr chr = vm->def->consoles[0];
+ virDomainChrDef *chr = vm->def->consoles[0];
if (vm->def->nserials &&
chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
static void
-qemuProcessRefreshChannelVirtioState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRefreshChannelVirtioState(virQEMUDriver *driver,
+ virDomainObj *vm,
GHashTable *info,
int booted)
{
size_t i;
int agentReason = VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL;
- qemuMonitorChardevInfoPtr entry;
- virObjectEventPtr event = NULL;
+ qemuMonitorChardevInfo *entry;
+ virObjectEvent *event = NULL;
g_autofree char *id = NULL;
if (booted)
agentReason = VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED;
for (i = 0; i < vm->def->nchannels; i++) {
- virDomainChrDefPtr chr = vm->def->channels[i];
+ virDomainChrDef *chr = vm->def->channels[i];
if (chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO) {
VIR_FREE(id);
int
-qemuRefreshVirtioChannelState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuRefreshVirtioChannelState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
GHashTable *info = NULL;
int ret = -1;
static int
-qemuProcessRefreshPRManagerState(virDomainObjPtr vm,
+qemuProcessRefreshPRManagerState(virDomainObj *vm,
GHashTable *info)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorPRManagerInfoPtr prManagerInfo;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitorPRManagerInfo *prManagerInfo;
const char *managedAlias = qemuDomainGetManagedPRAlias();
if (!(prManagerInfo = virHashLookup(info, managedAlias))) {
static int
-qemuRefreshPRManagerState(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuRefreshPRManagerState(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
GHashTable *info = NULL;
int ret = -1;
static void
-qemuRefreshRTC(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuRefreshRTC(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
time_t now, then;
struct tm thenbits;
long localOffset;
}
int
-qemuProcessRefreshBalloonState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRefreshBalloonState(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
unsigned long long balloon;
static int
-qemuProcessWaitForMonitor(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessWaitForMonitor(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob,
- qemuDomainLogContextPtr logCtxt)
+ qemuDomainLogContext *logCtxt)
{
int ret = -1;
GHashTable *info = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool retry = true;
if (priv->qemuCaps &&
static int
-qemuProcessDetectIOThreadPIDs(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessDetectIOThreadPIDs(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuMonitorIOThreadInfoPtr *iothreads = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuMonitorIOThreadInfo **iothreads = NULL;
int niothreads = 0;
int ret = -1;
size_t i;
}
for (i = 0; i < niothreads; i++) {
- virDomainIOThreadIDDefPtr iothrid;
+ virDomainIOThreadIDDef *iothrid;
if (!(iothrid = virDomainIOThreadIDFind(vm->def,
iothreads[i]->iothread_id))) {
static int
-qemuProcessGetAllCpuAffinity(virBitmapPtr *cpumapRet)
+qemuProcessGetAllCpuAffinity(virBitmap **cpumapRet)
{
*cpumapRet = NULL;
*/
#if defined(WITH_SCHED_GETAFFINITY) || defined(WITH_BSD_CPU_AFFINITY)
static int
-qemuProcessInitCpuAffinity(virDomainObjPtr vm)
+qemuProcessInitCpuAffinity(virDomainObj *vm)
{
bool settingAll = false;
g_autoptr(virBitmap) cpumapToSet = NULL;
virDomainNumatuneMemMode mem_mode;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!vm->pid) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
if (virDomainNumaGetNodeCount(vm->def->numa) <= 1 &&
virDomainNumatuneGetMode(vm->def->numa, -1, &mem_mode) == 0 &&
mem_mode == VIR_DOMAIN_NUMATUNE_MEM_STRICT) {
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
if (virDomainNumatuneMaybeGetNodeset(vm->def->numa,
priv->autoNodeset,
}
#else /* !defined(WITH_SCHED_GETAFFINITY) && !defined(WITH_BSD_CPU_AFFINITY) */
static int
-qemuProcessInitCpuAffinity(virDomainObjPtr vm G_GNUC_UNUSED)
+qemuProcessInitCpuAffinity(virDomainObj *vm G_GNUC_UNUSED)
{
return 0;
}
/* set link states to down on interfaces at qemu start */
static int
-qemuProcessSetLinkStates(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessSetLinkStates(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *def = vm->def;
size_t i;
int ret = -1;
int rv;
* Returns 0 on success, -1 on error.
*/
static int
-qemuProcessSetupPid(virDomainObjPtr vm,
+qemuProcessSetupPid(virDomainObj *vm,
pid_t pid,
virCgroupThreadName nameval,
int id,
- virBitmapPtr cpumask,
+ virBitmap *cpumask,
unsigned long long period,
long long quota,
- virDomainThreadSchedParamPtr sched)
+ virDomainThreadSchedParam *sched)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainNumatuneMemMode mem_mode;
- virCgroupPtr cgroup = NULL;
- virBitmapPtr use_cpumask = NULL;
- virBitmapPtr affinity_cpumask = NULL;
+ virCgroup *cgroup = NULL;
+ virBitmap *use_cpumask = NULL;
+ virBitmap *affinity_cpumask = NULL;
g_autoptr(virBitmap) hostcpumap = NULL;
g_autofree char *mem_mask = NULL;
int ret = -1;
static int
-qemuProcessSetupEmulator(virDomainObjPtr vm)
+qemuProcessSetupEmulator(virDomainObj *vm)
{
return qemuProcessSetupPid(vm, vm->pid, VIR_CGROUP_THREAD_EMULATOR,
0, vm->def->cputune.emulatorpin,
static int
-qemuProcessResctrlCreate(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessResctrlCreate(virQEMUDriver *driver,
+ virDomainObj *vm)
{
size_t i = 0;
g_autoptr(virCaps) caps = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!vm->def->nresctrls)
return 0;
return -1;
for (j = 0; j < vm->def->resctrls[i]->nmonitors; j++) {
- virDomainResctrlMonDefPtr mon = NULL;
+ virDomainResctrlMonDef *mon = NULL;
mon = vm->def->resctrls[i]->monitors[j];
if (virResctrlMonitorCreate(mon->instance,
static char *
-qemuProcessBuildPRHelperPidfilePath(virDomainObjPtr vm)
+qemuProcessBuildPRHelperPidfilePath(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
const char *prdAlias = qemuDomainGetManagedPRAlias();
return virPidFileBuildPath(priv->libDir, prdAlias);
void
-qemuProcessKillManagedPRDaemon(virDomainObjPtr vm)
+qemuProcessKillManagedPRDaemon(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
g_autofree char *pidfile = NULL;
static int
qemuProcessStartPRDaemonHook(void *opaque)
{
- virDomainObjPtr vm = opaque;
+ virDomainObj *vm = opaque;
size_t i, nfds = 0;
g_autofree int *fds = NULL;
int ret = -1;
int
-qemuProcessStartManagedPRDaemon(virDomainObjPtr vm)
+qemuProcessStartManagedPRDaemon(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
int errfd = -1;
g_autofree char *pidfile = NULL;
static int
-qemuProcessInitPasswords(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessInitPasswords(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
int ret = 0;
size_t i;
for (i = 0; i < vm->def->ngraphics; ++i) {
- virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
+ virDomainGraphicsDef *graphics = vm->def->graphics[i];
if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
ret = qemuDomainChangeGraphicsPasswords(driver, vm,
VIR_DOMAIN_GRAPHICS_TYPE_VNC,
static int
-qemuProcessPrepareChardevDevice(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrDefPtr dev,
+qemuProcessPrepareChardevDevice(virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrDef *dev,
void *opaque G_GNUC_UNUSED)
{
int fd;
static int
-qemuProcessCleanupChardevDevice(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrDefPtr dev,
+qemuProcessCleanupChardevDevice(virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrDef *dev,
void *opaque G_GNUC_UNUSED)
{
if (dev->source->type == VIR_DOMAIN_CHR_TYPE_UNIX &&
* migration.
*/
static int
-qemuProcessUpdateVideoRamSize(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessUpdateVideoRamSize(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob)
{
int ret = -1;
ssize_t i;
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainVideoDefPtr video = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainVideoDef *video = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
struct qemuProcessHookData {
- virDomainObjPtr vm;
- virQEMUDriverPtr driver;
- virQEMUDriverConfigPtr cfg;
+ virDomainObj *vm;
+ virQEMUDriver *driver;
+ virQEMUDriverConfig *cfg;
};
static int qemuProcessHook(void *data)
{
struct qemuProcessHookData *h = data;
- qemuDomainObjPrivatePtr priv = h->vm->privateData;
+ qemuDomainObjPrivate *priv = h->vm->privateData;
int ret = -1;
int fd;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
virDomainNumatuneMemMode mode;
/* This method cannot use any mutexes, which are not
}
int
-qemuProcessPrepareMonitorChr(virDomainChrSourceDefPtr monConfig,
+qemuProcessPrepareMonitorChr(virDomainChrSourceDef *monConfig,
const char *domainDir)
{
monConfig->type = VIR_DOMAIN_CHR_TYPE_UNIX;
* This method will call {Enter,Exit}Monitor
*/
int
-qemuProcessStartCPUs(virQEMUDriverPtr driver, virDomainObjPtr vm,
+qemuProcessStartCPUs(virQEMUDriver *driver, virDomainObj *vm,
virDomainRunningReason reason,
qemuDomainAsyncJob asyncJob)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
/* Bring up netdevs before starting CPUs */
}
-int qemuProcessStopCPUs(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessStopCPUs(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainPausedReason reason,
qemuDomainAsyncJob asyncJob)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_FREE(priv->lockState);
static void
-qemuProcessNotifyNets(virDomainDefPtr def)
+qemuProcessNotifyNets(virDomainDef *def)
{
size_t i;
g_autoptr(virConnect) conn = NULL;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
/* keep others from trying to use the macvtap device name, but
* don't return error if this happens, since that causes the
* domain to be unceremoniously killed, which would be *very*
* same. We'll just log the error conditions other than of course
* ignoreExists possibility (e.g. the true flag) */
static void
-qemuProcessFiltersInstantiate(virDomainDefPtr def)
+qemuProcessFiltersInstantiate(virDomainDef *def)
{
size_t i;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if ((net->filter) && (net->ifname)) {
if (virDomainConfNWFilterInstantiate(def->name, def->uuid, net,
true) < 0) {
}
static int
-qemuProcessUpdateState(virQEMUDriverPtr driver, virDomainObjPtr vm)
+qemuProcessUpdateState(virQEMUDriver *driver, virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainState state;
virDomainPausedReason reason;
virDomainState newState = VIR_DOMAIN_NOSTATE;
}
static int
-qemuProcessRecoverMigrationIn(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRecoverMigrationIn(virQEMUDriver *driver,
+ virDomainObj *vm,
const qemuDomainJobObj *job,
virDomainState state,
int reason)
{
- qemuDomainJobPrivatePtr jobPriv = job->privateData;
+ qemuDomainJobPrivate *jobPriv = job->privateData;
bool postcopy = (state == VIR_DOMAIN_PAUSED &&
reason == VIR_DOMAIN_PAUSED_POSTCOPY_FAILED) ||
(state == VIR_DOMAIN_RUNNING &&
}
static int
-qemuProcessRecoverMigrationOut(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRecoverMigrationOut(virQEMUDriver *driver,
+ virDomainObj *vm,
const qemuDomainJobObj *job,
virDomainState state,
int reason,
unsigned int *stopFlags)
{
- qemuDomainJobPrivatePtr jobPriv = job->privateData;
+ qemuDomainJobPrivate *jobPriv = job->privateData;
bool postcopy = state == VIR_DOMAIN_PAUSED &&
(reason == VIR_DOMAIN_PAUSED_POSTCOPY ||
reason == VIR_DOMAIN_PAUSED_POSTCOPY_FAILED);
}
static int
-qemuProcessRecoverJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRecoverJob(virQEMUDriver *driver,
+ virDomainObj *vm,
const qemuDomainJobObj *job,
unsigned int *stopFlags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainState state;
int reason;
unsigned long long now;
}
static int
-qemuProcessUpdateDevices(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessUpdateDevices(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainDeviceDef dev;
g_auto(GStrv) old = g_steal_pointer(&priv->qemuDevices);
GStrv tmp;
}
static int
-qemuDomainPerfRestart(virDomainObjPtr vm)
+qemuDomainPerfRestart(virDomainObj *vm)
{
size_t i;
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!(priv->perf = virPerfNew()))
return -1;
static void
-qemuProcessReconnectCheckMemAliasOrderMismatch(virDomainObjPtr vm)
+qemuProcessReconnectCheckMemAliasOrderMismatch(virDomainObj *vm)
{
size_t i;
int aliasidx;
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!virDomainDefHasMemoryHotplug(def) || def->nmems == 0)
return;
static bool
-qemuProcessNeedHugepagesPath(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+qemuProcessNeedHugepagesPath(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
const long system_pagesize = virGetSystemPageSizeKB();
size_t i;
static bool
-qemuProcessNeedMemoryBackingPath(virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+qemuProcessNeedMemoryBackingPath(virDomainDef *def,
+ virDomainMemoryDef *mem)
{
size_t i;
size_t numaNodes;
static int
-qemuProcessBuildDestroyMemoryPathsImpl(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessBuildDestroyMemoryPathsImpl(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
bool build)
{
int
-qemuProcessBuildDestroyMemoryPaths(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem,
+qemuProcessBuildDestroyMemoryPaths(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem,
bool build)
{
int
-qemuProcessDestroyMemoryBackingPath(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuProcessDestroyMemoryBackingPath(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
g_autofree char *path = NULL;
static int
-qemuProcessVNCAllocatePorts(virQEMUDriverPtr driver,
- virDomainGraphicsDefPtr graphics,
+qemuProcessVNCAllocatePorts(virQEMUDriver *driver,
+ virDomainGraphicsDef *graphics,
bool allocate)
{
unsigned short port;
}
static int
-qemuProcessSPICEAllocatePorts(virQEMUDriverPtr driver,
- virDomainGraphicsDefPtr graphics,
+qemuProcessSPICEAllocatePorts(virQEMUDriver *driver,
+ virDomainGraphicsDef *graphics,
bool allocate)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static int
-qemuProcessVerifyHypervFeatures(virDomainDefPtr def,
- virCPUDataPtr cpu)
+qemuProcessVerifyHypervFeatures(virDomainDef *def,
+ virCPUData *cpu)
{
size_t i;
int rc;
static int
-qemuProcessVerifyKVMFeatures(virDomainDefPtr def,
- virCPUDataPtr cpu)
+qemuProcessVerifyKVMFeatures(virDomainDef *def,
+ virCPUData *cpu)
{
int rc = 0;
static int
-qemuProcessVerifyCPUFeatures(virDomainDefPtr def,
- virCPUDataPtr cpu)
+qemuProcessVerifyCPUFeatures(virDomainDef *def,
+ virCPUData *cpu)
{
int rc;
qemuProcessTranslateCPUFeatures(const char *name,
void *opaque)
{
- virQEMUCapsPtr qemuCaps = opaque;
+ virQEMUCaps *qemuCaps = opaque;
return virQEMUCapsCPUFeatureFromQEMU(qemuCaps, name);
}
static int
-qemuProcessFetchGuestCPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessFetchGuestCPU(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virCPUDataPtr *enabled,
- virCPUDataPtr *disabled)
+ virCPUData **enabled,
+ virCPUData **disabled)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCPUData) dataEnabled = NULL;
g_autoptr(virCPUData) dataDisabled = NULL;
bool generic;
static int
-qemuProcessVerifyCPU(virDomainObjPtr vm,
- virCPUDataPtr cpu)
+qemuProcessVerifyCPU(virDomainObj *vm,
+ virCPUData *cpu)
{
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
if (!cpu)
return 0;
static int
-qemuProcessUpdateLiveGuestCPU(virDomainObjPtr vm,
- virCPUDataPtr enabled,
- virCPUDataPtr disabled)
+qemuProcessUpdateLiveGuestCPU(virDomainObj *vm,
+ virCPUData *enabled,
+ virCPUData *disabled)
{
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCPUDef) orig = NULL;
int rc;
static int
-qemuProcessUpdateAndVerifyCPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessUpdateAndVerifyCPU(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- virCPUDataPtr cpu = NULL;
- virCPUDataPtr disabled = NULL;
+ virCPUData *cpu = NULL;
+ virCPUData *disabled = NULL;
int ret = -1;
if (qemuProcessFetchGuestCPU(driver, vm, asyncJob, &cpu, &disabled) < 0)
static int
-qemuProcessFetchCPUDefinitions(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessFetchCPUDefinitions(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- virDomainCapsCPUModelsPtr *cpuModels)
+ virDomainCapsCPUModels **cpuModels)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virDomainCapsCPUModels) models = NULL;
int rc;
static int
-qemuProcessUpdateCPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessUpdateCPU(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(virCPUData) cpu = NULL;
static int
-qemuPrepareNVRAM(virQEMUDriverConfigPtr cfg,
- virDomainObjPtr vm)
+qemuPrepareNVRAM(virQEMUDriverConfig *cfg,
+ virDomainObj *vm)
{
int ret = -1;
int srcFD = -1;
int dstFD = -1;
- virDomainLoaderDefPtr loader = vm->def->os.loader;
+ virDomainLoaderDef *loader = vm->def->os.loader;
bool created = false;
const char *master_nvram_path;
ssize_t r;
static void
-qemuLogOperation(virDomainObjPtr vm,
+qemuLogOperation(virDomainObj *vm,
const char *msg,
- virCommandPtr cmd,
- qemuDomainLogContextPtr logCtxt)
+ virCommand *cmd,
+ qemuDomainLogContext *logCtxt)
{
g_autofree char *timestamp = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int qemuVersion = virQEMUCapsGetVersion(priv->qemuCaps);
const char *package = virQEMUCapsGetPackage(priv->qemuCaps);
g_autofree char *hostname = virGetHostname();
void
-qemuProcessIncomingDefFree(qemuProcessIncomingDefPtr inc)
+qemuProcessIncomingDefFree(qemuProcessIncomingDef *inc)
{
if (!inc)
return;
* The caller is responsible for closing @fd, calling
* qemuProcessIncomingDefFree will NOT close it.
*/
-qemuProcessIncomingDefPtr
-qemuProcessIncomingDefNew(virQEMUCapsPtr qemuCaps,
+qemuProcessIncomingDef *
+qemuProcessIncomingDefNew(virQEMUCaps *qemuCaps,
const char *listenAddress,
const char *migrateFrom,
int fd,
const char *path)
{
- qemuProcessIncomingDefPtr inc = NULL;
+ qemuProcessIncomingDef *inc = NULL;
if (qemuMigrationDstCheckProtocol(qemuCaps, migrateFrom) < 0)
return NULL;
* parameter between qemuProcessBeginJob and qemuProcessEndJob.
*/
int
-qemuProcessBeginJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessBeginJob(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainJobOperation operation,
unsigned long apiFlags)
{
void
-qemuProcessEndJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessEndJob(virQEMUDriver *driver,
+ virDomainObj *vm)
{
qemuDomainObjEndAsyncJob(driver, vm);
}
static int
-qemuProcessStartHook(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessStartHook(virQEMUDriver *driver,
+ virDomainObj *vm,
virHookQemuOpType op,
virHookSubopType subop)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *xml = NULL;
int ret;
static int
-qemuProcessGraphicsReservePorts(virDomainGraphicsDefPtr graphics,
+qemuProcessGraphicsReservePorts(virDomainGraphicsDef *graphics,
bool reconnect)
{
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
if (graphics->nListens <= 0)
return 0;
static int
-qemuProcessGraphicsAllocatePorts(virQEMUDriverPtr driver,
- virDomainGraphicsDefPtr graphics,
+qemuProcessGraphicsAllocatePorts(virQEMUDriver *driver,
+ virDomainGraphicsDef *graphics,
bool allocate)
{
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
if (graphics->nListens <= 0)
return 0;
g_autoptr(virConnect) conn = NULL;
int ret = -1;
g_autoptr(virNetwork) net = NULL;
- virNetworkDefPtr netdef = NULL;
- virNetworkIPDefPtr ipdef;
+ virNetworkDef *netdef = NULL;
+ virNetworkIPDef *ipdef;
virSocketAddr addr;
- virSocketAddrPtr addrptr = NULL;
+ virSocketAddr *addrptr = NULL;
char *dev_name = NULL;
g_autofree char *xml = NULL;
static int
-qemuProcessGraphicsSetupNetworkAddress(virDomainGraphicsListenDefPtr glisten,
+qemuProcessGraphicsSetupNetworkAddress(virDomainGraphicsListenDef *glisten,
const char *listenAddr)
{
int rc;
static int
-qemuProcessGraphicsSetupListen(virQEMUDriverPtr driver,
- virDomainGraphicsDefPtr graphics,
- virDomainObjPtr vm)
+qemuProcessGraphicsSetupListen(virQEMUDriver *driver,
+ virDomainGraphicsDef *graphics,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
const char *type = virDomainGraphicsTypeToString(graphics->type);
char *listenAddr = NULL;
}
for (i = 0; i < graphics->nListens; i++) {
- virDomainGraphicsListenDefPtr glisten = &graphics->listens[i];
+ virDomainGraphicsListenDef *glisten = &graphics->listens[i];
switch (glisten->type) {
case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
static int
-qemuProcessGraphicsSetupRenderNode(virDomainGraphicsDefPtr graphics,
- virQEMUCapsPtr qemuCaps)
+qemuProcessGraphicsSetupRenderNode(virDomainGraphicsDef *graphics,
+ virQEMUCaps *qemuCaps)
{
char **rendernode = NULL;
static int
-qemuProcessSetupGraphics(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virQEMUCapsPtr qemuCaps,
+qemuProcessSetupGraphics(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virQEMUCaps *qemuCaps,
unsigned int flags)
{
- virDomainGraphicsDefPtr graphics;
+ virDomainGraphicsDef *graphics;
bool allocate = !(flags & VIR_QEMU_PROCESS_START_PRETEND);
size_t i;
static int
-qemuProcessSetupRawIO(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd G_GNUC_UNUSED)
+qemuProcessSetupRawIO(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd G_GNUC_UNUSED)
{
bool rawio = false;
size_t i;
/* in case a certain disk is desirous of CAP_SYS_RAWIO, add this */
for (i = 0; i < vm->def->ndisks; i++) {
virDomainDeviceDef dev;
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
if (disk->rawio == VIR_TRISTATE_BOOL_YES) {
rawio = true;
/* If rawio not already set, check hostdevs as well */
if (!rawio) {
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevSubsysSCSIPtr scsisrc;
+ virDomainHostdevSubsysSCSI *scsisrc;
if (!virHostdevIsSCSIDevice(vm->def->hostdevs[i]))
continue;
static int
-qemuProcessSetupBalloon(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessSetupBalloon(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
unsigned long long balloon = vm->def->mem.cur_balloon;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
if (!virDomainDefHasMemballoon(vm->def))
static int
-qemuProcessMakeDir(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessMakeDir(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path)
{
if (g_mkdir_with_parents(path, 0750) < 0) {
static void
-qemuProcessStartWarnShmem(virDomainObjPtr vm)
+qemuProcessStartWarnShmem(virDomainObj *vm)
{
size_t i;
bool check_shmem = false;
static int
-qemuProcessStartValidateGraphics(virDomainObjPtr vm)
+qemuProcessStartValidateGraphics(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->ngraphics; i++) {
- virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
+ virDomainGraphicsDef *graphics = vm->def->graphics[i];
switch (graphics->type) {
case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
static int
-qemuProcessStartValidateIOThreads(virDomainObjPtr vm,
- virQEMUCapsPtr qemuCaps)
+qemuProcessStartValidateIOThreads(virDomainObj *vm,
+ virQEMUCaps *qemuCaps)
{
size_t i;
}
for (i = 0; i < vm->def->ncontrollers; i++) {
- virDomainControllerDefPtr cont = vm->def->controllers[i];
+ virDomainControllerDef *cont = vm->def->controllers[i];
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI &&
cont->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI &&
static int
-qemuProcessStartValidateShmem(virDomainObjPtr vm)
+qemuProcessStartValidateShmem(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nshmems; i++) {
- virDomainShmemDefPtr shmem = vm->def->shmems[i];
+ virDomainShmemDef *shmem = vm->def->shmems[i];
if (strchr(shmem->name, '/')) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
-qemuProcessStartValidateDisks(virDomainObjPtr vm,
- virQEMUCapsPtr qemuCaps)
+qemuProcessStartValidateDisks(virDomainObj *vm,
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- virStorageSourcePtr src = disk->src;
+ virDomainDiskDef *disk = vm->def->disks[i];
+ virStorageSource *src = disk->src;
/* This is a best effort check as we can only check if the command
* option exists, but we cannot determine whether the running QEMU
#define TSC_TOLERANCE 250
static int
-qemuProcessStartValidateTSC(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessStartValidateTSC(virQEMUDriver *driver,
+ virDomainObj *vm)
{
size_t i;
unsigned long long freq = 0;
unsigned long long tolerance;
unsigned long long minFreq;
unsigned long long maxFreq;
- virHostCPUTscInfoPtr tsc;
+ virHostCPUTscInfo *tsc;
g_autoptr(virCPUDef) cpu = NULL;
for (i = 0; i < vm->def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = vm->def->clock.timers[i];
+ virDomainTimerDef *timer = vm->def->clock.timers[i];
if (timer->name == VIR_DOMAIN_TIMER_NAME_TSC &&
timer->frequency > 0) {
* executed in this case, make sure to check this flag.
*/
static int
-qemuProcessStartValidate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virQEMUCapsPtr qemuCaps,
+qemuProcessStartValidate(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virQEMUCaps *qemuCaps,
unsigned int flags)
{
if (!(flags & VIR_QEMU_PROCESS_START_PRETEND)) {
static int
-qemuProcessStartUpdateCustomCaps(virDomainObjPtr vm)
+qemuProcessStartUpdateCustomCaps(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
- qemuDomainXmlNsDefPtr nsdef = vm->def->namespaceData;
+ qemuDomainXmlNsDef *nsdef = vm->def->namespaceData;
char **next;
int tmp;
size_t i;
* Returns 0 on success, -1 on error.
*/
static int
-qemuProcessPrepareQEMUCaps(virDomainObjPtr vm,
- virFileCachePtr qemuCapsCache,
+qemuProcessPrepareQEMUCaps(virDomainObj *vm,
+ virFileCache *qemuCapsCache,
unsigned int processStartFlags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virObjectUnref(priv->qemuCaps);
if (!(priv->qemuCaps = virQEMUCapsCacheLookupCopy(qemuCapsCache,
* Returns 0 on success, -1 on error.
*/
int
-qemuProcessInit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCPUDefPtr updatedCPU,
+qemuProcessInit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCPUDef *updatedCPU,
qemuDomainAsyncJob asyncJob,
bool migration,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int stopFlags;
- virCPUDefPtr origCPU = NULL;
+ virCPUDef *origCPU = NULL;
int ret = -1;
VIR_DEBUG("vm=%p name=%s id=%d migration=%d",
* qemuProcessNetworkPrepareDevices
*/
static int
-qemuProcessNetworkPrepareDevices(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessNetworkPrepareDevices(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
g_autoptr(virConnect) conn = NULL;
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
virDomainNetType actualType;
/* If appropriate, grab a physical device from the configured
* network / determined at runtime, we need to do it
* separately.
*/
- virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);
- virDomainHostdevSubsysPCIPtr pcisrc = &hostdev->source.subsys.u.pci;
+ virDomainHostdevDef *hostdev = virDomainNetGetActualHostdev(net);
+ virDomainHostdevSubsysPCI *pcisrc = &hostdev->source.subsys.u.pci;
if (virDomainHostdevFind(def, hostdev, NULL) >= 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
} else if (actualType == VIR_DOMAIN_NET_TYPE_USER &&
!priv->disableSlirp &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
- qemuSlirpPtr slirp = NULL;
+ qemuSlirp *slirp = NULL;
int rv = qemuInterfacePrepareSlirp(driver, net, &slirp);
if (rv == -1)
* Returns 0 on success, -1 on error.
*/
int
-qemuProcessSetupVcpu(virDomainObjPtr vm,
+qemuProcessSetupVcpu(virDomainObj *vm,
unsigned int vcpuid)
{
pid_t vcpupid = qemuDomainGetVcpuPid(vm, vcpuid);
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
- virDomainResctrlMonDefPtr mon = NULL;
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
+ virDomainResctrlMonDef *mon = NULL;
size_t i = 0;
if (qemuProcessSetupPid(vm, vcpupid, VIR_CGROUP_THREAD_VCPU,
for (i = 0; i < vm->def->nresctrls; i++) {
size_t j = 0;
- virDomainResctrlDefPtr ct = vm->def->resctrls[i];
+ virDomainResctrlDef *ct = vm->def->resctrls[i];
if (virBitmapIsBitSet(ct->vcpus, vcpuid)) {
if (virResctrlAllocAddPID(ct->alloc, vcpupid) < 0)
static int
-qemuProcessSetupVcpus(virDomainObjPtr vm)
+qemuProcessSetupVcpus(virDomainObj *vm)
{
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
unsigned int maxvcpus = virDomainDefGetVcpusMax(vm->def);
size_t i;
if ((vm->def->cputune.period || vm->def->cputune.quota) &&
- !virCgroupHasController(((qemuDomainObjPrivatePtr) vm->privateData)->cgroup,
+ !virCgroupHasController(((qemuDomainObjPrivate *) vm->privateData)->cgroup,
VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("cgroup cpu is required for scheduler tuning"));
int
-qemuProcessSetupIOThread(virDomainObjPtr vm,
- virDomainIOThreadIDDefPtr iothread)
+qemuProcessSetupIOThread(virDomainObj *vm,
+ virDomainIOThreadIDDef *iothread)
{
return qemuProcessSetupPid(vm, iothread->thread_id,
VIR_CGROUP_THREAD_IOTHREAD,
static int
-qemuProcessSetupIOThreads(virDomainObjPtr vm)
+qemuProcessSetupIOThreads(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->niothreadids; i++) {
- virDomainIOThreadIDDefPtr info = vm->def->iothreadids[i];
+ virDomainIOThreadIDDef *info = vm->def->iothreadids[i];
if (qemuProcessSetupIOThread(vm, info) < 0)
return -1;
static int
-qemuProcessValidateHotpluggableVcpus(virDomainDefPtr def)
+qemuProcessValidateHotpluggableVcpus(virDomainDef *def)
{
- virDomainVcpuDefPtr vcpu;
- virDomainVcpuDefPtr subvcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
+ virDomainVcpuDef *vcpu;
+ virDomainVcpuDef *subvcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
size_t i = 0;
size_t j;
- virBitmapPtr ordermap = virBitmapNew(maxvcpus + 1);
+ virBitmap *ordermap = virBitmapNew(maxvcpus + 1);
int ret = -1;
/* validate:
static int
-qemuDomainHasHotpluggableStartupVcpus(virDomainDefPtr def)
+qemuDomainHasHotpluggableStartupVcpus(virDomainDef *def)
{
size_t maxvcpus = virDomainDefGetVcpusMax(def);
- virDomainVcpuDefPtr vcpu;
+ virDomainVcpuDef *vcpu;
size_t i;
for (i = 0; i < maxvcpus; i++) {
qemuProcessVcpusSortOrder(const void *a,
const void *b)
{
- virDomainVcpuDefPtr vcpua = *((virDomainVcpuDefPtr *)a);
- virDomainVcpuDefPtr vcpub = *((virDomainVcpuDefPtr *)b);
+ virDomainVcpuDef *vcpua = *((virDomainVcpuDef **)a);
+ virDomainVcpuDef *vcpub = *((virDomainVcpuDef **)b);
return vcpua->order - vcpub->order;
}
static int
-qemuProcessSetupHotpluggableVcpus(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessSetupHotpluggableVcpus(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
unsigned int maxvcpus = virDomainDefGetVcpusMax(vm->def);
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuCgroupEmulatorAllNodesDataPtr emulatorCgroup = NULL;
- virDomainVcpuDefPtr vcpu;
- qemuDomainVcpuPrivatePtr vcpupriv;
- virJSONValuePtr vcpuprops = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuCgroupEmulatorAllNodesData *emulatorCgroup = NULL;
+ virDomainVcpuDef *vcpu;
+ qemuDomainVcpuPrivate *vcpupriv;
+ virJSONValue *vcpuprops = NULL;
size_t i;
int ret = -1;
int rc;
- virDomainVcpuDefPtr *bootHotplug = NULL;
+ virDomainVcpuDef **bootHotplug = NULL;
size_t nbootHotplug = 0;
for (i = 0; i < maxvcpus; i++) {
static int
-qemuProcessUpdateGuestCPU(virDomainDefPtr def,
- virQEMUCapsPtr qemuCaps,
+qemuProcessUpdateGuestCPU(virDomainDef *def,
+ virQEMUCaps *qemuCaps,
virArch hostarch,
unsigned int flags)
{
return -1;
if (def->cpu->check != VIR_CPU_CHECK_NONE) {
- virCPUDefPtr host;
+ virCPUDef *host;
host = virQEMUCapsGetHostModel(qemuCaps, def->virtType,
VIR_QEMU_CAPS_HOST_CPU_FULL);
static int
-qemuProcessPrepareDomainNUMAPlacement(virDomainObjPtr vm)
+qemuProcessPrepareDomainNUMAPlacement(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *nodeset = NULL;
g_autoptr(virBitmap) numadNodeset = NULL;
g_autoptr(virBitmap) hostMemoryNodeset = NULL;
static int
-qemuProcessPrepareDomainStorage(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuDomainObjPrivatePtr priv,
- virQEMUDriverConfigPtr cfg,
+qemuProcessPrepareDomainStorage(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuDomainObjPrivate *priv,
+ virQEMUDriverConfig *cfg,
unsigned int flags)
{
size_t i;
for (i = vm->def->ndisks; i > 0; i--) {
size_t idx = i - 1;
- virDomainDiskDefPtr disk = vm->def->disks[idx];
+ virDomainDiskDef *disk = vm->def->disks[idx];
if (virDomainDiskTranslateSourcePool(disk) < 0) {
if (qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) < 0)
static int
-qemuProcessPrepareDomainHostdevs(virDomainObjPtr vm,
- qemuDomainObjPrivatePtr priv)
+qemuProcessPrepareDomainHostdevs(virDomainObj *vm,
+ qemuDomainObjPrivate *priv)
{
size_t i;
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
+ virDomainHostdevDef *hostdev = vm->def->hostdevs[i];
if (qemuDomainPrepareHostdev(hostdev, priv) < 0)
return -1;
int
-qemuProcessPrepareHostHostdev(virDomainHostdevDefPtr hostdev)
+qemuProcessPrepareHostHostdev(virDomainHostdevDef *hostdev)
{
if (virHostdevIsSCSIDevice(hostdev)) {
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
- virStorageSourcePtr src = scsisrc->u.host.src;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
+ virStorageSource *src = scsisrc->u.host.src;
g_autofree char *devstr = NULL;
if (!(devstr = virSCSIDeviceGetSgName(NULL,
static int
-qemuProcessPrepareHostHostdevs(virDomainObjPtr vm)
+qemuProcessPrepareHostHostdevs(virDomainObj *vm)
{
size_t i;
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
+ virDomainHostdevDef *hostdev = vm->def->hostdevs[i];
if (qemuProcessPrepareHostHostdev(hostdev) < 0)
return -1;
static void
-qemuProcessPrepareAllowReboot(virDomainObjPtr vm)
+qemuProcessPrepareAllowReboot(virDomainObj *vm)
{
- virDomainDefPtr def = vm->def;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDef *def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (priv->allowReboot != VIR_TRISTATE_BOOL_ABSENT)
return;
static int
-qemuProcessUpdateSEVInfo(virDomainObjPtr vm)
+qemuProcessUpdateSEVInfo(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUCapsPtr qemuCaps = priv->qemuCaps;
- virDomainSEVDefPtr sev = vm->def->sev;
- virSEVCapabilityPtr sevCaps = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUCaps *qemuCaps = priv->qemuCaps;
+ virDomainSEVDef *sev = vm->def->sev;
+ virSEVCapability *sevCaps = NULL;
/* if platform specific info like 'cbitpos' and 'reducedPhysBits' have
* not been supplied, we need to autofill them from caps now as both are
* TODO: move all XML modification from qemuBuildCommandLine into this function
*/
int
-qemuProcessPrepareDomain(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessPrepareDomain(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags)
{
size_t i;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
priv->machineName = qemuDomainGetMachineName(vm);
static int
-qemuProcessSEVCreateFile(virDomainObjPtr vm,
+qemuProcessSEVCreateFile(virDomainObj *vm,
const char *name,
const char *data)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autofree char *configFile = NULL;
if (!(configFile = virFileBuildPath(priv->libDir, name, ".base64")))
static int
-qemuProcessPrepareSEVGuestInput(virDomainObjPtr vm)
+qemuProcessPrepareSEVGuestInput(virDomainObj *vm)
{
- virDomainSEVDefPtr sev = vm->def->sev;
+ virDomainSEVDef *sev = vm->def->sev;
if (!sev)
return 0;
static int
-qemuProcessPrepareHostStorage(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessPrepareHostStorage(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
bool cold_boot = flags & VIR_QEMU_PROCESS_START_COLD;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
for (i = vm->def->ndisks; i > 0; i--) {
size_t idx = i - 1;
- virDomainDiskDefPtr disk = vm->def->disks[idx];
+ virDomainDiskDef *disk = vm->def->disks[idx];
if (virStorageSourceIsEmpty(disk->src))
continue;
int
-qemuProcessOpenVhostVsock(virDomainVsockDefPtr vsock)
+qemuProcessOpenVhostVsock(virDomainVsockDef *vsock)
{
- qemuDomainVsockPrivatePtr priv = (qemuDomainVsockPrivatePtr)vsock->privateData;
+ qemuDomainVsockPrivate *priv = (qemuDomainVsockPrivate *)vsock->privateData;
const char *vsock_path = "/dev/vhost-vsock";
int fd;
* TODO: move all host modification from qemuBuildCommandLine into this function
*/
int
-qemuProcessPrepareHost(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessPrepareHost(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags)
{
unsigned int hostdev_flags = 0;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
if (qemuPrepareNVRAM(cfg, vm) < 0)
* something that has already been executed before.
*/
static int
-qemuProcessGenID(virDomainObjPtr vm,
+qemuProcessGenID(virDomainObj *vm,
unsigned int flags)
{
if (!vm->def->genidRequested)
* Same hack is done in qemuDomainAttachDiskGeneric.
*/
static int
-qemuProcessSetupDiskThrottlingBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessSetupDiskThrottlingBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
int ret = -1;
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
/* sd-cards are instantiated via -drive */
if (qemuDiskBusIsSD(disk->bus))
static int
-qemuProcessEnableDomainNamespaces(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessEnableDomainNamespaces(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
static int
-qemuProcessEnablePerf(virDomainObjPtr vm)
+qemuProcessEnablePerf(virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
size_t i;
if (!(priv->perf = virPerfNew()))
*/
int
qemuProcessLaunch(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuProcessIncomingDefPtr incoming,
- virDomainMomentObjPtr snapshot,
+ qemuProcessIncomingDef *incoming,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
unsigned int flags)
{
int rv;
int logfile = -1;
g_autoptr(qemuDomainLogContext) logCtxt = NULL;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCommand) cmd = NULL;
struct qemuProcessHookData hookData;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
* state influenced by the migration stream.
*/
int
-qemuProcessRefreshState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRefreshState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Fetching list of active devices");
if (qemuDomainUpdateDeviceList(driver, vm, asyncJob) < 0)
* Finish starting a new domain.
*/
int
-qemuProcessFinishStartup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessFinishStartup(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
bool startCPUs,
virDomainPausedReason pausedReason)
int
qemuProcessStart(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCPUDefPtr updatedCPU,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCPUDef *updatedCPU,
qemuDomainAsyncJob asyncJob,
const char *migrateFrom,
int migrateFd,
const char *migratePath,
- virDomainMomentObjPtr snapshot,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuProcessIncomingDefPtr incoming = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ qemuProcessIncomingDef *incoming = NULL;
unsigned int stopFlags;
bool relabel = false;
bool relabelSavedState = false;
int
-qemuProcessCreatePretendCmdPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessCreatePretendCmdPrepare(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *migrateURI,
bool standalone,
unsigned int flags)
}
-virCommandPtr
-qemuProcessCreatePretendCmdBuild(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+virCommand *
+qemuProcessCreatePretendCmdBuild(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *migrateURI,
bool enableFips,
bool standalone,
int
-qemuProcessKill(virDomainObjPtr vm, unsigned int flags)
+qemuProcessKill(virDomainObj *vm, unsigned int flags)
{
VIR_DEBUG("vm=%p name=%s pid=%lld flags=0x%x",
vm, vm->def->name,
* qemuProcessStop.
*/
int
-qemuProcessBeginStopJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessBeginStopJob(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainJob job,
bool forceKill)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
unsigned int killFlags = forceKill ? VIR_QEMU_PROCESS_KILL_FORCE : 0;
int ret = -1;
}
-void qemuProcessStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuProcessStop(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason,
qemuDomainAsyncJob asyncJob,
unsigned int flags)
{
int ret;
int retries = 0;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr orig_err;
- virDomainDefPtr def = vm->def;
+ virDomainDef *def = vm->def;
const virNetDevVPortProfile *vport = NULL;
size_t i;
g_autofree char *timestamp = NULL;
if (cfg->macFilter) {
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
if (net->ifname == NULL)
continue;
ignore_value(ebtablesRemoveForwardAllowIn(driver->ebtables,
for (i = 0; i < vm->def->ndisks; i++) {
virDomainDeviceDef dev;
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
dev.type = VIR_DOMAIN_DEVICE_DISK;
dev.data.disk = disk;
qemuHostdevReAttachDomainDevices(driver, vm->def);
for (i = 0; i < def->nnets; i++) {
- virDomainNetDefPtr net = def->nets[i];
+ virDomainNetDef *net = def->nets[i];
vport = virDomainNetGetActualVirtPortProfile(net);
switch (virDomainNetGetActualType(net)) {
size_t j = 0;
for (j = 0; j < vm->def->resctrls[i]->nmonitors; j++) {
- virDomainResctrlMonDefPtr mon = NULL;
+ virDomainResctrlMonDef *mon = NULL;
mon = vm->def->resctrls[i]->monitors[j];
virResctrlMonitorRemove(mon->instance);
they were reserved by the driver (autoport=yes)
*/
for (i = 0; i < vm->def->ngraphics; ++i) {
- virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
+ virDomainGraphicsDef *graphics = vm->def->graphics[i];
if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
if (graphics->data.vnc.autoport) {
virPortAllocatorRelease(graphics->data.vnc.port);
* is no longer running. */
if (!(flags & VIR_QEMU_PROCESS_STOP_NO_RELABEL)) {
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (disk->mirror) {
if (qemuSecurityRestoreImageLabel(driver, vm, disk->mirror, false) < 0)
static void
-qemuProcessAutoDestroy(virDomainObjPtr dom,
+qemuProcessAutoDestroy(virDomainObj *dom,
virConnectPtr conn,
void *opaque)
{
- virQEMUDriverPtr driver = opaque;
- qemuDomainObjPrivatePtr priv = dom->privateData;
- virObjectEventPtr event = NULL;
+ virQEMUDriver *driver = opaque;
+ qemuDomainObjPrivate *priv = dom->privateData;
+ virObjectEvent *event = NULL;
unsigned int stopFlags = 0;
VIR_DEBUG("vm=%s, conn=%p", dom->def->name, conn);
virObjectEventStateQueue(driver->domainEventState, event);
}
-int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessAutoDestroyAdd(virQEMUDriver *driver,
+ virDomainObj *vm,
virConnectPtr conn)
{
VIR_DEBUG("vm=%s, conn=%p", vm->def->name, conn);
qemuProcessAutoDestroy);
}
-int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+int qemuProcessAutoDestroyRemove(virQEMUDriver *driver,
+ virDomainObj *vm)
{
VIR_DEBUG("vm=%s", vm->def->name);
return virCloseCallbacksUnset(driver->closeCallbacks, vm,
qemuProcessAutoDestroy);
}
-bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+bool qemuProcessAutoDestroyActive(virQEMUDriver *driver,
+ virDomainObj *vm)
{
virCloseCallback cb;
VIR_DEBUG("vm=%s", vm->def->name);
int
-qemuProcessRefreshDisks(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRefreshDisks(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
GHashTable *table = NULL;
int ret = -1;
goto cleanup;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
- qemuDomainDiskPrivatePtr diskpriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
+ virDomainDiskDef *disk = vm->def->disks[i];
+ qemuDomainDiskPrivate *diskpriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
struct qemuDomainDiskInfo *info;
const char *entryname = disk->info.alias;
static int
-qemuProcessRefreshCPUMigratability(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuProcessRefreshCPUMigratability(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainDefPtr def = vm->def;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virDomainDef *def = vm->def;
bool migratable;
int rc;
static int
-qemuProcessRefreshCPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessRefreshCPU(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virCPUDef) host = NULL;
g_autoptr(virCPUDef) hostmig = NULL;
g_autoptr(virCPUDef) cpu = NULL;
void *opaque)
{
const char *jobname = name;
- virDomainObjPtr vm = opaque;
- qemuMonitorBlockJobInfoPtr info = payload;
- virDomainDiskDefPtr disk;
- qemuBlockJobDataPtr job;
+ virDomainObj *vm = opaque;
+ qemuMonitorBlockJobInfo *info = payload;
+ virDomainDiskDef *disk;
+ qemuBlockJobData *job;
qemuBlockJobType jobtype = info->type;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (!(disk = qemuProcessFindDomainDiskByAliasOrQOM(vm, jobname, jobname))) {
VIR_DEBUG("could not find disk for block job '%s'", jobname);
static int
-qemuProcessRefreshLegacyBlockjobs(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessRefreshLegacyBlockjobs(virQEMUDriver *driver,
+ virDomainObj *vm)
{
GHashTable *blockJobs = NULL;
int ret = -1;
static int
-qemuProcessRefreshBlockjobs(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuProcessRefreshBlockjobs(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV))
return qemuBlockJobRefreshJobs(driver, vm);
struct qemuProcessReconnectData {
- virQEMUDriverPtr driver;
- virDomainObjPtr obj;
- virIdentityPtr identity;
+ virQEMUDriver *driver;
+ virDomainObj *obj;
+ virIdentity *identity;
};
/*
* Open an existing VM's monitor, re-detect VCPU threads
qemuProcessReconnect(void *opaque)
{
struct qemuProcessReconnectData *data = opaque;
- virQEMUDriverPtr driver = data->driver;
- virDomainObjPtr obj = data->obj;
- qemuDomainObjPrivatePtr priv;
+ virQEMUDriver *driver = data->driver;
+ virDomainObj *obj = data->obj;
+ qemuDomainObjPrivate *priv;
g_auto(qemuDomainJobObj) oldjob = {
.cb = NULL,
};
* qemu_driver->sharedDevices.
*/
for (i = 0; i < obj->def->ndisks; i++) {
- virDomainDiskDefPtr disk = obj->def->disks[i];
+ virDomainDiskDef *disk = obj->def->disks[i];
virDomainDeviceDef dev;
if (virDomainDiskTranslateSourcePool(disk) < 0)
goto error;
for (j = 0; j < obj->def->resctrls[i]->nmonitors; j++) {
- virDomainResctrlMonDefPtr mon = NULL;
+ virDomainResctrlMonDef *mon = NULL;
mon = obj->def->resctrls[i]->monitors[j];
if (virResctrlMonitorDeterminePath(mon->instance,
}
static int
-qemuProcessReconnectHelper(virDomainObjPtr obj,
+qemuProcessReconnectHelper(virDomainObj *obj,
void *opaque)
{
virThread thread;
* about.
*/
void
-qemuProcessReconnectAll(virQEMUDriverPtr driver)
+qemuProcessReconnectAll(virQEMUDriver *driver)
{
struct qemuProcessReconnectData data = {.driver = driver};
virDomainObjListForEach(driver->domains, true,
}
-static void virQEMUCapsMonitorNotify(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm G_GNUC_UNUSED,
+static void virQEMUCapsMonitorNotify(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static void
-qemuProcessQMPStop(qemuProcessQMPPtr proc)
+qemuProcessQMPStop(qemuProcessQMP *proc)
{
if (proc->mon) {
virObjectUnlock(proc->mon);
* Kill QEMU process and free process data structure.
*/
void
-qemuProcessQMPFree(qemuProcessQMPPtr proc)
+qemuProcessQMPFree(qemuProcessQMP *proc)
{
if (!proc)
return;
* Allocate and initialize domain structure encapsulating QEMU process state
* and monitor connection for completing QMP queries.
*/
-qemuProcessQMPPtr
+qemuProcessQMP *
qemuProcessQMPNew(const char *binary,
const char *libDir,
uid_t runUid,
static int
-qemuProcessQEMULabelUniqPath(qemuProcessQMPPtr proc)
+qemuProcessQEMULabelUniqPath(qemuProcessQMP *proc)
{
/* We cannot use the security driver here, but we should not need to. */
if (chown(proc->uniqDir, proc->runUid, -1) < 0) {
static int
-qemuProcessQMPInit(qemuProcessQMPPtr proc)
+qemuProcessQMPInit(qemuProcessQMP *proc)
{
g_autofree char *template = NULL;
static int
-qemuProcessQMPLaunch(qemuProcessQMPPtr proc)
+qemuProcessQMPLaunch(qemuProcessQMP *proc)
{
const char *machine;
int status = 0;
int
-qemuProcessQMPInitMonitor(qemuMonitorPtr mon)
+qemuProcessQMPInitMonitor(qemuMonitor *mon)
{
if (qemuMonitorSetCapabilities(mon) < 0) {
VIR_DEBUG("Failed to set monitor capabilities %s",
static int
-qemuProcessQMPConnectMonitor(qemuProcessQMPPtr proc)
+qemuProcessQMPConnectMonitor(qemuProcessQMP *proc)
{
- virDomainXMLOptionPtr xmlopt = NULL;
+ virDomainXMLOption *xmlopt = NULL;
virDomainChrSourceDef monConfig;
int ret = -1;
* struct until qemuProcessQMPFree is called.
*/
int
-qemuProcessQMPStart(qemuProcessQMPPtr proc)
+qemuProcessQMPStart(qemuProcessQMP *proc)
{
VIR_DEBUG("proc=%p, emulator=%s", proc, proc->binary);
#include "virstoragefile.h"
#include "vireventthread.h"
-int qemuProcessPrepareMonitorChr(virDomainChrSourceDefPtr monConfig,
+int qemuProcessPrepareMonitorChr(virDomainChrSourceDef *monConfig,
const char *domainDir);
-int qemuProcessStartCPUs(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessStartCPUs(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainRunningReason reason,
qemuDomainAsyncJob asyncJob);
-int qemuProcessStopCPUs(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessStopCPUs(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainPausedReason reason,
qemuDomainAsyncJob asyncJob);
-int qemuProcessBuildDestroyMemoryPaths(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem,
+int qemuProcessBuildDestroyMemoryPaths(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem,
bool build);
-int qemuProcessDestroyMemoryBackingPath(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
+int qemuProcessDestroyMemoryBackingPath(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem);
-void qemuProcessReconnectAll(virQEMUDriverPtr driver);
+void qemuProcessReconnectAll(virQEMUDriver *driver);
typedef struct _qemuProcessIncomingDef qemuProcessIncomingDef;
-typedef qemuProcessIncomingDef *qemuProcessIncomingDefPtr;
struct _qemuProcessIncomingDef {
char *address; /* address where QEMU is supposed to listen */
char *launchURI; /* used as a parameter for -incoming command line option */
const char *path; /* path associated with fd */
};
-qemuProcessIncomingDefPtr qemuProcessIncomingDefNew(virQEMUCapsPtr qemuCaps,
+qemuProcessIncomingDef *qemuProcessIncomingDefNew(virQEMUCaps *qemuCaps,
const char *listenAddress,
const char *migrateFrom,
int fd,
const char *path);
-void qemuProcessIncomingDefFree(qemuProcessIncomingDefPtr inc);
+void qemuProcessIncomingDefFree(qemuProcessIncomingDef *inc);
-int qemuProcessBeginJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessBeginJob(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainJobOperation operation,
unsigned long apiFlags);
-void qemuProcessEndJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuProcessEndJob(virQEMUDriver *driver,
+ virDomainObj *vm);
typedef enum {
VIR_QEMU_PROCESS_START_COLD = 1 << 0,
} qemuProcessStartFlags;
int qemuProcessStart(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCPUDefPtr updatedCPU,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCPUDef *updatedCPU,
qemuDomainAsyncJob asyncJob,
const char *migrateFrom,
int stdin_fd,
const char *stdin_path,
- virDomainMomentObjPtr snapshot,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
unsigned int flags);
-int qemuProcessCreatePretendCmdPrepare(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessCreatePretendCmdPrepare(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *migrateURI,
bool standalone,
unsigned int flags);
-virCommandPtr qemuProcessCreatePretendCmdBuild(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+virCommand *qemuProcessCreatePretendCmdBuild(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *migrateURI,
bool enableFips,
bool standalone,
bool jsonPropsValidation);
-int qemuProcessInit(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCPUDefPtr updatedCPU,
+int qemuProcessInit(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCPUDef *updatedCPU,
qemuDomainAsyncJob asyncJob,
bool migration,
unsigned int flags);
-int qemuProcessPrepareDomain(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessPrepareDomain(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags);
-int qemuProcessOpenVhostVsock(virDomainVsockDefPtr vsock);
+int qemuProcessOpenVhostVsock(virDomainVsockDef *vsock);
-int qemuProcessPrepareHostHostdev(virDomainHostdevDefPtr hostdev);
+int qemuProcessPrepareHostHostdev(virDomainHostdevDef *hostdev);
-int qemuProcessPrepareHost(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessPrepareHost(virQEMUDriver *driver,
+ virDomainObj *vm,
unsigned int flags);
int qemuProcessLaunch(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
- qemuProcessIncomingDefPtr incoming,
- virDomainMomentObjPtr snapshot,
+ qemuProcessIncomingDef *incoming,
+ virDomainMomentObj *snapshot,
virNetDevVPortProfileOp vmop,
unsigned int flags);
-int qemuProcessFinishStartup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessFinishStartup(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob,
bool startCPUs,
virDomainPausedReason pausedReason);
-int qemuProcessRefreshState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessRefreshState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
typedef enum {
VIR_QEMU_PROCESS_STOP_NO_RELABEL = 1 << 1,
} qemuProcessStopFlags;
-int qemuProcessBeginStopJob(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessBeginStopJob(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainJob job,
bool forceKill);
-void qemuProcessStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuProcessStop(virQEMUDriver *driver,
+ virDomainObj *vm,
virDomainShutoffReason reason,
qemuDomainAsyncJob asyncJob,
unsigned int flags);
VIR_QEMU_PROCESS_KILL_NOCHECK = 1 << 2, /* bypass the running vm check */
} virQemuProcessKillMode;
-int qemuProcessKill(virDomainObjPtr vm, unsigned int flags);
+int qemuProcessKill(virDomainObj *vm, unsigned int flags);
-void qemuProcessShutdownOrReboot(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuProcessShutdownOrReboot(virQEMUDriver *driver,
+ virDomainObj *vm);
-int qemuProcessAutoDestroyInit(virQEMUDriverPtr driver);
-void qemuProcessAutoDestroyShutdown(virQEMUDriverPtr driver);
-int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessAutoDestroyInit(virQEMUDriver *driver);
+void qemuProcessAutoDestroyShutdown(virQEMUDriver *driver);
+int qemuProcessAutoDestroyAdd(virQEMUDriver *driver,
+ virDomainObj *vm,
virConnectPtr conn);
-int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
-bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+int qemuProcessAutoDestroyRemove(virQEMUDriver *driver,
+ virDomainObj *vm);
+bool qemuProcessAutoDestroyActive(virQEMUDriver *driver,
+ virDomainObj *vm);
int qemuProcessSetSchedParams(int id, pid_t pid, size_t nsp,
- virDomainThreadSchedParamPtr sp);
+ virDomainThreadSchedParam *sp);
-virDomainDiskDefPtr qemuProcessFindDomainDiskByAliasOrQOM(virDomainObjPtr vm,
+virDomainDiskDef *qemuProcessFindDomainDiskByAliasOrQOM(virDomainObj *vm,
const char *alias,
const char *qomid);
-int qemuConnectAgent(virQEMUDriverPtr driver, virDomainObjPtr vm);
+int qemuConnectAgent(virQEMUDriver *driver, virDomainObj *vm);
-int qemuProcessSetupVcpu(virDomainObjPtr vm,
+int qemuProcessSetupVcpu(virDomainObj *vm,
unsigned int vcpuid);
-int qemuProcessSetupIOThread(virDomainObjPtr vm,
- virDomainIOThreadIDDefPtr iothread);
+int qemuProcessSetupIOThread(virDomainObj *vm,
+ virDomainIOThreadIDDef *iothread);
-int qemuRefreshVirtioChannelState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuRefreshVirtioChannelState(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
-int qemuProcessRefreshBalloonState(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessRefreshBalloonState(virQEMUDriver *driver,
+ virDomainObj *vm,
int asyncJob);
-int qemuProcessRefreshDisks(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuProcessRefreshDisks(virQEMUDriver *driver,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
-int qemuProcessStartManagedPRDaemon(virDomainObjPtr vm) G_GNUC_NO_INLINE;
+int qemuProcessStartManagedPRDaemon(virDomainObj *vm) G_GNUC_NO_INLINE;
-void qemuProcessKillManagedPRDaemon(virDomainObjPtr vm) G_GNUC_NO_INLINE;
+void qemuProcessKillManagedPRDaemon(virDomainObj *vm) G_GNUC_NO_INLINE;
typedef struct _qemuProcessQMP qemuProcessQMP;
-typedef qemuProcessQMP *qemuProcessQMPPtr;
struct _qemuProcessQMP {
char *binary;
char *libDir;
char *pidfile;
char *uniqDir;
virEventThread *eventThread;
- virCommandPtr cmd;
- qemuMonitorPtr mon;
+ virCommand *cmd;
+ qemuMonitor *mon;
pid_t pid;
- virDomainObjPtr vm;
+ virDomainObj *vm;
bool forceTCG;
};
-qemuProcessQMPPtr qemuProcessQMPNew(const char *binary,
+qemuProcessQMP *qemuProcessQMPNew(const char *binary,
const char *libDir,
uid_t runUid,
gid_t runGid,
bool forceTCG);
-void qemuProcessQMPFree(qemuProcessQMPPtr proc);
+void qemuProcessQMPFree(qemuProcessQMP *proc);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuProcessQMP, qemuProcessQMPFree);
-int qemuProcessQMPStart(qemuProcessQMPPtr proc);
+int qemuProcessQMPStart(qemuProcessQMP *proc);
* This header file should never be used outside unit tests.
*/
-int qemuProcessHandleDeviceDeleted(qemuMonitorPtr mon,
- virDomainObjPtr vm,
+int qemuProcessHandleDeviceDeleted(qemuMonitor *mon,
+ virDomainObj *vm,
const char *devAlias,
void *opaque);
-int qemuProcessQMPInitMonitor(qemuMonitorPtr mon);
+int qemuProcessQMPInitMonitor(qemuMonitor *mon);
* Helper that selects the type of a QMP schema object member or it's variant
* member. Returns the QMP entry on success or NULL on error.
*/
-static virJSONValuePtr
+static virJSONValue *
virQEMUQAPISchemaObjectGet(const char *field,
const char *name,
const char *namefield,
- virJSONValuePtr elem)
+ virJSONValue *elem)
{
- virJSONValuePtr arr;
- virJSONValuePtr cur;
+ virJSONValue *arr;
+ virJSONValue *cur;
const char *curname;
size_t i;
const char *prevquery;
GHashTable *schema;
char **queries;
- virJSONValuePtr returnType;
+ virJSONValue *returnType;
size_t depth;
};
*/
static int
virQEMUQAPISchemaTraverseHasObjectFeature(const char *featurename,
- virJSONValuePtr elem)
+ virJSONValue *elem)
{
- virJSONValuePtr featuresarray;
- virJSONValuePtr cur;
+ virJSONValue *featuresarray;
+ virJSONValue *cur;
const char *curstr;
size_t i;
static int
-virQEMUQAPISchemaTraverseObject(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseObject(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
- virJSONValuePtr obj;
+ virJSONValue *obj;
const char *query = virQEMUQAPISchemaTraverseContextNextQuery(ctxt);
char modifier = *query;
static int
-virQEMUQAPISchemaTraverseArray(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseArray(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
const char *querytype;
static int
-virQEMUQAPISchemaTraverseCommand(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseCommand(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
const char *query = virQEMUQAPISchemaTraverseContextNextQuery(ctxt);
static int
-virQEMUQAPISchemaTraverseEnum(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseEnum(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
const char *query = virQEMUQAPISchemaTraverseContextNextQuery(ctxt);
- virJSONValuePtr values;
- virJSONValuePtr enumval;
+ virJSONValue *values;
+ virJSONValue *enumval;
const char *value;
size_t i;
static int
-virQEMUQAPISchemaTraverseBuiltin(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseBuiltin(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
const char *query = virQEMUQAPISchemaTraverseContextNextQuery(ctxt);
static int
-virQEMUQAPISchemaTraverseAlternate(virJSONValuePtr cur,
+virQEMUQAPISchemaTraverseAlternate(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
struct virQEMUQAPISchemaTraverseContext savectxt = *ctxt;
- virJSONValuePtr members;
- virJSONValuePtr member;
+ virJSONValue *members;
+ virJSONValue *member;
const char *membertype;
int rc;
size_t i;
/* The function must return 1 on successful query, 0 if the query was not found
* -1 when a libvirt error is reported, -2 if the schema is invalid and -3 if
* the query component is malformed. */
-typedef int (*virQEMUQAPISchemaTraverseFunc)(virJSONValuePtr cur,
+typedef int (*virQEMUQAPISchemaTraverseFunc)(virJSONValue *cur,
struct virQEMUQAPISchemaTraverseContext *ctxt);
struct virQEMUQAPISchemaTraverseMetaType {
virQEMUQAPISchemaTraverse(const char *baseName,
struct virQEMUQAPISchemaTraverseContext *ctxt)
{
- virJSONValuePtr cur;
+ virJSONValue *cur;
const char *metatype;
size_t i;
int
virQEMUQAPISchemaPathGet(const char *query,
GHashTable *schema,
- virJSONValuePtr *entry)
+ virJSONValue **entry)
{
g_auto(GStrv) elems = NULL;
struct virQEMUQAPISchemaTraverseContext ctxt;
static int
virQEMUQAPISchemaEntryProcess(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
const char *name;
* the schema. @schemareply is consumed and freed.
*/
GHashTable *
-virQEMUQAPISchemaConvert(virJSONValuePtr schemareply)
+virQEMUQAPISchemaConvert(virJSONValue *schemareply)
{
g_autoptr(GHashTable) schema = NULL;
g_autoptr(virJSONValue) schemajson = schemareply;
int
virQEMUQAPISchemaPathGet(const char *query,
GHashTable *schema,
- virJSONValuePtr *entry);
+ virJSONValue **entry);
bool
virQEMUQAPISchemaPathExists(const char *query,
GHashTable *schema);
GHashTable *
-virQEMUQAPISchemaConvert(virJSONValuePtr schemareply);
+virQEMUQAPISchemaConvert(virJSONValue *schemareply);
);
static inline void
-qemuSaveImageBswapHeader(virQEMUSaveHeaderPtr hdr)
+qemuSaveImageBswapHeader(virQEMUSaveHeader *hdr)
{
hdr->version = GUINT32_SWAP_LE_BE(hdr->version);
hdr->data_len = GUINT32_SWAP_LE_BE(hdr->data_len);
void
-virQEMUSaveDataFree(virQEMUSaveDataPtr data)
+virQEMUSaveDataFree(virQEMUSaveData *data)
{
if (!data)
return;
/**
* This function steals @domXML on success.
*/
-virQEMUSaveDataPtr
+virQEMUSaveData *
virQEMUSaveDataNew(char *domXML,
- qemuDomainSaveCookiePtr cookieObj,
+ qemuDomainSaveCookie *cookieObj,
bool running,
int compressed,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virQEMUSaveDataPtr data = NULL;
- virQEMUSaveHeaderPtr header;
+ virQEMUSaveData *data = NULL;
+ virQEMUSaveHeader *header;
data = g_new0(virQEMUSaveData, 1);
if (cookieObj &&
- !(data->cookie = virSaveCookieFormat((virObjectPtr) cookieObj,
+ !(data->cookie = virSaveCookieFormat((virObject *) cookieObj,
virDomainXMLOptionGetSaveCookie(xmlopt))))
goto error;
* Returns -1 on failure, or 0 on success.
*/
int
-virQEMUSaveDataWrite(virQEMUSaveDataPtr data,
+virQEMUSaveDataWrite(virQEMUSaveData *data,
int fd,
const char *path)
{
- virQEMUSaveHeaderPtr header = &data->header;
+ virQEMUSaveHeader *header = &data->header;
size_t len;
size_t xml_len;
size_t cookie_len = 0;
static int
-virQEMUSaveDataFinish(virQEMUSaveDataPtr data,
+virQEMUSaveDataFinish(virQEMUSaveData *data,
int *fd,
const char *path)
{
- virQEMUSaveHeaderPtr header = &data->header;
+ virQEMUSaveHeader *header = &data->header;
memcpy(header->magic, QEMU_SAVE_MAGIC, sizeof(header->magic));
}
-static virCommandPtr
+static virCommand *
qemuSaveImageGetCompressionCommand(virQEMUSaveFormat compression)
{
- virCommandPtr ret = NULL;
+ virCommand *ret = NULL;
const char *prog = qemuSaveCompressionTypeToString(compression);
if (!prog) {
* the caller needs to make sure that the processors are stopped and do all other
* actions besides saving memory */
int
-qemuSaveImageCreate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSaveImageCreate(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
- virQEMUSaveDataPtr data,
- virCommandPtr compressor,
+ virQEMUSaveData *data,
+ virCommand *compressor,
unsigned int flags,
qemuDomainAsyncJob asyncJob)
{
int ret = -1;
int fd = -1;
int directFlag = 0;
- virFileWrapperFdPtr wrapperFd = NULL;
+ virFileWrapperFd *wrapperFd = NULL;
unsigned int wrapperFlags = VIR_FILE_WRAPPER_NON_BLOCKING;
/* Obtain the file handle. */
*/
int
qemuSaveImageGetCompressionProgram(const char *imageFormat,
- virCommandPtr *compressor,
+ virCommand **compressor,
const char *styleFormat,
bool use_raw_on_fail)
{
* unlinked (no error raised).
*/
int
-qemuSaveImageOpen(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+qemuSaveImageOpen(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *path,
- virDomainDefPtr *ret_def,
- virQEMUSaveDataPtr *ret_data,
+ virDomainDef **ret_def,
+ virQEMUSaveData **ret_data,
bool bypass_cache,
- virFileWrapperFdPtr *wrapperFd,
+ virFileWrapperFd **wrapperFd,
bool open_write,
bool unlink_corrupt)
{
VIR_AUTOCLOSE fd = -1;
int ret = -1;
g_autoptr(virQEMUSaveData) data = NULL;
- virQEMUSaveHeaderPtr header;
+ virQEMUSaveHeader *header;
g_autoptr(virDomainDef) def = NULL;
int oflags = open_write ? O_RDWR : O_RDONLY;
size_t xml_len;
int
qemuSaveImageStartVM(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
int *fd,
- virQEMUSaveDataPtr data,
+ virQEMUSaveData *data,
const char *path,
bool start_paused,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
bool started = false;
- virObjectEventPtr event;
+ virObjectEvent *event;
VIR_AUTOCLOSE intermediatefd = -1;
g_autoptr(virCommand) cmd = NULL;
g_autofree char *errbuf = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virQEMUSaveHeaderPtr header = &data->header;
+ virQEMUSaveHeader *header = &data->header;
g_autoptr(qemuDomainSaveCookie) cookie = NULL;
int rc = 0;
- if (virSaveCookieParseString(data->cookie, (virObjectPtr *)&cookie,
+ if (virSaveCookieParseString(data->cookie, (virObject **)&cookie,
virDomainXMLOptionGetSaveCookie(driver->xmlopt)) < 0)
goto cleanup;
* Returns the new domain definition in case @newxml is ABI compatible with the
* guest.
*/
-virDomainDefPtr
-qemuSaveImageUpdateDef(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+virDomainDef *
+qemuSaveImageUpdateDef(virQEMUDriver *driver,
+ virDomainDef *def,
const char *newxml)
{
- virDomainDefPtr ret = NULL;
- virDomainDefPtr newdef_migr = NULL;
- virDomainDefPtr newdef = NULL;
+ virDomainDef *ret = NULL;
+ virDomainDef *newdef_migr = NULL;
+ virDomainDef *newdef = NULL;
if (!(newdef = virDomainDefParseString(newxml, driver->xmlopt, NULL,
VIR_DOMAIN_DEF_PARSE_INACTIVE)))
G_STATIC_ASSERT(sizeof(QEMU_SAVE_MAGIC) == sizeof(QEMU_SAVE_PARTIAL));
typedef struct _virQEMUSaveHeader virQEMUSaveHeader;
-typedef virQEMUSaveHeader *virQEMUSaveHeaderPtr;
struct _virQEMUSaveHeader {
char magic[sizeof(QEMU_SAVE_MAGIC)-1];
uint32_t version;
typedef struct _virQEMUSaveData virQEMUSaveData;
-typedef virQEMUSaveData *virQEMUSaveDataPtr;
struct _virQEMUSaveData {
virQEMUSaveHeader header;
char *xml;
};
-virDomainDefPtr
-qemuSaveImageUpdateDef(virQEMUDriverPtr driver,
- virDomainDefPtr def,
+virDomainDef *
+qemuSaveImageUpdateDef(virQEMUDriver *driver,
+ virDomainDef *def,
const char *newxml);
int
qemuSaveImageStartVM(virConnectPtr conn,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
int *fd,
- virQEMUSaveDataPtr data,
+ virQEMUSaveData *data,
const char *path,
bool start_paused,
qemuDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6);
int
-qemuSaveImageOpen(virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps,
+qemuSaveImageOpen(virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps,
const char *path,
- virDomainDefPtr *ret_def,
- virQEMUSaveDataPtr *ret_data,
+ virDomainDef **ret_def,
+ virQEMUSaveData **ret_data,
bool bypass_cache,
- virFileWrapperFdPtr *wrapperFd,
+ virFileWrapperFd **wrapperFd,
bool open_write,
bool unlink_corrupt)
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
int
qemuSaveImageGetCompressionProgram(const char *imageFormat,
- virCommandPtr *compressor,
+ virCommand **compressor,
const char *styleFormat,
bool use_raw_on_fail)
ATTRIBUTE_NONNULL(2);
int
-qemuSaveImageCreate(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSaveImageCreate(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
- virQEMUSaveDataPtr data,
- virCommandPtr compressor,
+ virQEMUSaveData *data,
+ virCommand *compressor,
unsigned int flags,
qemuDomainAsyncJob asyncJob);
int
-virQEMUSaveDataWrite(virQEMUSaveDataPtr data,
+virQEMUSaveDataWrite(virQEMUSaveData *data,
int fd,
const char *path);
-virQEMUSaveDataPtr
+virQEMUSaveData *
virQEMUSaveDataNew(char *domXML,
- qemuDomainSaveCookiePtr cookieObj,
+ qemuDomainSaveCookie *cookieObj,
bool running,
int compressed,
- virDomainXMLOptionPtr xmlopt);
+ virDomainXMLOption *xmlopt);
void
-virQEMUSaveDataFree(virQEMUSaveDataPtr data);
+virQEMUSaveDataFree(virQEMUSaveData *data);
int
-qemuSecuritySetAllLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSecuritySetAllLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *incomingPath,
bool migrated)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
if (qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
void
-qemuSecurityRestoreAllLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSecurityRestoreAllLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
bool migrated)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool transactionStarted = false;
/* In contrast to qemuSecuritySetAllLabel, do not use vm->pid
int
-qemuSecuritySetImageLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuSecuritySetImageLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
bool backingChain,
bool chainTop)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
virSecurityDomainImageLabelFlags labelFlags = 0;
int
-qemuSecurityRestoreImageLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+qemuSecurityRestoreImageLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
bool backingChain)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
virSecurityDomainImageLabelFlags labelFlags = 0;
int
-qemuSecurityMoveImageMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr dst)
+qemuSecurityMoveImageMetadata(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *dst)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
if (!priv->rememberOwner)
int
-qemuSecuritySetHostdevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuSecuritySetHostdevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
int
-qemuSecurityRestoreHostdevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev)
+qemuSecurityRestoreHostdevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
int
-qemuSecuritySetMemoryLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuSecuritySetMemoryLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
int
-qemuSecurityRestoreMemoryLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem)
+qemuSecurityRestoreMemoryLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
int
-qemuSecuritySetInputLabel(virDomainObjPtr vm,
- virDomainInputDefPtr input)
+qemuSecuritySetInputLabel(virDomainObj *vm,
+ virDomainInputDef *input)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
pid_t pid = -1;
int ret = -1;
int
-qemuSecurityRestoreInputLabel(virDomainObjPtr vm,
- virDomainInputDefPtr input)
+qemuSecurityRestoreInputLabel(virDomainObj *vm,
+ virDomainInputDef *input)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
pid_t pid = -1;
int ret = -1;
int
-qemuSecuritySetChardevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr)
+qemuSecuritySetChardevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
if (qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
int
-qemuSecurityRestoreChardevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr)
+qemuSecurityRestoreChardevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr)
{
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
if (qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
* exitstatus also set.
*/
int
-qemuSecurityStartVhostUserGPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+qemuSecurityStartVhostUserGPU(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
int *exitstatus,
int *cmdret)
{
* exitstatus also set.
*/
int
-qemuSecurityStartTPMEmulator(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+qemuSecurityStartTPMEmulator(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
uid_t uid,
gid_t gid,
int *exitstatus,
int *cmdret)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
bool transactionStarted = false;
void
-qemuSecurityCleanupTPMEmulator(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuSecurityCleanupTPMEmulator(virQEMUDriver *driver,
+ virDomainObj *vm)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool transactionStarted = false;
if (virSecurityManagerTransactionStart(driver->securityManager) >= 0)
int
-qemuSecurityDomainSetPathLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSecurityDomainSetPathLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
bool allowSubtree)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
int
-qemuSecurityDomainRestorePathLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuSecurityDomainRestorePathLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
pid_t pid = -1;
int ret = -1;
* -1 otherwise.
*/
int
-qemuSecurityCommandRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+qemuSecurityCommandRun(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
uid_t uid,
gid_t gid,
int *exitstatus,
#include "domain_conf.h"
#include "security/security_manager.h"
-int qemuSecuritySetAllLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuSecuritySetAllLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *incomingPath,
bool migrated);
-void qemuSecurityRestoreAllLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+void qemuSecurityRestoreAllLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
bool migrated);
-int qemuSecuritySetImageLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+int qemuSecuritySetImageLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
bool backingChain,
bool chainTop);
-int qemuSecurityRestoreImageLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
+int qemuSecurityRestoreImageLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
bool backingChain);
-int qemuSecurityMoveImageMetadata(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virStorageSourcePtr src,
- virStorageSourcePtr dst);
+int qemuSecurityMoveImageMetadata(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virStorageSource *src,
+ virStorageSource *dst);
-int qemuSecuritySetHostdevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
+int qemuSecuritySetHostdevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
-int qemuSecurityRestoreHostdevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainHostdevDefPtr hostdev);
+int qemuSecurityRestoreHostdevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainHostdevDef *hostdev);
-int qemuSecuritySetMemoryLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
+int qemuSecuritySetMemoryLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem);
-int qemuSecurityRestoreMemoryLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMemoryDefPtr mem);
+int qemuSecurityRestoreMemoryLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMemoryDef *mem);
-int qemuSecuritySetInputLabel(virDomainObjPtr vm,
- virDomainInputDefPtr input);
+int qemuSecuritySetInputLabel(virDomainObj *vm,
+ virDomainInputDef *input);
-int qemuSecurityRestoreInputLabel(virDomainObjPtr vm,
- virDomainInputDefPtr input);
+int qemuSecurityRestoreInputLabel(virDomainObj *vm,
+ virDomainInputDef *input);
-int qemuSecuritySetChardevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr);
+int qemuSecuritySetChardevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr);
-int qemuSecurityRestoreChardevLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainChrDefPtr chr);
+int qemuSecurityRestoreChardevLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainChrDef *chr);
-int qemuSecurityStartVhostUserGPU(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+int qemuSecurityStartVhostUserGPU(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
int *exitstatus,
int *cmdret);
-int qemuSecurityStartTPMEmulator(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+int qemuSecurityStartTPMEmulator(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
uid_t uid,
gid_t gid,
int *exitstatus,
int *cmdret);
-void qemuSecurityCleanupTPMEmulator(virQEMUDriverPtr driver,
- virDomainObjPtr vm);
+void qemuSecurityCleanupTPMEmulator(virQEMUDriver *driver,
+ virDomainObj *vm);
-int qemuSecuritySetSavedStateLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuSecuritySetSavedStateLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *savefile);
-int qemuSecurityRestoreSavedStateLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuSecurityRestoreSavedStateLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *savefile);
-int qemuSecurityDomainSetPathLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuSecurityDomainSetPathLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path,
bool allowSubtree);
-int qemuSecurityDomainRestorePathLabel(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuSecurityDomainRestorePathLabel(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *path);
-int qemuSecurityCommandRun(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virCommandPtr cmd,
+int qemuSecurityCommandRun(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virCommand *cmd,
uid_t uid,
gid_t gid,
int *exitstatus,
void
-qemuSlirpFree(qemuSlirpPtr slirp)
+qemuSlirpFree(qemuSlirp *slirp)
{
if (!slirp)
return;
void
-qemuSlirpSetFeature(qemuSlirpPtr slirp,
+qemuSlirpSetFeature(qemuSlirp *slirp,
qemuSlirpFeature feature)
{
ignore_value(virBitmapSetBit(slirp->features, feature));
}
-qemuSlirpPtr
+qemuSlirp *
qemuSlirpNew(void)
{
g_autoptr(qemuSlirp) slirp = g_new0(qemuSlirp, 1);
}
-qemuSlirpPtr
+qemuSlirp *
qemuSlirpNewForHelper(const char *helper)
{
g_autoptr(qemuSlirp) slirp = NULL;
g_autoptr(virCommand) cmd = NULL;
g_autofree char *output = NULL;
g_autoptr(virJSONValue) doc = NULL;
- virJSONValuePtr featuresJSON;
+ virJSONValue *featuresJSON;
size_t i, nfeatures;
slirp = qemuSlirpNew();
nfeatures = virJSONValueArraySize(featuresJSON);
for (i = 0; i < nfeatures; i++) {
- virJSONValuePtr item = virJSONValueArrayGet(featuresJSON, i);
+ virJSONValue *item = virJSONValueArrayGet(featuresJSON, i);
const char *tmpStr = virJSONValueGetString(item);
int tmp;
static char *
-qemuSlirpCreatePidFilename(virQEMUDriverConfigPtr cfg,
+qemuSlirpCreatePidFilename(virQEMUDriverConfig *cfg,
const virDomainDef *def,
const char *alias)
{
int
-qemuSlirpOpen(qemuSlirpPtr slirp,
- virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuSlirpOpen(qemuSlirp *slirp,
+ virQEMUDriver *driver,
+ virDomainDef *def)
{
int rc, pair[2] = { -1, -1 };
int
-qemuSlirpGetFD(qemuSlirpPtr slirp)
+qemuSlirpGetFD(qemuSlirp *slirp)
{
int fd = slirp->fd[0];
slirp->fd[0] = -1;
static char *
-qemuSlirpGetDBusVMStateId(virDomainNetDefPtr net)
+qemuSlirpGetDBusVMStateId(virDomainNetDef *net)
{
char macstr[VIR_MAC_STRING_BUFLEN] = "";
void
-qemuSlirpStop(qemuSlirpPtr slirp,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net)
+qemuSlirpStop(qemuSlirp *slirp,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
+ virDomainNetDef *net)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *id = qemuSlirpGetDBusVMStateId(net);
int
-qemuSlirpSetupCgroup(qemuSlirpPtr slirp,
- virCgroupPtr cgroup)
+qemuSlirpSetupCgroup(qemuSlirp *slirp,
+ virCgroup *cgroup)
{
return virCgroupAddProcess(cgroup, slirp->pid);
}
int
-qemuSlirpStart(qemuSlirpPtr slirp,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+qemuSlirpStart(qemuSlirp *slirp,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
bool incoming)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
VIR_ENUM_DECL(qemuSlirpFeature);
typedef struct _qemuSlirp qemuSlirp;
-typedef qemuSlirp *qemuSlirpPtr;
struct _qemuSlirp {
int fd[2];
- virBitmapPtr features;
+ virBitmap *features;
pid_t pid;
};
-qemuSlirpPtr qemuSlirpNew(void);
+qemuSlirp *qemuSlirpNew(void);
-qemuSlirpPtr qemuSlirpNewForHelper(const char *helper);
+qemuSlirp *qemuSlirpNewForHelper(const char *helper);
-void qemuSlirpFree(qemuSlirpPtr slirp);
+void qemuSlirpFree(qemuSlirp *slirp);
-void qemuSlirpSetFeature(qemuSlirpPtr slirp,
+void qemuSlirpSetFeature(qemuSlirp *slirp,
qemuSlirpFeature feature);
bool qemuSlirpHasFeature(const qemuSlirp *slirp,
qemuSlirpFeature feature);
-int qemuSlirpOpen(qemuSlirpPtr slirp,
- virQEMUDriverPtr driver,
- virDomainDefPtr def);
+int qemuSlirpOpen(qemuSlirp *slirp,
+ virQEMUDriver *driver,
+ virDomainDef *def);
-int qemuSlirpStart(qemuSlirpPtr slirp,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net,
+int qemuSlirpStart(qemuSlirp *slirp,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
+ virDomainNetDef *net,
bool incoming);
-void qemuSlirpStop(qemuSlirpPtr slirp,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
- virDomainNetDefPtr net);
+void qemuSlirpStop(qemuSlirp *slirp,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
+ virDomainNetDef *net);
-int qemuSlirpGetFD(qemuSlirpPtr slirp);
+int qemuSlirpGetFD(qemuSlirp *slirp);
-int qemuSlirpSetupCgroup(qemuSlirpPtr slirp,
- virCgroupPtr cgroup);
+int qemuSlirpSetupCgroup(qemuSlirp *slirp,
+ virCgroup *cgroup);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuSlirp, qemuSlirpFree);
* the snapshot which was 'current' previously is updated.
*/
static void
-qemuSnapshotSetCurrent(virDomainObjPtr vm,
- virDomainMomentObjPtr newcurrent)
+qemuSnapshotSetCurrent(virDomainObj *vm,
+ virDomainMomentObj *newcurrent)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virDomainMomentObjPtr oldcurrent = virDomainSnapshotGetCurrent(vm->snapshots);
+ virDomainMomentObj *oldcurrent = virDomainSnapshotGetCurrent(vm->snapshots);
virDomainSnapshotSetCurrent(vm->snapshots, newcurrent);
/* Looks up snapshot object from VM and name */
-virDomainMomentObjPtr
-qemuSnapObjFromName(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuSnapObjFromName(virDomainObj *vm,
const char *name)
{
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
snap = virDomainSnapshotFindByName(vm->snapshots, name);
if (!snap)
virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
/* Looks up snapshot object from VM and snapshotPtr */
-virDomainMomentObjPtr
-qemuSnapObjFromSnapshot(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuSnapObjFromSnapshot(virDomainObj *vm,
virDomainSnapshotPtr snapshot)
{
return qemuSnapObjFromName(vm, snapshot->name);
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr snap = payload;
+ virDomainMomentObj *snap = payload;
int *count = data;
if (virDomainSnapshotIsExternal(snap))
int
-qemuSnapshotFSFreeze(virDomainObjPtr vm,
+qemuSnapshotFSFreeze(virDomainObj *vm,
const char **mountpoints,
unsigned int nmountpoints)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int frozen;
if (!qemuDomainAgentAvailable(vm, true))
/* Return -1 on error, otherwise number of thawed filesystems. */
int
-qemuSnapshotFSThaw(virDomainObjPtr vm,
+qemuSnapshotFSThaw(virDomainObj *vm,
bool report)
{
- qemuAgentPtr agent;
+ qemuAgent *agent;
int thawed;
virErrorPtr err = NULL;
/* The domain is expected to be locked and inactive. */
static int
-qemuSnapshotCreateInactiveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap)
+qemuSnapshotCreateInactiveInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap)
{
return qemuDomainSnapshotForEachQcow2(driver, vm->def, snap, "-c", false);
}
/* The domain is expected to be locked and inactive. */
static int
-qemuSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
+qemuSnapshotCreateInactiveExternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap,
bool reuse)
{
size_t i;
- virDomainSnapshotDiskDefPtr snapdisk;
- virDomainDiskDefPtr defdisk;
- virCommandPtr cmd = NULL;
+ virDomainSnapshotDiskDef *snapdisk;
+ virDomainDiskDef *defdisk;
+ virCommand *cmd = NULL;
const char *qemuImgPath;
- virBitmapPtr created = NULL;
+ virBitmap *created = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int ret = -1;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ virDomainSnapshotDef *snapdef = virDomainSnapshotObjGetDef(snap);
if (!(qemuImgPath = qemuFindQemuImgBinary(driver)))
goto cleanup;
/* The domain is expected to be locked and active. */
static int
-qemuSnapshotCreateActiveInternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
+qemuSnapshotCreateActiveInternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap,
unsigned int flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virObjectEventPtr event = NULL;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virObjectEvent *event = NULL;
bool resume = false;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ virDomainSnapshotDef *snapdef = virDomainSnapshotObjGetDef(snap);
int ret = -1;
if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
if (ret < 0)
goto cleanup;
- if (!(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
+ if (!(snapdef->cookie = (virObject *) qemuDomainSaveCookieNew(vm)))
goto cleanup;
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
static int
-qemuSnapshotPrepareDiskShared(virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk)
+qemuSnapshotPrepareDiskShared(virDomainSnapshotDiskDef *snapdisk,
+ virDomainDiskDef *domdisk)
{
if (!domdisk->src->shared || domdisk->src->readonly)
return 0;
static int
-qemuSnapshotPrepareDiskExternalInactive(virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk)
+qemuSnapshotPrepareDiskExternalInactive(virDomainSnapshotDiskDef *snapdisk,
+ virDomainDiskDef *domdisk)
{
int domDiskType = virStorageSourceGetActualType(domdisk->src);
int snapDiskType = virStorageSourceGetActualType(snapdisk->src);
static int
-qemuSnapshotPrepareDiskExternalActive(virDomainObjPtr vm,
- virDomainSnapshotDiskDefPtr snapdisk,
- virDomainDiskDefPtr domdisk,
+qemuSnapshotPrepareDiskExternalActive(virDomainObj *vm,
+ virDomainSnapshotDiskDef *snapdisk,
+ virDomainDiskDef *domdisk,
bool blockdev)
{
int actualType = virStorageSourceGetActualType(snapdisk->src);
static int
-qemuSnapshotPrepareDiskExternal(virDomainObjPtr vm,
- virDomainDiskDefPtr disk,
- virDomainSnapshotDiskDefPtr snapdisk,
+qemuSnapshotPrepareDiskExternal(virDomainObj *vm,
+ virDomainDiskDef *disk,
+ virDomainSnapshotDiskDef *snapdisk,
bool active,
bool reuse,
bool blockdev)
static int
-qemuSnapshotPrepareDiskInternal(virDomainDiskDefPtr disk,
+qemuSnapshotPrepareDiskInternal(virDomainDiskDef *disk,
bool active)
{
int actualType;
static int
-qemuSnapshotPrepare(virDomainObjPtr vm,
- virDomainSnapshotDefPtr def,
+qemuSnapshotPrepare(virDomainObj *vm,
+ virDomainSnapshotDef *def,
unsigned int *flags)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
size_t i;
bool active = virDomainObjIsActive(vm);
int external = 0;
for (i = 0; i < def->ndisks; i++) {
- virDomainSnapshotDiskDefPtr disk = &def->disks[i];
- virDomainDiskDefPtr dom_disk = vm->def->disks[i];
+ virDomainSnapshotDiskDef *disk = &def->disks[i];
+ virDomainDiskDef *dom_disk = vm->def->disks[i];
if (disk->snapshot != VIR_DOMAIN_SNAPSHOT_LOCATION_NONE &&
qemuDomainDiskBlockJobIsActive(dom_disk))
struct _qemuSnapshotDiskData {
- virStorageSourcePtr src;
+ virStorageSource *src;
bool initialized; /* @src was initialized in the storage driver */
bool created; /* @src was created by the snapshot code */
bool prepared; /* @src was prepared using qemuDomainStorageSourceAccessAllow */
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
char *relPath; /* relative path component to fill into original disk */
- qemuBlockStorageSourceChainDataPtr crdata;
+ qemuBlockStorageSourceChainData *crdata;
bool blockdevadded;
- virStorageSourcePtr persistsrc;
- virDomainDiskDefPtr persistdisk;
+ virStorageSource *persistsrc;
+ virDomainDiskDef *persistdisk;
};
typedef struct _qemuSnapshotDiskData qemuSnapshotDiskData;
-typedef qemuSnapshotDiskData *qemuSnapshotDiskDataPtr;
static void
-qemuSnapshotDiskCleanup(qemuSnapshotDiskDataPtr data,
+qemuSnapshotDiskCleanup(qemuSnapshotDiskData *data,
size_t ndata,
- virDomainObjPtr vm,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
virErrorPtr orig_err;
size_t i;
struct _qemuSnapshotDiskContext {
- qemuSnapshotDiskDataPtr dd;
+ qemuSnapshotDiskData *dd;
size_t ndd;
- virJSONValuePtr actions;
+ virJSONValue *actions;
/* needed for automatic cleanup of 'dd' */
- virDomainObjPtr vm;
+ virDomainObj *vm;
qemuDomainAsyncJob asyncJob;
};
typedef struct _qemuSnapshotDiskContext qemuSnapshotDiskContext;
-typedef qemuSnapshotDiskContext *qemuSnapshotDiskContextPtr;
-static qemuSnapshotDiskContextPtr
+static qemuSnapshotDiskContext *
qemuSnapshotDiskContextNew(size_t ndisks,
- virDomainObjPtr vm,
+ virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuSnapshotDiskContextPtr ret = g_new0(qemuSnapshotDiskContext, 1);
+ qemuSnapshotDiskContext *ret = g_new0(qemuSnapshotDiskContext, 1);
ret->dd = g_new0(qemuSnapshotDiskData, ndisks);
ret->actions = virJSONValueNewArray();
static void
-qemuSnapshotDiskContextCleanup(qemuSnapshotDiskContextPtr snapctxt)
+qemuSnapshotDiskContextCleanup(qemuSnapshotDiskContext *snapctxt)
{
if (!snapctxt)
return;
* expected.
*/
static int
-qemuSnapshotDiskBitmapsPropagate(qemuSnapshotDiskDataPtr dd,
- virJSONValuePtr actions,
+qemuSnapshotDiskBitmapsPropagate(qemuSnapshotDiskData *dd,
+ virJSONValue *actions,
GHashTable *blockNamedNodeData)
{
- qemuBlockNamedNodeDataPtr entry;
+ qemuBlockNamedNodeData *entry;
size_t i;
if (!(entry = virHashLookup(blockNamedNodeData, dd->disk->src->nodeformat)))
return 0;
for (i = 0; i < entry->nbitmaps; i++) {
- qemuBlockNamedNodeDataBitmapPtr bitmap = entry->bitmaps[i];
+ qemuBlockNamedNodeDataBitmap *bitmap = entry->bitmaps[i];
/* we don't care about temporary, inconsistent, or disabled bitmaps */
if (!bitmap->persistent || !bitmap->recording || bitmap->inconsistent)
static int
-qemuSnapshotDiskPrepareOneBlockdev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- qemuSnapshotDiskDataPtr dd,
- virQEMUDriverConfigPtr cfg,
+qemuSnapshotDiskPrepareOneBlockdev(virQEMUDriver *driver,
+ virDomainObj *vm,
+ qemuSnapshotDiskData *dd,
+ virQEMUDriverConfig *cfg,
bool reuse,
GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(virStorageSource) terminator = NULL;
int rc;
static int
-qemuSnapshotDiskPrepareOne(virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
- virDomainDiskDefPtr disk,
- virDomainSnapshotDiskDefPtr snapdisk,
- qemuSnapshotDiskDataPtr dd,
+qemuSnapshotDiskPrepareOne(virDomainObj *vm,
+ virQEMUDriverConfig *cfg,
+ virDomainDiskDef *disk,
+ virDomainSnapshotDiskDef *snapdisk,
+ qemuSnapshotDiskData *dd,
GHashTable *blockNamedNodeData,
bool reuse,
bool updateConfig,
qemuDomainAsyncJob asyncJob,
- virJSONValuePtr actions)
+ virJSONValue *actions)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
- virDomainDiskDefPtr persistdisk;
+ virDomainDiskDef *persistdisk;
bool supportsCreate;
bool updateRelativeBacking = false;
* Collects and prepares a list of structures that hold information about disks
* that are selected for the snapshot.
*/
-static qemuSnapshotDiskContextPtr
-qemuSnapshotDiskPrepareActiveExternal(virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- virQEMUDriverConfigPtr cfg,
+static qemuSnapshotDiskContext *
+qemuSnapshotDiskPrepareActiveExternal(virDomainObj *vm,
+ virDomainMomentObj *snap,
+ virQEMUDriverConfig *cfg,
bool reuse,
GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(qemuSnapshotDiskContext) snapctxt = NULL;
size_t i;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ virDomainSnapshotDef *snapdef = virDomainSnapshotObjGetDef(snap);
snapctxt = qemuSnapshotDiskContextNew(snapdef->ndisks, vm, asyncJob);
}
-static qemuSnapshotDiskContextPtr
-qemuSnapshotDiskPrepareDisksTransient(virDomainObjPtr vm,
- virQEMUDriverConfigPtr cfg,
+static qemuSnapshotDiskContext *
+qemuSnapshotDiskPrepareDisksTransient(virDomainObj *vm,
+ virQEMUDriverConfig *cfg,
GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
snapctxt = qemuSnapshotDiskContextNew(vm->def->ndisks, vm, asyncJob);
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr domdisk = vm->def->disks[i];
+ virDomainDiskDef *domdisk = vm->def->disks[i];
g_autoptr(virDomainSnapshotDiskDef) snapdisk = g_new0(virDomainSnapshotDiskDef, 1);
if (!domdisk->transient)
static void
-qemuSnapshotDiskUpdateSourceRenumber(virStorageSourcePtr src)
+qemuSnapshotDiskUpdateSourceRenumber(virStorageSource *src)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
unsigned int idx = 1;
for (next = src->backingStore; virStorageSourceIsBacking(next); next = next->backingStore)
* Updates disk definition after a successful snapshot.
*/
static void
-qemuSnapshotDiskUpdateSource(virDomainObjPtr vm,
- qemuSnapshotDiskDataPtr dd)
+qemuSnapshotDiskUpdateSource(virDomainObj *vm,
+ qemuSnapshotDiskData *dd)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
/* storage driver access won'd be needed */
if (dd->initialized)
static int
-qemuSnapshotDiskCreate(qemuSnapshotDiskContextPtr snapctxt,
- virQEMUDriverConfigPtr cfg)
+qemuSnapshotDiskCreate(qemuSnapshotDiskContext *snapctxt,
+ virQEMUDriverConfig *cfg)
{
- qemuDomainObjPrivatePtr priv = snapctxt->vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = snapctxt->vm->privateData;
+ virQEMUDriver *driver = priv->driver;
size_t i;
int rc;
rc = -1;
for (i = 0; i < snapctxt->ndd; i++) {
- qemuSnapshotDiskDataPtr dd = snapctxt->dd + i;
+ qemuSnapshotDiskData *dd = snapctxt->dd + i;
virDomainAuditDisk(snapctxt->vm, dd->disk->src, dd->src, "snapshot", rc >= 0);
/* The domain is expected to be locked and active. */
static int
-qemuSnapshotCreateActiveExternalDisks(virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
+qemuSnapshotCreateActiveExternalDisks(virDomainObj *vm,
+ virDomainMomentObj *snap,
GHashTable *blockNamedNodeData,
unsigned int flags,
- virQEMUDriverConfigPtr cfg,
+ virQEMUDriverConfig *cfg,
qemuDomainAsyncJob asyncJob)
{
bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
* configuration.
*/
int
-qemuSnapshotCreateDisksTransient(virDomainObjPtr vm,
+qemuSnapshotCreateDisksTransient(virDomainObj *vm,
qemuDomainAsyncJob asyncJob)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
- virQEMUDriverPtr driver = priv->driver;
+ qemuDomainObjPrivate *priv = vm->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(qemuSnapshotDiskContext) snapctxt = NULL;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
static int
-qemuSnapshotCreateActiveExternal(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap,
- virQEMUDriverConfigPtr cfg,
+qemuSnapshotCreateActiveExternal(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap,
+ virQEMUDriverConfig *cfg,
unsigned int flags)
{
- virObjectEventPtr event;
+ virObjectEvent *event;
bool resume = false;
int ret = -1;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *xml = NULL;
- virDomainSnapshotDefPtr snapdef = virDomainSnapshotObjGetDef(snap);
+ virDomainSnapshotDef *snapdef = virDomainSnapshotObjGetDef(snap);
bool memory = snapdef->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
bool memory_unlink = false;
bool thaw = false;
bool pmsuspended = false;
int compressed;
g_autoptr(virCommand) compressor = NULL;
- virQEMUSaveDataPtr data = NULL;
+ virQEMUSaveData *data = NULL;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
/* If quiesce was requested, then issue a freeze command, and a
if (!(xml = qemuDomainDefFormatLive(driver, priv->qemuCaps,
vm->def, priv->origCPU,
true, true)) ||
- !(snapdef->cookie = (virObjectPtr) qemuDomainSaveCookieNew(vm)))
+ !(snapdef->cookie = (virObject *) qemuDomainSaveCookieNew(vm)))
goto cleanup;
if (!(data = virQEMUSaveDataNew(xml,
- (qemuDomainSaveCookiePtr) snapdef->cookie,
+ (qemuDomainSaveCookie *) snapdef->cookie,
resume, compressed, driver->xmlopt)))
goto cleanup;
xml = NULL;
virDomainSnapshotPtr
qemuSnapshotCreateXML(virDomainPtr domain,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlDesc,
unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
+ virQEMUDriver *driver = domain->conn->privateData;
g_autofree char *xml = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr snapshot = NULL;
- virDomainMomentObjPtr current = NULL;
+ virDomainMomentObj *current = NULL;
bool update_current = true;
bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
unsigned int parse_flags = VIR_DOMAIN_SNAPSHOT_PARSE_DISKS;
int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
bool align_match = true;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
virDomainSnapshotState state;
g_autoptr(virDomainSnapshotDef) def = NULL;
/* The domain is expected to be locked and inactive. */
static int
-qemuSnapshotRevertInactive(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainMomentObjPtr snap)
+qemuSnapshotRevertInactive(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainMomentObj *snap)
{
/* Prefer action on the disks in use at the time the snapshot was
* created; but fall back to current definition if dealing with a
* snapshot created prior to libvirt 0.9.5. */
- virDomainDefPtr def = snap->def->dom;
+ virDomainDef *def = snap->def->dom;
if (!def)
def = vm->def;
int
-qemuSnapshotRevert(virDomainObjPtr vm,
+qemuSnapshotRevert(virDomainObj *vm,
virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
+ virQEMUDriver *driver = snapshot->domain->conn->privateData;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
- virDomainSnapshotDefPtr snapdef;
- virObjectEventPtr event = NULL;
- virObjectEventPtr event2 = NULL;
+ virDomainMomentObj *snap = NULL;
+ virDomainSnapshotDef *snapdef;
+ virObjectEvent *event = NULL;
+ virObjectEvent *event2 = NULL;
int detail;
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
int rc;
- virDomainDefPtr config = NULL;
- virDomainDefPtr inactiveConfig = NULL;
+ virDomainDef *config = NULL;
+ virDomainDef *inactiveConfig = NULL;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
bool was_stopped = false;
- qemuDomainSaveCookiePtr cookie;
- virCPUDefPtr origCPU = NULL;
+ qemuDomainSaveCookie *cookie;
+ virCPUDef *origCPU = NULL;
unsigned int start_flags = VIR_QEMU_PROCESS_START_GEN_VMID;
bool defined = false;
}
}
- cookie = (qemuDomainSaveCookiePtr) snapdef->cookie;
+ cookie = (qemuDomainSaveCookie *) snapdef->cookie;
switch ((virDomainSnapshotState) snapdef->state) {
case VIR_DOMAIN_SNAPSHOT_RUNNING:
typedef struct _virQEMUMomentReparent virQEMUMomentReparent;
-typedef virQEMUMomentReparent *virQEMUMomentReparentPtr;
struct _virQEMUMomentReparent {
const char *dir;
- virDomainMomentObjPtr parent;
- virDomainObjPtr vm;
- virDomainXMLOptionPtr xmlopt;
+ virDomainMomentObj *parent;
+ virDomainObj *vm;
+ virDomainXMLOption *xmlopt;
int err;
- int (*writeMetadata)(virDomainObjPtr, virDomainMomentObjPtr,
- virDomainXMLOptionPtr, const char *);
+ int (*writeMetadata)(virDomainObj *, virDomainMomentObj *,
+ virDomainXMLOption *, const char *);
};
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr moment = payload;
- virQEMUMomentReparentPtr rep = data;
+ virDomainMomentObj *moment = payload;
+ virQEMUMomentReparent *rep = data;
if (rep->err < 0)
return 0;
int
-qemuSnapshotDelete(virDomainObjPtr vm,
+qemuSnapshotDelete(virDomainObj *vm,
virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
+ virQEMUDriver *driver = snapshot->domain->conn->privateData;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
virQEMUMomentRemove rem;
virQEMUMomentReparent rep;
bool metadata_only = !!(flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY);
#include "qemu_conf.h"
#include "qemu_domainjob.h"
-virDomainMomentObjPtr
-qemuSnapObjFromName(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuSnapObjFromName(virDomainObj *vm,
const char *name);
-virDomainMomentObjPtr
-qemuSnapObjFromSnapshot(virDomainObjPtr vm,
+virDomainMomentObj *
+qemuSnapObjFromSnapshot(virDomainObj *vm,
virDomainSnapshotPtr snapshot);
int
-qemuSnapshotFSFreeze(virDomainObjPtr vm,
+qemuSnapshotFSFreeze(virDomainObj *vm,
const char **mountpoints,
unsigned int nmountpoints);
int
-qemuSnapshotFSThaw(virDomainObjPtr vm,
+qemuSnapshotFSThaw(virDomainObj *vm,
bool report);
virDomainSnapshotPtr
qemuSnapshotCreateXML(virDomainPtr domain,
- virDomainObjPtr vm,
+ virDomainObj *vm,
const char *xmlDesc,
unsigned int flags);
int
-qemuSnapshotRevert(virDomainObjPtr vm,
+qemuSnapshotRevert(virDomainObj *vm,
virDomainSnapshotPtr snapshot,
unsigned int flags);
int
-qemuSnapshotDelete(virDomainObjPtr vm,
+qemuSnapshotDelete(virDomainObj *vm,
virDomainSnapshotPtr snapshot,
unsigned int flags);
int
-qemuSnapshotCreateDisksTransient(virDomainObjPtr vm,
+qemuSnapshotCreateDisksTransient(virDomainObj *vm,
qemuDomainAsyncJob asyncJob);
static void
-qemuTPMDeleteEmulatorStorage(virDomainTPMDefPtr tpm)
+qemuTPMDeleteEmulatorStorage(virDomainTPMDef *tpm)
{
g_autofree char *path = g_path_get_dirname(tpm->data.emulator.storagepath);
* @uuid: the UUID of the VM
*/
static int
-qemuTPMEmulatorInitPaths(virDomainTPMDefPtr tpm,
+qemuTPMEmulatorInitPaths(virDomainTPMDef *tpm,
const char *swtpmStorageDir,
const char *logDir,
const char *vmname,
* the socket between tss and qemu users.
*/
static int
-qemuTPMEmulatorPrepareHost(virDomainTPMDefPtr tpm,
+qemuTPMEmulatorPrepareHost(virDomainTPMDef *tpm,
const char *logDir,
uid_t swtpm_user,
gid_t swtpm_group,
*/
static int
qemuTPMSetupEncryption(const unsigned char *secretuuid,
- virCommandPtr cmd)
+ virCommand *cmd)
{
g_autoptr(virConnect) conn = NULL;
g_autofree uint8_t *secret = NULL;
* Do some initializations on the way, such as creation of storage
* and emulator setup.
*/
-static virCommandPtr
-qemuTPMEmulatorBuildCommand(virDomainTPMDefPtr tpm,
+static virCommand *
+qemuTPMEmulatorBuildCommand(virDomainTPMDef *tpm,
const char *vmname,
const unsigned char *vmuuid,
bool privileged,
qemuTPMEmulatorStop(const char *swtpmStateDir,
const char *shortName)
{
- virCommandPtr cmd;
+ virCommand *cmd;
g_autofree char *pathname = NULL;
g_autofree char *errbuf = NULL;
g_autofree char *swtpm_ioctl = virTPMGetSwtpmIoctl();
int
-qemuExtTPMInitPaths(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuExtTPMInitPaths(virQEMUDriver *driver,
+ virDomainDef *def)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
size_t i;
int
-qemuExtTPMPrepareHost(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+qemuExtTPMPrepareHost(virQEMUDriver *driver,
+ virDomainDef *def)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *shortName = NULL;
void
-qemuExtTPMCleanupHost(virDomainDefPtr def)
+qemuExtTPMCleanupHost(virDomainDef *def)
{
size_t i;
* - start the external TPM Emulator and sync with it before QEMU start
*/
static int
-qemuExtTPMStartEmulator(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainTPMDefPtr tpm,
+qemuExtTPMStartEmulator(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainTPMDef *tpm,
bool incomingMigration)
{
g_autoptr(virCommand) cmd = NULL;
int
-qemuExtTPMStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuExtTPMStart(virQEMUDriver *driver,
+ virDomainObj *vm,
bool incomingMigration)
{
size_t i;
void
-qemuExtTPMStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+qemuExtTPMStop(virQEMUDriver *driver,
+ virDomainObj *vm)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
size_t i;
int
-qemuExtTPMSetupCgroup(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virCgroupPtr cgroup)
+qemuExtTPMSetupCgroup(virQEMUDriver *driver,
+ virDomainDef *def,
+ virCgroup *cgroup)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
int rc;
#include "vircommand.h"
-int qemuExtTPMInitPaths(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+int qemuExtTPMInitPaths(virQEMUDriver *driver,
+ virDomainDef *def)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuExtTPMPrepareHost(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+int qemuExtTPMPrepareHost(virQEMUDriver *driver,
+ virDomainDef *def)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuExtTPMCleanupHost(virDomainDefPtr def)
+void qemuExtTPMCleanupHost(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
-int qemuExtTPMStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+int qemuExtTPMStart(virQEMUDriver *driver,
+ virDomainObj *vm,
bool incomingMigration)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuExtTPMStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm)
+void qemuExtTPMStop(virQEMUDriver *driver,
+ virDomainObj *vm)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuExtTPMSetupCgroup(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virCgroupPtr cgroup)
+int qemuExtTPMSetupCgroup(virQEMUDriver *driver,
+ virDomainDef *def,
+ virCgroup *cgroup)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
G_GNUC_WARN_UNUSED_RESULT;
static int
qemuValidateDomainDefPSeriesFeature(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps,
+ virQEMUCaps *qemuCaps,
int feature)
{
const char *str;
static int
qemuValidateDomainDefFeatures(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
static int
-qemuValidateDomainDefCpu(virQEMUDriverPtr driver,
+qemuValidateDomainDefCpu(virQEMUDriver *driver,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
- virCPUDefPtr cpu = def->cpu;
+ virCPUDef *cpu = def->cpu;
if (!cpu)
return 0;
static int
qemuValidateDomainDefClockTimers(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
for (i = 0; i < def->clock.ntimers; i++) {
- virDomainTimerDefPtr timer = def->clock.timers[i];
+ virDomainTimerDef *timer = def->clock.timers[i];
switch ((virDomainTimerNameType)timer->name) {
case VIR_DOMAIN_TIMER_NAME_PLATFORM:
static int
qemuValidateDomainDefPM(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
bool q35Dom = qemuDomainIsQ35(def);
static int
qemuValidateDomainDefBoot(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (def->os.loader &&
def->os.loader->secure == VIR_TRISTATE_BOOL_YES) {
static int
-qemuValidateDomainVCpuTopology(const virDomainDef *def, virQEMUCapsPtr qemuCaps)
+qemuValidateDomainVCpuTopology(const virDomainDef *def, virQEMUCaps *qemuCaps)
{
unsigned int maxCpus = virQEMUCapsGetMachineMaxCpus(qemuCaps, def->virtType,
def->os.machine);
static int
qemuValidateDomainDefMemory(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const char *defaultRAMid = virQEMUCapsGetMachineDefaultRAMid(qemuCaps,
def->virtType,
static int
qemuValidateDomainDefNuma(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const long system_page_size = virGetSystemPageSizeKB();
size_t ncells = virDomainNumaGetNodeCount(def->numa);
}
for (i = 0; i < ncells; i++) {
- virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(def->numa, i);
+ virBitmap *cpumask = virDomainNumaGetNodeCpumask(def->numa, i);
if (!hasMemoryCap &&
virDomainNumaGetNodeMemoryAccessMode(def->numa, i)) {
static int
qemuValidateDomainDefConsole(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
/* Explicit console devices */
for (i = 0; i < def->nconsoles; i++) {
- virDomainChrDefPtr console = def->consoles[i];
+ virDomainChrDef *console = def->consoles[i];
switch (console->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
static int
qemuValidateDomainDefSysinfo(const virSysinfoDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
static int
qemuValidateDomainDefPanic(const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
static int
-qemuValidateDomainDeviceInfo(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainDeviceDefPtr dev G_GNUC_UNUSED,
- virDomainDeviceInfoPtr info,
+qemuValidateDomainDeviceInfo(virDomainDef *def G_GNUC_UNUSED,
+ virDomainDeviceDef *dev G_GNUC_UNUSED,
+ virDomainDeviceInfo *info,
void *opaque)
{
- virQEMUCapsPtr qemuCaps = opaque;
+ virQEMUCaps *qemuCaps = opaque;
if (info->acpiIndex) {
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_ACPI_INDEX)) {
void *opaque,
void *parseOpaque)
{
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virQEMUCaps) qemuCapsLocal = NULL;
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
size_t i;
if (!qemuCaps) {
* we know our callback qemuValidateDomainDeviceInfo will
* not modify it
*/
- if (virDomainDeviceInfoIterate((virDomainDefPtr)def,
+ if (virDomainDeviceInfoIterate((virDomainDef *)def,
qemuValidateDomainDeviceInfo,
qemuCaps) < 0)
return -1;
static int
-qemuValidateDomainDeviceDefZPCIAddress(virDomainDeviceInfoPtr info,
- virQEMUCapsPtr qemuCaps)
+qemuValidateDomainDeviceDefZPCIAddress(virDomainDeviceInfo *info,
+ virQEMUCaps *qemuCaps)
{
- virZPCIDeviceAddressPtr zpci = &info->addr.pci.zpci;
+ virZPCIDeviceAddress *zpci = &info->addr.pci.zpci;
if (virZPCIDeviceAddressIsPresent(zpci) &&
!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_ZPCI)) {
static int
qemuValidateDomainDeviceDefAddress(const virDomainDeviceDef *dev,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
- virDomainDeviceInfoPtr info;
+ virDomainDeviceInfo *info;
if (!(info = virDomainDeviceGetInfo((virDomainDeviceDef *)dev)))
return 0;
break;
case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO: {
- virDomainDeviceSpaprVioAddressPtr addr = &(info->addr.spaprvio);
+ virDomainDeviceSpaprVioAddress *addr = &(info->addr.spaprvio);
if (addr->has_reg && addr->reg > 0xffffffff) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
qemuValidateDomainVirtioOptions(const virDomainVirtioOptions *virtio,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (!virtio)
return 0;
static int
qemuValidateDomainDefVhostUserRequireSharedMemory(const virDomainDef *def,
const char *name,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const char *defaultRAMId = virQEMUCapsGetMachineDefaultRAMid(qemuCaps,
def->virtType,
static int
qemuValidateDomainDeviceDefNetwork(const virDomainNetDef *net,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
bool hasIPv4 = false;
bool hasIPv6 = false;
static int
qemuValidateDomainChrSourceDef(const virDomainChrSourceDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
switch ((virDomainChrType)def->type) {
case VIR_DOMAIN_CHR_TYPE_TCP:
static int
qemuValidateDomainChrDef(const virDomainChrDef *dev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (qemuValidateDomainChrSourceDef(dev->source, qemuCaps) < 0)
return -1;
static int
qemuValidateDomainSmartcardDef(const virDomainSmartcardDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
switch (def->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
static int
qemuValidateDomainRNGDef(const virDomainRNGDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
virDomainCapsDeviceRNG rngCaps = { 0 };
static int
qemuValidateDomainRedirdevDef(const virDomainRedirdevDef *dev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (qemuValidateDomainChrSourceDef(dev->source, qemuCaps) < 0)
return -1;
static int
qemuValidateDomainMdevDefVFIOPCI(const virDomainHostdevDef *hostdev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const virDomainHostdevSubsysMediatedDev *dev;
static int
qemuValidateDomainMdevDefVFIOAP(const virDomainHostdevDef *hostdev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
size_t i;
bool vfioap_found = false;
/* VFIO-AP is restricted to a single mediated device only */
for (i = 0; i < def->nhostdevs; i++) {
- virDomainHostdevDefPtr hdev = def->hostdevs[i];
+ virDomainHostdevDef *hdev = def->hostdevs[i];
if (virHostdevIsMdevDevice(hdev) &&
hdev->source.subsys.u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_AP) {
static int
qemuValidateDomainMdevDef(const virDomainHostdevDef *hostdev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const virDomainHostdevSubsysMediatedDev *mdevsrc;
static int
qemuValidateDomainDeviceDefHostdev(const virDomainHostdevDef *hostdev,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
int backend;
static int
qemuValidateDomainDeviceDefVideo(const virDomainVideoDef *video,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
virDomainCapsDeviceVideo videoCaps = { 0 };
static int
qemuValidateDomainDeviceDefDiskFrontend(const virDomainDiskDef *disk,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
- virDomainDeviceInfoPtr diskInfo;
+ virDomainDeviceInfo *diskInfo;
int cModel;
if (disk->geometry.cylinders > 0 &&
switch (disk->bus) {
case VIR_DOMAIN_DISK_BUS_SCSI:
- diskInfo = (virDomainDeviceInfoPtr)&disk->info;
+ diskInfo = (virDomainDeviceInfo *)&disk->info;
cModel = qemuDomainFindSCSIControllerModel(def, diskInfo);
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
static int
qemuValidateDomainDeviceDefDiskBlkdeviotune(const virDomainDiskDef *disk,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
/* group_name by itself is ignored by qemu */
if (disk->blkdeviotune.group_name &&
size_t i;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr d = def->disks[i];
+ virDomainDiskDef *d = def->disks[i];
if (STREQ(d->dst, disk->dst) ||
STRNEQ_NULLABLE(d->blkdeviotune.group_name,
static int
qemuValidateDomainDeviceDefDiskTransient(const virDomainDiskDef *disk,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
virStorageType actualType = virStorageSourceGetActualType(disk->src);
int
qemuValidateDomainDeviceDefDisk(const virDomainDiskDef *disk,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const char *driverName = virDomainDiskGetDriver(disk);
bool isSD = qemuDiskBusIsSD(disk->bus);
- virStorageSourcePtr n;
+ virStorageSource *n;
int idx;
int partition;
* Returns true if acceptable, false otherwise with error message set.
*/
static bool
-qemuValidateCheckSCSIControllerModel(virQEMUCapsPtr qemuCaps,
+qemuValidateCheckSCSIControllerModel(virQEMUCaps *qemuCaps,
int model)
{
switch ((virDomainControllerModelSCSI) model) {
static int
qemuValidateDomainDeviceDefControllerSATA(const virDomainControllerDef *controller,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
/* first SATA controller on Q35 machines is implicit */
if (controller->idx == 0 && qemuDomainIsQ35(def))
static int
qemuValidateDomainDeviceDefControllerAttributes(const virDomainControllerDef *controller,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (!(controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI &&
(controller->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI ||
static int
qemuValidateDomainDeviceDefControllerPCI(const virDomainControllerDef *cont,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const virDomainPCIControllerOpts *pciopts = &cont->opts.pciopts;
static int
qemuValidateDomainDeviceDefController(const virDomainControllerDef *controller,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
int ret = 0;
static int
qemuValidateDomainDeviceDefSPICEGraphics(const virDomainGraphicsDef *graphics,
- virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps)
+ virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
- virDomainGraphicsListenDefPtr glisten = NULL;
+ virDomainGraphicsListenDef *glisten = NULL;
int tlsPort = graphics->data.spice.tlsPort;
- glisten = virDomainGraphicsGetListen((virDomainGraphicsDefPtr)graphics, 0);
+ glisten = virDomainGraphicsGetListen((virDomainGraphicsDef *)graphics, 0);
if (!glisten) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("missing listen element"));
static int
qemuValidateDomainDeviceDefVNCGraphics(const virDomainGraphicsDef *graphics,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (graphics->data.vnc.powerControl != VIR_TRISTATE_BOOL_ABSENT &&
!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_POWER_CONTROL)) {
static int
qemuValidateDomainDeviceDefGraphics(const virDomainGraphicsDef *graphics,
const virDomainDef *def,
- virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps)
+ virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps)
{
virDomainCapsDeviceGraphics graphicsCaps = { 0 };
bool have_egl_headless = false;
static int
-qemuValidateDomainDeviceDefFS(virDomainFSDefPtr fs,
+qemuValidateDomainDeviceDefFS(virDomainFSDef *fs,
const virDomainDef *def,
- virQEMUDriverPtr driver,
- virQEMUCapsPtr qemuCaps)
+ virQEMUDriver *driver,
+ virQEMUCaps *qemuCaps)
{
if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
static int
-qemuValidateDomainDeviceDefAudio(virDomainAudioDefPtr audio,
- virQEMUCapsPtr qemuCaps G_GNUC_UNUSED)
+qemuValidateDomainDeviceDefAudio(virDomainAudioDef *audio,
+ virQEMUCaps *qemuCaps G_GNUC_UNUSED)
{
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_AUDIODEV)) {
if (audio->input.mixingEngine == VIR_TRISTATE_BOOL_NO ||
static int
-qemuValidateDomainDeviceDefSound(virDomainSoundDefPtr sound,
- virQEMUCapsPtr qemuCaps)
+qemuValidateDomainDeviceDefSound(virDomainSoundDef *sound,
+ virQEMUCaps *qemuCaps)
{
size_t i;
static int
qemuValidateDomainDeviceDefVsock(const virDomainVsockDef *vsock,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VHOST_VSOCK)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
static int
qemuValidateDomainDeviceDefTPM(virDomainTPMDef *tpm,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
virQEMUCapsFlags flag;
static int
qemuValidateDomainDeviceDefInput(const virDomainInputDef *input,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
const char *baseName;
int cap;
static int
qemuValidateDomainDeviceDefMemballoon(const virDomainMemballoonDef *memballoon,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (!memballoon ||
memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE) {
static int
qemuValidateDomainDeviceDefIOMMU(const virDomainIOMMUDef *iommu,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
switch (iommu->model) {
case VIR_DOMAIN_IOMMU_MODEL_INTEL:
static int
-qemuValidateDomainDeviceDefNVRAM(virDomainNVRAMDefPtr nvram,
+qemuValidateDomainDeviceDefNVRAM(virDomainNVRAMDef *nvram,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps)
+ virQEMUCaps *qemuCaps)
{
if (!nvram)
return 0;
static int
-qemuValidateDomainDeviceDefHub(virDomainHubDefPtr hub,
- virQEMUCapsPtr qemuCaps)
+qemuValidateDomainDeviceDefHub(virDomainHubDef *hub,
+ virQEMUCaps *qemuCaps)
{
if (hub->type != VIR_DOMAIN_HUB_TYPE_USB) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
-qemuValidateDomainDeviceDefMemory(virDomainMemoryDefPtr mem,
- virQEMUCapsPtr qemuCaps)
+qemuValidateDomainDeviceDefMemory(virDomainMemoryDef *mem,
+ virQEMUCaps *qemuCaps)
{
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
static int
-qemuValidateDomainDeviceDefShmem(virDomainShmemDefPtr shmem,
- virQEMUCapsPtr qemuCaps)
+qemuValidateDomainDeviceDefShmem(virDomainShmemDef *shmem,
+ virQEMUCaps *qemuCaps)
{
switch (shmem->model) {
case VIR_DOMAIN_SHMEM_MODEL_IVSHMEM:
void *parseOpaque)
{
int ret = 0;
- virQEMUDriverPtr driver = opaque;
+ virQEMUDriver *driver = opaque;
g_autoptr(virQEMUCaps) qemuCapsLocal = NULL;
- virQEMUCapsPtr qemuCaps = parseOpaque;
+ virQEMUCaps *qemuCaps = parseOpaque;
if (!qemuCaps) {
if (!(qemuCapsLocal = virQEMUCapsCacheLookup(driver->qemuCapsCache,
void *parseOpaque);
int qemuValidateDomainDeviceDefDisk(const virDomainDiskDef *disk,
const virDomainDef *def,
- virQEMUCapsPtr qemuCaps);
+ virQEMUCaps *qemuCaps);
int qemuValidateDomainDeviceDef(const virDomainDeviceDef *dev,
const virDomainDef *def,
void *opaque,
);
typedef struct _qemuVhostUserGPU qemuVhostUserGPU;
-typedef qemuVhostUserGPU *qemuVhostUserGPUPtr;
struct _qemuVhostUserGPU {
size_t nfeatures;
qemuVhostUserGPUFeature *features;
void
-qemuVhostUserFree(qemuVhostUserPtr vu)
+qemuVhostUserFree(qemuVhostUser *vu)
{
if (!vu)
return;
static int
qemuVhostUserTypeParse(const char *path,
- virJSONValuePtr doc,
- qemuVhostUserPtr vu)
+ virJSONValue *doc,
+ qemuVhostUser *vu)
{
const char *type = virJSONValueObjectGetString(doc, "type");
int tmp;
static int
qemuVhostUserBinaryParse(const char *path,
- virJSONValuePtr doc,
- qemuVhostUserPtr vu)
+ virJSONValue *doc,
+ qemuVhostUser *vu)
{
const char *binary = virJSONValueObjectGetString(doc, "binary");
}
-qemuVhostUserPtr
+qemuVhostUser *
qemuVhostUserParse(const char *path)
{
g_autofree char *cont = NULL;
char *
-qemuVhostUserFormat(qemuVhostUserPtr vu)
+qemuVhostUserFormat(qemuVhostUser *vu)
{
g_autoptr(virJSONValue) doc = NULL;
static ssize_t
qemuVhostUserFetchParsedConfigs(bool privileged,
- qemuVhostUserPtr **vhostuserRet,
+ qemuVhostUser ***vhostuserRet,
char ***pathsRet)
{
g_auto(GStrv) paths = NULL;
size_t npaths;
- qemuVhostUserPtr *vus = NULL;
+ qemuVhostUser **vus = NULL;
size_t i;
if (qemuVhostUserFetchConfigs(&paths, privileged) < 0)
return 0;
npaths = g_strv_length(paths);
- vus = g_new0(qemuVhostUserPtr, npaths);
+ vus = g_new0(qemuVhostUser *, npaths);
for (i = 0; i < npaths; i++) {
if (!(vus[i] = qemuVhostUserParse(paths[i])))
static int
-qemuVhostUserGPUFillCapabilities(qemuVhostUserPtr vu,
- virJSONValuePtr doc)
+qemuVhostUserGPUFillCapabilities(qemuVhostUser *vu,
+ virJSONValue *doc)
{
- qemuVhostUserGPUPtr gpu = &vu->capabilities.gpu;
- virJSONValuePtr featuresJSON;
+ qemuVhostUserGPU *gpu = &vu->capabilities.gpu;
+ virJSONValue *featuresJSON;
size_t nfeatures;
size_t i;
g_autoptr(qemuVhostUserGPUFeature) features = NULL;
features = g_new0(qemuVhostUserGPUFeature, nfeatures);
for (i = 0; i < nfeatures; i++) {
- virJSONValuePtr item = virJSONValueArrayGet(featuresJSON, i);
+ virJSONValue *item = virJSONValueArrayGet(featuresJSON, i);
const char *tmpStr = virJSONValueGetString(item);
int tmp;
static bool
-qemuVhostUserGPUHasFeature(qemuVhostUserGPUPtr gpu,
+qemuVhostUserGPUHasFeature(qemuVhostUserGPU *gpu,
qemuVhostUserGPUFeature feature)
{
size_t i;
int
-qemuVhostUserFillDomainGPU(virQEMUDriverPtr driver,
- virDomainVideoDefPtr video)
+qemuVhostUserFillDomainGPU(virQEMUDriver *driver,
+ virDomainVideoDef *video)
{
- qemuVhostUserPtr *vus = NULL;
- qemuVhostUserPtr vu = NULL;
+ qemuVhostUser **vus = NULL;
+ qemuVhostUser *vu = NULL;
ssize_t nvus = 0;
ssize_t i;
int ret = -1;
int
-qemuVhostUserFillDomainFS(virQEMUDriverPtr driver,
- virDomainFSDefPtr fs)
+qemuVhostUserFillDomainFS(virQEMUDriver *driver,
+ virDomainFSDef *fs)
{
- qemuVhostUserPtr *vus = NULL;
+ qemuVhostUser **vus = NULL;
ssize_t nvus = 0;
ssize_t i;
int ret = -1;
goto end;
for (i = 0; i < nvus; i++) {
- qemuVhostUserPtr vu = vus[i];
+ qemuVhostUser *vu = vus[i];
if (vu->type != QEMU_VHOST_USER_TYPE_FS)
continue;
#include "virarch.h"
typedef struct _qemuVhostUser qemuVhostUser;
-typedef qemuVhostUser *qemuVhostUserPtr;
void
-qemuVhostUserFree(qemuVhostUserPtr fw);
+qemuVhostUserFree(qemuVhostUser *fw);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuVhostUser, qemuVhostUserFree);
-qemuVhostUserPtr
+qemuVhostUser *
qemuVhostUserParse(const char *path);
char *
-qemuVhostUserFormat(qemuVhostUserPtr fw);
+qemuVhostUserFormat(qemuVhostUser *fw);
int
qemuVhostUserFetchConfigs(char ***configs,
bool privileged);
int
-qemuVhostUserFillDomainGPU(virQEMUDriverPtr driver,
- virDomainVideoDefPtr video);
+qemuVhostUserFillDomainGPU(virQEMUDriver *driver,
+ virDomainVideoDef *video);
int
-qemuVhostUserFillDomainFS(virQEMUDriverPtr driver,
- virDomainFSDefPtr fs);
+qemuVhostUserFillDomainFS(virQEMUDriver *driver,
+ virDomainFSDef *fs);
}
-int qemuExtVhostUserGPUPrepareDomain(virQEMUDriverPtr driver,
- virDomainVideoDefPtr video)
+int qemuExtVhostUserGPUPrepareDomain(virQEMUDriver *driver,
+ virDomainVideoDef *video)
{
return qemuVhostUserFillDomainGPU(driver, video);
}
* - have the command line built
* - start the external process and sync with it before QEMU start
*/
-int qemuExtVhostUserGPUStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainVideoDefPtr video)
+int qemuExtVhostUserGPUStart(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainVideoDef *video)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *shortname = NULL;
* Check if vhost-user process pidfile is around, kill the process,
* and remove the pidfile.
*/
-void qemuExtVhostUserGPUStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainVideoDefPtr video)
+void qemuExtVhostUserGPUStop(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainVideoDef *video)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *pidfile = NULL;
* Add the vhost-user-gpu PID to the given cgroup.
*/
int
-qemuExtVhostUserGPUSetupCgroup(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virDomainVideoDefPtr video,
- virCgroupPtr cgroup)
+qemuExtVhostUserGPUSetupCgroup(virQEMUDriver *driver,
+ virDomainDef *def,
+ virDomainVideoDef *video,
+ virCgroup *cgroup)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *shortname = NULL;
#include "qemu_domain.h"
#include "qemu_security.h"
-int qemuExtVhostUserGPUPrepareDomain(virQEMUDriverPtr driver,
- virDomainVideoDefPtr video)
+int qemuExtVhostUserGPUPrepareDomain(virQEMUDriver *driver,
+ virDomainVideoDef *video)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuExtVhostUserGPUStart(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainVideoDefPtr video)
+int qemuExtVhostUserGPUStart(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainVideoDef *video)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuExtVhostUserGPUStop(virQEMUDriverPtr driver,
- virDomainObjPtr def,
- virDomainVideoDefPtr video)
+void qemuExtVhostUserGPUStop(virQEMUDriver *driver,
+ virDomainObj *def,
+ virDomainVideoDef *video)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-qemuExtVhostUserGPUSetupCgroup(virQEMUDriverPtr driver,
- virDomainDefPtr def,
- virDomainVideoDefPtr video,
- virCgroupPtr cgroup)
+qemuExtVhostUserGPUSetupCgroup(virQEMUDriver *driver,
+ virDomainDef *def,
+ virDomainVideoDef *video,
+ virCgroup *cgroup)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
G_GNUC_WARN_UNUSED_RESULT;
char *
-qemuVirtioFSCreatePidFilename(virDomainObjPtr vm,
+qemuVirtioFSCreatePidFilename(virDomainObj *vm,
const char *alias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *name = NULL;
name = g_strdup_printf("%s-fs", alias);
char *
-qemuVirtioFSCreateSocketFilename(virDomainObjPtr vm,
+qemuVirtioFSCreateSocketFilename(virDomainObj *vm,
const char *alias)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
return virFileBuildPath(priv->libDir, alias, "-fs.sock");
}
static char *
-qemuVirtioFSCreateLogFilename(virQEMUDriverConfigPtr cfg,
+qemuVirtioFSCreateLogFilename(virQEMUDriverConfig *cfg,
const virDomainDef *def,
const char *alias)
{
static int
-qemuVirtioFSOpenChardev(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuVirtioFSOpenChardev(virQEMUDriver *driver,
+ virDomainObj *vm,
const char *socket_path)
{
- virDomainChrSourceDefPtr chrdev = virDomainChrSourceDefNew(NULL);
+ virDomainChrSourceDef *chrdev = virDomainChrSourceDefNew(NULL);
virDomainChrDef chr = { .source = chrdev };
VIR_AUTOCLOSE fd = -1;
int ret = -1;
}
-static virCommandPtr
-qemuVirtioFSBuildCommandLine(virQEMUDriverConfigPtr cfg,
- virDomainFSDefPtr fs,
+static virCommand *
+qemuVirtioFSBuildCommandLine(virQEMUDriverConfig *cfg,
+ virDomainFSDef *fs,
int *fd)
{
g_autoptr(virCommand) cmd = NULL;
}
int
-qemuVirtioFSStart(virLogManagerPtr logManager,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainFSDefPtr fs)
+qemuVirtioFSStart(virLogManager *logManager,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainFSDef *fs)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virCommand) cmd = NULL;
void
-qemuVirtioFSStop(virQEMUDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr vm,
- virDomainFSDefPtr fs)
+qemuVirtioFSStop(virQEMUDriver *driver G_GNUC_UNUSED,
+ virDomainObj *vm,
+ virDomainFSDef *fs)
{
g_autofree char *pidfile = NULL;
virErrorPtr orig_err;
int
-qemuVirtioFSSetupCgroup(virDomainObjPtr vm,
- virDomainFSDefPtr fs,
- virCgroupPtr cgroup)
+qemuVirtioFSSetupCgroup(virDomainObj *vm,
+ virDomainFSDef *fs,
+ virCgroup *cgroup)
{
g_autofree char *pidfile = NULL;
pid_t pid = -1;
}
int
-qemuVirtioFSPrepareDomain(virQEMUDriverPtr driver,
- virDomainFSDefPtr fs)
+qemuVirtioFSPrepareDomain(virQEMUDriver *driver,
+ virDomainFSDef *fs)
{
if (fs->binary)
return 0;
char *
-qemuVirtioFSCreatePidFilename(virDomainObjPtr vm,
+qemuVirtioFSCreatePidFilename(virDomainObj *vm,
const char *alias);
char *
-qemuVirtioFSCreateSocketFilename(virDomainObjPtr vm,
+qemuVirtioFSCreateSocketFilename(virDomainObj *vm,
const char *alias);
int
-qemuVirtioFSStart(virLogManagerPtr logManager,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainFSDefPtr fs);
+qemuVirtioFSStart(virLogManager *logManager,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainFSDef *fs);
void
-qemuVirtioFSStop(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- virDomainFSDefPtr fs);
+qemuVirtioFSStop(virQEMUDriver *driver,
+ virDomainObj *vm,
+ virDomainFSDef *fs);
int
-qemuVirtioFSSetupCgroup(virDomainObjPtr vm,
- virDomainFSDefPtr fs,
- virCgroupPtr cgroup);
+qemuVirtioFSSetupCgroup(virDomainObj *vm,
+ virDomainFSDef *fs,
+ virCgroup *cgroup);
int
-qemuVirtioFSPrepareDomain(virQEMUDriverPtr driver,
- virDomainFSDefPtr fs);
+qemuVirtioFSPrepareDomain(virQEMUDriver *driver,
+ virDomainFSDef *fs);
#endif
#if WITH_SASL
-virNetSASLContextPtr saslCtxt = NULL;
+virNetSASLContext *saslCtxt = NULL;
#endif
-virNetServerProgramPtr remoteProgram = NULL;
-virNetServerProgramPtr qemuProgram = NULL;
+virNetServerProgram *remoteProgram = NULL;
+virNetServerProgram *qemuProgram = NULL;
volatile bool driversInitialized = false;
static int ATTRIBUTE_NONNULL(3)
-daemonSetupNetworking(virNetServerPtr srv,
- virNetServerPtr srvAdm,
+daemonSetupNetworking(virNetServer *srv,
+ virNetServer *srvAdm,
struct daemonConfig *config,
#ifdef WITH_IP
bool ipsock,
return -1;
if (((ipsock && config->listen_tls) || (act && virSystemdActivationHasName(act, DAEMON_NAME "-tls.socket")))) {
- virNetTLSContextPtr ctxt = NULL;
+ virNetTLSContext *ctxt = NULL;
if (config->ca_file ||
config->cert_file ||
static int
daemonSetupAccessManager(struct daemonConfig *config)
{
- virAccessManagerPtr mgr;
+ virAccessManager *mgr;
const char *none[] = { "none", NULL };
const char **drv = (const char **)config->access_drivers;
}
-static void daemonShutdownHandler(virNetDaemonPtr dmn,
+static void daemonShutdownHandler(virNetDaemon *dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
VIR_WARN("Error while reloading drivers");
}
-static void daemonReloadHandler(virNetDaemonPtr dmn G_GNUC_UNUSED,
+static void daemonReloadHandler(virNetDaemon *dmn G_GNUC_UNUSED,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
}
-static int daemonSetupSignals(virNetDaemonPtr dmn)
+static int daemonSetupSignals(virNetDaemon *dmn)
{
if (virNetDaemonAddSignalHandler(dmn, SIGINT, daemonShutdownHandler, NULL) < 0)
return -1;
static void daemonInhibitCallback(bool inhibit, void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
if (inhibit)
virNetDaemonAddShutdownInhibition(dmn);
static void daemonStopWorker(void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
VIR_DEBUG("Begin stop dmn=%p", dmn);
/* We do this in a thread to not block the main loop */
-static void daemonStop(virNetDaemonPtr dmn)
+static void daemonStop(virNetDaemon *dmn)
{
- virThreadPtr thr;
+ virThread *thr;
virObjectRef(dmn);
thr = g_new0(virThread, 1);
gboolean incoming G_GNUC_UNUSED,
gpointer opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
VIR_DEBUG("dmn=%p", dmn);
GVariant *parameters G_GNUC_UNUSED,
gpointer opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
VIR_DEBUG("dmn=%p", dmn);
static void daemonRunStateInit(void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
g_autoptr(virIdentity) sysident = virIdentityGetSystem();
#ifdef MODULE_NAME
bool mandatory = true;
virIdentitySetCurrent(NULL);
}
-static int daemonStateInit(virNetDaemonPtr dmn)
+static int daemonStateInit(virNetDaemon *dmn)
{
virThread thr;
virObjectRef(dmn);
}
int main(int argc, char **argv) {
- virNetDaemonPtr dmn = NULL;
- virNetServerPtr srv = NULL;
- virNetServerPtr srvAdm = NULL;
- virNetServerProgramPtr adminProgram = NULL;
- virNetServerProgramPtr lxcProgram = NULL;
+ virNetDaemon *dmn = NULL;
+ virNetServer *srv = NULL;
+ virNetServer *srvAdm = NULL;
+ virNetServerProgram *adminProgram = NULL;
+ virNetServerProgram *lxcProgram = NULL;
char *remote_config_file = NULL;
int statuswrite = -1;
int ret = 1;
#include "virnetserverprogram.h"
typedef struct daemonClientStream daemonClientStream;
-typedef daemonClientStream *daemonClientStreamPtr;
typedef struct daemonClientPrivate daemonClientPrivate;
-typedef daemonClientPrivate *daemonClientPrivatePtr;
typedef struct daemonClientEventCallback daemonClientEventCallback;
-typedef daemonClientEventCallback *daemonClientEventCallbackPtr;
/* Stores the per-client connection state */
struct daemonClientPrivate {
/* Hold while accessing any data except conn */
virMutex lock;
- daemonClientEventCallbackPtr *domainEventCallbacks;
+ daemonClientEventCallback **domainEventCallbacks;
size_t ndomainEventCallbacks;
- daemonClientEventCallbackPtr *networkEventCallbacks;
+ daemonClientEventCallback **networkEventCallbacks;
size_t nnetworkEventCallbacks;
- daemonClientEventCallbackPtr *qemuEventCallbacks;
+ daemonClientEventCallback **qemuEventCallbacks;
size_t nqemuEventCallbacks;
- daemonClientEventCallbackPtr *storageEventCallbacks;
+ daemonClientEventCallback **storageEventCallbacks;
size_t nstorageEventCallbacks;
- daemonClientEventCallbackPtr *nodeDeviceEventCallbacks;
+ daemonClientEventCallback **nodeDeviceEventCallbacks;
size_t nnodeDeviceEventCallbacks;
- daemonClientEventCallbackPtr *secretEventCallbacks;
+ daemonClientEventCallback **secretEventCallbacks;
size_t nsecretEventCallbacks;
bool closeRegistered;
#if WITH_SASL
- virNetSASLSessionPtr sasl;
+ virNetSASLSession *sasl;
#endif
/* This is only valid if a remote open call has been made on this
const char *storageURI;
bool readonly;
- daemonClientStreamPtr streams;
+ daemonClientStream *streams;
};
#if WITH_SASL
-extern virNetSASLContextPtr saslCtxt;
+extern virNetSASLContext *saslCtxt;
#endif
-extern virNetServerProgramPtr remoteProgram;
-extern virNetServerProgramPtr qemuProgram;
+extern virNetServerProgram *remoteProgram;
+extern virNetServerProgram *qemuProgram;
static int
-remoteConfigGetAuth(virConfPtr conf,
+remoteConfigGetAuth(virConf *conf,
const char *filename,
const char *key,
int *auth)
static int
daemonConfigLoadOptions(struct daemonConfig *data,
const char *filename,
- virConfPtr conf)
+ virConf *conf)
{
#ifdef WITH_IP
if (virConfGetValueBool(conf, "listen_tcp", &data->listen_tcp) < 0)
#endif
struct daemonClientEventCallback {
- virNetServerClientPtr client;
- virNetServerProgramPtr program;
+ virNetServerClient *client;
+ virNetServerProgram *program;
int eventID;
int callbackID;
bool legacy;
u_int *ret_errors_len);
static virConnectPtr
-remoteGetHypervisorConn(virNetServerClientPtr client);
+remoteGetHypervisorConn(virNetServerClient *client);
static virConnectPtr
-remoteGetInterfaceConn(virNetServerClientPtr client);
+remoteGetInterfaceConn(virNetServerClient *client);
static virConnectPtr
-remoteGetNetworkConn(virNetServerClientPtr client);
+remoteGetNetworkConn(virNetServerClient *client);
static virConnectPtr
-remoteGetNodeDevConn(virNetServerClientPtr client);
+remoteGetNodeDevConn(virNetServerClient *client);
static virConnectPtr
-remoteGetNWFilterConn(virNetServerClientPtr client);
+remoteGetNWFilterConn(virNetServerClient *client);
static virConnectPtr
-remoteGetSecretConn(virNetServerClientPtr client);
+remoteGetSecretConn(virNetServerClient *client);
static virConnectPtr
-remoteGetStorageConn(virNetServerClientPtr client);
+remoteGetStorageConn(virNetServerClient *client);
#include "remote_daemon_dispatch_stubs.h"
/* Prototypes */
static void
-remoteDispatchObjectEventSend(virNetServerClientPtr client,
- virNetServerProgramPtr program,
+remoteDispatchObjectEventSend(virNetServerClient *client,
+ virNetServerProgram *program,
int procnr,
xdrproc_t proc,
void *data);
static void
remoteEventCallbackFree(void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
if (!callback)
return;
virObjectUnref(callback->program);
static bool
-remoteRelayDomainEventCheckACL(virNetServerClientPtr client,
+remoteRelayDomainEventCheckACL(virNetServerClient *client,
virConnectPtr conn, virDomainPtr dom)
{
virDomainDef def;
static bool
-remoteRelayNetworkEventCheckACL(virNetServerClientPtr client,
+remoteRelayNetworkEventCheckACL(virNetServerClient *client,
virConnectPtr conn, virNetworkPtr net)
{
virNetworkDef def;
}
static bool
-remoteRelayStoragePoolEventCheckACL(virNetServerClientPtr client,
+remoteRelayStoragePoolEventCheckACL(virNetServerClient *client,
virConnectPtr conn,
virStoragePoolPtr pool)
{
}
static bool
-remoteRelayNodeDeviceEventCheckACL(virNetServerClientPtr client,
+remoteRelayNodeDeviceEventCheckACL(virNetServerClient *client,
virConnectPtr conn,
virNodeDevicePtr dev)
{
}
static bool
-remoteRelaySecretEventCheckACL(virNetServerClientPtr client,
+remoteRelaySecretEventCheckACL(virNetServerClient *client,
virConnectPtr conn,
virSecretPtr secret)
{
}
static bool
-remoteRelayDomainQemuMonitorEventCheckACL(virNetServerClientPtr client,
+remoteRelayDomainQemuMonitorEventCheckACL(virNetServerClient *client,
virConnectPtr conn, virDomainPtr dom)
{
virDomainDef def;
int detail,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_lifecycle_msg data;
if (callback->callbackID < 0 ||
virDomainPtr dom,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_reboot_msg data;
if (callback->callbackID < 0 ||
long long offset,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_rtc_change_msg data;
if (callback->callbackID < 0 ||
int action,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_watchdog_msg data;
if (callback->callbackID < 0 ||
int action,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_io_error_msg data;
if (callback->callbackID < 0 ||
const char *reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_io_error_reason_msg data;
if (callback->callbackID < 0 ||
virDomainEventGraphicsSubjectPtr subject,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_graphics_msg data;
size_t i;
int status,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_block_job_msg data;
if (callback->callbackID < 0 ||
virDomainPtr dom,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_control_error_msg data;
if (callback->callbackID < 0 ||
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_disk_change_msg data;
if (callback->callbackID < 0 ||
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_tray_change_msg data;
if (callback->callbackID < 0 ||
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_pmwakeup_msg data;
if (callback->callbackID < 0 ||
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_pmsuspend_msg data;
if (callback->callbackID < 0 ||
unsigned long long actual,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_balloon_change_msg data;
if (callback->callbackID < 0 ||
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_pmsuspend_disk_msg data;
if (callback->callbackID < 0 ||
const char *devAlias,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_device_removed_msg data;
if (callback->callbackID < 0 ||
int status,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_block_job_2_msg data;
if (callback->callbackID < 0 ||
int nparams,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_tunable_msg data;
if (callback->callbackID < 0 ||
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_EVENT_TUNABLE_MAX,
- (virTypedParameterRemotePtr *) &data.params.params_val,
+ (struct _virTypedParameterRemote **) &data.params.params_val,
&data.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
return -1;
int reason,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_agent_lifecycle_msg data;
if (callback->callbackID < 0 ||
const char *devAlias,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_device_added_msg data;
if (callback->callbackID < 0 ||
int iteration,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_migration_iteration_msg data;
if (callback->callbackID < 0 ||
int nparams,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_job_completed_msg data;
if (callback->callbackID < 0 ||
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_JOB_STATS_MAX,
- (virTypedParameterRemotePtr *) &data.params.params_val,
+ (struct _virTypedParameterRemote **) &data.params.params_val,
&data.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
return -1;
const char *devAlias,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_device_removal_failed_msg data;
if (callback->callbackID < 0 ||
const char *nsuri,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_callback_metadata_change_msg data;
if (callback->callbackID < 0 ||
unsigned long long excess,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_block_threshold_msg data;
if (callback->callbackID < 0 ||
unsigned int flags,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_domain_event_memory_failure_msg data;
if (callback->callbackID < 0 ||
int detail,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_network_event_lifecycle_msg data;
if (callback->callbackID < 0 ||
int detail,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_storage_pool_event_lifecycle_msg data;
if (callback->callbackID < 0 ||
virStoragePoolPtr pool,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_storage_pool_event_refresh_msg data;
if (callback->callbackID < 0 ||
int detail,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_node_device_event_lifecycle_msg data;
if (callback->callbackID < 0 ||
virNodeDevicePtr dev,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_node_device_event_update_msg data;
if (callback->callbackID < 0 ||
int detail,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_secret_event_lifecycle_msg data;
if (callback->callbackID < 0 ||
virSecretPtr secret,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
remote_secret_event_value_changed_msg data;
if (callback->callbackID < 0 ||
const char *details,
void *opaque)
{
- daemonClientEventCallbackPtr callback = opaque;
+ daemonClientEventCallback *callback = opaque;
qemu_domain_monitor_event_msg data;
if (callback->callbackID < 0 ||
static
void remoteRelayConnectionClosedEvent(virConnectPtr conn G_GNUC_UNUSED, int reason, void *opaque)
{
- virNetServerClientPtr client = opaque;
+ virNetServerClient *client = opaque;
remote_connect_event_connection_closed_msg msg = { reason };
VIR_DEBUG("Relaying connection closed event, reason %d", reason);
}
-static void remoteClientCloseFunc(virNetServerClientPtr client)
+static void remoteClientCloseFunc(virNetServerClient *client)
{
struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetHypervisorConn(virNetServerClientPtr client)
+remoteGetHypervisorConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetInterfaceConn(virNetServerClientPtr client)
+remoteGetInterfaceConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetNetworkConn(virNetServerClientPtr client)
+remoteGetNetworkConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetNodeDevConn(virNetServerClientPtr client)
+remoteGetNodeDevConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetNWFilterConn(virNetServerClientPtr client)
+remoteGetNWFilterConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetSecretConn(virNetServerClientPtr client)
+remoteGetSecretConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static virConnectPtr
-remoteGetStorageConn(virNetServerClientPtr client)
+remoteGetStorageConn(virNetServerClient *client)
{
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
}
-void *remoteClientNew(virNetServerClientPtr client,
+void *remoteClientNew(virNetServerClient *client,
void *opaque G_GNUC_UNUSED)
{
struct daemonClientPrivate *priv;
static int
-remoteDispatchConnectOpen(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchConnectOpen(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
struct remote_connect_open_args *args)
{
const char *name;
static int
-remoteDispatchConnectClose(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED)
+remoteDispatchConnectClose(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED)
{
virNetServerClientDelayedClose(client);
return 0;
static int
-remoteDispatchConnectSetIdentity(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchConnectSetIdentity(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_connect_set_identity_args *args)
{
virTypedParameterPtr params = NULL;
goto cleanup;
VIR_DEBUG("Received forwarded identity");
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
REMOTE_CONNECT_IDENTITY_PARAMS_MAX,
¶ms,
static int
-remoteDispatchDomainGetSchedulerType(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetSchedulerType(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_scheduler_type_args *args,
remote_domain_get_scheduler_type_ret *ret)
{
}
static int
-remoteDispatchDomainGetSchedulerParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetSchedulerParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_scheduler_parameters_args *args,
remote_domain_get_scheduler_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
0) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetSchedulerParametersFlags(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetSchedulerParametersFlags(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_scheduler_parameters_flags_args *args,
remote_domain_get_scheduler_parameters_flags_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainMemoryStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMemoryStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_memory_stats_args *args,
remote_domain_memory_stats_ret *ret)
{
}
static int
-remoteDispatchDomainBlockPeek(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainBlockPeek(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_block_peek_args *args,
remote_domain_block_peek_ret *ret)
{
}
static int
-remoteDispatchDomainBlockStatsFlags(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainBlockStatsFlags(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_block_stats_flags_args *args,
remote_domain_block_stats_flags_ret *ret)
{
/* Serialize the block stats. */
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainMemoryPeek(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMemoryPeek(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_memory_peek_args *args,
remote_domain_memory_peek_ret *ret)
{
}
static int
-remoteDispatchDomainGetSecurityLabel(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetSecurityLabel(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_security_label_args *args,
remote_domain_get_security_label_ret *ret)
{
}
static int
-remoteDispatchDomainGetSecurityLabelList(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetSecurityLabelList(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_security_label_list_args *args,
remote_domain_get_security_label_list_ret *ret)
{
}
static int
-remoteDispatchNodeGetSecurityModel(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetSecurityModel(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_security_model_ret *ret)
{
virSecurityModel secmodel;
}
static int
-remoteDispatchDomainGetVcpuPinInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetVcpuPinInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_vcpu_pin_info_args *args,
remote_domain_get_vcpu_pin_info_ret *ret)
{
}
static int
-remoteDispatchDomainPinEmulator(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainPinEmulator(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_pin_emulator_args *args)
{
int rv = -1;
static int
-remoteDispatchDomainGetEmulatorPinInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetEmulatorPinInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_emulator_pin_info_args *args,
remote_domain_get_emulator_pin_info_ret *ret)
{
}
static int
-remoteDispatchDomainGetVcpus(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetVcpus(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_vcpus_args *args,
remote_domain_get_vcpus_ret *ret)
{
}
static int
-remoteDispatchDomainGetIOThreadInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetIOThreadInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_iothread_info_args *args,
remote_domain_get_iothread_info_ret *ret)
{
}
static int
-remoteDispatchDomainMigratePrepare(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePrepare(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_prepare_args *args,
remote_domain_migrate_prepare_ret *ret)
{
}
static int
-remoteDispatchDomainMigratePrepare2(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePrepare2(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_prepare2_args *args,
remote_domain_migrate_prepare2_ret *ret)
{
}
static int
-remoteDispatchDomainGetMemoryParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetMemoryParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_memory_parameters_args *args,
remote_domain_get_memory_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetNumaParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetNumaParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_numa_parameters_args *args,
remote_domain_get_numa_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_NUMA_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetBlkioParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetBlkioParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_blkio_parameters_args *args,
remote_domain_get_blkio_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchNodeGetCPUStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetCPUStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_cpu_stats_args *args,
remote_node_get_cpu_stats_ret *ret)
{
}
static int
-remoteDispatchNodeGetMemoryStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetMemoryStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_memory_stats_args *args,
remote_node_get_memory_stats_ret *ret)
{
}
static int
-remoteDispatchDomainGetLaunchSecurityInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetLaunchSecurityInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_launch_security_info_args *args,
remote_domain_get_launch_security_info_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_LAUNCH_SECURITY_INFO_PARAMS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetPerfEvents(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetPerfEvents(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_perf_events_args *args,
remote_domain_get_perf_events_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_PERF_EVENTS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
0) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetBlockJobInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetBlockJobInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_block_job_info_args *args,
remote_domain_get_block_job_info_ret *ret)
{
}
static int
-remoteDispatchDomainGetBlockIoTune(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr hdr G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetBlockIoTune(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *hdr G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_block_io_tune_args *args,
remote_domain_get_block_io_tune_ret *ret)
{
/* Serialize the block I/O tuning parameters. */
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
/*-------------------------------------------------------------*/
static int
-remoteDispatchAuthList(virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchAuthList(virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_auth_list_ret *ret)
{
int auth = virNetServerClientGetAuth(client);
* and gives the client a list of allowed mechanisms to choose
*/
static int
-remoteDispatchAuthSaslInit(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslInit(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_init_ret *ret)
{
- virNetSASLSessionPtr sasl = NULL;
+ virNetSASLSession *sasl = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
* Returns 0 if ok, -1 on error, -2 if rejected
*/
static int
-remoteSASLFinish(virNetServerPtr server,
- virNetServerClientPtr client)
+remoteSASLFinish(virNetServer *server,
+ virNetServerClient *client)
{
g_autoptr(virIdentity) clnt_identity = NULL;
const char *identity;
* This starts the SASL authentication negotiation.
*/
static int
-remoteDispatchAuthSaslStart(virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslStart(virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_start_args *args,
remote_auth_sasl_start_ret *ret)
{
static int
-remoteDispatchAuthSaslStep(virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslStep(virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_step_args *args,
remote_auth_sasl_step_ret *ret)
{
}
#else
static int
-remoteDispatchAuthSaslInit(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslInit(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_init_ret *ret G_GNUC_UNUSED)
{
VIR_WARN("Client tried unsupported SASL auth");
return -1;
}
static int
-remoteDispatchAuthSaslStart(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslStart(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_start_args *args G_GNUC_UNUSED,
remote_auth_sasl_start_ret *ret G_GNUC_UNUSED)
{
return -1;
}
static int
-remoteDispatchAuthSaslStep(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client G_GNUC_UNUSED,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthSaslStep(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client G_GNUC_UNUSED,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_sasl_step_args *args G_GNUC_UNUSED,
remote_auth_sasl_step_ret *ret G_GNUC_UNUSED)
{
static int
-remoteDispatchAuthPolkit(virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchAuthPolkit(virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_auth_polkit_ret *ret)
{
pid_t callerPid = -1;
static int
-remoteDispatchNodeDeviceGetParent(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeDeviceGetParent(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_device_get_parent_args *args,
remote_node_device_get_parent_ret *ret)
{
}
static int
-remoteDispatchConnectRegisterCloseCallback(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr)
+remoteDispatchConnectRegisterCloseCallback(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr)
{
int rv = -1;
struct daemonClientPrivate *priv =
}
static int
-remoteDispatchConnectUnregisterCloseCallback(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr)
+remoteDispatchConnectUnregisterCloseCallback(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr)
{
int rv = -1;
struct daemonClientPrivate *priv =
}
static int
-remoteDispatchConnectDomainEventRegister(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventRegister(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_register_ret *ret G_GNUC_UNUSED)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virConnectPtr conn = remoteGetHypervisorConn(client);
}
static int
-remoteDispatchConnectDomainEventDeregister(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventDeregister(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_deregister_ret *ret G_GNUC_UNUSED)
{
int callbackID = -1;
}
static void
-remoteDispatchObjectEventSend(virNetServerClientPtr client,
- virNetServerProgramPtr program,
+remoteDispatchObjectEventSend(virNetServerClient *client,
+ virNetServerProgram *program,
int procnr,
xdrproc_t proc,
void *data)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
if (!(msg = virNetMessageNew(false)))
goto cleanup;
}
static int
-remoteDispatchSecretGetValue(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchSecretGetValue(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_secret_get_value_args *args,
remote_secret_get_value_ret *ret)
{
}
static int
-remoteDispatchDomainGetState(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetState(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_state_args *args,
remote_domain_get_state_ret *ret)
{
* VIR_DRV_SUPPORTS_FEATURE(VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK),
* and must not mix the two styles. */
static int
-remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_register_any_args *args)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virConnectPtr conn = remoteGetHypervisorConn(client);
static int
-remoteDispatchConnectDomainEventCallbackRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventCallbackRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_callback_register_any_args *args,
remote_connect_domain_event_callback_register_any_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virDomainPtr dom = NULL;
static int
-remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_deregister_any_args *args)
{
int callbackID = -1;
static int
-remoteDispatchConnectDomainEventCallbackDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectDomainEventCallbackDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_domain_event_callback_deregister_any_args *args)
{
int rv = -1;
static int
-qemuDispatchDomainMonitorCommand(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+qemuDispatchDomainMonitorCommand(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
qemu_domain_monitor_command_args *args,
qemu_domain_monitor_command_ret *ret)
{
static int
-remoteDispatchDomainMigrateBegin3(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateBegin3(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_begin3_args *args,
remote_domain_migrate_begin3_ret *ret)
{
static int
-remoteDispatchDomainMigratePrepare3(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePrepare3(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_prepare3_args *args,
remote_domain_migrate_prepare3_ret *ret)
{
static int
-remoteDispatchDomainMigratePerform3(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePerform3(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_perform3_args *args,
remote_domain_migrate_perform3_ret *ret)
{
static int
-remoteDispatchDomainMigrateFinish3(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateFinish3(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_finish3_args *args,
remote_domain_migrate_finish3_ret *ret)
{
static int
-remoteDispatchDomainMigrateConfirm3(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateConfirm3(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_confirm3_args *args)
{
virDomainPtr dom = NULL;
}
-static int remoteDispatchConnectSupportsFeature(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+static int remoteDispatchConnectSupportsFeature(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_connect_supports_feature_args *args,
remote_connect_supports_feature_ret *ret)
{
static int
-remoteDispatchDomainOpenGraphics(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainOpenGraphics(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
remote_domain_open_graphics_args *args)
{
virDomainPtr dom = NULL;
static int
-remoteDispatchDomainOpenGraphicsFd(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainOpenGraphicsFd(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
remote_domain_open_graphics_fd_args *args)
{
virDomainPtr dom = NULL;
static int
-remoteDispatchDomainGetInterfaceParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetInterfaceParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_interface_parameters_args *args,
remote_domain_get_interface_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetCPUStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr hdr G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetCPUStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *hdr G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_cpu_stats_args *args,
remote_domain_get_cpu_stats_ret *ret)
{
if (virTypedParamsSerialize(params, args->nparams * args->ncpus,
REMOTE_DOMAIN_GET_CPU_STATS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetDiskErrors(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetDiskErrors(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_disk_errors_args *args,
remote_domain_get_disk_errors_ret *ret)
{
static int
-remoteDispatchNodeGetSevInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetSevInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_sev_info_args *args,
remote_node_get_sev_info_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_NODE_SEV_INFO_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
static int
-remoteDispatchNodeGetMemoryParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetMemoryParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_memory_parameters_args *args,
remote_node_get_memory_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_NODE_MEMORY_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchNodeGetCPUMap(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetCPUMap(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_cpu_map_args *args,
remote_node_get_cpu_map_ret *ret)
{
}
static int
-lxcDispatchDomainOpenNamespace(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+lxcDispatchDomainOpenNamespace(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
lxc_domain_open_namespace_args *args)
{
int rv = -1;
}
static int
-remoteDispatchDomainGetJobStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetJobStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_job_stats_args *args,
remote_domain_get_job_stats_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_JOB_STATS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainMigrateBegin3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateBegin3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_begin3_params_args *args,
remote_domain_migrate_begin3_params_ret *ret)
{
if (!(dom = get_nonnull_domain(conn, args->dom)))
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainMigratePrepare3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePrepare3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_prepare3_params_args *args,
remote_domain_migrate_prepare3_params_ret *ret)
{
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainMigratePrepareTunnel3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePrepareTunnel3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
remote_domain_migrate_prepare_tunnel3_params_args *args,
remote_domain_migrate_prepare_tunnel3_params_ret *ret)
{
int cookieoutlen = 0;
int rv = -1;
virStreamPtr st = NULL;
- daemonClientStreamPtr stream = NULL;
+ daemonClientStream *stream = NULL;
virConnectPtr conn = remoteGetHypervisorConn(client);
if (!conn)
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
static int
-remoteDispatchDomainMigratePerform3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigratePerform3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_perform3_params_args *args,
remote_domain_migrate_perform3_params_ret *ret)
{
if (!(dom = get_nonnull_domain(conn, args->dom)))
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
static int
-remoteDispatchDomainMigrateFinish3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateFinish3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_finish3_params_args *args,
remote_domain_migrate_finish3_params_ret *ret)
{
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
static int
-remoteDispatchDomainMigrateConfirm3Params(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainMigrateConfirm3Params(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_migrate_confirm3_params_args *args)
{
virTypedParameterPtr params = NULL;
if (!(dom = get_nonnull_domain(conn, args->dom)))
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) args->params.params_val,
args->params.params_len,
0, ¶ms, &nparams) < 0)
goto cleanup;
static int
-remoteDispatchConnectGetCPUModelNames(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchConnectGetCPUModelNames(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_connect_get_cpu_model_names_args *args,
remote_connect_get_cpu_model_names_ret *ret)
{
static int
-remoteDispatchDomainCreateXMLWithFiles(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainCreateXMLWithFiles(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_create_xml_with_files_args *args,
remote_domain_create_xml_with_files_ret *ret)
{
}
-static int remoteDispatchDomainCreateWithFiles(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+static int remoteDispatchDomainCreateWithFiles(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_create_with_files_args *args,
remote_domain_create_with_files_ret *ret)
{
static int
-remoteDispatchConnectNetworkEventRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectNetworkEventRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_network_event_register_any_args *args,
remote_connect_network_event_register_any_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
static int
-remoteDispatchConnectNetworkEventDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectNetworkEventDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_network_event_deregister_any_args *args)
{
int rv = -1;
}
static int
-remoteDispatchConnectStoragePoolEventRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectStoragePoolEventRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_storage_pool_event_register_any_args *args,
remote_connect_storage_pool_event_register_any_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virStoragePoolPtr pool = NULL;
}
static int
-remoteDispatchConnectStoragePoolEventDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectStoragePoolEventDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_storage_pool_event_deregister_any_args *args)
{
int rv = -1;
}
static int
-remoteDispatchConnectNodeDeviceEventRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectNodeDeviceEventRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_node_device_event_register_any_args *args,
remote_connect_node_device_event_register_any_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virNodeDevicePtr dev = NULL;
}
static int
-remoteDispatchConnectNodeDeviceEventDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectNodeDeviceEventDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_node_device_event_deregister_any_args *args)
{
int rv = -1;
}
static int
-remoteDispatchConnectSecretEventRegisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectSecretEventRegisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_secret_event_register_any_args *args,
remote_connect_secret_event_register_any_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virSecretPtr secret = NULL;
}
static int
-remoteDispatchConnectSecretEventDeregisterAny(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+remoteDispatchConnectSecretEventDeregisterAny(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
remote_connect_secret_event_deregister_any_args *args)
{
int rv = -1;
}
static int
-qemuDispatchConnectDomainMonitorEventRegister(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+qemuDispatchConnectDomainMonitorEventRegister(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
qemu_connect_domain_monitor_event_register_args *args,
qemu_connect_domain_monitor_event_register_ret *ret)
{
int callbackID;
int rv = -1;
- daemonClientEventCallbackPtr callback = NULL;
- daemonClientEventCallbackPtr ref;
+ daemonClientEventCallback *callback = NULL;
+ daemonClientEventCallback *ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
virDomainPtr dom = NULL;
static int
-qemuDispatchConnectDomainMonitorEventDeregister(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr G_GNUC_UNUSED,
+qemuDispatchConnectDomainMonitorEventDeregister(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr G_GNUC_UNUSED,
qemu_connect_domain_monitor_event_deregister_args *args)
{
int rv = -1;
}
static int
-remoteDispatchDomainGetTime(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetTime(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_time_args *args,
remote_domain_get_time_ret *ret)
{
static int
-remoteDispatchNodeGetFreePages(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeGetFreePages(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_get_free_pages_args *args,
remote_node_get_free_pages_ret *ret)
{
static int
-remoteDispatchNetworkGetDHCPLeases(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNetworkGetDHCPLeases(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_network_get_dhcp_leases_args *args,
remote_network_get_dhcp_leases_ret *ret)
{
static int
-remoteDispatchConnectGetAllDomainStats(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchConnectGetAllDomainStats(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_connect_get_all_domain_stats_args *args,
remote_connect_get_all_domain_stats_ret *ret)
{
if (virTypedParamsSerialize(retStats[i]->params,
retStats[i]->nparams,
REMOTE_CONNECT_GET_ALL_DOMAIN_STATS_MAX,
- (virTypedParameterRemotePtr *) &dst->params.params_val,
+ (struct _virTypedParameterRemote **) &dst->params.params_val,
&dst->params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
goto cleanup;
static int
-remoteDispatchNodeAllocPages(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNodeAllocPages(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_node_alloc_pages_args *args,
remote_node_alloc_pages_ret *ret)
{
static int
-remoteDispatchDomainGetFSInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetFSInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_fsinfo_args *args,
remote_domain_get_fsinfo_ret *ret)
{
static int
-remoteDispatchDomainInterfaceAddresses(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainInterfaceAddresses(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_interface_addresses_args *args,
remote_domain_interface_addresses_ret *ret)
{
static int
-remoteDispatchNetworkPortGetParameters(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchNetworkPortGetParameters(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_network_port_get_parameters_args *args,
remote_network_port_get_parameters_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_NETWORK_PORT_PARAMETERS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
args->flags) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainGetGuestInfo(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetGuestInfo(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_guest_info_args *args,
remote_domain_get_guest_info_ret *ret)
{
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_GUEST_INFO_PARAMS_MAX,
- (virTypedParameterRemotePtr *) &ret->params.params_val,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
&ret->params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0)
goto cleanup;
}
static int
-remoteDispatchDomainAuthorizedSshKeysGet(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainAuthorizedSshKeysGet(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_authorized_ssh_keys_get_args *args,
remote_domain_authorized_ssh_keys_get_ret *ret)
{
}
static int
-remoteDispatchDomainAuthorizedSshKeysSet(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainAuthorizedSshKeysSet(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_authorized_ssh_keys_set_args *args)
{
int rv = -1;
}
static int
-remoteDispatchDomainGetMessages(virNetServerPtr server G_GNUC_UNUSED,
- virNetServerClientPtr client,
- virNetMessagePtr msg G_GNUC_UNUSED,
- virNetMessageErrorPtr rerr,
+remoteDispatchDomainGetMessages(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *msg G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
remote_domain_get_messages_args *args,
remote_domain_get_messages_ret *ret)
{
extern size_t qemuNProcs;
void remoteClientFree(void *data);
-void *remoteClientNew(virNetServerClientPtr client,
+void *remoteClientNew(virNetServerClient *client,
void *opaque);
VIR_LOG_INIT("daemon.stream");
struct daemonClientStream {
- daemonClientPrivatePtr priv;
+ daemonClientPrivate *priv;
int refs;
- virNetServerProgramPtr prog;
+ virNetServerProgram *prog;
virStreamPtr st;
int procedure;
int filterID;
- virNetMessagePtr rx;
+ virNetMessage *rx;
bool tx;
bool allowSkip;
size_t dataLen; /* How much data is there remaining until we see a hole */
- daemonClientStreamPtr next;
+ daemonClientStream *next;
};
static int
-daemonStreamHandleWrite(virNetServerClientPtr client,
+daemonStreamHandleWrite(virNetServerClient *client,
daemonClientStream *stream);
static int
-daemonStreamHandleRead(virNetServerClientPtr client,
+daemonStreamHandleRead(virNetServerClient *client,
daemonClientStream *stream);
static int
-daemonStreamHandleFinish(virNetServerClientPtr client,
+daemonStreamHandleFinish(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg);
+ virNetMessage *msg);
static int
-daemonStreamHandleAbort(virNetServerClientPtr client,
+daemonStreamHandleAbort(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg);
+ virNetMessage *msg);
* fast stream, but slow client
*/
static void
-daemonStreamMessageFinished(virNetMessagePtr msg,
+daemonStreamMessageFinished(virNetMessage *msg,
void *opaque)
{
daemonClientStream *stream = opaque;
static void
daemonStreamEvent(virStreamPtr st, int events, void *opaque)
{
- virNetServerClientPtr client = opaque;
+ virNetServerClient *client = opaque;
daemonClientStream *stream;
- daemonClientPrivatePtr priv = virNetServerClientGetPrivateData(client);
+ daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
virMutexLock(&priv->lock);
/* If we have a completion/abort message, always process it */
if (stream->rx) {
- virNetMessagePtr msg = stream->rx;
+ virNetMessage *msg = stream->rx;
switch (msg->header.status) {
case VIR_NET_CONTINUE:
/* nada */
*/
if (!stream->closed && !stream->recvEOF &&
(events & VIR_STREAM_EVENT_HANGUP)) {
- virNetMessagePtr msg;
+ virNetMessage *msg;
events &= ~(VIR_STREAM_EVENT_HANGUP);
stream->tx = false;
stream->recvEOF = true;
if (!stream->closed &&
(events & (VIR_STREAM_EVENT_ERROR | VIR_STREAM_EVENT_HANGUP))) {
int ret;
- virNetMessagePtr msg;
+ virNetMessage *msg;
virNetMessageError rerr;
virErrorPtr origErr;
* -1 on fatal client error
*/
static int
-daemonStreamFilter(virNetServerClientPtr client,
- virNetMessagePtr msg,
+daemonStreamFilter(virNetServerClient *client,
+ virNetMessage *msg,
void *opaque)
{
daemonClientStream *stream = opaque;
* Returns a new stream object, or NULL upon OOM
*/
daemonClientStream *
-daemonCreateClientStream(virNetServerClientPtr client,
+daemonCreateClientStream(virNetServerClient *client,
virStreamPtr st,
- virNetServerProgramPtr prog,
- virNetMessageHeaderPtr header,
+ virNetServerProgram *prog,
+ struct virNetMessageHeader *header,
bool allowSkip)
{
daemonClientStream *stream;
- daemonClientPrivatePtr priv = virNetServerClientGetPrivateData(client);
+ daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
VIR_DEBUG("client=%p, proc=%d, serial=%u, st=%p",
client, header->proc, header->serial, st);
* Frees the memory associated with this inactive client
* stream
*/
-int daemonFreeClientStream(virNetServerClientPtr client,
+int daemonFreeClientStream(virNetServerClient *client,
daemonClientStream *stream)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
int ret = 0;
if (!stream)
msg = stream->rx;
while (msg) {
- virNetMessagePtr tmp = msg->next;
+ virNetMessage *tmp = msg->next;
if (client) {
/* Send a dummy reply to free up 'msg' & unblock client rx */
virNetMessageClear(msg);
* @client: a locked client to add the stream to
* @stream: a stream to add
*/
-int daemonAddClientStream(virNetServerClientPtr client,
+int daemonAddClientStream(virNetServerClient *client,
daemonClientStream *stream,
bool transmit)
{
- daemonClientPrivatePtr priv = virNetServerClientGetPrivateData(client);
+ daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
VIR_DEBUG("client=%p, proc=%d, serial=%u, st=%p, transmit=%d",
client, stream->procedure, stream->serial, stream->st, transmit);
* Returns 0 if the stream was removed, -1 if it doesn't exist
*/
int
-daemonRemoveClientStream(virNetServerClientPtr client,
+daemonRemoveClientStream(virNetServerClient *client,
daemonClientStream *stream)
{
- daemonClientPrivatePtr priv = virNetServerClientGetPrivateData(client);
+ daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
daemonClientStream *curr = priv->streams;
daemonClientStream *prev = NULL;
* 1 if message is still being processed
*/
static int
-daemonStreamHandleWriteData(virNetServerClientPtr client,
+daemonStreamHandleWriteData(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
int ret;
* Returns 0 if successfully sent RPC reply, -1 upon fatal error
*/
static int
-daemonStreamHandleFinish(virNetServerClientPtr client,
+daemonStreamHandleFinish(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
int ret;
* Returns 0 if successfully aborted, -1 upon error
*/
static int
-daemonStreamHandleAbort(virNetServerClientPtr client,
+daemonStreamHandleAbort(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
int ret;
bool raise_error = false;
static int
-daemonStreamHandleHole(virNetServerClientPtr client,
+daemonStreamHandleHole(virNetServerClient *client,
daemonClientStream *stream,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
int ret;
virNetStreamHole data;
* Returns 0 on success, or -1 upon fatal error
*/
static int
-daemonStreamHandleWrite(virNetServerClientPtr client,
+daemonStreamHandleWrite(virNetServerClient *client,
daemonClientStream *stream)
{
VIR_DEBUG("client=%p, stream=%p", client, stream);
while (stream->rx && !stream->closed) {
- virNetMessagePtr msg = stream->rx;
+ virNetMessage *msg = stream->rx;
int ret;
if (msg->header.type == VIR_NET_STREAM_HOLE) {
* be killed
*/
static int
-daemonStreamHandleRead(virNetServerClientPtr client,
+daemonStreamHandleRead(virNetServerClient *client,
daemonClientStream *stream)
{
- virNetMessagePtr msg = NULL;
+ virNetMessage *msg = NULL;
virNetMessageError rerr;
char *buffer;
size_t bufferLen = VIR_NET_MESSAGE_LEGACY_PAYLOAD_MAX;
#include "remote_daemon.h"
daemonClientStream *
-daemonCreateClientStream(virNetServerClientPtr client,
+daemonCreateClientStream(virNetServerClient *client,
virStreamPtr st,
- virNetServerProgramPtr prog,
- virNetMessageHeaderPtr hdr,
+ virNetServerProgram *prog,
+ struct virNetMessageHeader *hdr,
bool allowSkip);
-int daemonFreeClientStream(virNetServerClientPtr client,
+int daemonFreeClientStream(virNetServerClient *client,
daemonClientStream *stream);
-int daemonAddClientStream(virNetServerClientPtr client,
+int daemonAddClientStream(virNetServerClient *client,
daemonClientStream *stream,
bool transmit);
int
-daemonRemoveClientStream(virNetServerClientPtr client,
+daemonRemoveClientStream(virNetServerClient *client,
daemonClientStream *stream);
void
struct private_data {
virMutex lock;
- virNetClientPtr client;
- virNetClientProgramPtr remoteProgram;
- virNetClientProgramPtr qemuProgram;
- virNetClientProgramPtr lxcProgram;
+ virNetClient *client;
+ virNetClientProgram *remoteProgram;
+ virNetClientProgram *qemuProgram;
+ virNetClientProgram *lxcProgram;
int counter; /* Serial number for RPC */
- virNetTLSContextPtr tls;
+ virNetTLSContext *tls;
int is_secure; /* Secure if TLS or SASL or UNIX sockets */
char *type; /* Cached return from remoteType. */
bool serverEventFilter; /* Does server support modern event filtering */
bool serverCloseCallback; /* Does server support driver close callback */
- virObjectEventStatePtr eventState;
- virConnectCloseCallbackDataPtr closeCallback;
+ virObjectEventState *eventState;
+ virConnectCloseCallbackData *closeCallback;
};
enum {
static void
-remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventReboot(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventReboot(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackReboot(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventRTCChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventWatchdog(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventIOError(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventIOError(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackIOError(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventIOErrorReason(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventGraphics(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventGraphics(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackGraphics(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventControlError(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventControlError(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackControlError(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventBlockJob(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventDiskChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventTrayChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventPMWakeup(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventPMSuspend(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventBalloonChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventPMSuspendDisk(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventDeviceRemoved(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackDeviceAdded(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackDeviceAdded(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackDeviceRemovalFailed(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackDeviceRemovalFailed(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventBlockJob2(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventBlockJob2(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackTunable(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackTunable(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackJobCompleted(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackJobCompleted(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventCallbackMetadataChange(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventCallbackMetadataChange(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNetworkBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteStoragePoolBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteStoragePoolBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteStoragePoolBuildEventRefresh(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteStoragePoolBuildEventRefresh(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteNodeDeviceBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNodeDeviceBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteNodeDeviceBuildEventUpdate(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNodeDeviceBuildEventUpdate(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteSecretBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteSecretBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteSecretBuildEventValueChanged(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteSecretBuildEventValueChanged(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventBlockThreshold(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventBlockThreshold(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteDomainBuildEventMemoryFailure(virNetClientProgramPtr prog,
- virNetClientPtr client,
+remoteDomainBuildEventMemoryFailure(virNetClientProgram *prog,
+ virNetClient *client,
void *evdata, void *opaque);
static void
-remoteConnectNotifyEventConnectionClosed(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteConnectNotifyEventConnectionClosed(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static virNetClientProgramEvent remoteEvents[] = {
};
static void
-remoteConnectNotifyEventConnectionClosed(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteConnectNotifyEventConnectionClosed(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
}
static void
-remoteDomainBuildQemuMonitorEvent(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildQemuMonitorEvent(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque);
static virNetClientProgramEvent qemuEvents[] = {
static void
-remoteClientCloseFunc(virNetClientPtr client G_GNUC_UNUSED,
+remoteClientCloseFunc(virNetClient *client G_GNUC_UNUSED,
int reason,
void *opaque)
{
- virConnectCloseCallbackDataCall((virConnectCloseCallbackDataPtr)opaque,
+ virConnectCloseCallbackDataCall((virConnectCloseCallbackData *)opaque,
reason);
}
const char *driver_str,
remoteDriverTransport transport,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf,
+ virConf *conf,
unsigned int flags)
{
#ifndef WIN32
*/
if (conn->uri) {
for (i = 0; i < conn->uri->paramsCount; i++) {
- virURIParamPtr var = &conn->uri->params[i];
+ virURIParam *var = &conn->uri->params[i];
EXTRACT_URI_ARG_STR("name", name);
EXTRACT_URI_ARG_STR("command", command);
EXTRACT_URI_ARG_STR("socket", sockname);
static virDrvOpenStatus
remoteConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth,
- virConfPtr conf,
+ virConf *conf,
unsigned int flags)
{
struct private_data *priv;
*nparams = ret.params.params_len;
/* Deserialize the result. */
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX,
¶ms,
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX,
¶ms,
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_NUMA_PARAMETERS_MAX,
¶ms,
(xdrproc_t) xdr_remote_domain_get_launch_security_info_ret, (char *) &ret) == -1)
goto done;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_LAUNCH_SECURITY_INFO_PARAMS_MAX,
params,
(xdrproc_t) xdr_remote_domain_get_perf_events_ret, (char *) &ret) == -1)
goto done;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_PERF_EVENTS_MAX,
params,
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX,
¶ms,
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX,
¶ms,
virTypedParameterPtr cpu_params = ¶ms[cpu * nparams];
remote_typed_param *stride = &ret.params.params_val[cpu * ret.nparams];
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) stride,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) stride,
ret.nparams,
REMOTE_NODE_CPU_STATS_MAX,
&cpu_params, &tmp) < 0)
sasl_interact_t *interact;
virConnectCredentialPtr cred;
size_t ncred;
- virAuthConfigPtr config;
+ virAuthConfig *config;
};
sasl_callback_t *saslcb = NULL;
int ret = -1;
const char *mechlist;
- virNetSASLContextPtr saslCtxt;
- virNetSASLSessionPtr sasl = NULL;
+ virNetSASLContext *saslCtxt;
+ virNetSASLSession *sasl = NULL;
struct remoteAuthInteractState state;
memset(&state, 0, sizeof(state));
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventLifecycleHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventReboot(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventReboot(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventRebootHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackReboot(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventRTCChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventRTCChangeHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventWatchdog(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventWatchdogHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventIOError(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventIOError(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventIOErrorHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackIOError(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventIOErrorReason(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventIOErrorReasonHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventBlockJob(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventBlockJobHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventBlockJobHelper(conn, &msg->msg, msg->callbackID);
}
static void
-remoteDomainBuildEventBlockJob2(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventBlockJob2(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_block_job_2_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
virDomainEventGraphicsSubjectPtr subject = NULL;
return;
}
static void
-remoteDomainBuildEventGraphics(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventGraphics(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventGraphicsHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackGraphics(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventControlError(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventControlError(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventControlErrorHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackControlError(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventDiskChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventDiskChangeHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventTrayChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventTrayChangeHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventPMWakeup(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventPMWakeupHelper(conn, msg, -1, 0);
}
static void
-remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventPMSuspend(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventPMSuspendHelper(conn, msg, -1, 0);
}
static void
-remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventBalloonChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventBalloonChangeHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventPMSuspendDisk(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventPMSuspendDiskHelper(conn, msg, -1, 0);
}
static void
-remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
virObjectEventStateQueueRemote(priv->eventState, event, callbackID);
}
static void
-remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventDeviceRemoved(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remoteDomainBuildEventDeviceRemovedHelper(conn, msg, -1);
}
static void
-remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
}
static void
-remoteDomainBuildEventCallbackDeviceAdded(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackDeviceAdded(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_callback_device_added_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
static void
-remoteDomainBuildEventCallbackDeviceRemovalFailed(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackDeviceRemovalFailed(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_callback_device_removal_failed_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
}
static void
-remoteDomainBuildEventCallbackTunable(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackTunable(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
virDomainPtr dom;
virTypedParameterPtr params = NULL;
int nparams = 0;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) msg->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) msg->params.params_val,
msg->params.params_len,
REMOTE_DOMAIN_EVENT_TUNABLE_MAX,
¶ms, &nparams) < 0)
static void
-remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_callback_agent_lifecycle_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
static void
-remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata,
void *opaque)
{
remote_domain_event_callback_migration_iteration_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
static void
-remoteDomainBuildEventCallbackJobCompleted(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackJobCompleted(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata,
void *opaque)
{
remote_domain_event_callback_job_completed_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) msg->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) msg->params.params_val,
msg->params.params_len,
REMOTE_DOMAIN_JOB_STATS_MAX,
¶ms, &nparams) < 0)
static void
-remoteDomainBuildEventCallbackMetadataChange(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventCallbackMetadataChange(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_callback_metadata_change_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
static void
-remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNetworkBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_network_event_lifecycle_msg *msg = evdata;
virNetworkPtr net;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
net = get_nonnull_network(conn, msg->net);
if (!net)
}
static void
-remoteStoragePoolBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteStoragePoolBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_storage_pool_event_lifecycle_msg *msg = evdata;
virStoragePoolPtr pool;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
pool = get_nonnull_storage_pool(conn, msg->pool);
if (!pool)
}
static void
-remoteStoragePoolBuildEventRefresh(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteStoragePoolBuildEventRefresh(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_storage_pool_event_refresh_msg *msg = evdata;
virStoragePoolPtr pool;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
pool = get_nonnull_storage_pool(conn, msg->pool);
if (!pool)
}
static void
-remoteNodeDeviceBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNodeDeviceBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_node_device_event_lifecycle_msg *msg = evdata;
virNodeDevicePtr dev;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dev = get_nonnull_node_device(conn, msg->dev);
if (!dev)
}
static void
-remoteNodeDeviceBuildEventUpdate(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteNodeDeviceBuildEventUpdate(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_node_device_event_update_msg *msg = evdata;
virNodeDevicePtr dev;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dev = get_nonnull_node_device(conn, msg->dev);
if (!dev)
}
static void
-remoteSecretBuildEventLifecycle(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteSecretBuildEventLifecycle(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_secret_event_lifecycle_msg *msg = evdata;
virSecretPtr secret;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
secret = get_nonnull_secret(conn, msg->secret);
if (!secret)
}
static void
-remoteSecretBuildEventValueChanged(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteSecretBuildEventValueChanged(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
remote_secret_event_value_changed_msg *msg = evdata;
virSecretPtr secret;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
secret = get_nonnull_secret(conn, msg->secret);
if (!secret)
}
static void
-remoteDomainBuildQemuMonitorEvent(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildQemuMonitorEvent(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
qemu_domain_monitor_event_msg *msg = evdata;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
static void
-remoteDomainBuildEventBlockThreshold(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventBlockThreshold(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_block_threshold_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
static void
-remoteDomainBuildEventMemoryFailure(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetClientPtr client G_GNUC_UNUSED,
+remoteDomainBuildEventMemoryFailure(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetClient *client G_GNUC_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
remote_domain_event_memory_failure_msg *msg = evdata;
struct private_data *priv = conn->privateData;
virDomainPtr dom;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(dom = get_nonnull_domain(conn, msg->dom)))
return;
size_t nbytes)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int rv;
VIR_DEBUG("st=%p data=%p nbytes=%zu", st, data, nbytes);
unsigned int flags)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int rv;
VIR_DEBUG("st=%p data=%p nbytes=%zu flags=0x%x",
unsigned int flags)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int rv;
VIR_DEBUG("st=%p length=%lld flags=0x%x",
unsigned int flags)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int rv;
VIR_DEBUG("st=%p length=%p flags=0x%x",
virFreeCallback ff;
};
-static void remoteStreamEventCallback(virNetClientStreamPtr stream G_GNUC_UNUSED,
+static void remoteStreamEventCallback(virNetClientStream *stream G_GNUC_UNUSED,
int events,
void *opaque)
{
virFreeCallback ff)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int ret = -1;
struct remoteStreamCallbackData *cbdata;
int events)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int ret = -1;
remoteDriverLock(priv);
remoteStreamEventRemoveCallback(virStreamPtr st)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int ret = -1;
remoteDriverLock(priv);
remoteStreamCloseInt(virStreamPtr st, bool streamAbort)
{
struct private_data *priv = st->conn->privateData;
- virNetClientStreamPtr privst = st->privateData;
+ virNetClientStream *privst = st->privateData;
int ret = -1;
remoteDriverLock(priv);
int rv = -1;
remote_domain_migrate_prepare_tunnel3_args args;
remote_domain_migrate_prepare_tunnel3_ret ret;
- virNetClientStreamPtr netst;
+ virNetClientStream *netst;
remoteDriverLock(priv);
xdrproc_t ret_filter, char *ret)
{
int rv;
- virNetClientProgramPtr prog;
+ virNetClientProgram *prog;
int counter = priv->counter++;
- virNetClientPtr client = priv->client;
+ virNetClient *client = priv->client;
priv->localUses++;
if (flags & REMOTE_CALL_QEMU)
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX,
¶ms,
goto cleanup;
}
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_NODE_MEMORY_PARAMETERS_MAX,
¶ms,
(xdrproc_t) xdr_remote_node_get_sev_info_ret, (char *) &ret) == -1)
goto done;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_NODE_SEV_INFO_MAX,
params,
*type = ret.type;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_JOB_STATS_MAX,
params, nparams) < 0)
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_begin3_params_args,
rv = ret.xml; /* caller frees */
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
remoteDriverUnlock(priv);
return rv;
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_prepare3_params_args,
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
VIR_FREE(ret.uri_out);
remoteDriverUnlock(priv);
int rv = -1;
remote_domain_migrate_prepare_tunnel3_params_args args;
remote_domain_migrate_prepare_tunnel3_params_ret ret;
- virNetClientStreamPtr netst;
+ virNetClientStream *netst;
remoteDriverLock(priv);
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_params_args,
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
remoteDriverUnlock(priv);
return rv;
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_perform3_params_args,
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
remoteDriverUnlock(priv);
return rv;
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_finish3_params_args,
(char *) &ret);
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
remoteDriverUnlock(priv);
return rv;
if (virTypedParamsSerialize(params, nparams,
REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX,
- (virTypedParameterRemotePtr *) &args.params.params_val,
+ (struct _virTypedParameterRemote **) &args.params.params_val,
&args.params.params_len,
VIR_TYPED_PARAM_STRING_OKAY) < 0) {
xdr_free((xdrproc_t) xdr_remote_domain_migrate_confirm3_params_args,
rv = 0;
cleanup:
- virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val,
+ virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
remoteDriverUnlock(priv);
return rv;
if (!(elem->dom = get_nonnull_domain(conn, rec->dom)))
goto cleanup;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) rec->params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) rec->params.params_val,
rec->params.params_len,
REMOTE_CONNECT_GET_ALL_DOMAIN_STATS_MAX,
&elem->params,
(xdrproc_t) xdr_remote_network_port_get_parameters_ret, (char *) &ret) == -1)
goto done;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_NETWORK_PORT_PARAMETERS_MAX,
params,
(xdrproc_t)xdr_remote_domain_get_guest_info_ret, (char *)&ret) == -1)
goto done;
- if (virTypedParamsDeserialize((virTypedParameterRemotePtr) ret.params.params_val,
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
REMOTE_DOMAIN_GUEST_INFO_PARAMS_MAX,
params,
int
-remoteSplitURIScheme(virURIPtr uri,
+remoteSplitURIScheme(virURI *uri,
char **driver,
remoteDriverTransport *transport)
{
void
-remoteGetURIDaemonInfo(virURIPtr uri,
+remoteGetURIDaemonInfo(virURI *uri,
remoteDriverTransport transport,
bool *session,
bool *autostart)
VIR_ENUM_DECL(remoteDriverMode);
int
-remoteSplitURIScheme(virURIPtr uri,
+remoteSplitURIScheme(virURI *uri,
char **driver,
remoteDriverTransport *transport);
char **daemon);
void
-remoteGetURIDaemonInfo(virURIPtr uri,
+remoteGetURIDaemonInfo(virURI *uri,
remoteDriverTransport transport,
bool *session,
bool *autostart);
};
typedef struct virRemoteSSHHelper virRemoteSSHHelper;
-typedef virRemoteSSHHelper *virRemoteSSHHelperPtr;
struct virRemoteSSHHelper {
bool quit;
- virNetSocketPtr sock;
+ virNetSocket *sock;
int sockEvents;
int stdinWatch;
int stdinEvents;
static void
-virRemoteSSHHelperShutdown(virRemoteSSHHelperPtr proxy)
+virRemoteSSHHelperShutdown(virRemoteSSHHelper *proxy)
{
if (proxy->sock) {
virNetSocketRemoveIOCallback(proxy->sock);
static void
-virRemoteSSHHelperUpdateEvents(virRemoteSSHHelperPtr proxy)
+virRemoteSSHHelperUpdateEvents(virRemoteSSHHelper *proxy)
{
int sockEvents = 0;
int stdinEvents = 0;
}
static void
-virRemoteSSHHelperEventOnSocket(virNetSocketPtr sock,
+virRemoteSSHHelperEventOnSocket(virNetSocket *sock,
int events,
void *opaque)
{
- virRemoteSSHHelperPtr proxy = opaque;
+ virRemoteSSHHelper *proxy = opaque;
/* we got late event after proxy was shutdown */
if (!proxy->sock)
int events,
void *opaque)
{
- virRemoteSSHHelperPtr proxy = opaque;
+ virRemoteSSHHelper *proxy = opaque;
/* we got late event after console was shutdown */
if (!proxy->sock)
int events,
void *opaque)
{
- virRemoteSSHHelperPtr proxy = opaque;
+ virRemoteSSHHelper *proxy = opaque;
/* we got late event after console was shutdown */
if (!proxy->sock)
static int
-virRemoteSSHHelperRun(virNetSocketPtr sock)
+virRemoteSSHHelperRun(virNetSocket *sock)
{
int ret = -1;
virRemoteSSHHelper proxy = {
};
-static virClassPtr virKeepAliveClass;
+static virClass *virKeepAliveClass;
static void virKeepAliveDispose(void *obj);
static int virKeepAliveOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virKeepAlive);
-static virNetMessagePtr
-virKeepAliveMessage(virKeepAlivePtr ka, int proc)
+static virNetMessage *
+virKeepAliveMessage(virKeepAlive *ka, int proc)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
const char *procstr = NULL;
switch (proc) {
static bool
-virKeepAliveTimerInternal(virKeepAlivePtr ka,
- virNetMessagePtr *msg)
+virKeepAliveTimerInternal(virKeepAlive *ka,
+ virNetMessage **msg)
{
gint64 now = g_get_monotonic_time() / G_USEC_PER_SEC;
int timeval;
static void
virKeepAliveTimer(int timer G_GNUC_UNUSED, void *opaque)
{
- virKeepAlivePtr ka = opaque;
- virNetMessagePtr msg = NULL;
+ virKeepAlive *ka = opaque;
+ virNetMessage *msg = NULL;
bool dead;
void *client;
}
-virKeepAlivePtr
+virKeepAlive *
virKeepAliveNew(int interval,
unsigned int count,
void *client,
virKeepAliveDeadFunc deadCB,
virKeepAliveFreeFunc freeCB)
{
- virKeepAlivePtr ka;
+ virKeepAlive *ka;
VIR_DEBUG("client=%p, interval=%d, count=%u", client, interval, count);
void
virKeepAliveDispose(void *obj)
{
- virKeepAlivePtr ka = obj;
+ virKeepAlive *ka = obj;
PROBE(RPC_KEEPALIVE_DISPOSE,
"ka=%p", ka);
int
-virKeepAliveStart(virKeepAlivePtr ka,
+virKeepAliveStart(virKeepAlive *ka,
int interval,
unsigned int count)
{
void
-virKeepAliveStop(virKeepAlivePtr ka)
+virKeepAliveStop(virKeepAlive *ka)
{
virObjectLock(ka);
int
-virKeepAliveTimeout(virKeepAlivePtr ka)
+virKeepAliveTimeout(virKeepAlive *ka)
{
int timeout;
bool
-virKeepAliveTrigger(virKeepAlivePtr ka,
- virNetMessagePtr *msg)
+virKeepAliveTrigger(virKeepAlive *ka,
+ virNetMessage **msg)
{
bool dead;
bool
-virKeepAliveCheckMessage(virKeepAlivePtr ka,
- virNetMessagePtr msg,
- virNetMessagePtr *response)
+virKeepAliveCheckMessage(virKeepAlive *ka,
+ virNetMessage *msg,
+ virNetMessage **response)
{
bool ret = false;
#include "virnetmessage.h"
#include "virobject.h"
-typedef int (*virKeepAliveSendFunc)(void *client, virNetMessagePtr msg);
+typedef int (*virKeepAliveSendFunc)(void *client, virNetMessage *msg);
typedef void (*virKeepAliveDeadFunc)(void *client);
typedef void (*virKeepAliveFreeFunc)(void *client);
typedef struct _virKeepAlive virKeepAlive;
-typedef virKeepAlive *virKeepAlivePtr;
-virKeepAlivePtr virKeepAliveNew(int interval,
+virKeepAlive *virKeepAliveNew(int interval,
unsigned int count,
void *client,
virKeepAliveSendFunc sendCB,
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6);
-int virKeepAliveStart(virKeepAlivePtr ka,
+int virKeepAliveStart(virKeepAlive *ka,
int interval,
unsigned int count);
-void virKeepAliveStop(virKeepAlivePtr ka);
-
-int virKeepAliveTimeout(virKeepAlivePtr ka);
-bool virKeepAliveTrigger(virKeepAlivePtr ka,
- virNetMessagePtr *msg);
-bool virKeepAliveCheckMessage(virKeepAlivePtr ka,
- virNetMessagePtr msg,
- virNetMessagePtr *response);
+void virKeepAliveStop(virKeepAlive *ka);
+
+int virKeepAliveTimeout(virKeepAlive *ka);
+bool virKeepAliveTrigger(virKeepAlive *ka,
+ virNetMessage **msg);
+bool virKeepAliveCheckMessage(virKeepAlive *ka,
+ virNetMessage *msg,
+ virNetMessage **response);
VIR_LOG_INIT("rpc.netclient");
typedef struct _virNetClientCall virNetClientCall;
-typedef virNetClientCall *virNetClientCallPtr;
enum {
VIR_NET_CLIENT_MODE_WAIT_TX,
struct _virNetClientCall {
int mode;
- virNetMessagePtr msg;
+ virNetMessage *msg;
bool expectReply;
bool nonBlock;
bool haveThread;
virCond cond;
- virNetClientCallPtr next;
+ virNetClientCall *next;
};
struct _virNetClient {
virObjectLockable parent;
- virNetSocketPtr sock;
+ virNetSocket *sock;
bool asyncIO;
- virNetTLSSessionPtr tls;
+ virNetTLSSession *tls;
char *hostname;
- virNetClientProgramPtr *programs;
+ virNetClientProgram **programs;
size_t nprograms;
/* For incoming message packets */
virNetMessage msg;
#if WITH_SASL
- virNetSASLSessionPtr sasl;
+ virNetSASLSession *sasl;
#endif
GMainLoop *eventLoop;
* them, except possibly the first call in the list
* which might be a partially sent non-blocking call.
*/
- virNetClientCallPtr waitDispatch;
+ virNetClientCall *waitDispatch;
/* True if a thread holds the buck */
bool haveTheBuck;
size_t nstreams;
- virNetClientStreamPtr *streams;
+ virNetClientStream **streams;
- virKeepAlivePtr keepalive;
+ virKeepAlive *keepalive;
bool wantClose;
int closeReason;
virErrorPtr error;
};
-static virClassPtr virNetClientClass;
+static virClass *virNetClientClass;
static void virNetClientDispose(void *obj);
static int virNetClientOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virNetClient);
-static void virNetClientIOEventLoopPassTheBuck(virNetClientPtr client,
- virNetClientCallPtr thiscall);
-static int virNetClientQueueNonBlocking(virNetClientPtr client,
- virNetMessagePtr msg);
-static void virNetClientCloseInternal(virNetClientPtr client,
+static void virNetClientIOEventLoopPassTheBuck(virNetClient *client,
+ virNetClientCall *thiscall);
+static int virNetClientQueueNonBlocking(virNetClient *client,
+ virNetMessage *msg);
+static void virNetClientCloseInternal(virNetClient *client,
int reason);
-void virNetClientSetCloseCallback(virNetClientPtr client,
+void virNetClientSetCloseCallback(virNetClient *client,
virNetClientCloseFunc cb,
void *opaque,
virFreeCallback ff)
}
-static void virNetClientIncomingEvent(virNetSocketPtr sock,
+static void virNetClientIncomingEvent(virNetSocket *sock,
int events,
void *opaque);
/* Append a call to the end of the list */
-static void virNetClientCallQueue(virNetClientCallPtr *head,
- virNetClientCallPtr call)
+static void virNetClientCallQueue(virNetClientCall **head,
+ virNetClientCall *call)
{
- virNetClientCallPtr tmp = *head;
+ virNetClientCall *tmp = *head;
while (tmp && tmp->next)
tmp = tmp->next;
if (tmp)
#if 0
/* Obtain a call from the head of the list */
-static virNetClientCallPtr virNetClientCallServe(virNetClientCallPtr *head)
+static virNetClientCall *virNetClientCallServe(virNetClientCall **head)
{
- virNetClientCallPtr tmp = *head;
+ virNetClientCall *tmp = *head;
if (tmp)
*head = tmp->next;
else
#endif
/* Remove a call from anywhere in the list */
-static void virNetClientCallRemove(virNetClientCallPtr *head,
- virNetClientCallPtr call)
+static void virNetClientCallRemove(virNetClientCall **head,
+ virNetClientCall *call)
{
- virNetClientCallPtr tmp = *head;
- virNetClientCallPtr prev = NULL;
+ virNetClientCall *tmp = *head;
+ virNetClientCall *prev = NULL;
while (tmp) {
if (tmp == call) {
if (prev)
}
/* Predicate returns true if matches */
-typedef bool (*virNetClientCallPredicate)(virNetClientCallPtr call, void *opaque);
+typedef bool (*virNetClientCallPredicate)(virNetClientCall *call, void *opaque);
/* Remove a list of calls from the list based on a predicate */
-static void virNetClientCallRemovePredicate(virNetClientCallPtr *head,
+static void virNetClientCallRemovePredicate(virNetClientCall **head,
virNetClientCallPredicate pred,
void *opaque)
{
- virNetClientCallPtr tmp = *head;
- virNetClientCallPtr prev = NULL;
+ virNetClientCall *tmp = *head;
+ virNetClientCall *prev = NULL;
while (tmp) {
- virNetClientCallPtr next = tmp->next;
+ virNetClientCall *next = tmp->next;
tmp->next = NULL; /* Temp unlink */
if (pred(tmp, opaque)) {
if (prev)
}
/* Returns true if the predicate matches at least one call in the list */
-static bool virNetClientCallMatchPredicate(virNetClientCallPtr head,
+static bool virNetClientCallMatchPredicate(virNetClientCall *head,
virNetClientCallPredicate pred,
void *opaque)
{
- virNetClientCallPtr tmp = head;
+ virNetClientCall *tmp = head;
while (tmp) {
if (pred(tmp, opaque))
return true;
bool
-virNetClientKeepAliveIsSupported(virNetClientPtr client)
+virNetClientKeepAliveIsSupported(virNetClient *client)
{
bool supported;
}
int
-virNetClientKeepAliveStart(virNetClientPtr client,
+virNetClientKeepAliveStart(virNetClient *client,
int interval,
unsigned int count)
{
}
void
-virNetClientKeepAliveStop(virNetClientPtr client)
+virNetClientKeepAliveStop(virNetClient *client)
{
virObjectLock(client);
virKeepAliveStop(client->keepalive);
static int
virNetClientKeepAliveSendCB(void *opaque,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
int ret;
return ret;
}
-static virNetClientPtr virNetClientNew(virNetSocketPtr sock,
+static virNetClient *virNetClientNew(virNetSocket *sock,
const char *hostname)
{
- virNetClientPtr client = NULL;
+ virNetClient *client = NULL;
if (virNetClientInitialize() < 0)
goto error;
}
-virNetClientPtr virNetClientNewUNIX(const char *path,
+virNetClient *virNetClientNewUNIX(const char *path,
bool spawnDaemon,
const char *binary)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
if (virNetSocketNewConnectUNIX(path, spawnDaemon, binary, &sock) < 0)
return NULL;
}
-virNetClientPtr virNetClientNewTCP(const char *nodename,
+virNetClient *virNetClientNewTCP(const char *nodename,
const char *service,
int family)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
if (virNetSocketNewConnectTCP(nodename, service,
family,
if (!VAR) \
VAR = VAL;
-virNetClientPtr virNetClientNewSSH(const char *nodename,
+virNetClient *virNetClientNewSSH(const char *nodename,
const char *service,
const char *binary,
const char *username,
const char *driverURI,
bool readonly)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
g_autofree char *command = NULL;
if (!(command = virNetClientSSHHelperCommand(proxy, netcatPath, socketPath,
return virNetClientNew(sock, NULL);
}
-virNetClientPtr virNetClientNewLibSSH2(const char *host,
+virNetClient *virNetClientNewLibSSH2(const char *host,
const char *port,
int family,
const char *username,
const char *driverURI,
bool readonly,
virConnectAuthPtr authPtr,
- virURIPtr uri)
+ virURI *uri)
{
- virNetSocketPtr sock = NULL;
+ virNetSocket *sock = NULL;
g_autofree char *command = NULL;
g_autofree char *homedir = NULL;
g_autofree char *confdir = NULL;
return virNetClientNew(sock, NULL);
}
-virNetClientPtr virNetClientNewLibssh(const char *host,
+virNetClient *virNetClientNewLibssh(const char *host,
const char *port,
int family,
const char *username,
const char *driverURI,
bool readonly,
virConnectAuthPtr authPtr,
- virURIPtr uri)
+ virURI *uri)
{
- virNetSocketPtr sock = NULL;
+ virNetSocket *sock = NULL;
g_autofree char *command = NULL;
g_autofree char *homedir = NULL;
g_autofree char *confdir = NULL;
}
#undef DEFAULT_VALUE
-virNetClientPtr virNetClientNewExternal(const char **cmdargv)
+virNetClient *virNetClientNewExternal(const char **cmdargv)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
if (virNetSocketNewConnectExternal(cmdargv, &sock) < 0)
return NULL;
}
-int virNetClientRegisterAsyncIO(virNetClientPtr client)
+int virNetClientRegisterAsyncIO(virNetClient *client)
{
if (client->asyncIO)
return 0;
}
-int virNetClientRegisterKeepAlive(virNetClientPtr client)
+int virNetClientRegisterKeepAlive(virNetClient *client)
{
- virKeepAlivePtr ka;
+ virKeepAlive *ka;
if (client->keepalive)
return 0;
}
-int virNetClientGetFD(virNetClientPtr client)
+int virNetClientGetFD(virNetClient *client)
{
int fd;
virObjectLock(client);
}
-int virNetClientDupFD(virNetClientPtr client, bool cloexec)
+int virNetClientDupFD(virNetClient *client, bool cloexec)
{
int fd;
virObjectLock(client);
}
-bool virNetClientHasPassFD(virNetClientPtr client)
+bool virNetClientHasPassFD(virNetClient *client)
{
bool hasPassFD;
virObjectLock(client);
void virNetClientDispose(void *obj)
{
- virNetClientPtr client = obj;
+ virNetClient *client = obj;
size_t i;
PROBE(RPC_CLIENT_DISPOSE,
static void
-virNetClientMarkClose(virNetClientPtr client,
+virNetClientMarkClose(virNetClient *client,
int reason)
{
VIR_DEBUG("client=%p, reason=%d", client, reason);
static void
-virNetClientCloseLocked(virNetClientPtr client)
+virNetClientCloseLocked(virNetClient *client)
{
- virKeepAlivePtr ka;
+ virKeepAlive *ka;
VIR_DEBUG("client=%p, sock=%p, reason=%d", client, client->sock, client->closeReason);
}
-static void virNetClientCloseInternal(virNetClientPtr client,
+static void virNetClientCloseInternal(virNetClient *client,
int reason)
{
VIR_DEBUG("client=%p wantclose=%d", client, client ? client->wantClose : false);
}
-void virNetClientClose(virNetClientPtr client)
+void virNetClientClose(virNetClient *client)
{
virNetClientCloseInternal(client, VIR_CONNECT_CLOSE_REASON_CLIENT);
}
#if WITH_SASL
-void virNetClientSetSASLSession(virNetClientPtr client,
- virNetSASLSessionPtr sasl)
+void virNetClientSetSASLSession(virNetClient *client,
+ virNetSASLSession *sasl)
{
virObjectLock(client);
client->sasl = virObjectRef(sasl);
gpointer opaque);
static gboolean
-virNetClientTLSHandshake(virNetClientPtr client)
+virNetClientTLSHandshake(virNetClient *client)
{
g_autoptr(GSource) source = NULL;
GIOCondition ev;
GIOCondition ev G_GNUC_UNUSED,
gpointer opaque)
{
- virNetClientPtr client = opaque;
+ virNetClient *client = opaque;
if (!virNetClientTLSHandshake(client))
g_main_loop_quit(client->eventLoop);
GIOCondition ev G_GNUC_UNUSED,
gpointer opaque)
{
- virNetClientPtr client = opaque;
+ virNetClient *client = opaque;
g_main_loop_quit(client->eventLoop);
}
-int virNetClientSetTLSSession(virNetClientPtr client,
- virNetTLSContextPtr tls)
+int virNetClientSetTLSSession(virNetClient *client,
+ virNetTLSContext *tls)
{
int ret;
char buf[1];
return -1;
}
-bool virNetClientIsEncrypted(virNetClientPtr client)
+bool virNetClientIsEncrypted(virNetClient *client)
{
bool ret = false;
virObjectLock(client);
}
-bool virNetClientIsOpen(virNetClientPtr client)
+bool virNetClientIsOpen(virNetClient *client)
{
bool ret;
}
-int virNetClientAddProgram(virNetClientPtr client,
- virNetClientProgramPtr prog)
+int virNetClientAddProgram(virNetClient *client,
+ virNetClientProgram *prog)
{
virObjectLock(client);
}
-int virNetClientAddStream(virNetClientPtr client,
- virNetClientStreamPtr st)
+int virNetClientAddStream(virNetClient *client,
+ virNetClientStream *st)
{
virObjectLock(client);
}
-void virNetClientRemoveStream(virNetClientPtr client,
- virNetClientStreamPtr st)
+void virNetClientRemoveStream(virNetClient *client,
+ virNetClientStream *st)
{
size_t i;
}
-const char *virNetClientLocalAddrStringSASL(virNetClientPtr client)
+const char *virNetClientLocalAddrStringSASL(virNetClient *client)
{
return virNetSocketLocalAddrStringSASL(client->sock);
}
-const char *virNetClientRemoteAddrStringSASL(virNetClientPtr client)
+const char *virNetClientRemoteAddrStringSASL(virNetClient *client)
{
return virNetSocketRemoteAddrStringSASL(client->sock);
}
-int virNetClientGetTLSKeySize(virNetClientPtr client)
+int virNetClientGetTLSKeySize(virNetClient *client)
{
int ret = 0;
virObjectLock(client);
}
static int
-virNetClientCallDispatchReply(virNetClientPtr client)
+virNetClientCallDispatchReply(virNetClient *client)
{
- virNetClientCallPtr thecall;
+ virNetClientCall *thecall;
/* Ok, definitely got an RPC reply now find
out which waiting call is associated with it */
return 0;
}
-static int virNetClientCallDispatchMessage(virNetClientPtr client)
+static int virNetClientCallDispatchMessage(virNetClient *client)
{
size_t i;
- virNetClientProgramPtr prog = NULL;
+ virNetClientProgram *prog = NULL;
for (i = 0; i < client->nprograms; i++) {
if (virNetClientProgramMatches(client->programs[i],
return 0;
}
-static void virNetClientCallCompleteAllWaitingReply(virNetClientPtr client)
+static void virNetClientCallCompleteAllWaitingReply(virNetClient *client)
{
- virNetClientCallPtr call;
+ virNetClientCall *call;
for (call = client->waitDispatch; call; call = call->next) {
if (call->msg->header.prog == client->msg.header.prog &&
}
}
-static int virNetClientCallDispatchStream(virNetClientPtr client)
+static int virNetClientCallDispatchStream(virNetClient *client)
{
size_t i;
- virNetClientStreamPtr st = NULL;
- virNetClientCallPtr thecall;
+ virNetClientStream *st = NULL;
+ virNetClientCall *thecall;
/* First identify what stream this packet is directed at */
for (i = 0; i < client->nstreams; i++) {
static int
-virNetClientCallDispatch(virNetClientPtr client)
+virNetClientCallDispatch(virNetClient *client)
{
- virNetMessagePtr response = NULL;
+ virNetMessage *response = NULL;
PROBE(RPC_CLIENT_MSG_RX,
"client=%p len=%zu prog=%u vers=%u proc=%u type=%u status=%u serial=%u",
static ssize_t
-virNetClientIOWriteMessage(virNetClientPtr client,
- virNetClientCallPtr thecall)
+virNetClientIOWriteMessage(virNetClient *client,
+ virNetClientCall *thecall)
{
ssize_t ret = 0;
static ssize_t
-virNetClientIOHandleOutput(virNetClientPtr client)
+virNetClientIOHandleOutput(virNetClient *client)
{
- virNetClientCallPtr thecall = client->waitDispatch;
+ virNetClientCall *thecall = client->waitDispatch;
while (thecall &&
thecall->mode != VIR_NET_CLIENT_MODE_WAIT_TX)
}
static ssize_t
-virNetClientIOReadMessage(virNetClientPtr client)
+virNetClientIOReadMessage(virNetClient *client)
{
size_t wantData;
ssize_t ret;
static ssize_t
-virNetClientIOHandleInput(virNetClientPtr client)
+virNetClientIOHandleInput(virNetClient *client)
{
/* Read as much data as is available, until we get
* EAGAIN
}
-static bool virNetClientIOEventLoopPollEvents(virNetClientCallPtr call,
+static bool virNetClientIOEventLoopPollEvents(virNetClientCall *call,
void *opaque)
{
GIOCondition *ev = opaque;
}
-static bool virNetClientIOEventLoopRemoveDone(virNetClientCallPtr call,
+static bool virNetClientIOEventLoopRemoveDone(virNetClientCall *call,
void *opaque)
{
- virNetClientCallPtr thiscall = opaque;
+ virNetClientCall *thiscall = opaque;
if (call == thiscall)
return false;
static void
-virNetClientIODetachNonBlocking(virNetClientCallPtr call)
+virNetClientIODetachNonBlocking(virNetClientCall *call)
{
VIR_DEBUG("Keeping unfinished non-blocking call %p in the queue", call);
call->haveThread = false;
static bool
-virNetClientIOEventLoopRemoveAll(virNetClientCallPtr call,
+virNetClientIOEventLoopRemoveAll(virNetClientCall *call,
void *opaque)
{
- virNetClientCallPtr thiscall = opaque;
+ virNetClientCall *thiscall = opaque;
if (call == thiscall)
return false;
static void
-virNetClientIOEventLoopPassTheBuck(virNetClientPtr client,
- virNetClientCallPtr thiscall)
+virNetClientIOEventLoopPassTheBuck(virNetClient *client,
+ virNetClientCall *thiscall)
{
- virNetClientCallPtr tmp = client->waitDispatch;
+ virNetClientCall *tmp = client->waitDispatch;
VIR_DEBUG("Giving up the buck %p", thiscall);
struct virNetClientIOEventData {
- virNetClientPtr client;
+ virNetClient *client;
GIOCondition rev;
};
* Returns 1 if the call was queued and will be completed later (only
* for nonBlock == true), 0 if the call was completed and -1 on error.
*/
-static int virNetClientIOEventLoop(virNetClientPtr client,
- virNetClientCallPtr thiscall)
+static int virNetClientIOEventLoop(virNetClient *client,
+ virNetClientCall *thiscall)
{
bool error = false;
int closeReason;
sigset_t oldmask, blockedsigs;
#endif /* !WIN32 */
int timeout = -1;
- virNetMessagePtr msg = NULL;
+ virNetMessage *msg = NULL;
g_autoptr(GSource) source = NULL;
GIOCondition ev = 0;
struct virNetClientIOEventData data = {
static bool
-virNetClientIOUpdateEvents(virNetClientCallPtr call,
+virNetClientIOUpdateEvents(virNetClientCall *call,
void *opaque)
{
int *events = opaque;
}
-static void virNetClientIOUpdateCallback(virNetClientPtr client,
+static void virNetClientIOUpdateCallback(virNetClient *client,
bool enableCallback)
{
int events = 0;
* Returns 1 if the call was queued and will be completed later (only
* for nonBlock == true), 0 if the call was completed and -1 on error.
*/
-static int virNetClientIO(virNetClientPtr client,
- virNetClientCallPtr thiscall)
+static int virNetClientIO(virNetClient *client,
+ virNetClientCall *thiscall)
{
int rv = -1;
}
-void virNetClientIncomingEvent(virNetSocketPtr sock,
+void virNetClientIncomingEvent(virNetSocket *sock,
int events,
void *opaque)
{
- virNetClientPtr client = opaque;
+ virNetClient *client = opaque;
int closeReason;
virObjectLock(client);
}
-static virNetClientCallPtr
-virNetClientCallNew(virNetMessagePtr msg,
+static virNetClientCall *
+virNetClientCallNew(virNetMessage *msg,
bool expectReply,
bool nonBlock)
{
- virNetClientCallPtr call = NULL;
+ virNetClientCall *call = NULL;
if (expectReply &&
(msg->bufferLength != 0) &&
static int
-virNetClientQueueNonBlocking(virNetClientPtr client,
- virNetMessagePtr msg)
+virNetClientQueueNonBlocking(virNetClient *client,
+ virNetMessage *msg)
{
- virNetClientCallPtr call;
+ virNetClientCall *call;
PROBE(RPC_CLIENT_MSG_TX_QUEUE,
"client=%p len=%zu prog=%u vers=%u proc=%u"
* Returns 1 if the call was queued and will be completed later (only
* for nonBlock == true), 0 if the call was completed and -1 on error.
*/
-static int virNetClientSendInternal(virNetClientPtr client,
- virNetMessagePtr msg,
+static int virNetClientSendInternal(virNetClient *client,
+ virNetMessage *msg,
bool expectReply,
bool nonBlock)
{
- virNetClientCallPtr call;
+ virNetClientCall *call;
int ret = -1;
PROBE(RPC_CLIENT_MSG_TX_QUEUE,
*
* Returns 0 on success, -1 on failure
*/
-int virNetClientSendWithReply(virNetClientPtr client,
- virNetMessagePtr msg)
+int virNetClientSendWithReply(virNetClient *client,
+ virNetMessage *msg)
{
int ret;
virObjectLock(client);
* Returns 1 if the message was queued and will be completed later (only
* for nonBlock == true), 0 if the message was completed and -1 on error.
*/
-int virNetClientSendNonBlock(virNetClientPtr client,
- virNetMessagePtr msg)
+int virNetClientSendNonBlock(virNetClient *client,
+ virNetMessage *msg)
{
int ret;
virObjectLock(client);
*
* Returns 0 on success, -1 on failure
*/
-int virNetClientSendStream(virNetClientPtr client,
- virNetMessagePtr msg,
- virNetClientStreamPtr st)
+int virNetClientSendStream(virNetClient *client,
+ virNetMessage *msg,
+ virNetClientStream *st)
{
int ret = -1;
bool expectReply = !msg->bufferLength ||
const char *driverURI,
bool readonly);
-virNetClientPtr virNetClientNewUNIX(const char *path,
+virNetClient *virNetClientNewUNIX(const char *path,
bool spawnDaemon,
const char *binary);
-virNetClientPtr virNetClientNewTCP(const char *nodename,
+virNetClient *virNetClientNewTCP(const char *nodename,
const char *service,
int family);
-virNetClientPtr virNetClientNewSSH(const char *nodename,
+virNetClient *virNetClientNewSSH(const char *nodename,
const char *service,
const char *binary,
const char *username,
const char *driverURI,
bool readonly);
-virNetClientPtr virNetClientNewLibSSH2(const char *host,
+virNetClient *virNetClientNewLibSSH2(const char *host,
const char *port,
int family,
const char *username,
const char *driverURI,
bool readonly,
virConnectAuthPtr authPtr,
- virURIPtr uri);
+ virURI *uri);
-virNetClientPtr virNetClientNewLibssh(const char *host,
+virNetClient *virNetClientNewLibssh(const char *host,
const char *port,
int family,
const char *username,
const char *driverURI,
bool readonly,
virConnectAuthPtr authPtr,
- virURIPtr uri);
+ virURI *uri);
-virNetClientPtr virNetClientNewExternal(const char **cmdargv);
+virNetClient *virNetClientNewExternal(const char **cmdargv);
-int virNetClientRegisterAsyncIO(virNetClientPtr client);
-int virNetClientRegisterKeepAlive(virNetClientPtr client);
+int virNetClientRegisterAsyncIO(virNetClient *client);
+int virNetClientRegisterKeepAlive(virNetClient *client);
-typedef void (*virNetClientCloseFunc)(virNetClientPtr client,
+typedef void (*virNetClientCloseFunc)(virNetClient *client,
int reason,
void *opaque);
-void virNetClientSetCloseCallback(virNetClientPtr client,
+void virNetClientSetCloseCallback(virNetClient *client,
virNetClientCloseFunc cb,
void *opaque,
virFreeCallback ff);
-int virNetClientGetFD(virNetClientPtr client);
-int virNetClientDupFD(virNetClientPtr client, bool cloexec);
+int virNetClientGetFD(virNetClient *client);
+int virNetClientDupFD(virNetClient *client, bool cloexec);
-bool virNetClientHasPassFD(virNetClientPtr client);
+bool virNetClientHasPassFD(virNetClient *client);
-int virNetClientAddProgram(virNetClientPtr client,
- virNetClientProgramPtr prog);
+int virNetClientAddProgram(virNetClient *client,
+ virNetClientProgram *prog);
-int virNetClientAddStream(virNetClientPtr client,
- virNetClientStreamPtr st);
+int virNetClientAddStream(virNetClient *client,
+ virNetClientStream *st);
-void virNetClientRemoveStream(virNetClientPtr client,
- virNetClientStreamPtr st);
+void virNetClientRemoveStream(virNetClient *client,
+ virNetClientStream *st);
-int virNetClientSendWithReply(virNetClientPtr client,
- virNetMessagePtr msg);
+int virNetClientSendWithReply(virNetClient *client,
+ virNetMessage *msg);
-int virNetClientSendNonBlock(virNetClientPtr client,
- virNetMessagePtr msg);
+int virNetClientSendNonBlock(virNetClient *client,
+ virNetMessage *msg);
-int virNetClientSendStream(virNetClientPtr client,
- virNetMessagePtr msg,
- virNetClientStreamPtr st);
+int virNetClientSendStream(virNetClient *client,
+ virNetMessage *msg,
+ virNetClientStream *st);
#ifdef WITH_SASL
-void virNetClientSetSASLSession(virNetClientPtr client,
- virNetSASLSessionPtr sasl);
+void virNetClientSetSASLSession(virNetClient *client,
+ virNetSASLSession *sasl);
#endif
-int virNetClientSetTLSSession(virNetClientPtr client,
- virNetTLSContextPtr tls);
+int virNetClientSetTLSSession(virNetClient *client,
+ virNetTLSContext *tls);
-bool virNetClientIsEncrypted(virNetClientPtr client);
-bool virNetClientIsOpen(virNetClientPtr client);
+bool virNetClientIsEncrypted(virNetClient *client);
+bool virNetClientIsOpen(virNetClient *client);
-const char *virNetClientLocalAddrStringSASL(virNetClientPtr client);
-const char *virNetClientRemoteAddrStringSASL(virNetClientPtr client);
+const char *virNetClientLocalAddrStringSASL(virNetClient *client);
+const char *virNetClientRemoteAddrStringSASL(virNetClient *client);
-int virNetClientGetTLSKeySize(virNetClientPtr client);
+int virNetClientGetTLSKeySize(virNetClient *client);
-void virNetClientClose(virNetClientPtr client);
+void virNetClientClose(virNetClient *client);
-bool virNetClientKeepAliveIsSupported(virNetClientPtr client);
-int virNetClientKeepAliveStart(virNetClientPtr client,
+bool virNetClientKeepAliveIsSupported(virNetClient *client);
+int virNetClientKeepAliveStart(virNetClient *client,
int interval,
unsigned int count);
-void virNetClientKeepAliveStop(virNetClientPtr client);
+void virNetClientKeepAliveStop(virNetClient *client);
unsigned program;
unsigned version;
- virNetClientProgramEventPtr events;
+ virNetClientProgramEvent *events;
size_t nevents;
void *eventOpaque;
};
-static virClassPtr virNetClientProgramClass;
+static virClass *virNetClientProgramClass;
static void virNetClientProgramDispose(void *obj);
static int virNetClientProgramOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virNetClientProgram);
-virNetClientProgramPtr virNetClientProgramNew(unsigned program,
+virNetClientProgram *virNetClientProgramNew(unsigned program,
unsigned version,
- virNetClientProgramEventPtr events,
+ virNetClientProgramEvent *events,
size_t nevents,
void *eventOpaque)
{
- virNetClientProgramPtr prog;
+ virNetClientProgram *prog;
if (virNetClientProgramInitialize() < 0)
return NULL;
}
-unsigned virNetClientProgramGetProgram(virNetClientProgramPtr prog)
+unsigned virNetClientProgramGetProgram(virNetClientProgram *prog)
{
return prog->program;
}
-unsigned virNetClientProgramGetVersion(virNetClientProgramPtr prog)
+unsigned virNetClientProgramGetVersion(virNetClientProgram *prog)
{
return prog->version;
}
-int virNetClientProgramMatches(virNetClientProgramPtr prog,
- virNetMessagePtr msg)
+int virNetClientProgramMatches(virNetClientProgram *prog,
+ virNetMessage *msg)
{
if (prog->program == msg->header.prog &&
prog->version == msg->header.vers)
static int
-virNetClientProgramDispatchError(virNetClientProgramPtr prog G_GNUC_UNUSED,
- virNetMessagePtr msg)
+virNetClientProgramDispatchError(virNetClientProgram *prog G_GNUC_UNUSED,
+ virNetMessage *msg)
{
virNetMessageError err;
int ret = -1;
}
-static virNetClientProgramEventPtr virNetClientProgramGetEvent(virNetClientProgramPtr prog,
+static virNetClientProgramEvent *virNetClientProgramGetEvent(virNetClientProgram *prog,
int procedure)
{
size_t i;
}
-int virNetClientProgramDispatch(virNetClientProgramPtr prog,
- virNetClientPtr client,
- virNetMessagePtr msg)
+int virNetClientProgramDispatch(virNetClientProgram *prog,
+ virNetClient *client,
+ virNetMessage *msg)
{
- virNetClientProgramEventPtr event;
+ virNetClientProgramEvent *event;
char *evdata;
VIR_DEBUG("prog=%d ver=%d type=%d status=%d serial=%d proc=%d",
}
-int virNetClientProgramCall(virNetClientProgramPtr prog,
- virNetClientPtr client,
+int virNetClientProgramCall(virNetClientProgram *prog,
+ virNetClient *client,
unsigned serial,
int proc,
size_t noutfds,
xdrproc_t args_filter, void *args,
xdrproc_t ret_filter, void *ret)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
size_t i;
if (infds)
#include "virobject.h"
typedef struct _virNetClient virNetClient;
-typedef virNetClient *virNetClientPtr;
typedef struct _virNetClientProgram virNetClientProgram;
-typedef virNetClientProgram *virNetClientProgramPtr;
typedef struct _virNetClientProgramEvent virNetClientProgramEvent;
-typedef virNetClientProgramEvent *virNetClientProgramEventPtr;
typedef struct _virNetClientProgramErrorHandler virNetClientProgramErrorHander;
-typedef virNetClientProgramErrorHander *virNetClientProgramErrorHanderPtr;
-typedef void (*virNetClientProgramDispatchFunc)(virNetClientProgramPtr prog,
- virNetClientPtr client,
+typedef void (*virNetClientProgramDispatchFunc)(virNetClientProgram *prog,
+ virNetClient *client,
void *msg,
void *opaque);
xdrproc_t msg_filter;
};
-virNetClientProgramPtr virNetClientProgramNew(unsigned program,
+virNetClientProgram *virNetClientProgramNew(unsigned program,
unsigned version,
- virNetClientProgramEventPtr events,
+ virNetClientProgramEvent *events,
size_t nevents,
void *eventOpaque);
-unsigned virNetClientProgramGetProgram(virNetClientProgramPtr prog);
-unsigned virNetClientProgramGetVersion(virNetClientProgramPtr prog);
+unsigned virNetClientProgramGetProgram(virNetClientProgram *prog);
+unsigned virNetClientProgramGetVersion(virNetClientProgram *prog);
-int virNetClientProgramMatches(virNetClientProgramPtr prog,
- virNetMessagePtr msg);
+int virNetClientProgramMatches(virNetClientProgram *prog,
+ virNetMessage *msg);
-int virNetClientProgramDispatch(virNetClientProgramPtr prog,
- virNetClientPtr client,
- virNetMessagePtr msg);
+int virNetClientProgramDispatch(virNetClientProgram *prog,
+ virNetClient *client,
+ virNetMessage *msg);
-int virNetClientProgramCall(virNetClientProgramPtr prog,
- virNetClientPtr client,
+int virNetClientProgramCall(virNetClientProgram *prog,
+ virNetClient *client,
unsigned serial,
int proc,
size_t noutfds,
struct _virNetClientStream {
virObjectLockable parent;
- virNetClientProgramPtr prog;
+ virNetClientProgram *prog;
int proc;
unsigned serial;
* time by stopping consuming any incoming data
* off the socket....
*/
- virNetMessagePtr rx;
+ virNetMessage *rx;
bool incomingEOF;
virNetClientStreamClosed closed;
};
-static virClassPtr virNetClientStreamClass;
+static virClass *virNetClientStreamClass;
static void virNetClientStreamDispose(void *obj);
static int virNetClientStreamOnceInit(void)
static void
-virNetClientStreamEventTimerUpdate(virNetClientStreamPtr st)
+virNetClientStreamEventTimerUpdate(virNetClientStream *st)
{
if (!st->cb)
return;
static void
virNetClientStreamEventTimer(int timer G_GNUC_UNUSED, void *opaque)
{
- virNetClientStreamPtr st = opaque;
+ virNetClientStream *st = opaque;
int events = 0;
virObjectLock(st);
}
-virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,
+virNetClientStream *virNetClientStreamNew(virNetClientProgram *prog,
int proc,
unsigned serial,
bool allowSkip)
{
- virNetClientStreamPtr st;
+ virNetClientStream *st;
if (virNetClientStreamInitialize() < 0)
return NULL;
void virNetClientStreamDispose(void *obj)
{
- virNetClientStreamPtr st = obj;
+ virNetClientStream *st = obj;
virResetError(&st->err);
while (st->rx) {
- virNetMessagePtr msg = st->rx;
+ virNetMessage *msg = st->rx;
virNetMessageQueueServe(&st->rx);
virNetMessageFree(msg);
}
virObjectUnref(st->prog);
}
-bool virNetClientStreamMatches(virNetClientStreamPtr st,
- virNetMessagePtr msg)
+bool virNetClientStreamMatches(virNetClientStream *st,
+ virNetMessage *msg)
{
bool match = false;
virObjectLock(st);
static
-void virNetClientStreamRaiseError(virNetClientStreamPtr st)
+void virNetClientStreamRaiseError(virNetClientStream *st)
{
virRaiseErrorFull(__FILE__, __FUNCTION__, __LINE__,
st->err.domain,
/* MUST be called under stream or client lock */
-int virNetClientStreamCheckState(virNetClientStreamPtr st)
+int virNetClientStreamCheckState(virNetClientStream *st)
{
if (st->err.code != VIR_ERR_OK) {
virNetClientStreamRaiseError(st);
/* MUST be called under stream or client lock. This should
* be called only for message that expect reply. */
-int virNetClientStreamCheckSendStatus(virNetClientStreamPtr st,
- virNetMessagePtr msg)
+int virNetClientStreamCheckSendStatus(virNetClientStream *st,
+ virNetMessage *msg)
{
if (st->err.code != VIR_ERR_OK) {
virNetClientStreamRaiseError(st);
}
-void virNetClientStreamSetClosed(virNetClientStreamPtr st,
+void virNetClientStreamSetClosed(virNetClientStream *st,
virNetClientStreamClosed closed)
{
virObjectLock(st);
}
-int virNetClientStreamSetError(virNetClientStreamPtr st,
- virNetMessagePtr msg)
+int virNetClientStreamSetError(virNetClientStream *st,
+ virNetMessage *msg)
{
virNetMessageError err;
int ret = -1;
}
-int virNetClientStreamQueuePacket(virNetClientStreamPtr st,
- virNetMessagePtr msg)
+int virNetClientStreamQueuePacket(virNetClientStream *st,
+ virNetMessage *msg)
{
- virNetMessagePtr tmp_msg;
+ virNetMessage *tmp_msg;
VIR_DEBUG("Incoming stream message: stream=%p message=%p", st, msg);
}
-int virNetClientStreamSendPacket(virNetClientStreamPtr st,
- virNetClientPtr client,
+int virNetClientStreamSendPacket(virNetClientStream *st,
+ virNetClient *client,
int status,
const char *data,
size_t nbytes)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
VIR_DEBUG("st=%p status=%d data=%p nbytes=%zu", st, status, data, nbytes);
if (!(msg = virNetMessageNew(false)))
static int
-virNetClientStreamSetHole(virNetClientStreamPtr st,
+virNetClientStreamSetHole(virNetClientStream *st,
long long length,
unsigned int flags)
{
* -1 otherwise.
*/
static int
-virNetClientStreamHandleHole(virNetClientPtr client,
- virNetClientStreamPtr st)
+virNetClientStreamHandleHole(virNetClient *client,
+ virNetClientStream *st)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
virNetStreamHole data;
int ret = -1;
}
-int virNetClientStreamRecvPacket(virNetClientStreamPtr st,
- virNetClientPtr client,
+int virNetClientStreamRecvPacket(virNetClientStream *st,
+ virNetClient *client,
char *data,
size_t nbytes,
bool nonblock,
goto cleanup;
if (!st->rx && !st->incomingEOF) {
- virNetMessagePtr msg;
+ virNetMessage *msg;
int ret;
if (nonblock) {
while (want &&
st->rx &&
st->rx->header.type == VIR_NET_STREAM) {
- virNetMessagePtr msg = st->rx;
+ virNetMessage *msg = st->rx;
size_t len = want;
if (len > msg->bufferLength - msg->bufferOffset)
int
-virNetClientStreamSendHole(virNetClientStreamPtr st,
- virNetClientPtr client,
+virNetClientStreamSendHole(virNetClientStream *st,
+ virNetClient *client,
long long length,
unsigned int flags)
{
- virNetMessagePtr msg = NULL;
+ virNetMessage *msg = NULL;
virNetStreamHole data;
int ret = -1;
int
-virNetClientStreamRecvHole(virNetClientPtr client G_GNUC_UNUSED,
- virNetClientStreamPtr st,
+virNetClientStreamRecvHole(virNetClient *client G_GNUC_UNUSED,
+ virNetClientStream *st,
long long *length)
{
if (!st->allowSkip) {
}
-int virNetClientStreamEventAddCallback(virNetClientStreamPtr st,
+int virNetClientStreamEventAddCallback(virNetClientStream *st,
int events,
virNetClientStreamEventCallback cb,
void *opaque,
return ret;
}
-int virNetClientStreamEventUpdateCallback(virNetClientStreamPtr st,
+int virNetClientStreamEventUpdateCallback(virNetClientStream *st,
int events)
{
int ret = -1;
return ret;
}
-int virNetClientStreamEventRemoveCallback(virNetClientStreamPtr st)
+int virNetClientStreamEventRemoveCallback(virNetClientStream *st)
{
int ret = -1;
return ret;
}
-bool virNetClientStreamEOF(virNetClientStreamPtr st)
+bool virNetClientStreamEOF(virNetClientStream *st)
{
return st->incomingEOF;
}
#include "virobject.h"
typedef struct _virNetClientStream virNetClientStream;
-typedef virNetClientStream *virNetClientStreamPtr;
typedef enum {
VIR_NET_CLIENT_STREAM_CLOSED_NOT = 0,
VIR_NET_CLIENT_STREAM_CLOSED_ABORTED,
} virNetClientStreamClosed;
-typedef void (*virNetClientStreamEventCallback)(virNetClientStreamPtr stream,
+typedef void (*virNetClientStreamEventCallback)(virNetClientStream *stream,
int events, void *opaque);
-virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,
+virNetClientStream *virNetClientStreamNew(virNetClientProgram *prog,
int proc,
unsigned serial,
bool allowSkip);
-int virNetClientStreamCheckState(virNetClientStreamPtr st);
+int virNetClientStreamCheckState(virNetClientStream *st);
-int virNetClientStreamCheckSendStatus(virNetClientStreamPtr st,
- virNetMessagePtr msg);
+int virNetClientStreamCheckSendStatus(virNetClientStream *st,
+ virNetMessage *msg);
-int virNetClientStreamSetError(virNetClientStreamPtr st,
- virNetMessagePtr msg);
+int virNetClientStreamSetError(virNetClientStream *st,
+ virNetMessage *msg);
-void virNetClientStreamSetClosed(virNetClientStreamPtr st,
+void virNetClientStreamSetClosed(virNetClientStream *st,
virNetClientStreamClosed closed);
-bool virNetClientStreamMatches(virNetClientStreamPtr st,
- virNetMessagePtr msg);
+bool virNetClientStreamMatches(virNetClientStream *st,
+ virNetMessage *msg);
-int virNetClientStreamQueuePacket(virNetClientStreamPtr st,
- virNetMessagePtr msg);
+int virNetClientStreamQueuePacket(virNetClientStream *st,
+ virNetMessage *msg);
-int virNetClientStreamSendPacket(virNetClientStreamPtr st,
- virNetClientPtr client,
+int virNetClientStreamSendPacket(virNetClientStream *st,
+ virNetClient *client,
int status,
const char *data,
size_t nbytes);
-int virNetClientStreamRecvPacket(virNetClientStreamPtr st,
- virNetClientPtr client,
+int virNetClientStreamRecvPacket(virNetClientStream *st,
+ virNetClient *client,
char *data,
size_t nbytes,
bool nonblock,
unsigned int flags);
-int virNetClientStreamSendHole(virNetClientStreamPtr st,
- virNetClientPtr client,
+int virNetClientStreamSendHole(virNetClientStream *st,
+ virNetClient *client,
long long length,
unsigned int flags);
-int virNetClientStreamRecvHole(virNetClientPtr client,
- virNetClientStreamPtr st,
+int virNetClientStreamRecvHole(virNetClient *client,
+ virNetClientStream *st,
long long *length);
-int virNetClientStreamEventAddCallback(virNetClientStreamPtr st,
+int virNetClientStreamEventAddCallback(virNetClientStream *st,
int events,
virNetClientStreamEventCallback cb,
void *opaque,
virFreeCallback ff);
-int virNetClientStreamEventUpdateCallback(virNetClientStreamPtr st,
+int virNetClientStreamEventUpdateCallback(virNetClientStream *st,
int events);
-int virNetClientStreamEventRemoveCallback(virNetClientStreamPtr st);
+int virNetClientStreamEventRemoveCallback(virNetClientStream *st);
-bool virNetClientStreamEOF(virNetClientStreamPtr st)
+bool virNetClientStreamEOF(virNetClientStream *st)
ATTRIBUTE_NONNULL(1);
#ifndef WIN32
typedef struct _virNetDaemonSignal virNetDaemonSignal;
-typedef virNetDaemonSignal *virNetDaemonSignalPtr;
-
struct _virNetDaemonSignal {
struct sigaction oldaction;
int signum;
#ifndef WIN32
size_t nsignals;
- virNetDaemonSignalPtr *signals;
+ virNetDaemonSignal **signals;
int sigread;
int sigwrite;
int sigwatch;
#endif /* !WIN32 */
GHashTable *servers;
- virJSONValuePtr srvObject;
+ virJSONValue *srvObject;
virNetDaemonShutdownCallback shutdownPrepareCb;
virNetDaemonShutdownCallback shutdownWaitCb;
- virThreadPtr stateStopThread;
+ virThread *stateStopThread;
int finishTimer;
bool quit;
bool finished;
};
-static virClassPtr virNetDaemonClass;
+static virClass *virNetDaemonClass;
static int
daemonServerClose(void *payload,
static void
virNetDaemonDispose(void *obj)
{
- virNetDaemonPtr dmn = obj;
+ virNetDaemon *dmn = obj;
#ifndef WIN32
size_t i;
VIR_ONCE_GLOBAL_INIT(virNetDaemon);
-virNetDaemonPtr
+virNetDaemon *
virNetDaemonNew(void)
{
- virNetDaemonPtr dmn;
+ virNetDaemon *dmn;
#ifndef WIN32
struct sigaction sig_action;
#endif /* !WIN32 */
int
-virNetDaemonAddServer(virNetDaemonPtr dmn,
- virNetServerPtr srv)
+virNetDaemonAddServer(virNetDaemon *dmn,
+ virNetServer *srv)
{
int ret = -1;
const char *serverName = virNetServerGetName(srv);
}
-virNetServerPtr
-virNetDaemonGetServer(virNetDaemonPtr dmn,
+virNetServer *
+virNetDaemonGetServer(virNetDaemon *dmn,
const char *serverName)
{
- virNetServerPtr srv = NULL;
+ virNetServer *srv = NULL;
virObjectLock(dmn);
srv = virObjectRef(virHashLookup(dmn->servers, serverName));
}
bool
-virNetDaemonHasServer(virNetDaemonPtr dmn,
+virNetDaemonHasServer(virNetDaemon *dmn,
const char *serverName)
{
void *ent;
struct collectData {
- virNetServerPtr **servers;
+ virNetServer ***servers;
size_t nservers;
};
const char *name G_GNUC_UNUSED,
void *opaque)
{
- virNetServerPtr srv = virObjectRef(payload);
+ virNetServer *srv = virObjectRef(payload);
struct collectData *data = opaque;
if (!srv)
* but not the items in it (similarly to virHashGetItems).
*/
ssize_t
-virNetDaemonGetServers(virNetDaemonPtr dmn,
- virNetServerPtr **servers)
+virNetDaemonGetServers(virNetDaemon *dmn,
+ virNetServer ***servers)
{
struct collectData data = { servers, 0 };
ssize_t ret = -1;
struct virNetDaemonServerData {
- virNetDaemonPtr dmn;
+ virNetDaemon *dmn;
virNetDaemonNewServerPostExecRestart cb;
void *opaque;
};
static int
virNetDaemonServerIterator(const char *key,
- virJSONValuePtr value,
+ virJSONValue *value,
void *opaque)
{
struct virNetDaemonServerData *data = opaque;
- virNetServerPtr srv;
+ virNetServer *srv;
VIR_DEBUG("Creating server '%s'", key);
srv = data->cb(data->dmn, key, value, data->opaque);
}
-virNetDaemonPtr
-virNetDaemonNewPostExecRestart(virJSONValuePtr object,
+virNetDaemon *
+virNetDaemonNewPostExecRestart(virJSONValue *object,
size_t nDefServerNames,
const char **defServerNames,
virNetDaemonNewServerPostExecRestart cb,
void *opaque)
{
- virNetDaemonPtr dmn = NULL;
- virJSONValuePtr servers = virJSONValueObjectGet(object, "servers");
+ virNetDaemon *dmn = NULL;
+ virJSONValue *servers = virJSONValueObjectGet(object, "servers");
bool new_version = virJSONValueObjectHasKey(object, "servers");
if (!(dmn = virNetDaemonNew()))
}
if (!new_version) {
- virNetServerPtr srv;
+ virNetServer *srv;
if (nDefServerNames < 1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
for (i = 0; i < n; i++) {
- virNetServerPtr srv;
- virJSONValuePtr value = virJSONValueArrayGet(servers, i);
+ virNetServer *srv;
+ virJSONValue *value = virJSONValueArrayGet(servers, i);
VIR_DEBUG("Creating server '%s'", defServerNames[i]);
srv = cb(dmn, defServerNames[i], value, opaque);
}
-virJSONValuePtr
-virNetDaemonPreExecRestart(virNetDaemonPtr dmn)
+virJSONValue *
+virNetDaemonPreExecRestart(virNetDaemon *dmn)
{
size_t i = 0;
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) srvObj = virJSONValueNewObject();
- g_autofree virHashKeyValuePairPtr srvArray = NULL;
+ g_autofree virHashKeyValuePair *srvArray = NULL;
virObjectLock(dmn);
goto error;
for (i = 0; srvArray[i].key; i++) {
- virNetServerPtr server = virHashLookup(dmn->servers, srvArray[i].key);
+ virNetServer *server = virHashLookup(dmn->servers, srvArray[i].key);
g_autoptr(virJSONValue) srvJSON = NULL;
if (!server)
bool
-virNetDaemonIsPrivileged(virNetDaemonPtr dmn)
+virNetDaemonIsPrivileged(virNetDaemon *dmn)
{
bool priv;
virObjectLock(dmn);
void
-virNetDaemonAutoShutdown(virNetDaemonPtr dmn,
+virNetDaemonAutoShutdown(virNetDaemon *dmn,
unsigned int timeout)
{
virObjectLock(dmn);
#ifdef G_OS_UNIX
/* As per: https://www.freedesktop.org/wiki/Software/systemd/inhibit */
static void
-virNetDaemonCallInhibit(virNetDaemonPtr dmn,
+virNetDaemonCallInhibit(virNetDaemon *dmn,
const char *what,
const char *who,
const char *why,
#endif
void
-virNetDaemonAddShutdownInhibition(virNetDaemonPtr dmn)
+virNetDaemonAddShutdownInhibition(virNetDaemon *dmn)
{
virObjectLock(dmn);
dmn->autoShutdownInhibitions++;
void
-virNetDaemonRemoveShutdownInhibition(virNetDaemonPtr dmn)
+virNetDaemonRemoveShutdownInhibition(virNetDaemon *dmn)
{
virObjectLock(dmn);
dmn->autoShutdownInhibitions--;
int events G_GNUC_UNUSED,
void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
siginfo_t siginfo;
size_t i;
}
static int
-virNetDaemonSignalSetup(virNetDaemonPtr dmn)
+virNetDaemonSignalSetup(virNetDaemon *dmn)
{
int fds[2] = { -1, -1 };
int
-virNetDaemonAddSignalHandler(virNetDaemonPtr dmn,
+virNetDaemonAddSignalHandler(virNetDaemon *dmn,
int signum,
virNetDaemonSignalFunc func,
void *opaque)
{
- virNetDaemonSignalPtr sigdata = NULL;
+ virNetDaemonSignal *sigdata = NULL;
struct sigaction sig_action;
virObjectLock(dmn);
#else /* WIN32 */
int
-virNetDaemonAddSignalHandler(virNetDaemonPtr dmn G_GNUC_UNUSED,
+virNetDaemonAddSignalHandler(virNetDaemon *dmn G_GNUC_UNUSED,
int signum G_GNUC_UNUSED,
virNetDaemonSignalFunc func G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
virNetDaemonAutoShutdownTimer(int timerid G_GNUC_UNUSED,
void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
virObjectLock(dmn);
void *opaque)
{
bool *enable = opaque;
- virNetServerPtr srv = payload;
+ virNetServer *srv = payload;
virNetServerUpdateServices(srv, *enable);
return 0;
}
void
-virNetDaemonUpdateServices(virNetDaemonPtr dmn,
+virNetDaemonUpdateServices(virNetDaemon *dmn,
bool enabled)
{
virObjectLock(dmn);
const char *key G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virNetServerPtr srv = payload;
+ virNetServer *srv = payload;
virNetServerProcessClients(srv);
return 0;
const char *key G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virNetServerPtr srv = payload;
+ virNetServer *srv = payload;
virNetServerShutdownWait(srv);
return 0;
static void
daemonShutdownWait(void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
bool graceful = false;
virHashForEach(dmn->servers, daemonServerShutdownWait, NULL);
virNetDaemonFinishTimer(int timerid G_GNUC_UNUSED,
void *opaque)
{
- virNetDaemonPtr dmn = opaque;
+ virNetDaemon *dmn = opaque;
virObjectLock(dmn);
dmn->finished = true;
}
void
-virNetDaemonRun(virNetDaemonPtr dmn)
+virNetDaemonRun(virNetDaemon *dmn)
{
int timerid = -1;
bool timerActive = false;
void
-virNetDaemonSetStateStopWorkerThread(virNetDaemonPtr dmn,
- virThreadPtr *thr)
+virNetDaemonSetStateStopWorkerThread(virNetDaemon *dmn,
+ virThread **thr)
{
virObjectLock(dmn);
void
-virNetDaemonQuit(virNetDaemonPtr dmn)
+virNetDaemonQuit(virNetDaemon *dmn)
{
virObjectLock(dmn);
const char *key G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
- virNetServerPtr srv = payload;
+ virNetServer *srv = payload;
virNetServerClose(srv);
return 0;
void *opaque)
{
bool *clients = opaque;
- virNetServerPtr srv = payload;
+ virNetServer *srv = payload;
if (virNetServerHasClients(srv))
*clients = true;
}
bool
-virNetDaemonHasClients(virNetDaemonPtr dmn)
+virNetDaemonHasClients(virNetDaemon *dmn)
{
bool ret = false;
}
void
-virNetDaemonSetShutdownCallbacks(virNetDaemonPtr dmn,
+virNetDaemonSetShutdownCallbacks(virNetDaemon *dmn,
virNetDaemonShutdownCallback prepareCb,
virNetDaemonShutdownCallback waitCb)
{
#include "virnetserverservice.h"
#include "virnetserver.h"
-virNetDaemonPtr virNetDaemonNew(void);
+virNetDaemon *virNetDaemonNew(void);
-int virNetDaemonAddServer(virNetDaemonPtr dmn,
- virNetServerPtr srv);
+int virNetDaemonAddServer(virNetDaemon *dmn,
+ virNetServer *srv);
-typedef virNetServerPtr (*virNetDaemonNewServerPostExecRestart)(virNetDaemonPtr dmn,
+typedef virNetServer *(*virNetDaemonNewServerPostExecRestart)(virNetDaemon *dmn,
const char *name,
- virJSONValuePtr object,
+ virJSONValue *object,
void *opaque);
-virNetDaemonPtr virNetDaemonNewPostExecRestart(virJSONValuePtr object,
+virNetDaemon *virNetDaemonNewPostExecRestart(virJSONValue *object,
size_t nDefServerNames,
const char **defServerNames,
virNetDaemonNewServerPostExecRestart cb,
void *opaque);
-virJSONValuePtr virNetDaemonPreExecRestart(virNetDaemonPtr dmn);
+virJSONValue *virNetDaemonPreExecRestart(virNetDaemon *dmn);
-bool virNetDaemonIsPrivileged(virNetDaemonPtr dmn);
+bool virNetDaemonIsPrivileged(virNetDaemon *dmn);
-void virNetDaemonAutoShutdown(virNetDaemonPtr dmn,
+void virNetDaemonAutoShutdown(virNetDaemon *dmn,
unsigned int timeout);
-void virNetDaemonAddShutdownInhibition(virNetDaemonPtr dmn);
-void virNetDaemonRemoveShutdownInhibition(virNetDaemonPtr dmn);
+void virNetDaemonAddShutdownInhibition(virNetDaemon *dmn);
+void virNetDaemonRemoveShutdownInhibition(virNetDaemon *dmn);
#ifdef WIN32
# define siginfo_t void
#endif
-typedef void (*virNetDaemonSignalFunc)(virNetDaemonPtr dmn, siginfo_t *info, void *opaque);
+typedef void (*virNetDaemonSignalFunc)(virNetDaemon *dmn, siginfo_t *info, void *opaque);
-int virNetDaemonAddSignalHandler(virNetDaemonPtr dmn,
+int virNetDaemonAddSignalHandler(virNetDaemon *dmn,
int signum,
virNetDaemonSignalFunc func,
void *opaque);
-void virNetDaemonUpdateServices(virNetDaemonPtr dmn,
+void virNetDaemonUpdateServices(virNetDaemon *dmn,
bool enabled);
-void virNetDaemonSetStateStopWorkerThread(virNetDaemonPtr dmn,
- virThreadPtr *thr);
+void virNetDaemonSetStateStopWorkerThread(virNetDaemon *dmn,
+ virThread **thr);
-void virNetDaemonRun(virNetDaemonPtr dmn);
+void virNetDaemonRun(virNetDaemon *dmn);
-void virNetDaemonQuit(virNetDaemonPtr dmn);
+void virNetDaemonQuit(virNetDaemon *dmn);
void virNetDaemonQuitExecRestart(virNetDaemon *dmn);
-bool virNetDaemonHasClients(virNetDaemonPtr dmn);
+bool virNetDaemonHasClients(virNetDaemon *dmn);
-virNetServerPtr virNetDaemonGetServer(virNetDaemonPtr dmn,
+virNetServer *virNetDaemonGetServer(virNetDaemon *dmn,
const char *serverName);
-ssize_t virNetDaemonGetServers(virNetDaemonPtr dmn, virNetServerPtr **servers);
-bool virNetDaemonHasServer(virNetDaemonPtr dmn,
+ssize_t virNetDaemonGetServers(virNetDaemon *dmn, virNetServer ***servers);
+bool virNetDaemonHasServer(virNetDaemon *dmn,
const char *serverName);
typedef int (*virNetDaemonShutdownCallback)(void);
-void virNetDaemonSetShutdownCallbacks(virNetDaemonPtr dmn,
+void virNetDaemonSetShutdownCallbacks(virNetDaemon *dmn,
virNetDaemonShutdownCallback prepareCb,
virNetDaemonShutdownCallback waitCb);
typedef struct _virNetLibsshAuthMethod virNetLibsshAuthMethod;
-typedef virNetLibsshAuthMethod *virNetLibsshAuthMethodPtr;
-
struct _virNetLibsshAuthMethod {
virNetLibsshAuthMethods method;
int ssh_flags; /* SSH_AUTH_METHOD_* for this auth method */
virConnectAuthPtr cred;
char *authPath;
size_t nauths;
- virNetLibsshAuthMethodPtr *auths;
+ virNetLibsshAuthMethod **auths;
/* channel stuff */
char *channelCommand;
static void
virNetLibsshSessionDispose(void *obj)
{
- virNetLibsshSessionPtr sess = obj;
+ virNetLibsshSession *sess = obj;
size_t i;
VIR_DEBUG("sess=0x%p", sess);
g_free(sess->username);
}
-static virClassPtr virNetLibsshSessionClass;
+static virClass *virNetLibsshSessionClass;
static int
virNetLibsshSessionOnceInit(void)
{
}
VIR_ONCE_GLOBAL_INIT(virNetLibsshSession);
-static virNetLibsshAuthMethodPtr
-virNetLibsshSessionAuthMethodNew(virNetLibsshSessionPtr sess)
+static virNetLibsshAuthMethod *
+virNetLibsshSessionAuthMethodNew(virNetLibsshSession *sess)
{
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
auth = g_new0(virNetLibsshAuthMethod, 1);
/* string representation of public key of remote server */
static char *
-virLibsshServerKeyAsString(virNetLibsshSessionPtr sess)
+virLibsshServerKeyAsString(virNetLibsshSession *sess)
{
int ret;
ssh_key key;
* return value: 0 on success, -1 on error
*/
static int
-virNetLibsshCheckHostKey(virNetLibsshSessionPtr sess)
+virNetLibsshCheckHostKey(virNetLibsshSession *sess)
{
int state;
char *keyhashstr;
int verify G_GNUC_UNUSED,
void *userdata)
{
- virNetLibsshSessionPtr sess = userdata;
+ virNetLibsshSession *sess = userdata;
virConnectCredential retr_passphrase;
int cred_type;
g_autofree char *actual_prompt = NULL;
}
static int
-virNetLibsshImportPrivkey(virNetLibsshSessionPtr sess,
- virNetLibsshAuthMethodPtr priv,
+virNetLibsshImportPrivkey(virNetLibsshSession *sess,
+ virNetLibsshAuthMethod *priv,
ssh_key *ret_key)
{
int err;
* returns SSH_AUTH_* values
*/
static int
-virNetLibsshAuthenticatePrivkey(virNetLibsshSessionPtr sess,
- virNetLibsshAuthMethodPtr priv)
+virNetLibsshAuthenticatePrivkey(virNetLibsshSession *sess,
+ virNetLibsshAuthMethod *priv)
{
int err;
int ret;
* returns SSH_AUTH_* values
*/
static int
-virNetLibsshAuthenticatePassword(virNetLibsshSessionPtr sess,
- virNetLibsshAuthMethodPtr priv)
+virNetLibsshAuthenticatePassword(virNetLibsshSession *sess,
+ virNetLibsshAuthMethod *priv)
{
const char *errmsg;
int rc = SSH_AUTH_ERROR;
* returns SSH_AUTH_* values
*/
static int
-virNetLibsshAuthenticateKeyboardInteractive(virNetLibsshSessionPtr sess,
- virNetLibsshAuthMethodPtr priv)
+virNetLibsshAuthenticateKeyboardInteractive(virNetLibsshSession *sess,
+ virNetLibsshAuthMethod *priv)
{
int ret;
const char *errmsg;
/* select auth method and authenticate */
static int
-virNetLibsshAuthenticate(virNetLibsshSessionPtr sess)
+virNetLibsshAuthenticate(virNetLibsshSession *sess)
{
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
bool no_method = false;
bool auth_failed = false;
const char *errmsg;
/* open channel */
static int
-virNetLibsshOpenChannel(virNetLibsshSessionPtr sess)
+virNetLibsshOpenChannel(virNetLibsshSession *sess)
{
const char *errmsg;
/* validate if all required parameters are configured */
static int
-virNetLibsshValidateConfig(virNetLibsshSessionPtr sess)
+virNetLibsshValidateConfig(virNetLibsshSession *sess)
{
size_t i;
bool has_auths = false;
/* ### PUBLIC API ### */
int
-virNetLibsshSessionAuthSetCallback(virNetLibsshSessionPtr sess,
+virNetLibsshSessionAuthSetCallback(virNetLibsshSession *sess,
virConnectAuthPtr auth)
{
virObjectLock(sess);
}
int
-virNetLibsshSessionAuthAddPasswordAuth(virNetLibsshSessionPtr sess,
- virURIPtr uri)
+virNetLibsshSessionAuthAddPasswordAuth(virNetLibsshSession *sess,
+ virURI *uri)
{
int ret;
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
if (uri) {
VIR_FREE(sess->authPath);
}
int
-virNetLibsshSessionAuthAddAgentAuth(virNetLibsshSessionPtr sess)
+virNetLibsshSessionAuthAddAgentAuth(virNetLibsshSession *sess)
{
int ret;
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
virObjectLock(sess);
}
int
-virNetLibsshSessionAuthAddPrivKeyAuth(virNetLibsshSessionPtr sess,
+virNetLibsshSessionAuthAddPrivKeyAuth(virNetLibsshSession *sess,
const char *keyfile,
const char *password)
{
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
if (!keyfile) {
virReportError(VIR_ERR_LIBSSH, "%s",
}
int
-virNetLibsshSessionAuthAddKeyboardAuth(virNetLibsshSessionPtr sess,
+virNetLibsshSessionAuthAddKeyboardAuth(virNetLibsshSession *sess,
int tries)
{
int ret;
- virNetLibsshAuthMethodPtr auth;
+ virNetLibsshAuthMethod *auth;
virObjectLock(sess);
}
void
-virNetLibsshSessionSetChannelCommand(virNetLibsshSessionPtr sess,
+virNetLibsshSessionSetChannelCommand(virNetLibsshSession *sess,
const char *command)
{
virObjectLock(sess);
}
int
-virNetLibsshSessionSetHostKeyVerification(virNetLibsshSessionPtr sess,
+virNetLibsshSessionSetHostKeyVerification(virNetLibsshSession *sess,
const char *hostname,
int port,
const char *hostsfile,
}
/* allocate and initialize a libssh session object */
-virNetLibsshSessionPtr virNetLibsshSessionNew(const char *username)
+virNetLibsshSession *virNetLibsshSessionNew(const char *username)
{
- virNetLibsshSessionPtr sess = NULL;
+ virNetLibsshSession *sess = NULL;
if (virNetLibsshSessionInitialize() < 0)
goto error;
sess->username = g_strdup(username);
- VIR_DEBUG("virNetLibsshSessionPtr: %p, ssh_session: %p",
+ VIR_DEBUG("virNetLibsshSession *: %p, ssh_session: %p",
sess, sess->session);
/* set blocking mode for libssh until handshake is complete */
}
int
-virNetLibsshSessionConnect(virNetLibsshSessionPtr sess,
+virNetLibsshSessionConnect(virNetLibsshSession *sess,
int sock)
{
int ret;
if (!sess || sess->state != VIR_NET_LIBSSH_STATE_NEW) {
virReportError(VIR_ERR_LIBSSH, "%s",
- _("Invalid virNetLibsshSessionPtr"));
+ _("Invalid virNetLibsshSession *"));
return -1;
}
/* do a read from a ssh channel, used instead of normal read on socket */
ssize_t
-virNetLibsshChannelRead(virNetLibsshSessionPtr sess,
+virNetLibsshChannelRead(virNetLibsshSession *sess,
char *buf,
size_t len)
{
}
ssize_t
-virNetLibsshChannelWrite(virNetLibsshSessionPtr sess,
+virNetLibsshChannelWrite(virNetLibsshSession *sess,
const char *buf,
size_t len)
{
}
bool
-virNetLibsshSessionHasCachedData(virNetLibsshSessionPtr sess)
+virNetLibsshSessionHasCachedData(virNetLibsshSession *sess)
{
bool ret;
#include "viruri.h"
typedef struct _virNetLibsshSession virNetLibsshSession;
-typedef virNetLibsshSession *virNetLibsshSessionPtr;
-virNetLibsshSessionPtr virNetLibsshSessionNew(const char *username);
-void virNetLibsshSessionFree(virNetLibsshSessionPtr sess);
+virNetLibsshSession *virNetLibsshSessionNew(const char *username);
+void virNetLibsshSessionFree(virNetLibsshSession *sess);
typedef enum {
VIR_NET_LIBSSH_HOSTKEY_VERIFY_NORMAL,
VIR_NET_LIBSSH_HOSTKEY_VERIFY_IGNORE
} virNetLibsshHostkeyVerify;
-void virNetLibsshSessionSetChannelCommand(virNetLibsshSessionPtr sess,
+void virNetLibsshSessionSetChannelCommand(virNetLibsshSession *sess,
const char *command);
-int virNetLibsshSessionAuthSetCallback(virNetLibsshSessionPtr sess,
+int virNetLibsshSessionAuthSetCallback(virNetLibsshSession *sess,
virConnectAuthPtr auth);
-int virNetLibsshSessionAuthAddPasswordAuth(virNetLibsshSessionPtr sess,
- virURIPtr uri);
+int virNetLibsshSessionAuthAddPasswordAuth(virNetLibsshSession *sess,
+ virURI *uri);
-int virNetLibsshSessionAuthAddAgentAuth(virNetLibsshSessionPtr sess);
+int virNetLibsshSessionAuthAddAgentAuth(virNetLibsshSession *sess);
-int virNetLibsshSessionAuthAddPrivKeyAuth(virNetLibsshSessionPtr sess,
+int virNetLibsshSessionAuthAddPrivKeyAuth(virNetLibsshSession *sess,
const char *keyfile,
const char *password);
-int virNetLibsshSessionAuthAddKeyboardAuth(virNetLibsshSessionPtr sess,
+int virNetLibsshSessionAuthAddKeyboardAuth(virNetLibsshSession *sess,
int tries);
-int virNetLibsshSessionSetHostKeyVerification(virNetLibsshSessionPtr sess,
+int virNetLibsshSessionSetHostKeyVerification(virNetLibsshSession *sess,
const char *hostname,
int port,
const char *hostsfile,
virNetLibsshHostkeyVerify opt);
-int virNetLibsshSessionConnect(virNetLibsshSessionPtr sess,
+int virNetLibsshSessionConnect(virNetLibsshSession *sess,
int sock);
-ssize_t virNetLibsshChannelRead(virNetLibsshSessionPtr sess,
+ssize_t virNetLibsshChannelRead(virNetLibsshSession *sess,
char *buf,
size_t len);
-ssize_t virNetLibsshChannelWrite(virNetLibsshSessionPtr sess,
+ssize_t virNetLibsshChannelWrite(virNetLibsshSession *sess,
const char *buf,
size_t len);
-bool virNetLibsshSessionHasCachedData(virNetLibsshSessionPtr sess);
+bool virNetLibsshSessionHasCachedData(virNetLibsshSession *sess);
VIR_LOG_INIT("rpc.netmessage");
-virNetMessagePtr virNetMessageNew(bool tracked)
+virNetMessage *virNetMessageNew(bool tracked)
{
- virNetMessagePtr msg;
+ virNetMessage *msg;
msg = g_new0(virNetMessage, 1);
void
-virNetMessageClearPayload(virNetMessagePtr msg)
+virNetMessageClearPayload(virNetMessage *msg)
{
size_t i;
}
-void virNetMessageClear(virNetMessagePtr msg)
+void virNetMessageClear(virNetMessage *msg)
{
bool tracked = msg->tracked;
}
-void virNetMessageFree(virNetMessagePtr msg)
+void virNetMessageFree(virNetMessage *msg)
{
if (!msg)
return;
g_free(msg);
}
-void virNetMessageQueuePush(virNetMessagePtr *queue, virNetMessagePtr msg)
+void virNetMessageQueuePush(virNetMessage **queue, virNetMessage *msg)
{
- virNetMessagePtr tmp = *queue;
+ virNetMessage *tmp = *queue;
if (tmp) {
while (tmp->next)
}
-virNetMessagePtr virNetMessageQueueServe(virNetMessagePtr *queue)
+virNetMessage *virNetMessageQueueServe(virNetMessage **queue)
{
- virNetMessagePtr tmp = *queue;
+ virNetMessage *tmp = *queue;
if (tmp) {
*queue = g_steal_pointer(&tmp->next);
}
-int virNetMessageDecodeLength(virNetMessagePtr msg)
+int virNetMessageDecodeLength(virNetMessage *msg)
{
XDR xdr;
unsigned int len;
*
* returns 0 if successfully decoded, -1 upon fatal error
*/
-int virNetMessageDecodeHeader(virNetMessagePtr msg)
+int virNetMessageDecodeHeader(virNetMessage *msg)
{
XDR xdr;
int ret = -1;
*
* returns 0 if successfully encoded, -1 upon fatal error
*/
-int virNetMessageEncodeHeader(virNetMessagePtr msg)
+int virNetMessageEncodeHeader(virNetMessage *msg)
{
XDR xdr;
int ret = -1;
}
-int virNetMessageEncodeNumFDs(virNetMessagePtr msg)
+int virNetMessageEncodeNumFDs(virNetMessage *msg)
{
XDR xdr;
unsigned int numFDs = msg->nfds;
}
-int virNetMessageDecodeNumFDs(virNetMessagePtr msg)
+int virNetMessageDecodeNumFDs(virNetMessage *msg)
{
XDR xdr;
unsigned int numFDs;
}
-int virNetMessageEncodePayload(virNetMessagePtr msg,
+int virNetMessageEncodePayload(virNetMessage *msg,
xdrproc_t filter,
void *data)
{
}
-int virNetMessageDecodePayload(virNetMessagePtr msg,
+int virNetMessageDecodePayload(virNetMessage *msg,
xdrproc_t filter,
void *data)
{
}
-int virNetMessageEncodePayloadRaw(virNetMessagePtr msg,
+int virNetMessageEncodePayloadRaw(virNetMessage *msg,
const char *data,
size_t len)
{
}
-int virNetMessageEncodePayloadEmpty(virNetMessagePtr msg)
+int virNetMessageEncodePayloadEmpty(virNetMessage *msg)
{
XDR xdr;
unsigned int msglen;
}
-void virNetMessageSaveError(virNetMessageErrorPtr rerr)
+void virNetMessageSaveError(struct virNetMessageError *rerr)
{
virErrorPtr verr;
}
-int virNetMessageDupFD(virNetMessagePtr msg,
+int virNetMessageDupFD(virNetMessage *msg,
size_t slot)
{
int fd;
return fd;
}
-int virNetMessageAddFD(virNetMessagePtr msg,
+int virNetMessageAddFD(virNetMessage *msg,
int fd)
{
int newfd = -1;
#include "virnetprotocol.h"
-typedef struct virNetMessageHeader *virNetMessageHeaderPtr;
-typedef struct virNetMessageError *virNetMessageErrorPtr;
-
typedef struct _virNetMessage virNetMessage;
-typedef virNetMessage *virNetMessagePtr;
-typedef void (*virNetMessageFreeCallback)(virNetMessagePtr msg, void *opaque);
+typedef void (*virNetMessageFreeCallback)(virNetMessage *msg, void *opaque);
struct _virNetMessage {
bool tracked;
int *fds;
size_t donefds;
- virNetMessagePtr next;
+ virNetMessage *next;
};
-virNetMessagePtr virNetMessageNew(bool tracked);
+virNetMessage *virNetMessageNew(bool tracked);
-void virNetMessageClearPayload(virNetMessagePtr msg);
+void virNetMessageClearPayload(virNetMessage *msg);
-void virNetMessageClear(virNetMessagePtr);
+void virNetMessageClear(virNetMessage *);
-void virNetMessageFree(virNetMessagePtr msg);
+void virNetMessageFree(virNetMessage *msg);
-virNetMessagePtr virNetMessageQueueServe(virNetMessagePtr *queue)
+virNetMessage *virNetMessageQueueServe(virNetMessage **queue)
ATTRIBUTE_NONNULL(1);
-void virNetMessageQueuePush(virNetMessagePtr *queue,
- virNetMessagePtr msg)
+void virNetMessageQueuePush(virNetMessage **queue,
+ virNetMessage *msg)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virNetMessageEncodeHeader(virNetMessagePtr msg)
+int virNetMessageEncodeHeader(virNetMessage *msg)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageDecodeLength(virNetMessagePtr msg)
+int virNetMessageDecodeLength(virNetMessage *msg)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageDecodeHeader(virNetMessagePtr msg)
+int virNetMessageDecodeHeader(virNetMessage *msg)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageEncodePayload(virNetMessagePtr msg,
+int virNetMessageEncodePayload(virNetMessage *msg,
xdrproc_t filter,
void *data)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageDecodePayload(virNetMessagePtr msg,
+int virNetMessageDecodePayload(virNetMessage *msg,
xdrproc_t filter,
void *data)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageEncodeNumFDs(virNetMessagePtr msg);
-int virNetMessageDecodeNumFDs(virNetMessagePtr msg);
+int virNetMessageEncodeNumFDs(virNetMessage *msg);
+int virNetMessageDecodeNumFDs(virNetMessage *msg);
-int virNetMessageEncodePayloadRaw(virNetMessagePtr msg,
+int virNetMessageEncodePayloadRaw(virNetMessage *msg,
const char *buf,
size_t len)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virNetMessageEncodePayloadEmpty(virNetMessagePtr msg)
+int virNetMessageEncodePayloadEmpty(virNetMessage *msg)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-void virNetMessageSaveError(virNetMessageErrorPtr rerr)
+void virNetMessageSaveError(struct virNetMessageError *rerr)
ATTRIBUTE_NONNULL(1);
-int virNetMessageDupFD(virNetMessagePtr msg,
+int virNetMessageDupFD(virNetMessage *msg,
size_t slot);
-int virNetMessageAddFD(virNetMessagePtr msg,
+int virNetMessageAddFD(virNetMessage *msg,
int fd);
};
-static virClassPtr virNetSASLContextClass;
-static virClassPtr virNetSASLSessionClass;
+static virClass *virNetSASLContextClass;
+static virClass *virNetSASLSessionClass;
static void virNetSASLContextDispose(void *obj);
static void virNetSASLSessionDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virNetSASLContextServer);
-virNetSASLContextPtr virNetSASLContextNewClient(void)
+virNetSASLContext *virNetSASLContextNewClient(void)
{
- virNetSASLContextPtr ctxt;
+ virNetSASLContext *ctxt;
if (virNetSASLContextInitialize() < 0 ||
virNetSASLContextClientInitialize() < 0)
return ctxt;
}
-virNetSASLContextPtr virNetSASLContextNewServer(const char *const *usernameACL)
+virNetSASLContext *virNetSASLContextNewServer(const char *const *usernameACL)
{
- virNetSASLContextPtr ctxt;
+ virNetSASLContext *ctxt;
if (virNetSASLContextInitialize() < 0 ||
virNetSASLContextServerInitialize() < 0)
return ctxt;
}
-int virNetSASLContextCheckIdentity(virNetSASLContextPtr ctxt,
+int virNetSASLContextCheckIdentity(virNetSASLContext *ctxt,
const char *identity)
{
const char *const*wildcards;
}
-virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt G_GNUC_UNUSED,
+virNetSASLSession *virNetSASLSessionNewClient(virNetSASLContext *ctxt G_GNUC_UNUSED,
const char *service,
const char *hostname,
const char *localAddr,
const char *remoteAddr,
sasl_callback_t *cbs)
{
- virNetSASLSessionPtr sasl = NULL;
+ virNetSASLSession *sasl = NULL;
int err;
if (!(sasl = virObjectLockableNew(virNetSASLSessionClass)))
return NULL;
}
-virNetSASLSessionPtr virNetSASLSessionNewServer(virNetSASLContextPtr ctxt G_GNUC_UNUSED,
+virNetSASLSession *virNetSASLSessionNewServer(virNetSASLContext *ctxt G_GNUC_UNUSED,
const char *service,
const char *localAddr,
const char *remoteAddr)
{
- virNetSASLSessionPtr sasl = NULL;
+ virNetSASLSession *sasl = NULL;
int err;
if (!(sasl = virObjectLockableNew(virNetSASLSessionClass)))
return NULL;
}
-int virNetSASLSessionExtKeySize(virNetSASLSessionPtr sasl,
+int virNetSASLSessionExtKeySize(virNetSASLSession *sasl,
int ssf)
{
int err;
return ret;
}
-const char *virNetSASLSessionGetIdentity(virNetSASLSessionPtr sasl)
+const char *virNetSASLSessionGetIdentity(virNetSASLSession *sasl)
{
const void *val = NULL;
int err;
}
-int virNetSASLSessionGetKeySize(virNetSASLSessionPtr sasl)
+int virNetSASLSessionGetKeySize(virNetSASLSession *sasl)
{
int err;
int ssf;
return ssf;
}
-int virNetSASLSessionSecProps(virNetSASLSessionPtr sasl,
+int virNetSASLSessionSecProps(virNetSASLSession *sasl,
int minSSF,
int maxSSF,
bool allowAnonymous)
}
-static int virNetSASLSessionUpdateBufSize(virNetSASLSessionPtr sasl)
+static int virNetSASLSessionUpdateBufSize(virNetSASLSession *sasl)
{
union {
unsigned *maxbufsize;
return 0;
}
-char *virNetSASLSessionListMechanisms(virNetSASLSessionPtr sasl)
+char *virNetSASLSessionListMechanisms(virNetSASLSession *sasl)
{
const char *mechlist;
char *ret = NULL;
}
-int virNetSASLSessionClientStart(virNetSASLSessionPtr sasl,
+int virNetSASLSessionClientStart(virNetSASLSession *sasl,
const char *mechlist,
sasl_interact_t **prompt_need,
const char **clientout,
}
-int virNetSASLSessionClientStep(virNetSASLSessionPtr sasl,
+int virNetSASLSessionClientStep(virNetSASLSession *sasl,
const char *serverin,
size_t serverinlen,
sasl_interact_t **prompt_need,
return ret;
}
-int virNetSASLSessionServerStart(virNetSASLSessionPtr sasl,
+int virNetSASLSessionServerStart(virNetSASLSession *sasl,
const char *mechname,
const char *clientin,
size_t clientinlen,
}
-int virNetSASLSessionServerStep(virNetSASLSessionPtr sasl,
+int virNetSASLSessionServerStep(virNetSASLSession *sasl,
const char *clientin,
size_t clientinlen,
const char **serverout,
return ret;
}
-size_t virNetSASLSessionGetMaxBufSize(virNetSASLSessionPtr sasl)
+size_t virNetSASLSessionGetMaxBufSize(virNetSASLSession *sasl)
{
size_t ret;
virObjectLock(sasl);
return ret;
}
-ssize_t virNetSASLSessionEncode(virNetSASLSessionPtr sasl,
+ssize_t virNetSASLSessionEncode(virNetSASLSession *sasl,
const char *input,
size_t inputLen,
const char **output,
return ret;
}
-ssize_t virNetSASLSessionDecode(virNetSASLSessionPtr sasl,
+ssize_t virNetSASLSessionDecode(virNetSASLSession *sasl,
const char *input,
size_t inputLen,
const char **output,
void virNetSASLSessionDispose(void *obj)
{
- virNetSASLSessionPtr sasl = obj;
+ virNetSASLSession *sasl = obj;
if (sasl->conn)
sasl_dispose(&sasl->conn);
#include "virobject.h"
typedef struct _virNetSASLContext virNetSASLContext;
-typedef virNetSASLContext *virNetSASLContextPtr;
typedef struct _virNetSASLSession virNetSASLSession;
-typedef virNetSASLSession *virNetSASLSessionPtr;
enum {
VIR_NET_SASL_COMPLETE,
VIR_NET_SASL_INTERACT,
};
-virNetSASLContextPtr virNetSASLContextNewClient(void);
-virNetSASLContextPtr virNetSASLContextNewServer(const char *const *usernameACL);
+virNetSASLContext *virNetSASLContextNewClient(void);
+virNetSASLContext *virNetSASLContextNewServer(const char *const *usernameACL);
-int virNetSASLContextCheckIdentity(virNetSASLContextPtr ctxt,
+int virNetSASLContextCheckIdentity(virNetSASLContext *ctxt,
const char *identity);
-virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt,
+virNetSASLSession *virNetSASLSessionNewClient(virNetSASLContext *ctxt,
const char *service,
const char *hostname,
const char *localAddr,
const char *remoteAddr,
sasl_callback_t *cbs);
-virNetSASLSessionPtr virNetSASLSessionNewServer(virNetSASLContextPtr ctxt,
+virNetSASLSession *virNetSASLSessionNewServer(virNetSASLContext *ctxt,
const char *service,
const char *localAddr,
const char *remoteAddr);
-char *virNetSASLSessionListMechanisms(virNetSASLSessionPtr sasl);
+char *virNetSASLSessionListMechanisms(virNetSASLSession *sasl);
-int virNetSASLSessionExtKeySize(virNetSASLSessionPtr sasl,
+int virNetSASLSessionExtKeySize(virNetSASLSession *sasl,
int ssf);
-int virNetSASLSessionGetKeySize(virNetSASLSessionPtr sasl);
+int virNetSASLSessionGetKeySize(virNetSASLSession *sasl);
-const char *virNetSASLSessionGetIdentity(virNetSASLSessionPtr sasl);
+const char *virNetSASLSessionGetIdentity(virNetSASLSession *sasl);
-int virNetSASLSessionSecProps(virNetSASLSessionPtr sasl,
+int virNetSASLSessionSecProps(virNetSASLSession *sasl,
int minSSF,
int maxSSF,
bool allowAnonymous);
-int virNetSASLSessionClientStart(virNetSASLSessionPtr sasl,
+int virNetSASLSessionClientStart(virNetSASLSession *sasl,
const char *mechlist,
sasl_interact_t **prompt_need,
const char **clientout,
size_t *clientoutlen,
const char **mech);
-int virNetSASLSessionClientStep(virNetSASLSessionPtr sasl,
+int virNetSASLSessionClientStep(virNetSASLSession *sasl,
const char *serverin,
size_t serverinlen,
sasl_interact_t **prompt_need,
const char **clientout,
size_t *clientoutlen);
-int virNetSASLSessionServerStart(virNetSASLSessionPtr sasl,
+int virNetSASLSessionServerStart(virNetSASLSession *sasl,
const char *mechname,
const char *clientin,
size_t clientinlen,
const char **serverout,
size_t *serveroutlen);
-int virNetSASLSessionServerStep(virNetSASLSessionPtr sasl,
+int virNetSASLSessionServerStep(virNetSASLSession *sasl,
const char *clientin,
size_t clientinlen,
const char **serverout,
size_t *serveroutlen);
-size_t virNetSASLSessionGetMaxBufSize(virNetSASLSessionPtr sasl);
+size_t virNetSASLSessionGetMaxBufSize(virNetSASLSession *sasl);
-ssize_t virNetSASLSessionEncode(virNetSASLSessionPtr sasl,
+ssize_t virNetSASLSessionEncode(virNetSASLSession *sasl,
const char *input,
size_t inputLen,
const char **output,
size_t *outputlen);
-ssize_t virNetSASLSessionDecode(virNetSASLSessionPtr sasl,
+ssize_t virNetSASLSessionDecode(virNetSASLSession *sasl,
const char *input,
size_t inputLen,
const char **output,
typedef struct _virNetServerJob virNetServerJob;
-typedef virNetServerJob *virNetServerJobPtr;
-
struct _virNetServerJob {
- virNetServerClientPtr client;
- virNetMessagePtr msg;
- virNetServerProgramPtr prog;
+ virNetServerClient *client;
+ virNetMessage *msg;
+ virNetServerProgram *prog;
};
struct _virNetServer {
char *name;
/* Immutable pointer, self-locking APIs */
- virThreadPoolPtr workers;
+ virThreadPool *workers;
size_t nservices;
- virNetServerServicePtr *services;
+ virNetServerService **services;
size_t nprograms;
- virNetServerProgramPtr *programs;
+ virNetServerProgram **programs;
size_t nclients; /* Current clients count */
- virNetServerClientPtr *clients; /* Clients */
+ virNetServerClient **clients; /* Clients */
unsigned long long next_client_id; /* next client ID */
size_t nclients_max; /* Max allowed clients count */
size_t nclients_unauth; /* Unauthenticated clients count */
int keepaliveInterval;
unsigned int keepaliveCount;
- virNetTLSContextPtr tls;
+ virNetTLSContext *tls;
virNetServerClientPrivNew clientPrivNew;
virNetServerClientPrivPreExecRestart clientPrivPreExecRestart;
};
-static virClassPtr virNetServerClass;
+static virClass *virNetServerClass;
static void virNetServerDispose(void *obj);
-static void virNetServerUpdateServicesLocked(virNetServerPtr srv,
+static void virNetServerUpdateServicesLocked(virNetServer *srv,
bool enabled);
-static inline size_t virNetServerTrackPendingAuthLocked(virNetServerPtr srv);
-static inline size_t virNetServerTrackCompletedAuthLocked(virNetServerPtr srv);
+static inline size_t virNetServerTrackPendingAuthLocked(virNetServer *srv);
+static inline size_t virNetServerTrackCompletedAuthLocked(virNetServer *srv);
static int virNetServerOnceInit(void)
{
VIR_ONCE_GLOBAL_INIT(virNetServer);
-unsigned long long virNetServerNextClientID(virNetServerPtr srv)
+unsigned long long virNetServerNextClientID(virNetServer *srv)
{
unsigned long long val;
return val;
}
-static int virNetServerProcessMsg(virNetServerPtr srv,
- virNetServerClientPtr client,
- virNetServerProgramPtr prog,
- virNetMessagePtr msg)
+static int virNetServerProcessMsg(virNetServer *srv,
+ virNetServerClient *client,
+ virNetServerProgram *prog,
+ virNetMessage *msg)
{
if (!prog) {
/* Only send back an error for type == CALL. Other
static void virNetServerHandleJob(void *jobOpaque, void *opaque)
{
- virNetServerPtr srv = opaque;
- virNetServerJobPtr job = jobOpaque;
+ virNetServer *srv = opaque;
+ virNetServerJob *job = jobOpaque;
VIR_DEBUG("server=%p client=%p message=%p prog=%p",
srv, job->client, job->msg, job->prog);
*
* Returns a pointer to the server program or NULL if not found.
*/
-static virNetServerProgramPtr
-virNetServerGetProgramLocked(virNetServerPtr srv,
- virNetMessagePtr msg)
+static virNetServerProgram *
+virNetServerGetProgramLocked(virNetServer *srv,
+ virNetMessage *msg)
{
size_t i;
for (i = 0; i < srv->nprograms; i++) {
}
static void
-virNetServerDispatchNewMessage(virNetServerClientPtr client,
- virNetMessagePtr msg,
+virNetServerDispatchNewMessage(virNetServerClient *client,
+ virNetMessage *msg,
void *opaque)
{
- virNetServerPtr srv = opaque;
- virNetServerProgramPtr prog = NULL;
+ virNetServer *srv = opaque;
+ virNetServerProgram *prog = NULL;
unsigned int priority = 0;
VIR_DEBUG("server=%p client=%p message=%p",
virObjectUnlock(srv);
if (virThreadPoolGetMaxWorkers(srv->workers) > 0) {
- virNetServerJobPtr job;
+ virNetServerJob *job;
job = g_new0(virNetServerJob, 1);
* The @srv must be locked when this function is called.
*/
static void
-virNetServerCheckLimits(virNetServerPtr srv)
+virNetServerCheckLimits(virNetServer *srv)
{
VIR_DEBUG("Checking client-related limits to re-enable or temporarily "
"suspend services: nclients=%zu nclients_max=%zu "
}
}
-int virNetServerAddClient(virNetServerPtr srv,
- virNetServerClientPtr client)
+int virNetServerAddClient(virNetServer *srv,
+ virNetServerClient *client)
{
virObjectLock(srv);
return -1;
}
-static int virNetServerDispatchNewClient(virNetServerServicePtr svc,
- virNetSocketPtr clientsock,
+static int virNetServerDispatchNewClient(virNetServerService *svc,
+ virNetSocket *clientsock,
void *opaque)
{
- virNetServerPtr srv = opaque;
- virNetServerClientPtr client;
+ virNetServer *srv = opaque;
+ virNetServerClient *client;
if (!(client = virNetServerClientNew(virNetServerNextClientID(srv),
clientsock,
}
-virNetServerPtr virNetServerNew(const char *name,
+virNetServer *virNetServerNew(const char *name,
unsigned long long next_client_id,
size_t min_workers,
size_t max_workers,
virFreeCallback clientPrivFree,
void *clientPrivOpaque)
{
- virNetServerPtr srv;
+ virNetServer *srv;
if (virNetServerInitialize() < 0)
return NULL;
}
-virNetServerPtr virNetServerNewPostExecRestart(virJSONValuePtr object,
+virNetServer *virNetServerNewPostExecRestart(virJSONValue *object,
const char *name,
virNetServerClientPrivNew clientPrivNew,
virNetServerClientPrivNewPostExecRestart clientPrivNewPostExecRestart,
virFreeCallback clientPrivFree,
void *clientPrivOpaque)
{
- virNetServerPtr srv = NULL;
- virJSONValuePtr clients;
- virJSONValuePtr services;
+ virNetServer *srv = NULL;
+ virJSONValue *clients;
+ virJSONValue *services;
size_t i;
unsigned int min_workers;
unsigned int max_workers;
}
for (i = 0; i < virJSONValueArraySize(services); i++) {
- virNetServerServicePtr service;
- virJSONValuePtr child = virJSONValueArrayGet(services, i);
+ virNetServerService *service;
+ virJSONValue *child = virJSONValueArrayGet(services, i);
if (!child) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Missing service data in JSON document"));
}
for (i = 0; i < virJSONValueArraySize(clients); i++) {
- virNetServerClientPtr client;
- virJSONValuePtr child = virJSONValueArrayGet(clients, i);
+ virNetServerClient *client;
+ virJSONValue *child = virJSONValueArrayGet(clients, i);
if (!child) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Missing client data in JSON document"));
}
-virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv)
+virJSONValue *virNetServerPreExecRestart(virNetServer *srv)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) clients = virJSONValueNewArray();
-int virNetServerAddService(virNetServerPtr srv,
- virNetServerServicePtr svc)
+int virNetServerAddService(virNetServer *srv,
+ virNetServerService *svc)
{
virObjectLock(srv);
static int
-virNetServerAddServiceActivation(virNetServerPtr srv,
- virSystemdActivationPtr act,
+virNetServerAddServiceActivation(virNetServer *srv,
+ virSystemdActivation *act,
const char *actname,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
virSystemdActivationClaimFDs(act, actname, &fds, &nfds);
if (nfds) {
- virNetServerServicePtr svc;
+ virNetServerService *svc;
svc = virNetServerServiceNewFDs(fds,
nfds,
}
-int virNetServerAddServiceTCP(virNetServerPtr srv,
- virSystemdActivationPtr act,
+int virNetServerAddServiceTCP(virNetServer *srv,
+ virSystemdActivation *act,
const char *actname,
const char *nodename,
const char *service,
int family,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc = NULL;
+ virNetServerService *svc = NULL;
int ret;
ret = virNetServerAddServiceActivation(srv, act, actname,
}
-int virNetServerAddServiceUNIX(virNetServerPtr srv,
- virSystemdActivationPtr act,
+int virNetServerAddServiceUNIX(virNetServer *srv,
+ virSystemdActivation *act,
const char *actname,
const char *path,
mode_t mask,
gid_t grp,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc = NULL;
+ virNetServerService *svc = NULL;
int ret;
ret = virNetServerAddServiceActivation(srv, act, actname,
}
-int virNetServerAddProgram(virNetServerPtr srv,
- virNetServerProgramPtr prog)
+int virNetServerAddProgram(virNetServer *srv,
+ virNetServerProgram *prog)
{
virObjectLock(srv);
return 0;
}
-int virNetServerSetTLSContext(virNetServerPtr srv,
- virNetTLSContextPtr tls)
+int virNetServerSetTLSContext(virNetServer *srv,
+ virNetTLSContext *tls)
{
srv->tls = virObjectRef(tls);
return 0;
* update the server tracking.
*/
static void
-virNetServerSetClientAuthCompletedLocked(virNetServerPtr srv,
- virNetServerClientPtr client)
+virNetServerSetClientAuthCompletedLocked(virNetServer *srv,
+ virNetServerClient *client)
{
if (virNetServerClientIsAuthPendingLocked(client)) {
virNetServerClientSetAuthPendingLocked(client, false);
* the limits of @srv.
*/
void
-virNetServerSetClientAuthenticated(virNetServerPtr srv,
- virNetServerClientPtr client)
+virNetServerSetClientAuthenticated(virNetServer *srv,
+ virNetServerClient *client)
{
virObjectLock(srv);
virObjectLock(client);
static void
-virNetServerUpdateServicesLocked(virNetServerPtr srv,
+virNetServerUpdateServicesLocked(virNetServer *srv,
bool enabled)
{
size_t i;
}
-void virNetServerUpdateServices(virNetServerPtr srv,
+void virNetServerUpdateServices(virNetServer *srv,
bool enabled)
{
virObjectLock(srv);
void virNetServerDispose(void *obj)
{
- virNetServerPtr srv = obj;
+ virNetServer *srv = obj;
size_t i;
g_free(srv->name);
g_free(srv->clients);
}
-void virNetServerClose(virNetServerPtr srv)
+void virNetServerClose(virNetServer *srv)
{
size_t i;
}
void
-virNetServerShutdownWait(virNetServerPtr srv)
+virNetServerShutdownWait(virNetServer *srv)
{
virThreadPoolDrain(srv->workers);
}
static inline size_t
-virNetServerTrackPendingAuthLocked(virNetServerPtr srv)
+virNetServerTrackPendingAuthLocked(virNetServer *srv)
{
return ++srv->nclients_unauth;
}
static inline size_t
-virNetServerTrackCompletedAuthLocked(virNetServerPtr srv)
+virNetServerTrackCompletedAuthLocked(virNetServer *srv)
{
return --srv->nclients_unauth;
}
bool
-virNetServerHasClients(virNetServerPtr srv)
+virNetServerHasClients(virNetServer *srv)
{
bool ret;
}
void
-virNetServerProcessClients(virNetServerPtr srv)
+virNetServerProcessClients(virNetServer *srv)
{
size_t i;
- virNetServerClientPtr client;
+ virNetServerClient *client;
virObjectLock(srv);
}
const char *
-virNetServerGetName(virNetServerPtr srv)
+virNetServerGetName(virNetServer *srv)
{
return srv->name;
}
int
-virNetServerGetThreadPoolParameters(virNetServerPtr srv,
+virNetServerGetThreadPoolParameters(virNetServer *srv,
size_t *minWorkers,
size_t *maxWorkers,
size_t *nWorkers,
}
int
-virNetServerSetThreadPoolParameters(virNetServerPtr srv,
+virNetServerSetThreadPoolParameters(virNetServer *srv,
long long int minWorkers,
long long int maxWorkers,
long long int prioWorkers)
}
size_t
-virNetServerGetMaxClients(virNetServerPtr srv)
+virNetServerGetMaxClients(virNetServer *srv)
{
size_t ret;
}
size_t
-virNetServerGetCurrentClients(virNetServerPtr srv)
+virNetServerGetCurrentClients(virNetServer *srv)
{
size_t ret;
}
size_t
-virNetServerGetMaxUnauthClients(virNetServerPtr srv)
+virNetServerGetMaxUnauthClients(virNetServer *srv)
{
size_t ret;
}
size_t
-virNetServerGetCurrentUnauthClients(virNetServerPtr srv)
+virNetServerGetCurrentUnauthClients(virNetServer *srv)
{
size_t ret;
}
-bool virNetServerNeedsAuth(virNetServerPtr srv,
+bool virNetServerNeedsAuth(virNetServer *srv,
int auth)
{
bool ret = false;
}
int
-virNetServerGetClients(virNetServerPtr srv,
- virNetServerClientPtr **clts)
+virNetServerGetClients(virNetServer *srv,
+ virNetServerClient ***clts)
{
int ret = -1;
size_t i;
size_t nclients = 0;
- virNetServerClientPtr *list = NULL;
+ virNetServerClient **list = NULL;
virObjectLock(srv);
for (i = 0; i < srv->nclients; i++) {
- virNetServerClientPtr client = virObjectRef(srv->clients[i]);
+ virNetServerClient *client = virObjectRef(srv->clients[i]);
if (VIR_APPEND_ELEMENT(list, nclients, client) < 0) {
virObjectUnref(client);
goto cleanup;
return ret;
}
-virNetServerClientPtr
-virNetServerGetClient(virNetServerPtr srv,
+virNetServerClient *
+virNetServerGetClient(virNetServer *srv,
unsigned long long id)
{
size_t i;
- virNetServerClientPtr ret = NULL;
+ virNetServerClient *ret = NULL;
virObjectLock(srv);
for (i = 0; i < srv->nclients; i++) {
- virNetServerClientPtr client = srv->clients[i];
+ virNetServerClient *client = srv->clients[i];
if (virNetServerClientGetID(client) == id)
ret = virObjectRef(client);
}
}
int
-virNetServerSetClientLimits(virNetServerPtr srv,
+virNetServerSetClientLimits(virNetServer *srv,
long long int maxClients,
long long int maxClientsUnauth)
{
return ret;
}
-static virNetTLSContextPtr
-virNetServerGetTLSContext(virNetServerPtr srv)
+static virNetTLSContext *
+virNetServerGetTLSContext(virNetServer *srv)
{
size_t i;
- virNetTLSContextPtr ctxt = NULL;
- virNetServerServicePtr svc = NULL;
+ virNetTLSContext *ctxt = NULL;
+ virNetServerService *svc = NULL;
/* find svcTLS from srv, get svcTLS->tls */
for (i = 0; i < srv->nservices; i++) {
}
int
-virNetServerUpdateTlsFiles(virNetServerPtr srv)
+virNetServerUpdateTlsFiles(virNetServer *srv)
{
int ret = -1;
- virNetTLSContextPtr ctxt = NULL;
+ virNetTLSContext *ctxt = NULL;
bool privileged = geteuid() == 0;
ctxt = virNetServerGetTLSContext(srv);
#include "virsystemd.h"
-virNetServerPtr virNetServerNew(const char *name,
+virNetServer *virNetServerNew(const char *name,
unsigned long long next_client_id,
size_t min_workers,
size_t max_workers,
void *clientPrivOpaque)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(10) ATTRIBUTE_NONNULL(12);
-virNetServerPtr virNetServerNewPostExecRestart(virJSONValuePtr object,
+virNetServer *virNetServerNewPostExecRestart(virJSONValue *object,
const char *name,
virNetServerClientPrivNew clientPrivNew,
virNetServerClientPrivNewPostExecRestart clientPrivNewPostExecRestart,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6);
-void virNetServerClose(virNetServerPtr srv);
-void virNetServerShutdownWait(virNetServerPtr srv);
+void virNetServerClose(virNetServer *srv);
+void virNetServerShutdownWait(virNetServer *srv);
-virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv);
+virJSONValue *virNetServerPreExecRestart(virNetServer *srv);
-int virNetServerAddService(virNetServerPtr srv,
- virNetServerServicePtr svc);
-int virNetServerAddServiceTCP(virNetServerPtr srv,
- virSystemdActivationPtr act,
+int virNetServerAddService(virNetServer *srv,
+ virNetServerService *svc);
+int virNetServerAddServiceTCP(virNetServer *srv,
+ virSystemdActivation *act,
const char *actname,
const char *nodename,
const char *service,
int family,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max);
-int virNetServerAddServiceUNIX(virNetServerPtr srv,
- virSystemdActivationPtr act,
+int virNetServerAddServiceUNIX(virNetServer *srv,
+ virSystemdActivation *act,
const char *actname,
const char *path,
mode_t mask,
gid_t grp,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max);
-int virNetServerAddProgram(virNetServerPtr srv,
- virNetServerProgramPtr prog);
+int virNetServerAddProgram(virNetServer *srv,
+ virNetServerProgram *prog);
-int virNetServerSetTLSContext(virNetServerPtr srv,
- virNetTLSContextPtr tls);
+int virNetServerSetTLSContext(virNetServer *srv,
+ virNetTLSContext *tls);
-int virNetServerAddClient(virNetServerPtr srv,
- virNetServerClientPtr client);
-bool virNetServerHasClients(virNetServerPtr srv);
-void virNetServerProcessClients(virNetServerPtr srv);
-void virNetServerSetClientAuthenticated(virNetServerPtr srv, virNetServerClientPtr client);
+int virNetServerAddClient(virNetServer *srv,
+ virNetServerClient *client);
+bool virNetServerHasClients(virNetServer *srv);
+void virNetServerProcessClients(virNetServer *srv);
+void virNetServerSetClientAuthenticated(virNetServer *srv, virNetServerClient *client);
-void virNetServerUpdateServices(virNetServerPtr srv, bool enabled);
+void virNetServerUpdateServices(virNetServer *srv, bool enabled);
-const char *virNetServerGetName(virNetServerPtr srv);
+const char *virNetServerGetName(virNetServer *srv);
-int virNetServerGetThreadPoolParameters(virNetServerPtr srv,
+int virNetServerGetThreadPoolParameters(virNetServer *srv,
size_t *minWorkers,
size_t *maxWorkers,
size_t *nWorkers,
size_t *nPrioWorkers,
size_t *jobQueueDepth);
-int virNetServerSetThreadPoolParameters(virNetServerPtr srv,
+int virNetServerSetThreadPoolParameters(virNetServer *srv,
long long int minWorkers,
long long int maxWorkers,
long long int prioWorkers);
-unsigned long long virNetServerNextClientID(virNetServerPtr srv);
+unsigned long long virNetServerNextClientID(virNetServer *srv);
-virNetServerClientPtr virNetServerGetClient(virNetServerPtr srv,
+virNetServerClient *virNetServerGetClient(virNetServer *srv,
unsigned long long id);
-bool virNetServerNeedsAuth(virNetServerPtr srv,
+bool virNetServerNeedsAuth(virNetServer *srv,
int auth);
-int virNetServerGetClients(virNetServerPtr srv,
- virNetServerClientPtr **clients);
+int virNetServerGetClients(virNetServer *srv,
+ virNetServerClient ***clients);
-size_t virNetServerGetMaxClients(virNetServerPtr srv);
-size_t virNetServerGetCurrentClients(virNetServerPtr srv);
-size_t virNetServerGetMaxUnauthClients(virNetServerPtr srv);
-size_t virNetServerGetCurrentUnauthClients(virNetServerPtr srv);
+size_t virNetServerGetMaxClients(virNetServer *srv);
+size_t virNetServerGetCurrentClients(virNetServer *srv);
+size_t virNetServerGetMaxUnauthClients(virNetServer *srv);
+size_t virNetServerGetCurrentUnauthClients(virNetServer *srv);
-int virNetServerSetClientLimits(virNetServerPtr srv,
+int virNetServerSetClientLimits(virNetServer *srv,
long long int maxClients,
long long int maxClientsUnauth);
-int virNetServerUpdateTlsFiles(virNetServerPtr srv);
+int virNetServerUpdateTlsFiles(virNetServer *srv);
*/
typedef struct _virNetServerClientFilter virNetServerClientFilter;
-typedef virNetServerClientFilter *virNetServerClientFilterPtr;
-
struct _virNetServerClientFilter {
int id;
virNetServerClientFilterFunc func;
void *opaque;
- virNetServerClientFilterPtr next;
+ virNetServerClientFilter *next;
};
unsigned long long id;
bool wantClose;
bool delayedClose;
- virNetSocketPtr sock;
+ virNetSocket *sock;
int auth;
bool auth_pending;
bool readonly;
- virNetTLSContextPtr tlsCtxt;
- virNetTLSSessionPtr tls;
+ virNetTLSContext *tlsCtxt;
+ virNetTLSSession *tls;
#if WITH_SASL
- virNetSASLSessionPtr sasl;
+ virNetSASLSession *sasl;
#endif
int sockTimer; /* Timer to be fired upon cached data,
* so we jump out from poll() immediately */
- virIdentityPtr identity;
+ virIdentity *identity;
/* Connection timestamp, i.e. when a client connected to the daemon (UTC).
* For old clients restored by post-exec-restart, which did not have this
size_t nrequests_max;
/* Zero or one messages being received. Zero if
* nrequests >= max_clients and throttling */
- virNetMessagePtr rx;
+ virNetMessage *rx;
/* Zero or many messages waiting for transmit
* back to client, including async events */
- virNetMessagePtr tx;
+ virNetMessage *tx;
/* Filters to capture messages that would otherwise
* end up on the 'dx' queue */
- virNetServerClientFilterPtr filters;
+ virNetServerClientFilter *filters;
int nextFilterID;
virNetServerClientDispatchFunc dispatchFunc;
virNetServerClientPrivPreExecRestart privateDataPreExecRestart;
virNetServerClientCloseFunc privateDataCloseFunc;
- virKeepAlivePtr keepalive;
+ virKeepAlive *keepalive;
};
-static virClassPtr virNetServerClientClass;
+static virClass *virNetServerClientClass;
static void virNetServerClientDispose(void *obj);
static int virNetServerClientOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virNetServerClient);
-static void virNetServerClientDispatchEvent(virNetSocketPtr sock, int events, void *opaque);
-static void virNetServerClientUpdateEvent(virNetServerClientPtr client);
-static virNetMessagePtr virNetServerClientDispatchRead(virNetServerClientPtr client);
-static int virNetServerClientSendMessageLocked(virNetServerClientPtr client,
- virNetMessagePtr msg);
+static void virNetServerClientDispatchEvent(virNetSocket *sock, int events, void *opaque);
+static void virNetServerClientUpdateEvent(virNetServerClient *client);
+static virNetMessage *virNetServerClientDispatchRead(virNetServerClient *client);
+static int virNetServerClientSendMessageLocked(virNetServerClient *client,
+ virNetMessage *msg);
/*
* @client: a locked client object
*/
static int
-virNetServerClientCalculateHandleMode(virNetServerClientPtr client)
+virNetServerClientCalculateHandleMode(virNetServerClient *client)
{
int mode = 0;
* @server: a locked or unlocked server object
* @client: a locked client object
*/
-static int virNetServerClientRegisterEvent(virNetServerClientPtr client)
+static int virNetServerClientRegisterEvent(virNetServerClient *client)
{
int mode = virNetServerClientCalculateHandleMode(client);
/*
* @client: a locked client object
*/
-static void virNetServerClientUpdateEvent(virNetServerClientPtr client)
+static void virNetServerClientUpdateEvent(virNetServerClient *client)
{
int mode;
}
-int virNetServerClientAddFilter(virNetServerClientPtr client,
+int virNetServerClientAddFilter(virNetServerClient *client,
virNetServerClientFilterFunc func,
void *opaque)
{
- virNetServerClientFilterPtr filter;
- virNetServerClientFilterPtr *place;
+ virNetServerClientFilter *filter;
+ virNetServerClientFilter **place;
int ret;
filter = g_new0(virNetServerClientFilter, 1);
return ret;
}
-void virNetServerClientRemoveFilter(virNetServerClientPtr client,
+void virNetServerClientRemoveFilter(virNetServerClient *client,
int filterID)
{
- virNetServerClientFilterPtr tmp;
- virNetServerClientFilterPtr prev;
+ virNetServerClientFilter *tmp;
+ virNetServerClientFilter *prev;
virObjectLock(client);
/* Check the client's access. */
static int
-virNetServerClientCheckAccess(virNetServerClientPtr client)
+virNetServerClientCheckAccess(virNetServerClient *client)
{
- virNetMessagePtr confirm;
+ virNetMessage *confirm;
/* Verify client certificate. */
if (virNetTLSContextCheckCertificate(client->tlsCtxt, client->tls) < 0)
}
-static void virNetServerClientDispatchMessage(virNetServerClientPtr client,
- virNetMessagePtr msg)
+static void virNetServerClientDispatchMessage(virNetServerClient *client,
+ virNetMessage *msg)
{
virObjectLock(client);
if (!client->dispatchFunc) {
static void virNetServerClientSockTimerFunc(int timer,
void *opaque)
{
- virNetServerClientPtr client = opaque;
- virNetMessagePtr msg = NULL;
+ virNetServerClient *client = opaque;
+ virNetMessage *msg = NULL;
virObjectLock(client);
virEventUpdateTimeout(timer, -1);
/* Although client->rx != NULL when this timer is enabled, it might have
}
-static virNetServerClientPtr
+static virNetServerClient *
virNetServerClientNewInternal(unsigned long long id,
- virNetSocketPtr sock,
+ virNetSocket *sock,
int auth,
bool auth_pending,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t nrequests_max,
long long timestamp)
{
- virNetServerClientPtr client;
+ virNetServerClient *client;
if (virNetServerClientInitialize() < 0)
return NULL;
}
-virNetServerClientPtr virNetServerClientNew(unsigned long long id,
- virNetSocketPtr sock,
+virNetServerClient *virNetServerClientNew(unsigned long long id,
+ virNetSocket *sock,
int auth,
bool readonly,
size_t nrequests_max,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
virNetServerClientPrivNew privNew,
virNetServerClientPrivPreExecRestart privPreExecRestart,
virFreeCallback privFree,
void *privOpaque)
{
- virNetServerClientPtr client;
+ virNetServerClient *client;
time_t now;
bool auth_pending = !virNetServerClientAuthMethodImpliesAuthenticated(auth);
}
-virNetServerClientPtr virNetServerClientNewPostExecRestart(virNetServerPtr srv,
- virJSONValuePtr object,
+virNetServerClient *virNetServerClientNewPostExecRestart(virNetServer *srv,
+ virJSONValue *object,
virNetServerClientPrivNewPostExecRestart privNew,
virNetServerClientPrivPreExecRestart privPreExecRestart,
virFreeCallback privFree,
void *privOpaque)
{
- virJSONValuePtr child;
- virNetServerClientPtr client = NULL;
- virNetSocketPtr sock;
+ virJSONValue *child;
+ virNetServerClient *client = NULL;
+ virNetSocket *sock;
int auth;
bool readonly, auth_pending;
unsigned int nrequests_max;
}
-virJSONValuePtr virNetServerClientPreExecRestart(virNetServerClientPtr client)
+virJSONValue *virNetServerClientPreExecRestart(virNetServerClient *client)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) sock = NULL;
}
-int virNetServerClientGetAuth(virNetServerClientPtr client)
+int virNetServerClientGetAuth(virNetServerClient *client)
{
int auth;
virObjectLock(client);
void
-virNetServerClientSetAuthLocked(virNetServerClientPtr client,
+virNetServerClientSetAuthLocked(virNetServerClient *client,
int auth)
{
client->auth = auth;
}
-bool virNetServerClientGetReadonly(virNetServerClientPtr client)
+bool virNetServerClientGetReadonly(virNetServerClient *client)
{
bool readonly;
virObjectLock(client);
void
-virNetServerClientSetReadonly(virNetServerClientPtr client,
+virNetServerClientSetReadonly(virNetServerClient *client,
bool readonly)
{
virObjectLock(client);
}
-unsigned long long virNetServerClientGetID(virNetServerClientPtr client)
+unsigned long long virNetServerClientGetID(virNetServerClient *client)
{
return client->id;
}
-long long virNetServerClientGetTimestamp(virNetServerClientPtr client)
+long long virNetServerClientGetTimestamp(virNetServerClient *client)
{
return client->conn_time;
}
-bool virNetServerClientHasTLSSession(virNetServerClientPtr client)
+bool virNetServerClientHasTLSSession(virNetServerClient *client)
{
bool has;
virObjectLock(client);
}
-virNetTLSSessionPtr virNetServerClientGetTLSSession(virNetServerClientPtr client)
+virNetTLSSession *virNetServerClientGetTLSSession(virNetServerClient *client)
{
- virNetTLSSessionPtr tls;
+ virNetTLSSession *tls;
virObjectLock(client);
tls = client->tls;
virObjectUnlock(client);
return tls;
}
-int virNetServerClientGetTLSKeySize(virNetServerClientPtr client)
+int virNetServerClientGetTLSKeySize(virNetServerClient *client)
{
int size = 0;
virObjectLock(client);
return size;
}
-int virNetServerClientGetFD(virNetServerClientPtr client)
+int virNetServerClientGetFD(virNetServerClient *client)
{
int fd = -1;
virObjectLock(client);
}
-bool virNetServerClientIsLocal(virNetServerClientPtr client)
+bool virNetServerClientIsLocal(virNetServerClient *client)
{
bool local = false;
virObjectLock(client);
}
-int virNetServerClientGetUNIXIdentity(virNetServerClientPtr client,
+int virNetServerClientGetUNIXIdentity(virNetServerClient *client,
uid_t *uid, gid_t *gid, pid_t *pid,
unsigned long long *timestamp)
{
}
-static virIdentityPtr
-virNetServerClientCreateIdentity(virNetServerClientPtr client)
+static virIdentity *
+virNetServerClientCreateIdentity(virNetServerClient *client)
{
g_autofree char *username = NULL;
g_autofree char *groupname = NULL;
}
-virIdentityPtr virNetServerClientGetIdentity(virNetServerClientPtr client)
+virIdentity *virNetServerClientGetIdentity(virNetServerClient *client)
{
- virIdentityPtr ret = NULL;
+ virIdentity *ret = NULL;
virObjectLock(client);
if (!client->identity)
client->identity = virNetServerClientCreateIdentity(client);
}
-void virNetServerClientSetIdentity(virNetServerClientPtr client,
- virIdentityPtr identity)
+void virNetServerClientSetIdentity(virNetServerClient *client,
+ virIdentity *identity)
{
virObjectLock(client);
g_clear_object(&client->identity);
}
-int virNetServerClientGetSELinuxContext(virNetServerClientPtr client,
+int virNetServerClientGetSELinuxContext(virNetServerClient *client,
char **context)
{
int ret = 0;
}
-bool virNetServerClientIsSecure(virNetServerClientPtr client)
+bool virNetServerClientIsSecure(virNetServerClient *client)
{
bool secure = false;
virObjectLock(client);
#if WITH_SASL
-void virNetServerClientSetSASLSession(virNetServerClientPtr client,
- virNetSASLSessionPtr sasl)
+void virNetServerClientSetSASLSession(virNetServerClient *client,
+ virNetSASLSession *sasl)
{
/* We don't set the sasl session on the socket here
* because we need to send out the auth confirmation
}
-virNetSASLSessionPtr virNetServerClientGetSASLSession(virNetServerClientPtr client)
+virNetSASLSession *virNetServerClientGetSASLSession(virNetServerClient *client)
{
- virNetSASLSessionPtr sasl;
+ virNetSASLSession *sasl;
virObjectLock(client);
sasl = client->sasl;
virObjectUnlock(client);
return sasl;
}
-bool virNetServerClientHasSASLSession(virNetServerClientPtr client)
+bool virNetServerClientHasSASLSession(virNetServerClient *client)
{
bool has = false;
virObjectLock(client);
#endif
-void *virNetServerClientGetPrivateData(virNetServerClientPtr client)
+void *virNetServerClientGetPrivateData(virNetServerClient *client)
{
void *data;
virObjectLock(client);
}
-void virNetServerClientSetCloseHook(virNetServerClientPtr client,
+void virNetServerClientSetCloseHook(virNetServerClient *client,
virNetServerClientCloseFunc cf)
{
virObjectLock(client);
}
-void virNetServerClientSetDispatcher(virNetServerClientPtr client,
+void virNetServerClientSetDispatcher(virNetServerClient *client,
virNetServerClientDispatchFunc func,
void *opaque)
{
}
-const char *virNetServerClientLocalAddrStringSASL(virNetServerClientPtr client)
+const char *virNetServerClientLocalAddrStringSASL(virNetServerClient *client)
{
if (!client->sock)
return NULL;
}
-const char *virNetServerClientRemoteAddrStringSASL(virNetServerClientPtr client)
+const char *virNetServerClientRemoteAddrStringSASL(virNetServerClient *client)
{
if (!client->sock)
return NULL;
return virNetSocketRemoteAddrStringSASL(client->sock);
}
-const char *virNetServerClientRemoteAddrStringURI(virNetServerClientPtr client)
+const char *virNetServerClientRemoteAddrStringURI(virNetServerClient *client)
{
if (!client->sock)
return NULL;
void virNetServerClientDispose(void *obj)
{
- virNetServerClientPtr client = obj;
+ virNetServerClient *client = obj;
PROBE(RPC_SERVER_CLIENT_DISPOSE,
"client=%p", client);
* where it can be guaranteed it is no longer in use
*/
void
-virNetServerClientCloseLocked(virNetServerClientPtr client)
+virNetServerClientCloseLocked(virNetServerClient *client)
{
virNetServerClientCloseFunc cf;
- virKeepAlivePtr ka;
+ virKeepAlive *ka;
VIR_DEBUG("client=%p", client);
if (!client->sock)
client->wantClose = true;
while (client->rx) {
- virNetMessagePtr msg
+ virNetMessage *msg
= virNetMessageQueueServe(&client->rx);
virNetMessageFree(msg);
}
while (client->tx) {
- virNetMessagePtr msg
+ virNetMessage *msg
= virNetMessageQueueServe(&client->tx);
virNetMessageFree(msg);
}
void
-virNetServerClientClose(virNetServerClientPtr client)
+virNetServerClientClose(virNetServerClient *client)
{
virObjectLock(client);
virNetServerClientCloseLocked(client);
bool
-virNetServerClientIsClosedLocked(virNetServerClientPtr client)
+virNetServerClientIsClosedLocked(virNetServerClient *client)
{
return client->sock == NULL;
}
-void virNetServerClientDelayedClose(virNetServerClientPtr client)
+void virNetServerClientDelayedClose(virNetServerClient *client)
{
virObjectLock(client);
client->delayedClose = true;
virObjectUnlock(client);
}
-void virNetServerClientImmediateClose(virNetServerClientPtr client)
+void virNetServerClientImmediateClose(virNetServerClient *client)
{
virObjectLock(client);
client->wantClose = true;
bool
-virNetServerClientWantCloseLocked(virNetServerClientPtr client)
+virNetServerClientWantCloseLocked(virNetServerClient *client)
{
return client->wantClose;
}
-int virNetServerClientInit(virNetServerClientPtr client)
+int virNetServerClientInit(virNetServerClient *client)
{
virObjectLock(client);
* 0 on EAGAIN
* n number of bytes
*/
-static ssize_t virNetServerClientRead(virNetServerClientPtr client)
+static ssize_t virNetServerClientRead(virNetServerClient *client)
{
ssize_t ret;
* yet available, or an error occurred. On error, the wantClose
* flag will be set.
*/
-static virNetMessagePtr virNetServerClientDispatchRead(virNetServerClientPtr client)
+static virNetMessage *virNetServerClientDispatchRead(virNetServerClient *client)
{
readmore:
if (client->rx->nfds == 0) {
goto readmore;
} else {
/* Grab the completed message */
- virNetMessagePtr msg = client->rx;
- virNetMessagePtr response = NULL;
- virNetServerClientFilterPtr filter;
+ virNetMessage *msg = client->rx;
+ virNetMessage *response = NULL;
+ virNetServerClientFilter *filter;
size_t i;
/* Decode the header so we can use it for routing decisions */
* 0 on EAGAIN
* n number of bytes
*/
-static ssize_t virNetServerClientWrite(virNetServerClientPtr client)
+static ssize_t virNetServerClientWrite(virNetServerClient *client)
{
ssize_t ret;
* we would block on I/O
*/
static void
-virNetServerClientDispatchWrite(virNetServerClientPtr client)
+virNetServerClientDispatchWrite(virNetServerClient *client)
{
while (client->tx) {
if (client->tx->bufferOffset < client->tx->bufferLength) {
}
if (client->tx->bufferOffset == client->tx->bufferLength) {
- virNetMessagePtr msg;
+ virNetMessage *msg;
size_t i;
for (i = client->tx->donefds; i < client->tx->nfds; i++) {
static void
-virNetServerClientDispatchHandshake(virNetServerClientPtr client)
+virNetServerClientDispatchHandshake(virNetServerClient *client)
{
int ret;
/* Continue the handshake. */
static void
-virNetServerClientDispatchEvent(virNetSocketPtr sock, int events, void *opaque)
+virNetServerClientDispatchEvent(virNetSocket *sock, int events, void *opaque)
{
- virNetServerClientPtr client = opaque;
- virNetMessagePtr msg = NULL;
+ virNetServerClient *client = opaque;
+ virNetMessage *msg = NULL;
virObjectLock(client);
static int
-virNetServerClientSendMessageLocked(virNetServerClientPtr client,
- virNetMessagePtr msg)
+virNetServerClientSendMessageLocked(virNetServerClient *client,
+ virNetMessage *msg)
{
int ret = -1;
VIR_DEBUG("msg=%p proc=%d len=%zu offset=%zu",
return ret;
}
-int virNetServerClientSendMessage(virNetServerClientPtr client,
- virNetMessagePtr msg)
+int virNetServerClientSendMessage(virNetServerClient *client,
+ virNetMessage *msg)
{
int ret;
bool
-virNetServerClientIsAuthenticated(virNetServerClientPtr client)
+virNetServerClientIsAuthenticated(virNetServerClient *client)
{
bool authenticated;
virObjectLock(client);
/* The caller must hold the lock for @client */
void
-virNetServerClientSetAuthPendingLocked(virNetServerClientPtr client,
+virNetServerClientSetAuthPendingLocked(virNetServerClient *client,
bool auth_pending)
{
client->auth_pending = auth_pending;
/* The caller must hold the lock for @client */
bool
-virNetServerClientIsAuthPendingLocked(virNetServerClientPtr client)
+virNetServerClientIsAuthPendingLocked(virNetServerClient *client)
{
return client->auth_pending;
}
static int
virNetServerClientKeepAliveSendCB(void *opaque,
- virNetMessagePtr msg)
+ virNetMessage *msg)
{
return virNetServerClientSendMessage(opaque, msg);
}
int
-virNetServerClientInitKeepAlive(virNetServerClientPtr client,
+virNetServerClientInitKeepAlive(virNetServerClient *client,
int interval,
unsigned int count)
{
- virKeepAlivePtr ka;
+ virKeepAlive *ka;
int ret = -1;
virObjectLock(client);
}
int
-virNetServerClientStartKeepAlive(virNetServerClientPtr client)
+virNetServerClientStartKeepAlive(virNetServerClient *client)
{
int ret = -1;
}
int
-virNetServerClientGetTransport(virNetServerClientPtr client)
+virNetServerClientGetTransport(virNetServerClient *client)
{
int ret = -1;
}
int
-virNetServerClientGetInfo(virNetServerClientPtr client,
+virNetServerClientGetInfo(virNetServerClient *client,
bool *readonly, char **sock_addr,
- virIdentityPtr *identity)
+ virIdentity **identity)
{
int ret = -1;
const char *addr;
* socket rather than calling an API to close it.
*/
void
-virNetServerClientSetQuietEOF(virNetServerClientPtr client)
+virNetServerClientSetQuietEOF(virNetServerClient *client)
{
virNetSocketSetQuietEOF(client->sock);
}
#include "virjson.h"
typedef struct _virNetServer virNetServer;
-typedef virNetServer *virNetServerPtr;
typedef struct _virNetServerClient virNetServerClient;
-typedef virNetServerClient *virNetServerClientPtr;
/* This function owns the "msg" pointer it is passed and
* must arrange for virNetMessageFree to be called on it
*/
-typedef void (*virNetServerClientDispatchFunc)(virNetServerClientPtr client,
- virNetMessagePtr msg,
+typedef void (*virNetServerClientDispatchFunc)(virNetServerClient *client,
+ virNetMessage *msg,
void *opaque);
/*
* @client is locked when this callback is called
*/
-typedef int (*virNetServerClientFilterFunc)(virNetServerClientPtr client,
- virNetMessagePtr msg,
+typedef int (*virNetServerClientFilterFunc)(virNetServerClient *client,
+ virNetMessage *msg,
void *opaque);
/*
* @data: value allocated by virNetServerClintPrivNew(PostExecRestart) callback
*/
-typedef virJSONValuePtr (*virNetServerClientPrivPreExecRestart)(virNetServerClientPtr client,
+typedef virJSONValue *(*virNetServerClientPrivPreExecRestart)(virNetServerClient *client,
void *data);
/*
* @opaque: value of @privOpaque from virNetServerClientNewPostExecRestart
*/
-typedef void *(*virNetServerClientPrivNewPostExecRestart)(virNetServerClientPtr client,
- virJSONValuePtr object,
+typedef void *(*virNetServerClientPrivNewPostExecRestart)(virNetServerClient *client,
+ virJSONValue *object,
void *opaque);
/*
* @opaque: value of @privOpaque from virNetServerClientNew
*/
-typedef void *(*virNetServerClientPrivNew)(virNetServerClientPtr client,
+typedef void *(*virNetServerClientPrivNew)(virNetServerClient *client,
void *opaque);
-virNetServerClientPtr virNetServerClientNew(unsigned long long id,
- virNetSocketPtr sock,
+virNetServerClient *virNetServerClientNew(unsigned long long id,
+ virNetSocket *sock,
int auth,
bool readonly,
size_t nrequests_max,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
virNetServerClientPrivNew privNew,
virNetServerClientPrivPreExecRestart privPreExecRestart,
virFreeCallback privFree,
void *privOpaque)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(7) ATTRIBUTE_NONNULL(9);
-virNetServerClientPtr virNetServerClientNewPostExecRestart(virNetServerPtr srv,
- virJSONValuePtr object,
+virNetServerClient *virNetServerClientNewPostExecRestart(virNetServer *srv,
+ virJSONValue *object,
virNetServerClientPrivNewPostExecRestart privNew,
virNetServerClientPrivPreExecRestart privPreExecRestart,
virFreeCallback privFree,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
-virJSONValuePtr virNetServerClientPreExecRestart(virNetServerClientPtr client);
+virJSONValue *virNetServerClientPreExecRestart(virNetServerClient *client);
-int virNetServerClientAddFilter(virNetServerClientPtr client,
+int virNetServerClientAddFilter(virNetServerClient *client,
virNetServerClientFilterFunc func,
void *opaque);
-void virNetServerClientRemoveFilter(virNetServerClientPtr client,
+void virNetServerClientRemoveFilter(virNetServerClient *client,
int filterID);
-int virNetServerClientGetAuth(virNetServerClientPtr client);
-void virNetServerClientSetAuthLocked(virNetServerClientPtr client, int auth);
-bool virNetServerClientGetReadonly(virNetServerClientPtr client);
-void virNetServerClientSetReadonly(virNetServerClientPtr client, bool readonly);
-unsigned long long virNetServerClientGetID(virNetServerClientPtr client);
-long long virNetServerClientGetTimestamp(virNetServerClientPtr client);
+int virNetServerClientGetAuth(virNetServerClient *client);
+void virNetServerClientSetAuthLocked(virNetServerClient *client, int auth);
+bool virNetServerClientGetReadonly(virNetServerClient *client);
+void virNetServerClientSetReadonly(virNetServerClient *client, bool readonly);
+unsigned long long virNetServerClientGetID(virNetServerClient *client);
+long long virNetServerClientGetTimestamp(virNetServerClient *client);
-bool virNetServerClientHasTLSSession(virNetServerClientPtr client);
-virNetTLSSessionPtr virNetServerClientGetTLSSession(virNetServerClientPtr client);
-int virNetServerClientGetTLSKeySize(virNetServerClientPtr client);
+bool virNetServerClientHasTLSSession(virNetServerClient *client);
+virNetTLSSession *virNetServerClientGetTLSSession(virNetServerClient *client);
+int virNetServerClientGetTLSKeySize(virNetServerClient *client);
#ifdef WITH_SASL
-bool virNetServerClientHasSASLSession(virNetServerClientPtr client);
-void virNetServerClientSetSASLSession(virNetServerClientPtr client,
- virNetSASLSessionPtr sasl);
-virNetSASLSessionPtr virNetServerClientGetSASLSession(virNetServerClientPtr client);
+bool virNetServerClientHasSASLSession(virNetServerClient *client);
+void virNetServerClientSetSASLSession(virNetServerClient *client,
+ virNetSASLSession *sasl);
+virNetSASLSession *virNetServerClientGetSASLSession(virNetServerClient *client);
#endif
-int virNetServerClientGetFD(virNetServerClientPtr client);
+int virNetServerClientGetFD(virNetServerClient *client);
-bool virNetServerClientIsSecure(virNetServerClientPtr client);
+bool virNetServerClientIsSecure(virNetServerClient *client);
-bool virNetServerClientIsLocal(virNetServerClientPtr client);
+bool virNetServerClientIsLocal(virNetServerClient *client);
-int virNetServerClientGetUNIXIdentity(virNetServerClientPtr client,
+int virNetServerClientGetUNIXIdentity(virNetServerClient *client,
uid_t *uid, gid_t *gid, pid_t *pid,
unsigned long long *timestamp);
-int virNetServerClientGetSELinuxContext(virNetServerClientPtr client,
+int virNetServerClientGetSELinuxContext(virNetServerClient *client,
char **context);
-virIdentityPtr virNetServerClientGetIdentity(virNetServerClientPtr client);
-void virNetServerClientSetIdentity(virNetServerClientPtr client,
- virIdentityPtr identity);
+virIdentity *virNetServerClientGetIdentity(virNetServerClient *client);
+void virNetServerClientSetIdentity(virNetServerClient *client,
+ virIdentity *identity);
-void *virNetServerClientGetPrivateData(virNetServerClientPtr client);
+void *virNetServerClientGetPrivateData(virNetServerClient *client);
-typedef void (*virNetServerClientCloseFunc)(virNetServerClientPtr client);
+typedef void (*virNetServerClientCloseFunc)(virNetServerClient *client);
-void virNetServerClientSetCloseHook(virNetServerClientPtr client,
+void virNetServerClientSetCloseHook(virNetServerClient *client,
virNetServerClientCloseFunc cf);
-void virNetServerClientSetDispatcher(virNetServerClientPtr client,
+void virNetServerClientSetDispatcher(virNetServerClient *client,
virNetServerClientDispatchFunc func,
void *opaque);
-void virNetServerClientClose(virNetServerClientPtr client);
-void virNetServerClientCloseLocked(virNetServerClientPtr client);
-bool virNetServerClientIsClosedLocked(virNetServerClientPtr client);
+void virNetServerClientClose(virNetServerClient *client);
+void virNetServerClientCloseLocked(virNetServerClient *client);
+bool virNetServerClientIsClosedLocked(virNetServerClient *client);
-void virNetServerClientDelayedClose(virNetServerClientPtr client);
-void virNetServerClientImmediateClose(virNetServerClientPtr client);
-bool virNetServerClientWantCloseLocked(virNetServerClientPtr client);
+void virNetServerClientDelayedClose(virNetServerClient *client);
+void virNetServerClientImmediateClose(virNetServerClient *client);
+bool virNetServerClientWantCloseLocked(virNetServerClient *client);
-int virNetServerClientInit(virNetServerClientPtr client);
+int virNetServerClientInit(virNetServerClient *client);
-int virNetServerClientInitKeepAlive(virNetServerClientPtr client,
+int virNetServerClientInitKeepAlive(virNetServerClient *client,
int interval,
unsigned int count);
-bool virNetServerClientCheckKeepAlive(virNetServerClientPtr client,
- virNetMessagePtr msg);
-int virNetServerClientStartKeepAlive(virNetServerClientPtr client);
+bool virNetServerClientCheckKeepAlive(virNetServerClient *client,
+ virNetMessage *msg);
+int virNetServerClientStartKeepAlive(virNetServerClient *client);
-const char *virNetServerClientLocalAddrStringSASL(virNetServerClientPtr client);
-const char *virNetServerClientRemoteAddrStringSASL(virNetServerClientPtr client);
-const char *virNetServerClientRemoteAddrStringURI(virNetServerClientPtr client);
+const char *virNetServerClientLocalAddrStringSASL(virNetServerClient *client);
+const char *virNetServerClientRemoteAddrStringSASL(virNetServerClient *client);
+const char *virNetServerClientRemoteAddrStringURI(virNetServerClient *client);
-int virNetServerClientSendMessage(virNetServerClientPtr client,
- virNetMessagePtr msg);
+int virNetServerClientSendMessage(virNetServerClient *client,
+ virNetMessage *msg);
-bool virNetServerClientIsAuthenticated(virNetServerClientPtr client);
-bool virNetServerClientIsAuthPendingLocked(virNetServerClientPtr client);
-void virNetServerClientSetAuthPendingLocked(virNetServerClientPtr client, bool auth_pending);
+bool virNetServerClientIsAuthenticated(virNetServerClient *client);
+bool virNetServerClientIsAuthPendingLocked(virNetServerClient *client);
+void virNetServerClientSetAuthPendingLocked(virNetServerClient *client, bool auth_pending);
-int virNetServerClientGetTransport(virNetServerClientPtr client);
-int virNetServerClientGetInfo(virNetServerClientPtr client,
+int virNetServerClientGetTransport(virNetServerClient *client);
+int virNetServerClientGetInfo(virNetServerClient *client,
bool *readonly, char **sock_addr,
- virIdentityPtr *identity);
+ virIdentity **identity);
-void virNetServerClientSetQuietEOF(virNetServerClientPtr client);
+void virNetServerClientSetQuietEOF(virNetServerClient *client);
unsigned program;
unsigned version;
- virNetServerProgramProcPtr procs;
+ virNetServerProgramProc *procs;
size_t nprocs;
};
-static virClassPtr virNetServerProgramClass;
+static virClass *virNetServerProgramClass;
static void virNetServerProgramDispose(void *obj);
static int virNetServerProgramOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virNetServerProgram);
-virNetServerProgramPtr virNetServerProgramNew(unsigned program,
+virNetServerProgram *virNetServerProgramNew(unsigned program,
unsigned version,
- virNetServerProgramProcPtr procs,
+ virNetServerProgramProc *procs,
size_t nprocs)
{
- virNetServerProgramPtr prog;
+ virNetServerProgram *prog;
if (virNetServerProgramInitialize() < 0)
return NULL;
}
-int virNetServerProgramGetID(virNetServerProgramPtr prog)
+int virNetServerProgramGetID(virNetServerProgram *prog)
{
return prog->program;
}
-int virNetServerProgramGetVersion(virNetServerProgramPtr prog)
+int virNetServerProgramGetVersion(virNetServerProgram *prog)
{
return prog->version;
}
-int virNetServerProgramMatches(virNetServerProgramPtr prog,
- virNetMessagePtr msg)
+int virNetServerProgramMatches(virNetServerProgram *prog,
+ virNetMessage *msg)
{
if (prog->program == msg->header.prog &&
prog->version == msg->header.vers)
}
-static virNetServerProgramProcPtr virNetServerProgramGetProc(virNetServerProgramPtr prog,
+static virNetServerProgramProc *virNetServerProgramGetProc(virNetServerProgram *prog,
int procedure)
{
- virNetServerProgramProcPtr proc;
+ virNetServerProgramProc *proc;
if (procedure < 0)
return NULL;
}
unsigned int
-virNetServerProgramGetPriority(virNetServerProgramPtr prog,
+virNetServerProgramGetPriority(virNetServerProgram *prog,
int procedure)
{
- virNetServerProgramProcPtr proc = virNetServerProgramGetProc(prog, procedure);
+ virNetServerProgramProc *proc = virNetServerProgramGetProc(prog, procedure);
if (!proc)
return 0;
static int
virNetServerProgramSendError(unsigned program,
unsigned version,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
int procedure,
int type,
unsigned int serial)
* Returns 0 if the error was sent, -1 upon fatal error
*/
int
-virNetServerProgramSendReplyError(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
- virNetMessageHeaderPtr req)
+virNetServerProgramSendReplyError(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
+ struct virNetMessageHeader *req)
{
/*
* For data streams, errors are sent back as data streams
}
-int virNetServerProgramSendStreamError(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+int virNetServerProgramSendStreamError(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
int procedure,
unsigned int serial)
{
}
-int virNetServerProgramUnknownError(virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageHeaderPtr req)
+int virNetServerProgramUnknownError(virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageHeader *req)
{
virNetMessageError rerr;
static int
-virNetServerProgramDispatchCall(virNetServerProgramPtr prog,
- virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg);
+virNetServerProgramDispatchCall(virNetServerProgram *prog,
+ virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg);
/*
* @server: the unlocked server object
*
* Returns 0 if the message was dispatched, -1 upon fatal error
*/
-int virNetServerProgramDispatch(virNetServerProgramPtr prog,
- virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg)
+int virNetServerProgramDispatch(virNetServerProgram *prog,
+ virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg)
{
int ret = -1;
virNetMessageError rerr;
* Returns 0 if the reply was sent, or -1 upon fatal error
*/
static int
-virNetServerProgramDispatchCall(virNetServerProgramPtr prog,
- virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg)
+virNetServerProgramDispatchCall(virNetServerProgram *prog,
+ virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg)
{
g_autofree char *arg = NULL;
g_autofree char *ret = NULL;
int rv = -1;
- virNetServerProgramProcPtr dispatcher;
+ virNetServerProgramProc *dispatcher;
virNetMessageError rerr;
size_t i;
g_autoptr(virIdentity) identity = NULL;
}
-int virNetServerProgramSendStreamData(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
+int virNetServerProgramSendStreamData(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
int procedure,
unsigned int serial,
const char *data,
}
-int virNetServerProgramSendStreamHole(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
+int virNetServerProgramSendStreamHole(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
int procedure,
unsigned int serial,
long long length,
#include "virobject.h"
typedef struct _virNetDaemon virNetDaemon;
-typedef virNetDaemon *virNetDaemonPtr;
typedef struct _virNetServerService virNetServerService;
-typedef virNetServerService *virNetServerServicePtr;
typedef struct _virNetServerProgram virNetServerProgram;
-typedef virNetServerProgram *virNetServerProgramPtr;
typedef struct _virNetServerProgramProc virNetServerProgramProc;
-typedef virNetServerProgramProc *virNetServerProgramProcPtr;
-typedef int (*virNetServerProgramDispatchFunc)(virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+typedef int (*virNetServerProgramDispatchFunc)(virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
void *args,
void *ret);
unsigned int priority;
};
-virNetServerProgramPtr virNetServerProgramNew(unsigned program,
+virNetServerProgram *virNetServerProgramNew(unsigned program,
unsigned version,
- virNetServerProgramProcPtr procs,
+ virNetServerProgramProc *procs,
size_t nprocs);
-int virNetServerProgramGetID(virNetServerProgramPtr prog);
-int virNetServerProgramGetVersion(virNetServerProgramPtr prog);
+int virNetServerProgramGetID(virNetServerProgram *prog);
+int virNetServerProgramGetVersion(virNetServerProgram *prog);
-unsigned int virNetServerProgramGetPriority(virNetServerProgramPtr prog,
+unsigned int virNetServerProgramGetPriority(virNetServerProgram *prog,
int procedure);
-int virNetServerProgramMatches(virNetServerProgramPtr prog,
- virNetMessagePtr msg);
+int virNetServerProgramMatches(virNetServerProgram *prog,
+ virNetMessage *msg);
-int virNetServerProgramDispatch(virNetServerProgramPtr prog,
- virNetServerPtr server,
- virNetServerClientPtr client,
- virNetMessagePtr msg);
+int virNetServerProgramDispatch(virNetServerProgram *prog,
+ virNetServer *server,
+ virNetServerClient *client,
+ virNetMessage *msg);
-int virNetServerProgramSendReplyError(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
- virNetMessageHeaderPtr req);
+int virNetServerProgramSendReplyError(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
+ struct virNetMessageHeader *req);
-int virNetServerProgramSendStreamError(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageErrorPtr rerr,
+int virNetServerProgramSendStreamError(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageError *rerr,
int procedure,
unsigned int serial);
-int virNetServerProgramUnknownError(virNetServerClientPtr client,
- virNetMessagePtr msg,
- virNetMessageHeaderPtr req);
+int virNetServerProgramUnknownError(virNetServerClient *client,
+ virNetMessage *msg,
+ struct virNetMessageHeader *req);
-int virNetServerProgramSendStreamData(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
+int virNetServerProgramSendStreamData(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
int procedure,
unsigned int serial,
const char *data,
size_t len);
-int virNetServerProgramSendStreamHole(virNetServerProgramPtr prog,
- virNetServerClientPtr client,
- virNetMessagePtr msg,
+int virNetServerProgramSendStreamHole(virNetServerProgram *prog,
+ virNetServerClient *client,
+ virNetMessage *msg,
int procedure,
unsigned int serial,
long long length,
virObject parent;
size_t nsocks;
- virNetSocketPtr *socks;
+ virNetSocket **socks;
int auth;
bool readonly;
size_t nrequests_client_max;
- virNetTLSContextPtr tls;
+ virNetTLSContext *tls;
virNetServerServiceDispatchFunc dispatchFunc;
void *dispatchOpaque;
};
-static virClassPtr virNetServerServiceClass;
+static virClass *virNetServerServiceClass;
static void virNetServerServiceDispose(void *obj);
static int virNetServerServiceOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virNetServerService);
-static void virNetServerServiceAccept(virNetSocketPtr sock,
+static void virNetServerServiceAccept(virNetSocket *sock,
int events G_GNUC_UNUSED,
void *opaque)
{
- virNetServerServicePtr svc = opaque;
- virNetSocketPtr clientsock = NULL;
+ virNetServerService *svc = opaque;
+ virNetSocket *clientsock = NULL;
if (virNetSocketAccept(sock, &clientsock) < 0)
goto cleanup;
}
-static virNetServerServicePtr
-virNetServerServiceNewSocket(virNetSocketPtr *socks,
+static virNetServerService *
+virNetServerServiceNewSocket(virNetSocket **socks,
size_t nsocks,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc;
+ virNetServerService *svc;
size_t i;
if (virNetServerServiceInitialize() < 0)
if (!(svc = virObjectNew(virNetServerServiceClass)))
return NULL;
- svc->socks = g_new0(virNetSocketPtr, nsocks);
+ svc->socks = g_new0(virNetSocket *, nsocks);
svc->nsocks = nsocks;
for (i = 0; i < svc->nsocks; i++) {
svc->socks[i] = socks[i];
}
-virNetServerServicePtr virNetServerServiceNewTCP(const char *nodename,
+virNetServerService *virNetServerServiceNewTCP(const char *nodename,
const char *service,
int family,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc;
+ virNetServerService *svc;
size_t i;
- virNetSocketPtr *socks;
+ virNetSocket **socks;
size_t nsocks;
VIR_DEBUG("Creating new TCP server nodename='%s' service='%s'",
}
-virNetServerServicePtr virNetServerServiceNewUNIX(const char *path,
+virNetServerService *virNetServerServiceNewUNIX(const char *path,
mode_t mask,
gid_t grp,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc;
- virNetSocketPtr sock;
+ virNetServerService *svc;
+ virNetSocket *sock;
VIR_DEBUG("Creating new UNIX server path='%s' mask=%o gid=%u",
path, mask, grp);
return svc;
}
-virNetServerServicePtr virNetServerServiceNewFDs(int *fds,
+virNetServerService *virNetServerServiceNewFDs(int *fds,
size_t nfds,
bool unlinkUNIX,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max)
{
- virNetServerServicePtr svc = NULL;
- virNetSocketPtr *socks;
+ virNetServerService *svc = NULL;
+ virNetSocket **socks;
size_t i;
- socks = g_new0(virNetSocketPtr, nfds);
+ socks = g_new0(virNetSocket *, nfds);
for (i = 0; i < nfds; i++) {
if (virNetSocketNewListenFD(fds[i],
}
-virNetServerServicePtr virNetServerServiceNewPostExecRestart(virJSONValuePtr object)
+virNetServerService *virNetServerServiceNewPostExecRestart(virJSONValue *object)
{
- virNetServerServicePtr svc;
- virJSONValuePtr socks;
+ virNetServerService *svc;
+ virJSONValue *socks;
size_t i;
size_t n;
unsigned int max;
}
n = virJSONValueArraySize(socks);
- svc->socks = g_new0(virNetSocketPtr, n);
+ svc->socks = g_new0(virNetSocket *, n);
svc->nsocks = n;
for (i = 0; i < svc->nsocks; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(socks, i);
- virNetSocketPtr sock;
+ virJSONValue *child = virJSONValueArrayGet(socks, i);
+ virNetSocket *sock;
if (!(sock = virNetSocketNewPostExecRestart(child))) {
virObjectUnref(sock);
}
-virJSONValuePtr virNetServerServicePreExecRestart(virNetServerServicePtr svc)
+virJSONValue *virNetServerServicePreExecRestart(virNetServerService *svc)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) socks = virJSONValueNewArray();
}
-int virNetServerServiceGetPort(virNetServerServicePtr svc)
+int virNetServerServiceGetPort(virNetServerService *svc)
{
/* We're assuming if there are multiple sockets
* for IPv4 & 6, then they are all on same port */
}
-int virNetServerServiceGetAuth(virNetServerServicePtr svc)
+int virNetServerServiceGetAuth(virNetServerService *svc)
{
return svc->auth;
}
-bool virNetServerServiceIsReadonly(virNetServerServicePtr svc)
+bool virNetServerServiceIsReadonly(virNetServerService *svc)
{
return svc->readonly;
}
-size_t virNetServerServiceGetMaxRequests(virNetServerServicePtr svc)
+size_t virNetServerServiceGetMaxRequests(virNetServerService *svc)
{
return svc->nrequests_client_max;
}
-virNetTLSContextPtr virNetServerServiceGetTLSContext(virNetServerServicePtr svc)
+virNetTLSContext *virNetServerServiceGetTLSContext(virNetServerService *svc)
{
return svc->tls;
}
-void virNetServerServiceSetDispatcher(virNetServerServicePtr svc,
+void virNetServerServiceSetDispatcher(virNetServerService *svc,
virNetServerServiceDispatchFunc func,
void *opaque)
{
void virNetServerServiceDispose(void *obj)
{
- virNetServerServicePtr svc = obj;
+ virNetServerService *svc = obj;
size_t i;
for (i = 0; i < svc->nsocks; i++)
virObjectUnref(svc->tls);
}
-void virNetServerServiceToggle(virNetServerServicePtr svc,
+void virNetServerServiceToggle(virNetServerService *svc,
bool enabled)
{
size_t i;
0);
}
-void virNetServerServiceClose(virNetServerServicePtr svc)
+void virNetServerServiceClose(virNetServerService *svc)
{
size_t i;
VIR_NET_SERVER_SERVICE_AUTH_POLKIT,
} virNetServerServiceAuthMethods;
-typedef int (*virNetServerServiceDispatchFunc)(virNetServerServicePtr svc,
- virNetSocketPtr sock,
+typedef int (*virNetServerServiceDispatchFunc)(virNetServerService *svc,
+ virNetSocket *sock,
void *opaque);
-virNetServerServicePtr virNetServerServiceNewTCP(const char *nodename,
+virNetServerService *virNetServerServiceNewTCP(const char *nodename,
const char *service,
int family,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max);
-virNetServerServicePtr virNetServerServiceNewUNIX(const char *path,
+virNetServerService *virNetServerServiceNewUNIX(const char *path,
mode_t mask,
gid_t grp,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max);
-virNetServerServicePtr virNetServerServiceNewFDs(int *fd,
+virNetServerService *virNetServerServiceNewFDs(int *fd,
size_t nfds,
bool unlinkUNIX,
int auth,
- virNetTLSContextPtr tls,
+ virNetTLSContext *tls,
bool readonly,
size_t max_queued_clients,
size_t nrequests_client_max);
-virNetServerServicePtr virNetServerServiceNewPostExecRestart(virJSONValuePtr object);
+virNetServerService *virNetServerServiceNewPostExecRestart(virJSONValue *object);
-virJSONValuePtr virNetServerServicePreExecRestart(virNetServerServicePtr service);
+virJSONValue *virNetServerServicePreExecRestart(virNetServerService *service);
-int virNetServerServiceGetPort(virNetServerServicePtr svc);
+int virNetServerServiceGetPort(virNetServerService *svc);
-int virNetServerServiceGetAuth(virNetServerServicePtr svc);
-bool virNetServerServiceIsReadonly(virNetServerServicePtr svc);
-size_t virNetServerServiceGetMaxRequests(virNetServerServicePtr svc);
-virNetTLSContextPtr virNetServerServiceGetTLSContext(virNetServerServicePtr svc);
+int virNetServerServiceGetAuth(virNetServerService *svc);
+bool virNetServerServiceIsReadonly(virNetServerService *svc);
+size_t virNetServerServiceGetMaxRequests(virNetServerService *svc);
+virNetTLSContext *virNetServerServiceGetTLSContext(virNetServerService *svc);
-void virNetServerServiceSetDispatcher(virNetServerServicePtr svc,
+void virNetServerServiceSetDispatcher(virNetServerService *svc,
virNetServerServiceDispatchFunc func,
void *opaque);
-void virNetServerServiceToggle(virNetServerServicePtr svc,
+void virNetServerServiceToggle(virNetServerService *svc,
bool enabled);
-void virNetServerServiceClose(virNetServerServicePtr svc);
+void virNetServerServiceClose(virNetServerService *svc);
char *remoteAddrStrSASL;
char *remoteAddrStrURI;
- virNetTLSSessionPtr tlsSession;
+ virNetTLSSession *tlsSession;
#if WITH_SASL
- virNetSASLSessionPtr saslSession;
+ virNetSASLSession *saslSession;
const char *saslDecoded;
size_t saslDecodedLength;
size_t saslEncodedOffset;
#endif
#if WITH_SSH2
- virNetSSHSessionPtr sshSession;
+ virNetSSHSession *sshSession;
#endif
#if WITH_LIBSSH
- virNetLibsshSessionPtr libsshSession;
+ virNetLibsshSession *libsshSession;
#endif
};
-static virClassPtr virNetSocketClass;
+static virClass *virNetSocketClass;
static void virNetSocketDispose(void *obj);
static int virNetSocketOnceInit(void)
static int virNetSocketForkDaemon(const char *binary)
{
int ret;
- virCommandPtr cmd = virCommandNewArgList(binary,
+ virCommand *cmd = virCommandNewArgList(binary,
"--timeout=120",
NULL);
}
-static virNetSocketPtr
-virNetSocketNew(virSocketAddrPtr localAddr,
- virSocketAddrPtr remoteAddr,
+static virNetSocket *
+virNetSocketNew(virSocketAddr *localAddr,
+ virSocketAddr *remoteAddr,
bool isClient,
int fd,
int errfd,
pid_t pid,
bool unlinkUNIX)
{
- virNetSocketPtr sock;
+ virNetSocket *sock;
int no_slow_start = 1;
if (virNetSocketInitialize() < 0)
int virNetSocketNewListenTCP(const char *nodename,
const char *service,
int family,
- virNetSocketPtr **retsocks,
+ virNetSocket ***retsocks,
size_t *nretsocks)
{
- virNetSocketPtr *socks = NULL;
+ virNetSocket **socks = NULL;
size_t nsocks = 0;
struct addrinfo *ai = NULL;
struct addrinfo hints;
mode_t mask,
uid_t user,
gid_t grp,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
virSocketAddr addr;
mode_t oldmask;
mode_t mask G_GNUC_UNUSED,
uid_t user G_GNUC_UNUSED,
gid_t grp G_GNUC_UNUSED,
- virNetSocketPtr *retsock G_GNUC_UNUSED)
+ virNetSocket **retsock G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("UNIX sockets are not supported on this platform"));
int virNetSocketNewListenFD(int fd,
bool unlinkUNIX,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
virSocketAddr addr;
*retsock = NULL;
int virNetSocketNewConnectTCP(const char *nodename,
const char *service,
int family,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
struct addrinfo *ai = NULL;
struct addrinfo hints;
int virNetSocketNewConnectUNIX(const char *path,
bool spawnDaemon,
const char *binary,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
char *lockpath = NULL;
int lockfd = -1;
int virNetSocketNewConnectUNIX(const char *path G_GNUC_UNUSED,
bool spawnDaemon G_GNUC_UNUSED,
const char *binary G_GNUC_UNUSED,
- virNetSocketPtr *retsock G_GNUC_UNUSED)
+ virNetSocket **retsock G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("UNIX sockets are not supported on this platform"));
#ifndef WIN32
-int virNetSocketNewConnectCommand(virCommandPtr cmd,
- virNetSocketPtr *retsock)
+int virNetSocketNewConnectCommand(virCommand *cmd,
+ virNetSocket **retsock)
{
pid_t pid = 0;
int sv[2] = { -1, -1 };
return -1;
}
#else
-int virNetSocketNewConnectCommand(virCommandPtr cmd G_GNUC_UNUSED,
- virNetSocketPtr *retsock G_GNUC_UNUSED)
+int virNetSocketNewConnectCommand(virCommand *cmd G_GNUC_UNUSED,
+ virNetSocket **retsock G_GNUC_UNUSED)
{
virReportSystemError(errno, "%s",
_("Tunnelling sockets not supported on this platform"));
bool noVerify,
const char *keyfile,
const char *command,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
- virCommandPtr cmd;
+ virCommand *cmd;
*retsock = NULL;
const char *authMethods,
const char *command,
virConnectAuthPtr auth,
- virURIPtr uri,
- virNetSocketPtr *retsock)
+ virURI *uri,
+ virNetSocket **retsock)
{
- virNetSocketPtr sock = NULL;
- virNetSSHSessionPtr sess = NULL;
+ virNetSocket *sock = NULL;
+ virNetSSHSession *sess = NULL;
unsigned int verify;
int ret = -1;
int portN;
const char *authMethods G_GNUC_UNUSED,
const char *command G_GNUC_UNUSED,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virURIPtr uri G_GNUC_UNUSED,
- virNetSocketPtr *retsock G_GNUC_UNUSED)
+ virURI *uri G_GNUC_UNUSED,
+ virNetSocket **retsock G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("libssh2 transport support was not enabled"));
const char *authMethods,
const char *command,
virConnectAuthPtr auth,
- virURIPtr uri,
- virNetSocketPtr *retsock)
+ virURI *uri,
+ virNetSocket **retsock)
{
- virNetSocketPtr sock = NULL;
- virNetLibsshSessionPtr sess = NULL;
+ virNetSocket *sock = NULL;
+ virNetLibsshSession *sess = NULL;
unsigned int verify;
int ret = -1;
int portN;
const char *authMethods G_GNUC_UNUSED,
const char *command G_GNUC_UNUSED,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virURIPtr uri G_GNUC_UNUSED,
- virNetSocketPtr *retsock G_GNUC_UNUSED)
+ virURI *uri G_GNUC_UNUSED,
+ virNetSocket **retsock G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("libssh transport support was not enabled"));
#endif /* WITH_LIBSSH */
int virNetSocketNewConnectExternal(const char **cmdargv,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
- virCommandPtr cmd;
+ virCommand *cmd;
*retsock = NULL;
int virNetSocketNewConnectSockFD(int sockfd,
- virNetSocketPtr *retsock)
+ virNetSocket **retsock)
{
virSocketAddr localAddr;
}
-virNetSocketPtr virNetSocketNewPostExecRestart(virJSONValuePtr object)
+virNetSocket *virNetSocketNewPostExecRestart(virJSONValue *object)
{
virSocketAddr localAddr;
virSocketAddr remoteAddr;
}
-virJSONValuePtr virNetSocketPreExecRestart(virNetSocketPtr sock)
+virJSONValue *virNetSocketPreExecRestart(virNetSocket *sock)
{
- virJSONValuePtr object = NULL;
+ virJSONValue *object = NULL;
virObjectLock(sock);
void virNetSocketDispose(void *obj)
{
- virNetSocketPtr sock = obj;
+ virNetSocket *sock = obj;
PROBE(RPC_SOCKET_DISPOSE,
"sock=%p", sock);
}
-int virNetSocketGetFD(virNetSocketPtr sock)
+int virNetSocketGetFD(virNetSocket *sock)
{
int fd;
virObjectLock(sock);
return fd;
}
-int virNetSocketDupFD(virNetSocketPtr sock, bool cloexec)
+int virNetSocketDupFD(virNetSocket *sock, bool cloexec)
{
int fd;
}
-bool virNetSocketIsLocal(virNetSocketPtr sock)
+bool virNetSocketIsLocal(virNetSocket *sock)
{
bool isLocal = false;
virObjectLock(sock);
}
-bool virNetSocketHasPassFD(virNetSocketPtr sock)
+bool virNetSocketHasPassFD(virNetSocket *sock)
{
bool hasPassFD = false;
virObjectLock(sock);
return hasPassFD;
}
-char *virNetSocketGetPath(virNetSocketPtr sock)
+char *virNetSocketGetPath(virNetSocket *sock)
{
char *path = NULL;
virObjectLock(sock);
return path;
}
-int virNetSocketGetPort(virNetSocketPtr sock)
+int virNetSocketGetPort(virNetSocket *sock)
{
int port;
virObjectLock(sock);
#if defined(SO_PEERCRED)
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock,
+int virNetSocketGetUNIXIdentity(virNetSocket *sock,
uid_t *uid,
gid_t *gid,
pid_t *pid,
# define VIR_SOL_PEERCRED 0
# endif
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock,
+int virNetSocketGetUNIXIdentity(virNetSocket *sock,
uid_t *uid,
gid_t *gid,
pid_t *pid,
return ret;
}
#else
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock G_GNUC_UNUSED,
+int virNetSocketGetUNIXIdentity(virNetSocket *sock G_GNUC_UNUSED,
uid_t *uid G_GNUC_UNUSED,
gid_t *gid G_GNUC_UNUSED,
pid_t *pid G_GNUC_UNUSED,
#endif
#ifdef WITH_SELINUX
-int virNetSocketGetSELinuxContext(virNetSocketPtr sock,
+int virNetSocketGetSELinuxContext(virNetSocket *sock,
char **context)
{
char *seccon = NULL;
return ret;
}
#else
-int virNetSocketGetSELinuxContext(virNetSocketPtr sock G_GNUC_UNUSED,
+int virNetSocketGetSELinuxContext(virNetSocket *sock G_GNUC_UNUSED,
char **context)
{
*context = NULL;
#endif
-int virNetSocketSetBlocking(virNetSocketPtr sock,
+int virNetSocketSetBlocking(virNetSocket *sock,
bool blocking)
{
int ret;
}
-const char *virNetSocketLocalAddrStringSASL(virNetSocketPtr sock)
+const char *virNetSocketLocalAddrStringSASL(virNetSocket *sock)
{
return sock->localAddrStrSASL;
}
-const char *virNetSocketRemoteAddrStringSASL(virNetSocketPtr sock)
+const char *virNetSocketRemoteAddrStringSASL(virNetSocket *sock)
{
return sock->remoteAddrStrSASL;
}
-const char *virNetSocketRemoteAddrStringURI(virNetSocketPtr sock)
+const char *virNetSocketRemoteAddrStringURI(virNetSocket *sock)
{
return sock->remoteAddrStrURI;
}
size_t len,
void *opaque)
{
- virNetSocketPtr sock = opaque;
+ virNetSocket *sock = opaque;
return write(sock->fd, buf, len);
}
size_t len,
void *opaque)
{
- virNetSocketPtr sock = opaque;
+ virNetSocket *sock = opaque;
return read(sock->fd, buf, len);
}
-void virNetSocketSetTLSSession(virNetSocketPtr sock,
- virNetTLSSessionPtr sess)
+void virNetSocketSetTLSSession(virNetSocket *sock,
+ virNetTLSSession *sess)
{
virObjectLock(sock);
virObjectUnref(sock->tlsSession);
}
#if WITH_SASL
-void virNetSocketSetSASLSession(virNetSocketPtr sock,
- virNetSASLSessionPtr sess)
+void virNetSocketSetSASLSession(virNetSocket *sock,
+ virNetSASLSession *sess)
{
virObjectLock(sock);
virObjectUnref(sock->saslSession);
#endif
-bool virNetSocketHasCachedData(virNetSocketPtr sock G_GNUC_UNUSED)
+bool virNetSocketHasCachedData(virNetSocket *sock G_GNUC_UNUSED)
{
bool hasCached = false;
virObjectLock(sock);
}
#if WITH_SSH2
-static ssize_t virNetSocketLibSSH2Read(virNetSocketPtr sock,
+static ssize_t virNetSocketLibSSH2Read(virNetSocket *sock,
char *buf,
size_t len)
{
return virNetSSHChannelRead(sock->sshSession, buf, len);
}
-static ssize_t virNetSocketLibSSH2Write(virNetSocketPtr sock,
+static ssize_t virNetSocketLibSSH2Write(virNetSocket *sock,
const char *buf,
size_t len)
{
#endif
#if WITH_LIBSSH
-static ssize_t virNetSocketLibsshRead(virNetSocketPtr sock,
+static ssize_t virNetSocketLibsshRead(virNetSocket *sock,
char *buf,
size_t len)
{
return virNetLibsshChannelRead(sock->libsshSession, buf, len);
}
-static ssize_t virNetSocketLibsshWrite(virNetSocketPtr sock,
+static ssize_t virNetSocketLibsshWrite(virNetSocket *sock,
const char *buf,
size_t len)
{
}
#endif
-bool virNetSocketHasPendingData(virNetSocketPtr sock G_GNUC_UNUSED)
+bool virNetSocketHasPendingData(virNetSocket *sock G_GNUC_UNUSED)
{
bool hasPending = false;
virObjectLock(sock);
}
-static ssize_t virNetSocketReadWire(virNetSocketPtr sock, char *buf, size_t len)
+static ssize_t virNetSocketReadWire(virNetSocket *sock, char *buf, size_t len)
{
char *errout = NULL;
ssize_t ret;
return ret;
}
-static ssize_t virNetSocketWriteWire(virNetSocketPtr sock, const char *buf, size_t len)
+static ssize_t virNetSocketWriteWire(virNetSocket *sock, const char *buf, size_t len)
{
ssize_t ret;
#if WITH_SASL
-static ssize_t virNetSocketReadSASL(virNetSocketPtr sock, char *buf, size_t len)
+static ssize_t virNetSocketReadSASL(virNetSocket *sock, char *buf, size_t len)
{
ssize_t got;
}
-static ssize_t virNetSocketWriteSASL(virNetSocketPtr sock, const char *buf, size_t len)
+static ssize_t virNetSocketWriteSASL(virNetSocket *sock, const char *buf, size_t len)
{
int ret;
size_t tosend = virNetSASLSessionGetMaxBufSize(sock->saslSession);
}
#endif
-ssize_t virNetSocketRead(virNetSocketPtr sock, char *buf, size_t len)
+ssize_t virNetSocketRead(virNetSocket *sock, char *buf, size_t len)
{
ssize_t ret;
virObjectLock(sock);
return ret;
}
-ssize_t virNetSocketWrite(virNetSocketPtr sock, const char *buf, size_t len)
+ssize_t virNetSocketWrite(virNetSocket *sock, const char *buf, size_t len)
{
ssize_t ret;
/*
* Returns 1 if an FD was sent, 0 if it would block, -1 on error
*/
-int virNetSocketSendFD(virNetSocketPtr sock, int fd)
+int virNetSocketSendFD(virNetSocket *sock, int fd)
{
int ret = -1;
if (!virNetSocketHasPassFD(sock)) {
/*
* Returns 1 if an FD was read, 0 if it would block, -1 on error
*/
-int virNetSocketRecvFD(virNetSocketPtr sock, int *fd)
+int virNetSocketRecvFD(virNetSocket *sock, int *fd)
{
int ret = -1;
}
-int virNetSocketListen(virNetSocketPtr sock, int backlog)
+int virNetSocketListen(virNetSocket *sock, int backlog)
{
virObjectLock(sock);
if (listen(sock->fd, backlog > 0 ? backlog : 30) < 0) {
return 0;
}
-int virNetSocketAccept(virNetSocketPtr sock, virNetSocketPtr *clientsock)
+int virNetSocketAccept(virNetSocket *sock, virNetSocket **clientsock)
{
int fd = -1;
virSocketAddr localAddr;
int events,
void *opaque)
{
- virNetSocketPtr sock = opaque;
+ virNetSocket *sock = opaque;
virNetSocketIOFunc func;
void *eopaque;
static void virNetSocketEventFree(void *opaque)
{
- virNetSocketPtr sock = opaque;
+ virNetSocket *sock = opaque;
virFreeCallback ff;
void *eopaque;
virObjectUnref(sock);
}
-int virNetSocketAddIOCallback(virNetSocketPtr sock,
+int virNetSocketAddIOCallback(virNetSocket *sock,
int events,
virNetSocketIOFunc func,
void *opaque,
return ret;
}
-void virNetSocketUpdateIOCallback(virNetSocketPtr sock,
+void virNetSocketUpdateIOCallback(virNetSocket *sock,
int events)
{
virObjectLock(sock);
virObjectUnlock(sock);
}
-void virNetSocketRemoveIOCallback(virNetSocketPtr sock)
+void virNetSocketRemoveIOCallback(virNetSocket *sock)
{
virObjectLock(sock);
virObjectUnlock(sock);
}
-void virNetSocketClose(virNetSocketPtr sock)
+void virNetSocketClose(virNetSocket *sock)
{
if (!sock)
return;
* reading data.
*/
void
-virNetSocketSetQuietEOF(virNetSocketPtr sock)
+virNetSocketSetQuietEOF(virNetSocket *sock)
{
sock->quietEOF = true;
}
#include "viruri.h"
typedef struct _virNetSocket virNetSocket;
-typedef virNetSocket *virNetSocketPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetSocket, virObjectUnref);
-typedef void (*virNetSocketIOFunc)(virNetSocketPtr sock,
+typedef void (*virNetSocketIOFunc)(virNetSocket *sock,
int events,
void *opaque);
int virNetSocketNewListenTCP(const char *nodename,
const char *service,
int family,
- virNetSocketPtr **addrs,
+ virNetSocket ***addrs,
size_t *naddrs);
int virNetSocketNewListenUNIX(const char *path,
mode_t mask,
uid_t user,
gid_t grp,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
int virNetSocketNewListenFD(int fd,
bool unlinkUNIX,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
int virNetSocketNewConnectTCP(const char *nodename,
const char *service,
int family,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
int virNetSocketNewConnectUNIX(const char *path,
bool spawnDaemon,
const char *binary,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
-int virNetSocketNewConnectCommand(virCommandPtr cmd,
- virNetSocketPtr *retsock);
+int virNetSocketNewConnectCommand(virCommand *cmd,
+ virNetSocket **retsock);
int virNetSocketNewConnectSSH(const char *nodename,
const char *service,
bool noVerify,
const char *keyfile,
const char *command,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
int virNetSocketNewConnectLibSSH2(const char *host,
const char *port,
const char *authMethods,
const char *command,
virConnectAuthPtr auth,
- virURIPtr uri,
- virNetSocketPtr *retsock);
+ virURI *uri,
+ virNetSocket **retsock);
int virNetSocketNewConnectLibssh(const char *host,
const char *port,
const char *authMethods,
const char *command,
virConnectAuthPtr auth,
- virURIPtr uri,
- virNetSocketPtr *retsock);
+ virURI *uri,
+ virNetSocket **retsock);
int virNetSocketNewConnectExternal(const char **cmdargv,
- virNetSocketPtr *addr);
+ virNetSocket **addr);
int virNetSocketNewConnectSockFD(int sockfd,
- virNetSocketPtr *retsock);
+ virNetSocket **retsock);
-virNetSocketPtr virNetSocketNewPostExecRestart(virJSONValuePtr object);
+virNetSocket *virNetSocketNewPostExecRestart(virJSONValue *object);
-virJSONValuePtr virNetSocketPreExecRestart(virNetSocketPtr sock);
+virJSONValue *virNetSocketPreExecRestart(virNetSocket *sock);
-int virNetSocketGetFD(virNetSocketPtr sock);
-int virNetSocketDupFD(virNetSocketPtr sock, bool cloexec);
+int virNetSocketGetFD(virNetSocket *sock);
+int virNetSocketDupFD(virNetSocket *sock, bool cloexec);
-bool virNetSocketIsLocal(virNetSocketPtr sock);
+bool virNetSocketIsLocal(virNetSocket *sock);
-bool virNetSocketHasPassFD(virNetSocketPtr sock);
+bool virNetSocketHasPassFD(virNetSocket *sock);
-char *virNetSocketGetPath(virNetSocketPtr sock);
-int virNetSocketGetPort(virNetSocketPtr sock);
+char *virNetSocketGetPath(virNetSocket *sock);
+int virNetSocketGetPort(virNetSocket *sock);
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock,
+int virNetSocketGetUNIXIdentity(virNetSocket *sock,
uid_t *uid,
gid_t *gid,
pid_t *pid,
unsigned long long *timestamp)
G_GNUC_NO_INLINE;
-int virNetSocketGetSELinuxContext(virNetSocketPtr sock,
+int virNetSocketGetSELinuxContext(virNetSocket *sock,
char **context)
G_GNUC_NO_INLINE;
-int virNetSocketSetBlocking(virNetSocketPtr sock,
+int virNetSocketSetBlocking(virNetSocket *sock,
bool blocking);
-void virNetSocketSetQuietEOF(virNetSocketPtr sock);
+void virNetSocketSetQuietEOF(virNetSocket *sock);
-ssize_t virNetSocketRead(virNetSocketPtr sock, char *buf, size_t len);
-ssize_t virNetSocketWrite(virNetSocketPtr sock, const char *buf, size_t len);
+ssize_t virNetSocketRead(virNetSocket *sock, char *buf, size_t len);
+ssize_t virNetSocketWrite(virNetSocket *sock, const char *buf, size_t len);
-int virNetSocketSendFD(virNetSocketPtr sock, int fd);
-int virNetSocketRecvFD(virNetSocketPtr sock, int *fd);
+int virNetSocketSendFD(virNetSocket *sock, int fd);
+int virNetSocketRecvFD(virNetSocket *sock, int *fd);
-void virNetSocketSetTLSSession(virNetSocketPtr sock,
- virNetTLSSessionPtr sess);
+void virNetSocketSetTLSSession(virNetSocket *sock,
+ virNetTLSSession *sess);
#ifdef WITH_SASL
-void virNetSocketSetSASLSession(virNetSocketPtr sock,
- virNetSASLSessionPtr sess);
+void virNetSocketSetSASLSession(virNetSocket *sock,
+ virNetSASLSession *sess);
#endif
-bool virNetSocketHasCachedData(virNetSocketPtr sock);
-bool virNetSocketHasPendingData(virNetSocketPtr sock);
+bool virNetSocketHasCachedData(virNetSocket *sock);
+bool virNetSocketHasPendingData(virNetSocket *sock);
-const char *virNetSocketLocalAddrStringSASL(virNetSocketPtr sock);
-const char *virNetSocketRemoteAddrStringSASL(virNetSocketPtr sock);
-const char *virNetSocketRemoteAddrStringURI(virNetSocketPtr sock);
+const char *virNetSocketLocalAddrStringSASL(virNetSocket *sock);
+const char *virNetSocketRemoteAddrStringSASL(virNetSocket *sock);
+const char *virNetSocketRemoteAddrStringURI(virNetSocket *sock);
-int virNetSocketListen(virNetSocketPtr sock, int backlog);
-int virNetSocketAccept(virNetSocketPtr sock,
- virNetSocketPtr *clientsock);
+int virNetSocketListen(virNetSocket *sock, int backlog);
+int virNetSocketAccept(virNetSocket *sock,
+ virNetSocket **clientsock);
-int virNetSocketAddIOCallback(virNetSocketPtr sock,
+int virNetSocketAddIOCallback(virNetSocket *sock,
int events,
virNetSocketIOFunc func,
void *opaque,
virFreeCallback ff);
-void virNetSocketUpdateIOCallback(virNetSocketPtr sock,
+void virNetSocketUpdateIOCallback(virNetSocket *sock,
int events);
-void virNetSocketRemoveIOCallback(virNetSocketPtr sock);
+void virNetSocketRemoveIOCallback(virNetSocket *sock);
-void virNetSocketClose(virNetSocketPtr sock);
+void virNetSocketClose(virNetSocket *sock);
typedef struct _virNetSSHAuthMethod virNetSSHAuthMethod;
-typedef virNetSSHAuthMethod *virNetSSHAuthMethodPtr;
struct _virNetSSHAuthMethod {
virNetSSHAuthMethods method;
char *authPath;
virNetSSHAuthCallbackError authCbErr;
size_t nauths;
- virNetSSHAuthMethodPtr *auths;
+ virNetSSHAuthMethod **auths;
/* channel stuff */
char *channelCommand;
};
static void
-virNetSSHSessionAuthMethodsClear(virNetSSHSessionPtr sess)
+virNetSSHSessionAuthMethodsClear(virNetSSHSession *sess)
{
size_t i;
static void
virNetSSHSessionDispose(void *obj)
{
- virNetSSHSessionPtr sess = obj;
+ virNetSSHSession *sess = obj;
VIR_DEBUG("sess=0x%p", sess);
if (sess->channel) {
g_free(sess->authPath);
}
-static virClassPtr virNetSSHSessionClass;
+static virClass *virNetSSHSessionClass;
static int
virNetSSHSessionOnceInit(void)
{
}
VIR_ONCE_GLOBAL_INIT(virNetSSHSession);
-static virNetSSHAuthMethodPtr
-virNetSSHSessionAuthMethodNew(virNetSSHSessionPtr sess)
+static virNetSSHAuthMethod *
+virNetSSHSessionAuthMethodNew(virNetSSHSession *sess)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
auth = g_new0(virNetSSHAuthMethod, 1);
LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
void **opaque)
{
- virNetSSHSessionPtr priv = *opaque;
+ virNetSSHSession *priv = *opaque;
virConnectCredentialPtr askcred = NULL;
size_t i;
int credtype_echo = -1;
* return value: 0 on success, -1 on error
*/
static int
-virNetSSHCheckHostKey(virNetSSHSessionPtr sess)
+virNetSSHCheckHostKey(virNetSSHSession *sess)
{
int ret;
const char *key;
* -1 on error
*/
static int
-virNetSSHAuthenticateAgent(virNetSSHSessionPtr sess,
- virNetSSHAuthMethodPtr priv)
+virNetSSHAuthenticateAgent(virNetSSHSession *sess,
+ virNetSSHAuthMethod *priv)
{
struct libssh2_agent_publickey *agent_identity = NULL;
bool no_identity = true;
* -1 on error
*/
static int
-virNetSSHAuthenticatePrivkey(virNetSSHSessionPtr sess,
- virNetSSHAuthMethodPtr priv)
+virNetSSHAuthenticatePrivkey(virNetSSHSession *sess,
+ virNetSSHAuthMethod *priv)
{
virConnectCredential retr_passphrase;
size_t i;
* -1 on error
*/
static int
-virNetSSHAuthenticatePassword(virNetSSHSessionPtr sess,
- virNetSSHAuthMethodPtr priv)
+virNetSSHAuthenticatePassword(virNetSSHSession *sess,
+ virNetSSHAuthMethod *priv)
{
char *password = NULL;
char *errmsg;
* -1 on error
*/
static int
-virNetSSHAuthenticateKeyboardInteractive(virNetSSHSessionPtr sess,
- virNetSSHAuthMethodPtr priv)
+virNetSSHAuthenticateKeyboardInteractive(virNetSSHSession *sess,
+ virNetSSHAuthMethod *priv)
{
char *errmsg;
int ret;
/* select auth method and authenticate */
static int
-virNetSSHAuthenticate(virNetSSHSessionPtr sess)
+virNetSSHAuthenticate(virNetSSHSession *sess)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
bool no_method = false;
bool auth_failed = false;
char *auth_list;
/* open channel */
static int
-virNetSSHOpenChannel(virNetSSHSessionPtr sess)
+virNetSSHOpenChannel(virNetSSHSession *sess)
{
char *errmsg;
/* validate if all required parameters are configured */
static int
-virNetSSHValidateConfig(virNetSSHSessionPtr sess)
+virNetSSHValidateConfig(virNetSSHSession *sess)
{
if (sess->nauths == 0) {
virReportError(VIR_ERR_SSH, "%s",
/* ### PUBLIC API ### */
int
-virNetSSHSessionAuthSetCallback(virNetSSHSessionPtr sess,
+virNetSSHSessionAuthSetCallback(virNetSSHSession *sess,
virConnectAuthPtr auth)
{
virObjectLock(sess);
}
void
-virNetSSHSessionAuthReset(virNetSSHSessionPtr sess)
+virNetSSHSessionAuthReset(virNetSSHSession *sess)
{
virObjectLock(sess);
virNetSSHSessionAuthMethodsClear(sess);
}
int
-virNetSSHSessionAuthAddPasswordAuth(virNetSSHSessionPtr sess,
- virURIPtr uri,
+virNetSSHSessionAuthAddPasswordAuth(virNetSSHSession *sess,
+ virURI *uri,
const char *username)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
char *user = NULL;
if (uri) {
}
int
-virNetSSHSessionAuthAddAgentAuth(virNetSSHSessionPtr sess,
+virNetSSHSessionAuthAddAgentAuth(virNetSSHSession *sess,
const char *username)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
char *user = NULL;
if (!username) {
}
int
-virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSessionPtr sess,
+virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSession *sess,
const char *username,
const char *keyfile,
const char *password)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
char *user = NULL;
char *pass = NULL;
}
int
-virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSessionPtr sess,
+virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSession *sess,
const char *username,
int tries)
{
- virNetSSHAuthMethodPtr auth;
+ virNetSSHAuthMethod *auth;
char *user = NULL;
if (!username) {
}
void
-virNetSSHSessionSetChannelCommand(virNetSSHSessionPtr sess,
+virNetSSHSessionSetChannelCommand(virNetSSHSession *sess,
const char *command)
{
virObjectLock(sess);
}
int
-virNetSSHSessionSetHostKeyVerification(virNetSSHSessionPtr sess,
+virNetSSHSessionSetHostKeyVerification(virNetSSHSession *sess,
const char *hostname,
int port,
const char *hostsfile,
}
/* allocate and initialize a ssh session object */
-virNetSSHSessionPtr virNetSSHSessionNew(void)
+virNetSSHSession *virNetSSHSessionNew(void)
{
- virNetSSHSessionPtr sess = NULL;
+ virNetSSHSession *sess = NULL;
if (virNetSSHSessionInitialize() < 0)
goto error;
goto error;
}
- VIR_DEBUG("virNetSSHSessionPtr: %p, LIBSSH2_SESSION: %p",
+ VIR_DEBUG("virNetSSHSession *: %p, LIBSSH2_SESSION: %p",
sess, sess->session);
/* set blocking mode for libssh2 until handshake is complete */
}
int
-virNetSSHSessionConnect(virNetSSHSessionPtr sess,
+virNetSSHSessionConnect(virNetSSHSession *sess,
int sock)
{
int ret;
if (!sess || sess->state != VIR_NET_SSH_STATE_NEW) {
virReportError(VIR_ERR_SSH, "%s",
- _("Invalid virNetSSHSessionPtr"));
+ _("Invalid virNetSSHSession *"));
return -1;
}
/* do a read from a ssh channel, used instead of normal read on socket */
ssize_t
-virNetSSHChannelRead(virNetSSHSessionPtr sess,
+virNetSSHChannelRead(virNetSSHSession *sess,
char *buf,
size_t len)
{
}
ssize_t
-virNetSSHChannelWrite(virNetSSHSessionPtr sess,
+virNetSSHChannelWrite(virNetSSHSession *sess,
const char *buf,
size_t len)
{
}
bool
-virNetSSHSessionHasCachedData(virNetSSHSessionPtr sess)
+virNetSSHSessionHasCachedData(virNetSSHSession *sess)
{
bool ret;
#include "viruri.h"
typedef struct _virNetSSHSession virNetSSHSession;
-typedef virNetSSHSession *virNetSSHSessionPtr;
-virNetSSHSessionPtr virNetSSHSessionNew(void);
-void virNetSSHSessionFree(virNetSSHSessionPtr sess);
+virNetSSHSession *virNetSSHSessionNew(void);
+void virNetSSHSessionFree(virNetSSHSession *sess);
typedef enum {
VIR_NET_SSH_HOSTKEY_VERIFY_NORMAL,
VIR_NET_SSH_HOSTKEY_FILE_CREATE = 1 << 1,
} virNetSSHHostKeyFileFlags;
-void virNetSSHSessionSetChannelCommand(virNetSSHSessionPtr sess,
+void virNetSSHSessionSetChannelCommand(virNetSSHSession *sess,
const char *command);
-void virNetSSHSessionAuthReset(virNetSSHSessionPtr sess);
+void virNetSSHSessionAuthReset(virNetSSHSession *sess);
-int virNetSSHSessionAuthSetCallback(virNetSSHSessionPtr sess,
+int virNetSSHSessionAuthSetCallback(virNetSSHSession *sess,
virConnectAuthPtr auth);
-int virNetSSHSessionAuthAddPasswordAuth(virNetSSHSessionPtr sess,
- virURIPtr uri,
+int virNetSSHSessionAuthAddPasswordAuth(virNetSSHSession *sess,
+ virURI *uri,
const char *username);
-int virNetSSHSessionAuthAddAgentAuth(virNetSSHSessionPtr sess,
+int virNetSSHSessionAuthAddAgentAuth(virNetSSHSession *sess,
const char *username);
-int virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSessionPtr sess,
+int virNetSSHSessionAuthAddPrivKeyAuth(virNetSSHSession *sess,
const char *username,
const char *keyfile,
const char *password);
-int virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSessionPtr sess,
+int virNetSSHSessionAuthAddKeyboardAuth(virNetSSHSession *sess,
const char *username,
int tries);
-int virNetSSHSessionSetHostKeyVerification(virNetSSHSessionPtr sess,
+int virNetSSHSessionSetHostKeyVerification(virNetSSHSession *sess,
const char *hostname,
int port,
const char *hostsfile,
virNetSSHHostkeyVerify opt,
unsigned int flags);
-int virNetSSHSessionConnect(virNetSSHSessionPtr sess,
+int virNetSSHSessionConnect(virNetSSHSession *sess,
int sock);
-ssize_t virNetSSHChannelRead(virNetSSHSessionPtr sess,
+ssize_t virNetSSHChannelRead(virNetSSHSession *sess,
char *buf,
size_t len);
-ssize_t virNetSSHChannelWrite(virNetSSHSessionPtr sess,
+ssize_t virNetSSHChannelWrite(virNetSSHSession *sess,
const char *buf,
size_t len);
-bool virNetSSHSessionHasCachedData(virNetSSHSessionPtr sess);
+bool virNetSSHSessionHasCachedData(virNetSSHSession *sess);
char *x509dname;
};
-static virClassPtr virNetTLSContextClass;
-static virClassPtr virNetTLSSessionClass;
+static virClass *virNetTLSContextClass;
+static virClass *virNetTLSSessionClass;
static void virNetTLSContextDispose(void *obj);
static void virNetTLSSessionDispose(void *obj);
}
-static int virNetTLSContextLoadCredentials(virNetTLSContextPtr ctxt,
+static int virNetTLSContextLoadCredentials(virNetTLSContext *ctxt,
bool isServer,
const char *cacert,
const char *cacrl,
}
-static virNetTLSContextPtr virNetTLSContextNew(const char *cacert,
+static virNetTLSContext *virNetTLSContextNew(const char *cacert,
const char *cacrl,
const char *cert,
const char *key,
bool requireValidCert,
bool isServer)
{
- virNetTLSContextPtr ctxt;
+ virNetTLSContext *ctxt;
int err;
if (virNetTLSContextInitialize() < 0)
}
-static virNetTLSContextPtr virNetTLSContextNewPath(const char *pkipath,
+static virNetTLSContext *virNetTLSContextNewPath(const char *pkipath,
bool tryUserPkiPath,
const char *const *x509dnACL,
const char *priority,
bool isServer)
{
char *cacert = NULL, *cacrl = NULL, *key = NULL, *cert = NULL;
- virNetTLSContextPtr ctxt = NULL;
+ virNetTLSContext *ctxt = NULL;
if (virNetTLSContextLocateCredentials(pkipath, tryUserPkiPath, isServer,
&cacert, &cacrl, &cert, &key) < 0)
return ctxt;
}
-virNetTLSContextPtr virNetTLSContextNewServerPath(const char *pkipath,
+virNetTLSContext *virNetTLSContextNewServerPath(const char *pkipath,
bool tryUserPkiPath,
const char *const *x509dnACL,
const char *priority,
sanityCheckCert, requireValidCert, true);
}
-virNetTLSContextPtr virNetTLSContextNewClientPath(const char *pkipath,
+virNetTLSContext *virNetTLSContextNewClientPath(const char *pkipath,
bool tryUserPkiPath,
const char *priority,
bool sanityCheckCert,
}
-virNetTLSContextPtr virNetTLSContextNewServer(const char *cacert,
+virNetTLSContext *virNetTLSContextNewServer(const char *cacert,
const char *cacrl,
const char *cert,
const char *key,
}
-int virNetTLSContextReloadForServer(virNetTLSContextPtr ctxt,
+int virNetTLSContextReloadForServer(virNetTLSContext *ctxt,
bool tryUserPkiPath)
{
gnutls_certificate_credentials_t x509credBak;
}
-virNetTLSContextPtr virNetTLSContextNewClient(const char *cacert,
+virNetTLSContext *virNetTLSContextNewClient(const char *cacert,
const char *cacrl,
const char *cert,
const char *key,
}
-static int virNetTLSContextValidCertificate(virNetTLSContextPtr ctxt,
- virNetTLSSessionPtr sess)
+static int virNetTLSContextValidCertificate(virNetTLSContext *ctxt,
+ virNetTLSSession *sess)
{
int ret;
unsigned int status;
return -1;
}
-int virNetTLSContextCheckCertificate(virNetTLSContextPtr ctxt,
- virNetTLSSessionPtr sess)
+int virNetTLSContextCheckCertificate(virNetTLSContext *ctxt,
+ virNetTLSSession *sess)
{
int ret = -1;
void virNetTLSContextDispose(void *obj)
{
- virNetTLSContextPtr ctxt = obj;
+ virNetTLSContext *ctxt = obj;
PROBE(RPC_TLS_CONTEXT_DISPOSE,
"ctxt=%p", ctxt);
static ssize_t
virNetTLSSessionPush(void *opaque, const void *buf, size_t len)
{
- virNetTLSSessionPtr sess = opaque;
+ virNetTLSSession *sess = opaque;
if (!sess->writeFunc) {
VIR_WARN("TLS session push with missing write function");
errno = EIO;
static ssize_t
virNetTLSSessionPull(void *opaque, void *buf, size_t len)
{
- virNetTLSSessionPtr sess = opaque;
+ virNetTLSSession *sess = opaque;
if (!sess->readFunc) {
VIR_WARN("TLS session pull with missing read function");
errno = EIO;
}
-virNetTLSSessionPtr virNetTLSSessionNew(virNetTLSContextPtr ctxt,
+virNetTLSSession *virNetTLSSessionNew(virNetTLSContext *ctxt,
const char *hostname)
{
- virNetTLSSessionPtr sess;
+ virNetTLSSession *sess;
int err;
const char *priority;
}
-void virNetTLSSessionSetIOCallbacks(virNetTLSSessionPtr sess,
+void virNetTLSSessionSetIOCallbacks(virNetTLSSession *sess,
virNetTLSSessionWriteFunc writeFunc,
virNetTLSSessionReadFunc readFunc,
void *opaque)
}
-ssize_t virNetTLSSessionWrite(virNetTLSSessionPtr sess,
+ssize_t virNetTLSSessionWrite(virNetTLSSession *sess,
const char *buf, size_t len)
{
ssize_t ret;
return ret;
}
-ssize_t virNetTLSSessionRead(virNetTLSSessionPtr sess,
+ssize_t virNetTLSSessionRead(virNetTLSSession *sess,
char *buf, size_t len)
{
ssize_t ret;
return ret;
}
-int virNetTLSSessionHandshake(virNetTLSSessionPtr sess)
+int virNetTLSSessionHandshake(virNetTLSSession *sess)
{
int ret;
VIR_DEBUG("sess=%p", sess);
}
virNetTLSSessionHandshakeStatus
-virNetTLSSessionGetHandshakeStatus(virNetTLSSessionPtr sess)
+virNetTLSSessionGetHandshakeStatus(virNetTLSSession *sess)
{
virNetTLSSessionHandshakeStatus ret;
virObjectLock(sess);
return ret;
}
-int virNetTLSSessionGetKeySize(virNetTLSSessionPtr sess)
+int virNetTLSSessionGetKeySize(virNetTLSSession *sess)
{
gnutls_cipher_algorithm_t cipher;
int ssf;
return ssf;
}
-const char *virNetTLSSessionGetX509DName(virNetTLSSessionPtr sess)
+const char *virNetTLSSessionGetX509DName(virNetTLSSession *sess)
{
const char *ret = NULL;
void virNetTLSSessionDispose(void *obj)
{
- virNetTLSSessionPtr sess = obj;
+ virNetTLSSession *sess = obj;
PROBE(RPC_TLS_SESSION_DISPOSE,
"sess=%p", sess);
#include "virobject.h"
typedef struct _virNetTLSContext virNetTLSContext;
-typedef virNetTLSContext *virNetTLSContextPtr;
typedef struct _virNetTLSSession virNetTLSSession;
-typedef virNetTLSSession *virNetTLSSessionPtr;
void virNetTLSInit(void);
-virNetTLSContextPtr virNetTLSContextNewServerPath(const char *pkipath,
+virNetTLSContext *virNetTLSContextNewServerPath(const char *pkipath,
bool tryUserPkiPath,
const char *const *x509dnACL,
const char *priority,
bool sanityCheckCert,
bool requireValidCert);
-virNetTLSContextPtr virNetTLSContextNewClientPath(const char *pkipath,
+virNetTLSContext *virNetTLSContextNewClientPath(const char *pkipath,
bool tryUserPkiPath,
const char *priority,
bool sanityCheckCert,
bool requireValidCert);
-virNetTLSContextPtr virNetTLSContextNewServer(const char *cacert,
+virNetTLSContext *virNetTLSContextNewServer(const char *cacert,
const char *cacrl,
const char *cert,
const char *key,
bool sanityCheckCert,
bool requireValidCert);
-virNetTLSContextPtr virNetTLSContextNewClient(const char *cacert,
+virNetTLSContext *virNetTLSContextNewClient(const char *cacert,
const char *cacrl,
const char *cert,
const char *key,
bool sanityCheckCert,
bool requireValidCert);
-int virNetTLSContextReloadForServer(virNetTLSContextPtr ctxt,
+int virNetTLSContextReloadForServer(virNetTLSContext *ctxt,
bool tryUserPkiPath);
-int virNetTLSContextCheckCertificate(virNetTLSContextPtr ctxt,
- virNetTLSSessionPtr sess);
+int virNetTLSContextCheckCertificate(virNetTLSContext *ctxt,
+ virNetTLSSession *sess);
typedef ssize_t (*virNetTLSSessionWriteFunc)(const char *buf, size_t len,
typedef ssize_t (*virNetTLSSessionReadFunc)(char *buf, size_t len,
void *opaque);
-virNetTLSSessionPtr virNetTLSSessionNew(virNetTLSContextPtr ctxt,
+virNetTLSSession *virNetTLSSessionNew(virNetTLSContext *ctxt,
const char *hostname);
-void virNetTLSSessionSetIOCallbacks(virNetTLSSessionPtr sess,
+void virNetTLSSessionSetIOCallbacks(virNetTLSSession *sess,
virNetTLSSessionWriteFunc writeFunc,
virNetTLSSessionReadFunc readFunc,
void *opaque);
-ssize_t virNetTLSSessionWrite(virNetTLSSessionPtr sess,
+ssize_t virNetTLSSessionWrite(virNetTLSSession *sess,
const char *buf, size_t len);
-ssize_t virNetTLSSessionRead(virNetTLSSessionPtr sess,
+ssize_t virNetTLSSessionRead(virNetTLSSession *sess,
char *buf, size_t len);
-int virNetTLSSessionHandshake(virNetTLSSessionPtr sess);
+int virNetTLSSessionHandshake(virNetTLSSession *sess);
typedef enum {
VIR_NET_TLS_HANDSHAKE_COMPLETE,
} virNetTLSSessionHandshakeStatus;
virNetTLSSessionHandshakeStatus
-virNetTLSSessionGetHandshakeStatus(virNetTLSSessionPtr sess);
+virNetTLSSessionGetHandshakeStatus(virNetTLSSession *sess);
-int virNetTLSSessionGetKeySize(virNetTLSSessionPtr sess);
+int virNetTLSSessionGetKeySize(virNetTLSSession *sess);
-const char *virNetTLSSessionGetX509DName(virNetTLSSessionPtr sess);
+const char *virNetTLSSessionGetX509DName(virNetTLSSession *sess);
/* Internal driver state */
typedef struct _virSecretDriverState virSecretDriverState;
-typedef virSecretDriverState *virSecretDriverStatePtr;
struct _virSecretDriverState {
virMutex lock;
bool privileged; /* readonly */
char *embeddedRoot; /* readonly */
int embeddedRefs;
- virSecretObjListPtr secrets;
+ virSecretObjList *secrets;
char *stateDir;
char *configDir;
int lockFD;
/* Immutable pointer, self-locking APIs */
- virObjectEventStatePtr secretEventState;
+ virObjectEventState *secretEventState;
};
-static virSecretDriverStatePtr driver;
+static virSecretDriverState *driver;
static void
secretDriverLock(void)
}
-static virSecretObjPtr
+static virSecretObj *
secretObjFromSecret(virSecretPtr secret)
{
- virSecretObjPtr obj;
+ virSecretObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(secret->uuid, uuidstr);
const unsigned char *uuid)
{
virSecretPtr ret = NULL;
- virSecretObjPtr obj;
- virSecretDefPtr def;
+ virSecretObj *obj;
+ virSecretDef *def;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(uuid, uuidstr);
const char *usageID)
{
virSecretPtr ret = NULL;
- virSecretObjPtr obj;
- virSecretDefPtr def;
+ virSecretObj *obj;
+ virSecretDef *def;
if (!(obj = virSecretObjListFindByUsage(driver->secrets,
usageType, usageID))) {
unsigned int flags)
{
virSecretPtr ret = NULL;
- virSecretObjPtr obj = NULL;
- virSecretDefPtr objDef;
- virSecretDefPtr backup = NULL;
- virSecretDefPtr def;
- virObjectEventPtr event = NULL;
+ virSecretObj *obj = NULL;
+ virSecretDef *objDef;
+ virSecretDef *backup = NULL;
+ virSecretDef *def;
+ virObjectEvent *event = NULL;
virCheckFlags(0, NULL);
unsigned int flags)
{
char *ret = NULL;
- virSecretObjPtr obj;
- virSecretDefPtr def;
+ virSecretObj *obj;
+ virSecretDef *def;
virCheckFlags(0, NULL);
unsigned int flags)
{
int ret = -1;
- virSecretObjPtr obj;
- virSecretDefPtr def;
- virObjectEventPtr event = NULL;
+ virSecretObj *obj;
+ virSecretDef *def;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
unsigned int internalFlags)
{
unsigned char *ret = NULL;
- virSecretObjPtr obj;
- virSecretDefPtr def;
+ virSecretObj *obj;
+ virSecretDef *def;
virCheckFlags(0, NULL);
secretUndefine(virSecretPtr secret)
{
int ret = -1;
- virSecretObjPtr obj;
- virSecretDefPtr def;
- virObjectEventPtr event = NULL;
+ virSecretObj *obj;
+ virSecretDef *def;
+ virObjectEvent *event = NULL;
if (!(obj = secretObjFromSecret(secret)))
goto cleanup;
static virDrvOpenStatus
secretConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
/* Data structure to pass to *FileIterate so we have everything we need */
struct SDPDOP {
- virSecurityManagerPtr mgr;
- virDomainDefPtr def;
+ virSecurityManager *mgr;
+ virDomainDef *def;
};
/*
* load (add) a profile. Will create one if necessary
*/
static int
-load_profile(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+load_profile(virSecurityManager *mgr G_GNUC_UNUSED,
const char *profile,
- virDomainDefPtr def,
+ virDomainDef *def,
const char *fn,
bool append)
{
int rc = -1;
bool create = true;
char *xml = NULL;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
xml = virDomainDefFormat(def, NULL, VIR_DOMAIN_DEF_FORMAT_SECURE);
if (!xml)
}
static char *
-get_profile_name(virDomainDefPtr def)
+get_profile_name(virDomainDef *def)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
* NULL.
*/
static int
-reload_profile(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+reload_profile(virSecurityManager *mgr,
+ virDomainDef *def,
const char *fn,
bool append)
{
- virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(
+ virSecurityLabelDef *secdef = virDomainDefGetSecurityLabelDef(
def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->relabel)
AppArmorSetSecurityHostdevLabelHelper(const char *file, void *opaque)
{
struct SDPDOP *ptr = opaque;
- virDomainDefPtr def = ptr->def;
+ virDomainDef *def = ptr->def;
return reload_profile(ptr->mgr, def, file, true);
}
static int
-AppArmorSetSecurityUSBLabel(virUSBDevicePtr dev G_GNUC_UNUSED,
+AppArmorSetSecurityUSBLabel(virUSBDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return AppArmorSetSecurityHostdevLabelHelper(file, opaque);
}
static int
-AppArmorSetSecurityPCILabel(virPCIDevicePtr dev G_GNUC_UNUSED,
+AppArmorSetSecurityPCILabel(virPCIDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return AppArmorSetSecurityHostdevLabelHelper(file, opaque);
}
static int
-AppArmorSetSecuritySCSILabel(virSCSIDevicePtr dev G_GNUC_UNUSED,
+AppArmorSetSecuritySCSILabel(virSCSIDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return AppArmorSetSecurityHostdevLabelHelper(file, opaque);
}
static int
-AppArmorSetSecurityHostLabel(virSCSIVHostDevicePtr dev G_GNUC_UNUSED,
+AppArmorSetSecurityHostLabel(virSCSIVHostDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return AppArmorSetSecurityHostdevLabelHelper(file, opaque);
* currently not used.
*/
static int
-AppArmorSecurityManagerOpen(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+AppArmorSecurityManagerOpen(virSecurityManager *mgr G_GNUC_UNUSED)
{
return 0;
}
static int
-AppArmorSecurityManagerClose(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+AppArmorSecurityManagerClose(virSecurityManager *mgr G_GNUC_UNUSED)
{
return 0;
}
static const char *
-AppArmorSecurityManagerGetModel(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+AppArmorSecurityManagerGetModel(virSecurityManager *mgr G_GNUC_UNUSED)
{
return SECURITY_APPARMOR_NAME;
}
static const char *
-AppArmorSecurityManagerGetDOI(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+AppArmorSecurityManagerGetDOI(virSecurityManager *mgr G_GNUC_UNUSED)
{
return SECURITY_APPARMOR_VOID_DOI;
}
* called on shutdown.
*/
static int
-AppArmorGenSecurityLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+AppArmorGenSecurityLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
int rc = -1;
char *profile_name = NULL;
- virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(def,
+ virSecurityLabelDef *secdef = virDomainDefGetSecurityLabelDef(def,
SECURITY_APPARMOR_NAME);
if (!secdef)
}
static int
-AppArmorSetSecurityAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+AppArmorSetSecurityAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *incomingPath,
bool chardevStdioLogd G_GNUC_UNUSED,
bool migrated G_GNUC_UNUSED)
{
- virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(def,
+ virSecurityLabelDef *secdef = virDomainDefGetSecurityLabelDef(def,
SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->relabel)
return 0;
* running.
*/
static int
-AppArmorGetSecurityProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
+AppArmorGetSecurityProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
pid_t pid G_GNUC_UNUSED,
virSecurityLabelPtr sec)
{
* more details. Currently called via qemudShutdownVMDaemon.
*/
static int
-AppArmorReleaseSecurityLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+AppArmorReleaseSecurityLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(def,
+ virSecurityLabelDef *secdef = virDomainDefGetSecurityLabelDef(def,
SECURITY_APPARMOR_NAME);
if (secdef) {
VIR_FREE(secdef->model);
static int
-AppArmorRestoreSecurityAllLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
+AppArmorRestoreSecurityAllLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
bool migrated G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED)
{
int rc = 0;
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef)
* LOCALSTATEDIR/log/libvirt/qemu/<vm name>.log
*/
static int
-AppArmorSetSecurityProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+AppArmorSetSecurityProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
int rc = -1;
char *profile_name = NULL;
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->label)
* process*.
*/
static int
-AppArmorSetSecurityChildProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
- virCommandPtr cmd)
+AppArmorSetSecurityChildProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
+ virCommand *cmd)
{
int rc = -1;
char *profile_name = NULL;
char *cmd_str = NULL;
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->label)
}
static int
-AppArmorSetSecurityDaemonSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+AppArmorSetSecurityDaemonSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-AppArmorSetSecuritySocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+AppArmorSetSecuritySocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-AppArmorClearSecuritySocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+AppArmorClearSecuritySocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
/* Called when hotplugging */
static int
-AppArmorRestoreSecurityImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+AppArmorRestoreSecurityImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
if (!virStorageSourceIsLocalStorage(src))
/* Called when hotplugging */
static int
-AppArmorSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+AppArmorSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem)
{
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
static int
-AppArmorRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem G_GNUC_UNUSED)
+AppArmorRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem G_GNUC_UNUSED)
{
return reload_profile(mgr, def, NULL, false);
}
/* Called when hotplugging */
static int
-AppArmorSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input)
+AppArmorSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input)
{
if (input == NULL)
return 0;
static int
-AppArmorRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input G_GNUC_UNUSED)
+AppArmorRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input G_GNUC_UNUSED)
{
return reload_profile(mgr, def, NULL, false);
}
/* Called when hotplugging */
static int
-AppArmorSetSecurityImageLabelInternal(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src)
+AppArmorSetSecurityImageLabelInternal(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src)
{
g_autofree char *vfioGroupDev = NULL;
const char *path;
}
static int
-AppArmorSetSecurityImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+AppArmorSetSecurityImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
- virSecurityLabelDefPtr secdef;
- virStorageSourcePtr n;
+ virSecurityLabelDef *secdef;
+ virStorageSource *n;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->relabel)
}
static int
-AppArmorSecurityVerify(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+AppArmorSecurityVerify(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef)
}
static int
-AppArmorReserveSecurityLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
+AppArmorReserveSecurityLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
/* NOOP. Nothing to reserve with AppArmor */
}
static int
-AppArmorSetSecurityHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+AppArmorSetSecurityHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
struct SDPDOP *ptr;
int ret = -1;
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
if (!secdef || !secdef->relabel)
return 0;
switch ((virDomainHostdevSubsysType)dev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB: {
- virUSBDevicePtr usb =
+ virUSBDevice *usb =
virUSBDeviceNew(usbsrc->bus, usbsrc->device, vroot);
if (!usb)
goto done;
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: {
- virPCIDevicePtr pci =
+ virPCIDevice *pci =
virPCIDeviceNew(&pcisrc->addr);
if (!pci)
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
- virSCSIDevicePtr scsi =
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
+ virSCSIDevice *scsi =
virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
scsihostsrc->target, scsihostsrc->unit,
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST: {
- virSCSIVHostDevicePtr host = virSCSIVHostDeviceNew(hostsrc->wwpn);
+ virSCSIVHostDevice *host = virSCSIVHostDeviceNew(hostsrc->wwpn);
if (!host)
goto done;
static int
-AppArmorRestoreSecurityHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev G_GNUC_UNUSED,
+AppArmorRestoreSecurityHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev G_GNUC_UNUSED,
const char *vroot G_GNUC_UNUSED)
{
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->relabel)
}
static int
-AppArmorSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+AppArmorSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd G_GNUC_UNUSED)
{
char *in = NULL, *out = NULL;
int ret = -1;
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef)
}
static int
-AppArmorRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source G_GNUC_UNUSED,
+AppArmorRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef)
}
static int
-AppArmorSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+AppArmorSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path,
bool allowSubtree)
{
}
static int
-AppArmorRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+AppArmorRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path G_GNUC_UNUSED)
{
return reload_profile(mgr, def, NULL, false);
}
static int
-AppArmorSetFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+AppArmorSetFDLabel(virSecurityManager *mgr,
+ virDomainDef *def,
int fd)
{
char *proc = NULL;
char *fd_path = NULL;
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_APPARMOR_NAME);
if (!secdef || !secdef->imagelabel)
}
static char *
-AppArmorGetMountOptions(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+AppArmorGetMountOptions(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
char *opts;
}
static const char *
-AppArmorGetBaseLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+AppArmorGetBaseLabel(virSecurityManager *mgr G_GNUC_UNUSED,
int virtType G_GNUC_UNUSED)
{
return NULL;
#define DEV_SEV "/dev/sev"
typedef struct _virSecurityDACData virSecurityDACData;
-typedef virSecurityDACData *virSecurityDACDataPtr;
-
struct _virSecurityDACData {
uid_t user;
gid_t group;
};
typedef struct _virSecurityDACCallbackData virSecurityDACCallbackData;
-typedef virSecurityDACCallbackData *virSecurityDACCallbackDataPtr;
-
struct _virSecurityDACCallbackData {
- virSecurityManagerPtr manager;
- virSecurityLabelDefPtr secdef;
+ virSecurityManager *manager;
+ virSecurityLabelDef *secdef;
};
typedef struct _virSecurityDACChownItem virSecurityDACChownItem;
-typedef virSecurityDACChownItem *virSecurityDACChownItemPtr;
struct _virSecurityDACChownItem {
char *path;
const virStorageSource *src;
};
typedef struct _virSecurityDACChownList virSecurityDACChownList;
-typedef virSecurityDACChownList *virSecurityDACChownListPtr;
struct _virSecurityDACChownList {
- virSecurityManagerPtr manager;
- virSecurityDACChownItemPtr *items;
+ virSecurityManager *manager;
+ virSecurityDACChownItem **items;
size_t nItems;
bool lock;
};
virThreadLocal chownList;
static int
-virSecurityDACChownListAppend(virSecurityDACChownListPtr list,
+virSecurityDACChownListAppend(virSecurityDACChownList *list,
const char *path,
const virStorageSource *src,
uid_t uid,
{
int ret = -1;
char *tmp = NULL;
- virSecurityDACChownItemPtr item = NULL;
+ virSecurityDACChownItem *item = NULL;
item = g_new0(virSecurityDACChownItem, 1);
static void
virSecurityDACChownListFree(void *opaque)
{
- virSecurityDACChownListPtr list = opaque;
+ virSecurityDACChownList *list = opaque;
size_t i;
if (!list)
bool remember,
bool restore)
{
- virSecurityDACChownListPtr list = virThreadLocalGet(&chownList);
+ virSecurityDACChownList *list = virThreadLocalGet(&chownList);
if (!list)
return 0;
}
-static int virSecurityDACSetOwnership(virSecurityManagerPtr mgr,
+static int virSecurityDACSetOwnership(virSecurityManager *mgr,
const virStorageSource *src,
const char *path,
uid_t uid,
gid_t gid,
bool remember);
-static int virSecurityDACRestoreFileLabelInternal(virSecurityManagerPtr mgr,
+static int virSecurityDACRestoreFileLabelInternal(virSecurityManager *mgr,
const virStorageSource *src,
const char *path,
bool recall);
virSecurityDACTransactionRun(pid_t pid G_GNUC_UNUSED,
void *opaque)
{
- virSecurityDACChownListPtr list = opaque;
- virSecurityManagerMetadataLockStatePtr state;
+ virSecurityDACChownList *list = opaque;
+ virSecurityManagerMetadataLockState *state;
const char **paths = NULL;
size_t npaths = 0;
size_t i;
paths = g_new0(const char *, list->nItems);
for (i = 0; i < list->nItems; i++) {
- virSecurityDACChownItemPtr item = list->items[i];
+ virSecurityDACChownItem *item = list->items[i];
const char *p = item->path;
if (item->remember)
goto cleanup;
for (i = 0; i < list->nItems; i++) {
- virSecurityDACChownItemPtr item = list->items[i];
+ virSecurityDACChownItem *item = list->items[i];
size_t j;
for (j = 0; j < state->nfds; j++) {
}
for (i = 0; i < list->nItems; i++) {
- virSecurityDACChownItemPtr item = list->items[i];
+ virSecurityDACChownItem *item = list->items[i];
const bool remember = item->remember && list->lock;
if (!item->restore) {
}
for (; rv < 0 && i > 0; i--) {
- virSecurityDACChownItemPtr item = list->items[i - 1];
+ virSecurityDACChownItem *item = list->items[i - 1];
const bool remember = item->remember && list->lock;
if (!item->restore) {
/* returns -1 on error, 0 on success */
int
-virSecurityDACSetUserAndGroup(virSecurityManagerPtr mgr,
+virSecurityDACSetUserAndGroup(virSecurityManager *mgr,
uid_t user,
gid_t group)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
priv->user = user;
priv->group = group;
}
void
-virSecurityDACSetDynamicOwnership(virSecurityManagerPtr mgr,
+virSecurityDACSetDynamicOwnership(virSecurityManager *mgr,
bool dynamicOwnership)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
priv->dynamicOwnership = dynamicOwnership;
}
void
-virSecurityDACSetMountNamespace(virSecurityManagerPtr mgr,
+virSecurityDACSetMountNamespace(virSecurityManager *mgr,
bool mountNamespace)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
priv->mountNamespace = mountNamespace;
}
void
-virSecurityDACSetChownCallback(virSecurityManagerPtr mgr,
+virSecurityDACSetChownCallback(virSecurityManager *mgr,
virSecurityManagerDACChownCallback chownCallback)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
priv->chownCallback = chownCallback;
}
/* returns 1 if label isn't found, 0 on success, -1 on error */
static int
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
-virSecurityDACParseIds(virSecurityLabelDefPtr seclabel,
+virSecurityDACParseIds(virSecurityLabelDef *seclabel,
uid_t *uidPtr, gid_t *gidPtr)
{
if (!seclabel || !seclabel->label)
static int
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-virSecurityDACGetIds(virSecurityLabelDefPtr seclabel,
- virSecurityDACDataPtr priv,
+virSecurityDACGetIds(virSecurityLabelDef *seclabel,
+ virSecurityDACData *priv,
uid_t *uidPtr, gid_t *gidPtr,
gid_t **groups, int *ngroups)
{
/* returns 1 if label isn't found, 0 on success, -1 on error */
static int
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
-virSecurityDACParseImageIds(virSecurityLabelDefPtr seclabel,
+virSecurityDACParseImageIds(virSecurityLabelDef *seclabel,
uid_t *uidPtr, gid_t *gidPtr)
{
if (!seclabel || !seclabel->imagelabel)
static int
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-virSecurityDACGetImageIds(virSecurityLabelDefPtr seclabel,
- virSecurityDACDataPtr priv,
+virSecurityDACGetImageIds(virSecurityLabelDef *seclabel,
+ virSecurityDACData *priv,
uid_t *uidPtr, gid_t *gidPtr)
{
int ret;
* -1 on failure
*/
static int
-virSecurityDACRememberLabel(virSecurityDACDataPtr priv G_GNUC_UNUSED,
+virSecurityDACRememberLabel(virSecurityDACData *priv G_GNUC_UNUSED,
const char *path,
uid_t uid,
gid_t gid)
* -1 on failure (@uid and @gid not touched)
*/
static int
-virSecurityDACRecallLabel(virSecurityDACDataPtr priv G_GNUC_UNUSED,
+virSecurityDACRecallLabel(virSecurityDACData *priv G_GNUC_UNUSED,
const char *path,
uid_t *uid,
gid_t *gid)
}
static int
-virSecurityDACOpen(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDACOpen(virSecurityManager *mgr G_GNUC_UNUSED)
{
if (virThreadLocalInit(&chownList,
virSecurityDACChownListFree) < 0) {
}
static int
-virSecurityDACClose(virSecurityManagerPtr mgr)
+virSecurityDACClose(virSecurityManager *mgr)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
VIR_FREE(priv->groups);
VIR_FREE(priv->baselabel);
return 0;
static const char *
-virSecurityDACGetModel(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDACGetModel(virSecurityManager *mgr G_GNUC_UNUSED)
{
return SECURITY_DAC_NAME;
}
static const char *
-virSecurityDACGetDOI(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDACGetDOI(virSecurityManager *mgr G_GNUC_UNUSED)
{
return "0";
}
static int
-virSecurityDACPreFork(virSecurityManagerPtr mgr)
+virSecurityDACPreFork(virSecurityManager *mgr)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
int ngroups;
VIR_FREE(priv->groups);
* -1 otherwise.
*/
static int
-virSecurityDACTransactionStart(virSecurityManagerPtr mgr)
+virSecurityDACTransactionStart(virSecurityManager *mgr)
{
- virSecurityDACChownListPtr list;
+ virSecurityDACChownList *list;
list = virThreadLocalGet(&chownList);
if (list) {
* -1 otherwise.
*/
static int
-virSecurityDACTransactionCommit(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+virSecurityDACTransactionCommit(virSecurityManager *mgr G_GNUC_UNUSED,
pid_t pid,
bool lock)
{
- virSecurityDACChownListPtr list;
+ virSecurityDACChownList *list;
int rc;
int ret = -1;
* Cancels and frees any out standing transaction.
*/
static void
-virSecurityDACTransactionAbort(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDACTransactionAbort(virSecurityManager *mgr G_GNUC_UNUSED)
{
- virSecurityDACChownListPtr list;
+ virSecurityDACChownList *list;
list = virThreadLocalGet(&chownList);
if (!list)
static int
-virSecurityDACSetOwnership(virSecurityManagerPtr mgr,
+virSecurityDACSetOwnership(virSecurityManager *mgr,
const virStorageSource *src,
const char *path,
uid_t uid,
gid_t gid,
bool remember)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
virErrorPtr origerr;
struct stat sb;
int refcount;
static int
-virSecurityDACRestoreFileLabelInternal(virSecurityManagerPtr mgr,
+virSecurityDACRestoreFileLabelInternal(virSecurityManager *mgr,
const virStorageSource *src,
const char *path,
bool recall)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
int rv;
uid_t uid = 0; /* By default return to root:root */
gid_t gid = 0;
static int
-virSecurityDACRestoreFileLabel(virSecurityManagerPtr mgr,
+virSecurityDACRestoreFileLabel(virSecurityManager *mgr,
const char *path)
{
return virSecurityDACRestoreFileLabelInternal(mgr, NULL, path, true);
static int
-virSecurityDACSetImageLabelInternal(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virSecurityDACSetImageLabelInternal(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
+ virStorageSource *parent,
bool isChainTop)
{
- virSecurityLabelDefPtr secdef;
- virSecurityDeviceLabelDefPtr disk_seclabel;
- virSecurityDeviceLabelDefPtr parent_seclabel = NULL;
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecurityDeviceLabelDef *disk_seclabel;
+ virSecurityDeviceLabelDef *parent_seclabel = NULL;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
bool remember;
uid_t user;
gid_t group;
static int
-virSecurityDACSetImageLabelRelative(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virSecurityDACSetImageLabelRelative(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
+ virStorageSource *parent,
virSecurityDomainImageLabelFlags flags)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
const bool isChainTop = flags & VIR_SECURITY_DOMAIN_IMAGE_PARENT_CHAIN_TOP;
}
static int
-virSecurityDACSetImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecurityDACSetImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
return virSecurityDACSetImageLabelRelative(mgr, def, src, src, flags);
}
static int
-virSecurityDACRestoreImageLabelSingle(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecurityDACRestoreImageLabelSingle(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
bool migrated)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
- virSecurityDeviceLabelDefPtr disk_seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecurityDeviceLabelDef *disk_seclabel;
if (!priv->dynamicOwnership)
return 0;
static int
-virSecurityDACRestoreImageLabelInt(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecurityDACRestoreImageLabelInt(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
bool migrated)
{
if (virSecurityDACRestoreImageLabelSingle(mgr, def, src, migrated) < 0)
static int
-virSecurityDACRestoreImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecurityDACRestoreImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
return virSecurityDACRestoreImageLabelInt(mgr, def, src, false);
struct virSecurityDACMoveImageMetadataData {
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
const char *src;
const char *dst;
};
{
struct virSecurityDACMoveImageMetadataData *data = opaque;
const char *paths[2] = { data->src, data->dst };
- virSecurityManagerMetadataLockStatePtr state;
+ virSecurityManagerMetadataLockState *state;
int ret;
if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, G_N_ELEMENTS(paths))))
static int
-virSecurityDACMoveImageMetadata(virSecurityManagerPtr mgr,
+virSecurityDACMoveImageMetadata(virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst)
+ virStorageSource *src,
+ virStorageSource *dst)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
struct virSecurityDACMoveImageMetadataData data = { .mgr = mgr, 0 };
int rc;
bool remember,
void *opaque)
{
- virSecurityDACCallbackDataPtr cbdata = opaque;
- virSecurityManagerPtr mgr = cbdata->manager;
- virSecurityLabelDefPtr secdef = cbdata->secdef;
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACCallbackData *cbdata = opaque;
+ virSecurityManager *mgr = cbdata->manager;
+ virSecurityLabelDef *secdef = cbdata->secdef;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
uid_t user;
gid_t group;
static int
-virSecurityDACSetPCILabel(virPCIDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACSetPCILabel(virPCIDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
static int
-virSecurityDACSetUSBLabel(virUSBDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACSetUSBLabel(virUSBDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
static int
-virSecurityDACSetSCSILabel(virSCSIDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACSetSCSILabel(virSCSIDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
static int
-virSecurityDACSetHostLabel(virSCSIVHostDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACSetHostLabel(virSCSIVHostDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
static int
-virSecurityDACSetHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecurityDACSetHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
virSecurityDACCallbackData cbdata;
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
int ret = -1;
if (!priv->dynamicOwnership)
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi =
virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
static int
-virSecurityDACRestorePCILabel(virPCIDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACRestorePCILabel(virPCIDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecurityDACRestoreFileLabel(mgr, file);
}
static int
-virSecurityDACRestoreUSBLabel(virUSBDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACRestoreUSBLabel(virUSBDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecurityDACRestoreFileLabel(mgr, file);
}
static int
-virSecurityDACRestoreSCSILabel(virSCSIDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACRestoreSCSILabel(virSCSIDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecurityDACRestoreFileLabel(mgr, file);
}
static int
-virSecurityDACRestoreHostLabel(virSCSIVHostDevicePtr dev G_GNUC_UNUSED,
+virSecurityDACRestoreHostLabel(virSCSIVHostDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecurityDACRestoreFileLabel(mgr, file);
}
static int
-virSecurityDACRestoreHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecurityDACRestoreHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
int ret = -1;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_DAC_NAME);
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi =
virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
static int
-virSecurityDACSetChardevLabelHelper(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityDACSetChardevLabelHelper(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd,
bool remember)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
- virSecurityDeviceLabelDefPtr chr_seclabel = NULL;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
+ virSecurityDeviceLabelDef *chr_seclabel = NULL;
char *in = NULL, *out = NULL;
int ret = -1;
uid_t user;
static int
-virSecurityDACSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityDACSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
return virSecurityDACSetChardevLabelHelper(mgr, def, dev_source,
static int
-virSecurityDACRestoreChardevLabelHelper(virSecurityManagerPtr mgr,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrSourceDefPtr dev_source,
+virSecurityDACRestoreChardevLabelHelper(virSecurityManager *mgr,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd,
bool recall)
{
- virSecurityDeviceLabelDefPtr chr_seclabel = NULL;
+ virSecurityDeviceLabelDef *chr_seclabel = NULL;
char *in = NULL, *out = NULL;
int ret = -1;
static int
-virSecurityDACRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityDACRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
return virSecurityDACRestoreChardevLabelHelper(mgr, def, dev_source,
struct _virSecuritySELinuxChardevCallbackData {
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
bool chardevStdioLogd;
};
static int
-virSecurityDACRestoreChardevCallback(virDomainDefPtr def,
- virDomainChrDefPtr dev G_GNUC_UNUSED,
+virSecurityDACRestoreChardevCallback(virDomainDef *def,
+ virDomainChrDef *dev G_GNUC_UNUSED,
void *opaque)
{
struct _virSecuritySELinuxChardevCallbackData *data = opaque;
static int
-virSecurityDACSetTPMFileLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainTPMDefPtr tpm)
+virSecurityDACSetTPMFileLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainTPMDef *tpm)
{
int ret = 0;
static int
-virSecurityDACRestoreTPMFileLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainTPMDefPtr tpm)
+virSecurityDACRestoreTPMFileLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainTPMDef *tpm)
{
int ret = 0;
static int
-virSecurityDACSetGraphicsLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainGraphicsDefPtr gfx)
+virSecurityDACSetGraphicsLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainGraphicsDef *gfx)
{
const char *rendernode = virDomainGraphicsGetRenderNode(gfx);
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
uid_t user;
gid_t group;
static int
-virSecurityDACRestoreGraphicsLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainGraphicsDefPtr gfx G_GNUC_UNUSED)
+virSecurityDACRestoreGraphicsLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainGraphicsDef *gfx G_GNUC_UNUSED)
{
/* The only graphics labelling we do is dependent on mountNamespaces,
static int
-virSecurityDACSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input)
+virSecurityDACSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
int ret = -1;
uid_t user;
gid_t group;
}
static int
-virSecurityDACRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainInputDefPtr input)
+virSecurityDACRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainInputDef *input)
{
int ret = -1;
static int
-virSecurityDACRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainMemoryDefPtr mem)
+virSecurityDACRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainMemoryDef *mem)
{
int ret = -1;
static int
-virSecurityDACRestoreSEVLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDACRestoreSEVLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
/* we only label /dev/sev when running with namespaces, so we don't need to
* restore anything */
static int
-virSecurityDACRestoreSysinfoLabel(virSecurityManagerPtr mgr,
- virSysinfoDefPtr def)
+virSecurityDACRestoreSysinfoLabel(virSecurityManager *mgr,
+ virSysinfoDef *def)
{
size_t i;
for (i = 0; i < def->nfw_cfgs; i++) {
- virSysinfoFWCfgDefPtr f = &def->fw_cfgs[i];
+ virSysinfoFWCfgDef *f = &def->fw_cfgs[i];
if (f->file &&
virSecurityDACRestoreFileLabel(mgr, f->file) < 0)
static int
-virSecurityDACRestoreAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecurityDACRestoreAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
bool migrated,
bool chardevStdioLogd)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
size_t i;
int rc = 0;
static int
-virSecurityDACSetChardevCallback(virDomainDefPtr def,
- virDomainChrDefPtr dev G_GNUC_UNUSED,
+virSecurityDACSetChardevCallback(virDomainDef *def,
+ virDomainChrDef *dev G_GNUC_UNUSED,
void *opaque)
{
struct _virSecuritySELinuxChardevCallbackData *data = opaque;
static int
-virSecurityDACSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virSecurityDACSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
int ret = -1;
uid_t user;
gid_t group;
static int
-virSecurityDACSetSEVLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityDACSetSEVLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
uid_t user;
gid_t group;
static int
-virSecurityDACSetSysinfoLabel(virSecurityManagerPtr mgr,
+virSecurityDACSetSysinfoLabel(virSecurityManager *mgr,
uid_t user,
gid_t group,
- virSysinfoDefPtr def)
+ virSysinfoDef *def)
{
size_t i;
for (i = 0; i < def->nfw_cfgs; i++) {
- virSysinfoFWCfgDefPtr f = &def->fw_cfgs[i];
+ virSysinfoFWCfgDef *f = &def->fw_cfgs[i];
if (f->file &&
virSecurityDACSetOwnership(mgr, NULL, f->file,
static int
-virSecurityDACSetAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecurityDACSetAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *incomingPath G_GNUC_UNUSED,
bool chardevStdioLogd,
bool migrated G_GNUC_UNUSED)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
size_t i;
uid_t user;
gid_t group;
static int
-virSecurityDACSetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityDACSetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
uid_t user;
gid_t group;
gid_t *groups;
static int
-virSecurityDACSetChildProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virCommandPtr cmd)
+virSecurityDACSetChildProcessLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virCommand *cmd)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
uid_t user;
gid_t group;
static int
-virSecurityDACVerify(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDACVerify(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACGenLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityDACGenLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
int rc = -1;
- virSecurityLabelDefPtr seclabel;
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_DAC_NAME);
if (seclabel == NULL)
}
static int
-virSecurityDACReleaseLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDACReleaseLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACReserveLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
+virSecurityDACReserveLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
return 0;
#endif
static int
-virSecurityDACGetProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
+virSecurityDACGetProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
pid_t pid,
virSecurityLabelPtr seclabel)
{
- virSecurityLabelDefPtr secdef =
+ virSecurityLabelDef *secdef =
virDomainDefGetSecurityLabelDef(def, SECURITY_DAC_NAME);
if (secdef == NULL) {
}
static int
-virSecurityDACSetDaemonSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDACSetDaemonSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACSetSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDACSetSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACClearSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDACClearSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACSetImageFDLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
+virSecurityDACSetImageFDLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
int fd G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDACSetTapFDLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
+virSecurityDACSetTapFDLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
int fd G_GNUC_UNUSED)
{
return 0;
}
static char *
-virSecurityDACGetMountOptions(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDACGetMountOptions(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return NULL;
}
static const char *
-virSecurityDACGetBaseLabel(virSecurityManagerPtr mgr,
+virSecurityDACGetBaseLabel(virSecurityManager *mgr,
int virt G_GNUC_UNUSED)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
return priv->baselabel;
}
static int
-virSecurityDACDomainSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecurityDACDomainSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path,
bool allowSubtree G_GNUC_UNUSED)
{
- virSecurityDACDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr seclabel;
+ virSecurityDACData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *seclabel;
uid_t user;
gid_t group;
}
static int
-virSecurityDACDomainRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def G_GNUC_UNUSED,
+virSecurityDACDomainRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *def G_GNUC_UNUSED,
const char *path)
{
return virSecurityDACRestoreFileLabel(mgr, path);
extern virSecurityDriver virSecurityDriverDAC;
-int virSecurityDACSetUserAndGroup(virSecurityManagerPtr mgr,
+int virSecurityDACSetUserAndGroup(virSecurityManager *mgr,
uid_t user,
gid_t group);
-void virSecurityDACSetDynamicOwnership(virSecurityManagerPtr mgr,
+void virSecurityDACSetDynamicOwnership(virSecurityManager *mgr,
bool dynamic);
-void virSecurityDACSetMountNamespace(virSecurityManagerPtr mgr,
+void virSecurityDACSetMountNamespace(virSecurityManager *mgr,
bool mountNamespace);
-void virSecurityDACSetChownCallback(virSecurityManagerPtr mgr,
+void virSecurityDACSetChownCallback(virSecurityManager *mgr,
virSecurityManagerDACChownCallback chownCallback);
VIR_LOG_INIT("security.security_driver");
-static virSecurityDriverPtr security_drivers[] = {
+static virSecurityDriver *security_drivers[] = {
#ifdef WITH_SECDRIVER_SELINUX
&virSecurityDriverSELinux,
#endif
&virSecurityDriverNop, /* Must always be last, since it will always probe */
};
-virSecurityDriverPtr virSecurityDriverLookup(const char *name,
+virSecurityDriver *virSecurityDriverLookup(const char *name,
const char *virtDriver)
{
- virSecurityDriverPtr drv = NULL;
+ virSecurityDriver *drv = NULL;
size_t i;
VIR_DEBUG("name=%s", NULLSTR(name));
for (i = 0; i < G_N_ELEMENTS(security_drivers) && !drv; i++) {
- virSecurityDriverPtr tmp = security_drivers[i];
+ virSecurityDriver *tmp = security_drivers[i];
if (name &&
STRNEQ(tmp->name, name))
} virSecurityDriverStatus;
typedef struct _virSecurityDriver virSecurityDriver;
-typedef virSecurityDriver *virSecurityDriverPtr;
typedef virSecurityDriverStatus (*virSecurityDriverProbe) (const char *virtDriver);
-typedef int (*virSecurityDriverOpen) (virSecurityManagerPtr mgr);
-typedef int (*virSecurityDriverClose) (virSecurityManagerPtr mgr);
+typedef int (*virSecurityDriverOpen) (virSecurityManager *mgr);
+typedef int (*virSecurityDriverClose) (virSecurityManager *mgr);
-typedef const char *(*virSecurityDriverGetModel) (virSecurityManagerPtr mgr);
-typedef const char *(*virSecurityDriverGetDOI) (virSecurityManagerPtr mgr);
-typedef const char *(*virSecurityDriverGetBaseLabel) (virSecurityManagerPtr mgr,
+typedef const char *(*virSecurityDriverGetModel) (virSecurityManager *mgr);
+typedef const char *(*virSecurityDriverGetDOI) (virSecurityManager *mgr);
+typedef const char *(*virSecurityDriverGetBaseLabel) (virSecurityManager *mgr,
int virtType);
-typedef int (*virSecurityDriverPreFork) (virSecurityManagerPtr mgr);
+typedef int (*virSecurityDriverPreFork) (virSecurityManager *mgr);
-typedef int (*virSecurityDriverTransactionStart) (virSecurityManagerPtr mgr);
-typedef int (*virSecurityDriverTransactionCommit) (virSecurityManagerPtr mgr,
+typedef int (*virSecurityDriverTransactionStart) (virSecurityManager *mgr);
+typedef int (*virSecurityDriverTransactionCommit) (virSecurityManager *mgr,
pid_t pid,
bool lock);
-typedef void (*virSecurityDriverTransactionAbort) (virSecurityManagerPtr mgr);
-
-typedef int (*virSecurityDomainSetDaemonSocketLabel)(virSecurityManagerPtr mgr,
- virDomainDefPtr vm);
-typedef int (*virSecurityDomainSetSocketLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainClearSocketLabel)(virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainRestoreHostdevLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+typedef void (*virSecurityDriverTransactionAbort) (virSecurityManager *mgr);
+
+typedef int (*virSecurityDomainSetDaemonSocketLabel)(virSecurityManager *mgr,
+ virDomainDef *vm);
+typedef int (*virSecurityDomainSetSocketLabel) (virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainClearSocketLabel)(virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainRestoreHostdevLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot);
-typedef int (*virSecurityDomainSetHostdevLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+typedef int (*virSecurityDomainSetHostdevLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot);
-typedef int (*virSecurityDomainSetSavedStateLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainSetSavedStateLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile);
-typedef int (*virSecurityDomainRestoreSavedStateLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainRestoreSavedStateLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile);
-typedef int (*virSecurityDomainGenLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr sec);
-typedef int (*virSecurityDomainReserveLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr sec,
+typedef int (*virSecurityDomainGenLabel) (virSecurityManager *mgr,
+ virDomainDef *sec);
+typedef int (*virSecurityDomainReserveLabel) (virSecurityManager *mgr,
+ virDomainDef *sec,
pid_t pid);
-typedef int (*virSecurityDomainReleaseLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr sec);
-typedef int (*virSecurityDomainSetAllLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr sec,
+typedef int (*virSecurityDomainReleaseLabel) (virSecurityManager *mgr,
+ virDomainDef *sec);
+typedef int (*virSecurityDomainSetAllLabel) (virSecurityManager *mgr,
+ virDomainDef *sec,
const char *incomingPath,
bool chardevStdioLogd,
bool migrated);
-typedef int (*virSecurityDomainRestoreAllLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainRestoreAllLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
bool migrated,
bool chardevStdioLogd);
-typedef int (*virSecurityDomainGetProcessLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainGetProcessLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
pid_t pid,
virSecurityLabelPtr sec);
-typedef int (*virSecurityDomainSetProcessLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainSetChildProcessLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virCommandPtr cmd);
-typedef int (*virSecurityDomainSecurityVerify) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainSetImageFDLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainSetProcessLabel) (virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainSetChildProcessLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virCommand *cmd);
+typedef int (*virSecurityDomainSecurityVerify) (virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainSetImageFDLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
int fd);
-typedef int (*virSecurityDomainSetTapFDLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainSetTapFDLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
int fd);
-typedef char *(*virSecurityDomainGetMountOptions) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainSetHugepages) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef char *(*virSecurityDomainGetMountOptions) (virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainSetHugepages) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *path);
-typedef int (*virSecurityDomainSetImageLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+typedef int (*virSecurityDomainSetImageLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags);
-typedef int (*virSecurityDomainRestoreImageLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+typedef int (*virSecurityDomainRestoreImageLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags);
-typedef int (*virSecurityDomainMoveImageMetadata) (virSecurityManagerPtr mgr,
+typedef int (*virSecurityDomainMoveImageMetadata) (virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst);
-typedef int (*virSecurityDomainSetMemoryLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem);
-typedef int (*virSecurityDomainRestoreMemoryLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem);
-typedef int (*virSecurityDomainSetInputLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input);
-typedef int (*virSecurityDomainRestoreInputLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input);
-typedef int (*virSecurityDomainSetPathLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+ virStorageSource *src,
+ virStorageSource *dst);
+typedef int (*virSecurityDomainSetMemoryLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem);
+typedef int (*virSecurityDomainRestoreMemoryLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem);
+typedef int (*virSecurityDomainSetInputLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input);
+typedef int (*virSecurityDomainRestoreInputLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input);
+typedef int (*virSecurityDomainSetPathLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *path,
bool allowSubtree);
-typedef int (*virSecurityDomainSetPathLabelRO) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainSetPathLabelRO) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *path);
-typedef int (*virSecurityDomainRestorePathLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+typedef int (*virSecurityDomainRestorePathLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
const char *path);
-typedef int (*virSecurityDomainSetChardevLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+typedef int (*virSecurityDomainSetChardevLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd);
-typedef int (*virSecurityDomainRestoreChardevLabel) (virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+typedef int (*virSecurityDomainRestoreChardevLabel) (virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd);
-typedef int (*virSecurityDomainSetTPMLabels) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-typedef int (*virSecurityDomainRestoreTPMLabels) (virSecurityManagerPtr mgr,
- virDomainDefPtr def);
+typedef int (*virSecurityDomainSetTPMLabels) (virSecurityManager *mgr,
+ virDomainDef *def);
+typedef int (*virSecurityDomainRestoreTPMLabels) (virSecurityManager *mgr,
+ virDomainDef *def);
struct _virSecurityDriver {
virSecurityDomainRestoreTPMLabels domainRestoreSecurityTPMLabels;
};
-virSecurityDriverPtr virSecurityDriverLookup(const char *name,
+virSecurityDriver *virSecurityDriverLookup(const char *name,
const char *virtDriver);
struct _virSecurityManager {
virObjectLockable parent;
- virSecurityDriverPtr drv;
+ virSecurityDriver *drv;
unsigned int flags;
const char *virtDriver;
void *privateData;
};
-static virClassPtr virSecurityManagerClass;
+static virClass *virSecurityManagerClass;
static
void virSecurityManagerDispose(void *obj)
{
- virSecurityManagerPtr mgr = obj;
+ virSecurityManager *mgr = obj;
if (mgr->drv->close)
mgr->drv->close(mgr);
VIR_ONCE_GLOBAL_INIT(virSecurityManager);
-static virSecurityManagerPtr
-virSecurityManagerNewDriver(virSecurityDriverPtr drv,
+static virSecurityManager *
+virSecurityManagerNewDriver(virSecurityDriver *drv,
const char *virtDriver,
unsigned int flags)
{
- virSecurityManagerPtr mgr = NULL;
+ virSecurityManager *mgr = NULL;
char *privateData = NULL;
if (virSecurityManagerInitialize() < 0)
}
-virSecurityManagerPtr
-virSecurityManagerNewStack(virSecurityManagerPtr primary)
+virSecurityManager *
+virSecurityManagerNewStack(virSecurityManager *primary)
{
- virSecurityManagerPtr mgr =
+ virSecurityManager *mgr =
virSecurityManagerNewDriver(&virSecurityDriverStack,
virSecurityManagerGetVirtDriver(primary),
primary->flags);
int
-virSecurityManagerStackAddNested(virSecurityManagerPtr stack,
- virSecurityManagerPtr nested)
+virSecurityManagerStackAddNested(virSecurityManager *stack,
+ virSecurityManager *nested)
{
if (STRNEQ("stack", stack->drv->name))
return -1;
}
-virSecurityManagerPtr
+virSecurityManager *
virSecurityManagerNewDAC(const char *virtDriver,
uid_t user,
gid_t group,
unsigned int flags,
virSecurityManagerDACChownCallback chownCallback)
{
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
virCheckFlags(VIR_SECURITY_MANAGER_NEW_MASK |
VIR_SECURITY_MANAGER_DYNAMIC_OWNERSHIP |
}
-virSecurityManagerPtr
+virSecurityManager *
virSecurityManagerNew(const char *name,
const char *virtDriver,
unsigned int flags)
{
- virSecurityDriverPtr drv = virSecurityDriverLookup(name, virtDriver);
+ virSecurityDriver *drv = virSecurityDriverLookup(name, virtDriver);
if (!drv)
return NULL;
* parent and child.
*/
int
-virSecurityManagerPreFork(virSecurityManagerPtr mgr)
+virSecurityManagerPreFork(virSecurityManager *mgr)
{
int ret = 0;
* to ensure mutex state is sane for the child to use
*/
void
-virSecurityManagerPostFork(virSecurityManagerPtr mgr)
+virSecurityManagerPostFork(virSecurityManager *mgr)
{
virObjectUnlock(mgr);
}
* -1 otherwise.
*/
int
-virSecurityManagerTransactionStart(virSecurityManagerPtr mgr)
+virSecurityManagerTransactionStart(virSecurityManager *mgr)
{
int ret = 0;
* -1 otherwise.
*/
int
-virSecurityManagerTransactionCommit(virSecurityManagerPtr mgr,
+virSecurityManagerTransactionCommit(virSecurityManager *mgr,
pid_t pid,
bool lock)
{
* Cancels and frees any out standing transaction.
*/
void
-virSecurityManagerTransactionAbort(virSecurityManagerPtr mgr)
+virSecurityManagerTransactionAbort(virSecurityManager *mgr)
{
virObjectLock(mgr);
if (mgr->drv->transactionAbort)
void *
-virSecurityManagerGetPrivateData(virSecurityManagerPtr mgr)
+virSecurityManagerGetPrivateData(virSecurityManager *mgr)
{
return mgr->privateData;
}
const char *
-virSecurityManagerGetVirtDriver(virSecurityManagerPtr mgr)
+virSecurityManagerGetVirtDriver(virSecurityManager *mgr)
{
return mgr->virtDriver;
}
const char *
-virSecurityManagerGetDriver(virSecurityManagerPtr mgr)
+virSecurityManagerGetDriver(virSecurityManager *mgr)
{
return mgr->drv->name;
}
const char *
-virSecurityManagerGetDOI(virSecurityManagerPtr mgr)
+virSecurityManagerGetDOI(virSecurityManager *mgr)
{
if (mgr->drv->getDOI) {
const char *ret;
const char *
-virSecurityManagerGetModel(virSecurityManagerPtr mgr)
+virSecurityManagerGetModel(virSecurityManager *mgr)
{
if (mgr->drv->getModel) {
const char *ret;
/* return NULL if a base label is not present */
const char *
-virSecurityManagerGetBaseLabel(virSecurityManagerPtr mgr,
+virSecurityManagerGetBaseLabel(virSecurityManager *mgr,
int virtType)
{
if (mgr->drv->getBaseLabel) {
bool
-virSecurityManagerGetDefaultConfined(virSecurityManagerPtr mgr)
+virSecurityManagerGetDefaultConfined(virSecurityManager *mgr)
{
return mgr->flags & VIR_SECURITY_MANAGER_DEFAULT_CONFINED;
}
bool
-virSecurityManagerGetRequireConfined(virSecurityManagerPtr mgr)
+virSecurityManagerGetRequireConfined(virSecurityManager *mgr)
{
return mgr->flags & VIR_SECURITY_MANAGER_REQUIRE_CONFINED;
}
bool
-virSecurityManagerGetPrivileged(virSecurityManagerPtr mgr)
+virSecurityManagerGetPrivileged(virSecurityManager *mgr)
{
return mgr->flags & VIR_SECURITY_MANAGER_PRIVILEGED;
}
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerRestoreImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+virSecurityManagerRestoreImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
if (mgr->drv->domainRestoreSecurityImageLabel) {
* -1 otherwise.
*/
int
-virSecurityManagerMoveImageMetadata(virSecurityManagerPtr mgr,
+virSecurityManagerMoveImageMetadata(virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst)
+ virStorageSource *src,
+ virStorageSource *dst)
{
if (mgr->drv->domainMoveImageMetadata) {
int ret;
int
-virSecurityManagerSetDaemonSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerSetDaemonSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainSetSecurityDaemonSocketLabel) {
int ret;
int
-virSecurityManagerSetSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerSetSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainSetSecuritySocketLabel) {
int ret;
int
-virSecurityManagerClearSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerClearSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainClearSecuritySocketLabel) {
int ret;
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerSetImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+virSecurityManagerSetImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
if (mgr->drv->domainSetSecurityImageLabel) {
int
-virSecurityManagerRestoreHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainHostdevDefPtr dev,
+virSecurityManagerRestoreHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainHostdevDef *dev,
const char *vroot)
{
if (mgr->drv->domainRestoreSecurityHostdevLabel) {
int
-virSecurityManagerSetHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainHostdevDefPtr dev,
+virSecurityManagerSetHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainHostdevDef *dev,
const char *vroot)
{
if (mgr->drv->domainSetSecurityHostdevLabel) {
int
-virSecurityManagerSetSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerSetSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *savefile)
{
if (mgr->drv->domainSetSavedStateLabel) {
int
-virSecurityManagerRestoreSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerRestoreSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *savefile)
{
if (mgr->drv->domainRestoreSavedStateLabel) {
int
-virSecurityManagerGenLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerGenLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
int ret = -1;
size_t i;
- virSecurityManagerPtr* sec_managers = NULL;
- virSecurityLabelDefPtr seclabel;
+ virSecurityManager ** sec_managers = NULL;
+ virSecurityLabelDef *seclabel;
bool generated = false;
if ((sec_managers = virSecurityManagerGetNested(mgr)) == NULL)
int
-virSecurityManagerReserveLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerReserveLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
pid_t pid)
{
if (mgr->drv->domainReserveSecurityLabel) {
int
-virSecurityManagerReleaseLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerReleaseLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainReleaseSecurityLabel) {
int ret;
}
-static int virSecurityManagerCheckModel(virSecurityManagerPtr mgr,
+static int virSecurityManagerCheckModel(virSecurityManager *mgr,
char *secmodel)
{
int ret = -1;
size_t i;
- virSecurityManagerPtr *sec_managers = NULL;
+ virSecurityManager **sec_managers = NULL;
if (STREQ_NULLABLE(secmodel, "none"))
return 0;
static int
-virSecurityManagerCheckDomainLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityManagerCheckDomainLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
size_t i;
static int
-virSecurityManagerCheckDiskLabel(virSecurityManagerPtr mgr,
- virDomainDiskDefPtr disk)
+virSecurityManagerCheckDiskLabel(virSecurityManager *mgr,
+ virDomainDiskDef *disk)
{
size_t i;
static int
-virSecurityManagerCheckChardevLabel(virSecurityManagerPtr mgr,
- virDomainChrDefPtr dev)
+virSecurityManagerCheckChardevLabel(virSecurityManager *mgr,
+ virDomainChrDef *dev)
{
size_t i;
static int
-virSecurityManagerCheckChardevCallback(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrDefPtr dev,
+virSecurityManagerCheckChardevCallback(virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrDef *dev,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecurityManagerCheckChardevLabel(mgr, dev);
}
-int virSecurityManagerCheckAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+int virSecurityManagerCheckAllLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
size_t i;
int
-virSecurityManagerSetAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerSetAllLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *incomingPath,
bool chardevStdioLogd,
bool migrated)
int
-virSecurityManagerRestoreAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerRestoreAllLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
bool migrated,
bool chardevStdioLogd)
{
}
int
-virSecurityManagerGetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerGetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
pid_t pid,
virSecurityLabelPtr sec)
{
int
-virSecurityManagerSetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerSetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainSetSecurityProcessLabel) {
int ret;
int
-virSecurityManagerSetChildProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virCommandPtr cmd)
+virSecurityManagerSetChildProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virCommand *cmd)
{
if (mgr->drv->domainSetSecurityChildProcessLabel)
return mgr->drv->domainSetSecurityChildProcessLabel(mgr, vm, cmd);
int
-virSecurityManagerVerify(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityManagerVerify(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
if (mgr == NULL || mgr->drv == NULL)
return 0;
int
-virSecurityManagerSetImageFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerSetImageFDLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
int fd)
{
if (mgr->drv->domainSetSecurityImageFDLabel) {
int
-virSecurityManagerSetTapFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerSetTapFDLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
int fd)
{
if (mgr->drv->domainSetSecurityTapFDLabel) {
char *
-virSecurityManagerGetMountOptions(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerGetMountOptions(virSecurityManager *mgr,
+ virDomainDef *vm)
{
if (mgr->drv->domainGetSecurityMountOptions) {
char *ret;
}
-virSecurityManagerPtr*
-virSecurityManagerGetNested(virSecurityManagerPtr mgr)
+virSecurityManager **
+virSecurityManagerGetNested(virSecurityManager *mgr)
{
- virSecurityManagerPtr* list = NULL;
+ virSecurityManager ** list = NULL;
if (STREQ("stack", mgr->drv->name))
return virSecurityStackGetNested(mgr);
- list = g_new0(virSecurityManagerPtr, 2);
+ list = g_new0(virSecurityManager *, 2);
list[0] = mgr;
list[1] = NULL;
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerDomainSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerDomainSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path,
bool allowSubtree)
{
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerDomainSetPathLabelRO(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerDomainSetPathLabelRO(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path)
{
if (mgr->drv->domainSetPathLabelRO) {
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerDomainRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityManagerDomainRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path)
{
if (mgr->drv->domainRestorePathLabel) {
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem)
+virSecurityManagerSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem)
{
if (mgr->drv->domainSetSecurityMemoryLabel) {
int ret;
* Returns: 0 on success, -1 on error.
*/
int
-virSecurityManagerRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem)
+virSecurityManagerRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem)
{
if (mgr->drv->domainRestoreSecurityMemoryLabel) {
int ret;
int
-virSecurityManagerSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input)
+virSecurityManagerSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input)
{
if (mgr->drv->domainSetSecurityInputLabel) {
int ret;
int
-virSecurityManagerRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input)
+virSecurityManagerRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input)
{
if (mgr->drv->domainRestoreSecurityInputLabel) {
int ret;
int
-virSecurityManagerSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityManagerSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
if (mgr->drv->domainSetSecurityChardevLabel) {
int
-virSecurityManagerRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityManagerRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
if (mgr->drv->domainRestoreSecurityChardevLabel) {
int
-virSecurityManagerSetTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerSetTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm)
{
int ret;
int
-virSecurityManagerRestoreTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityManagerRestoreTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm)
{
int ret;
* Returns: state on success,
* NULL on failure.
*/
-virSecurityManagerMetadataLockStatePtr
-virSecurityManagerMetadataLock(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+virSecurityManagerMetadataLockState *
+virSecurityManagerMetadataLock(virSecurityManager *mgr G_GNUC_UNUSED,
const char **paths,
size_t npaths)
{
size_t nfds = 0;
int *fds = NULL;
const char **locked_paths = NULL;
- virSecurityManagerMetadataLockStatePtr ret = NULL;
+ virSecurityManagerMetadataLockState *ret = NULL;
fds = g_new0(int, npaths);
locked_paths = g_new0(const char *, npaths);
void
-virSecurityManagerMetadataUnlock(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virSecurityManagerMetadataLockStatePtr *state)
+virSecurityManagerMetadataUnlock(virSecurityManager *mgr G_GNUC_UNUSED,
+ virSecurityManagerMetadataLockState **state)
{
size_t i;
#include "virstoragefile.h"
typedef struct _virSecurityManager virSecurityManager;
-typedef virSecurityManager *virSecurityManagerPtr;
typedef enum {
VIR_SECURITY_MANAGER_DEFAULT_CONFINED = 1 << 1,
VIR_SECURITY_MANAGER_REQUIRE_CONFINED | \
VIR_SECURITY_MANAGER_PRIVILEGED)
-virSecurityManagerPtr virSecurityManagerNew(const char *name,
+virSecurityManager *virSecurityManagerNew(const char *name,
const char *virtDriver,
unsigned int flags);
-virSecurityManagerPtr virSecurityManagerNewStack(virSecurityManagerPtr primary);
-int virSecurityManagerStackAddNested(virSecurityManagerPtr stack,
- virSecurityManagerPtr nested);
+virSecurityManager *virSecurityManagerNewStack(virSecurityManager *primary);
+int virSecurityManagerStackAddNested(virSecurityManager *stack,
+ virSecurityManager *nested);
/**
* virSecurityManagerDACChownCallback:
gid_t gid);
-virSecurityManagerPtr virSecurityManagerNewDAC(const char *virtDriver,
+virSecurityManager *virSecurityManagerNewDAC(const char *virtDriver,
uid_t user,
gid_t group,
unsigned int flags,
virSecurityManagerDACChownCallback chownCallback);
-int virSecurityManagerPreFork(virSecurityManagerPtr mgr);
-void virSecurityManagerPostFork(virSecurityManagerPtr mgr);
+int virSecurityManagerPreFork(virSecurityManager *mgr);
+void virSecurityManagerPostFork(virSecurityManager *mgr);
-int virSecurityManagerTransactionStart(virSecurityManagerPtr mgr);
-int virSecurityManagerTransactionCommit(virSecurityManagerPtr mgr,
+int virSecurityManagerTransactionStart(virSecurityManager *mgr);
+int virSecurityManagerTransactionCommit(virSecurityManager *mgr,
pid_t pid,
bool lock);
-void virSecurityManagerTransactionAbort(virSecurityManagerPtr mgr);
-
-void *virSecurityManagerGetPrivateData(virSecurityManagerPtr mgr);
-
-const char *virSecurityManagerGetDriver(virSecurityManagerPtr mgr);
-const char *virSecurityManagerGetVirtDriver(virSecurityManagerPtr mgr);
-const char *virSecurityManagerGetDOI(virSecurityManagerPtr mgr);
-const char *virSecurityManagerGetModel(virSecurityManagerPtr mgr);
-const char *virSecurityManagerGetBaseLabel(virSecurityManagerPtr mgr, int virtType);
-
-bool virSecurityManagerGetDefaultConfined(virSecurityManagerPtr mgr);
-bool virSecurityManagerGetRequireConfined(virSecurityManagerPtr mgr);
-bool virSecurityManagerGetPrivileged(virSecurityManagerPtr mgr);
-
-int virSecurityManagerSetDaemonSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm);
-int virSecurityManagerSetSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-int virSecurityManagerClearSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-int virSecurityManagerRestoreHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+void virSecurityManagerTransactionAbort(virSecurityManager *mgr);
+
+void *virSecurityManagerGetPrivateData(virSecurityManager *mgr);
+
+const char *virSecurityManagerGetDriver(virSecurityManager *mgr);
+const char *virSecurityManagerGetVirtDriver(virSecurityManager *mgr);
+const char *virSecurityManagerGetDOI(virSecurityManager *mgr);
+const char *virSecurityManagerGetModel(virSecurityManager *mgr);
+const char *virSecurityManagerGetBaseLabel(virSecurityManager *mgr, int virtType);
+
+bool virSecurityManagerGetDefaultConfined(virSecurityManager *mgr);
+bool virSecurityManagerGetRequireConfined(virSecurityManager *mgr);
+bool virSecurityManagerGetPrivileged(virSecurityManager *mgr);
+
+int virSecurityManagerSetDaemonSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm);
+int virSecurityManagerSetSocketLabel(virSecurityManager *mgr,
+ virDomainDef *def);
+int virSecurityManagerClearSocketLabel(virSecurityManager *mgr,
+ virDomainDef *def);
+int virSecurityManagerRestoreHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot);
-int virSecurityManagerSetHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+int virSecurityManagerSetHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot);
-int virSecurityManagerSetSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerSetSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile);
-int virSecurityManagerRestoreSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerRestoreSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile);
-int virSecurityManagerGenLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr sec);
-int virSecurityManagerReserveLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr sec,
+int virSecurityManagerGenLabel(virSecurityManager *mgr,
+ virDomainDef *sec);
+int virSecurityManagerReserveLabel(virSecurityManager *mgr,
+ virDomainDef *sec,
pid_t pid);
-int virSecurityManagerReleaseLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr sec);
-int virSecurityManagerCheckAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr sec);
-int virSecurityManagerSetAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr sec,
+int virSecurityManagerReleaseLabel(virSecurityManager *mgr,
+ virDomainDef *sec);
+int virSecurityManagerCheckAllLabel(virSecurityManager *mgr,
+ virDomainDef *sec);
+int virSecurityManagerSetAllLabel(virSecurityManager *mgr,
+ virDomainDef *sec,
const char *incomingPath,
bool chardevStdioLogd,
bool migrated);
-int virSecurityManagerRestoreAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerRestoreAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
bool migrated,
bool chardevStdioLogd);
-int virSecurityManagerGetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerGetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *def,
pid_t pid,
virSecurityLabelPtr sec);
-int virSecurityManagerSetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-int virSecurityManagerSetChildProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virCommandPtr cmd);
-int virSecurityManagerVerify(virSecurityManagerPtr mgr,
- virDomainDefPtr def);
-int virSecurityManagerSetImageFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerSetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *def);
+int virSecurityManagerSetChildProcessLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virCommand *cmd);
+int virSecurityManagerVerify(virSecurityManager *mgr,
+ virDomainDef *def);
+int virSecurityManagerSetImageFDLabel(virSecurityManager *mgr,
+ virDomainDef *def,
int fd);
-int virSecurityManagerSetTapFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+int virSecurityManagerSetTapFDLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
int fd);
-char *virSecurityManagerGetMountOptions(virSecurityManagerPtr mgr,
- virDomainDefPtr vm);
-virSecurityManagerPtr* virSecurityManagerGetNested(virSecurityManagerPtr mgr);
+char *virSecurityManagerGetMountOptions(virSecurityManager *mgr,
+ virDomainDef *vm);
+virSecurityManager ** virSecurityManagerGetNested(virSecurityManager *mgr);
typedef enum {
VIR_SECURITY_DOMAIN_IMAGE_LABEL_BACKING_CHAIN = 1 << 0,
VIR_SECURITY_DOMAIN_IMAGE_PARENT_CHAIN_TOP = 1 << 1,
} virSecurityDomainImageLabelFlags;
-int virSecurityManagerSetImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+int virSecurityManagerSetImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags);
-int virSecurityManagerRestoreImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+int virSecurityManagerRestoreImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags);
-int virSecurityManagerMoveImageMetadata(virSecurityManagerPtr mgr,
+int virSecurityManagerMoveImageMetadata(virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst);
-
-int virSecurityManagerSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem);
-int virSecurityManagerRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem);
-
-int virSecurityManagerSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input);
-int virSecurityManagerRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input);
-
-int virSecurityManagerDomainSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+ virStorageSource *src,
+ virStorageSource *dst);
+
+int virSecurityManagerSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem);
+int virSecurityManagerRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem);
+
+int virSecurityManagerSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input);
+int virSecurityManagerRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input);
+
+int virSecurityManagerDomainSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path,
bool allowSubtree);
-int virSecurityManagerDomainSetPathLabelRO(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+int virSecurityManagerDomainSetPathLabelRO(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path);
-int virSecurityManagerDomainRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+int virSecurityManagerDomainRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path);
-int virSecurityManagerSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+int virSecurityManagerSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd);
-int virSecurityManagerRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+int virSecurityManagerRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd);
-int virSecurityManagerSetTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm);
+int virSecurityManagerSetTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm);
-int virSecurityManagerRestoreTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm);
+int virSecurityManagerRestoreTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm);
typedef struct _virSecurityManagerMetadataLockState virSecurityManagerMetadataLockState;
-typedef virSecurityManagerMetadataLockState *virSecurityManagerMetadataLockStatePtr;
struct _virSecurityManagerMetadataLockState {
size_t nfds; /* Captures size of both @fds and @paths */
int *fds;
};
-virSecurityManagerMetadataLockStatePtr
-virSecurityManagerMetadataLock(virSecurityManagerPtr mgr,
+virSecurityManagerMetadataLockState *
+virSecurityManagerMetadataLock(virSecurityManager *mgr,
const char **paths,
size_t npaths);
void
-virSecurityManagerMetadataUnlock(virSecurityManagerPtr mgr,
- virSecurityManagerMetadataLockStatePtr *state);
+virSecurityManagerMetadataUnlock(virSecurityManager *mgr,
+ virSecurityManagerMetadataLockState **state);
}
static int
-virSecurityDriverOpenNop(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDriverOpenNop(virSecurityManager *mgr G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDriverCloseNop(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDriverCloseNop(virSecurityManager *mgr G_GNUC_UNUSED)
{
return 0;
}
static const char *
-virSecurityDriverGetModelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDriverGetModelNop(virSecurityManager *mgr G_GNUC_UNUSED)
{
return "none";
}
static const char *
-virSecurityDriverGetDOINop(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityDriverGetDOINop(virSecurityManager *mgr G_GNUC_UNUSED)
{
return "0";
}
static int
-virSecurityDomainSetDaemonSocketLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDomainSetDaemonSocketLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetSocketLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDomainSetSocketLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainClearSocketLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDomainClearSocketLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainRestoreHostdevLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED,
- virDomainHostdevDefPtr dev G_GNUC_UNUSED,
+virSecurityDomainRestoreHostdevLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED,
+ virDomainHostdevDef *dev G_GNUC_UNUSED,
const char *vroot G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetHostdevLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED,
- virDomainHostdevDefPtr dev G_GNUC_UNUSED,
+virSecurityDomainSetHostdevLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED,
+ virDomainHostdevDef *dev G_GNUC_UNUSED,
const char *vroot G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainGenLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr sec G_GNUC_UNUSED)
+virSecurityDomainGenLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *sec G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainReserveLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr sec G_GNUC_UNUSED,
+virSecurityDomainReserveLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *sec G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainReleaseLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr sec G_GNUC_UNUSED)
+virSecurityDomainReleaseLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *sec G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetAllLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr sec G_GNUC_UNUSED,
+virSecurityDomainSetAllLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *sec G_GNUC_UNUSED,
const char *incomingPath G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED,
bool migrated G_GNUC_UNUSED)
}
static int
-virSecurityDomainRestoreAllLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED,
+virSecurityDomainRestoreAllLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED,
bool migrated G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED)
{
}
static int
-virSecurityDomainGetProcessLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED,
+virSecurityDomainGetProcessLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED,
virSecurityLabelPtr sec G_GNUC_UNUSED)
{
}
static int
-virSecurityDomainSetProcessLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDomainSetProcessLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetChildProcessLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED,
- virCommandPtr cmd G_GNUC_UNUSED)
+virSecurityDomainSetChildProcessLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED,
+ virCommand *cmd G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainVerifyNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED)
+virSecurityDomainVerifyNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetFDLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr sec G_GNUC_UNUSED,
+virSecurityDomainSetFDLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *sec G_GNUC_UNUSED,
int fd G_GNUC_UNUSED)
{
return 0;
}
static char *
-virSecurityDomainGetMountOptionsNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityDomainGetMountOptionsNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
char *opts;
}
static const char *
-virSecurityGetBaseLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+virSecurityGetBaseLabel(virSecurityManager *mgr G_GNUC_UNUSED,
int virtType G_GNUC_UNUSED)
{
return NULL;
}
static int
-virSecurityDomainRestoreImageLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virStorageSourcePtr src G_GNUC_UNUSED,
+virSecurityDomainRestoreImageLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virStorageSource *src G_GNUC_UNUSED,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetImageLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virStorageSourcePtr src G_GNUC_UNUSED,
+virSecurityDomainSetImageLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virStorageSource *src G_GNUC_UNUSED,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainMoveImageMetadataNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+virSecurityDomainMoveImageMetadataNop(virSecurityManager *mgr G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED,
- virStorageSourcePtr src G_GNUC_UNUSED,
- virStorageSourcePtr dst G_GNUC_UNUSED)
+ virStorageSource *src G_GNUC_UNUSED,
+ virStorageSource *dst G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetMemoryLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainMemoryDefPtr mem G_GNUC_UNUSED)
+virSecurityDomainSetMemoryLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainMemoryDef *mem G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainRestoreMemoryLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainMemoryDefPtr mem G_GNUC_UNUSED)
+virSecurityDomainRestoreMemoryLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainMemoryDef *mem G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainInputLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainInputDefPtr input G_GNUC_UNUSED)
+virSecurityDomainInputLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainInputDef *input G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainSetChardevLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrSourceDefPtr dev_source G_GNUC_UNUSED,
+virSecurityDomainSetChardevLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrSourceDef *dev_source G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityDomainRestoreChardevLabelNop(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
- virDomainChrSourceDefPtr dev_source G_GNUC_UNUSED,
+virSecurityDomainRestoreChardevLabelNop(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
+ virDomainChrSourceDef *dev_source G_GNUC_UNUSED,
bool chardevStdioLogd G_GNUC_UNUSED)
{
return 0;
#define MAX_CONTEXT 1024
typedef struct _virSecuritySELinuxData virSecuritySELinuxData;
-typedef virSecuritySELinuxData *virSecuritySELinuxDataPtr;
-
struct _virSecuritySELinuxData {
char *domain_context;
char *alt_domain_context;
/* Data structure to pass to various callbacks so we have everything we need */
typedef struct _virSecuritySELinuxCallbackData virSecuritySELinuxCallbackData;
-typedef virSecuritySELinuxCallbackData *virSecuritySELinuxCallbackDataPtr;
-
struct _virSecuritySELinuxCallbackData {
- virSecurityManagerPtr mgr;
- virDomainDefPtr def;
+ virSecurityManager *mgr;
+ virDomainDef *def;
};
typedef struct _virSecuritySELinuxContextItem virSecuritySELinuxContextItem;
-typedef virSecuritySELinuxContextItem *virSecuritySELinuxContextItemPtr;
struct _virSecuritySELinuxContextItem {
char *path;
char *tcon;
};
typedef struct _virSecuritySELinuxContextList virSecuritySELinuxContextList;
-typedef virSecuritySELinuxContextList *virSecuritySELinuxContextListPtr;
struct _virSecuritySELinuxContextList {
- virSecurityManagerPtr manager;
- virSecuritySELinuxContextItemPtr *items;
+ virSecurityManager *manager;
+ virSecuritySELinuxContextItem **items;
size_t nItems;
bool lock;
};
#define SECURITY_SELINUX_NAME "selinux"
static int
-virSecuritySELinuxRestoreTPMFileLabelInt(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainTPMDefPtr tpm);
+virSecuritySELinuxRestoreTPMFileLabelInt(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainTPMDef *tpm);
virThreadLocal contextList;
static void
-virSecuritySELinuxContextItemFree(virSecuritySELinuxContextItemPtr item)
+virSecuritySELinuxContextItemFree(virSecuritySELinuxContextItem *item)
{
if (!item)
return;
}
static int
-virSecuritySELinuxContextListAppend(virSecuritySELinuxContextListPtr list,
+virSecuritySELinuxContextListAppend(virSecuritySELinuxContextList *list,
const char *path,
const char *tcon,
bool remember,
bool restore)
{
int ret = -1;
- virSecuritySELinuxContextItemPtr item = NULL;
+ virSecuritySELinuxContextItem *item = NULL;
item = g_new0(virSecuritySELinuxContextItem, 1);
static void
virSecuritySELinuxContextListFree(void *opaque)
{
- virSecuritySELinuxContextListPtr list = opaque;
+ virSecuritySELinuxContextList *list = opaque;
size_t i;
if (!list)
bool remember,
bool restore)
{
- virSecuritySELinuxContextListPtr list;
+ virSecuritySELinuxContextList *list;
list = virThreadLocalGet(&contextList);
if (!list)
}
-static int virSecuritySELinuxSetFilecon(virSecurityManagerPtr mgr,
+static int virSecuritySELinuxSetFilecon(virSecurityManager *mgr,
const char *path,
const char *tcon,
bool remember);
-static int virSecuritySELinuxRestoreFileLabel(virSecurityManagerPtr mgr,
+static int virSecuritySELinuxRestoreFileLabel(virSecurityManager *mgr,
const char *path,
bool recall);
virSecuritySELinuxTransactionRun(pid_t pid G_GNUC_UNUSED,
void *opaque)
{
- virSecuritySELinuxContextListPtr list = opaque;
- virSecurityManagerMetadataLockStatePtr state;
+ virSecuritySELinuxContextList *list = opaque;
+ virSecurityManagerMetadataLockState *state;
const char **paths = NULL;
size_t npaths = 0;
size_t i;
paths = g_new0(const char *, list->nItems);
for (i = 0; i < list->nItems; i++) {
- virSecuritySELinuxContextItemPtr item = list->items[i];
+ virSecuritySELinuxContextItem *item = list->items[i];
const char *p = item->path;
if (item->remember)
goto cleanup;
for (i = 0; i < list->nItems; i++) {
- virSecuritySELinuxContextItemPtr item = list->items[i];
+ virSecuritySELinuxContextItem *item = list->items[i];
size_t j;
for (j = 0; j < state->nfds; j++) {
rv = 0;
for (i = 0; i < list->nItems; i++) {
- virSecuritySELinuxContextItemPtr item = list->items[i];
+ virSecuritySELinuxContextItem *item = list->items[i];
const bool remember = item->remember && list->lock;
if (!item->restore) {
}
for (; rv < 0 && i > 0; i--) {
- virSecuritySELinuxContextItemPtr item = list->items[i - 1];
+ virSecuritySELinuxContextItem *item = list->items[i - 1];
const bool remember = item->remember && list->lock;
if (!item->restore) {
* Returns 0 on success, 1 if already reserved, or -1 on fatal error
*/
static int
-virSecuritySELinuxMCSAdd(virSecurityManagerPtr mgr,
+virSecuritySELinuxMCSAdd(virSecurityManager *mgr,
const char *mcs)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
if (virHashLookup(data->mcs, mcs))
return 1;
}
static void
-virSecuritySELinuxMCSRemove(virSecurityManagerPtr mgr,
+virSecuritySELinuxMCSRemove(virSecurityManager *mgr,
const char *mcs)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
virHashRemoveEntry(data->mcs, mcs);
}
static char *
-virSecuritySELinuxMCSFind(virSecurityManagerPtr mgr,
+virSecuritySELinuxMCSFind(virSecurityManager *mgr,
const char *sens,
int catMin,
int catMax)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
int catRange;
char *mcs = NULL;
static int
-virSecuritySELinuxLXCInitialize(virSecurityManagerPtr mgr)
+virSecuritySELinuxLXCInitialize(virSecurityManager *mgr)
{
g_autoptr(virConf) selinux_conf = NULL;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
data->skipAllLabel = true;
static int
-virSecuritySELinuxQEMUInitialize(virSecurityManagerPtr mgr)
+virSecuritySELinuxQEMUInitialize(virSecurityManager *mgr)
{
char *ptr;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
data->skipAllLabel = false;
static int
-virSecuritySELinuxInitialize(virSecurityManagerPtr mgr)
+virSecuritySELinuxInitialize(virSecurityManager *mgr)
{
VIR_DEBUG("SELinuxInitialize %s", virSecurityManagerGetVirtDriver(mgr));
static int
-virSecuritySELinuxGenLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxGenLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
int rc = -1;
char *mcs = NULL;
context_t ctx = NULL;
const char *range;
- virSecurityLabelDefPtr seclabel;
- virSecuritySELinuxDataPtr data;
+ virSecurityLabelDef *seclabel;
+ virSecuritySELinuxData *data;
const char *baselabel;
char *sens = NULL;
int catMin, catMax;
}
static int
-virSecuritySELinuxReserveLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxReserveLabel(virSecurityManager *mgr,
+ virDomainDef *def,
pid_t pid)
{
char *pctx;
context_t ctx = NULL;
const char *mcs;
int rv;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel ||
static int
-virSecuritySELinuxDriverOpen(virSecurityManagerPtr mgr)
+virSecuritySELinuxDriverOpen(virSecurityManager *mgr)
{
return virSecuritySELinuxInitialize(mgr);
}
static int
-virSecuritySELinuxDriverClose(virSecurityManagerPtr mgr)
+virSecuritySELinuxDriverClose(virSecurityManager *mgr)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
if (!data)
return 0;
static const char *
-virSecuritySELinuxGetModel(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecuritySELinuxGetModel(virSecurityManager *mgr G_GNUC_UNUSED)
{
return SECURITY_SELINUX_NAME;
}
static const char *
-virSecuritySELinuxGetDOI(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecuritySELinuxGetDOI(virSecurityManager *mgr G_GNUC_UNUSED)
{
/*
* Where will the DOI come from? SELinux configuration, or qemu
* -1 otherwise.
*/
static int
-virSecuritySELinuxTransactionStart(virSecurityManagerPtr mgr)
+virSecuritySELinuxTransactionStart(virSecurityManager *mgr)
{
- virSecuritySELinuxContextListPtr list;
+ virSecuritySELinuxContextList *list;
list = virThreadLocalGet(&contextList);
if (list) {
* -1 otherwise.
*/
static int
-virSecuritySELinuxTransactionCommit(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+virSecuritySELinuxTransactionCommit(virSecurityManager *mgr G_GNUC_UNUSED,
pid_t pid,
bool lock)
{
- virSecuritySELinuxContextListPtr list;
+ virSecuritySELinuxContextList *list;
int rc;
int ret = -1;
* Cancels and frees any out standing transaction.
*/
static void
-virSecuritySELinuxTransactionAbort(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecuritySELinuxTransactionAbort(virSecurityManager *mgr G_GNUC_UNUSED)
{
- virSecuritySELinuxContextListPtr list;
+ virSecuritySELinuxContextList *list;
list = virThreadLocalGet(&contextList);
if (!list)
}
static int
-virSecuritySELinuxGetProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def G_GNUC_UNUSED,
+virSecuritySELinuxGetProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def G_GNUC_UNUSED,
pid_t pid,
virSecurityLabelPtr sec)
{
static int
-virSecuritySELinuxSetFilecon(virSecurityManagerPtr mgr,
+virSecuritySELinuxSetFilecon(virSecurityManager *mgr,
const char *path,
const char *tcon,
bool remember)
/* Set fcon to the appropriate label for path and mode, or return -1. */
static int
-getContext(virSecurityManagerPtr mgr G_GNUC_UNUSED,
+getContext(virSecurityManager *mgr G_GNUC_UNUSED,
const char *newpath, mode_t mode, char **fcon)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
return selabel_lookup_raw(data->label_handle, fcon, newpath, mode);
}
/* This method shouldn't raise errors, since they'll overwrite
* errors that the caller(s) are already dealing with */
static int
-virSecuritySELinuxRestoreFileLabel(virSecurityManagerPtr mgr,
+virSecuritySELinuxRestoreFileLabel(virSecurityManager *mgr,
const char *path,
bool recall)
{
static int
-virSecuritySELinuxSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input)
+virSecuritySELinuxSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input)
{
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (seclabel == NULL)
static int
-virSecuritySELinuxRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainInputDefPtr input)
+virSecuritySELinuxRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainInputDef *input)
{
int rc = 0;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (seclabel == NULL)
static int
-virSecuritySELinuxSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virSecuritySELinuxSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem)
{
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
static int
-virSecuritySELinuxRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainMemoryDefPtr mem)
+virSecuritySELinuxRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainMemoryDef *mem)
{
int ret = -1;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
static int
-virSecuritySELinuxSetTPMFileLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainTPMDefPtr tpm)
+virSecuritySELinuxSetTPMFileLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainTPMDef *tpm)
{
int rc;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
char *cancel_path;
const char *tpmdev;
static int
-virSecuritySELinuxRestoreTPMFileLabelInt(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainTPMDefPtr tpm)
+virSecuritySELinuxRestoreTPMFileLabelInt(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainTPMDef *tpm)
{
int rc = 0;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
char *cancel_path;
const char *tpmdev;
static int
-virSecuritySELinuxRestoreImageLabelSingle(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecuritySELinuxRestoreImageLabelSingle(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
bool migrated)
{
- virSecurityLabelDefPtr seclabel;
- virSecurityDeviceLabelDefPtr disk_seclabel;
+ virSecurityLabelDef *seclabel;
+ virSecurityDeviceLabelDef *disk_seclabel;
g_autofree char *vfioGroupDev = NULL;
const char *path = src->path;
static int
-virSecuritySELinuxRestoreImageLabelInt(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecuritySELinuxRestoreImageLabelInt(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
bool migrated)
{
if (virSecuritySELinuxRestoreImageLabelSingle(mgr, def, src, migrated) < 0)
static int
-virSecuritySELinuxRestoreImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecuritySELinuxRestoreImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags G_GNUC_UNUSED)
{
return virSecuritySELinuxRestoreImageLabelInt(mgr, def, src, false);
static int
-virSecuritySELinuxSetImageLabelInternal(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virSecuritySELinuxSetImageLabelInternal(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
+ virStorageSource *parent,
bool isChainTop)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
- virSecurityDeviceLabelDefPtr disk_seclabel;
- virSecurityDeviceLabelDefPtr parent_seclabel = NULL;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecurityDeviceLabelDef *disk_seclabel;
+ virSecurityDeviceLabelDef *parent_seclabel = NULL;
char *use_label = NULL;
bool remember;
g_autofree char *vfioGroupDev = NULL;
static int
-virSecuritySELinuxSetImageLabelRelative(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virSecuritySELinuxSetImageLabelRelative(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
+ virStorageSource *parent,
virSecurityDomainImageLabelFlags flags)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = src; virStorageSourceIsBacking(n); n = n->backingStore) {
const bool isChainTop = flags & VIR_SECURITY_DOMAIN_IMAGE_PARENT_CHAIN_TOP;
static int
-virSecuritySELinuxSetImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virStorageSourcePtr src,
+virSecuritySELinuxSetImageLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
return virSecuritySELinuxSetImageLabelRelative(mgr, def, src, src, flags);
}
struct virSecuritySELinuxMoveImageMetadataData {
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
const char *src;
const char *dst;
};
{
struct virSecuritySELinuxMoveImageMetadataData *data = opaque;
const char *paths[2] = { data->src, data->dst };
- virSecurityManagerMetadataLockStatePtr state;
+ virSecurityManagerMetadataLockState *state;
int ret;
if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, G_N_ELEMENTS(paths))))
static int
-virSecuritySELinuxMoveImageMetadata(virSecurityManagerPtr mgr,
+virSecuritySELinuxMoveImageMetadata(virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst)
+ virStorageSource *src,
+ virStorageSource *dst)
{
struct virSecuritySELinuxMoveImageMetadataData data = { .mgr = mgr, 0 };
int rc;
bool remember,
void *opaque)
{
- virSecurityLabelDefPtr secdef;
- virSecuritySELinuxCallbackDataPtr data = opaque;
- virSecurityManagerPtr mgr = data->mgr;
- virDomainDefPtr def = data->def;
+ virSecurityLabelDef *secdef;
+ virSecuritySELinuxCallbackData *data = opaque;
+ virSecurityManager *mgr = data->mgr;
+ virDomainDef *def = data->def;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (secdef == NULL)
}
static int
-virSecuritySELinuxSetPCILabel(virPCIDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxSetPCILabel(virPCIDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return virSecuritySELinuxSetHostdevLabelHelper(file, true, opaque);
}
static int
-virSecuritySELinuxSetUSBLabel(virUSBDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxSetUSBLabel(virUSBDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return virSecuritySELinuxSetHostdevLabelHelper(file, true, opaque);
}
static int
-virSecuritySELinuxSetSCSILabel(virSCSIDevicePtr dev,
+virSecuritySELinuxSetSCSILabel(virSCSIDevice *dev,
const char *file, void *opaque)
{
- virSecurityLabelDefPtr secdef;
- virSecuritySELinuxCallbackDataPtr ptr = opaque;
- virSecurityManagerPtr mgr = ptr->mgr;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecuritySELinuxCallbackData *ptr = opaque;
+ virSecurityManager *mgr = ptr->mgr;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
secdef = virDomainDefGetSecurityLabelDef(ptr->def, SECURITY_SELINUX_NAME);
if (secdef == NULL)
}
static int
-virSecuritySELinuxSetHostLabel(virSCSIVHostDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxSetHostLabel(virSCSIVHostDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
return virSecuritySELinuxSetHostdevLabelHelper(file, true, opaque);
static int
-virSecuritySELinuxSetHostdevSubsysLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxSetHostdevSubsysLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
virSecuritySELinuxCallbackData data = {.mgr = mgr, .def = def};
int ret = -1;
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi =
virSCSIDeviceNew(NULL,
static int
-virSecuritySELinuxSetHostdevCapsLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxSetHostdevCapsLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
int ret = -1;
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
char *path;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
static int
-virSecuritySELinuxSetHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxSetHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->relabel)
}
static int
-virSecuritySELinuxRestorePCILabel(virPCIDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxRestorePCILabel(virPCIDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecuritySELinuxRestoreFileLabel(mgr, file, true);
}
static int
-virSecuritySELinuxRestoreUSBLabel(virUSBDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxRestoreUSBLabel(virUSBDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecuritySELinuxRestoreFileLabel(mgr, file, true);
}
static int
-virSecuritySELinuxRestoreSCSILabel(virSCSIDevicePtr dev,
+virSecuritySELinuxRestoreSCSILabel(virSCSIDevice *dev,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
/* Don't restore labels on a shareable or readonly hostdev, because
* other VMs may still be accessing.
}
static int
-virSecuritySELinuxRestoreHostLabel(virSCSIVHostDevicePtr dev G_GNUC_UNUSED,
+virSecuritySELinuxRestoreHostLabel(virSCSIVHostDevice *dev G_GNUC_UNUSED,
const char *file,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
return virSecuritySELinuxRestoreFileLabel(mgr, file, true);
}
static int
-virSecuritySELinuxRestoreHostdevSubsysLabel(virSecurityManagerPtr mgr,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxRestoreHostdevSubsysLabel(virSecurityManager *mgr,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
- virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
- virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
- virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevSubsysPCI *pcisrc = &dev->source.subsys.u.pci;
+ virDomainHostdevSubsysSCSI *scsisrc = &dev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSIVHost *hostsrc = &dev->source.subsys.u.scsi_host;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
int ret = -1;
/* Like virSecuritySELinuxRestoreImageLabelInt() for a networked
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
- virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
+ virDomainHostdevSubsysSCSIHost *scsihostsrc = &scsisrc->u.host;
g_autoptr(virSCSIDevice) scsi =
virSCSIDeviceNew(NULL,
scsihostsrc->adapter, scsihostsrc->bus,
static int
-virSecuritySELinuxRestoreHostdevCapsLabel(virSecurityManagerPtr mgr,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxRestoreHostdevCapsLabel(virSecurityManager *mgr,
+ virDomainHostdevDef *dev,
const char *vroot)
{
int ret = -1;
static int
-virSecuritySELinuxRestoreHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainHostdevDefPtr dev,
+virSecuritySELinuxRestoreHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->relabel)
static int
-virSecuritySELinuxSetSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxSetSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
static int
-virSecuritySELinuxRestoreSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxRestoreSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *savefile)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->relabel)
static int
-virSecuritySELinuxSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecuritySELinuxSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
- virSecurityLabelDefPtr seclabel;
- virSecurityDeviceLabelDefPtr chr_seclabel = NULL;
+ virSecurityLabelDef *seclabel;
+ virSecurityDeviceLabelDef *chr_seclabel = NULL;
char *imagelabel = NULL;
char *in = NULL, *out = NULL;
int ret = -1;
}
static int
-virSecuritySELinuxRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecuritySELinuxRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
- virSecurityLabelDefPtr seclabel;
- virSecurityDeviceLabelDefPtr chr_seclabel = NULL;
+ virSecurityLabelDef *seclabel;
+ virSecurityDeviceLabelDef *chr_seclabel = NULL;
char *in = NULL, *out = NULL;
int ret = -1;
struct _virSecuritySELinuxChardevCallbackData {
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
bool chardevStdioLogd;
};
static int
-virSecuritySELinuxRestoreSecurityChardevCallback(virDomainDefPtr def,
- virDomainChrDefPtr dev G_GNUC_UNUSED,
+virSecuritySELinuxRestoreSecurityChardevCallback(virDomainDef *def,
+ virDomainChrDef *dev G_GNUC_UNUSED,
void *opaque)
{
struct _virSecuritySELinuxChardevCallbackData *data = opaque;
static int
-virSecuritySELinuxRestoreSecuritySmartcardCallback(virDomainDefPtr def,
- virDomainSmartcardDefPtr dev,
+virSecuritySELinuxRestoreSecuritySmartcardCallback(virDomainDef *def,
+ virDomainSmartcardDef *dev,
void *opaque)
{
- virSecurityManagerPtr mgr = opaque;
+ virSecurityManager *mgr = opaque;
const char *database;
switch (dev->type) {
static const char *
-virSecuritySELinuxGetBaseLabel(virSecurityManagerPtr mgr, int virtType)
+virSecuritySELinuxGetBaseLabel(virSecurityManager *mgr, int virtType)
{
- virSecuritySELinuxDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecuritySELinuxData *priv = virSecurityManagerGetPrivateData(mgr);
if (virtType == VIR_DOMAIN_VIRT_QEMU && priv->alt_domain_context)
return priv->alt_domain_context;
else
static int
-virSecuritySELinuxRestoreSysinfoLabel(virSecurityManagerPtr mgr,
- virSysinfoDefPtr def)
+virSecuritySELinuxRestoreSysinfoLabel(virSecurityManager *mgr,
+ virSysinfoDef *def)
{
size_t i;
for (i = 0; i < def->nfw_cfgs; i++) {
- virSysinfoFWCfgDefPtr f = &def->fw_cfgs[i];
+ virSysinfoFWCfgDef *f = &def->fw_cfgs[i];
if (f->file &&
virSecuritySELinuxRestoreFileLabel(mgr, f->file, true) < 0)
static int
-virSecuritySELinuxRestoreAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxRestoreAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
bool migrated,
bool chardevStdioLogd)
{
- virSecurityLabelDefPtr secdef;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
size_t i;
int rc = 0;
return 0;
for (i = 0; i < def->ndisks; i++) {
- virDomainDiskDefPtr disk = def->disks[i];
+ virDomainDiskDef *disk = def->disks[i];
if (virSecuritySELinuxRestoreImageLabelInt(mgr, def, disk->src,
migrated) < 0)
}
static int
-virSecuritySELinuxReleaseLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxReleaseLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (secdef == NULL)
static int
-virSecuritySELinuxVerify(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+virSecuritySELinuxVerify(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (secdef == NULL)
}
static int
-virSecuritySELinuxSetProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+virSecuritySELinuxSetProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
/* TODO: verify DOI */
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->label)
}
static int
-virSecuritySELinuxSetChildProcessLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
- virCommandPtr cmd)
+virSecuritySELinuxSetChildProcessLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
+ virCommand *cmd)
{
/* TODO: verify DOI */
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->label)
}
static int
-virSecuritySELinuxSetDaemonSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+virSecuritySELinuxSetDaemonSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
/* TODO: verify DOI */
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
char *scon = NULL;
char *str = NULL;
int rc = -1;
}
static int
-virSecuritySELinuxSetSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm)
+virSecuritySELinuxSetSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
int rc = -1;
secdef = virDomainDefGetSecurityLabelDef(vm, SECURITY_SELINUX_NAME);
}
static int
-virSecuritySELinuxClearSocketLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def)
+virSecuritySELinuxClearSocketLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def)
{
/* TODO: verify DOI */
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->label)
static int
-virSecuritySELinuxSetSecurityChardevCallback(virDomainDefPtr def,
- virDomainChrDefPtr dev G_GNUC_UNUSED,
+virSecuritySELinuxSetSecurityChardevCallback(virDomainDef *def,
+ virDomainChrDef *dev G_GNUC_UNUSED,
void *opaque)
{
struct _virSecuritySELinuxChardevCallbackData *data = opaque;
static int
-virSecuritySELinuxSetSecuritySmartcardCallback(virDomainDefPtr def,
- virDomainSmartcardDefPtr dev,
+virSecuritySELinuxSetSecuritySmartcardCallback(virDomainDef *def,
+ virDomainSmartcardDef *dev,
void *opaque)
{
const char *database;
- virSecurityManagerPtr mgr = opaque;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityManager *mgr = opaque;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
switch (dev->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
static int
-virSecuritySELinuxSetSysinfoLabel(virSecurityManagerPtr mgr,
- virSysinfoDefPtr def,
- virSecuritySELinuxDataPtr data)
+virSecuritySELinuxSetSysinfoLabel(virSecurityManager *mgr,
+ virSysinfoDef *def,
+ virSecuritySELinuxData *data)
{
size_t i;
for (i = 0; i < def->nfw_cfgs; i++) {
- virSysinfoFWCfgDefPtr f = &def->fw_cfgs[i];
+ virSysinfoFWCfgDef *f = &def->fw_cfgs[i];
if (f->file &&
virSecuritySELinuxSetFilecon(mgr, f->file,
static int
-virSecuritySELinuxSetAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxSetAllLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *incomingPath G_GNUC_UNUSED,
bool chardevStdioLogd,
bool migrated G_GNUC_UNUSED)
{
size_t i;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
struct _virSecuritySELinuxChardevCallbackData chardevData = {
.mgr = mgr,
}
static int
-virSecuritySELinuxSetImageFDLabel(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr def,
+virSecuritySELinuxSetImageFDLabel(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *def,
int fd)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->imagelabel)
}
static int
-virSecuritySELinuxSetTapFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxSetTapFDLabel(virSecurityManager *mgr,
+ virDomainDef *def,
int fd)
{
struct stat buf;
char *fcon = NULL;
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
char *str = NULL, *proc = NULL, *fd_path = NULL;
int rc = -1;
}
static char *
-virSecuritySELinuxGenImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxGenImageLabel(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityLabelDefPtr secdef;
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
const char *range;
context_t ctx = NULL;
char *label = NULL;
}
static char *
-virSecuritySELinuxGetSecurityMountOptions(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxGetSecurityMountOptions(virSecurityManager *mgr,
+ virDomainDef *def)
{
char *opts = NULL;
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
if ((secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME))) {
if (!secdef->imagelabel)
}
static int
-virSecuritySELinuxDomainSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxDomainSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path,
bool allowSubtree G_GNUC_UNUSED)
{
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel || !seclabel->relabel)
}
static int
-virSecuritySELinuxDomainSetPathLabelRO(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxDomainSetPathLabelRO(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path)
{
- virSecuritySELinuxDataPtr data = virSecurityManagerGetPrivateData(mgr);
- virSecurityLabelDefPtr secdef;
+ virSecuritySELinuxData *data = virSecurityManagerGetPrivateData(mgr);
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
}
static int
-virSecuritySELinuxDomainRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
+virSecuritySELinuxDomainRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *def,
const char *path)
{
- virSecurityLabelDefPtr secdef;
+ virSecurityLabelDef *secdef;
secdef = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!secdef || !secdef->relabel)
* otherwise we just label the file.
*/
static int
-virSecuritySELinuxSetFileLabels(virSecurityManagerPtr mgr,
+virSecuritySELinuxSetFileLabels(virSecurityManager *mgr,
const char *path,
- virSecurityLabelDefPtr seclabel)
+ virSecurityLabelDef *seclabel)
{
int ret = 0;
struct dirent *ent;
* directory itself, otherwise we just restore the label on the file.
*/
static int
-virSecuritySELinuxRestoreFileLabels(virSecurityManagerPtr mgr,
+virSecuritySELinuxRestoreFileLabels(virSecurityManager *mgr,
const char *path)
{
int ret = 0;
static int
-virSecuritySELinuxSetTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxSetTPMLabels(virSecurityManager *mgr,
+ virDomainDef *def)
{
int ret = 0;
size_t i;
- virSecurityLabelDefPtr seclabel;
+ virSecurityLabelDef *seclabel;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (seclabel == NULL)
static int
-virSecuritySELinuxRestoreTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecuritySELinuxRestoreTPMLabels(virSecurityManager *mgr,
+ virDomainDef *def)
{
int ret = 0;
size_t i;
VIR_LOG_INIT("security.security_stack");
typedef struct _virSecurityStackData virSecurityStackData;
-typedef virSecurityStackData *virSecurityStackDataPtr;
typedef struct _virSecurityStackItem virSecurityStackItem;
-typedef virSecurityStackItem *virSecurityStackItemPtr;
struct _virSecurityStackItem {
- virSecurityManagerPtr securityManager;
- virSecurityStackItemPtr next;
- virSecurityStackItemPtr prev;
+ virSecurityManager *securityManager;
+ virSecurityStackItem *next;
+ virSecurityStackItem *prev;
};
struct _virSecurityStackData {
- virSecurityStackItemPtr itemsHead;
+ virSecurityStackItem *itemsHead;
};
int
-virSecurityStackAddNested(virSecurityManagerPtr mgr,
- virSecurityManagerPtr nested)
+virSecurityStackAddNested(virSecurityManager *mgr,
+ virSecurityManager *nested)
{
- virSecurityStackItemPtr item = NULL;
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr tmp;
+ virSecurityStackItem *item = NULL;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *tmp;
tmp = priv->itemsHead;
while (tmp && tmp->next)
return 0;
}
-virSecurityManagerPtr
-virSecurityStackGetPrimary(virSecurityManagerPtr mgr)
+virSecurityManager *
+virSecurityStackGetPrimary(virSecurityManager *mgr)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
return priv->itemsHead->securityManager;
}
}
static int
-virSecurityStackOpen(virSecurityManagerPtr mgr G_GNUC_UNUSED)
+virSecurityStackOpen(virSecurityManager *mgr G_GNUC_UNUSED)
{
return 0;
}
static int
-virSecurityStackClose(virSecurityManagerPtr mgr)
+virSecurityStackClose(virSecurityManager *mgr)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
- virSecurityStackItemPtr next;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
+ virSecurityStackItem *next;
while (item) {
next = item->next;
}
static const char *
-virSecurityStackGetModel(virSecurityManagerPtr mgr)
+virSecurityStackGetModel(virSecurityManager *mgr)
{
return virSecurityManagerGetModel(virSecurityStackGetPrimary(mgr));
}
static const char *
-virSecurityStackGetDOI(virSecurityManagerPtr mgr)
+virSecurityStackGetDOI(virSecurityManager *mgr)
{
return virSecurityManagerGetDOI(virSecurityStackGetPrimary(mgr));
}
static int
-virSecurityStackPreFork(virSecurityManagerPtr mgr)
+virSecurityStackPreFork(virSecurityManager *mgr)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
/* XXX For now, we rely on no driver having any state that requires
static int
-virSecurityStackTransactionStart(virSecurityManagerPtr mgr)
+virSecurityStackTransactionStart(virSecurityManager *mgr)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerTransactionStart(item->securityManager) < 0)
static int
-virSecurityStackTransactionCommit(virSecurityManagerPtr mgr,
+virSecurityStackTransactionCommit(virSecurityManager *mgr,
pid_t pid,
bool lock)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerTransactionCommit(item->securityManager, pid, lock) < 0)
static void
-virSecurityStackTransactionAbort(virSecurityManagerPtr mgr)
+virSecurityStackTransactionAbort(virSecurityManager *mgr)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next)
virSecurityManagerTransactionAbort(item->securityManager);
static int
-virSecurityStackVerify(virSecurityManagerPtr mgr,
- virDomainDefPtr def)
+virSecurityStackVerify(virSecurityManager *mgr,
+ virDomainDef *def)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackGenLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackGenLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
int rc = 0;
static int
-virSecurityStackReleaseLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackReleaseLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
int rc = 0;
static int
-virSecurityStackReserveLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackReserveLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
pid_t pid)
{
int rc = 0;
static int
-virSecurityStackSetHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainHostdevDefPtr dev,
+virSecurityStackSetHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetHostdevLabel(item->securityManager,
static int
-virSecurityStackRestoreHostdevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainHostdevDefPtr dev,
+virSecurityStackRestoreHostdevLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainHostdevDef *dev,
const char *vroot)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackSetAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackSetAllLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *incomingPath,
bool chardevStdioLogd,
bool migrated)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetAllLabel(item->securityManager, vm,
static int
-virSecurityStackRestoreAllLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackRestoreAllLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
bool migrated,
bool chardevStdioLogd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackSetSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackSetSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *savefile)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetSavedStateLabel(item->securityManager, vm, savefile) < 0)
static int
-virSecurityStackRestoreSavedStateLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackRestoreSavedStateLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *savefile)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackSetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetChildProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virCommandPtr cmd)
+virSecurityStackSetChildProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virCommand *cmd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackGetProcessLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackGetProcessLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
pid_t pid,
virSecurityLabelPtr seclabel)
{
static int
-virSecurityStackSetDaemonSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackSetDaemonSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetDaemonSocketLabel(item->securityManager, vm) < 0)
static int
-virSecurityStackSetSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackSetSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetSocketLabel(item->securityManager, vm) < 0)
static int
-virSecurityStackClearSocketLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackClearSocketLabel(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetImageFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackSetImageFDLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
int fd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetTapFDLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackSetTapFDLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
int fd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static char *
-virSecurityStackGetMountOptions(virSecurityManagerPtr mgr G_GNUC_UNUSED,
- virDomainDefPtr vm G_GNUC_UNUSED)
+virSecurityStackGetMountOptions(virSecurityManager *mgr G_GNUC_UNUSED,
+ virDomainDef *vm G_GNUC_UNUSED)
{
return NULL;
}
-virSecurityManagerPtr*
-virSecurityStackGetNested(virSecurityManagerPtr mgr)
+virSecurityManager **
+virSecurityStackGetNested(virSecurityManager *mgr)
{
- virSecurityManagerPtr *list = NULL;
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item;
+ virSecurityManager **list = NULL;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item;
int len = 0;
size_t i;
for (item = priv->itemsHead; item; item = item->next)
len++;
- list = g_new0(virSecurityManagerPtr, len + 1);
+ list = g_new0(virSecurityManager *, len + 1);
for (i = 0, item = priv->itemsHead; item; item = item->next, i++)
list[i] = item->securityManager;
}
static const char *
-virSecurityStackGetBaseLabel(virSecurityManagerPtr mgr, int virtType)
+virSecurityStackGetBaseLabel(virSecurityManager *mgr, int virtType)
{
return virSecurityManagerGetBaseLabel(virSecurityStackGetPrimary(mgr),
virtType);
}
static int
-virSecurityStackSetImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+virSecurityStackSetImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetImageLabel(item->securityManager, vm, src,
}
static int
-virSecurityStackRestoreImageLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virStorageSourcePtr src,
+virSecurityStackRestoreImageLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virStorageSource *src,
virSecurityDomainImageLabelFlags flags)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackMoveImageMetadata(virSecurityManagerPtr mgr,
+virSecurityStackMoveImageMetadata(virSecurityManager *mgr,
pid_t pid,
- virStorageSourcePtr src,
- virStorageSourcePtr dst)
+ virStorageSource *src,
+ virStorageSource *dst)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem)
+virSecurityStackSetMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetMemoryLabel(item->securityManager, vm, mem) < 0)
}
static int
-virSecurityStackRestoreMemoryLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainMemoryDefPtr mem)
+virSecurityStackRestoreMemoryLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainMemoryDef *mem)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackSetInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input)
+virSecurityStackSetInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetInputLabel(item->securityManager, vm, input) < 0)
}
static int
-virSecurityStackRestoreInputLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
- virDomainInputDefPtr input)
+virSecurityStackRestoreInputLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
+ virDomainInputDef *input)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
}
static int
-virSecurityStackDomainSetPathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackDomainSetPathLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path,
bool allowSubtree)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackDomainSetPathLabelRO(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackDomainSetPathLabelRO(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackDomainRestorePathLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr vm,
+virSecurityStackDomainRestorePathLabel(virSecurityManager *mgr,
+ virDomainDef *vm,
const char *path)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackDomainSetChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityStackDomainSetChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetChardevLabel(item->securityManager,
}
static int
-virSecurityStackDomainRestoreChardevLabel(virSecurityManagerPtr mgr,
- virDomainDefPtr def,
- virDomainChrSourceDefPtr dev_source,
+virSecurityStackDomainRestoreChardevLabel(virSecurityManager *mgr,
+ virDomainDef *def,
+ virDomainChrSourceDef *dev_source,
bool chardevStdioLogd)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
static int
-virSecurityStackSetTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackSetTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
for (; item; item = item->next) {
if (virSecurityManagerSetTPMLabels(item->securityManager,
static int
-virSecurityStackRestoreTPMLabels(virSecurityManagerPtr mgr,
- virDomainDefPtr vm)
+virSecurityStackRestoreTPMLabels(virSecurityManager *mgr,
+ virDomainDef *vm)
{
- virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackData *priv = virSecurityManagerGetPrivateData(mgr);
+ virSecurityStackItem *item = priv->itemsHead;
int rc = 0;
for (; item; item = item->next) {
int
-virSecurityStackAddNested(virSecurityManagerPtr mgr,
- virSecurityManagerPtr nested);
-virSecurityManagerPtr
-virSecurityStackGetPrimary(virSecurityManagerPtr mgr);
+virSecurityStackAddNested(virSecurityManager *mgr,
+ virSecurityManager *nested);
+virSecurityManager *
+virSecurityStackGetPrimary(virSecurityManager *mgr);
-virSecurityManagerPtr*
-virSecurityStackGetNested(virSecurityManagerPtr mgr);
+virSecurityManager **
+virSecurityStackGetNested(virSecurityManager *mgr);
* 'r' replace
* 'R' remove */
char *files; /* list of files */
- virDomainDefPtr def; /* VM definition */
- virCapsPtr caps; /* VM capabilities */
- virDomainXMLOptionPtr xmlopt; /* XML parser data */
+ virDomainDef *def; /* VM definition */
+ virCaps *caps; /* VM capabilities */
+ virDomainXMLOption *xmlopt; /* XML parser data */
char *virtType; /* type of hypervisor (eg qemu, xen, lxc) */
char *os; /* type of os (eg hvm, xen, exe) */
virArch arch; /* machine architecture */
* ctl->os
* ctl->arch
*
- * These are suitable for setting up a virCapsPtr
+ * These are suitable for setting up a virCaps *
*/
static int
caps_mockup(vahControl * ctl, const char *xmlStr)
get_definition(vahControl * ctl, const char *xmlStr)
{
int ostype, virtType;
- virCapsGuestPtr guest; /* this is freed when caps is freed */
+ virCapsGuest *guest; /* this is freed when caps is freed */
/*
* mock up some capabilities. We don't currently use these explicitly,
* read with no explicit deny rule.
*/
static int
-vah_add_path(virBufferPtr buf, const char *path, const char *perms, bool recursive)
+vah_add_path(virBuffer *buf, const char *path, const char *perms, bool recursive)
{
char *tmp = NULL;
int rc = -1;
}
static int
-vah_add_file(virBufferPtr buf, const char *path, const char *perms)
+vah_add_file(virBuffer *buf, const char *path, const char *perms)
{
return vah_add_path(buf, path, perms, false);
}
static int
-vah_add_file_chardev(virBufferPtr buf,
+vah_add_file_chardev(virBuffer *buf,
const char *path,
const char *perms,
const int type)
}
static int
-file_iterate_hostdev_cb(virUSBDevicePtr dev G_GNUC_UNUSED,
+file_iterate_hostdev_cb(virUSBDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
- virBufferPtr buf = opaque;
+ virBuffer *buf = opaque;
return vah_add_file(buf, file, "rw");
}
static int
-file_iterate_pci_cb(virPCIDevicePtr dev G_GNUC_UNUSED,
+file_iterate_pci_cb(virPCIDevice *dev G_GNUC_UNUSED,
const char *file, void *opaque)
{
- virBufferPtr buf = opaque;
+ virBuffer *buf = opaque;
return vah_add_file(buf, file, "rw");
}
static int
-add_file_path(virStorageSourcePtr src,
+add_file_path(virStorageSource *src,
size_t depth,
- virBufferPtr buf)
+ virBuffer *buf)
{
int ret;
static int
-storage_source_add_files(virStorageSourcePtr src,
- virBufferPtr buf,
+storage_source_add_files(virStorageSource *src,
+ virBuffer *buf,
size_t depth)
{
- virStorageSourcePtr tmp;
+ virStorageSource *tmp;
for (tmp = src; virStorageSourceIsBacking(tmp); tmp = tmp->backingStore) {
if (add_file_path(tmp, depth, buf) < 0)
#endif
for (i = 0; i < ctl->def->ndisks; i++) {
- virDomainDiskDefPtr disk = ctl->def->disks[i];
+ virDomainDiskDef *disk = ctl->def->disks[i];
if (virStorageSourceIsEmpty(disk->src))
continue;
goto cleanup;
for (i = 0; i < ctl->def->ngraphics; i++) {
- virDomainGraphicsDefPtr graphics = ctl->def->graphics[i];
+ virDomainGraphicsDef *graphics = ctl->def->graphics[i];
size_t n;
const char *rendernode = virDomainGraphicsGetRenderNode(graphics);
for (i = 0; i < ctl->def->nhostdevs; i++)
if (ctl->def->hostdevs[i]) {
- virDomainHostdevDefPtr dev = ctl->def->hostdevs[i];
- virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
+ virDomainHostdevDef *dev = ctl->def->hostdevs[i];
+ virDomainHostdevSubsysUSB *usbsrc = &dev->source.subsys.u.usb;
switch (dev->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB: {
- virUSBDevicePtr usb =
+ virUSBDevice *usb =
virUSBDeviceNew(usbsrc->bus, usbsrc->device, NULL);
if (usb == NULL)
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV: {
- virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
+ virDomainHostdevSubsysMediatedDev *mdevsrc = &dev->source.subsys.u.mdev;
switch ((virMediatedDeviceModelType) mdevsrc->model) {
case VIR_MDEV_MODEL_TYPE_VFIO_PCI:
case VIR_MDEV_MODEL_TYPE_VFIO_AP:
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: {
- virPCIDevicePtr pci = virPCIDeviceNew(&dev->source.subsys.u.pci.addr);
+ virPCIDevice *pci = virPCIDeviceNew(&dev->source.subsys.u.pci.addr);
virDomainHostdevSubsysPCIBackendType backend = dev->source.subsys.u.pci.backend;
if (backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO ||
(ctl->def->fss[i]->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_PATH ||
ctl->def->fss[i]->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_DEFAULT) &&
ctl->def->fss[i]->src) {
- virDomainFSDefPtr fs = ctl->def->fss[i];
+ virDomainFSDef *fs = ctl->def->fss[i];
/* We don't need to add deny rw rules for readonly mounts,
* this can only lead to troubles when mounting / readonly.
if (ctl->def->nets[i] &&
ctl->def->nets[i]->type == VIR_DOMAIN_NET_TYPE_VHOSTUSER &&
ctl->def->nets[i]->data.vhostuser) {
- virDomainChrSourceDefPtr vhu = ctl->def->nets[i]->data.vhostuser;
+ virDomainChrSourceDef *vhu = ctl->def->nets[i]->data.vhostuser;
if (vah_add_file_chardev(&buf, vhu->data.nix.path, "rw",
vhu->type) != 0)
size_t j;
for (j = 0; j < ctl->def->sysinfo[i]->nfw_cfgs; j++) {
- virSysinfoFWCfgDefPtr f = &ctl->def->sysinfo[i]->fw_cfgs[j];
+ virSysinfoFWCfgDef *f = &ctl->def->sysinfo[i]->fw_cfgs[j];
if (f->file &&
vah_add_file(&buf, f->file, "r") != 0)
}
for (i = 0; i < ctl->def->nsmartcards; i++) {
- virDomainSmartcardDefPtr sc = ctl->def->smartcards[i];
+ virDomainSmartcardDef *sc = ctl->def->smartcards[i];
virDomainSmartcardType sc_type = sc->type;
char *sc_db = (char *)VIR_DOMAIN_SMARTCARD_DEFAULT_DATABASE;
if (sc->data.cert.database)
if (ctl->def->virtType == VIR_DOMAIN_VIRT_KVM) {
for (i = 0; i < ctl->def->nnets; i++) {
- virDomainNetDefPtr net = ctl->def->nets[i];
+ virDomainNetDef *net = ctl->def->nets[i];
if (net && virDomainNetGetModelString(net)) {
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_QEMU)
continue;
#define VIR_STORAGE_BACKENDS_MAX 20
-static virStorageBackendPtr virStorageBackends[VIR_STORAGE_BACKENDS_MAX];
+static virStorageBackend *virStorageBackends[VIR_STORAGE_BACKENDS_MAX];
static size_t virStorageBackendsCount;
#define STORAGE_BACKEND_MODULE_DIR LIBDIR "/libvirt/storage-backend"
int
-virStorageBackendRegister(virStorageBackendPtr backend)
+virStorageBackendRegister(virStorageBackend *backend)
{
VIR_DEBUG("Registering storage backend '%s'",
virStoragePoolTypeToString(backend->type));
}
-virStorageBackendPtr
+virStorageBackend *
virStorageBackendForType(int type)
{
size_t i;
}
-virCapsPtr
+virCaps *
virStorageBackendGetCapabilities(void)
{
- virCapsPtr caps;
+ virCaps *caps;
size_t i;
if (!(caps = virCapabilitiesNew(VIR_ARCH_NONE, false, false)))
typedef char * (*virStorageBackendFindPoolSources)(const char *srcSpec,
unsigned int flags);
-typedef int (*virStorageBackendCheckPool)(virStoragePoolObjPtr pool,
+typedef int (*virStorageBackendCheckPool)(virStoragePoolObj *pool,
bool *active);
-typedef int (*virStorageBackendStartPool)(virStoragePoolObjPtr pool);
-typedef int (*virStorageBackendBuildPool)(virStoragePoolObjPtr pool,
+typedef int (*virStorageBackendStartPool)(virStoragePoolObj *pool);
+typedef int (*virStorageBackendBuildPool)(virStoragePoolObj *pool,
unsigned int flags);
-typedef int (*virStorageBackendRefreshPool)(virStoragePoolObjPtr pool);
-typedef int (*virStorageBackendStopPool)(virStoragePoolObjPtr pool);
-typedef int (*virStorageBackendDeletePool)(virStoragePoolObjPtr pool,
+typedef int (*virStorageBackendRefreshPool)(virStoragePoolObj *pool);
+typedef int (*virStorageBackendStopPool)(virStoragePoolObj *pool);
+typedef int (*virStorageBackendDeletePool)(virStoragePoolObj *pool,
unsigned int flags);
/* A 'buildVol' backend must remove any volume created on error since
* was not aware of between checking the pool and the create attempt. It
* also avoids extra round trips to just delete a file.
*/
-typedef int (*virStorageBackendBuildVol)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendBuildVol)(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags);
-typedef int (*virStorageBackendCreateVol)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol);
-typedef int (*virStorageBackendRefreshVol)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol);
-typedef int (*virStorageBackendDeleteVol)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendCreateVol)(virStoragePoolObj *pool,
+ virStorageVolDef *vol);
+typedef int (*virStorageBackendRefreshVol)(virStoragePoolObj *pool,
+ virStorageVolDef *vol);
+typedef int (*virStorageBackendDeleteVol)(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags);
-typedef int (*virStorageBackendBuildVolFrom)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr origvol,
- virStorageVolDefPtr newvol,
+typedef int (*virStorageBackendBuildVolFrom)(virStoragePoolObj *pool,
+ virStorageVolDef *origvol,
+ virStorageVolDef *newvol,
unsigned int flags);
-typedef int (*virStorageBackendVolumeResize)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendVolumeResize)(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity,
unsigned int flags);
/* Upon entering this callback passed @obj is unlocked. However,
* the pool's asyncjobs counter has been incremented and volume's
* in_use has been adjusted to ensure singular usage. */
-typedef int (*virStorageBackendVolumeDownload)(virStoragePoolObjPtr obj,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendVolumeDownload)(virStoragePoolObj *obj,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
/* Upon entering this callback passed @obj is unlocked. However,
* the pool's asyncjobs counter has been incremented and volume's
* in_use has been adjusted to ensure singular usage. */
-typedef int (*virStorageBackendVolumeUpload)(virStoragePoolObjPtr obj,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendVolumeUpload)(virStoragePoolObj *obj,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long len,
/* Upon entering this callback passed @obj is unlocked. However,
* the pool's asyncjobs counter has been incremented and volume's
* in_use has been adjusted to ensure singular usage. */
-typedef int (*virStorageBackendVolumeWipe)(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+typedef int (*virStorageBackendVolumeWipe)(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags);
typedef struct _virStorageBackend virStorageBackend;
-typedef virStorageBackend *virStorageBackendPtr;
/* Callbacks are optional unless documented otherwise; but adding more
* callbacks provides better pool support. */
virStorageBackendVolumeWipe wipeVol;
};
-virStorageBackendPtr virStorageBackendForType(int type);
+virStorageBackend *virStorageBackendForType(int type);
int virStorageBackendDriversRegister(bool allmodules);
-int virStorageBackendRegister(virStorageBackendPtr backend);
+int virStorageBackendRegister(virStorageBackend *backend);
-virCapsPtr
+virCaps *
virStorageBackendGetCapabilities(void);
#define SECTOR_SIZE 512
static bool
-virStorageVolPartFindExtended(virStorageVolDefPtr def,
+virStorageVolPartFindExtended(virStorageVolDef *def,
const void *opaque G_GNUC_UNUSED)
{
if (def->source.partType == VIR_STORAGE_VOL_DISK_TYPE_EXTENDED)
static int
-virStorageBackendDiskMakeDataVol(virStoragePoolObjPtr pool,
+virStorageBackendDiskMakeDataVol(virStoragePoolObj *pool,
char **const groups,
- virStorageVolDefPtr vol)
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
char *tmp, *partname;
bool addVol = false;
g_autofree char *devpath = NULL;
/* Find the extended partition and increase the allocation value */
if (vol->source.partType == VIR_STORAGE_VOL_DISK_TYPE_LOGICAL) {
- virStorageVolDefPtr voldef;
+ virStorageVolDef *voldef;
voldef = virStoragePoolObjSearchVolume(pool,
virStorageVolPartFindExtended,
}
static int
-virStorageBackendDiskMakeFreeExtent(virStoragePoolObjPtr pool,
+virStorageBackendDiskMakeFreeExtent(virStoragePoolObj *pool,
char **const groups)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStoragePoolSourceDevicePtr dev = &def->source.devices[0];
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStoragePoolSourceDevice *dev = &def->source.devices[0];
VIR_REALLOC_N(dev->freeExtents, dev->nfreeExtent + 1);
struct virStorageBackendDiskPoolVolData {
- virStoragePoolObjPtr pool;
- virStorageVolDefPtr vol;
+ virStoragePoolObj *pool;
+ virStorageVolDef *vol;
};
static int
void *opaque)
{
struct virStorageBackendDiskPoolVolData *data = opaque;
- virStoragePoolObjPtr pool = data->pool;
+ virStoragePoolObj *pool = data->pool;
/*
* Ignore normal+metadata, and logical+metadata partitions
* since they're basically internal book-keeping regions
/* Remaining data / metadata parts get turn into volumes... */
if (STREQ(groups[2], "metadata") ||
STREQ(groups[2], "data")) {
- virStorageVolDefPtr vol = data->vol;
+ virStorageVolDef *vol = data->vol;
if (vol) {
/* We're searching for a specific vol only */
* and we can even ensure the output is friendly.
*/
static int
-virStorageBackendDiskReadPartitions(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendDiskReadPartitions(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
/*
* # libvirt_parthelper DEVICE
*
*/
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct virStorageBackendDiskPoolVolData cbdata = {
.pool = pool,
.vol = vol,
char **const groups,
void *data)
{
- virStoragePoolObjPtr pool = data;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStoragePoolSourceDevicePtr device = &(def->source.devices[0]);
+ virStoragePoolObj *pool = data;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStoragePoolSourceDevice *device = &(def->source.devices[0]);
if (virStrToLong_i(groups[0], NULL, 0, &device->geometry.cylinders) < 0 ||
virStrToLong_i(groups[1], NULL, 0, &device->geometry.heads) < 0 ||
virStrToLong_i(groups[2], NULL, 0, &device->geometry.sectors) < 0) {
}
static int
-virStorageBackendDiskReadGeometry(virStoragePoolObjPtr pool)
+virStorageBackendDiskReadGeometry(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *parthelper_path = NULL;
g_autoptr(virCommand) cmd = NULL;
}
static int
-virStorageBackendDiskRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendDiskRefreshPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
VIR_FREE(def->source.devices[0].freeExtents);
def->source.devices[0].nfreeExtent = 0;
static int
-virStorageBackendDiskStartPool(virStoragePoolObjPtr pool)
+virStorageBackendDiskStartPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
const char *format;
const char *path = def->source.devices[0].path;
* Write a new partition table header
*/
static int
-virStorageBackendDiskBuildPool(virStoragePoolObjPtr pool,
+virStorageBackendDiskBuildPool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int format = def->source.format;
const char *fmt;
g_autoptr(virCommand) cmd = NULL;
* Wipe the existing partition table
*/
static int
-virStorageBackendDiskDeletePool(virStoragePoolObjPtr pool,
+virStorageBackendDiskDeletePool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
virCheckFlags(0, -1);
};
static int
-virStorageVolNumOfPartTypes(virStorageVolDefPtr def,
+virStorageVolNumOfPartTypes(virStorageVolDef *def,
const void *opaque)
{
struct virStorageVolNumData *data = (struct virStorageVolNumData *)opaque;
* Important when the partition table is of msdos type
*/
static int
-virStorageBackendDiskPartTypeToCreate(virStoragePoolObjPtr pool)
+virStorageBackendDiskPartTypeToCreate(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct virStorageVolNumData data = { .count = 0 };
if (def->source.format == VIR_STORAGE_POOL_DISK_DOS) {
}
static int
-virStorageBackendDiskPartFormat(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendDiskPartFormat(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
char** partFormat)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (def->source.format == VIR_STORAGE_POOL_DISK_DOS) {
const char *partedFormat;
* partitions
*/
static int
-virStorageBackendDiskPartBoundaries(virStoragePoolObjPtr pool,
+virStorageBackendDiskPartBoundaries(virStoragePoolObj *pool,
unsigned long long *start,
unsigned long long *end,
unsigned long long allocation)
unsigned long long smallestSize = 0;
unsigned long long extraBytes = 0;
unsigned long long alignedAllocation = allocation;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStoragePoolSourceDevicePtr dev = &def->source.devices[0];
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStoragePoolSourceDevice *dev = &def->source.devices[0];
unsigned long long cylinderSize = (unsigned long long)dev->geometry.heads *
dev->geometry.sectors * SECTOR_SIZE;
int partType = virStorageBackendDiskPartTypeToCreate(pool);
* Returns 0 on success, -1 on failure with error message set.
*/
static int
-virStorageBackendDiskDeleteVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendDiskDeleteVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
char *part_num = NULL;
g_autofree char *dev_name = NULL;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
char *src_path = def->source.devices[0].path;
g_autofree char *srcname = g_path_get_basename(src_path);
bool isDevMapperDevice;
static int
-virStorageBackendDiskCreateVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendDiskCreateVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
unsigned long long startOffset = 0, endOffset = 0;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
virErrorPtr save_err;
g_autofree char *partFormat = NULL;
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendDiskBuildVolFrom(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendDiskBuildVolFrom(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
virStorageBackendBuildVolFrom build_func;
static int
-virStorageBackendDiskVolWipe(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendDiskVolWipe(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags)
{
* Return 0 if everything's OK, -1 on error
*/
static int
-virStorageBackendFileSystemIsValid(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemIsValid(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (def->type == VIR_STORAGE_POOL_NETFS) {
if (def->source.nhost != 1) {
* Return 0 if not mounted, 1 if mounted, -1 on error
*/
static int
-virStorageBackendFileSystemIsMounted(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemIsMounted(virStoragePoolObj *pool)
{
int ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
FILE *mtab;
struct mntent ent;
char buf[1024];
* Returns 0 if successfully mounted, -1 on error
*/
static int
-virStorageBackendFileSystemMount(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemMount(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int rc;
g_autofree char *src = NULL;
g_autoptr(virCommand) cmd = NULL;
* Returns 0 on success, -1 on error
*/
static int
-virStorageBackendFileSystemStart(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemStart(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (def->type != VIR_STORAGE_POOL_DIR &&
virStorageBackendFileSystemMount(pool) < 0)
* Returns 0 if successfully unmounted, -1 on error
*/
static int
-virStorageBackendFileSystemStop(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemStop(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int rc;
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendFileSystemCheck(virStoragePoolObjPtr pool,
+virStorageBackendFileSystemCheck(virStoragePoolObj *pool,
bool *isActive)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (def->type == VIR_STORAGE_POOL_DIR) {
*isActive = virFileExists(def->target.path);
#endif /* #ifdef MKFS */
static int
-virStorageBackendMakeFileSystem(virStoragePoolObjPtr pool,
+virStorageBackendMakeFileSystem(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
const char *device = NULL, *format = NULL;
bool ok_to_mkfs = false;
int ret = -1;
* Returns 0 on success, -1 on error
*/
static int
-virStorageBackendFileSystemBuild(virStoragePoolObjPtr pool,
+virStorageBackendFileSystemBuild(virStoragePoolObj *pool,
unsigned int flags)
{
virCheckFlags(VIR_STORAGE_POOL_BUILD_OVERWRITE |
static void
virStoragePoolDefFSNamespaceFree(void *nsdata)
{
- virStoragePoolFSMountOptionsDefPtr cmdopts = nsdata;
+ virStoragePoolFSMountOptionsDef *cmdopts = nsdata;
size_t i;
if (!cmdopts)
virStoragePoolDefFSNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- virStoragePoolFSMountOptionsDefPtr cmdopts = NULL;
+ virStoragePoolFSMountOptionsDef *cmdopts = NULL;
int nnodes;
size_t i;
int ret = -1;
static int
-virStoragePoolDefFSNamespaceFormatXML(virBufferPtr buf,
+virStoragePoolDefFSNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
size_t i;
- virStoragePoolFSMountOptionsDefPtr def = nsdata;
+ virStoragePoolFSMountOptionsDef *def = nsdata;
if (!def)
return 0;
};
typedef struct _virStorageBackendGlusterState virStorageBackendGlusterState;
-typedef virStorageBackendGlusterState *virStorageBackendGlusterStatePtr;
static void
-virStorageBackendGlusterClose(virStorageBackendGlusterStatePtr state)
+virStorageBackendGlusterClose(virStorageBackendGlusterState *state)
{
if (!state)
return;
VIR_FREE(state);
}
-static virStorageBackendGlusterStatePtr
-virStorageBackendGlusterOpen(virStoragePoolObjPtr pool)
+static virStorageBackendGlusterState *
+virStorageBackendGlusterOpen(virStoragePoolObj *pool)
{
- virStorageBackendGlusterStatePtr ret = NULL;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStorageBackendGlusterState *ret = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
const char *name = def->source.name;
const char *dir = def->source.dir;
bool trailing_slash = true;
static int
-virStorageBackendGlusterSetMetadata(virStorageBackendGlusterStatePtr state,
- virStorageVolDefPtr vol,
+virStorageBackendGlusterSetMetadata(virStorageBackendGlusterState *state,
+ virStorageVolDef *vol,
const char *name)
{
char *tmp;
* it NULL if the entry should be skipped (such as "."). Return 0 on
* success, -1 on failure. */
static int
-virStorageBackendGlusterRefreshVol(virStorageBackendGlusterStatePtr state,
+virStorageBackendGlusterRefreshVol(virStorageBackendGlusterState *state,
const char *name,
struct stat *st,
- virStorageVolDefPtr *volptr)
+ virStorageVolDef **volptr)
{
int ret = -1;
glfs_fd_t *fd = NULL;
}
static int
-virStorageBackendGlusterRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendGlusterRefreshPool(virStoragePoolObj *pool)
{
int ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageBackendGlusterStatePtr state = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageBackendGlusterState *state = NULL;
struct {
struct dirent ent;
/* See comment below about readdir_r needing padding */
goto cleanup;
}
while (!(errno = glfs_readdirplus_r(dir, &st, &de.ent, &ent)) && ent) {
- virStorageVolDefPtr vol;
+ virStorageVolDef *vol;
int okay = virStorageBackendGlusterRefreshVol(state,
ent->d_name, &st,
&vol);
static int
-virStorageBackendGlusterVolDelete(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendGlusterVolDelete(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
- virStorageBackendGlusterStatePtr state = NULL;
+ virStorageBackendGlusterState *state = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int
-virStorageBackendGlusterCheckPool(virStoragePoolObjPtr pool,
+virStorageBackendGlusterCheckPool(virStoragePoolObj *pool,
bool *active)
{
/* Return previous state remembered by the status XML. If the pool is not
#define ISCSI_DEFAULT_TARGET_PORT 3260
static char *
-virStorageBackendISCSIPortal(virStoragePoolSourcePtr source)
+virStorageBackendISCSIPortal(virStoragePoolSource *source)
{
char *portal = NULL;
static char *
-virStorageBackendISCSISession(virStoragePoolObjPtr pool,
+virStorageBackendISCSISession(virStoragePoolObj *pool,
bool probe)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
return virISCSIGetSession(def->source.devices[0].path, probe);
}
}
static int
-virStorageBackendISCSIFindLUs(virStoragePoolObjPtr pool,
+virStorageBackendISCSIFindLUs(virStoragePoolObj *pool,
const char *session)
{
uint32_t host;
}
static int
-virStorageBackendISCSICheckPool(virStoragePoolObjPtr pool,
+virStorageBackendISCSICheckPool(virStoragePoolObj *pool,
bool *isActive)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *session = NULL;
*isActive = false;
static int
virStorageBackendISCSISetAuth(const char *portal,
- virStoragePoolSourcePtr source)
+ virStoragePoolSource *source)
{
g_autofree unsigned char *secret_value = NULL;
size_t secret_size;
g_autofree char *secret_str = NULL;
- virStorageAuthDefPtr authdef = source->auth;
+ virStorageAuthDef *authdef = source->auth;
int ret = -1;
virConnectPtr conn = NULL;
}
static int
-virStorageBackendISCSIStartPool(virStoragePoolObjPtr pool)
+virStorageBackendISCSIStartPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *portal = NULL;
g_autofree char *session = NULL;
}
static int
-virStorageBackendISCSIRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendISCSIRefreshPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *session = NULL;
def->allocation = def->capacity = def->available = 0;
static int
-virStorageBackendISCSIStopPool(virStoragePoolObjPtr pool)
+virStorageBackendISCSIStopPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *portal = NULL;
g_autofree char *session = NULL;
}
static char *
-virStorageBackendISCSIDirectPortal(virStoragePoolSourcePtr source)
+virStorageBackendISCSIDirectPortal(virStoragePoolSource *source)
{
char *portal = NULL;
static int
virStorageBackendISCSIDirectSetAuth(struct iscsi_context *iscsi,
- virStoragePoolSourcePtr source)
+ virStoragePoolSource *source)
{
g_autofree unsigned char *secret_value = NULL;
size_t secret_size;
g_autofree char *secret_str = NULL;
- virStorageAuthDefPtr authdef = source->auth;
+ virStorageAuthDef *authdef = source->auth;
int ret = -1;
virConnectPtr conn = NULL;
}
static int
-virISCSIDirectSetVolumeAttributes(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virISCSIDirectSetVolumeAttributes(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
int lun,
char *portal)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
vol->name = g_strdup_printf("%s%u", VOL_NAME_PREFIX, lun);
vol->key = g_strdup_printf("ip-%s-iscsi-%s-lun-%u", portal,
}
static int
-virISCSIDirectRefreshVol(virStoragePoolObjPtr pool,
+virISCSIDirectRefreshVol(virStoragePoolObj *pool,
struct iscsi_context *iscsi,
int lun,
char *portal)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
uint32_t block_size = 0;
uint64_t nb_block = 0;
g_autoptr(virStorageVolDef) vol = NULL;
}
static int
-virISCSIDirectReportLuns(virStoragePoolObjPtr pool,
+virISCSIDirectReportLuns(virStoragePoolObj *pool,
struct iscsi_context *iscsi,
char *portal)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct scsi_task *task = NULL;
struct scsi_reportluns_list *list = NULL;
int full_size;
}
static int
-virStorageBackendISCSIDirectCheckPool(virStoragePoolObjPtr pool,
+virStorageBackendISCSIDirectCheckPool(virStoragePoolObj *pool,
bool *isActive)
{
*isActive = virStoragePoolObjIsActive(pool);
}
static struct iscsi_context *
-virStorageBackendISCSIDirectSetConnection(virStoragePoolObjPtr pool,
+virStorageBackendISCSIDirectSetConnection(virStoragePoolObj *pool,
char **portalRet)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct iscsi_context *iscsi = NULL;
g_autofree char *portal = NULL;
}
static int
-virStorageBackendISCSIDirectRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendISCSIDirectRefreshPool(virStoragePoolObj *pool)
{
struct iscsi_context *iscsi = NULL;
int ret = -1;
}
static int
-virStorageBackendISCSIDirectGetLun(virStorageVolDefPtr vol,
+virStorageBackendISCSIDirectGetLun(virStorageVolDef *vol,
int *lun)
{
const char *name;
}
static int
-virStorageBackendISCSIDirectVolWipeZero(virStorageVolDefPtr vol,
+virStorageBackendISCSIDirectVolWipeZero(virStorageVolDef *vol,
struct iscsi_context *iscsi)
{
uint64_t lba = 0;
}
static int
-virStorageBackenISCSIDirectWipeVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackenISCSIDirectWipeVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags)
{
static int
-virStorageBackendLogicalSetActive(virStoragePoolObjPtr pool,
+virStorageBackendLogicalSetActive(virStoragePoolObj *pool,
bool on)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virCommand) cmd = NULL;
int ret;
#define VIR_STORAGE_VOL_LOGICAL_SEGTYPE_RAID "raid"
struct virStorageBackendLogicalPoolVolData {
- virStoragePoolObjPtr pool;
- virStorageVolDefPtr vol;
+ virStoragePoolObj *pool;
+ virStorageVolDef *vol;
};
static int
-virStorageBackendLogicalParseVolExtents(virStorageVolDefPtr vol,
+virStorageBackendLogicalParseVolExtents(virStorageVolDef *vol,
char **const groups)
{
g_autoptr(GRegex) re = NULL;
void *opaque)
{
struct virStorageBackendLogicalPoolVolData *data = opaque;
- virStoragePoolObjPtr pool = data->pool;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageVolDefPtr vol = NULL;
+ virStoragePoolObj *pool = data->pool;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageVolDef *vol = NULL;
bool is_new_vol = false;
int ret = -1;
const char *attrs = groups[9];
VIR_STORAGE_VOL_LOGICAL_SUFFIX_REGEX
static int
-virStorageBackendLogicalFindLVs(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendLogicalFindLVs(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
/*
* # lvs --separator # --noheadings --units b --unbuffered --nosuffix --options \
int vars[] = {
VIR_STORAGE_VOL_LOGICAL_REGEX_COUNT
};
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct virStorageBackendLogicalPoolVolData cbdata = {
.pool = pool,
.vol = vol,
virStorageBackendLogicalRefreshPoolFunc(char **const groups,
void *data)
{
- virStoragePoolObjPtr pool = data;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolObj *pool = data;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (virStrToLong_ull(groups[0], NULL, 10, &def->capacity) < 0)
return -1;
virStorageBackendLogicalFindPoolSourcesFunc(char **const groups,
void *data)
{
- virStoragePoolSourceListPtr sourceList = data;
+ virStoragePoolSourceList *sourceList = data;
size_t i;
- virStoragePoolSourceDevicePtr dev;
+ virStoragePoolSourceDevice *dev;
virStoragePoolSource *thisSource;
g_autofree char *pvname = NULL;
g_autofree char *vgname = NULL;
* Returns 0 if successful, -1 and sets error on failure
*/
static int
-virStorageBackendLogicalGetPoolSources(virStoragePoolSourceListPtr sourceList)
+virStorageBackendLogicalGetPoolSources(virStoragePoolSourceList *sourceList)
{
/*
* # pvs --noheadings -o pv_name,vg_name
* the any device list members.
*/
static bool
-virStorageBackendLogicalMatchPoolSource(virStoragePoolObjPtr pool)
+virStorageBackendLogicalMatchPoolSource(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
virStoragePoolSourceList sourceList;
virStoragePoolSource *thisSource = NULL;
size_t i, j;
static int
-virStorageBackendLogicalCheckPool(virStoragePoolObjPtr pool,
+virStorageBackendLogicalCheckPool(virStoragePoolObj *pool,
bool *isActive)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
/* If we can find the target.path as well as ensure that the
* pool's def source
}
static int
-virStorageBackendLogicalStartPool(virStoragePoolObjPtr pool)
+virStorageBackendLogicalStartPool(virStoragePoolObj *pool)
{
/* Let's make sure that the pool's name matches the pvs output and
* that the pool's source devices match the pvs output.
static int
-virStorageBackendLogicalBuildPool(virStoragePoolObjPtr pool,
+virStorageBackendLogicalBuildPool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int ret = -1;
size_t i = 0;
g_autoptr(virCommand) vgcmd = NULL;
static int
-virStorageBackendLogicalRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendLogicalRefreshPool(virStoragePoolObj *pool)
{
/*
* # vgs --separator : --noheadings --units b --unbuffered --nosuffix --options "vg_size,vg_free" VGNAME
int vars[] = {
2
};
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virCommand) cmd = NULL;
virWaitForDevices();
* "Can't deactivate volume group "VolGroup00" with 3 open logical volume(s)"
*/
static int
-virStorageBackendLogicalStopPool(virStoragePoolObjPtr pool)
+virStorageBackendLogicalStopPool(virStoragePoolObj *pool)
{
if (virStorageBackendLogicalSetActive(pool, false) < 0)
return -1;
}
static int
-virStorageBackendLogicalDeletePool(virStoragePoolObjPtr pool,
+virStorageBackendLogicalDeletePool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
size_t i;
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendLogicalDeleteVol(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
+virStorageBackendLogicalDeleteVol(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
unsigned int flags)
{
g_autoptr(virCommand) lvchange_cmd = NULL;
static int
-virStorageBackendLogicalLVCreate(virStorageVolDefPtr vol,
- virStoragePoolDefPtr def)
+virStorageBackendLogicalLVCreate(virStorageVolDef *vol,
+ virStoragePoolDef *def)
{
unsigned long long capacity = vol->target.capacity;
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendLogicalCreateVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendLogicalCreateVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
virErrorPtr err;
struct stat sb;
VIR_AUTOCLOSE fd = -1;
}
static int
-virStorageBackendLogicalBuildVolFrom(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendLogicalBuildVolFrom(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
virStorageBackendBuildVolFrom build_func;
}
static int
-virStorageBackendLogicalVolWipe(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendLogicalVolWipe(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags)
{
VIR_LOG_INIT("storage.storage_backend_mpath");
static int
-virStorageBackendMpathNewVol(virStoragePoolObjPtr pool,
+virStorageBackendMpathNewVol(virStoragePoolObj *pool,
const int devnum,
const char *dev)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virStorageVolDef) vol = NULL;
vol = g_new0(virStorageVolDef, 1);
static int
-virStorageBackendCreateVols(virStoragePoolObjPtr pool,
+virStorageBackendCreateVols(virStoragePoolObj *pool,
struct dm_names *names)
{
uint32_t minor = -1;
static int
-virStorageBackendGetMaps(virStoragePoolObjPtr pool)
+virStorageBackendGetMaps(virStoragePoolObj *pool)
{
int retval = 0;
struct dm_task *dmt = NULL;
}
static int
-virStorageBackendMpathCheckPool(virStoragePoolObjPtr pool G_GNUC_UNUSED,
+virStorageBackendMpathCheckPool(virStoragePoolObj *pool G_GNUC_UNUSED,
bool *isActive)
{
*isActive = virFileExists("/dev/mapper") ||
static int
-virStorageBackendMpathRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendMpathRefreshPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
VIR_DEBUG("pool=%p", pool);
};
typedef struct _virStorageBackendRBDState virStorageBackendRBDState;
-typedef virStorageBackendRBDState *virStorageBackendRBDStatePtr;
typedef struct _virStoragePoolRBDConfigOptionsDef virStoragePoolRBDConfigOptionsDef;
-typedef virStoragePoolRBDConfigOptionsDef *virStoragePoolRBDConfigOptionsDefPtr;
struct _virStoragePoolRBDConfigOptionsDef {
size_t noptions;
char **names;
static void
virStoragePoolDefRBDNamespaceFree(void *nsdata)
{
- virStoragePoolRBDConfigOptionsDefPtr cmdopts = nsdata;
+ virStoragePoolRBDConfigOptionsDef *cmdopts = nsdata;
size_t i;
if (!cmdopts)
virStoragePoolDefRBDNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- virStoragePoolRBDConfigOptionsDefPtr cmdopts = NULL;
+ virStoragePoolRBDConfigOptionsDef *cmdopts = NULL;
int nnodes;
size_t i;
int ret = -1;
static int
-virStoragePoolDefRBDNamespaceFormatXML(virBufferPtr buf,
+virStoragePoolDefRBDNamespaceFormatXML(virBuffer *buf,
void *nsdata)
{
size_t i;
- virStoragePoolRBDConfigOptionsDefPtr def = nsdata;
+ virStoragePoolRBDConfigOptionsDef *def = nsdata;
if (!def)
return 0;
}
static int
-virStorageBackendRBDOpenRADOSConn(virStorageBackendRBDStatePtr ptr,
- virStoragePoolDefPtr def)
+virStorageBackendRBDOpenRADOSConn(virStorageBackendRBDState *ptr,
+ virStoragePoolDef *def)
{
int ret = -1;
- virStoragePoolSourcePtr source = &def->source;
- virStorageAuthDefPtr authdef = source->auth;
+ virStoragePoolSource *source = &def->source;
+ virStorageAuthDef *authdef = source->auth;
g_autofree unsigned char *secret_value = NULL;
size_t secret_value_size = 0;
g_auto(virBuffer) mon_host = VIR_BUFFER_INITIALIZER;
goto cleanup;
if (def->namespaceData) {
- virStoragePoolRBDConfigOptionsDefPtr cmdopts = def->namespaceData;
+ virStoragePoolRBDConfigOptionsDef *cmdopts = def->namespaceData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
for (i = 0; i < cmdopts->noptions; i++) {
}
static int
-virStorageBackendRBDOpenIoCTX(virStorageBackendRBDStatePtr ptr,
- virStoragePoolObjPtr pool)
+virStorageBackendRBDOpenIoCTX(virStorageBackendRBDState *ptr,
+ virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int rc = rados_ioctx_create(ptr->cluster, def->source.name, &ptr->ioctx);
if (rc < 0) {
virReportSystemError(errno, _("failed to create the RBD IoCTX. Does the pool '%s' exist?"),
}
static void
-virStorageBackendRBDCloseRADOSConn(virStorageBackendRBDStatePtr ptr)
+virStorageBackendRBDCloseRADOSConn(virStorageBackendRBDState *ptr)
{
if (ptr->ioctx != NULL) {
VIR_DEBUG("Closing RADOS IoCTX");
static void
-virStorageBackendRBDFreeState(virStorageBackendRBDStatePtr *ptr)
+virStorageBackendRBDFreeState(virStorageBackendRBDState **ptr)
{
if (!*ptr)
return;
}
-static virStorageBackendRBDStatePtr
-virStorageBackendRBDNewState(virStoragePoolObjPtr pool)
+static virStorageBackendRBDState *
+virStorageBackendRBDNewState(virStoragePoolObj *pool)
{
- virStorageBackendRBDStatePtr ptr;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStorageBackendRBDState *ptr;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
ptr = g_new0(virStorageBackendRBDState, 1);
}
static int
-virStorageBackendRBDSetAllocation(virStorageVolDefPtr vol,
+virStorageBackendRBDSetAllocation(virStorageVolDef *vol,
rbd_image_t *image,
rbd_image_info_t *info)
{
}
static int
-virStorageBackendRBDSetAllocation(virStorageVolDefPtr vol G_GNUC_UNUSED,
+virStorageBackendRBDSetAllocation(virStorageVolDef *vol G_GNUC_UNUSED,
rbd_image_t *image G_GNUC_UNUSED,
rbd_image_info_t *info G_GNUC_UNUSED)
{
#endif
static int
-volStorageBackendRBDRefreshVolInfo(virStorageVolDefPtr vol,
- virStoragePoolObjPtr pool,
- virStorageBackendRBDStatePtr ptr)
+volStorageBackendRBDRefreshVolInfo(virStorageVolDef *vol,
+ virStoragePoolObj *pool,
+ virStorageBackendRBDState *ptr)
{
int ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
rbd_image_t image = NULL;
rbd_image_info_t info;
uint64_t features;
#ifdef WITH_RBD_LIST2
static char **
-virStorageBackendRBDGetVolNames(virStorageBackendRBDStatePtr ptr)
+virStorageBackendRBDGetVolNames(virStorageBackendRBDState *ptr)
{
char **names = NULL;
size_t nnames = 0;
#else /* ! WITH_RBD_LIST2 */
static char **
-virStorageBackendRBDGetVolNames(virStorageBackendRBDStatePtr ptr)
+virStorageBackendRBDGetVolNames(virStorageBackendRBDState *ptr)
{
char **names = NULL;
size_t nnames = 0;
static int
-virStorageBackendRBDRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendRBDRefreshPool(virStoragePoolObj *pool)
{
int rc, ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageBackendRBDState *ptr = NULL;
struct rados_cluster_stat_t clusterstat;
struct rados_pool_stat_t poolstat;
char **names = NULL;
static int
virStorageBackendRBDCleanupSnapshots(rados_ioctx_t ioctx,
- virStoragePoolSourcePtr source,
- virStorageVolDefPtr vol)
+ virStoragePoolSource *source,
+ virStorageVolDef *vol)
{
int ret = -1;
int max_snaps = 128;
}
static int
-virStorageBackendRBDDeleteVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendRBDDeleteVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
int rc, ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageBackendRBDState *ptr = NULL;
virCheckFlags(VIR_STORAGE_VOL_DELETE_ZEROED |
VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS, -1);
static int
-virStorageBackendRBDCreateVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendRBDCreateVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
vol->type = VIR_STORAGE_VOL_NETWORK;
}
static int
-virStorageBackendRBDBuildVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendRBDBuildVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageBackendRBDState *ptr = NULL;
int ret = -1;
VIR_DEBUG("Creating RBD image %s/%s with size %llu",
static int
virStorageBackendRBDSnapshotFindNoDiff(rbd_image_t image,
char *imgname,
- virBufferPtr snapname)
+ virBuffer *snapname)
{
int ret = -1;
int snap_count;
}
static int
-virStorageBackendRBDBuildVolFrom(virStoragePoolObjPtr pool,
- virStorageVolDefPtr newvol,
- virStorageVolDefPtr origvol,
+virStorageBackendRBDBuildVolFrom(virStoragePoolObj *pool,
+ virStorageVolDef *newvol,
+ virStorageVolDef *origvol,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
+ virStorageBackendRBDState *ptr = NULL;
int ret = -1;
VIR_DEBUG("Creating clone of RBD image %s/%s with name %s",
}
static int
-virStorageBackendRBDRefreshVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendRBDRefreshVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStorageBackendRBDState *ptr = NULL;
int ret = -1;
if (!(ptr = virStorageBackendRBDNewState(pool)))
}
static int
-virStorageBackendRBDResizeVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendRBDResizeVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity,
unsigned int flags)
{
- virStorageBackendRBDStatePtr ptr = NULL;
+ virStorageBackendRBDState *ptr = NULL;
rbd_image_t image = NULL;
int ret = -1;
}
static int
-virStorageBackendRBDVolWipe(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendRBDVolWipe(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags)
{
- virStorageBackendRBDStatePtr ptr = NULL;
- virStoragePoolDefPtr def;
+ virStorageBackendRBDState *ptr = NULL;
+ virStoragePoolDef *def;
rbd_image_t image = NULL;
rbd_image_info_t info;
uint64_t stripe_count;
#define LINUX_SYSFS_SCSI_HOST_SCAN_STRING "- - -"
typedef struct _virStoragePoolFCRefreshInfo virStoragePoolFCRefreshInfo;
-typedef virStoragePoolFCRefreshInfo *virStoragePoolFCRefreshInfoPtr;
struct _virStoragePoolFCRefreshInfo {
char *fchost_name;
unsigned char pool_uuid[VIR_UUID_BUFLEN];
static void
virStoragePoolFCRefreshDataFree(void *opaque)
{
- virStoragePoolFCRefreshInfoPtr cbdata = opaque;
+ virStoragePoolFCRefreshInfo *cbdata = opaque;
g_free(cbdata->fchost_name);
g_free(cbdata);
static void
virStoragePoolFCRefreshThread(void *opaque)
{
- virStoragePoolFCRefreshInfoPtr cbdata = opaque;
+ virStoragePoolFCRefreshInfo *cbdata = opaque;
const char *fchost_name = cbdata->fchost_name;
const unsigned char *pool_uuid = cbdata->pool_uuid;
- virStoragePoolObjPtr pool = NULL;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *pool = NULL;
+ virStoragePoolDef *def;
unsigned int host;
int found = 0;
int tries = 2;
}
static char *
-getAdapterName(virStorageAdapterPtr adapter)
+getAdapterName(virStorageAdapter *adapter)
{
char *name = NULL;
if (adapter->type == VIR_STORAGE_ADAPTER_TYPE_SCSI_HOST) {
- virStorageAdapterSCSIHostPtr scsi_host = &adapter->data.scsi_host;
+ virStorageAdapterSCSIHost *scsi_host = &adapter->data.scsi_host;
if (scsi_host->has_parent) {
- virPCIDeviceAddressPtr addr = &scsi_host->parentaddr;
+ virPCIDeviceAddress *addr = &scsi_host->parentaddr;
unsigned int unique_id = scsi_host->unique_id;
if (!(name = virSCSIHostGetNameByParentaddr(addr->domain,
name = g_strdup(scsi_host->name);
}
} else if (adapter->type == VIR_STORAGE_ADAPTER_TYPE_FC_HOST) {
- virStorageAdapterFCHostPtr fchost = &adapter->data.fchost;
+ virStorageAdapterFCHost *fchost = &adapter->data.fchost;
if (!(name = virVHBAGetHostByWWN(NULL, fchost->wwnn, fchost->wwpn))) {
virReportError(VIR_ERR_XML_ERROR,
static int
-createVport(virStoragePoolDefPtr def,
+createVport(virStoragePoolDef *def,
const char *configFile,
- virStorageAdapterFCHostPtr fchost)
+ virStorageAdapterFCHost *fchost)
{
- virStoragePoolFCRefreshInfoPtr cbdata = NULL;
+ virStoragePoolFCRefreshInfo *cbdata = NULL;
virThread thread;
g_autofree char *name = NULL;
static int
-virStorageBackendSCSICheckPool(virStoragePoolObjPtr pool,
+virStorageBackendSCSICheckPool(virStoragePoolObj *pool,
bool *isActive)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
unsigned int host;
g_autofree char *path = NULL;
g_autofree char *name = NULL;
}
static int
-virStorageBackendSCSIRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendSCSIRefreshPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
unsigned int host;
g_autofree char *name = NULL;
static int
-virStorageBackendSCSIStartPool(virStoragePoolObjPtr pool)
+virStorageBackendSCSIStartPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
const char *configFile = virStoragePoolObjGetConfigFile(pool);
if (def->source.adapter.type == VIR_STORAGE_ADAPTER_TYPE_FC_HOST)
static int
-virStorageBackendSCSIStopPool(virStoragePoolObjPtr pool)
+virStorageBackendSCSIStopPool(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (def->source.adapter.type == VIR_STORAGE_ADAPTER_TYPE_FC_HOST) {
virConnectPtr conn;
#define VIR_FROM_THIS VIR_FROM_STORAGE
-static int virStorageBackendSheepdogRefreshVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol);
+static int virStorageBackendSheepdogRefreshVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol);
-void virStorageBackendSheepdogAddHostArg(virCommandPtr cmd,
- virStoragePoolObjPtr pool);
+void virStorageBackendSheepdogAddHostArg(virCommand *cmd,
+ virStoragePoolObj *pool);
int
-virStorageBackendSheepdogParseNodeInfo(virStoragePoolDefPtr pool,
+virStorageBackendSheepdogParseNodeInfo(virStoragePoolDef *pool,
char *output)
{
/* fields:
}
void
-virStorageBackendSheepdogAddHostArg(virCommandPtr cmd,
- virStoragePoolObjPtr pool)
+virStorageBackendSheepdogAddHostArg(virCommand *cmd,
+ virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
const char *address = "localhost";
int port = 7000;
if (def->source.nhost > 0) {
}
static int
-virStorageBackendSheepdogAddVolume(virStoragePoolObjPtr pool, const char *diskInfo)
+virStorageBackendSheepdogAddVolume(virStoragePoolObj *pool, const char *diskInfo)
{
g_autoptr(virStorageVolDef) vol = NULL;
}
static int
-virStorageBackendSheepdogRefreshAllVol(virStoragePoolObjPtr pool)
+virStorageBackendSheepdogRefreshAllVol(virStoragePoolObj *pool)
{
size_t i;
g_autofree char *output = NULL;
static int
-virStorageBackendSheepdogRefreshPool(virStoragePoolObjPtr pool)
+virStorageBackendSheepdogRefreshPool(virStoragePoolObj *pool)
{
g_autofree char *output = NULL;
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendSheepdogDeleteVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendSheepdogDeleteVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
g_autoptr(virCommand) cmd = NULL;
static int
-virStorageBackendSheepdogCreateVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendSheepdogCreateVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (vol->target.encryption != NULL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
-virStorageBackendSheepdogBuildVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendSheepdogBuildVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
g_autoptr(virCommand) cmd = NULL;
int
-virStorageBackendSheepdogParseVdiList(virStorageVolDefPtr vol,
+virStorageBackendSheepdogParseVdiList(virStorageVolDef *vol,
char *output)
{
/* fields:
}
static int
-virStorageBackendSheepdogRefreshVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendSheepdogRefreshVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
char *output = NULL;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virCommand) cmd = NULL;
cmd = virCommandNewArgList(SHEEPDOGCLI, "vdi", "list", vol->name, "-r", NULL);
static int
-virStorageBackendSheepdogResizeVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendSheepdogResizeVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity,
unsigned int flags)
{
#include "conf/storage_conf.h"
-int virStorageBackendSheepdogParseNodeInfo(virStoragePoolDefPtr pool,
+int virStorageBackendSheepdogParseNodeInfo(virStoragePoolDef *pool,
char *output);
-int virStorageBackendSheepdogParseVdiList(virStorageVolDefPtr vol,
+int virStorageBackendSheepdogParseVdiList(virStorageVolDef *vol,
char *output);
* Returns 0 on success, -1 on error
*/
static int
-virStorageBackendVzPoolBuild(virStoragePoolObjPtr pool,
+virStorageBackendVzPoolBuild(virStoragePoolObj *pool,
unsigned int flags)
{
virCheckFlags(0, -1);
static int
-virStorageBackendVzPoolStart(virStoragePoolObjPtr pool)
+virStorageBackendVzPoolStart(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *grp_name = NULL;
g_autofree char *usr_name = NULL;
g_autofree char *mode = NULL;
static int
-virStorageBackendVzIsMounted(virStoragePoolObjPtr pool)
+virStorageBackendVzIsMounted(virStoragePoolObj *pool)
{
int ret = -1;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
FILE *mtab;
struct mntent ent;
char buf[1024];
static int
-virStorageBackendVzPoolStop(virStoragePoolObjPtr pool)
+virStorageBackendVzPoolStop(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int rc;
g_autoptr(virCommand) cmd = NULL;
* Check whether the cluster is mounted
*/
static int
-virStorageBackendVzCheck(virStoragePoolObjPtr pool,
+virStorageBackendVzCheck(virStoragePoolObj *pool,
bool *isActive)
{
int ret = -1;
}
static int
-virStorageBackendZFSCheckPool(virStoragePoolObjPtr pool G_GNUC_UNUSED,
+virStorageBackendZFSCheckPool(virStoragePoolObj *pool G_GNUC_UNUSED,
bool *isActive)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autofree char *devpath = NULL;
devpath = g_strdup_printf("/dev/zvol/%s", def->source.name);
}
static int
-virStorageBackendZFSParseVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendZFSParseVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
const char *volume_string)
{
int ret = -1;
char *vol_name;
bool is_new_vol = false;
- virStorageVolDefPtr volume = NULL;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStorageVolDef *volume = NULL;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_auto(GStrv) tokens = NULL;
char *tmp;
}
static int
-virStorageBackendZFSFindVols(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendZFSFindVols(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
size_t i;
g_auto(GStrv) lines = NULL;
g_autoptr(virCommand) cmd = NULL;
}
static int
-virStorageBackendZFSRefreshPool(virStoragePoolObjPtr pool G_GNUC_UNUSED)
+virStorageBackendZFSRefreshPool(virStoragePoolObj *pool G_GNUC_UNUSED)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
char *zpool_props = NULL;
size_t i;
g_autoptr(virCommand) cmd = NULL;
}
static int
-virStorageBackendZFSCreateVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendZFSCreateVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int volmode_needed = -1;
g_autoptr(virCommand) cmd = NULL;
}
static int
-virStorageBackendZFSDeleteVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendZFSDeleteVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virCommand) destroy_cmd = NULL;
virCheckFlags(0, -1);
}
static int
-virStorageBackendZFSBuildPool(virStoragePoolObjPtr pool,
+virStorageBackendZFSBuildPool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
size_t i;
g_autoptr(virCommand) cmd = NULL;
int ret = -1;
}
static int
-virStorageBackendZFSDeletePool(virStoragePoolObjPtr pool,
+virStorageBackendZFSDeletePool(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(virCommand) cmd = NULL;
char *tmp;
VIR_LOG_INIT("storage.storage_driver");
-static virStorageDriverStatePtr driver;
+static virStorageDriverState *driver;
static int storageStateCleanup(void);
typedef struct _virStorageVolStreamInfo virStorageVolStreamInfo;
-typedef virStorageVolStreamInfo *virStorageVolStreamInfoPtr;
struct _virStorageVolStreamInfo {
char *pool_name;
char *vol_path;
static void
-storagePoolRefreshFailCleanup(virStorageBackendPtr backend,
- virStoragePoolObjPtr obj,
+storagePoolRefreshFailCleanup(virStorageBackend *backend,
+ virStoragePoolObj *obj,
const char *stateFile)
{
virErrorPtr orig_err;
static int
-storagePoolRefreshImpl(virStorageBackendPtr backend,
- virStoragePoolObjPtr obj,
+storagePoolRefreshImpl(virStorageBackend *backend,
+ virStoragePoolObj *obj,
const char *stateFile)
{
virStoragePoolObjClearVols(obj);
* pools are removed.
*/
static void
-virStoragePoolUpdateInactive(virStoragePoolObjPtr obj)
+virStoragePoolUpdateInactive(virStoragePoolObj *obj)
{
if (!virStoragePoolObjGetConfigFile(obj)) {
virStoragePoolObjRemove(driver->pools, obj);
static void
-storagePoolUpdateStateCallback(virStoragePoolObjPtr obj,
+storagePoolUpdateStateCallback(virStoragePoolObj *obj,
const void *opaque G_GNUC_UNUSED)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
bool active = false;
- virStorageBackendPtr backend;
+ virStorageBackend *backend;
g_autofree char *stateFile = NULL;
if ((backend = virStorageBackendForType(def->type)) == NULL) {
static void
-storageDriverAutostartCallback(virStoragePoolObjPtr obj,
+storageDriverAutostartCallback(virStoragePoolObj *obj,
const void *opaque G_GNUC_UNUSED)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
- virStorageBackendPtr backend;
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
+ virStorageBackend *backend;
bool started = false;
if (!(backend = virStorageBackendForType(def->type)))
static virDrvOpenStatus
storageConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
}
-static virStoragePoolObjPtr
+static virStoragePoolObj *
storagePoolObjFindByUUID(const unsigned char *uuid,
const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (!(obj = virStoragePoolObjFindByUUID(driver->pools, uuid))) {
}
-static virStoragePoolObjPtr
+static virStoragePoolObj *
virStoragePoolObjFromStoragePool(virStoragePoolPtr pool)
{
return storagePoolObjFindByUUID(pool->uuid, pool->name);
}
-static virStoragePoolObjPtr
+static virStoragePoolObj *
storagePoolObjFindByName(const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (!(obj = virStoragePoolObjFindByName(driver->pools, name)))
virReportError(VIR_ERR_NO_STORAGE_POOL,
storagePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
obj = storagePoolObjFindByUUID(uuid, NULL);
storagePoolLookupByName(virConnectPtr conn,
const char *name)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
if (!(obj = storagePoolObjFindByName(name)))
static virStoragePoolPtr
storagePoolLookupByVolume(virStorageVolPtr vol)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
if (!(obj = storagePoolObjFindByName(vol->pool)))
unsigned int flags)
{
int backend_type;
- virStorageBackendPtr backend;
+ virStorageBackend *backend;
if (virConnectFindStoragePoolSourcesEnsureACL(conn) < 0)
return NULL;
storageConnectGetStoragePoolCapabilities(virConnectPtr conn,
unsigned int flags)
{
- virStoragePoolCapsPtr caps = NULL;
+ virStoragePoolCaps *caps = NULL;
char *ret;
virCheckFlags(0, NULL);
static int
storagePoolIsActive(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
static int
storagePoolIsPersistent(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
const char *xml,
unsigned int flags)
{
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
unsigned int build_flags = 0;
g_autoptr(virStoragePoolDef) newDef = NULL;
g_autofree char *stateFile = NULL;
const char *xml,
unsigned int flags)
{
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autoptr(virStoragePoolDef) newDef = NULL;
virCheckFlags(0, NULL);
static int
storagePoolUndefine(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
const char *autostartLink;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
int ret = -1;
if (!(obj = storagePoolObjFindByUUID(pool->uuid, pool->name)))
storagePoolCreate(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
int ret = -1;
unsigned int build_flags = 0;
g_autofree char *stateFile = NULL;
storagePoolBuild(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
bool restoreStarting = false;
int ret = -1;
static int
storagePoolDestroy(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
int ret = -1;
g_autofree char *stateFile = NULL;
storagePoolDelete(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
int ret = -1;
g_autofree char *stateFile = NULL;
storagePoolRefresh(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
g_autofree char *stateFile = NULL;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
storagePoolGetInfo(virStoragePoolPtr pool,
virStoragePoolInfoPtr info)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
storagePoolGetXMLDesc(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStoragePoolDefPtr newDef;
- virStoragePoolDefPtr curDef;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStoragePoolDef *newDef;
+ virStoragePoolDef *curDef;
char *ret = NULL;
virCheckFlags(VIR_STORAGE_XML_INACTIVE, NULL);
storagePoolGetAutostart(virStoragePoolPtr pool,
int *autostart)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
int ret = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
storagePoolSetAutostart(virStoragePoolPtr pool,
int autostart)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
const char *configFile;
const char *autostartLink;
bool new_autostart;
static int
storagePoolNumOfVolumes(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
char **const names,
int maxnames)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int n = -1;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
virStorageVolPtr **vols,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
virCheckFlags(0, -1);
storageVolLookupByName(virStoragePoolPtr pool,
const char *name)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr voldef;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageVolDef *voldef;
virStorageVolPtr vol = NULL;
if (!(obj = virStoragePoolObjFromStoragePool(pool)))
const char *key;
char *cleanpath;
const char *path;
- virStorageVolDefPtr voldef;
+ virStorageVolDef *voldef;
};
static bool
-storageVolLookupByKeyCallback(virStoragePoolObjPtr obj,
+storageVolLookupByKeyCallback(virStoragePoolObj *obj,
const void *opaque)
{
struct storageVolLookupData *data = (struct storageVolLookupData *)opaque;
storageVolLookupByKey(virConnectPtr conn,
const char *key)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
struct storageVolLookupData data = {
.key = key, .voldef = NULL };
virStorageVolPtr vol = NULL;
static bool
-storageVolLookupByPathCallback(virStoragePoolObjPtr obj,
+storageVolLookupByPathCallback(virStoragePoolObj *obj,
const void *opaque)
{
struct storageVolLookupData *data = (struct storageVolLookupData *)opaque;
- virStoragePoolDefPtr def;
+ virStoragePoolDef *def;
g_autofree char *stable_path = NULL;
if (!virStoragePoolObjIsActive(obj))
storageVolLookupByPath(virConnectPtr conn,
const char *path)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
struct storageVolLookupData data = {
.path = path, .voldef = NULL };
virStorageVolPtr vol = NULL;
static bool
-storagePoolLookupByTargetPathCallback(virStoragePoolObjPtr obj,
+storagePoolLookupByTargetPathCallback(virStoragePoolObj *obj,
const void *opaque)
{
const char *path = opaque;
- virStoragePoolDefPtr def;
+ virStoragePoolDef *def;
if (!virStoragePoolObjIsActive(obj))
return false;
storagePoolLookupByTargetPath(virConnectPtr conn,
const char *path)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
g_autofree char *cleanpath = NULL;
static int
-storageVolDeleteInternal(virStorageBackendPtr backend,
- virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef,
+storageVolDeleteInternal(virStorageBackend *backend,
+ virStoragePoolObj *obj,
+ virStorageVolDef *voldef,
unsigned int flags,
bool updateMeta)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
if (!backend->deleteVol) {
virReportError(VIR_ERR_NO_SUPPORT,
}
-static virStorageVolDefPtr
+static virStorageVolDef *
virStorageVolDefFromVol(virStorageVolPtr vol,
- virStoragePoolObjPtr *obj,
- virStorageBackendPtr *backend)
+ virStoragePoolObj **obj,
+ virStorageBackend **backend)
{
- virStorageVolDefPtr voldef = NULL;
- virStoragePoolDefPtr def;
+ virStorageVolDef *voldef = NULL;
+ virStoragePoolDef *def;
if (!(*obj = storagePoolObjFindByName(vol->pool)))
return NULL;
storageVolDelete(virStorageVolPtr vol,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStorageBackendPtr backend;
- virStorageVolDefPtr voldef = NULL;
+ virStoragePoolObj *obj;
+ virStorageBackend *backend;
+ virStorageVolDef *voldef = NULL;
int ret = -1;
if (!(voldef = virStorageVolDefFromVol(vol, &obj, &backend)))
const char *xmldesc,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
virStorageVolPtr vol = NULL, newvol = NULL;
g_autoptr(virStorageVolDef) voldef = NULL;
if (backend->buildVol) {
int buildret;
- virStorageVolDefPtr buildvoldef = NULL;
+ virStorageVolDef *buildvoldef = NULL;
buildvoldef = g_new0(virStorageVolDef, 1);
virStorageVolPtr volsrc,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStoragePoolObjPtr objsrc = NULL;
- virStorageBackendPtr backend;
- virStorageVolDefPtr voldefsrc = NULL;
- virStorageVolDefPtr shadowvol = NULL;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStoragePoolObj *objsrc = NULL;
+ virStorageBackend *backend;
+ virStorageVolDef *voldefsrc = NULL;
+ virStorageVolDef *shadowvol = NULL;
virStorageVolPtr newvol = NULL;
virStorageVolPtr vol = NULL;
int buildret;
}
if (objsrc && !virStoragePoolObjIsActive(objsrc)) {
- virStoragePoolDefPtr objsrcdef = virStoragePoolObjGetDef(objsrc);
+ virStoragePoolDef *objsrcdef = virStoragePoolObjGetDef(objsrc);
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is not active"),
objsrcdef->name);
unsigned long long length,
unsigned int flags)
{
- virStorageBackendPtr backend;
- virStoragePoolObjPtr obj = NULL;
- virStorageVolDefPtr voldef = NULL;
+ virStorageBackend *backend;
+ virStoragePoolObj *obj = NULL;
+ virStorageVolDef *voldef = NULL;
int ret = -1;
virCheckFlags(VIR_STORAGE_VOL_DOWNLOAD_SPARSE_STREAM, -1);
static void
virStorageVolPoolRefreshDataFree(void *opaque)
{
- virStorageVolStreamInfoPtr cbdata = opaque;
+ virStorageVolStreamInfo *cbdata = opaque;
g_free(cbdata->pool_name);
g_free(cbdata);
static void
virStorageVolPoolRefreshThread(void *opaque)
{
- virStorageVolStreamInfoPtr cbdata = opaque;
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virObjectEventPtr event = NULL;
+ virStorageVolStreamInfo *cbdata = opaque;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virObjectEvent *event = NULL;
if (cbdata->vol_path) {
if (virStorageBackendPloopRestoreDesc(cbdata->vol_path) < 0)
unsigned long long length,
unsigned int flags)
{
- virStorageBackendPtr backend;
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr voldef = NULL;
- virStorageVolStreamInfoPtr cbdata = NULL;
+ virStorageBackend *backend;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
+ virStorageVolDef *voldef = NULL;
+ virStorageVolStreamInfo *cbdata = NULL;
int rc;
int ret = -1;
unsigned long long capacity,
unsigned int flags)
{
- virStorageBackendPtr backend;
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr voldef = NULL;
+ virStorageBackend *backend;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
+ virStorageVolDef *voldef = NULL;
unsigned long long abs_capacity, delta = 0;
int ret = -1;
unsigned int algorithm,
unsigned int flags)
{
- virStorageBackendPtr backend;
- virStoragePoolObjPtr obj = NULL;
- virStorageVolDefPtr voldef = NULL;
+ virStorageBackend *backend;
+ virStoragePoolObj *obj = NULL;
+ virStorageVolDef *voldef = NULL;
int rc;
int ret = -1;
virStorageVolInfoPtr info,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStorageBackendPtr backend;
- virStorageVolDefPtr voldef;
+ virStoragePoolObj *obj;
+ virStorageBackend *backend;
+ virStorageVolDef *voldef;
int ret = -1;
virCheckFlags(VIR_STORAGE_VOL_GET_PHYSICAL, -1);
storageVolGetXMLDesc(virStorageVolPtr vol,
unsigned int flags)
{
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageBackendPtr backend;
- virStorageVolDefPtr voldef;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageBackend *backend;
+ virStorageVolDef *voldef;
char *ret = NULL;
virCheckFlags(0, NULL);
static char *
storageVolGetPath(virStorageVolPtr vol)
{
- virStoragePoolObjPtr obj;
- virStorageVolDefPtr voldef;
+ virStoragePoolObj *obj;
+ virStorageVolDef *voldef;
char *ret = NULL;
if (!(voldef = virStorageVolDefFromVol(vol, &obj, NULL)))
*
* Returns NULL if pool is not found or a locked pool object pointer
*/
-virStoragePoolObjPtr
+virStoragePoolObj *
virStoragePoolObjFindPoolByUUID(const unsigned char *uuid)
{
return virStoragePoolObjFindByUUID(driver->pools, uuid);
* Returns a string pointer on success, NULL on failure
*/
char *
-virStoragePoolObjBuildTempFilePath(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef)
+virStoragePoolObjBuildTempFilePath(virStoragePoolObj *obj,
+ virStorageVolDef *voldef)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
return g_strdup_printf("%s/%s.%s.secret.XXXXXX", driver->stateDir,
def->name, voldef->name);
}
#include "domain_conf.h"
#include "virstorageobj.h"
-virStoragePoolObjPtr virStoragePoolObjFindPoolByUUID(const unsigned char *uuid)
+virStoragePoolObj *virStoragePoolObjFindPoolByUUID(const unsigned char *uuid)
ATTRIBUTE_NONNULL(1);
virStoragePoolPtr
const char *path)
ATTRIBUTE_NONNULL(2);
-char *virStoragePoolObjBuildTempFilePath(virStoragePoolObjPtr obj,
- virStorageVolDefPtr voldef)
+char *virStoragePoolObjBuildTempFilePath(virStoragePoolObj *obj,
+ virStorageVolDef *voldef)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int storageRegister(void);
*/
int
virStorageBackendNamespaceInit(int poolType,
- virXMLNamespacePtr xmlns)
+ virXMLNamespace *xmlns)
{
return virStoragePoolOptionsPoolTypeSetXMLNamespace(poolType, xmlns);
}
static int ATTRIBUTE_NONNULL(2)
-virStorageBackendCopyToFD(virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendCopyToFD(virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
int fd,
unsigned long long *total,
bool want_sparse,
}
static int
-storageBackendCreateBlockFrom(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendCreateBlockFrom(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
unsigned long long remain;
}
static int
-createRawFile(int fd, virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+createRawFile(int fd, virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
bool reflink_copy)
{
bool need_alloc = true;
}
static int
-storageBackendCreateRaw(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendCreateRaw(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int operation_flags;
bool reflink_copy = false;
mode_t open_mode = VIR_STORAGE_DEFAULT_VOL_PERM_MODE;
static int
-virStorageBackendCreateExecCommand(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virCommandPtr cmd)
+virStorageBackendCreateExecCommand(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virCommand *cmd)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
struct stat st;
gid_t gid;
uid_t uid;
/* Create ploop directory with ploop image and DiskDescriptor.xml
* if function fails to create image file the directory will be deleted.*/
static int
-storageBackendCreatePloop(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendCreatePloop(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
int ret = -1;
static int
-storagePloopResize(virStorageVolDefPtr vol,
+storagePloopResize(virStorageVolDef *vol,
unsigned long long capacity)
{
g_autoptr(virCommand) cmd = NULL;
bool encryption;
bool preallocate;
const char *compat;
- virBitmapPtr features;
+ virBitmap *features;
bool nocow;
const char *backingPath;
*
*/
static void
-storageBackendBuildQemuImgEncriptionOpts(virBufferPtr buf,
+storageBackendBuildQemuImgEncriptionOpts(virBuffer *buf,
int format,
- virStorageEncryptionInfoDefPtr encinfo,
+ virStorageEncryptionInfoDef *encinfo,
const char *alias)
{
const char *encprefix;
static int
-storageBackendCreateQemuImgOpts(virStorageEncryptionInfoDefPtr encinfo,
+storageBackendCreateQemuImgOpts(virStorageEncryptionInfoDef *encinfo,
char **opts,
struct _virStorageBackendQemuImgInfo *info)
{
static int
storageBackendCreateQemuImgCheckEncryption(int format,
const char *type,
- virStorageVolDefPtr vol)
+ virStorageVolDef *vol)
{
- virStorageEncryptionPtr enc = vol->target.encryption;
+ virStorageEncryption *enc = vol->target.encryption;
if (format == VIR_STORAGE_FILE_RAW ||
format == VIR_STORAGE_FILE_QCOW2) {
static int
-storageBackendCreateQemuImgSetInput(virStorageVolDefPtr inputvol,
+storageBackendCreateQemuImgSetInput(virStorageVolDef *inputvol,
virStorageVolEncryptConvertStep convertStep,
struct _virStorageBackendQemuImgInfo *info)
{
static int
-storageBackendCreateQemuImgSetBacking(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendCreateQemuImgSetBacking(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
struct _virStorageBackendQemuImgInfo *info)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int accessRetCode = -1;
g_autofree char *absolutePath = NULL;
static int
-storageBackendCreateQemuImgSetOptions(virCommandPtr cmd,
- virStorageEncryptionInfoDefPtr encinfo,
+storageBackendCreateQemuImgSetOptions(virCommand *cmd,
+ virStorageEncryptionInfoDef *encinfo,
struct _virStorageBackendQemuImgInfo *info)
{
g_autofree char *opts = NULL;
* NB: format=raw is assumed
*/
static int
-storageBackendCreateQemuImgSecretObject(virCommandPtr cmd,
+storageBackendCreateQemuImgSecretObject(virCommand *cmd,
const char *secretPath,
const char *secretAlias)
{
*
*/
static int
-storageBackendResizeQemuImgImageOpts(virCommandPtr cmd,
+storageBackendResizeQemuImgImageOpts(virCommand *cmd,
int format,
const char *path,
const char *secretAlias)
static int
-virStorageBackendCreateQemuImgSetInfo(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendCreateQemuImgSetInfo(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
virStorageVolEncryptConvertStep convertStep,
struct _virStorageBackendQemuImgInfo *info)
{
/* Create a qemu-img virCommand from the supplied arguments */
-virCommandPtr
-virStorageBackendCreateQemuImgCmdFromVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virCommand *
+virStorageBackendCreateQemuImgCmdFromVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags,
const char *create_tool,
const char *secretPath,
const char *inputSecretPath,
virStorageVolEncryptConvertStep convertStep)
{
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
struct _virStorageBackendQemuImgInfo info = {
.format = vol->target.format,
.type = NULL,
.nocow = vol->target.nocow,
.secretAlias = NULL,
};
- virStorageEncryptionPtr enc = vol->target.encryption;
- virStorageEncryptionPtr inputenc = inputvol ? inputvol->target.encryption : NULL;
- virStorageEncryptionInfoDefPtr encinfo = NULL;
+ virStorageEncryption *enc = vol->target.encryption;
+ virStorageEncryption *inputenc = inputvol ? inputvol->target.encryption : NULL;
+ virStorageEncryptionInfoDef *encinfo = NULL;
g_autofree char *inputSecretAlias = NULL;
const char *encprefix;
const char *inputencprefix;
static char *
-storageBackendCreateQemuImgSecretPath(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+storageBackendCreateQemuImgSecretPath(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStorageEncryptionPtr enc = vol->target.encryption;
+ virStorageEncryption *enc = vol->target.encryption;
char *secretPath = NULL;
uint8_t *secret = NULL;
size_t secretlen = 0;
static int
-storageBackendDoCreateQemuImg(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendDoCreateQemuImg(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags,
const char *create_tool,
const char *secretPath,
static int
-storageBackendCreateQemuImg(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendCreateQemuImg(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
int ret = -1;
* Returns: 0 on success, -1 on failure.
*/
int
-virStorageBackendCreateVolUsingQemuImg(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendCreateVolUsingQemuImg(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
int ret = -1;
virStorageBackendBuildVolFrom
-virStorageBackendGetBuildVolFromFunction(virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol)
+virStorageBackendGetBuildVolFromFunction(virStorageVolDef *vol,
+ virStorageVolDef *inputvol)
{
if (!inputvol)
return NULL;
* VIR_WARN of the issue).
*/
static int
-virStorageBackendDetectBlockVolFormatFD(virStorageSourcePtr target,
+virStorageBackendDetectBlockVolFormatFD(virStorageSource *target,
int fd,
unsigned int readflags)
{
* virStorageBackendUpdateVolTargetFd once again.
*/
static int
-storageBackendRedoPloopUpdate(virStorageSourcePtr target, struct stat *sb,
+storageBackendRedoPloopUpdate(virStorageSource *target, struct stat *sb,
int *fd, unsigned int flags)
{
g_autofree char *path = NULL;
*/
static int
storageBackendUpdateVolTargetInfo(virStorageVolType voltype,
- virStorageSourcePtr target,
+ virStorageSource *target,
bool withBlockVolFormat,
unsigned int openflags,
unsigned int readflags)
* open error occurred. It is up to the caller to handle.
*/
int
-virStorageBackendUpdateVolInfo(virStorageVolDefPtr vol,
+virStorageBackendUpdateVolInfo(virStorageVolDef *vol,
bool withBlockVolFormat,
unsigned int openflags,
unsigned int readflags)
* Returns 0 for success, -1 on a legitimate error condition.
*/
int
-virStorageBackendUpdateVolTargetInfoFD(virStorageSourcePtr target,
+virStorageBackendUpdateVolTargetInfoFD(virStorageSource *target,
int fd,
struct stat *sb)
{
* a change to appear.
*/
char *
-virStorageBackendStablePath(virStoragePoolObjPtr pool,
+virStorageBackendStablePath(virStoragePoolObj *pool,
const char *devpath,
bool loop)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(DIR) dh = NULL;
struct dirent *dent;
char *stablepath;
/* Common/Local File System/Directory Volume API's */
static int
-createFileDir(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+createFileDir(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
mode_t permmode = VIR_STORAGE_DEFAULT_VOL_PERM_MODE;
unsigned int createflags = 0;
* function), and can drop the parent pool lock during the (slow) allocation.
*/
int
-virStorageBackendVolCreateLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+virStorageBackendVolCreateLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
if (vol->target.format == VIR_STORAGE_FILE_DIR)
vol->type = VIR_STORAGE_VOL_DIR;
static int
-storageBackendVolBuildLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+storageBackendVolBuildLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
virStorageBackendBuildVolFrom create_func;
* special kinds of files
*/
int
-virStorageBackendVolBuildLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendVolBuildLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags)
{
return storageBackendVolBuildLocal(pool, vol, NULL, flags);
* Create a storage vol using 'inputvol' as input
*/
int
-virStorageBackendVolBuildFromLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendVolBuildFromLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags)
{
return storageBackendVolBuildLocal(pool, vol, inputvol, flags);
* Remove a volume - no support for BLOCK and NETWORK yet
*/
int
-virStorageBackendVolDeleteLocal(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
+virStorageBackendVolDeleteLocal(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
unsigned int flags)
{
virCheckFlags(0, -1);
* -1 on failures w/ error message set
*/
static int
-storageBackendLoadDefaultSecrets(virStorageVolDefPtr vol)
+storageBackendLoadDefaultSecrets(virStorageVolDef *vol)
{
virSecretPtr sec;
- virStorageEncryptionSecretPtr encsec = NULL;
+ virStorageEncryptionSecret *encsec = NULL;
virConnectPtr conn = NULL;
if (!vol->target.encryption || vol->target.encryption->nsecrets != 0)
if (!sec)
return 0;
- vol->target.encryption->secrets = g_new0(virStorageEncryptionSecretPtr, 1);
+ vol->target.encryption->secrets = g_new0(virStorageEncryptionSecret *, 1);
encsec = g_new0(virStorageEncryptionSecret, 1);
vol->target.encryption->nsecrets = 1;
* Update info about a volume's capacity/allocation
*/
int
-virStorageBackendVolRefreshLocal(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol)
+virStorageBackendVolRefreshLocal(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol)
{
int ret;
static int
-storageBackendResizeQemuImg(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+storageBackendResizeQemuImg(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity)
{
int ret = -1;
const char *type;
- virStorageEncryptionPtr enc = vol->target.encryption;
+ virStorageEncryption *enc = vol->target.encryption;
g_autoptr(virCommand) cmd = NULL;
g_autofree char *img_tool = NULL;
g_autofree char *secretPath = NULL;
* Resize a volume
*/
int
-virStorageBackendVolResizeLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+virStorageBackendVolResizeLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity,
unsigned int flags)
{
int
-virStorageBackendVolUploadLocal(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
+virStorageBackendVolUploadLocal(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long len,
}
int
-virStorageBackendVolDownloadLocal(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
+virStorageBackendVolDownloadLocal(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long len,
static int
-storageBackendVolWipePloop(virStorageVolDefPtr vol,
+storageBackendVolWipePloop(virStorageVolDef *vol,
unsigned int algorithm)
{
g_autoptr(virCommand) cmd = NULL;
int
-virStorageBackendVolWipeLocal(virStoragePoolObjPtr pool G_GNUC_UNUSED,
- virStorageVolDefPtr vol,
+virStorageBackendVolWipeLocal(virStoragePoolObj *pool G_GNUC_UNUSED,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags)
{
* Returns 0 on success, -1 on failure
*/
int
-virStorageBackendBuildLocal(virStoragePoolObjPtr pool)
+virStorageBackendBuildLocal(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
char *p = NULL;
mode_t mode;
bool needs_create_as_uid;
* Returns 0 on success, -1 on error
*/
int
-virStorageBackendDeleteLocal(virStoragePoolObjPtr pool,
+virStorageBackendDeleteLocal(virStoragePoolObj *pool,
unsigned int flags)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
virCheckFlags(0, -1);
int
virStorageUtilGlusterExtractPoolSources(const char *host,
const char *xml,
- virStoragePoolSourceListPtr list,
+ virStoragePoolSourceList *list,
virStoragePoolType pooltype)
{
xmlDocPtr doc = NULL;
int
virStorageBackendFindGlusterPoolSources(const char *host,
virStoragePoolType pooltype,
- virStoragePoolSourceListPtr list,
+ virStoragePoolSourceList *list,
bool report)
{
int rc;
static int
-storageBackendProbeTarget(virStorageSourcePtr target,
- virStorageEncryptionPtr *encryption)
+storageBackendProbeTarget(virStorageSource *target,
+ virStorageEncryption **encryption)
{
int rc;
struct stat sb;
* Returns 0 on success, -2 to ignore failure, -1 on failure
*/
int
-virStorageBackendRefreshVolTargetUpdate(virStorageVolDefPtr vol)
+virStorageBackendRefreshVolTargetUpdate(virStorageVolDef *vol)
{
int err;
* within it. This is non-recursive.
*/
int
-virStorageBackendRefreshLocal(virStoragePoolObjPtr pool)
+virStorageBackendRefreshLocal(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
g_autoptr(DIR) dir = NULL;
struct dirent *ent;
struct statvfs sb;
* -2 => Failure to find a stable path, not fatal, caller can try another
*/
static int
-virStorageBackendSCSINewLun(virStoragePoolObjPtr pool,
+virStorageBackendSCSINewLun(virStoragePoolObj *pool,
uint32_t host G_GNUC_UNUSED,
uint32_t bus,
uint32_t target,
uint32_t lun,
const char *dev)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int retval = -1;
g_autoptr(virStorageVolDef) vol = NULL;
g_autofree char *devpath = NULL;
* -2 => non-fatal error or a non-disk entry
*/
static int
-processLU(virStoragePoolObjPtr pool,
+processLU(virStoragePoolObj *pool,
uint32_t host,
uint32_t bus,
uint32_t target,
int
-virStorageBackendSCSIFindLUs(virStoragePoolObjPtr pool,
+virStorageBackendSCSIFindLUs(virStoragePoolObj *pool,
uint32_t scanhost)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
int retval = 0;
uint32_t bus, target, lun;
const char *device_path = "/sys/bus/scsi/devices";
* It is up to the caller to VIR_FREE the allocated string
*/
char *
-virStorageBackendFileSystemGetPoolSource(virStoragePoolObjPtr pool)
+virStorageBackendFileSystemGetPoolSource(virStoragePoolObj *pool)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(pool);
char *src = NULL;
if (def->type == VIR_STORAGE_POOL_NETFS) {
static void
-virStorageBackendFileSystemMountAddOptions(virCommandPtr cmd,
- virStoragePoolDefPtr def,
+virStorageBackendFileSystemMountAddOptions(virCommand *cmd,
+ virStoragePoolDef *def,
const char *providedOpts)
{
g_autofree char *mountOpts = NULL;
if (def->namespaceData) {
size_t i;
- virStoragePoolFSMountOptionsDefPtr opts = def->namespaceData;
+ virStoragePoolFSMountOptionsDef *opts = def->namespaceData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
for (i = 0; i < opts->noptions; i++)
static void
-virStorageBackendFileSystemMountNFSArgs(virCommandPtr cmd,
+virStorageBackendFileSystemMountNFSArgs(virCommand *cmd,
const char *src,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
const char *nfsVers)
{
virStorageBackendFileSystemMountAddOptions(cmd, def, nfsVers);
static void
-virStorageBackendFileSystemMountGlusterArgs(virCommandPtr cmd,
+virStorageBackendFileSystemMountGlusterArgs(virCommand *cmd,
const char *src,
- virStoragePoolDefPtr def)
+ virStoragePoolDef *def)
{
const char *fmt;
static void
-virStorageBackendFileSystemMountCIFSArgs(virCommandPtr cmd,
+virStorageBackendFileSystemMountCIFSArgs(virCommand *cmd,
const char *src,
- virStoragePoolDefPtr def)
+ virStoragePoolDef *def)
{
const char *fmt;
static void
-virStorageBackendFileSystemMountDefaultArgs(virCommandPtr cmd,
+virStorageBackendFileSystemMountDefaultArgs(virCommand *cmd,
const char *src,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
const char *nfsVers)
{
const char *fmt;
}
-virCommandPtr
+virCommand *
virStorageBackendFileSystemMountCmd(const char *cmdstr,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
const char *src)
{
/* 'mount -t auto' doesn't seem to auto determine nfs (or cifs),
def->source.format == VIR_STORAGE_POOL_NETFS_GLUSTERFS);
bool cifsfs = (def->type == VIR_STORAGE_POOL_NETFS &&
def->source.format == VIR_STORAGE_POOL_NETFS_CIFS);
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
g_autofree char *nfsVers = NULL;
if (def->type == VIR_STORAGE_POOL_NETFS && def->source.protocolVer > 0)
}
-virCommandPtr
+virCommand *
virStorageBackendLogicalChangeCmd(const char *cmdstr,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
bool on)
{
return virCommandNewArgList(cmdstr,
/* Storage Pool Namespace options to share w/ storage_backend_fs.c and
* the virStorageBackendFileSystemMountCmd method */
typedef struct _virStoragePoolFSMountOptionsDef virStoragePoolFSMountOptionsDef;
-typedef virStoragePoolFSMountOptionsDef *virStoragePoolFSMountOptionsDefPtr;
struct _virStoragePoolFSMountOptionsDef {
size_t noptions;
char **options;
int
virStorageBackendNamespaceInit(int poolType,
- virXMLNamespacePtr xmlns);
+ virXMLNamespace *xmlns);
/* File creation/cloning functions used for cloning between backends */
int
-virStorageBackendCreateVolUsingQemuImg(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virStorageBackendCreateVolUsingQemuImg(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags);
virStorageBackendBuildVolFrom
-virStorageBackendGetBuildVolFromFunction(virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol);
+virStorageBackendGetBuildVolFromFunction(virStorageVolDef *vol,
+ virStorageVolDef *inputvol);
-int virStorageBackendVolCreateLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol);
+int virStorageBackendVolCreateLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol);
-int virStorageBackendVolBuildLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolBuildLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags);
-int virStorageBackendVolBuildFromLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+int virStorageBackendVolBuildFromLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags);
-int virStorageBackendVolDeleteLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolDeleteLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int flags);
-int virStorageBackendVolRefreshLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol);
+int virStorageBackendVolRefreshLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol);
-int virStorageBackendVolResizeLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolResizeLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned long long capacity,
unsigned int flags);
-int virStorageBackendVolUploadLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolUploadLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long len,
unsigned int flags);
-int virStorageBackendVolDownloadLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolDownloadLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long len,
unsigned int flags);
-int virStorageBackendVolWipeLocal(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+int virStorageBackendVolWipeLocal(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
unsigned int algorithm,
unsigned int flags);
/* Local/Common Storage Pool Backend APIs */
-int virStorageBackendBuildLocal(virStoragePoolObjPtr pool);
+int virStorageBackendBuildLocal(virStoragePoolObj *pool);
-int virStorageBackendDeleteLocal(virStoragePoolObjPtr pool,
+int virStorageBackendDeleteLocal(virStoragePoolObj *pool,
unsigned int flags);
int
-virStorageBackendRefreshVolTargetUpdate(virStorageVolDefPtr vol);
+virStorageBackendRefreshVolTargetUpdate(virStorageVolDef *vol);
-int virStorageBackendRefreshLocal(virStoragePoolObjPtr pool);
+int virStorageBackendRefreshLocal(virStoragePoolObj *pool);
int virStorageUtilGlusterExtractPoolSources(const char *host,
const char *xml,
- virStoragePoolSourceListPtr list,
+ virStoragePoolSourceList *list,
virStoragePoolType pooltype);
int virStorageBackendFindGlusterPoolSources(const char *host,
virStoragePoolType pooltype,
- virStoragePoolSourceListPtr list,
+ virStoragePoolSourceList *list,
bool report);
bool virStorageBackendDeviceIsEmpty(const char *devpath,
#define VIR_STORAGE_DEFAULT_POOL_PERM_MODE 0711
#define VIR_STORAGE_DEFAULT_VOL_PERM_MODE 0600
-int virStorageBackendUpdateVolInfo(virStorageVolDefPtr vol,
+int virStorageBackendUpdateVolInfo(virStorageVolDef *vol,
bool withBlockVolFormat,
unsigned int openflags,
unsigned int readflags);
-int virStorageBackendUpdateVolTargetInfoFD(virStorageSourcePtr target,
+int virStorageBackendUpdateVolTargetInfoFD(virStorageSource *target,
int fd,
struct stat *sb);
bool virStorageBackendPoolPathIsStable(const char *path);
-char *virStorageBackendStablePath(virStoragePoolObjPtr pool,
+char *virStorageBackendStablePath(virStoragePoolObj *pool,
const char *devpath,
bool loop);
VIR_STORAGE_VOL_ENCRYPT_DONE,
} virStorageVolEncryptConvertStep;
-virCommandPtr
-virStorageBackendCreateQemuImgCmdFromVol(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
- virStorageVolDefPtr inputvol,
+virCommand *
+virStorageBackendCreateQemuImgCmdFromVol(virStoragePoolObj *pool,
+ virStorageVolDef *vol,
+ virStorageVolDef *inputvol,
unsigned int flags,
const char *create_tool,
const char *secretPath,
const char *inputSecretPath,
virStorageVolEncryptConvertStep convertStep);
-int virStorageBackendSCSIFindLUs(virStoragePoolObjPtr pool,
+int virStorageBackendSCSIFindLUs(virStoragePoolObj *pool,
uint32_t scanhost);
int
unsigned long long size);
char *
-virStorageBackendFileSystemGetPoolSource(virStoragePoolObjPtr pool);
+virStorageBackendFileSystemGetPoolSource(virStoragePoolObj *pool);
-virCommandPtr
+virCommand *
virStorageBackendFileSystemMountCmd(const char *cmdstr,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
const char *src);
-virCommandPtr
+virCommand *
virStorageBackendLogicalChangeCmd(const char *cmdstr,
- virStoragePoolDefPtr def,
+ virStoragePoolDef *def,
bool on);
#define VIR_STORAGE_BACKENDS_MAX 20
-static virStorageFileBackendPtr virStorageFileBackends[VIR_STORAGE_BACKENDS_MAX];
+static virStorageFileBackend *virStorageFileBackends[VIR_STORAGE_BACKENDS_MAX];
static size_t virStorageFileBackendsCount;
#if WITH_STORAGE_DIR || WITH_STORAGE_FS || WITH_STORAGE_GLUSTER
VIR_ONCE_GLOBAL_INIT(virStorageFileBackend);
int
-virStorageFileBackendRegister(virStorageFileBackendPtr backend)
+virStorageFileBackendRegister(virStorageFileBackend *backend)
{
VIR_DEBUG("Registering storage file backend '%s' protocol '%s'",
virStorageTypeToString(backend->type),
virStorageFileBackendForType(int type,
int protocol,
bool required,
- virStorageFileBackendPtr *backend)
+ virStorageFileBackend **backend)
{
size_t i;
/* ------- virStorageFile backends ------------ */
typedef struct _virStorageFileBackend virStorageFileBackend;
-typedef virStorageFileBackend *virStorageFileBackendPtr;
typedef struct _virStorageDriverData virStorageDriverData;
-typedef virStorageDriverData *virStorageDriverDataPtr;
struct _virStorageDriverData {
- virStorageFileBackendPtr backend;
+ virStorageFileBackend *backend;
void *priv;
uid_t uid;
};
typedef int
-(*virStorageFileBackendInit)(virStorageSourcePtr src);
+(*virStorageFileBackendInit)(virStorageSource *src);
typedef void
-(*virStorageFileBackendDeinit)(virStorageSourcePtr src);
+(*virStorageFileBackendDeinit)(virStorageSource *src);
typedef int
-(*virStorageFileBackendCreate)(virStorageSourcePtr src);
+(*virStorageFileBackendCreate)(virStorageSource *src);
typedef int
-(*virStorageFileBackendUnlink)(virStorageSourcePtr src);
+(*virStorageFileBackendUnlink)(virStorageSource *src);
typedef int
-(*virStorageFileBackendStat)(virStorageSourcePtr src,
+(*virStorageFileBackendStat)(virStorageSource *src,
struct stat *st);
typedef ssize_t
-(*virStorageFileBackendRead)(virStorageSourcePtr src,
+(*virStorageFileBackendRead)(virStorageSource *src,
size_t offset,
size_t len,
char **buf);
typedef int
-(*virStorageFileBackendAccess)(virStorageSourcePtr src,
+(*virStorageFileBackendAccess)(virStorageSource *src,
int mode);
typedef int
int virStorageFileBackendForType(int type,
int protocol,
bool required,
- virStorageFileBackendPtr *backend);
+ virStorageFileBackend **backend);
struct _virStorageFileBackend {
int type;
virStorageFileBackendChown storageFileChown;
};
-int virStorageFileBackendRegister(virStorageFileBackendPtr backend);
+int virStorageFileBackendRegister(virStorageFileBackend *backend);
static void
-virStorageFileBackendFileDeinit(virStorageSourcePtr src)
+virStorageFileBackendFileDeinit(virStorageSource *src)
{
VIR_DEBUG("deinitializing FS storage file %p (%s:%s)", src,
virStorageTypeToString(virStorageSourceGetActualType(src)),
static int
-virStorageFileBackendFileInit(virStorageSourcePtr src)
+virStorageFileBackendFileInit(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
VIR_DEBUG("initializing FS storage file %p (%s:%s)[%u:%u]", src,
virStorageTypeToString(virStorageSourceGetActualType(src)),
static int
-virStorageFileBackendFileCreate(virStorageSourcePtr src)
+virStorageFileBackendFileCreate(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
VIR_AUTOCLOSE fd = -1;
if ((fd = virFileOpenAs(src->path, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR,
static int
-virStorageFileBackendFileUnlink(virStorageSourcePtr src)
+virStorageFileBackendFileUnlink(virStorageSource *src)
{
return unlink(src->path);
}
static int
-virStorageFileBackendFileStat(virStorageSourcePtr src,
+virStorageFileBackendFileStat(virStorageSource *src,
struct stat *st)
{
return stat(src->path, st);
static ssize_t
-virStorageFileBackendFileRead(virStorageSourcePtr src,
+virStorageFileBackendFileRead(virStorageSource *src,
size_t offset,
size_t len,
char **buf)
{
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
ssize_t ret = -1;
VIR_AUTOCLOSE fd = -1;
static int
-virStorageFileBackendFileAccess(virStorageSourcePtr src,
+virStorageFileBackendFileAccess(virStorageSource *src,
int mode)
{
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
return virFileAccessibleAs(src->path, mode,
drv->uid, drv->gid);
typedef struct _virStorageFileBackendGlusterPriv virStorageFileBackendGlusterPriv;
-typedef virStorageFileBackendGlusterPriv *virStorageFileBackendGlusterPrivPtr;
-
struct _virStorageFileBackendGlusterPriv {
glfs_t *vol;
};
static void
-virStorageFileBackendGlusterDeinit(virStorageSourcePtr src)
+virStorageFileBackendGlusterDeinit(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
VIR_DEBUG("deinitializing gluster storage file %p (gluster://%s:%u/%s%s)",
src, src->hosts->name, src->hosts->port, src->volume, src->path);
}
static int
-virStorageFileBackendGlusterInitServer(virStorageFileBackendGlusterPrivPtr priv,
- virStorageNetHostDefPtr host)
+virStorageFileBackendGlusterInitServer(virStorageFileBackendGlusterPriv *priv,
+ virStorageNetHostDef *host)
{
const char *transport = virStorageNetHostTransportTypeToString(host->transport);
const char *hoststr = NULL;
static int
-virStorageFileBackendGlusterInit(virStorageSourcePtr src)
+virStorageFileBackendGlusterInit(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = NULL;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = NULL;
size_t i;
if (!src->volume) {
static int
-virStorageFileBackendGlusterCreate(virStorageSourcePtr src)
+virStorageFileBackendGlusterCreate(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
glfs_fd_t *fd = NULL;
if (!(fd = glfs_creat(priv->vol, src->path,
static int
-virStorageFileBackendGlusterUnlink(virStorageSourcePtr src)
+virStorageFileBackendGlusterUnlink(virStorageSource *src)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
return glfs_unlink(priv->vol, src->path);
}
static int
-virStorageFileBackendGlusterStat(virStorageSourcePtr src,
+virStorageFileBackendGlusterStat(virStorageSource *src,
struct stat *st)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
return glfs_stat(priv->vol, src->path, st);
}
static ssize_t
-virStorageFileBackendGlusterRead(virStorageSourcePtr src,
+virStorageFileBackendGlusterRead(virStorageSource *src,
size_t offset,
size_t len,
char **buf)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
glfs_fd_t *fd = NULL;
ssize_t ret = -1;
char *s;
static int
-virStorageFileBackendGlusterAccess(virStorageSourcePtr src,
+virStorageFileBackendGlusterAccess(virStorageSource *src,
int mode)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
return glfs_access(priv->vol, src->path, mode);
}
uid_t uid,
gid_t gid)
{
- virStorageDriverDataPtr drv = src->drv;
- virStorageFileBackendGlusterPrivPtr priv = drv->priv;
+ virStorageDriverData *drv = src->drv;
+ virStorageFileBackendGlusterPriv *priv = drv->priv;
return glfs_chown(priv->vol, src->path, uid, gid);
}
const struct FileEncryptionInfo *cryptInfo; /* Encryption info */
int (*getBackingStore)(char **res, int *format,
const char *buf, size_t buf_size);
- int (*getFeatures)(virBitmapPtr *features, int format,
+ int (*getFeatures)(virBitmap **features, int format,
char *buf, ssize_t len);
};
const char *, size_t);
static int qcowXGetBackingStore(char **, int *,
const char *, size_t);
-static int qcow2GetFeatures(virBitmapPtr *features, int format,
+static int qcow2GetFeatures(virBitmap **features, int format,
char *buf, ssize_t len);
static int vmdk4GetBackingStore(char **, int *,
const char *, size_t);
static int
-qcow2GetFeatures(virBitmapPtr *features,
+qcow2GetFeatures(virBitmap **features,
int format,
char *buf,
ssize_t len)
{
int version = -1;
- virBitmapPtr feat = NULL;
+ virBitmap *feat = NULL;
uint64_t bits;
size_t i;
* clean up any existing allocated memory which would be overwritten.
*/
int
-virStorageFileProbeGetMetadata(virStorageSourcePtr meta,
+virStorageFileProbeGetMetadata(virStorageSource *meta,
char *buf,
size_t len)
{
#define VIR_STORAGE_MAX_HEADER 0x8200
int
-virStorageFileProbeGetMetadata(virStorageSourcePtr meta,
+virStorageFileProbeGetMetadata(virStorageSource *meta,
char *buf,
size_t len);
}
-static virStorageSourcePtr
+static virStorageSource *
virStorageSourceMetadataNew(const char *path,
int format)
{
*
* Caller MUST free the result after use via virObjectUnref.
*/
-virStorageSourcePtr
+virStorageSource *
virStorageSourceGetMetadataFromBuf(const char *path,
char *buf,
size_t len,
int format)
{
- virStorageSourcePtr ret = NULL;
+ virStorageSource *ret = NULL;
if (!(ret = virStorageSourceMetadataNew(path, format)))
return NULL;
*
* Caller MUST free the result after use via virObjectUnref.
*/
-virStorageSourcePtr
+virStorageSource *
virStorageSourceGetMetadataFromFD(const char *path,
int fd,
int format)
* - "/path/to/file": Literal path is matched. Symlink resolution is attempted
* if the filename doesn't string-match with the path.
*/
-virStorageSourcePtr
-virStorageSourceChainLookup(virStorageSourcePtr chain,
- virStorageSourcePtr startFrom,
+virStorageSource *
+virStorageSourceChainLookup(virStorageSource *chain,
+ virStorageSource *startFrom,
const char *name,
const char *diskTarget,
- virStorageSourcePtr *parent)
+ virStorageSource **parent)
{
- virStorageSourcePtr prev;
+ virStorageSource *prev;
const char *start = chain->path;
bool nameIsFile = virStorageSourceBackinStoreStringIsFile(name);
g_autofree char *target = NULL;
}
-static virStorageSourcePtr
-virStorageSourceNewFromBackingRelative(virStorageSourcePtr parent,
+static virStorageSource *
+virStorageSourceNewFromBackingRelative(virStorageSource *parent,
const char *rel)
{
g_autofree char *dirname = NULL;
*/
int
virStorageSourceNewFromBackingAbsolute(const char *path,
- virStorageSourcePtr *src)
+ virStorageSource **src)
{
const char *json;
const char *dirpath;
* error is reported.
*/
static int
-virStorageSourceNewFromChild(virStorageSourcePtr parent,
+virStorageSourceNewFromChild(virStorageSource *parent,
const char *parentRaw,
- virStorageSourcePtr *child)
+ virStorageSource **child)
{
struct stat st;
g_autoptr(virStorageSource) def = NULL;
int
-virStorageSourceNewFromBacking(virStorageSourcePtr parent,
- virStorageSourcePtr *backing)
+virStorageSourceNewFromBacking(virStorageSource *parent,
+ virStorageSource **backing)
{
int rc;
* Returns 0 on success, -1 on error. No libvirt errors are reported.
*/
int
-virStorageSourceUpdatePhysicalSize(virStorageSourcePtr src,
+virStorageSourceUpdatePhysicalSize(virStorageSource *src,
int fd,
struct stat const *sb)
{
* Returns 0 on success, -1 on error.
*/
int
-virStorageSourceUpdateBackingSizes(virStorageSourcePtr src,
+virStorageSourceUpdateBackingSizes(virStorageSource *src,
int fd,
struct stat const *sb)
{
* Returns 0 on success, -1 on error.
*/
int
-virStorageSourceUpdateCapacity(virStorageSourcePtr src,
+virStorageSourceUpdateCapacity(virStorageSource *src,
char *buf,
ssize_t len)
{
* Returns 0 on success; 1 if backing chain isn't relative and -1 on error.
*/
int
-virStorageSourceGetRelativeBackingPath(virStorageSourcePtr top,
- virStorageSourcePtr base,
+virStorageSourceGetRelativeBackingPath(virStorageSource *top,
+ virStorageSource *base,
char **relpath)
{
- virStorageSourcePtr next;
+ virStorageSource *next;
g_autofree char *tmp = NULL;
g_autofree char *path = NULL;
* path between two images.
*/
int
-virStorageSourceFetchRelativeBackingPath(virStorageSourcePtr src,
+virStorageSourceFetchRelativeBackingPath(virStorageSource *src,
char **relPath)
{
ssize_t headerLen;
*/
static int
virStorageSourceGetBackendForSupportCheck(const virStorageSource *src,
- virStorageFileBackendPtr *backend)
+ virStorageFileBackend **backend)
{
int actualType;
}
if (src->drv) {
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
*backend = drv->backend;
return 1;
}
int
virStorageSourceSupportsBackingChainTraversal(const virStorageSource *src)
{
- virStorageFileBackendPtr backend;
+ virStorageFileBackend *backend;
int rv;
if ((rv = virStorageSourceGetBackendForSupportCheck(src, &backend)) < 1)
int
virStorageSourceSupportsSecurityDriver(const virStorageSource *src)
{
- virStorageFileBackendPtr backend;
+ virStorageFileBackend *backend;
int rv;
if ((rv = virStorageSourceGetBackendForSupportCheck(src, &backend)) < 1)
int
virStorageSourceSupportsAccess(const virStorageSource *src)
{
- virStorageFileBackendPtr backend;
+ virStorageFileBackend *backend;
int rv;
if ((rv = virStorageSourceGetBackendForSupportCheck(src, &backend)) < 1)
int
virStorageSourceSupportsCreate(const virStorageSource *src)
{
- virStorageFileBackendPtr backend;
+ virStorageFileBackend *backend;
int rv;
if ((rv = virStorageSourceGetBackendForSupportCheck(src, &backend)) < 1)
void
-virStorageSourceDeinit(virStorageSourcePtr src)
+virStorageSourceDeinit(virStorageSource *src)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
if (!virStorageSourceIsInitialized(src))
return;
* initialization failed. Libvirt error is reported.
*/
int
-virStorageSourceInitAs(virStorageSourcePtr src,
+virStorageSourceInitAs(virStorageSource *src,
uid_t uid, gid_t gid)
{
int actualType = virStorageSourceGetActualType(src);
- virStorageDriverDataPtr drv = g_new0(virStorageDriverData, 1);
+ virStorageDriverData *drv = g_new0(virStorageDriverData, 1);
src->drv = drv;
* current user.
*/
int
-virStorageSourceInit(virStorageSourcePtr src)
+virStorageSourceInit(virStorageSource *src)
{
return virStorageSourceInitAs(src, -1, -1);
}
* -1 on other failure. Errno is set in case of failure.
*/
int
-virStorageSourceCreate(virStorageSourcePtr src)
+virStorageSourceCreate(virStorageSource *src)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
int ret;
if (!virStorageSourceIsInitialized(src)) {
* -1 on other failure. Errno is set in case of failure.
*/
int
-virStorageSourceUnlink(virStorageSourcePtr src)
+virStorageSourceUnlink(virStorageSource *src)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
int ret;
if (!virStorageSourceIsInitialized(src)) {
* -1 on other failure. Errno is set in case of failure.
*/
int
-virStorageSourceStat(virStorageSourcePtr src,
+virStorageSourceStat(virStorageSource *src,
struct stat *st)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
int ret;
if (!virStorageSourceIsInitialized(src)) {
* Libvirt error is reported on failure.
*/
ssize_t
-virStorageSourceRead(virStorageSourcePtr src,
+virStorageSourceRead(virStorageSource *src,
size_t offset,
size_t len,
char **buf)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
ssize_t ret;
if (!virStorageSourceIsInitialized(src)) {
* by libvirt storage backend.
*/
int
-virStorageSourceAccess(virStorageSourcePtr src,
+virStorageSourceAccess(virStorageSource *src,
int mode)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
if (!virStorageSourceIsInitialized(src)) {
errno = ENOSYS;
uid_t uid,
gid_t gid)
{
- virStorageDriverDataPtr drv = NULL;
+ virStorageDriverData *drv = NULL;
if (!virStorageSourceIsInitialized(src)) {
errno = ENOSYS;
*/
void
virStorageSourceReportBrokenChain(int errcode,
- virStorageSourcePtr src,
- virStorageSourcePtr parent)
+ virStorageSource *src,
+ virStorageSource *parent)
{
if (src->drv) {
- virStorageDriverDataPtr drv = src->drv;
+ virStorageDriverData *drv = src->drv;
unsigned int access_user = drv->uid;
unsigned int access_group = drv->gid;
static int
-virStorageSourceGetMetadataRecurseReadHeader(virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virStorageSourceGetMetadataRecurseReadHeader(virStorageSource *src,
+ virStorageSource *parent,
uid_t uid,
gid_t gid,
char **buf,
/* Recursive workhorse for virStorageSourceGetMetadata. */
static int
-virStorageSourceGetMetadataRecurse(virStorageSourcePtr src,
- virStorageSourcePtr parent,
+virStorageSourceGetMetadataRecurse(virStorageSource *src,
+ virStorageSource *parent,
uid_t uid, gid_t gid,
bool report_broken,
size_t max_depth,
* Caller MUST free result after use via virObjectUnref.
*/
int
-virStorageSourceGetMetadata(virStorageSourcePtr src,
+virStorageSourceGetMetadata(virStorageSource *src,
uid_t uid, gid_t gid,
size_t max_depth,
bool report_broken)
# define DEV_BSIZE 512
#endif
-virStorageSourcePtr
+virStorageSource *
virStorageSourceGetMetadataFromFD(const char *path,
int fd,
int format);
-virStorageSourcePtr
+virStorageSource *
virStorageSourceGetMetadataFromBuf(const char *path,
char *buf,
size_t len,
int format)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-virStorageSourcePtr
-virStorageSourceChainLookup(virStorageSourcePtr chain,
- virStorageSourcePtr startFrom,
+virStorageSource *
+virStorageSourceChainLookup(virStorageSource *chain,
+ virStorageSource *startFrom,
const char *name,
const char *diskTarget,
- virStorageSourcePtr *parent)
+ virStorageSource **parent)
ATTRIBUTE_NONNULL(1);
int
-virStorageSourceUpdatePhysicalSize(virStorageSourcePtr src,
+virStorageSourceUpdatePhysicalSize(virStorageSource *src,
int fd,
struct stat const *sb);
int
-virStorageSourceUpdateBackingSizes(virStorageSourcePtr src,
+virStorageSourceUpdateBackingSizes(virStorageSource *src,
int fd,
struct stat const *sb);
int
-virStorageSourceUpdateCapacity(virStorageSourcePtr src,
+virStorageSourceUpdateCapacity(virStorageSource *src,
char *buf,
ssize_t len);
int
-virStorageSourceNewFromBacking(virStorageSourcePtr parent,
- virStorageSourcePtr *backing);
+virStorageSourceNewFromBacking(virStorageSource *parent,
+ virStorageSource **backing);
int
virStorageSourceParseRBDColonString(const char *rbdstr,
- virStorageSourcePtr src)
+ virStorageSource *src)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
-virStorageSourceGetRelativeBackingPath(virStorageSourcePtr top,
- virStorageSourcePtr base,
+virStorageSourceGetRelativeBackingPath(virStorageSource *top,
+ virStorageSource *base,
char **relpath)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int
virStorageSourceNewFromBackingAbsolute(const char *path,
- virStorageSourcePtr *src);
+ virStorageSource **src);
int
-virStorageSourceInit(virStorageSourcePtr src);
+virStorageSourceInit(virStorageSource *src);
int
-virStorageSourceInitAs(virStorageSourcePtr src,
+virStorageSourceInitAs(virStorageSource *src,
uid_t uid, gid_t gid);
void
-virStorageSourceDeinit(virStorageSourcePtr src);
+virStorageSourceDeinit(virStorageSource *src);
int
-virStorageSourceCreate(virStorageSourcePtr src);
+virStorageSourceCreate(virStorageSource *src);
int
-virStorageSourceUnlink(virStorageSourcePtr src);
+virStorageSourceUnlink(virStorageSource *src);
int
-virStorageSourceStat(virStorageSourcePtr src,
+virStorageSourceStat(virStorageSource *src,
struct stat *st);
ssize_t
-virStorageSourceRead(virStorageSourcePtr src,
+virStorageSourceRead(virStorageSource *src,
size_t offset,
size_t len,
char **buf);
int
-virStorageSourceAccess(virStorageSourcePtr src,
+virStorageSourceAccess(virStorageSource *src,
int mode);
int
virStorageSourceSupportsBackingChainTraversal(const virStorageSource *src);
int
-virStorageSourceGetMetadata(virStorageSourcePtr src,
+virStorageSourceGetMetadata(virStorageSource *src,
uid_t uid, gid_t gid,
size_t max_depth,
bool report_broken)
ATTRIBUTE_NONNULL(1);
int
-virStorageSourceFetchRelativeBackingPath(virStorageSourcePtr src,
+virStorageSourceFetchRelativeBackingPath(virStorageSource *src,
char **relPath)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void
virStorageSourceReportBrokenChain(int errcode,
- virStorageSourcePtr src,
- virStorageSourcePtr parent);
+ virStorageSource *src,
+ virStorageSource *parent);
int
-virStorageSourceParseBackingURI(virStorageSourcePtr src,
+virStorageSourceParseBackingURI(virStorageSource *src,
const char *uristr)
{
g_autoptr(virURI) uri = NULL;
static int
-virStorageSourceRBDAddHost(virStorageSourcePtr src,
+virStorageSourceRBDAddHost(virStorageSource *src,
char *hostport)
{
char *port;
int
virStorageSourceParseRBDColonString(const char *rbdstr,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
char *p, *e, *next;
g_autofree char *options = NULL;
static int
virStorageSourceParseNBDColonString(const char *nbdstr,
- virStorageSourcePtr src)
+ virStorageSource *src)
{
g_autofree char *nbd = g_strdup(nbdstr);
char *export_name;
int
-virStorageSourceParseBackingColon(virStorageSourcePtr src,
+virStorageSourceParseBackingColon(virStorageSource *src,
const char *path)
{
const char *p;
static int
-virStorageSourceParseBackingJSONInternal(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONInternal(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr,
bool allowformat);
static int
-virStorageSourceParseBackingJSONPath(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONPath(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int type)
{
static int
-virStorageSourceParseBackingJSONUriStr(virStorageSourcePtr src,
+virStorageSourceParseBackingJSONUriStr(virStorageSource *src,
const char *uri,
int protocol)
{
static int
-virStorageSourceParseBackingJSONUriCookies(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONUriCookies(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr)
{
const char *cookiestr;
return -1;
src->ncookies = g_strv_length(cookies);
- src->cookies = g_new0(virStorageNetCookieDefPtr, src->ncookies);
+ src->cookies = g_new0(virStorageNetCookieDef *, src->ncookies);
for (i = 0; i < src->ncookies; i++) {
char *cookiename = cookies[i];
static int
-virStorageSourceParseBackingJSONUri(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONUri(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr,
int protocol)
{
static int
-virStorageSourceParseBackingJSONInetSocketAddress(virStorageNetHostDefPtr host,
- virJSONValuePtr json)
+virStorageSourceParseBackingJSONInetSocketAddress(virStorageNetHostDef *host,
+ virJSONValue *json)
{
const char *hostname;
const char *port;
static int
-virStorageSourceParseBackingJSONSocketAddress(virStorageNetHostDefPtr host,
- virJSONValuePtr json)
+virStorageSourceParseBackingJSONSocketAddress(virStorageNetHostDef *host,
+ virJSONValue *json)
{
const char *type;
const char *socket;
static int
-virStorageSourceParseBackingJSONGluster(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONGluster(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *uri = virJSONValueObjectGetString(json, "filename");
const char *volume = virJSONValueObjectGetString(json, "volume");
const char *path = virJSONValueObjectGetString(json, "path");
- virJSONValuePtr server = virJSONValueObjectGetArray(json, "server");
+ virJSONValue *server = virJSONValueObjectGetArray(json, "server");
size_t nservers;
size_t i;
static int
-virStorageSourceParseBackingJSONiSCSI(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONiSCSI(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
static int
-virStorageSourceParseBackingJSONNbd(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONNbd(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *host = virJSONValueObjectGetString(json, "host");
const char *port = virJSONValueObjectGetString(json, "port");
const char *export = virJSONValueObjectGetString(json, "export");
- virJSONValuePtr server = virJSONValueObjectGetObject(json, "server");
+ virJSONValue *server = virJSONValueObjectGetObject(json, "server");
if (!path && !host && !server) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
static int
-virStorageSourceParseBackingJSONSheepdog(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONSheepdog(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *filename;
const char *vdi = virJSONValueObjectGetString(json, "vdi");
- virJSONValuePtr server = virJSONValueObjectGetObject(json, "server");
+ virJSONValue *server = virJSONValueObjectGetObject(json, "server");
/* legacy URI based syntax passed via 'filename' option */
if ((filename = virJSONValueObjectGetString(json, "filename"))) {
static int
-virStorageSourceParseBackingJSONSSH(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONSSH(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *port = virJSONValueObjectGetString(json, "port");
const char *user = virJSONValueObjectGetString(json, "user");
const char *host_key_check = virJSONValueObjectGetString(json, "host_key_check");
- virJSONValuePtr server = virJSONValueObjectGetObject(json, "server");
+ virJSONValue *server = virJSONValueObjectGetObject(json, "server");
if (!(host || server) || !path) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
static int
-virStorageSourceParseBackingJSONRBD(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONRBD(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *image = virJSONValueObjectGetString(json, "image");
const char *conf = virJSONValueObjectGetString(json, "conf");
const char *snapshot = virJSONValueObjectGetString(json, "snapshot");
- virJSONValuePtr servers = virJSONValueObjectGetArray(json, "server");
+ virJSONValue *servers = virJSONValueObjectGetArray(json, "server");
size_t nservers;
size_t i;
}
static int
-virStorageSourceParseBackingJSONRaw(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONRaw(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr,
int opaque G_GNUC_UNUSED)
{
bool has_offset = virJSONValueObjectHasKey(json, "offset");
bool has_size = virJSONValueObjectHasKey(json, "size");
- virJSONValuePtr file;
+ virJSONValue *file;
if (has_offset || has_size) {
src->sliceStorage = g_new0(virStorageSourceSlice, 1);
static int
-virStorageSourceParseBackingJSONVxHS(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONVxHS(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
const char *vdisk_id = virJSONValueObjectGetString(json, "vdisk-id");
- virJSONValuePtr server = virJSONValueObjectGetObject(json, "server");
+ virJSONValue *server = virJSONValueObjectGetObject(json, "server");
if (!vdisk_id || !server) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
static int
-virStorageSourceParseBackingJSONNFS(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONNFS(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
- virJSONValuePtr server = virJSONValueObjectGetObject(json, "server");
+ virJSONValue *server = virJSONValueObjectGetObject(json, "server");
int uidStore = -1;
int gidStore = -1;
int gotUID = virJSONValueObjectGetNumberInt(json, "user", &uidStore);
static int
-virStorageSourceParseBackingJSONNVMe(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONNVMe(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr G_GNUC_UNUSED,
int opaque G_GNUC_UNUSED)
{
* can't be converted to libvirt's configuration (e.g. inline authentication
* credentials are present).
*/
- int (*func)(virStorageSourcePtr src, virJSONValuePtr json, const char *jsonstr, int opaque);
+ int (*func)(virStorageSource *src, virJSONValue *json, const char *jsonstr, int opaque);
int opaque;
};
static int
-virStorageSourceParseBackingJSONInternal(virStorageSourcePtr src,
- virJSONValuePtr json,
+virStorageSourceParseBackingJSONInternal(virStorageSource *src,
+ virJSONValue *json,
const char *jsonstr,
bool allowformat)
{
int
-virStorageSourceParseBackingJSON(virStorageSourcePtr src,
+virStorageSourceParseBackingJSON(virStorageSource *src,
const char *json)
{
g_autoptr(virJSONValue) root = NULL;
g_autoptr(virJSONValue) deflattened = NULL;
- virJSONValuePtr file = NULL;
+ virJSONValue *file = NULL;
if (!(root = virJSONValueFromString(json)))
return -1;
#include "storage_source_conf.h"
int
-virStorageSourceParseBackingURI(virStorageSourcePtr src,
+virStorageSourceParseBackingURI(virStorageSource *src,
const char *uristr);
int
virStorageSourceParseRBDColonString(const char *rbdstr,
- virStorageSourcePtr src);
+ virStorageSource *src);
int
-virStorageSourceParseBackingColon(virStorageSourcePtr src,
+virStorageSourceParseBackingColon(virStorageSource *src,
const char *path);
int
-virStorageSourceParseBackingJSON(virStorageSourcePtr src,
+virStorageSourceParseBackingJSON(virStorageSource *src,
const char *json);
virCapsHostNUMACellCPU cpus[MAX_CPUS];
};
typedef struct _testCell testCell;
-typedef struct _testCell *testCellPtr;
struct _testAuth {
char *username;
char *password;
};
typedef struct _testAuth testAuth;
-typedef struct _testAuth *testAuthPtr;
struct _testDriver {
virObjectLockable parent;
virNodeInfo nodeInfo;
- virInterfaceObjListPtr ifaces;
+ virInterfaceObjList *ifaces;
bool transaction_running;
- virInterfaceObjListPtr backupIfaces;
- virStoragePoolObjListPtr pools;
- virNodeDeviceObjListPtr devs;
+ virInterfaceObjList *backupIfaces;
+ virStoragePoolObjList *pools;
+ virNodeDeviceObjList *devs;
int numCells;
testCell *cells;
size_t numAuths;
- testAuthPtr auths;
+ struct _testAuth *auths;
/* g_atomic access only */
volatile int nextDomID;
/* immutable pointer, immutable object after being initialized with
* testBuildCapabilities */
- virCapsPtr caps;
+ virCaps *caps;
/* immutable pointer, immutable object */
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
/* immutable pointer, self-locking APIs */
- virDomainObjListPtr domains;
- virNetworkObjListPtr networks;
- virObjectEventStatePtr eventState;
+ virDomainObjList *domains;
+ virNetworkObjList *networks;
+ virObjectEventState *eventState;
};
typedef struct _testDriver testDriver;
-typedef testDriver *testDriverPtr;
-static testDriverPtr defaultPrivconn;
+static testDriver *defaultPrivconn;
static virMutex defaultLock = VIR_MUTEX_INITIALIZER;
-static virClassPtr testDriverClass;
+static virClass *testDriverClass;
static __thread bool testDriverDisposed;
static void testDriverDispose(void *obj);
static int testDriverOnceInit(void)
static void
testDriverDispose(void *obj)
{
- testDriverPtr driver = obj;
+ testDriver *driver = obj;
size_t i;
virObjectUnref(driver->caps);
}
typedef struct _testDomainNamespaceDef testDomainNamespaceDef;
-typedef testDomainNamespaceDef *testDomainNamespaceDefPtr;
struct _testDomainNamespaceDef {
int runstate;
bool transient;
static void
testDomainDefNamespaceFree(void *data)
{
- testDomainNamespaceDefPtr nsdata = data;
+ testDomainNamespaceDef *nsdata = data;
size_t i;
if (!nsdata)
testDomainDefNamespaceParse(xmlXPathContextPtr ctxt,
void **data)
{
- testDomainNamespaceDefPtr nsdata = NULL;
+ testDomainNamespaceDef *nsdata = NULL;
int tmp, n;
size_t i;
unsigned int tmpuint;
return -1;
}
-static virCapsPtr
+static virCaps *
testBuildCapabilities(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
- virCapsPtr caps;
- virCapsGuestPtr guest;
+ testDriver *privconn = conn->privateData;
+ virCaps *caps;
+ virCapsGuest *guest;
int guest_types[] = { VIR_DOMAIN_OSTYPE_HVM,
VIR_DOMAIN_OSTYPE_XEN };
size_t i, j;
caps->host.numa = virCapabilitiesHostNUMANew();
for (i = 0; i < privconn->numCells; i++) {
- virCapsHostNUMACellCPUPtr cpu_cells;
- virCapsHostNUMACellPageInfoPtr pages;
+ virCapsHostNUMACellCPU *cpu_cells;
+ virCapsHostNUMACellPageInfo *pages;
size_t nPages = caps->host.nPagesSize - 1;
cpu_cells = g_new0(virCapsHostNUMACellCPU, privconn->cells[i].numCpus);
typedef struct _testDomainObjPrivate testDomainObjPrivate;
-typedef testDomainObjPrivate *testDomainObjPrivatePtr;
struct _testDomainObjPrivate {
- testDriverPtr driver;
+ testDriver *driver;
bool frozen[2]; /* used by file system related calls */
static void *
testDomainObjPrivateAlloc(void *opaque)
{
- testDomainObjPrivatePtr priv;
+ testDomainObjPrivate *priv;
priv = g_new0(testDomainObjPrivate, 1);
static int
-testDomainDevicesDefPostParse(virDomainDeviceDefPtr dev G_GNUC_UNUSED,
+testDomainDevicesDefPostParse(virDomainDeviceDef *dev G_GNUC_UNUSED,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
static void
testDomainObjPrivateFree(void *data)
{
- testDomainObjPrivatePtr priv = data;
+ testDomainObjPrivate *priv = data;
g_free(priv);
}
-static testDriverPtr
+static testDriver *
testDriverNew(void)
{
virXMLNamespace ns = {
.alloc = testDomainObjPrivateAlloc,
.free = testDomainObjPrivateFree,
};
- testDriverPtr ret;
+ testDriver *ret;
if (testDriverInitialize() < 0)
return NULL;
static const unsigned long long defaultPoolCap = (100 * 1024 * 1024 * 1024ull);
static const unsigned long long defaultPoolAlloc;
-static int testStoragePoolObjSetDefaults(virStoragePoolObjPtr obj);
+static int testStoragePoolObjSetDefaults(virStoragePoolObj *obj);
static int testNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info);
-static virNetworkObjPtr testNetworkObjFindByName(testDriverPtr privconn, const char *name);
+static virNetworkObj *testNetworkObjFindByName(testDriver *privconn, const char *name);
-static virDomainObjPtr
+static virDomainObj *
testDomObjFromDomain(virDomainPtr domain)
{
- virDomainObjPtr vm;
- testDriverPtr driver = domain->conn->privateData;
+ virDomainObj *vm;
+ testDriver *driver = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
}
static char *
-testDomainGenerateIfname(virDomainDefPtr domdef)
+testDomainGenerateIfname(virDomainDef *domdef)
{
int maxif = 1024;
int ifctr;
for (ifctr = 0; ifctr < maxif; ++ifctr) {
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
char *ifname;
ifname = g_strdup_printf("testnet%d", ifctr);
}
static int
-testDomainGenerateIfnames(virDomainDefPtr domdef)
+testDomainGenerateIfnames(virDomainDef *domdef)
{
size_t i = 0;
static void
testDomainShutdownState(virDomainPtr domain,
- virDomainObjPtr privdom,
+ virDomainObj *privdom,
virDomainShutoffReason reason)
{
virDomainObjRemoveTransientDef(privdom);
/* Set up domain runtime state */
static int
-testDomainStartState(testDriverPtr privconn,
- virDomainObjPtr dom,
+testDomainStartState(testDriver *privconn,
+ virDomainObj *dom,
virDomainRunningReason reason)
{
int ret = -1;
}
static int
-testParseDomainSnapshots(testDriverPtr privconn,
- virDomainObjPtr domobj,
+testParseDomainSnapshots(testDriver *privconn,
+ virDomainObj *domobj,
const char *file,
xmlXPathContextPtr ctxt)
{
size_t i;
- testDomainNamespaceDefPtr nsdata = domobj->def->namespaceData;
+ testDomainNamespaceDef *nsdata = domobj->def->namespaceData;
xmlNodePtr *nodes = nsdata->snap_nodes;
bool cur;
for (i = 0; i < nsdata->num_snap_nodes; i++) {
- virDomainMomentObjPtr snap;
- virDomainSnapshotDefPtr def;
+ virDomainMomentObj *snap;
+ virDomainSnapshotDef *def;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file,
"domainsnapshot");
if (!node)
}
static int
-testParseDomains(testDriverPtr privconn,
+testParseDomains(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
int num, ret = -1;
size_t i;
- virDomainObjPtr obj = NULL;
+ virDomainObj *obj = NULL;
g_autofree xmlNodePtr *nodes = NULL;
num = virXPathNodeSet("/node/domain", ctxt, &nodes);
return -1;
for (i = 0; i < num; i++) {
- virDomainDefPtr def;
- testDomainNamespaceDefPtr nsdata;
+ virDomainDef *def;
+ testDomainNamespaceDef *nsdata;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file, "domain");
if (!node)
goto error;
static int
-testParseNetworks(testDriverPtr privconn,
+testParseNetworks(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
int num;
size_t i;
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
g_autofree xmlNodePtr *nodes = NULL;
num = virXPathNodeSet("/node/network", ctxt, &nodes);
return -1;
for (i = 0; i < num; i++) {
- virNetworkDefPtr def;
+ virNetworkDef *def;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file, "network");
if (!node)
return -1;
static int
-testParseInterfaces(testDriverPtr privconn,
+testParseInterfaces(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
int num;
size_t i;
- virInterfaceObjPtr obj;
+ virInterfaceObj *obj;
g_autofree xmlNodePtr *nodes = NULL;
num = virXPathNodeSet("/node/interface", ctxt, &nodes);
return -1;
for (i = 0; i < num; i++) {
- virInterfaceDefPtr def;
+ virInterfaceDef *def;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file,
"interface");
if (!node)
static int
testOpenVolumesForPool(const char *file,
xmlXPathContextPtr ctxt,
- virStoragePoolObjPtr obj,
+ virStoragePoolObj *obj,
int objidx)
{
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
size_t i;
int num;
g_autofree char *vol_xpath = NULL;
static int
-testParseStorage(testDriverPtr privconn,
+testParseStorage(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
int num;
size_t i;
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
g_autofree xmlNodePtr *nodes = NULL;
num = virXPathNodeSet("/node/pool", ctxt, &nodes);
return -1;
for (i = 0; i < num; i++) {
- virStoragePoolDefPtr def;
+ virStoragePoolDef *def;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file,
"pool");
if (!node)
static int
-testParseNodedevs(testDriverPtr privconn,
+testParseNodedevs(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
int num;
size_t i;
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
g_autofree xmlNodePtr *nodes = NULL;
num = virXPathNodeSet("/node/device", ctxt, &nodes);
return -1;
for (i = 0; i < num; i++) {
- virNodeDeviceDefPtr def;
+ virNodeDeviceDef *def;
xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file,
"nodedev");
if (!node)
}
static int
-testParseAuthUsers(testDriverPtr privconn,
+testParseAuthUsers(testDriver *privconn,
xmlXPathContextPtr ctxt)
{
int num;
}
static int
-testOpenParse(testDriverPtr privconn,
+testOpenParse(testDriver *privconn,
const char *file,
xmlXPathContextPtr ctxt)
{
{
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
- testDriverPtr privconn;
+ testDriver *privconn;
if (!(privconn = testDriverNew()))
return VIR_DRV_OPEN_ERROR;
testOpenDefault(virConnectPtr conn)
{
int ret = VIR_DRV_OPEN_ERROR;
- testDriverPtr privconn = NULL;
+ testDriver *privconn = NULL;
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
size_t i;
privconn->cells[i].freeMem = (i + 1) * 1024 * 1024;
}
for (i = 0; i < 16; i++) {
- virBitmapPtr siblings = virBitmapNew(16);
+ virBitmap *siblings = virBitmapNew(16);
ignore_value(virBitmapSetBit(siblings, i));
privconn->cells[i / 8].cpus[(i % 8)].id = i;
privconn->cells[i / 8].cpus[(i % 8)].socket_id = i / 8;
testConnectAuthenticate(virConnectPtr conn,
virConnectAuthPtr auth)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ret = -1;
ssize_t i;
g_autofree char *username = NULL;
static void
-testDriverCloseInternal(testDriverPtr driver)
+testDriverCloseInternal(testDriver *driver)
{
virMutexLock(&defaultLock);
testDriverDisposed = false;
static virDrvOpenStatus
testConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
int ret;
unsigned int ncpus,
unsigned int flags)
{
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, NULL);
static int testNodeGetInfo(virConnectPtr conn,
virNodeInfoPtr info)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virObjectLock(privconn);
memcpy(info, &privconn->nodeInfo, sizeof(virNodeInfo));
virObjectUnlock(privconn);
static char *testConnectGetCapabilities(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
char *xml;
virObjectLock(privconn);
xml = virCapabilitiesFormatXML(privconn->caps);
static int testConnectNumOfDomains(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int count;
virObjectLock(privconn);
static int testDomainIsActive(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret;
if (!(obj = testDomObjFromDomain(dom)))
static int testDomainIsPersistent(virDomainPtr dom)
{
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret;
if (!(obj = testDomObjFromDomain(dom)))
testDomainCreateXML(virConnectPtr conn, const char *xml,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainDefPtr def;
- virDomainObjPtr dom = NULL;
- virObjectEventPtr event = NULL;
+ virDomainDef *def;
+ virDomainObj *dom = NULL;
+ virObjectEvent *event = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_START_VALIDATE, NULL);
static virDomainPtr testDomainLookupByID(virConnectPtr conn,
int id)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
if (!(dom = virDomainObjListFindByID(privconn->domains, id))) {
virReportError(VIR_ERR_NO_DOMAIN, NULL);
static virDomainPtr testDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
if (!(dom = virDomainObjListFindByUUID(privconn->domains, uuid))) {
virReportError(VIR_ERR_NO_DOMAIN, NULL);
static virDomainPtr testDomainLookupByName(virConnectPtr conn,
const char *name)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
if (!(dom = virDomainObjListFindByName(privconn->domains, name))) {
virReportError(VIR_ERR_NO_DOMAIN, NULL);
int *ids,
int maxids)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virDomainObjListGetActiveIDs(privconn->domains, ids, maxids,
NULL, NULL);
static int testDomainDestroyFlags(virDomainPtr domain,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_DESTROY_GRACEFUL, -1);
static int testDomainResume(virDomainPtr domain)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
if (!(privdom = testDomObjFromDomain(domain)))
static int testDomainSuspend(virDomainPtr domain)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
int state;
static void
-testDomainActionSetState(virDomainObjPtr dom,
+testDomainActionSetState(virDomainObj *dom,
int lifecycle_type)
{
switch (lifecycle_type) {
static int testDomainShutdownFlags(virDomainPtr domain,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int testDomainReboot(virDomainPtr domain,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_REBOOT_DEFAULT |
testDomainReset(virDomainPtr dom,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
unsigned int flags)
{
char *ret = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virCheckFlags(0, NULL);
static int testDomainGetInfo(virDomainPtr domain,
virDomainInfoPtr info)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
if (!(privdom = testDomObjFromDomain(domain)))
return -1;
int *reason,
unsigned int flags)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
virCheckFlags(0, -1);
unsigned int *nseconds,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- testDomainObjPrivatePtr priv;
+ virDomainObj *vm = NULL;
+ testDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(0, -1);
unsigned int nseconds,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- testDomainObjPrivatePtr priv;
+ virDomainObj *vm = NULL;
+ testDomainObjPrivate *priv;
int ret = -1;
virCheckFlags(VIR_DOMAIN_TIME_SYNC, ret);
* Returns true on success, else false.
*/
static bool
-testDomainSaveImageWrite(testDriverPtr driver,
+testDomainSaveImageWrite(testDriver *driver,
const char *path,
- virDomainDefPtr def)
+ virDomainDef *def)
{
int len;
int fd = -1;
* Returns -1, on error.
*/
static int ATTRIBUTE_NONNULL(3)
-testDomainSaveImageOpen(testDriverPtr driver,
+testDomainSaveImageOpen(testDriver *driver,
const char *path,
- virDomainDefPtr *ret_def)
+ virDomainDef **ret_def)
{
char magic[15];
int fd = -1;
int len;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
g_autofree char *xml = NULL;
if ((fd = open(path, O_RDONLY)) < 0) {
testDomainSaveFlags(virDomainPtr domain, const char *path,
const char *dxml, unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(0, -1);
const char *dxml,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int fd = -1;
- virDomainDefPtr def = NULL;
- virDomainObjPtr dom = NULL;
- virObjectEventPtr event = NULL;
+ virDomainDef *def = NULL;
+ virDomainObj *dom = NULL;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(0, -1);
{
int ret = -1;
int fd = -1;
- virDomainDefPtr def = NULL;
- virDomainDefPtr newdef = NULL;
- testDriverPtr privconn = conn->privateData;
+ virDomainDef *def = NULL;
+ virDomainDef *newdef = NULL;
+ testDriver *privconn = conn->privateData;
virCheckFlags(VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
{
int fd = -1;
char *ret = NULL;
- virDomainDefPtr def = NULL;
- testDriverPtr privconn = conn->privateData;
+ virDomainDef *def = NULL;
+ testDriver *privconn = conn->privateData;
virCheckFlags(VIR_DOMAIN_SAVE_IMAGE_XML_SECURE, NULL);
unsigned int dumpformat,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
+ testDriver *privconn = domain->conn->privateData;
int fd = -1;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(VIR_DUMP_CRASH, -1);
static unsigned long long
testDomainGetMaxMemory(virDomainPtr domain)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
unsigned long long ret = 0;
if (!(privdom = testDomObjFromDomain(domain)))
int period,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virDomainObj *vm;
+ virDomainDef *def;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
unsigned long memory,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virDomainObj *vm;
+ virDomainDef *def;
int ret = -1;
bool live = false;
int maplen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virBitmapPtr pcpumap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virBitmap *pcpumap = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
int maplen,
unsigned int flags)
{
- testDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virBitmapPtr cpumask = NULL;
- virBitmapPtr bitmap = NULL;
+ testDriver *driver = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virBitmap *cpumask = NULL;
+ virBitmap *bitmap = NULL;
int hostcpus;
int ret = -1;
static int
testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainDefPtr def;
+ virDomainObj *vm;
+ virDomainDef *def;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
unsigned int flags)
{
- testDriverPtr driver = domain->conn->privateData;
- virDomainObjPtr privdom = NULL;
- virDomainDefPtr def;
- virDomainDefPtr persistentDef;
+ testDriver *driver = domain->conn->privateData;
+ virDomainObj *privdom = NULL;
+ virDomainDef *def;
+ virDomainDef *persistentDef;
int ret = -1, maxvcpus;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
unsigned int flags)
{
int ret = -1;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(VIR_DOMAIN_PASSWORD_ENCRYPTED, -1);
unsigned char *cpumaps,
int maplen)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virDomainDefPtr def;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virDomainDef *def;
size_t i;
int hostcpus;
int ret = -1;
unsigned long long statbase;
- virBitmapPtr allcpumap = NULL;
+ virBitmap *allcpumap = NULL;
if (!(privdom = testDomObjFromDomain(domain)))
return -1;
memset(cpumaps, 0, maxinfo * maplen);
for (i = 0; i < maxinfo; i++) {
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(def, i);
- virBitmapPtr bitmap = NULL;
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(def, i);
+ virBitmap *bitmap = NULL;
if (!vcpu->online)
continue;
int maplen,
unsigned int flags)
{
- virDomainVcpuDefPtr vcpuinfo;
- virDomainObjPtr privdom;
- virDomainDefPtr def;
+ virDomainVcpuDef *vcpuinfo;
+ virDomainObj *privdom;
+ virDomainDef *def;
int ret = -1;
virCheckFlags(0, -1);
int maplen,
unsigned int flags)
{
- testDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr privdom;
- virDomainDefPtr def;
+ testDriver *driver = dom->conn->privateData;
+ virDomainObj *privdom;
+ virDomainDef *def;
g_autoptr(virBitmap) hostcpus = NULL;
int ret = -1;
}
static int
-testDomainRenameCallback(virDomainObjPtr privdom,
+testDomainRenameCallback(virDomainObj *privdom,
const char *new_name,
unsigned int flags,
void *opaque)
{
- testDriverPtr driver = opaque;
- virObjectEventPtr event_new = NULL;
- virObjectEventPtr event_old = NULL;
+ testDriver *driver = opaque;
+ virObjectEvent *event_new = NULL;
+ virObjectEvent *event_old = NULL;
int ret = -1;
g_autofree char *new_dom_name = NULL;
const char *new_name,
unsigned int flags)
{
- testDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr privdom = NULL;
+ testDriver *driver = dom->conn->privateData;
+ virDomainObj *privdom = NULL;
int ret = -1;
virCheckFlags(0, ret);
static char *testDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainDefPtr def;
- virDomainObjPtr privdom;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainDef *def;
+ virDomainObj *privdom;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
int nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
unsigned long long swap_hard_limit = 0;
unsigned long long hard_limit = 0;
unsigned long long soft_limit = 0;
unsigned int flags)
{
int ret = -1;
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
int nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virBitmapPtr nodeset = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virBitmap *nodeset = NULL;
virDomainNumatuneMemMode config_mode;
bool live;
size_t i;
int *nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
virDomainNumatuneMemMode mode = VIR_DOMAIN_NUMATUNE_MEM_STRICT;
g_autofree char *nodeset = NULL;
int ret = -1;
int nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def;
- virDomainNetDefPtr net = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def;
+ virDomainNetDef *net = NULL;
g_autoptr(virNetDevBandwidth) bandwidth = NULL;
bool inboundSpecified = false;
bool outboundSpecified = false;
{
virNetDevBandwidthRate in = {0};
virNetDevBandwidthRate out = {0};
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainNetDefPtr net = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainNetDef *net = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
int nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
virDomainBlockIoTuneInfo info = {0};
- virDomainDiskDefPtr conf_disk = NULL;
+ virDomainDiskDef *conf_disk = NULL;
virTypedParameterPtr eventParams = NULL;
int eventNparams = 0;
int eventMaxparams = 0;
int *nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDiskDefPtr disk;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDiskDef *disk;
virDomainBlockIoTuneInfo reply = {0};
int ret = -1;
static int testConnectNumOfDefinedDomains(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virDomainObjListNumOfDomains(privconn->domains, false, NULL, NULL);
}
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
memset(names, 0, sizeof(*names)*maxnames);
return virDomainObjListGetInactiveNames(privconn->domains, names, maxnames,
const char *xml,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainDefPtr def;
- virDomainObjPtr dom = NULL;
- virObjectEventPtr event = NULL;
- virDomainDefPtr oldDef = NULL;
+ virDomainDef *def;
+ virDomainObj *dom = NULL;
+ virObjectEvent *event = NULL;
+ virDomainDef *oldDef = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
const char *uri,
unsigned int flags)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
char *ret;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
const char *uri,
unsigned int flags)
{
- testDriverPtr privconn = dom->conn->privateData;
- virDomainObjPtr privdom;
+ testDriver *privconn = dom->conn->privateData;
+ virDomainObj *privdom;
int ret;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
NULL, NULL, flags);
if (ret == 0) {
- virObjectEventPtr ev = NULL;
+ virObjectEvent *ev = NULL;
ev = virDomainEventMetadataChangeNewFromObj(privdom, type, uri);
virObjectEventStateQueue(privconn->eventState, ev);
}
unsigned int ncpus,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- testDriverPtr privconn = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ testDriver *privconn = dom->conn->privateData;
int ret = -1;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
unsigned int flags)
{
int ret = -1;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virCheckFlags(0, -1);
unsigned long long *freemems,
int startCell, int maxCells)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int cell;
size_t i;
int ret = -1;
static unsigned long long
testNodeGetFreeMemory(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
unsigned int freeMem = 0;
size_t i;
static int testDomainCreateWithFlags(virDomainPtr domain, unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int testDomainUndefineFlags(virDomainPtr domain,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr privdom;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *privdom;
+ virObjectEvent *event = NULL;
int nsnapshots;
int ret = -1;
unsigned int nmountpoints,
unsigned int flags)
{
- virDomainObjPtr vm;
- testDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ testDomainObjPrivate *priv;
size_t i;
int ret = -1;
unsigned int nmountpoints,
unsigned int flags)
{
- virDomainObjPtr vm;
- testDomainObjPrivatePtr priv;
+ virDomainObj *vm;
+ testDomainObjPrivate *priv;
size_t i;
int ret = -1;
unsigned long long minimum G_GNUC_UNUSED,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
static int testDomainGetAutostart(virDomainPtr domain,
int *autostart)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
if (!(privdom = testDomObjFromDomain(domain)))
return -1;
static int testDomainSetAutostart(virDomainPtr domain,
int autostart)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
if (!(privdom = testDomObjFromDomain(domain)))
return -1;
unsigned int maxerrors,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
size_t i;
size_t nerrors = 0;
unsigned int flags)
{
size_t i;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainFSInfoPtr *info_ret = NULL;
int ret = -1;
int nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
size_t i;
int ret = -1;
int *nparams,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
virTypedParameterPtr par = NULL;
size_t i;
int maxpar = 0;
int *nparams,
unsigned int flags)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
int ret = -1;
virCheckFlags(0, -1);
int nparams,
unsigned int flags)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
int ret = -1;
size_t i;
const char *path,
virDomainBlockStatsPtr stats)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
unsigned long long statbase;
int ret = -1;
static int
-testDomainInterfaceAddressFromNet(testDriverPtr driver,
+testDomainInterfaceAddressFromNet(testDriver *driver,
const virDomainNetDef *net,
size_t addr_offset,
virDomainInterfacePtr iface)
{
virSocketAddr addr;
- virNetworkObjPtr net_obj = NULL;
- virNetworkDefPtr net_def = NULL;
+ virNetworkObj *net_obj = NULL;
+ virNetworkDef *net_def = NULL;
int ret = -1;
if (!(net_obj = testNetworkObjFindByName(driver, net->data.network.name)))
size_t ifaces_count = 0;
int ret = -1;
char macaddr[VIR_MAC_STRING_BUFLEN];
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainInterfacePtr iface = NULL;
virDomainInterfacePtr *ifaces_ret = NULL;
const char *device,
virDomainInterfaceStatsPtr stats)
{
- virDomainObjPtr privdom;
+ virDomainObj *privdom;
unsigned long long statbase;
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
int ret = -1;
}
-static virNetworkObjPtr
-testNetworkObjFindByUUID(testDriverPtr privconn,
+static virNetworkObj *
+testNetworkObjFindByUUID(testDriver *privconn,
const unsigned char *uuid)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (!(obj = virNetworkObjFindByUUID(privconn->networks, uuid))) {
testNetworkLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- testDriverPtr privconn = conn->privateData;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virNetworkObj *obj;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
if (!(obj = testNetworkObjFindByUUID(privconn, uuid)))
}
-static virNetworkObjPtr
-testNetworkObjFindByName(testDriverPtr privconn,
+static virNetworkObj *
+testNetworkObjFindByName(testDriver *privconn,
const char *name)
{
- virNetworkObjPtr obj;
+ virNetworkObj *obj;
if (!(obj = virNetworkObjFindByName(privconn->networks, name)))
virReportError(VIR_ERR_NO_NETWORK,
testNetworkLookupByName(virConnectPtr conn,
const char *name)
{
- testDriverPtr privconn = conn->privateData;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virNetworkObj *obj;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
if (!(obj = testNetworkObjFindByName(privconn, name)))
static int
testConnectNumOfNetworks(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virNetworkObjListNumOfNetworks(privconn->networks, true, NULL,
conn);
}
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virNetworkObjListGetNames(privconn->networks, true, names,
maxnames, NULL, conn);
}
static int
testConnectNumOfDefinedNetworks(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virNetworkObjListNumOfNetworks(privconn->networks, false, NULL,
conn);
}
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
return virNetworkObjListGetNames(privconn->networks, false, names,
maxnames, NULL, conn);
}
virNetworkPtr **nets,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1);
static int
testNetworkIsActive(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = testNetworkObjFindByUUID(privconn, net->uuid)))
static int
testNetworkIsPersistent(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = testNetworkObjFindByUUID(privconn, net->uuid)))
static virNetworkPtr
testNetworkCreateXML(virConnectPtr conn, const char *xml)
{
- testDriverPtr privconn = conn->privateData;
- virNetworkDefPtr newDef;
- virNetworkObjPtr obj = NULL;
- virNetworkDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virNetworkDef *newDef;
+ virNetworkObj *obj = NULL;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if ((newDef = virNetworkDefParseString(xml, NULL)) == NULL)
goto cleanup;
testNetworkDefineXML(virConnectPtr conn,
const char *xml)
{
- testDriverPtr privconn = conn->privateData;
- virNetworkDefPtr newDef;
- virNetworkObjPtr obj = NULL;
- virNetworkDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virNetworkDef *newDef;
+ virNetworkObj *obj = NULL;
+ virNetworkDef *def;
virNetworkPtr net = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if ((newDef = virNetworkDefParseString(xml, NULL)) == NULL)
goto cleanup;
static int
testNetworkUndefine(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = testNetworkObjFindByName(privconn, net->name)))
goto cleanup;
const char *xml,
unsigned int flags)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj = NULL;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj = NULL;
int isActive, ret = -1;
virCheckFlags(VIR_NETWORK_UPDATE_AFFECT_LIVE |
static int
testNetworkCreate(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = testNetworkObjFindByName(privconn, net->name)))
goto cleanup;
static int
testNetworkDestroy(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
+ virNetworkDef *def;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = testNetworkObjFindByName(privconn, net->name)))
goto cleanup;
testNetworkGetXMLDesc(virNetworkPtr net,
unsigned int flags)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
char *ret = NULL;
virCheckFlags(0, NULL);
static char *
testNetworkGetBridgeName(virNetworkPtr net)
{
- testDriverPtr privconn = net->conn->privateData;
+ testDriver *privconn = net->conn->privateData;
char *bridge = NULL;
- virNetworkObjPtr obj;
- virNetworkDefPtr def;
+ virNetworkObj *obj;
+ virNetworkDef *def;
if (!(obj = testNetworkObjFindByName(privconn, net->name)))
goto cleanup;
testNetworkGetAutostart(virNetworkPtr net,
int *autostart)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
int ret = -1;
if (!(obj = testNetworkObjFindByName(privconn, net->name)))
testNetworkSetAutostart(virNetworkPtr net,
int autostart)
{
- testDriverPtr privconn = net->conn->privateData;
- virNetworkObjPtr obj;
+ testDriver *privconn = net->conn->privateData;
+ virNetworkObj *obj;
bool new_autostart = (autostart != 0);
int ret = -1;
*/
-static virInterfaceObjPtr
-testInterfaceObjFindByName(testDriverPtr privconn,
+static virInterfaceObj *
+testInterfaceObjFindByName(testDriver *privconn,
const char *name)
{
- virInterfaceObjPtr obj;
+ virInterfaceObj *obj;
virObjectLock(privconn);
obj = virInterfaceObjListFindByName(privconn->ifaces, name);
static int
testConnectNumOfInterfaces(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ninterfaces;
virObjectLock(privconn);
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int nnames;
virObjectLock(privconn);
static int
testConnectNumOfDefinedInterfaces(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ninterfaces;
virObjectLock(privconn);
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int nnames;
virObjectLock(privconn);
virInterfacePtr **ifaces,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_INTERFACES_FILTERS_ACTIVE, -1);
testInterfaceLookupByName(virConnectPtr conn,
const char *name)
{
- testDriverPtr privconn = conn->privateData;
- virInterfaceObjPtr obj;
- virInterfaceDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virInterfaceObj *obj;
+ virInterfaceDef *def;
virInterfacePtr ret = NULL;
if (!(obj = testInterfaceObjFindByName(privconn, name)))
testInterfaceLookupByMACString(virConnectPtr conn,
const char *mac)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ifacect;
char *ifacenames[] = { NULL, NULL };
virInterfacePtr ret = NULL;
static int
testInterfaceIsActive(virInterfacePtr iface)
{
- testDriverPtr privconn = iface->conn->privateData;
- virInterfaceObjPtr obj;
+ testDriver *privconn = iface->conn->privateData;
+ virInterfaceObj *obj;
int ret = -1;
if (!(obj = testInterfaceObjFindByName(privconn, iface->name)))
testInterfaceChangeBegin(virConnectPtr conn,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ret = -1;
virCheckFlags(0, -1);
testInterfaceChangeCommit(virConnectPtr conn,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ret = -1;
virCheckFlags(0, -1);
testInterfaceChangeRollback(virConnectPtr conn,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ret = -1;
virCheckFlags(0, -1);
testInterfaceGetXMLDesc(virInterfacePtr iface,
unsigned int flags)
{
- testDriverPtr privconn = iface->conn->privateData;
- virInterfaceObjPtr obj;
- virInterfaceDefPtr def;
+ testDriver *privconn = iface->conn->privateData;
+ virInterfaceObj *obj;
+ virInterfaceDef *def;
char *ret = NULL;
virCheckFlags(0, NULL);
const char *xmlStr,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
- virInterfaceDefPtr def;
- virInterfaceObjPtr obj = NULL;
- virInterfaceDefPtr objdef;
+ testDriver *privconn = conn->privateData;
+ virInterfaceDef *def;
+ virInterfaceObj *obj = NULL;
+ virInterfaceDef *objdef;
virInterfacePtr ret = NULL;
virCheckFlags(0, NULL);
static int
testInterfaceUndefine(virInterfacePtr iface)
{
- testDriverPtr privconn = iface->conn->privateData;
- virInterfaceObjPtr obj;
+ testDriver *privconn = iface->conn->privateData;
+ virInterfaceObj *obj;
if (!(obj = testInterfaceObjFindByName(privconn, iface->name)))
return -1;
testInterfaceCreate(virInterfacePtr iface,
unsigned int flags)
{
- testDriverPtr privconn = iface->conn->privateData;
- virInterfaceObjPtr obj;
+ testDriver *privconn = iface->conn->privateData;
+ virInterfaceObj *obj;
int ret = -1;
virCheckFlags(0, -1);
testInterfaceDestroy(virInterfacePtr iface,
unsigned int flags)
{
- testDriverPtr privconn = iface->conn->privateData;
- virInterfaceObjPtr obj;
+ testDriver *privconn = iface->conn->privateData;
+ virInterfaceObj *obj;
int ret = -1;
virCheckFlags(0, -1);
*/
static int
-testStoragePoolObjSetDefaults(virStoragePoolObjPtr obj)
+testStoragePoolObjSetDefaults(virStoragePoolObj *obj)
{
char *configFile;
- virStoragePoolDefPtr def = virStoragePoolObjGetDef(obj);
+ virStoragePoolDef *def = virStoragePoolObjGetDef(obj);
def->capacity = defaultPoolCap;
def->allocation = defaultPoolAlloc;
}
-static virStoragePoolObjPtr
-testStoragePoolObjFindByName(testDriverPtr privconn,
+static virStoragePoolObj *
+testStoragePoolObjFindByName(testDriver *privconn,
const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
virObjectLock(privconn);
obj = virStoragePoolObjFindByName(privconn->pools, name);
}
-static virStoragePoolObjPtr
-testStoragePoolObjFindActiveByName(testDriverPtr privconn,
+static virStoragePoolObj *
+testStoragePoolObjFindActiveByName(testDriver *privconn,
const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (!(obj = testStoragePoolObjFindByName(privconn, name)))
return NULL;
}
-static virStoragePoolObjPtr
-testStoragePoolObjFindInactiveByName(testDriverPtr privconn,
+static virStoragePoolObj *
+testStoragePoolObjFindInactiveByName(testDriver *privconn,
const char *name)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
if (!(obj = testStoragePoolObjFindByName(privconn, name)))
return NULL;
}
-static virStoragePoolObjPtr
-testStoragePoolObjFindByUUID(testDriverPtr privconn,
+static virStoragePoolObj *
+testStoragePoolObjFindByUUID(testDriver *privconn,
const unsigned char *uuid)
{
- virStoragePoolObjPtr obj;
+ virStoragePoolObj *obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virObjectLock(privconn);
testStoragePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
if (!(obj = testStoragePoolObjFindByUUID(privconn, uuid)))
testStoragePoolLookupByName(virConnectPtr conn,
const char *name)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
if (!(obj = testStoragePoolObjFindByName(privconn, name)))
static int
testConnectNumOfStoragePools(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int numActive = 0;
virObjectLock(privconn);
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int n = 0;
virObjectLock(privconn);
static int
testConnectNumOfDefinedStoragePools(virConnectPtr conn)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int numInactive = 0;
virObjectLock(privconn);
char **const names,
int maxnames)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int n = 0;
virObjectLock(privconn);
virStoragePoolPtr **pools,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
int ret = -1;
virCheckFlags(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ALL, -1);
static int
testStoragePoolIsActive(virStoragePoolPtr pool)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
int ret = -1;
if (!(obj = testStoragePoolObjFindByUUID(privconn, pool->uuid)))
static int
testStoragePoolIsPersistent(virStoragePoolPtr pool)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
int ret = -1;
if (!(obj = testStoragePoolObjFindByUUID(privconn, pool->uuid)))
testStoragePoolCreate(virStoragePoolPtr pool,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
}
-static virNodeDeviceObjPtr
-testNodeDeviceMockCreateVport(testDriverPtr driver,
+static virNodeDeviceObj *
+testNodeDeviceMockCreateVport(testDriver *driver,
const char *wwnn,
const char *wwpn);
static int
-testCreateVport(testDriverPtr driver,
+testCreateVport(testDriver *driver,
const char *wwnn,
const char *wwpn)
{
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
/* The storage_backend_scsi createVport() will use the input adapter
* fields parent name, parent_wwnn/parent_wwpn, or parent_fabric_wwn
* in order to determine whether the provided parent can be used to
const char *xml,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autoptr(virStoragePoolDef) newDef = NULL;
virCheckFlags(0, NULL);
const char *xml,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj = NULL;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj = NULL;
+ virStoragePoolDef *def;
virStoragePoolPtr pool = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
g_autoptr(virStoragePoolDef) newDef = NULL;
virCheckFlags(0, NULL);
static int
testStoragePoolUndefine(virStoragePoolPtr pool)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virObjectEvent *event = NULL;
if (!(obj = testStoragePoolObjFindInactiveByName(privconn, pool->name)))
return -1;
testStoragePoolBuild(virStoragePoolPtr pool,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
static int
-testDestroyVport(testDriverPtr privconn,
+testDestroyVport(testDriver *privconn,
const char *wwnn G_GNUC_UNUSED,
const char *wwpn G_GNUC_UNUSED)
{
- virNodeDeviceObjPtr obj = NULL;
- virObjectEventPtr event = NULL;
+ virNodeDeviceObj *obj = NULL;
+ virObjectEvent *event = NULL;
/* NB: Cannot use virVHBAGetHostByWWN (yet) like the storage_backend_scsi
* deleteVport() helper since that traverses the file system looking for
static int
testStoragePoolDestroy(virStoragePoolPtr pool)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
int ret = -1;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, pool->name)))
return -1;
testStoragePoolDelete(virStoragePoolPtr pool,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
testStoragePoolRefresh(virStoragePoolPtr pool,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virObjectEvent *event = NULL;
virCheckFlags(0, -1);
testStoragePoolGetInfo(virStoragePoolPtr pool,
virStoragePoolInfoPtr info)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
if (!(obj = testStoragePoolObjFindByName(privconn, pool->name)))
return -1;
testStoragePoolGetXMLDesc(virStoragePoolPtr pool,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
char *ret = NULL;
virCheckFlags(0, NULL);
testStoragePoolGetAutostart(virStoragePoolPtr pool,
int *autostart)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
if (!(obj = testStoragePoolObjFindByName(privconn, pool->name)))
return -1;
testStoragePoolSetAutostart(virStoragePoolPtr pool,
int autostart)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
bool new_autostart = (autostart != 0);
int ret = -1;
static int
testStoragePoolNumOfVolumes(virStoragePoolPtr pool)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
int ret = -1;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, pool->name)))
char **const names,
int maxnames)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
int n = -1;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, pool->name)))
virStorageVolPtr **vols,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
int ret = -1;
virCheckFlags(0, -1);
}
-static virStorageVolDefPtr
-testStorageVolDefFindByName(virStoragePoolObjPtr obj,
+static virStorageVolDef *
+testStorageVolDefFindByName(virStoragePoolObj *obj,
const char *name)
{
- virStorageVolDefPtr privvol;
+ virStorageVolDef *privvol;
if (!(privvol = virStorageVolDefFindByName(obj, name))) {
virReportError(VIR_ERR_NO_STORAGE_VOL,
testStorageVolLookupByName(virStoragePoolPtr pool,
const char *name)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr privvol;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageVolDef *privvol;
virStorageVolPtr ret = NULL;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, pool->name)))
struct storageVolLookupData {
const char *key;
const char *path;
- virStorageVolDefPtr voldef;
+ virStorageVolDef *voldef;
};
static bool
-testStorageVolLookupByKeyCallback(virStoragePoolObjPtr obj,
+testStorageVolLookupByKeyCallback(virStoragePoolObj *obj,
const void *opaque)
{
struct storageVolLookupData *data = (struct storageVolLookupData *)opaque;
testStorageVolLookupByKey(virConnectPtr conn,
const char *key)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
struct storageVolLookupData data = {
.key = key, .voldef = NULL };
virStorageVolPtr vol = NULL;
static bool
-testStorageVolLookupByPathCallback(virStoragePoolObjPtr obj,
+testStorageVolLookupByPathCallback(virStoragePoolObj *obj,
const void *opaque)
{
struct storageVolLookupData *data = (struct storageVolLookupData *)opaque;
testStorageVolLookupByPath(virConnectPtr conn,
const char *path)
{
- testDriverPtr privconn = conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
struct storageVolLookupData data = {
.path = path, .voldef = NULL };
virStorageVolPtr vol = NULL;
const char *xmldesc,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
virStorageVolPtr ret = NULL;
g_autoptr(virStorageVolDef) privvol = NULL;
virStorageVolPtr clonevol,
unsigned int flags)
{
- testDriverPtr privconn = pool->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr origvol = NULL;
+ testDriver *privconn = pool->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageVolDef *origvol = NULL;
virStorageVolPtr ret = NULL;
g_autoptr(virStorageVolDef) privvol = NULL;
testStorageVolDelete(virStorageVolPtr vol,
unsigned int flags)
{
- testDriverPtr privconn = vol->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr privvol;
+ testDriver *privconn = vol->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageVolDef *privvol;
int ret = -1;
virCheckFlags(0, -1);
testStorageVolGetInfo(virStorageVolPtr vol,
virStorageVolInfoPtr info)
{
- testDriverPtr privconn = vol->conn->privateData;
- virStoragePoolObjPtr obj;
- virStoragePoolDefPtr def;
- virStorageVolDefPtr privvol;
+ testDriver *privconn = vol->conn->privateData;
+ virStoragePoolObj *obj;
+ virStoragePoolDef *def;
+ virStorageVolDef *privvol;
int ret = -1;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, vol->pool)))
testStorageVolGetXMLDesc(virStorageVolPtr vol,
unsigned int flags)
{
- testDriverPtr privconn = vol->conn->privateData;
- virStoragePoolObjPtr obj;
- virStorageVolDefPtr privvol;
+ testDriver *privconn = vol->conn->privateData;
+ virStoragePoolObj *obj;
+ virStorageVolDef *privvol;
char *ret = NULL;
virCheckFlags(0, NULL);
static char *
testStorageVolGetPath(virStorageVolPtr vol)
{
- testDriverPtr privconn = vol->conn->privateData;
- virStoragePoolObjPtr obj;
- virStorageVolDefPtr privvol;
+ testDriver *privconn = vol->conn->privateData;
+ virStoragePoolObj *obj;
+ virStorageVolDef *privvol;
char *ret = NULL;
if (!(obj = testStoragePoolObjFindActiveByName(privconn, vol->pool)))
/* Node device implementations */
-static virNodeDeviceObjPtr
-testNodeDeviceObjFindByName(testDriverPtr driver,
+static virNodeDeviceObj *
+testNodeDeviceObjFindByName(testDriver *driver,
const char *name)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
if (!(obj = virNodeDeviceObjListFindByName(driver->devs, name)))
virReportError(VIR_ERR_NO_NODE_DEVICE,
const char *cap,
unsigned int flags)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
virCheckFlags(0, -1);
int maxnames,
unsigned int flags)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
virCheckFlags(0, -1);
virNodeDevicePtr **devices,
unsigned int flags)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP, -1);
static virNodeDevicePtr
testNodeDeviceLookupByName(virConnectPtr conn, const char *name)
{
- testDriverPtr driver = conn->privateData;
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ testDriver *driver = conn->privateData;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
virNodeDevicePtr ret = NULL;
if (!(obj = testNodeDeviceObjFindByName(driver, name)))
testNodeDeviceGetXMLDesc(virNodeDevicePtr dev,
unsigned int flags)
{
- testDriverPtr driver = dev->conn->privateData;
- virNodeDeviceObjPtr obj;
+ testDriver *driver = dev->conn->privateData;
+ virNodeDeviceObj *obj;
char *ret = NULL;
virCheckFlags(0, NULL);
static char *
testNodeDeviceGetParent(virNodeDevicePtr dev)
{
- testDriverPtr driver = dev->conn->privateData;
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
+ testDriver *driver = dev->conn->privateData;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
char *ret = NULL;
if (!(obj = testNodeDeviceObjFindByName(driver, dev->name)))
static int
testNodeDeviceNumOfCaps(virNodeDevicePtr dev)
{
- testDriverPtr driver = dev->conn->privateData;
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
- virNodeDevCapsDefPtr caps;
+ testDriver *driver = dev->conn->privateData;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
+ virNodeDevCapsDef *caps;
int ncaps = 0;
if (!(obj = testNodeDeviceObjFindByName(driver, dev->name)))
static int
testNodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames)
{
- testDriverPtr driver = dev->conn->privateData;
- virNodeDeviceObjPtr obj;
- virNodeDeviceDefPtr def;
- virNodeDevCapsDefPtr caps;
+ testDriver *driver = dev->conn->privateData;
+ virNodeDeviceObj *obj;
+ virNodeDeviceDef *def;
+ virNodeDevCapsDef *caps;
int ncaps = 0;
if (!(obj = testNodeDeviceObjFindByName(driver, dev->name)))
}
-static virNodeDeviceObjPtr
-testNodeDeviceMockCreateVport(testDriverPtr driver,
+static virNodeDeviceObj *
+testNodeDeviceMockCreateVport(testDriver *driver,
const char *wwnn,
const char *wwpn)
{
- virNodeDeviceDefPtr def = NULL;
- virNodeDevCapsDefPtr caps;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceObjPtr objcopy = NULL;
- virNodeDeviceDefPtr objdef;
- virObjectEventPtr event = NULL;
+ virNodeDeviceDef *def = NULL;
+ virNodeDevCapsDef *caps;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceObj *objcopy = NULL;
+ virNodeDeviceDef *objdef;
+ virObjectEvent *event = NULL;
g_autofree char *xml = NULL;
/* In the real code, we'd call virVHBAManageVport which would take the
const char *xmlDesc,
unsigned int flags)
{
- testDriverPtr driver = conn->privateData;
- virNodeDeviceDefPtr def = NULL;
+ testDriver *driver = conn->privateData;
+ virNodeDeviceDef *def = NULL;
virNodeDevicePtr dev = NULL, ret = NULL;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceDefPtr objdef;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceDef *objdef;
g_autofree char *wwnn = NULL;
g_autofree char *wwpn = NULL;
testNodeDeviceDestroy(virNodeDevicePtr dev)
{
int ret = 0;
- testDriverPtr driver = dev->conn->privateData;
- virNodeDeviceObjPtr obj = NULL;
- virNodeDeviceObjPtr parentobj = NULL;
- virNodeDeviceDefPtr def;
- virObjectEventPtr event = NULL;
+ testDriver *driver = dev->conn->privateData;
+ virNodeDeviceObj *obj = NULL;
+ virNodeDeviceObj *parentobj = NULL;
+ virNodeDeviceDef *def;
+ virObjectEvent *event = NULL;
g_autofree char *wwnn = NULL;
g_autofree char *wwpn = NULL;
void *opaque,
virFreeCallback freecb)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virDomainEventStateRegister(conn, driver->eventState,
testConnectDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virDomainEventStateDeregister(conn, driver->eventState,
void *opaque,
virFreeCallback freecb)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret;
if (virDomainEventStateRegisterID(conn, driver->eventState,
testConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virObjectEventStateDeregisterID(conn, driver->eventState,
void *opaque,
virFreeCallback freecb)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret;
if (virNetworkEventStateRegisterID(conn, driver->eventState,
testConnectNetworkEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virObjectEventStateDeregisterID(conn, driver->eventState,
void *opaque,
virFreeCallback freecb)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret;
if (virStoragePoolEventStateRegisterID(conn, driver->eventState,
testConnectStoragePoolEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virObjectEventStateDeregisterID(conn, driver->eventState,
void *opaque,
virFreeCallback freecb)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret;
if (virNodeDeviceEventStateRegisterID(conn, driver->eventState,
testConnectNodeDeviceEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- testDriverPtr driver = conn->privateData;
+ testDriver *driver = conn->privateData;
int ret = 0;
if (virObjectEventStateDeregisterID(conn, driver->eventState,
virDomainPtr **domains,
unsigned int flags)
{
- testDriverPtr privconn = conn->privateData;
+ testDriver *privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
testDomainInjectNMI(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
{
int ret = -1;
size_t i;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virCheckFlags(0, -1);
static int
testDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
- testDriverPtr privconn = dom->conn->privateData;
- virDomainObjPtr vm = NULL;
- virObjectEventPtr event = NULL;
+ testDriver *privconn = dom->conn->privateData;
+ virDomainObj *vm = NULL;
+ virObjectEvent *event = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
static int
testDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret;
virCheckFlags(0, -1);
static int
testDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virCheckFlags(0, -1);
unsigned int nr_stats,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int cur_memory;
int ret = -1;
int ret = -1;
size_t i;
unsigned char b = start;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virCheckFlags(VIR_MEMORY_VIRTUAL | VIR_MEMORY_PHYSICAL, -1);
virDomainBlockInfoPtr info,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDiskDefPtr disk;
+ virDomainObj *vm = NULL;
+ virDomainDiskDef *disk;
int ret = -1;
virCheckFlags(0, -1);
static void
-testDomainModifyLifecycleAction(virDomainDefPtr def,
+testDomainModifyLifecycleAction(virDomainDef *def,
virDomainLifecycle type,
virDomainLifecycleAction action)
{
unsigned int action,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainDefPtr def = NULL;
- virDomainDefPtr persistentDef = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDef *def = NULL;
+ virDomainDef *persistentDef = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
* Snapshot APIs
*/
-static virDomainMomentObjPtr
-testSnapObjFromName(virDomainObjPtr vm,
+static virDomainMomentObj *
+testSnapObjFromName(virDomainObj *vm,
const char *name)
{
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
snap = virDomainSnapshotFindByName(vm->snapshots, name);
if (!snap)
virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
return snap;
}
-static virDomainMomentObjPtr
-testSnapObjFromSnapshot(virDomainObjPtr vm,
+static virDomainMomentObj *
+testSnapObjFromSnapshot(virDomainObj *vm,
virDomainSnapshotPtr snapshot)
{
return testSnapObjFromName(vm, snapshot->name);
}
-static virDomainObjPtr
+static virDomainObj *
testDomObjFromSnapshot(virDomainSnapshotPtr snapshot)
{
return testDomObjFromDomain(snapshot->domain);
static int
testDomainSnapshotNum(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
int nameslen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
int nameslen,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
testDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
const char *name,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr snapshot = NULL;
virCheckFlags(0, NULL);
testDomainHasCurrentSnapshot(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret;
virCheckFlags(0, -1);
testDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr snap = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr parent = NULL;
virCheckFlags(0, NULL);
testDomainSnapshotCurrent(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainSnapshotPtr snapshot = NULL;
- virDomainMomentObjPtr current;
+ virDomainMomentObj *current;
virCheckFlags(0, NULL);
testDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
char *xml = NULL;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- testDriverPtr privconn = snapshot->domain->conn->privateData;
+ testDriver *privconn = snapshot->domain->conn->privateData;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_XML_SECURE, NULL);
testDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
virCheckFlags(0, -1);
testDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
virCheckFlags(0, -1);
}
static int
-testDomainSnapshotAlignDisks(virDomainObjPtr vm,
- virDomainSnapshotDefPtr def,
+testDomainSnapshotAlignDisks(virDomainObj *vm,
+ virDomainSnapshotDef *def,
unsigned int flags)
{
int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
const char *xmlDesc,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
virDomainSnapshotPtr snapshot = NULL;
- virObjectEventPtr event = NULL;
+ virObjectEvent *event = NULL;
bool update_current = true;
bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
unsigned int parse_flags = VIR_DOMAIN_SNAPSHOT_PARSE_DISKS;
typedef struct _testMomentRemoveData testMomentRemoveData;
-typedef testMomentRemoveData *testMomentRemoveDataPtr;
struct _testMomentRemoveData {
- virDomainObjPtr vm;
+ virDomainObj *vm;
bool current;
};
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr snap = payload;
- testMomentRemoveDataPtr curr = data;
+ virDomainMomentObj *snap = payload;
+ testMomentRemoveData *curr = data;
curr->current |= virDomainSnapshotObjListRemove(curr->vm->snapshots, snap);
return 0;
}
typedef struct _testMomentReparentData testMomentReparentData;
-typedef testMomentReparentData *testMomentReparentDataPtr;
struct _testMomentReparentData {
- virDomainMomentObjPtr parent;
- virDomainObjPtr vm;
+ virDomainMomentObj *parent;
+ virDomainObj *vm;
int err;
};
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr moment = payload;
- testMomentReparentDataPtr rep = data;
+ virDomainMomentObj *moment = payload;
+ testMomentReparentData *rep = data;
if (rep->err < 0)
return 0;
testDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
- virDomainMomentObjPtr parentsnap = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
+ virDomainMomentObj *parentsnap = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- testDriverPtr privconn = snapshot->domain->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr snap = NULL;
- virObjectEventPtr event = NULL;
- virObjectEventPtr event2 = NULL;
- virDomainDefPtr config = NULL;
- virDomainSnapshotDefPtr snapdef;
+ testDriver *privconn = snapshot->domain->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *snap = NULL;
+ virObjectEvent *event = NULL;
+ virObjectEvent *event2 = NULL;
+ virDomainDef *config = NULL;
+ virDomainSnapshotDef *snapdef;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
const char *name G_GNUC_UNUSED,
void *data)
{
- virDomainMomentObjPtr chk = payload;
- testMomentRemoveDataPtr curr = data;
+ virDomainMomentObj *chk = payload;
+ testMomentRemoveData *curr = data;
curr->current |= virDomainCheckpointObjListRemove(curr->vm->checkpoints,
chk);
return 0;
}
-static virDomainObjPtr
+static virDomainObj *
testDomObjFromCheckpoint(virDomainCheckpointPtr checkpoint)
{
return testDomObjFromDomain(checkpoint->domain);
}
-static virDomainMomentObjPtr
-testCheckpointObjFromName(virDomainObjPtr vm,
+static virDomainMomentObj *
+testCheckpointObjFromName(virDomainObj *vm,
const char *name)
{
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
chk = virDomainCheckpointFindByName(vm->checkpoints, name);
if (!chk)
return chk;
}
-static virDomainMomentObjPtr
-testCheckpointObjFromCheckpoint(virDomainObjPtr vm,
+static virDomainMomentObj *
+testCheckpointObjFromCheckpoint(virDomainObj *vm,
virDomainCheckpointPtr checkpoint)
{
return testCheckpointObjFromName(vm, checkpoint->name);
const char *xmlDesc,
unsigned int flags)
{
- testDriverPtr privconn = domain->conn->privateData;
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr chk = NULL;
+ testDriver *privconn = domain->conn->privateData;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr checkpoint = NULL;
- virDomainMomentObjPtr current = NULL;
+ virDomainMomentObj *current = NULL;
bool update_current = true;
bool redefine = flags & VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE;
unsigned int parse_flags = 0;
virDomainCheckpointPtr **chks,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_LIST_ROOTS |
virDomainCheckpointPtr **chks,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm = NULL;
+ virDomainMomentObj *chk = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS |
const char *name,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr checkpoint = NULL;
virCheckFlags(0, NULL);
testDomainCheckpointGetParent(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- virDomainObjPtr vm;
- virDomainMomentObjPtr chk = NULL;
+ virDomainObj *vm;
+ virDomainMomentObj *chk = NULL;
virDomainCheckpointPtr parent = NULL;
virCheckFlags(0, NULL);
testDomainCheckpointGetXMLDesc(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- testDriverPtr privconn = checkpoint->domain->conn->privateData;
- virDomainObjPtr vm = NULL;
+ testDriver *privconn = checkpoint->domain->conn->privateData;
+ virDomainObj *vm = NULL;
char *xml = NULL;
- virDomainMomentObjPtr chk = NULL;
+ virDomainMomentObj *chk = NULL;
size_t i;
- virDomainCheckpointDefPtr chkdef;
+ virDomainCheckpointDef *chkdef;
unsigned int format_flags;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_XML_SECURE |
goto cleanup;
for (i = 0; i < chkdef->ndisks; i++) {
- virDomainCheckpointDiskDefPtr disk = &chkdef->disks[i];
+ virDomainCheckpointDiskDef *disk = &chkdef->disks[i];
if (disk->type != VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP)
continue;
testDomainCheckpointDelete(virDomainCheckpointPtr checkpoint,
unsigned int flags)
{
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
int ret = -1;
- virDomainMomentObjPtr chk = NULL;
- virDomainMomentObjPtr parentchk = NULL;
+ virDomainMomentObj *chk = NULL;
+ virDomainMomentObj *parentchk = NULL;
virCheckFlags(VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN |
VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY |
}
-virArpTablePtr
+virArpTable *
virArpTableGet(void)
{
int num = 0;
int msglen;
g_autofree void *nlData = NULL;
- virArpTablePtr table = NULL;
+ virArpTable *table = NULL;
struct nlmsghdr* nh;
struct rtattr * tb[NDA_MAX+1];
#else
-virArpTablePtr
+virArpTable *
virArpTableGet(void)
{
virReportError(VIR_ERR_NO_SUPPORT, "%s",
#endif /* __linux__ */
void
-virArpTableFree(virArpTablePtr table)
+virArpTableFree(virArpTable *table)
{
size_t i;
#include "internal.h"
typedef struct _virArpTableEntry virArpTableEntry;
-typedef virArpTableEntry *virArpTableEntryPtr;
typedef struct _virArpTable virArpTable;
-typedef virArpTable *virArpTablePtr;
struct _virArpTableEntry{
char *ipaddr;
struct _virArpTable {
int n;
- virArpTableEntryPtr t;
+ virArpTableEntry *t;
};
-virArpTablePtr virArpTableGet(void);
-void virArpTableFree(virArpTablePtr table);
+virArpTable *virArpTableGet(void);
+void virArpTableFree(virArpTable *table);
}
-void virAuditSend(virLogSourcePtr source,
+void virAuditSend(virLogSource *source,
const char *filename,
size_t linenr,
const char *funcname,
void virAuditLog(bool enabled);
-void virAuditSend(virLogSourcePtr source,
+void virAuditSend(virLogSource *source,
const char *filename, size_t linenr, const char *funcname,
const char *clienttty, const char *clientaddr,
virAuditRecordType type, bool success,
VIR_LOG_INIT("util.auth");
int
-virAuthGetConfigFilePathURI(virURIPtr uri,
+virAuthGetConfigFilePathURI(virURI *uri,
char **path)
{
size_t i;
int virAuthGetConfigFilePath(virConnectPtr conn,
char **path);
-int virAuthGetConfigFilePathURI(virURIPtr uri,
+int virAuthGetConfigFilePathURI(virURI *uri,
char **path);
VIR_LOG_INIT("util.authconfig");
-virAuthConfigPtr virAuthConfigNew(const char *path)
+virAuthConfig *virAuthConfigNew(const char *path)
{
- virAuthConfigPtr auth;
+ virAuthConfig *auth;
auth = g_new0(virAuthConfig, 1);
}
-virAuthConfigPtr virAuthConfigNewData(const char *path,
+virAuthConfig *virAuthConfigNewData(const char *path,
const char *data,
size_t len)
{
- virAuthConfigPtr auth;
+ virAuthConfig *auth;
auth = g_new0(virAuthConfig, 1);
}
-void virAuthConfigFree(virAuthConfigPtr auth)
+void virAuthConfigFree(virAuthConfig *auth)
{
if (!auth)
return;
}
-int virAuthConfigLookup(virAuthConfigPtr auth,
+int virAuthConfigLookup(virAuthConfig *auth,
const char *service,
const char *hostname,
const char *credname,
#include "internal.h"
typedef struct _virAuthConfig virAuthConfig;
-typedef virAuthConfig *virAuthConfigPtr;
-
-virAuthConfigPtr virAuthConfigNew(const char *path);
-virAuthConfigPtr virAuthConfigNewData(const char *path,
+virAuthConfig *virAuthConfigNew(const char *path);
+virAuthConfig *virAuthConfigNewData(const char *path,
const char *data,
size_t len);
-void virAuthConfigFree(virAuthConfigPtr auth);
+void virAuthConfigFree(virAuthConfig *auth);
-int virAuthConfigLookup(virAuthConfigPtr auth,
+int virAuthConfigLookup(virAuthConfig *auth,
const char *service,
const char *hostname,
const char *credname,
*
* Returns a pointer to the allocated bitmap.
*/
-virBitmapPtr
+virBitmap *
virBitmapNew(size_t size)
{
- virBitmapPtr bitmap;
+ virBitmap *bitmap;
size_t sz;
if (SIZE_MAX - VIR_BITMAP_BITS_PER_UNIT < size) {
* Free @bitmap previously allocated by virBitmapNew.
*/
void
-virBitmapFree(virBitmapPtr bitmap)
+virBitmapFree(virBitmap *bitmap)
{
if (bitmap) {
g_free(bitmap->map);
* Returns 0 on if bit is successfully set, -1 on error.
*/
int
-virBitmapSetBit(virBitmapPtr bitmap,
+virBitmapSetBit(virBitmap *bitmap,
size_t b)
{
if (bitmap->nbits <= b)
* Returns 0 on success, -1 on error.
*/
static int
-virBitmapExpand(virBitmapPtr map,
+virBitmapExpand(virBitmap *map,
size_t b)
{
size_t new_len = VIR_DIV_UP(b + 1, VIR_BITMAP_BITS_PER_UNIT);
* Returns 0 on if bit is successfully set, -1 on error.
*/
int
-virBitmapSetBitExpand(virBitmapPtr bitmap,
+virBitmapSetBitExpand(virBitmap *bitmap,
size_t b)
{
if (bitmap->nbits <= b && virBitmapExpand(bitmap, b) < 0)
* Returns 0 on if bit is successfully clear, -1 on error.
*/
int
-virBitmapClearBit(virBitmapPtr bitmap,
+virBitmapClearBit(virBitmap *bitmap,
size_t b)
{
if (bitmap->nbits <= b)
* Returns 0 on if bit is successfully cleared, -1 on error.
*/
int
-virBitmapClearBitExpand(virBitmapPtr bitmap,
+virBitmapClearBitExpand(virBitmap *bitmap,
size_t b)
{
if (bitmap->nbits <= b) {
/* Helper function. caller must ensure b < bitmap->nbits */
static bool
-virBitmapIsSet(virBitmapPtr bitmap, size_t b)
+virBitmapIsSet(virBitmap *bitmap, size_t b)
{
return !!(bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] & VIR_BITMAP_BIT(b));
}
* Otherwise false is returned.
*/
bool
-virBitmapIsBitSet(virBitmapPtr bitmap,
+virBitmapIsBitSet(virBitmap *bitmap,
size_t b)
{
if (bitmap->nbits <= b)
* returned. On failure, -1 is returned and @result is unchanged.
*/
int
-virBitmapGetBit(virBitmapPtr bitmap,
+virBitmapGetBit(virBitmap *bitmap,
size_t b,
bool *result)
{
* Returns pointer to the string or NULL on error.
*/
char *
-virBitmapToString(virBitmapPtr bitmap)
+virBitmapToString(virBitmap *bitmap)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t sz;
* VIR_FREE to free the string.
*/
char *
-virBitmapFormat(virBitmapPtr bitmap)
+virBitmapFormat(virBitmap *bitmap)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool first = true;
int
virBitmapParseSeparator(const char *str,
char terminator,
- virBitmapPtr *bitmap,
+ virBitmap **bitmap,
size_t bitmapSize)
{
bool neg = false;
*/
int
virBitmapParse(const char *str,
- virBitmapPtr *bitmap,
+ virBitmap **bitmap,
size_t bitmapSize)
{
return virBitmapParseSeparator(str, '\0', bitmap, bitmapSize);
*
* Returns @bitmap on success, or NULL in case of error
*/
-virBitmapPtr
+virBitmap *
virBitmapParseUnlimited(const char *str)
{
- virBitmapPtr bitmap = virBitmapNew(0);
+ virBitmap *bitmap = virBitmapNew(0);
bool neg = false;
const char *cur = str;
char *tmp;
*
* Returns a copy of bitmap @src.
*/
-virBitmapPtr
-virBitmapNewCopy(virBitmapPtr src)
+virBitmap *
+virBitmapNewCopy(virBitmap *src)
{
- virBitmapPtr dst = virBitmapNew(src->nbits);
+ virBitmap *dst = virBitmapNew(src->nbits);
memcpy(dst->map, src->map, src->map_len * sizeof(src->map[0]));
* Returns a pointer to the allocated bitmap or NULL if
* memory cannot be allocated.
*/
-virBitmapPtr
+virBitmap *
virBitmapNewData(const void *data,
int len)
{
- virBitmapPtr bitmap;
+ virBitmap *bitmap;
size_t i, j;
unsigned long *p;
const unsigned char *bytes = data;
* Returns 0 on success, -1 otherwise.
*/
int
-virBitmapToData(virBitmapPtr bitmap,
+virBitmapToData(virBitmap *bitmap,
unsigned char **data,
int *dataLen)
{
* lower bits.
*/
void
-virBitmapToDataBuf(virBitmapPtr bitmap,
+virBitmapToDataBuf(virBitmap *bitmap,
unsigned char *bytes,
size_t len)
{
* otherwise false.
*/
bool
-virBitmapEqual(virBitmapPtr b1,
- virBitmapPtr b2)
+virBitmapEqual(virBitmap *b1,
+ virBitmap *b2)
{
- virBitmapPtr tmp;
+ virBitmap *tmp;
size_t i;
if (!b1 && !b2)
* Returns number of bits @bitmap can store.
*/
size_t
-virBitmapSize(virBitmapPtr bitmap)
+virBitmapSize(virBitmap *bitmap)
{
return bitmap->nbits;
}
*
* set all bits in @bitmap.
*/
-void virBitmapSetAll(virBitmapPtr bitmap)
+void virBitmapSetAll(virBitmap *bitmap)
{
int tail = bitmap->nbits % VIR_BITMAP_BITS_PER_UNIT;
* clear all bits in @bitmap.
*/
void
-virBitmapClearAll(virBitmapPtr bitmap)
+virBitmapClearAll(virBitmap *bitmap)
{
memset(bitmap->map, 0,
bitmap->map_len * (VIR_BITMAP_BITS_PER_UNIT / CHAR_BIT));
* check if all bits in @bitmap are set.
*/
bool
-virBitmapIsAllSet(virBitmapPtr bitmap)
+virBitmapIsAllSet(virBitmap *bitmap)
{
size_t i;
int unusedBits;
* check if all bits in @bitmap are clear
*/
bool
-virBitmapIsAllClear(virBitmapPtr bitmap)
+virBitmapIsAllClear(virBitmap *bitmap)
{
size_t i;
* Returns the position of the found bit, or -1 if no bit found.
*/
ssize_t
-virBitmapNextSetBit(virBitmapPtr bitmap,
+virBitmapNextSetBit(virBitmap *bitmap,
ssize_t pos)
{
size_t nl;
* Returns the position of the found bit, or -1 if no bit is set.
*/
ssize_t
-virBitmapLastSetBit(virBitmapPtr bitmap)
+virBitmapLastSetBit(virBitmap *bitmap)
{
ssize_t i;
int unusedBits;
* Returns the position of the found bit, or -1 if no bit found.
*/
ssize_t
-virBitmapNextClearBit(virBitmapPtr bitmap,
+virBitmapNextClearBit(virBitmap *bitmap,
ssize_t pos)
{
size_t nl;
* Return the number of bits currently set in @bitmap.
*/
size_t
-virBitmapCountBits(virBitmapPtr bitmap)
+virBitmapCountBits(virBitmap *bitmap)
{
size_t i;
size_t ret = 0;
* Returns a pointer to the allocated bitmap or NULL and reports an error if
* @string can't be converted.
*/
-virBitmapPtr
+virBitmap *
virBitmapNewString(const char *string)
{
- virBitmapPtr bitmap;
+ virBitmap *bitmap;
size_t i = 0;
size_t len = strlen(string);
* @b2.
*/
bool
-virBitmapOverlaps(virBitmapPtr b1,
- virBitmapPtr b2)
+virBitmapOverlaps(virBitmap *b1,
+ virBitmap *b2)
{
size_t i;
if (b1->nbits > b2->nbits) {
- virBitmapPtr tmp = b1;
+ virBitmap *tmp = b1;
b1 = b2;
b2 = tmp;
}
* Performs intersection of two bitmaps: a = intersect(a, b)
*/
void
-virBitmapIntersect(virBitmapPtr a,
- virBitmapPtr b)
+virBitmapIntersect(virBitmap *a,
+ virBitmap *b)
{
size_t i;
size_t max = a->map_len;
* Returns 0 on success, <0 on failure.
*/
int
-virBitmapUnion(virBitmapPtr a,
+virBitmapUnion(virBitmap *a,
const virBitmap *b)
{
size_t i;
* Performs subtraction of two bitmaps: a = a - b
*/
void
-virBitmapSubtract(virBitmapPtr a,
- virBitmapPtr b)
+virBitmapSubtract(virBitmap *a,
+ virBitmap *b)
{
size_t i;
size_t max = a->map_len;
* smaller than or equal to @b.
*/
void
-virBitmapShrink(virBitmapPtr map,
+virBitmapShrink(virBitmap *map,
size_t b)
{
size_t toremove;
typedef struct _virBitmap virBitmap;
-typedef virBitmap *virBitmapPtr;
/*
* Allocate a bitmap capable of containing @size bits.
*/
-virBitmapPtr virBitmapNew(size_t size);
+virBitmap *virBitmapNew(size_t size);
/*
* Free previously allocated bitmap
*/
-void virBitmapFree(virBitmapPtr bitmap);
+void virBitmapFree(virBitmap *bitmap);
/*
* Set bit position @b in @bitmap
*/
-int virBitmapSetBit(virBitmapPtr bitmap, size_t b)
+int virBitmapSetBit(virBitmap *bitmap, size_t b)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virBitmapSetBitExpand(virBitmapPtr bitmap, size_t b)
+int virBitmapSetBitExpand(virBitmap *bitmap, size_t b)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
/*
* Clear bit position @b in @bitmap
*/
-int virBitmapClearBit(virBitmapPtr bitmap, size_t b)
+int virBitmapClearBit(virBitmap *bitmap, size_t b)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-int virBitmapClearBitExpand(virBitmapPtr bitmap, size_t b)
+int virBitmapClearBitExpand(virBitmap *bitmap, size_t b)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
/*
* Get bit @b in @bitmap. Returns false if b is out of range.
*/
-bool virBitmapIsBitSet(virBitmapPtr bitmap, size_t b)
+bool virBitmapIsBitSet(virBitmap *bitmap, size_t b)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
/*
* Get setting of bit position @b in @bitmap and store in @result
*/
-int virBitmapGetBit(virBitmapPtr bitmap, size_t b, bool *result)
+int virBitmapGetBit(virBitmap *bitmap, size_t b, bool *result)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) G_GNUC_WARN_UNUSED_RESULT;
-virBitmapPtr
+virBitmap *
virBitmapNewString(const char *string)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-char *virBitmapToString(virBitmapPtr bitmap)
+char *virBitmapToString(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
-char *virBitmapFormat(virBitmapPtr bitmap);
+char *virBitmapFormat(virBitmap *bitmap);
int virBitmapParse(const char *str,
- virBitmapPtr *bitmap,
+ virBitmap **bitmap,
size_t bitmapSize)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
virBitmapParseSeparator(const char *str,
char terminator,
- virBitmapPtr *bitmap,
+ virBitmap **bitmap,
size_t bitmapSize);
-virBitmapPtr
+virBitmap *
virBitmapParseUnlimited(const char *str);
-virBitmapPtr virBitmapNewCopy(virBitmapPtr src) ATTRIBUTE_NONNULL(1);
+virBitmap *virBitmapNewCopy(virBitmap *src) ATTRIBUTE_NONNULL(1);
-virBitmapPtr virBitmapNewData(const void *data, int len) ATTRIBUTE_NONNULL(1);
+virBitmap *virBitmapNewData(const void *data, int len) ATTRIBUTE_NONNULL(1);
-int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen)
+int virBitmapToData(virBitmap *bitmap, unsigned char **data, int *dataLen)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-void virBitmapToDataBuf(virBitmapPtr bitmap, unsigned char *data, size_t len)
+void virBitmapToDataBuf(virBitmap *bitmap, unsigned char *data, size_t len)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-bool virBitmapEqual(virBitmapPtr b1, virBitmapPtr b2);
+bool virBitmapEqual(virBitmap *b1, virBitmap *b2);
-size_t virBitmapSize(virBitmapPtr bitmap)
+size_t virBitmapSize(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-void virBitmapSetAll(virBitmapPtr bitmap)
+void virBitmapSetAll(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-void virBitmapClearAll(virBitmapPtr bitmap)
+void virBitmapClearAll(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-bool virBitmapIsAllSet(virBitmapPtr bitmap)
+bool virBitmapIsAllSet(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-bool virBitmapIsAllClear(virBitmapPtr bitmap)
+bool virBitmapIsAllClear(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-ssize_t virBitmapNextSetBit(virBitmapPtr bitmap, ssize_t pos)
+ssize_t virBitmapNextSetBit(virBitmap *bitmap, ssize_t pos)
ATTRIBUTE_NONNULL(1);
-ssize_t virBitmapLastSetBit(virBitmapPtr bitmap)
+ssize_t virBitmapLastSetBit(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
-ssize_t virBitmapNextClearBit(virBitmapPtr bitmap, ssize_t pos)
+ssize_t virBitmapNextClearBit(virBitmap *bitmap, ssize_t pos)
ATTRIBUTE_NONNULL(1);
-size_t virBitmapCountBits(virBitmapPtr bitmap)
+size_t virBitmapCountBits(virBitmap *bitmap)
ATTRIBUTE_NONNULL(1);
char *virBitmapDataFormat(const void *data,
int len)
ATTRIBUTE_NONNULL(1);
-bool virBitmapOverlaps(virBitmapPtr b1,
- virBitmapPtr b2)
+bool virBitmapOverlaps(virBitmap *b1,
+ virBitmap *b2)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virBitmapIntersect(virBitmapPtr a, virBitmapPtr b)
+void virBitmapIntersect(virBitmap *a, virBitmap *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virBitmapUnion(virBitmapPtr a,
+int virBitmapUnion(virBitmap *a,
const virBitmap *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virBitmapSubtract(virBitmapPtr a, virBitmapPtr b)
+void virBitmapSubtract(virBitmap *a, virBitmap *b)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void virBitmapShrink(virBitmapPtr map, size_t b);
+void virBitmapShrink(virBitmap *map, size_t b);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virBitmap, virBitmapFree);
* indentation level is truncated.
*/
void
-virBufferAdjustIndent(virBufferPtr buf, int indent)
+virBufferAdjustIndent(virBuffer *buf, int indent)
{
if (!buf)
return;
* indentation is applied.
*/
void
-virBufferSetIndent(virBufferPtr buf, int indent)
+virBufferSetIndent(virBuffer *buf, int indent)
{
if (!buf)
return;
* Ensures that the internal GString container is allocated.
*/
static void
-virBufferInitialize(virBufferPtr buf)
+virBufferInitialize(virBuffer *buf)
{
if (!buf->str)
buf->str = g_string_new(NULL);
static void
-virBufferApplyIndent(virBufferPtr buf)
+virBufferApplyIndent(virBuffer *buf)
{
const char space[] = " ";
size_t spacesz = sizeof(space) - 1;
*
*/
void
-virBufferAdd(virBufferPtr buf, const char *str, int len)
+virBufferAdd(virBuffer *buf, const char *str, int len)
{
if (!str || !buf)
return;
* The @toadd virBuffer is consumed and cleared.
*/
void
-virBufferAddBuffer(virBufferPtr buf, virBufferPtr toadd)
+virBufferAddBuffer(virBuffer *buf, virBuffer *toadd)
{
if (!toadd || !toadd->str)
return;
*
*/
void
-virBufferAddChar(virBufferPtr buf, char c)
+virBufferAddChar(virBuffer *buf, char c)
{
virBufferAdd(buf, &c, 1);
}
* Returns the buffer content or NULL in case of error.
*/
const char *
-virBufferCurrentContent(virBufferPtr buf)
+virBufferCurrentContent(virBuffer *buf)
{
if (!buf)
return NULL;
* Returns the buffer content or NULL in case of error.
*/
char *
-virBufferContentAndReset(virBufferPtr buf)
+virBufferContentAndReset(virBuffer *buf)
{
char *str = NULL;
*
* Frees the buffer content and resets the buffer structure.
*/
-void virBufferFreeAndReset(virBufferPtr buf)
+void virBufferFreeAndReset(virBuffer *buf)
{
if (!buf)
return;
* Do a formatted print to an XML buffer. Auto indentation may be applied.
*/
void
-virBufferAsprintf(virBufferPtr buf, const char *format, ...)
+virBufferAsprintf(virBuffer *buf, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
* Do a formatted print to an XML buffer. Auto indentation may be applied.
*/
void
-virBufferVasprintf(virBufferPtr buf, const char *format, va_list argptr)
+virBufferVasprintf(virBuffer *buf, const char *format, va_list argptr)
{
if ((format == NULL) || (buf == NULL))
return;
* applied.
*/
void
-virBufferEscapeString(virBufferPtr buf, const char *format, const char *str)
+virBufferEscapeString(virBuffer *buf, const char *format, const char *str)
{
int len;
g_autofree char *escaped = NULL;
* to work. Auto indentation may be applied.
*/
void
-virBufferEscapeSexpr(virBufferPtr buf,
+virBufferEscapeSexpr(virBuffer *buf,
const char *format,
const char *str)
{
* indentation may be applied.
*/
void
-virBufferEscapeRegex(virBufferPtr buf,
+virBufferEscapeRegex(virBuffer *buf,
const char *format,
const char *str)
{
* Auto indentation may be applied.
*/
void
-virBufferEscapeSQL(virBufferPtr buf,
+virBufferEscapeSQL(virBuffer *buf,
const char *format,
const char *str)
{
* Auto indentation may be applied.
*/
void
-virBufferEscape(virBufferPtr buf, char escape, const char *toescape,
+virBufferEscape(virBuffer *buf, char escape, const char *toescape,
const char *format, const char *str)
{
int len;
* with '%xx' hex sequences). Auto indentation may be applied.
*/
void
-virBufferURIEncodeString(virBufferPtr buf, const char *str)
+virBufferURIEncodeString(virBuffer *buf, const char *str)
{
if ((buf == NULL) || (str == NULL))
return;
* quoted string to mean str. Auto indentation may be applied.
*/
void
-virBufferEscapeShell(virBufferPtr buf, const char *str)
+virBufferEscapeShell(virBuffer *buf, const char *str)
{
int len;
g_autofree char *escaped = NULL;
* See virBufferStrcat.
*/
void
-virBufferStrcatVArgs(virBufferPtr buf,
+virBufferStrcatVArgs(virBuffer *buf,
va_list ap)
{
char *str;
* after each string argument.
*/
void
-virBufferStrcat(virBufferPtr buf, ...)
+virBufferStrcat(virBuffer *buf, ...)
{
va_list ap;
* Trim the supplied string from the tail of the buffer.
*/
void
-virBufferTrim(virBufferPtr buf, const char *str)
+virBufferTrim(virBuffer *buf, const char *str)
{
size_t len = 0;
* the characters from @trim is trimmed.
*/
void
-virBufferTrimChars(virBufferPtr buf, const char *trim)
+virBufferTrimChars(virBuffer *buf, const char *trim)
{
ssize_t i;
* Trim the tail of a buffer.
*/
void
-virBufferTrimLen(virBufferPtr buf, int len)
+virBufferTrimLen(virBuffer *buf, int len)
{
if (!buf || !buf->str)
return;
* @str.
*/
void
-virBufferAddStr(virBufferPtr buf,
+virBufferAddStr(virBuffer *buf,
const char *str)
{
const char *end;
* A buffer structure.
*/
typedef struct _virBuffer virBuffer;
-typedef virBuffer *virBufferPtr;
#define VIR_BUFFER_INITIALIZER { NULL, 0 }
int indent;
};
-const char *virBufferCurrentContent(virBufferPtr buf);
-char *virBufferContentAndReset(virBufferPtr buf);
-void virBufferFreeAndReset(virBufferPtr buf);
+const char *virBufferCurrentContent(virBuffer *buf);
+char *virBufferContentAndReset(virBuffer *buf);
+void virBufferFreeAndReset(virBuffer *buf);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(virBuffer, virBufferFreeAndReset);
size_t virBufferUse(const virBuffer *buf);
-void virBufferAdd(virBufferPtr buf, const char *str, int len);
-void virBufferAddBuffer(virBufferPtr buf, virBufferPtr toadd);
-void virBufferAddChar(virBufferPtr buf, char c);
-void virBufferAsprintf(virBufferPtr buf, const char *format, ...)
+void virBufferAdd(virBuffer *buf, const char *str, int len);
+void virBufferAddBuffer(virBuffer *buf, virBuffer *toadd);
+void virBufferAddChar(virBuffer *buf, char c);
+void virBufferAsprintf(virBuffer *buf, const char *format, ...)
G_GNUC_PRINTF(2, 3);
-void virBufferVasprintf(virBufferPtr buf, const char *format, va_list ap)
+void virBufferVasprintf(virBuffer *buf, const char *format, va_list ap)
G_GNUC_PRINTF(2, 0);
-void virBufferStrcat(virBufferPtr buf, ...)
+void virBufferStrcat(virBuffer *buf, ...)
G_GNUC_NULL_TERMINATED;
-void virBufferStrcatVArgs(virBufferPtr buf, va_list ap);
+void virBufferStrcatVArgs(virBuffer *buf, va_list ap);
-void virBufferEscape(virBufferPtr buf, char escape, const char *toescape,
+void virBufferEscape(virBuffer *buf, char escape, const char *toescape,
const char *format, const char *str);
-void virBufferEscapeString(virBufferPtr buf, const char *format,
+void virBufferEscapeString(virBuffer *buf, const char *format,
const char *str);
-void virBufferEscapeSexpr(virBufferPtr buf, const char *format,
+void virBufferEscapeSexpr(virBuffer *buf, const char *format,
const char *str);
-void virBufferEscapeRegex(virBufferPtr buf,
+void virBufferEscapeRegex(virBuffer *buf,
const char *format,
const char *str);
-void virBufferEscapeSQL(virBufferPtr buf,
+void virBufferEscapeSQL(virBuffer *buf,
const char *format,
const char *str);
-void virBufferEscapeShell(virBufferPtr buf, const char *str);
-void virBufferURIEncodeString(virBufferPtr buf, const char *str);
+void virBufferEscapeShell(virBuffer *buf, const char *str);
+void virBufferURIEncodeString(virBuffer *buf, const char *str);
#define virBufferAddLit(buf_, literal_string_) \
virBufferAdd(buf_, "" literal_string_ "", sizeof(literal_string_) - 1)
-void virBufferAdjustIndent(virBufferPtr buf, int indent);
-void virBufferSetIndent(virBufferPtr, int indent);
+void virBufferAdjustIndent(virBuffer *buf, int indent);
+void virBufferSetIndent(virBuffer *, int indent);
size_t virBufferGetIndent(const virBuffer *buf);
size_t virBufferGetEffectiveIndent(const virBuffer *buf);
-void virBufferTrim(virBufferPtr buf, const char *trim);
-void virBufferTrimChars(virBufferPtr buf, const char *trim);
-void virBufferTrimLen(virBufferPtr buf, int len);
-void virBufferAddStr(virBufferPtr buf, const char *str);
+void virBufferTrim(virBuffer *buf, const char *trim);
+void virBufferTrimChars(virBuffer *buf, const char *trim);
+void virBufferTrimLen(virBuffer *buf, int len);
+void virBufferAddStr(virBuffer *buf, const char *str);
virCgroupAvailable(void)
{
size_t i;
- virCgroupBackendPtr *backends = virCgroupBackendGetAll();
+ virCgroupBackend **backends = virCgroupBackendGetAll();
if (!backends)
return false;
static int
-virCgroupSetBackends(virCgroupPtr group)
+virCgroupSetBackends(virCgroup *group)
{
- virCgroupBackendPtr *backends = virCgroupBackendGetAll();
+ virCgroupBackend **backends = virCgroupBackendGetAll();
bool backendAvailable = false;
size_t i;
static int
-virCgroupCopyMounts(virCgroupPtr group,
- virCgroupPtr parent)
+virCgroupCopyMounts(virCgroup *group,
+ virCgroup *parent)
{
size_t i;
* mounted and where
*/
static int
-virCgroupDetectMounts(virCgroupPtr group)
+virCgroupDetectMounts(virCgroup *group)
{
FILE *mounts = NULL;
struct mntent entry;
static int
-virCgroupCopyPlacement(virCgroupPtr group,
+virCgroupCopyPlacement(virCgroup *group,
const char *path,
- virCgroupPtr parent)
+ virCgroup *parent)
{
size_t i;
* It then appends @path to each detected path.
*/
static int
-virCgroupDetectPlacement(virCgroupPtr group,
+virCgroupDetectPlacement(virCgroup *group,
pid_t pid,
const char *path)
{
static int
-virCgroupSetPlacement(virCgroupPtr group,
+virCgroupSetPlacement(virCgroup *group,
const char *path)
{
size_t i;
static int
-virCgroupValidatePlacement(virCgroupPtr group,
+virCgroupValidatePlacement(virCgroup *group,
pid_t pid)
{
size_t i;
static int
-virCgroupDetectControllers(virCgroupPtr group,
+virCgroupDetectControllers(virCgroup *group,
int controllers,
- virCgroupPtr parent)
+ virCgroup *parent)
{
size_t i;
int controllersAvailable = 0;
int
-virCgroupSetValueStr(virCgroupPtr group,
+virCgroupSetValueStr(virCgroup *group,
int controller,
const char *key,
const char *value)
int
-virCgroupGetValueStr(virCgroupPtr group,
+virCgroupGetValueStr(virCgroup *group,
int controller,
const char *key,
char **value)
int
-virCgroupSetValueU64(virCgroupPtr group,
+virCgroupSetValueU64(virCgroup *group,
int controller,
const char *key,
unsigned long long int value)
int
-virCgroupSetValueI64(virCgroupPtr group,
+virCgroupSetValueI64(virCgroup *group,
int controller,
const char *key,
long long int value)
int
-virCgroupGetValueI64(virCgroupPtr group,
+virCgroupGetValueI64(virCgroup *group,
int controller,
const char *key,
long long int *value)
int
-virCgroupGetValueU64(virCgroupPtr group,
+virCgroupGetValueU64(virCgroup *group,
int controller,
const char *key,
unsigned long long int *value)
static int
-virCgroupMakeGroup(virCgroupPtr parent,
- virCgroupPtr group,
+virCgroupMakeGroup(virCgroup *parent,
+ virCgroup *group,
bool create,
pid_t pid,
unsigned int flags)
static bool
-virCgroupExists(virCgroupPtr group)
+virCgroupExists(virCgroup *group)
{
size_t i;
int
virCgroupNew(const char *path,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autoptr(virCgroup) newGroup = NULL;
static int
-virCgroupAddTaskInternal(virCgroupPtr group,
+virCgroupAddTaskInternal(virCgroup *group,
pid_t pid,
unsigned int flags)
{
size_t i;
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
for (i = 0; i < VIR_CGROUP_BACKEND_TYPE_LAST; i++) {
if (parent->backends[i] &&
* Returns: 0 on success, -1 on error
*/
int
-virCgroupAddProcess(virCgroupPtr group, pid_t pid)
+virCgroupAddProcess(virCgroup *group, pid_t pid)
{
return virCgroupAddTaskInternal(group, pid, VIR_CGROUP_TASK_PROCESS);
}
* Returns: 0 on success, -1 on error
*/
int
-virCgroupAddMachineProcess(virCgroupPtr group, pid_t pid)
+virCgroupAddMachineProcess(virCgroup *group, pid_t pid)
{
return virCgroupAddTaskInternal(group, pid,
VIR_CGROUP_TASK_PROCESS |
* Returns: 0 on success, -1 on error
*/
int
-virCgroupAddThread(virCgroupPtr group,
+virCgroupAddThread(virCgroup *group,
pid_t pid)
{
return virCgroupAddTaskInternal(group, pid, VIR_CGROUP_TASK_THREAD);
static int
-virCgroupNewFromParent(virCgroupPtr parent,
+virCgroupNewFromParent(virCgroup *parent,
const char *path,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autoptr(virCgroup) new = g_new0(virCgroup, 1);
virCgroupNewPartition(const char *path,
bool create,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autofree char *newPath = NULL;
g_autoptr(virCgroup) parent = NULL;
static int
-virCgroupNewNested(virCgroupPtr parent,
+virCgroupNewNested(virCgroup *parent,
int controllers,
bool create,
pid_t pid,
- virCgroupPtr *nested)
+ virCgroup **nested)
{
g_autoptr(virCgroup) new = NULL;
/**
* virCgroupNewSelf:
*
-* @group: Pointer to returned virCgroupPtr
+* @group: Pointer to returned virCgroup *
*
* Obtain a cgroup representing the config of the
* current process
* Returns 0 on success, or -1 on error
*/
int
-virCgroupNewSelf(virCgroupPtr *group)
+virCgroupNewSelf(virCgroup **group)
{
return virCgroupNewDetect(-1, -1, group);
}
* @partition: partition holding the domain
* @driver: name of the driver
* @name: name of the domain
- * @group: Pointer to returned virCgroupPtr
+ * @group: Pointer to returned virCgroup *
*
* Returns 0 on success, or -1 on error
*/
int
-virCgroupNewDomainPartition(virCgroupPtr partition,
+virCgroupNewDomainPartition(virCgroup *partition,
const char *driver,
const char *name,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autofree char *grpname = NULL;
g_autoptr(virCgroup) newGroup = NULL;
* @name: enum to generate the name for the new thread
* @id: id of the vcpu or iothread
* @create: true to create if not already existing
- * @group: Pointer to returned virCgroupPtr
+ * @group: Pointer to returned virCgroup *
*
* Returns 0 on success, or -1 on error
*/
int
-virCgroupNewThread(virCgroupPtr domain,
+virCgroupNewThread(virCgroup *domain,
virCgroupThreadName nameval,
int id,
bool create,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autofree char *name = NULL;
g_autoptr(virCgroup) newGroup = NULL;
- virCgroupPtr parent = NULL;
+ virCgroup *parent = NULL;
int controllers;
*group = NULL;
int
virCgroupNewDetect(pid_t pid,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autoptr(virCgroup) new = g_new0(virCgroup, 1);
pid_t pid,
int controllers,
char *machinename,
- virCgroupPtr *group)
+ virCgroup **group)
{
size_t i;
g_autoptr(virCgroup) newGroup = NULL;
static int
virCgroupEnableMissingControllers(char *path,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autoptr(virCgroup) parent = NULL;
g_auto(GStrv) tokens = g_strsplit(path, "/", 0);
const char *partition,
int controllers,
unsigned int maxthreads,
- virCgroupPtr *group)
+ virCgroup **group)
{
int rv;
g_autoptr(virCgroup) init = NULL;
pid_t pidleader,
const char *partition,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
{
g_autoptr(virCgroup) parent = NULL;
g_autoptr(virCgroup) newGroup = NULL;
const char *partition,
int controllers,
unsigned int maxthreads,
- virCgroupPtr *group)
+ virCgroup **group)
{
int rv;
* with this cgroup object.
*/
bool
-virCgroupHasController(virCgroupPtr cgroup, int controller)
+virCgroupHasController(virCgroup *cgroup, int controller)
{
size_t i;
int
-virCgroupPathOfController(virCgroupPtr group,
+virCgroupPathOfController(virCgroup *group,
unsigned int controller,
const char *key,
char **path)
* Returns: 0 on success, -1 on error
*/
int
-virCgroupGetBlkioIoServiced(virCgroupPtr group,
+virCgroupGetBlkioIoServiced(virCgroup *group,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
long long *requests_write)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioIoServiced, -1,
* Returns: 0 on success, -1 on error
*/
int
-virCgroupGetBlkioIoDeviceServiced(virCgroupPtr group,
+virCgroupGetBlkioIoDeviceServiced(virCgroup *group,
const char *path,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
long long *requests_write)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioIoDeviceServiced, -1,
* Returns: 0 on success, -1 on error
*/
int
-virCgroupSetBlkioWeight(virCgroupPtr group, unsigned int weight)
+virCgroupSetBlkioWeight(virCgroup *group, unsigned int weight)
{
VIR_CGROUP_BACKEND_CALL(group, VIR_CGROUP_CONTROLLER_BLKIO,
setBlkioWeight, -1, weight);
* Returns: 0 on success, -1 on error
*/
int
-virCgroupGetBlkioWeight(virCgroupPtr group, unsigned int *weight)
+virCgroupGetBlkioWeight(virCgroup *group, unsigned int *weight)
{
VIR_CGROUP_BACKEND_CALL(group, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioWeight, -1, weight);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupSetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupSetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int riops)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
setBlkioDeviceReadIops, -1, path, riops);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupSetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupSetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int wiops)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
setBlkioDeviceWriteIops, -1, path, wiops);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupSetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupSetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long rbps)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
setBlkioDeviceReadBps, -1, path, rbps);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupSetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupSetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long wbps)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
setBlkioDeviceWriteBps, -1, path, wbps);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupSetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupSetBlkioDeviceWeight(virCgroup *group,
const char *path,
unsigned int weight)
{
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupGetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupGetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int *riops)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioDeviceReadIops, -1, path, riops);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupGetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupGetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int *wiops)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioDeviceWriteIops, -1, path, wiops);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupGetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupGetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long *rbps)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioDeviceReadBps, -1, path, rbps);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupGetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupGetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long *wbps)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_BLKIO,
getBlkioDeviceWriteBps, -1, path, wbps);
* Returns: 0 on success, -1 on error
*/
static int
-virCgroupGetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupGetBlkioDeviceWeight(virCgroup *group,
const char *path,
unsigned int *weight)
{
* Returns: 0 on success
*/
int
-virCgroupSetMemory(virCgroupPtr group, unsigned long long kb)
+virCgroupSetMemory(virCgroup *group, unsigned long long kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
setMemory, -1, kb);
* Returns: 0 on success, -1 on error
*/
int
-virCgroupGetMemoryStat(virCgroupPtr group,
+virCgroupGetMemoryStat(virCgroup *group,
unsigned long long *cache,
unsigned long long *activeAnon,
unsigned long long *inactiveAnon,
unsigned long long *inactiveFile,
unsigned long long *unevictable)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemoryStat, -1, cache,
* Returns: 0 on success
*/
int
-virCgroupGetMemoryUsage(virCgroupPtr group, unsigned long *kb)
+virCgroupGetMemoryUsage(virCgroup *group, unsigned long *kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemoryUsage, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupSetMemoryHardLimit(virCgroupPtr group, unsigned long long kb)
+virCgroupSetMemoryHardLimit(virCgroup *group, unsigned long long kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
setMemoryHardLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupGetMemoryHardLimit(virCgroupPtr group, unsigned long long *kb)
+virCgroupGetMemoryHardLimit(virCgroup *group, unsigned long long *kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemoryHardLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupSetMemorySoftLimit(virCgroupPtr group, unsigned long long kb)
+virCgroupSetMemorySoftLimit(virCgroup *group, unsigned long long kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
setMemorySoftLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupGetMemorySoftLimit(virCgroupPtr group, unsigned long long *kb)
+virCgroupGetMemorySoftLimit(virCgroup *group, unsigned long long *kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemorySoftLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupSetMemSwapHardLimit(virCgroupPtr group, unsigned long long kb)
+virCgroupSetMemSwapHardLimit(virCgroup *group, unsigned long long kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
setMemSwapHardLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupGetMemSwapHardLimit(virCgroupPtr group, unsigned long long *kb)
+virCgroupGetMemSwapHardLimit(virCgroup *group, unsigned long long *kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemSwapHardLimit, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupGetMemSwapUsage(virCgroupPtr group, unsigned long long *kb)
+virCgroupGetMemSwapUsage(virCgroup *group, unsigned long long *kb)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_MEMORY,
getMemSwapUsage, -1, kb);
* Returns: 0 on success
*/
int
-virCgroupSetCpusetMems(virCgroupPtr group, const char *mems)
+virCgroupSetCpusetMems(virCgroup *group, const char *mems)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
setCpusetMems, -1, mems);
* Returns: 0 on success
*/
int
-virCgroupGetCpusetMems(virCgroupPtr group, char **mems)
+virCgroupGetCpusetMems(virCgroup *group, char **mems)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
getCpusetMems, -1, mems);
* Returns: 0 on success
*/
int
-virCgroupSetCpusetMemoryMigrate(virCgroupPtr group, bool migrate)
+virCgroupSetCpusetMemoryMigrate(virCgroup *group, bool migrate)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
setCpusetMemoryMigrate, -1, migrate);
* Returns: 0 on success
*/
int
-virCgroupGetCpusetMemoryMigrate(virCgroupPtr group, bool *migrate)
+virCgroupGetCpusetMemoryMigrate(virCgroup *group, bool *migrate)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
getCpusetMemoryMigrate, -1, migrate);
* Returns: 0 on success
*/
int
-virCgroupSetCpusetCpus(virCgroupPtr group, const char *cpus)
+virCgroupSetCpusetCpus(virCgroup *group, const char *cpus)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
setCpusetCpus, -1, cpus);
* Returns: 0 on success
*/
int
-virCgroupGetCpusetCpus(virCgroupPtr group, char **cpus)
+virCgroupGetCpusetCpus(virCgroup *group, char **cpus)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUSET,
getCpusetCpus, -1, cpus);
* Returns: 0 on success
*/
int
-virCgroupDenyAllDevices(virCgroupPtr group)
+virCgroupDenyAllDevices(virCgroup *group)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_DEVICES,
denyAllDevices, -1);
* Returns: 0 on success
*/
int
-virCgroupAllowAllDevices(virCgroupPtr group, int perms)
+virCgroupAllowAllDevices(virCgroup *group, int perms)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_DEVICES,
allowAllDevices, -1, perms);
* Returns: 0 on success
*/
int
-virCgroupAllowDevice(virCgroupPtr group, char type, int major, int minor,
+virCgroupAllowDevice(virCgroup *group, char type, int major, int minor,
int perms)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_DEVICES,
allowDevice, -1, type, major, minor, perms);
* accessible, or * -1 on error
*/
int
-virCgroupAllowDevicePath(virCgroupPtr group,
+virCgroupAllowDevicePath(virCgroup *group,
const char *path,
int perms,
bool ignoreEacces)
{
struct stat sb;
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
if (stat(path, &sb) < 0) {
if (errno == EACCES && ignoreEacces)
* Returns: 0 on success
*/
int
-virCgroupDenyDevice(virCgroupPtr group, char type, int major, int minor,
+virCgroupDenyDevice(virCgroup *group, char type, int major, int minor,
int perms)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_DEVICES,
denyDevice, -1, type, major, minor, perms);
* accessible, or -1 on error.
*/
int
-virCgroupDenyDevicePath(virCgroupPtr group,
+virCgroupDenyDevicePath(virCgroup *group,
const char *path,
int perms,
bool ignoreEacces)
{
struct stat sb;
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
if (stat(path, &sb) < 0) {
if (errno == EACCES && ignoreEacces)
* s3 = t03 + t13
*/
static int
-virCgroupGetPercpuVcpuSum(virCgroupPtr group,
- virBitmapPtr guestvcpus,
+virCgroupGetPercpuVcpuSum(virCgroup *group,
+ virBitmap *guestvcpus,
unsigned long long *sum_cpu_time,
size_t nsum,
- virBitmapPtr cpumap)
+ virBitmap *cpumap)
{
ssize_t i = -1;
* Please DON'T use this function anywhere else.
*/
int
-virCgroupGetPercpuStats(virCgroupPtr group,
+virCgroupGetPercpuStats(virCgroup *group,
virTypedParameterPtr params,
unsigned int nparams,
int start_cpu,
unsigned int ncpus,
- virBitmapPtr guestvcpus)
+ virBitmap *guestvcpus)
{
int ret = -1;
size_t i;
virTypedParameterPtr ent;
int param_idx;
unsigned long long cpu_time;
- virBitmapPtr cpumap = NULL;
+ virBitmap *cpumap = NULL;
/* return the number of supported params */
if (nparams == 0 && ncpus != 0) {
int
-virCgroupGetDomainTotalCpuStats(virCgroupPtr group,
+virCgroupGetDomainTotalCpuStats(virCgroup *group,
virTypedParameterPtr params,
int nparams)
{
int
-virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares)
+virCgroupSetCpuShares(virCgroup *group, unsigned long long shares)
{
VIR_CGROUP_BACKEND_CALL(group, VIR_CGROUP_CONTROLLER_CPU,
setCpuShares, -1, shares);
int
-virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares)
+virCgroupGetCpuShares(virCgroup *group, unsigned long long *shares)
{
VIR_CGROUP_BACKEND_CALL(group, VIR_CGROUP_CONTROLLER_CPU,
getCpuShares, -1, shares);
* Returns: 0 on success
*/
int
-virCgroupSetCpuCfsPeriod(virCgroupPtr group, unsigned long long cfs_period)
+virCgroupSetCpuCfsPeriod(virCgroup *group, unsigned long long cfs_period)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPU,
setCpuCfsPeriod, -1, cfs_period);
* Returns: 0 on success
*/
int
-virCgroupGetCpuCfsPeriod(virCgroupPtr group, unsigned long long *cfs_period)
+virCgroupGetCpuCfsPeriod(virCgroup *group, unsigned long long *cfs_period)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPU,
getCpuCfsPeriod, -1, cfs_period);
* Returns: 0 on success
*/
int
-virCgroupSetCpuCfsQuota(virCgroupPtr group, long long cfs_quota)
+virCgroupSetCpuCfsQuota(virCgroup *group, long long cfs_quota)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPU,
setCpuCfsQuota, -1, cfs_quota);
int
-virCgroupGetCpuacctPercpuUsage(virCgroupPtr group, char **usage)
+virCgroupGetCpuacctPercpuUsage(virCgroup *group, char **usage)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUACCT,
getCpuacctPercpuUsage, -1, usage);
* Returns: 0 on success
*/
int
-virCgroupRemove(virCgroupPtr group)
+virCgroupRemove(virCgroup *group)
{
size_t i;
* Returns 1 if some PIDs are killed, 0 if none are killed, or -1 on error
*/
static int
-virCgroupKillInternal(virCgroupPtr group,
+virCgroupKillInternal(virCgroup *group,
int signum,
GHashTable *pids,
int controller,
int
-virCgroupKillRecursiveInternal(virCgroupPtr group,
+virCgroupKillRecursiveInternal(virCgroup *group,
int signum,
GHashTable *pids,
int controller,
int
-virCgroupKillRecursive(virCgroupPtr group, int signum)
+virCgroupKillRecursive(virCgroup *group, int signum)
{
int rc;
bool success = false;
size_t i;
bool backendAvailable = false;
- virCgroupBackendPtr *backends = virCgroupBackendGetAll();
+ virCgroupBackend **backends = virCgroupBackendGetAll();
g_autoptr(GHashTable) pids = g_hash_table_new_full(g_int64_hash, g_int64_equal, g_free, NULL);
VIR_DEBUG("group=%p signum=%d", group, signum);
int
-virCgroupKillPainfully(virCgroupPtr group)
+virCgroupKillPainfully(virCgroup *group)
{
size_t i;
int ret;
* Returns: 0 on success
*/
int
-virCgroupGetCpuCfsQuota(virCgroupPtr group, long long *cfs_quota)
+virCgroupGetCpuCfsQuota(virCgroup *group, long long *cfs_quota)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPU,
getCpuCfsQuota, -1, cfs_quota);
int
-virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage)
+virCgroupGetCpuacctUsage(virCgroup *group, unsigned long long *usage)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUACCT,
getCpuacctUsage, -1, usage);
int
-virCgroupGetCpuacctStat(virCgroupPtr group, unsigned long long *user,
+virCgroupGetCpuacctStat(virCgroup *group, unsigned long long *user,
unsigned long long *sys)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPUACCT,
getCpuacctStat, -1, user, sys);
int
-virCgroupSetFreezerState(virCgroupPtr group, const char *state)
+virCgroupSetFreezerState(virCgroup *group, const char *state)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_FREEZER,
setFreezerState, -1, state);
int
-virCgroupGetFreezerState(virCgroupPtr group, char **state)
+virCgroupGetFreezerState(virCgroup *group, char **state)
{
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_FREEZER,
getFreezerState, -1, state);
int
-virCgroupBindMount(virCgroupPtr group, const char *oldroot,
+virCgroupBindMount(virCgroup *group, const char *oldroot,
const char *mountopts)
{
size_t i;
- virCgroupPtr parent = virCgroupGetNested(group);
+ virCgroup *parent = virCgroupGetNested(group);
for (i = 0; i < VIR_CGROUP_BACKEND_TYPE_LAST; i++) {
if (parent->backends[i] &&
}
-int virCgroupSetOwner(virCgroupPtr cgroup,
+int virCgroupSetOwner(virCgroup *cgroup,
uid_t uid,
gid_t gid,
int controllers)
{
size_t i;
- virCgroupPtr parent = virCgroupGetNested(cgroup);
+ virCgroup *parent = virCgroupGetNested(cgroup);
for (i = 0; i < VIR_CGROUP_BACKEND_TYPE_LAST; i++) {
if (parent->backends[i] &&
* false when CFS bandwidth is not supported.
*/
bool
-virCgroupSupportsCpuBW(virCgroupPtr cgroup)
+virCgroupSupportsCpuBW(virCgroup *cgroup)
{
- virCgroupPtr parent = virCgroupGetNested(cgroup);
+ virCgroup *parent = virCgroupGetNested(cgroup);
VIR_CGROUP_BACKEND_CALL(parent, VIR_CGROUP_CONTROLLER_CPU,
supportsCpuBW, false);
}
int
-virCgroupHasEmptyTasks(virCgroupPtr cgroup, int controller)
+virCgroupHasEmptyTasks(virCgroup *cgroup, int controller)
{
size_t i;
- virCgroupPtr parent = virCgroupGetNested(cgroup);
+ virCgroup *parent = virCgroupGetNested(cgroup);
for (i = 0; i < VIR_CGROUP_BACKEND_TYPE_LAST; i++) {
if (parent->backends[i]) {
virCgroupNewPartition(const char *path G_GNUC_UNUSED,
bool create G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
virCgroupNew(const char *path G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupNewSelf(virCgroupPtr *group G_GNUC_UNUSED)
+virCgroupNewSelf(virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupNewDomainPartition(virCgroupPtr partition G_GNUC_UNUSED,
+virCgroupNewDomainPartition(virCgroup *partition G_GNUC_UNUSED,
const char *driver G_GNUC_UNUSED,
const char *name G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupNewThread(virCgroupPtr domain G_GNUC_UNUSED,
+virCgroupNewThread(virCgroup *domain G_GNUC_UNUSED,
virCgroupThreadName nameval G_GNUC_UNUSED,
int id G_GNUC_UNUSED,
bool create G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
virCgroupNewDetect(pid_t pid G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
pid_t pid G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED,
char *machinename G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
const char *partition G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED,
unsigned int maxthreads G_GNUC_UNUSED,
- virCgroupPtr *group G_GNUC_UNUSED)
+ virCgroup **group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
bool
-virCgroupHasController(virCgroupPtr cgroup G_GNUC_UNUSED,
+virCgroupHasController(virCgroup *cgroup G_GNUC_UNUSED,
int controller G_GNUC_UNUSED)
{
return false;
int
-virCgroupPathOfController(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupPathOfController(virCgroup *group G_GNUC_UNUSED,
unsigned int controller G_GNUC_UNUSED,
const char *key G_GNUC_UNUSED,
char **path G_GNUC_UNUSED)
int
-virCgroupAddProcess(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAddProcess(virCgroup *group G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
int
-virCgroupAddMachineProcess(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAddMachineProcess(virCgroup *group G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
int
-virCgroupAddThread(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAddThread(virCgroup *group G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
int
-virCgroupGetBlkioIoServiced(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioIoServiced(virCgroup *group G_GNUC_UNUSED,
long long *bytes_read G_GNUC_UNUSED,
long long *bytes_write G_GNUC_UNUSED,
long long *requests_read G_GNUC_UNUSED,
int
-virCgroupGetBlkioIoDeviceServiced(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioIoDeviceServiced(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
long long *bytes_read G_GNUC_UNUSED,
long long *bytes_write G_GNUC_UNUSED,
int
-virCgroupSetBlkioWeight(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioWeight(virCgroup *group G_GNUC_UNUSED,
unsigned int weight G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
int
-virCgroupGetBlkioWeight(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioWeight(virCgroup *group G_GNUC_UNUSED,
unsigned int *weight G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
static int
-virCgroupSetBlkioDeviceWeight(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioDeviceWeight(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int weight G_GNUC_UNUSED)
{
}
static int
-virCgroupSetBlkioDeviceReadIops(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioDeviceReadIops(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int riops G_GNUC_UNUSED)
{
}
static int
-virCgroupSetBlkioDeviceWriteIops(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioDeviceWriteIops(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int wiops G_GNUC_UNUSED)
{
}
static int
-virCgroupSetBlkioDeviceReadBps(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioDeviceReadBps(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned long long rbps G_GNUC_UNUSED)
{
}
static int
-virCgroupSetBlkioDeviceWriteBps(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetBlkioDeviceWriteBps(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned long long wbps G_GNUC_UNUSED)
{
}
static int
-virCgroupGetBlkioDeviceWeight(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioDeviceWeight(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int *weight G_GNUC_UNUSED)
{
}
static int
-virCgroupGetBlkioDeviceReadIops(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioDeviceReadIops(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int *riops G_GNUC_UNUSED)
{
}
static int
-virCgroupGetBlkioDeviceWriteIops(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioDeviceWriteIops(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned int *wiops G_GNUC_UNUSED)
{
}
static int
-virCgroupGetBlkioDeviceReadBps(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioDeviceReadBps(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned long long *rbps G_GNUC_UNUSED)
{
}
static int
-virCgroupGetBlkioDeviceWriteBps(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetBlkioDeviceWriteBps(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
unsigned long long *wbps G_GNUC_UNUSED)
{
}
int
-virCgroupSetMemory(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetMemory(virCgroup *group G_GNUC_UNUSED,
unsigned long long kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetMemoryStat(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemoryStat(virCgroup *group G_GNUC_UNUSED,
unsigned long long *cache G_GNUC_UNUSED,
unsigned long long *activeAnon G_GNUC_UNUSED,
unsigned long long *inactiveAnon G_GNUC_UNUSED,
int
-virCgroupGetMemoryUsage(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemoryUsage(virCgroup *group G_GNUC_UNUSED,
unsigned long *kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetMemoryHardLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetMemoryHardLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetMemoryHardLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemoryHardLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long *kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetMemorySoftLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetMemorySoftLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetMemorySoftLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemorySoftLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long *kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetMemSwapHardLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetMemSwapHardLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetMemSwapHardLimit(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemSwapHardLimit(virCgroup *group G_GNUC_UNUSED,
unsigned long long *kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetMemSwapUsage(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetMemSwapUsage(virCgroup *group G_GNUC_UNUSED,
unsigned long long *kb G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetCpusetMems(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpusetMems(virCgroup *group G_GNUC_UNUSED,
const char *mems G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpusetMems(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpusetMems(virCgroup *group G_GNUC_UNUSED,
char **mems G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetCpusetMemoryMigrate(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpusetMemoryMigrate(virCgroup *group G_GNUC_UNUSED,
bool migrate G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpusetMemoryMigrate(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpusetMemoryMigrate(virCgroup *group G_GNUC_UNUSED,
bool *migrate G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetCpusetCpus(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpusetCpus(virCgroup *group G_GNUC_UNUSED,
const char *cpus G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpusetCpus(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpusetCpus(virCgroup *group G_GNUC_UNUSED,
char **cpus G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
}
int
-virCgroupAllowAllDevices(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAllowAllDevices(virCgroup *group G_GNUC_UNUSED,
int perms G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
}
int
-virCgroupDenyAllDevices(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupDenyAllDevices(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupAllowDevice(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAllowDevice(virCgroup *group G_GNUC_UNUSED,
char type G_GNUC_UNUSED,
int major G_GNUC_UNUSED,
int minor G_GNUC_UNUSED,
int
-virCgroupAllowDevicePath(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupAllowDevicePath(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
int perms G_GNUC_UNUSED,
bool ignoreEaccess G_GNUC_UNUSED)
int
-virCgroupDenyDevice(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupDenyDevice(virCgroup *group G_GNUC_UNUSED,
char type G_GNUC_UNUSED,
int major G_GNUC_UNUSED,
int minor G_GNUC_UNUSED,
int
-virCgroupDenyDevicePath(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupDenyDevicePath(virCgroup *group G_GNUC_UNUSED,
const char *path G_GNUC_UNUSED,
int perms G_GNUC_UNUSED,
bool ignoreEacces G_GNUC_UNUSED)
int
-virCgroupSetCpuShares(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpuShares(virCgroup *group G_GNUC_UNUSED,
unsigned long long shares G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpuShares(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuShares(virCgroup *group G_GNUC_UNUSED,
unsigned long long *shares G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetCpuCfsPeriod(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpuCfsPeriod(virCgroup *group G_GNUC_UNUSED,
unsigned long long cfs_period G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpuCfsPeriod(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuCfsPeriod(virCgroup *group G_GNUC_UNUSED,
unsigned long long *cfs_period G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupSetCpuCfsQuota(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetCpuCfsQuota(virCgroup *group G_GNUC_UNUSED,
long long cfs_quota G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupRemove(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupRemove(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupKillRecursive(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupKillRecursive(virCgroup *group G_GNUC_UNUSED,
int signum G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupKillPainfully(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupKillPainfully(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupGetCpuCfsQuota(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuCfsQuota(virCgroup *group G_GNUC_UNUSED,
long long *cfs_quota G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpuacctUsage(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuacctUsage(virCgroup *group G_GNUC_UNUSED,
unsigned long long *usage G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpuacctPercpuUsage(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuacctPercpuUsage(virCgroup *group G_GNUC_UNUSED,
char **usage G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetCpuacctStat(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetCpuacctStat(virCgroup *group G_GNUC_UNUSED,
unsigned long long *user G_GNUC_UNUSED,
unsigned long long *sys G_GNUC_UNUSED)
{
int
-virCgroupGetDomainTotalCpuStats(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetDomainTotalCpuStats(virCgroup *group G_GNUC_UNUSED,
virTypedParameterPtr params G_GNUC_UNUSED,
int nparams G_GNUC_UNUSED)
{
int
-virCgroupSetFreezerState(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupSetFreezerState(virCgroup *group G_GNUC_UNUSED,
const char *state G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupGetFreezerState(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetFreezerState(virCgroup *group G_GNUC_UNUSED,
char **state G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCgroupBindMount(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupBindMount(virCgroup *group G_GNUC_UNUSED,
const char *oldroot G_GNUC_UNUSED,
const char *mountopts G_GNUC_UNUSED)
{
bool
-virCgroupSupportsCpuBW(virCgroupPtr cgroup G_GNUC_UNUSED)
+virCgroupSupportsCpuBW(virCgroup *cgroup G_GNUC_UNUSED)
{
VIR_DEBUG("Control groups not supported on this platform");
return false;
int
-virCgroupGetPercpuStats(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupGetPercpuStats(virCgroup *group G_GNUC_UNUSED,
virTypedParameterPtr params G_GNUC_UNUSED,
unsigned int nparams G_GNUC_UNUSED,
int start_cpu G_GNUC_UNUSED,
unsigned int ncpus G_GNUC_UNUSED,
- virBitmapPtr guestvcpus G_GNUC_UNUSED)
+ virBitmap *guestvcpus G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Control groups not supported on this platform"));
int
-virCgroupSetOwner(virCgroupPtr cgroup G_GNUC_UNUSED,
+virCgroupSetOwner(virCgroup *cgroup G_GNUC_UNUSED,
uid_t uid G_GNUC_UNUSED,
gid_t gid G_GNUC_UNUSED,
int controllers G_GNUC_UNUSED)
}
int
-virCgroupHasEmptyTasks(virCgroupPtr cgroup G_GNUC_UNUSED,
+virCgroupHasEmptyTasks(virCgroup *cgroup G_GNUC_UNUSED,
int controller G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
* @group: The group structure to free
*/
void
-virCgroupFree(virCgroupPtr group)
+virCgroupFree(virCgroup *group)
{
size_t i;
int
-virCgroupDelThread(virCgroupPtr cgroup,
+virCgroupDelThread(virCgroup *cgroup,
virCgroupThreadName nameval,
int idx)
{
g_autoptr(virCgroup) new_cgroup = NULL;
- virCgroupPtr parent = NULL;
+ virCgroup *parent = NULL;
if (cgroup) {
parent = virCgroupGetNested(cgroup);
* virCgroupGetBlkioDeviceWeight() in the same @weight pointer.
*/
int
-virCgroupSetupBlkioDeviceWeight(virCgroupPtr cgroup, const char *path,
+virCgroupSetupBlkioDeviceWeight(virCgroup *cgroup, const char *path,
unsigned int *weight)
{
if (virCgroupSetBlkioDeviceWeight(cgroup, path, *weight) < 0 ||
* virCgroupGetBlkioDeviceReadIops() in the same @riops pointer.
*/
int
-virCgroupSetupBlkioDeviceReadIops(virCgroupPtr cgroup, const char *path,
+virCgroupSetupBlkioDeviceReadIops(virCgroup *cgroup, const char *path,
unsigned int *riops)
{
if (virCgroupSetBlkioDeviceReadIops(cgroup, path, *riops) < 0 ||
* virCgroupGetBlkioDeviceWriteIops() in the same @wiops pointer.
*/
int
-virCgroupSetupBlkioDeviceWriteIops(virCgroupPtr cgroup, const char *path,
+virCgroupSetupBlkioDeviceWriteIops(virCgroup *cgroup, const char *path,
unsigned int *wiops)
{
if (virCgroupSetBlkioDeviceWriteIops(cgroup, path, *wiops) < 0 ||
* virCgroupGetBlkioDeviceReadBps() in the same @rbps pointer.
*/
int
-virCgroupSetupBlkioDeviceReadBps(virCgroupPtr cgroup, const char *path,
+virCgroupSetupBlkioDeviceReadBps(virCgroup *cgroup, const char *path,
unsigned long long *rbps)
{
if (virCgroupSetBlkioDeviceReadBps(cgroup, path, *rbps) < 0 ||
* virCgroupGetBlkioDeviceWriteBps() in the same @wbps pointer.
*/
int
-virCgroupSetupBlkioDeviceWriteBps(virCgroupPtr cgroup, const char *path,
+virCgroupSetupBlkioDeviceWriteBps(virCgroup *cgroup, const char *path,
unsigned long long *wbps)
{
if (virCgroupSetBlkioDeviceWriteBps(cgroup, path, *wbps) < 0 ||
int
-virCgroupSetupCpusetCpus(virCgroupPtr cgroup, virBitmapPtr cpumask)
+virCgroupSetupCpusetCpus(virCgroup *cgroup, virBitmap *cpumask)
{
g_autofree char *new_cpus = NULL;
int
-virCgroupSetupCpuPeriodQuota(virCgroupPtr cgroup,
+virCgroupSetupCpuPeriodQuota(virCgroup *cgroup,
unsigned long long period,
long long quota)
{
int
-virCgroupGetCpuPeriodQuota(virCgroupPtr cgroup, unsigned long long *period,
+virCgroupGetCpuPeriodQuota(virCgroup *cgroup, unsigned long long *period,
long long *quota)
{
if (virCgroupGetCpuCfsPeriod(cgroup, period) < 0)
struct _virCgroup;
typedef struct _virCgroup virCgroup;
-typedef virCgroup *virCgroupPtr;
enum {
VIR_CGROUP_CONTROLLER_CPU,
int virCgroupNew(const char *path,
int controllers,
- virCgroupPtr *group);
+ virCgroup **group);
-int virCgroupNewSelf(virCgroupPtr *group)
+int virCgroupNewSelf(virCgroup **group)
ATTRIBUTE_NONNULL(1);
-int virCgroupNewThread(virCgroupPtr domain,
+int virCgroupNewThread(virCgroup *domain,
virCgroupThreadName nameval,
int id,
bool create,
- virCgroupPtr *group)
+ virCgroup **group)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(5);
-int virCgroupDelThread(virCgroupPtr cgroup,
+int virCgroupDelThread(virCgroup *cgroup,
virCgroupThreadName nameval,
int idx);
int virCgroupNewDetect(pid_t pid,
int controllers,
- virCgroupPtr *group);
+ virCgroup **group);
int
virCgroupNewDetectMachine(const char *name,
pid_t pid,
int controllers,
char *machinename,
- virCgroupPtr *group)
+ virCgroup **group)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int virCgroupNewMachine(const char *name,
const char *partition,
int controllers,
unsigned int maxthreads,
- virCgroupPtr *group)
+ virCgroup **group)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3);
bool virCgroupNewIgnoreError(void);
-void virCgroupFree(virCgroupPtr group);
+void virCgroupFree(virCgroup *group);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCgroup, virCgroupFree);
-bool virCgroupHasController(virCgroupPtr cgroup, int controller);
-int virCgroupPathOfController(virCgroupPtr group,
+bool virCgroupHasController(virCgroup *cgroup, int controller);
+int virCgroupPathOfController(virCgroup *group,
unsigned int controller,
const char *key,
char **path);
-int virCgroupAddProcess(virCgroupPtr group, pid_t pid);
-int virCgroupAddMachineProcess(virCgroupPtr group, pid_t pid);
-int virCgroupAddThread(virCgroupPtr group, pid_t pid);
+int virCgroupAddProcess(virCgroup *group, pid_t pid);
+int virCgroupAddMachineProcess(virCgroup *group, pid_t pid);
+int virCgroupAddThread(virCgroup *group, pid_t pid);
-int virCgroupSetBlkioWeight(virCgroupPtr group, unsigned int weight);
-int virCgroupGetBlkioWeight(virCgroupPtr group, unsigned int *weight);
+int virCgroupSetBlkioWeight(virCgroup *group, unsigned int weight);
+int virCgroupGetBlkioWeight(virCgroup *group, unsigned int *weight);
-int virCgroupGetBlkioIoServiced(virCgroupPtr group,
+int virCgroupGetBlkioIoServiced(virCgroup *group,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
long long *requests_write);
-int virCgroupGetBlkioIoDeviceServiced(virCgroupPtr group,
+int virCgroupGetBlkioIoDeviceServiced(virCgroup *group,
const char *path,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
long long *requests_write);
-int virCgroupSetupBlkioDeviceWeight(virCgroupPtr cgroup,
+int virCgroupSetupBlkioDeviceWeight(virCgroup *cgroup,
const char *path,
unsigned int *weight);
-int virCgroupSetupBlkioDeviceReadIops(virCgroupPtr cgroup,
+int virCgroupSetupBlkioDeviceReadIops(virCgroup *cgroup,
const char *path,
unsigned int *riops);
-int virCgroupSetupBlkioDeviceWriteIops(virCgroupPtr cgroup,
+int virCgroupSetupBlkioDeviceWriteIops(virCgroup *cgroup,
const char *path,
unsigned int *wiops);
-int virCgroupSetupBlkioDeviceReadBps(virCgroupPtr cgroup,
+int virCgroupSetupBlkioDeviceReadBps(virCgroup *cgroup,
const char *path,
unsigned long long *rbps);
-int virCgroupSetupBlkioDeviceWriteBps(virCgroupPtr cgroup,
+int virCgroupSetupBlkioDeviceWriteBps(virCgroup *cgroup,
const char *path,
unsigned long long *wbps);
-int virCgroupSetMemory(virCgroupPtr group, unsigned long long kb);
-int virCgroupGetMemoryStat(virCgroupPtr group,
+int virCgroupSetMemory(virCgroup *group, unsigned long long kb);
+int virCgroupGetMemoryStat(virCgroup *group,
unsigned long long *cache,
unsigned long long *activeAnon,
unsigned long long *inactiveAnon,
unsigned long long *activeFile,
unsigned long long *inactiveFile,
unsigned long long *unevictable);
-int virCgroupGetMemoryUsage(virCgroupPtr group, unsigned long *kb);
+int virCgroupGetMemoryUsage(virCgroup *group, unsigned long *kb);
-int virCgroupSetMemoryHardLimit(virCgroupPtr group, unsigned long long kb);
-int virCgroupGetMemoryHardLimit(virCgroupPtr group, unsigned long long *kb);
-int virCgroupSetMemorySoftLimit(virCgroupPtr group, unsigned long long kb);
-int virCgroupGetMemorySoftLimit(virCgroupPtr group, unsigned long long *kb);
-int virCgroupSetMemSwapHardLimit(virCgroupPtr group, unsigned long long kb);
-int virCgroupGetMemSwapHardLimit(virCgroupPtr group, unsigned long long *kb);
-int virCgroupGetMemSwapUsage(virCgroupPtr group, unsigned long long *kb);
+int virCgroupSetMemoryHardLimit(virCgroup *group, unsigned long long kb);
+int virCgroupGetMemoryHardLimit(virCgroup *group, unsigned long long *kb);
+int virCgroupSetMemorySoftLimit(virCgroup *group, unsigned long long kb);
+int virCgroupGetMemorySoftLimit(virCgroup *group, unsigned long long *kb);
+int virCgroupSetMemSwapHardLimit(virCgroup *group, unsigned long long kb);
+int virCgroupGetMemSwapHardLimit(virCgroup *group, unsigned long long *kb);
+int virCgroupGetMemSwapUsage(virCgroup *group, unsigned long long *kb);
enum {
VIR_CGROUP_DEVICE_READ = 1,
const char *virCgroupGetDevicePermsString(int perms);
-int virCgroupDenyAllDevices(virCgroupPtr group);
+int virCgroupDenyAllDevices(virCgroup *group);
-int virCgroupAllowAllDevices(virCgroupPtr group, int perms);
+int virCgroupAllowAllDevices(virCgroup *group, int perms);
-int virCgroupAllowDevice(virCgroupPtr group,
+int virCgroupAllowDevice(virCgroup *group,
char type,
int major,
int minor,
int perms);
-int virCgroupAllowDevicePath(virCgroupPtr group,
+int virCgroupAllowDevicePath(virCgroup *group,
const char *path,
int perms,
bool ignoreEacces);
-int virCgroupDenyDevice(virCgroupPtr group,
+int virCgroupDenyDevice(virCgroup *group,
char type,
int major,
int minor,
int perms);
-int virCgroupDenyDevicePath(virCgroupPtr group,
+int virCgroupDenyDevicePath(virCgroup *group,
const char *path,
int perms,
bool ignoreEacces);
int
-virCgroupGetPercpuStats(virCgroupPtr group,
+virCgroupGetPercpuStats(virCgroup *group,
virTypedParameterPtr params,
unsigned int nparams,
int start_cpu,
unsigned int ncpus,
- virBitmapPtr guestvcpus);
+ virBitmap *guestvcpus);
int
-virCgroupGetDomainTotalCpuStats(virCgroupPtr group,
+virCgroupGetDomainTotalCpuStats(virCgroup *group,
virTypedParameterPtr params,
int nparams);
-int virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares);
-int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares);
+int virCgroupSetCpuShares(virCgroup *group, unsigned long long shares);
+int virCgroupGetCpuShares(virCgroup *group, unsigned long long *shares);
#define VIR_CGROUP_CPU_SHARES_MIN 2LL
#define VIR_CGROUP_CPU_SHARES_MAX 262144LL
* (64 - BW_SHIFT) and BW_SHIFT is 20 */
#define VIR_CGROUP_CPU_QUOTA_MAX 17592186044415LL
-int virCgroupSetCpuCfsPeriod(virCgroupPtr group, unsigned long long cfs_period);
-int virCgroupGetCpuCfsPeriod(virCgroupPtr group, unsigned long long *cfs_period);
-int virCgroupGetCpuPeriodQuota(virCgroupPtr cgroup, unsigned long long *period,
+int virCgroupSetCpuCfsPeriod(virCgroup *group, unsigned long long cfs_period);
+int virCgroupGetCpuCfsPeriod(virCgroup *group, unsigned long long *cfs_period);
+int virCgroupGetCpuPeriodQuota(virCgroup *cgroup, unsigned long long *period,
long long *quota);
-int virCgroupSetupCpuPeriodQuota(virCgroupPtr cgroup, unsigned long long period,
+int virCgroupSetupCpuPeriodQuota(virCgroup *cgroup, unsigned long long period,
long long quota);
-int virCgroupSetCpuCfsQuota(virCgroupPtr group, long long cfs_quota);
-int virCgroupGetCpuCfsQuota(virCgroupPtr group, long long *cfs_quota);
+int virCgroupSetCpuCfsQuota(virCgroup *group, long long cfs_quota);
+int virCgroupGetCpuCfsQuota(virCgroup *group, long long *cfs_quota);
-int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage);
-int virCgroupGetCpuacctPercpuUsage(virCgroupPtr group, char **usage);
-int virCgroupGetCpuacctStat(virCgroupPtr group, unsigned long long *user,
+int virCgroupGetCpuacctUsage(virCgroup *group, unsigned long long *usage);
+int virCgroupGetCpuacctPercpuUsage(virCgroup *group, char **usage);
+int virCgroupGetCpuacctStat(virCgroup *group, unsigned long long *user,
unsigned long long *sys);
-int virCgroupSetFreezerState(virCgroupPtr group, const char *state);
-int virCgroupGetFreezerState(virCgroupPtr group, char **state);
+int virCgroupSetFreezerState(virCgroup *group, const char *state);
+int virCgroupGetFreezerState(virCgroup *group, char **state);
-int virCgroupSetCpusetMems(virCgroupPtr group, const char *mems);
-int virCgroupGetCpusetMems(virCgroupPtr group, char **mems);
+int virCgroupSetCpusetMems(virCgroup *group, const char *mems);
+int virCgroupGetCpusetMems(virCgroup *group, char **mems);
-int virCgroupSetCpusetMemoryMigrate(virCgroupPtr group, bool migrate);
-int virCgroupGetCpusetMemoryMigrate(virCgroupPtr group, bool *migrate);
+int virCgroupSetCpusetMemoryMigrate(virCgroup *group, bool migrate);
+int virCgroupGetCpusetMemoryMigrate(virCgroup *group, bool *migrate);
-int virCgroupSetCpusetCpus(virCgroupPtr group, const char *cpus);
-int virCgroupGetCpusetCpus(virCgroupPtr group, char **cpus);
-int virCgroupSetupCpusetCpus(virCgroupPtr cgroup, virBitmapPtr cpumask);
+int virCgroupSetCpusetCpus(virCgroup *group, const char *cpus);
+int virCgroupGetCpusetCpus(virCgroup *group, char **cpus);
+int virCgroupSetupCpusetCpus(virCgroup *cgroup, virBitmap *cpumask);
-int virCgroupRemove(virCgroupPtr group);
+int virCgroupRemove(virCgroup *group);
-int virCgroupKillRecursive(virCgroupPtr group, int signum);
-int virCgroupKillPainfully(virCgroupPtr group);
+int virCgroupKillRecursive(virCgroup *group, int signum);
+int virCgroupKillPainfully(virCgroup *group);
-int virCgroupBindMount(virCgroupPtr group,
+int virCgroupBindMount(virCgroup *group,
const char *oldroot,
const char *mountopts);
-bool virCgroupSupportsCpuBW(virCgroupPtr cgroup);
+bool virCgroupSupportsCpuBW(virCgroup *cgroup);
-int virCgroupSetOwner(virCgroupPtr cgroup,
+int virCgroupSetOwner(virCgroup *cgroup,
uid_t uid,
gid_t gid,
int controllers);
-int virCgroupHasEmptyTasks(virCgroupPtr cgroup, int controller);
+int virCgroupHasEmptyTasks(virCgroup *cgroup, int controller);
bool virCgroupControllerAvailable(int controller);
);
static virOnceControl virCgroupBackendOnce = VIR_ONCE_CONTROL_INITIALIZER;
-static virCgroupBackendPtr virCgroupBackends[VIR_CGROUP_BACKEND_TYPE_LAST] = { 0 };
+static virCgroupBackend *virCgroupBackends[VIR_CGROUP_BACKEND_TYPE_LAST] = { 0 };
void
-virCgroupBackendRegister(virCgroupBackendPtr backend)
+virCgroupBackendRegister(virCgroupBackend *backend)
{
if (virCgroupBackends[backend->type]) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
-virCgroupBackendPtr *
+virCgroupBackend **
virCgroupBackendGetAll(void)
{
if (virOnce(&virCgroupBackendOnce, virCgroupBackendOnceInit) < 0) {
}
-virCgroupBackendPtr
-virCgroupBackendForController(virCgroupPtr group,
+virCgroupBackend *
+virCgroupBackendForController(virCgroup *group,
unsigned int controller)
{
size_t i;
(*virCgroupAvailableCB)(void);
typedef bool
-(*virCgroupValidateMachineGroupCB)(virCgroupPtr group,
+(*virCgroupValidateMachineGroupCB)(virCgroup *group,
const char *name,
const char *drivername,
const char *machinename);
typedef int
-(*virCgroupCopyMountsCB)(virCgroupPtr group,
- virCgroupPtr parent);
+(*virCgroupCopyMountsCB)(virCgroup *group,
+ virCgroup *parent);
typedef int
-(*virCgroupCopyPlacementCB)(virCgroupPtr group,
+(*virCgroupCopyPlacementCB)(virCgroup *group,
const char *path,
- virCgroupPtr parent);
+ virCgroup *parent);
typedef int
-(*virCgroupDetectMountsCB)(virCgroupPtr group,
+(*virCgroupDetectMountsCB)(virCgroup *group,
const char *mntType,
const char *mntOpts,
const char *mntDir);
typedef int
-(*virCgroupDetectPlacementCB)(virCgroupPtr group,
+(*virCgroupDetectPlacementCB)(virCgroup *group,
const char *path,
const char *controllers,
const char *selfpath);
typedef int
-(*virCgroupSetPlacementCB)(virCgroupPtr group,
+(*virCgroupSetPlacementCB)(virCgroup *group,
const char *path);
typedef int
-(*virCgroupValidatePlacementCB)(virCgroupPtr group,
+(*virCgroupValidatePlacementCB)(virCgroup *group,
pid_t pid);
typedef char *
-(*virCgroupStealPlacementCB)(virCgroupPtr group);
+(*virCgroupStealPlacementCB)(virCgroup *group);
typedef int
-(*virCgroupDetectControllersCB)(virCgroupPtr group,
+(*virCgroupDetectControllersCB)(virCgroup *group,
int controllers,
- virCgroupPtr parent,
+ virCgroup *parent,
int detected);
typedef bool
-(*virCgroupHasControllerCB)(virCgroupPtr cgroup,
+(*virCgroupHasControllerCB)(virCgroup *cgroup,
int controller);
typedef int
-(*virCgroupGetAnyControllerCB)(virCgroupPtr group);
+(*virCgroupGetAnyControllerCB)(virCgroup *group);
typedef int
-(*virCgroupPathOfControllerCB)(virCgroupPtr group,
+(*virCgroupPathOfControllerCB)(virCgroup *group,
int controller,
const char *key,
char **path);
typedef bool
-(*virCgroupExistsCB)(virCgroupPtr group);
+(*virCgroupExistsCB)(virCgroup *group);
typedef int
-(*virCgroupMakeGroupCB)(virCgroupPtr parent,
- virCgroupPtr group,
+(*virCgroupMakeGroupCB)(virCgroup *parent,
+ virCgroup *group,
bool create,
pid_t pid,
unsigned int flags);
typedef int
-(*virCgroupRemoveCB)(virCgroupPtr group);
+(*virCgroupRemoveCB)(virCgroup *group);
typedef int
-(*virCgroupAddTaskCB)(virCgroupPtr group,
+(*virCgroupAddTaskCB)(virCgroup *group,
pid_t pid,
unsigned int flags);
typedef int
-(*virCgroupHasEmptyTasksCB)(virCgroupPtr cgroup,
+(*virCgroupHasEmptyTasksCB)(virCgroup *cgroup,
int controller);
typedef int
-(*virCgroupKillRecursiveCB)(virCgroupPtr group,
+(*virCgroupKillRecursiveCB)(virCgroup *group,
int signum,
GHashTable *pids);
typedef int
-(*virCgroupBindMountCB)(virCgroupPtr group,
+(*virCgroupBindMountCB)(virCgroup *group,
const char *oldroot,
const char *mountopts);
typedef int
-(*virCgroupSetOwnerCB)(virCgroupPtr cgroup,
+(*virCgroupSetOwnerCB)(virCgroup *cgroup,
uid_t uid,
gid_t gid,
int controllers);
typedef int
-(*virCgroupSetBlkioWeightCB)(virCgroupPtr group,
+(*virCgroupSetBlkioWeightCB)(virCgroup *group,
unsigned int weight);
typedef int
-(*virCgroupGetBlkioWeightCB)(virCgroupPtr group,
+(*virCgroupGetBlkioWeightCB)(virCgroup *group,
unsigned int *weight);
typedef int
-(*virCgroupGetBlkioIoServicedCB)(virCgroupPtr group,
+(*virCgroupGetBlkioIoServicedCB)(virCgroup *group,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
long long *requests_write);
typedef int
-(*virCgroupGetBlkioIoDeviceServicedCB)(virCgroupPtr group,
+(*virCgroupGetBlkioIoDeviceServicedCB)(virCgroup *group,
const char *path,
long long *bytes_read,
long long *bytes_write,
long long *requests_write);
typedef int
-(*virCgroupSetBlkioDeviceWeightCB)(virCgroupPtr group,
+(*virCgroupSetBlkioDeviceWeightCB)(virCgroup *group,
const char *path,
unsigned int weight);
typedef int
-(*virCgroupGetBlkioDeviceWeightCB)(virCgroupPtr group,
+(*virCgroupGetBlkioDeviceWeightCB)(virCgroup *group,
const char *path,
unsigned int *weight);
typedef int
-(*virCgroupSetBlkioDeviceReadIopsCB)(virCgroupPtr group,
+(*virCgroupSetBlkioDeviceReadIopsCB)(virCgroup *group,
const char *path,
unsigned int riops);
typedef int
-(*virCgroupGetBlkioDeviceReadIopsCB)(virCgroupPtr group,
+(*virCgroupGetBlkioDeviceReadIopsCB)(virCgroup *group,
const char *path,
unsigned int *riops);
typedef int
-(*virCgroupSetBlkioDeviceWriteIopsCB)(virCgroupPtr group,
+(*virCgroupSetBlkioDeviceWriteIopsCB)(virCgroup *group,
const char *path,
unsigned int wiops);
typedef int
-(*virCgroupGetBlkioDeviceWriteIopsCB)(virCgroupPtr group,
+(*virCgroupGetBlkioDeviceWriteIopsCB)(virCgroup *group,
const char *path,
unsigned int *wiops);
typedef int
-(*virCgroupSetBlkioDeviceReadBpsCB)(virCgroupPtr group,
+(*virCgroupSetBlkioDeviceReadBpsCB)(virCgroup *group,
const char *path,
unsigned long long rbps);
typedef int
-(*virCgroupGetBlkioDeviceReadBpsCB)(virCgroupPtr group,
+(*virCgroupGetBlkioDeviceReadBpsCB)(virCgroup *group,
const char *path,
unsigned long long *rbps);
typedef int
-(*virCgroupSetBlkioDeviceWriteBpsCB)(virCgroupPtr group,
+(*virCgroupSetBlkioDeviceWriteBpsCB)(virCgroup *group,
const char *path,
unsigned long long wbps);
typedef int
-(*virCgroupGetBlkioDeviceWriteBpsCB)(virCgroupPtr group,
+(*virCgroupGetBlkioDeviceWriteBpsCB)(virCgroup *group,
const char *path,
unsigned long long *wbps);
typedef int
-(*virCgroupSetMemoryCB)(virCgroupPtr group,
+(*virCgroupSetMemoryCB)(virCgroup *group,
unsigned long long kb);
typedef int
-(*virCgroupGetMemoryStatCB)(virCgroupPtr group,
+(*virCgroupGetMemoryStatCB)(virCgroup *group,
unsigned long long *cache,
unsigned long long *activeAnon,
unsigned long long *inactiveAnon,
unsigned long long *unevictable);
typedef int
-(*virCgroupGetMemoryUsageCB)(virCgroupPtr group,
+(*virCgroupGetMemoryUsageCB)(virCgroup *group,
unsigned long *kb);
typedef int
-(*virCgroupSetMemoryHardLimitCB)(virCgroupPtr group,
+(*virCgroupSetMemoryHardLimitCB)(virCgroup *group,
unsigned long long kb);
typedef int
-(*virCgroupGetMemoryHardLimitCB)(virCgroupPtr group,
+(*virCgroupGetMemoryHardLimitCB)(virCgroup *group,
unsigned long long *kb);
typedef int
-(*virCgroupSetMemorySoftLimitCB)(virCgroupPtr group,
+(*virCgroupSetMemorySoftLimitCB)(virCgroup *group,
unsigned long long kb);
typedef int
-(*virCgroupGetMemorySoftLimitCB)(virCgroupPtr group,
+(*virCgroupGetMemorySoftLimitCB)(virCgroup *group,
unsigned long long *kb);
typedef int
-(*virCgroupSetMemSwapHardLimitCB)(virCgroupPtr group,
+(*virCgroupSetMemSwapHardLimitCB)(virCgroup *group,
unsigned long long kb);
typedef int
-(*virCgroupGetMemSwapHardLimitCB)(virCgroupPtr group,
+(*virCgroupGetMemSwapHardLimitCB)(virCgroup *group,
unsigned long long *kb);
typedef int
-(*virCgroupGetMemSwapUsageCB)(virCgroupPtr group,
+(*virCgroupGetMemSwapUsageCB)(virCgroup *group,
unsigned long long *kb);
typedef int
-(*virCgroupAllowDeviceCB)(virCgroupPtr group,
+(*virCgroupAllowDeviceCB)(virCgroup *group,
char type,
int major,
int minor,
int perms);
typedef int
-(*virCgroupDenyDeviceCB)(virCgroupPtr group,
+(*virCgroupDenyDeviceCB)(virCgroup *group,
char type,
int major,
int minor,
int perms);
typedef int
-(*virCgroupAllowAllDevicesCB)(virCgroupPtr group,
+(*virCgroupAllowAllDevicesCB)(virCgroup *group,
int perms);
typedef int
-(*virCgroupDenyAllDevicesCB)(virCgroupPtr group);
+(*virCgroupDenyAllDevicesCB)(virCgroup *group);
typedef int
-(*virCgroupSetCpuSharesCB)(virCgroupPtr group,
+(*virCgroupSetCpuSharesCB)(virCgroup *group,
unsigned long long shares);
typedef int
-(*virCgroupGetCpuSharesCB)(virCgroupPtr group,
+(*virCgroupGetCpuSharesCB)(virCgroup *group,
unsigned long long *shares);
typedef int
-(*virCgroupSetCpuCfsPeriodCB)(virCgroupPtr group,
+(*virCgroupSetCpuCfsPeriodCB)(virCgroup *group,
unsigned long long cfs_period);
typedef int
-(*virCgroupGetCpuCfsPeriodCB)(virCgroupPtr group,
+(*virCgroupGetCpuCfsPeriodCB)(virCgroup *group,
unsigned long long *cfs_period);
typedef int
-(*virCgroupSetCpuCfsQuotaCB)(virCgroupPtr group,
+(*virCgroupSetCpuCfsQuotaCB)(virCgroup *group,
long long cfs_quota);
typedef int
-(*virCgroupGetCpuCfsQuotaCB)(virCgroupPtr group,
+(*virCgroupGetCpuCfsQuotaCB)(virCgroup *group,
long long *cfs_quota);
typedef bool
-(*virCgroupSupportsCpuBWCB)(virCgroupPtr cgroup);
+(*virCgroupSupportsCpuBWCB)(virCgroup *cgroup);
typedef int
-(*virCgroupGetCpuacctUsageCB)(virCgroupPtr group,
+(*virCgroupGetCpuacctUsageCB)(virCgroup *group,
unsigned long long *usage);
typedef int
-(*virCgroupGetCpuacctPercpuUsageCB)(virCgroupPtr group,
+(*virCgroupGetCpuacctPercpuUsageCB)(virCgroup *group,
char **usage);
typedef int
-(*virCgroupGetCpuacctStatCB)(virCgroupPtr group,
+(*virCgroupGetCpuacctStatCB)(virCgroup *group,
unsigned long long *user,
unsigned long long *sys);
typedef int
-(*virCgroupSetFreezerStateCB)(virCgroupPtr group,
+(*virCgroupSetFreezerStateCB)(virCgroup *group,
const char *state);
typedef int
-(*virCgroupGetFreezerStateCB)(virCgroupPtr group,
+(*virCgroupGetFreezerStateCB)(virCgroup *group,
char **state);
typedef int
-(*virCgroupSetCpusetMemsCB)(virCgroupPtr group,
+(*virCgroupSetCpusetMemsCB)(virCgroup *group,
const char *mems);
typedef int
-(*virCgroupGetCpusetMemsCB)(virCgroupPtr group,
+(*virCgroupGetCpusetMemsCB)(virCgroup *group,
char **mems);
typedef int
-(*virCgroupSetCpusetMemoryMigrateCB)(virCgroupPtr group,
+(*virCgroupSetCpusetMemoryMigrateCB)(virCgroup *group,
bool migrate);
typedef int
-(*virCgroupGetCpusetMemoryMigrateCB)(virCgroupPtr group,
+(*virCgroupGetCpusetMemoryMigrateCB)(virCgroup *group,
bool *migrate);
typedef int
-(*virCgroupSetCpusetCpusCB)(virCgroupPtr group,
+(*virCgroupSetCpusetCpusCB)(virCgroup *group,
const char *cpus);
typedef int
-(*virCgroupGetCpusetCpusCB)(virCgroupPtr group,
+(*virCgroupGetCpusetCpusCB)(virCgroup *group,
char **cpus);
struct _virCgroupBackend {
virCgroupGetCpusetCpusCB getCpusetCpus;
};
typedef struct _virCgroupBackend virCgroupBackend;
-typedef virCgroupBackend *virCgroupBackendPtr;
void
-virCgroupBackendRegister(virCgroupBackendPtr backend);
+virCgroupBackendRegister(virCgroupBackend *backend);
-virCgroupBackendPtr *
+virCgroupBackend **
virCgroupBackendGetAll(void);
-virCgroupBackendPtr
-virCgroupBackendForController(virCgroupPtr group,
+virCgroupBackend *
+virCgroupBackendForController(virCgroup *group,
unsigned int controller);
#define VIR_CGROUP_BACKEND_CALL(group, controller, func, ret, ...) \
do { \
- virCgroupBackendPtr backend = virCgroupBackendForController(group, controller); \
+ virCgroupBackend *backend = virCgroupBackendForController(group, controller); \
if (!backend) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
_("failed to get cgroup backend for '%s'"), #func); \
char *placement;
};
typedef struct _virCgroupV1Controller virCgroupV1Controller;
-typedef virCgroupV1Controller *virCgroupV1ControllerPtr;
struct _virCgroupV2Devices {
int mapfd;
ssize_t max;
};
typedef struct _virCgroupV2Devices virCgroupV2Devices;
-typedef virCgroupV2Devices *virCgroupV2DevicesPtr;
struct _virCgroupV2Controller {
int controllers;
virCgroupV2Devices devices;
};
typedef struct _virCgroupV2Controller virCgroupV2Controller;
-typedef virCgroupV2Controller *virCgroupV2ControllerPtr;
struct _virCgroup {
- virCgroupBackendPtr backends[VIR_CGROUP_BACKEND_TYPE_LAST];
+ virCgroupBackend *backends[VIR_CGROUP_BACKEND_TYPE_LAST];
virCgroupV1Controller legacy[VIR_CGROUP_CONTROLLER_LAST];
virCgroupV2Controller unified;
char *unitName;
- virCgroupPtr nested;
+ virCgroup *nested;
};
#define virCgroupGetNested(cgroup) \
int virCgroupGetValueRaw(const char *path,
char **value);
-int virCgroupSetValueStr(virCgroupPtr group,
+int virCgroupSetValueStr(virCgroup *group,
int controller,
const char *key,
const char *value);
-int virCgroupGetValueStr(virCgroupPtr group,
+int virCgroupGetValueStr(virCgroup *group,
int controller,
const char *key,
char **value);
-int virCgroupSetValueU64(virCgroupPtr group,
+int virCgroupSetValueU64(virCgroup *group,
int controller,
const char *key,
unsigned long long int value);
-int virCgroupGetValueU64(virCgroupPtr group,
+int virCgroupGetValueU64(virCgroup *group,
int controller,
const char *key,
unsigned long long int *value);
-int virCgroupSetValueI64(virCgroupPtr group,
+int virCgroupSetValueI64(virCgroup *group,
int controller,
const char *key,
long long int value);
-int virCgroupGetValueI64(virCgroupPtr group,
+int virCgroupGetValueI64(virCgroup *group,
int controller,
const char *key,
long long int *value);
int virCgroupNewPartition(const char *path,
bool create,
int controllers,
- virCgroupPtr *group)
+ virCgroup **group)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
-int virCgroupNewDomainPartition(virCgroupPtr partition,
+int virCgroupNewDomainPartition(virCgroup *partition,
const char *driver,
const char *name,
- virCgroupPtr *group)
+ virCgroup **group)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4);
int virCgroupRemoveRecursively(char *grppath);
-int virCgroupKillRecursiveInternal(virCgroupPtr group,
+int virCgroupKillRecursiveInternal(virCgroup *group,
int signum,
GHashTable *pids,
int controller,
static bool
-virCgroupV1ValidateMachineGroup(virCgroupPtr group,
+virCgroupV1ValidateMachineGroup(virCgroup *group,
const char *name,
const char *drivername,
const char *machinename)
static int
-virCgroupV1CopyMounts(virCgroupPtr group,
- virCgroupPtr parent)
+virCgroupV1CopyMounts(virCgroup *group,
+ virCgroup *parent)
{
size_t i;
for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
static int
-virCgroupV1CopyPlacement(virCgroupPtr group,
+virCgroupV1CopyPlacement(virCgroup *group,
const char *path,
- virCgroupPtr parent)
+ virCgroup *parent)
{
size_t i;
for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
static int
virCgroupV1ResolveMountLink(const char *mntDir,
const char *typeStr,
- virCgroupV1ControllerPtr controller)
+ virCgroupV1Controller *controller)
{
g_autofree char *linkSrc = NULL;
g_autofree char *tmp = NULL;
static int
-virCgroupV1DetectMounts(virCgroupPtr group,
+virCgroupV1DetectMounts(virCgroup *group,
const char *mntType,
const char *mntOpts,
const char *mntDir)
* once. We need to save the results of the last one,
* and we need to be careful to release the memory used
* by previous processing. */
- virCgroupV1ControllerPtr controller = &group->legacy[i];
+ virCgroupV1Controller *controller = &group->legacy[i];
VIR_FREE(controller->mountPoint);
VIR_FREE(controller->linkPoint);
static int
-virCgroupV1DetectPlacement(virCgroupPtr group,
+virCgroupV1DetectPlacement(virCgroup *group,
const char *path,
const char *controllers,
const char *selfpath)
static int
-virCgroupV1SetPlacement(virCgroupPtr group,
+virCgroupV1SetPlacement(virCgroup *group,
const char *path)
{
size_t i;
static int
-virCgroupV1ValidatePlacement(virCgroupPtr group,
+virCgroupV1ValidatePlacement(virCgroup *group,
pid_t pid)
{
size_t i;
static char *
-virCgroupV1StealPlacement(virCgroupPtr group)
+virCgroupV1StealPlacement(virCgroup *group)
{
return g_steal_pointer(&group->legacy[VIR_CGROUP_CONTROLLER_SYSTEMD].placement);
}
static int
-virCgroupV1DetectControllers(virCgroupPtr group,
+virCgroupV1DetectControllers(virCgroup *group,
int controllers,
- virCgroupPtr parent G_GNUC_UNUSED,
+ virCgroup *parent G_GNUC_UNUSED,
int detected)
{
size_t i;
static bool
-virCgroupV1HasController(virCgroupPtr group,
+virCgroupV1HasController(virCgroup *group,
int controller)
{
return group->legacy[controller].mountPoint != NULL;
static int
-virCgroupV1GetAnyController(virCgroupPtr group)
+virCgroupV1GetAnyController(virCgroup *group)
{
size_t i;
static int
-virCgroupV1PathOfController(virCgroupPtr group,
+virCgroupV1PathOfController(virCgroup *group,
int controller,
const char *key,
char **path)
static int
-virCgroupV1CpuSetInherit(virCgroupPtr parent,
- virCgroupPtr group)
+virCgroupV1CpuSetInherit(virCgroup *parent,
+ virCgroup *group)
{
size_t i;
const char *inherit_values[] = {
static int
-virCgroupV1SetMemoryUseHierarchy(virCgroupPtr group)
+virCgroupV1SetMemoryUseHierarchy(virCgroup *group)
{
unsigned long long value;
const char *filename = "memory.use_hierarchy";
static int
-virCgroupV1MakeGroup(virCgroupPtr parent,
- virCgroupPtr group,
+virCgroupV1MakeGroup(virCgroup *parent,
+ virCgroup *group,
bool create,
pid_t pid G_GNUC_UNUSED,
unsigned int flags)
static bool
-virCgroupV1Exists(virCgroupPtr group)
+virCgroupV1Exists(virCgroup *group)
{
size_t i;
static int
-virCgroupV1Remove(virCgroupPtr group)
+virCgroupV1Remove(virCgroup *group)
{
int rc = 0;
size_t i;
static int
-virCgroupV1AddTask(virCgroupPtr group,
+virCgroupV1AddTask(virCgroup *group,
pid_t pid,
unsigned int flags)
{
static int
-virCgroupV1HasEmptyTasks(virCgroupPtr cgroup,
+virCgroupV1HasEmptyTasks(virCgroup *cgroup,
int controller)
{
int ret = -1;
static int
-virCgroupV1KillRecursive(virCgroupPtr group,
+virCgroupV1KillRecursive(virCgroup *group,
int signum,
GHashTable *pids)
{
static char *
-virCgroupV1IdentifyRoot(virCgroupPtr group)
+virCgroupV1IdentifyRoot(virCgroup *group)
{
char *ret = NULL;
size_t i;
static int
-virCgroupV1BindMount(virCgroupPtr group,
+virCgroupV1BindMount(virCgroup *group,
const char *oldroot,
const char *mountopts)
{
static int
-virCgroupV1SetOwner(virCgroupPtr cgroup,
+virCgroupV1SetOwner(virCgroup *cgroup,
uid_t uid,
gid_t gid,
int controllers)
static int
-virCgroupV1SetBlkioWeight(virCgroupPtr group,
+virCgroupV1SetBlkioWeight(virCgroup *group,
unsigned int weight)
{
g_autofree char *path = NULL;
static int
-virCgroupV1GetBlkioWeight(virCgroupPtr group,
+virCgroupV1GetBlkioWeight(virCgroup *group,
unsigned int *weight)
{
g_autofree char *path = NULL;
static int
-virCgroupV1GetBlkioIoServiced(virCgroupPtr group,
+virCgroupV1GetBlkioIoServiced(virCgroup *group,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
static int
-virCgroupV1GetBlkioIoDeviceServiced(virCgroupPtr group,
+virCgroupV1GetBlkioIoDeviceServiced(virCgroup *group,
const char *path,
long long *bytes_read,
long long *bytes_write,
static int
-virCgroupV1SetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupV1SetBlkioDeviceWeight(virCgroup *group,
const char *devPath,
unsigned int weight)
{
static int
-virCgroupV1GetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupV1GetBlkioDeviceWeight(virCgroup *group,
const char *devPath,
unsigned int *weight)
{
static int
-virCgroupV1SetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupV1SetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int riops)
{
static int
-virCgroupV1GetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupV1GetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int *riops)
{
static int
-virCgroupV1SetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupV1SetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int wiops)
{
static int
-virCgroupV1GetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupV1GetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int *wiops)
{
static int
-virCgroupV1SetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupV1SetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long rbps)
{
static int
-virCgroupV1GetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupV1GetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long *rbps)
{
static int
-virCgroupV1SetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupV1SetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long wbps)
{
static int
-virCgroupV1GetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupV1GetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long *wbps)
{
static int
-virCgroupV1SetMemory(virCgroupPtr group,
+virCgroupV1SetMemory(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV1GetMemoryStat(virCgroupPtr group,
+virCgroupV1GetMemoryStat(virCgroup *group,
unsigned long long *cache,
unsigned long long *activeAnon,
unsigned long long *inactiveAnon,
static int
-virCgroupV1GetMemoryUsage(virCgroupPtr group,
+virCgroupV1GetMemoryUsage(virCgroup *group,
unsigned long *kb)
{
long long unsigned int usage_in_bytes;
static int
-virCgroupV1SetMemoryHardLimit(virCgroupPtr group,
+virCgroupV1SetMemoryHardLimit(virCgroup *group,
unsigned long long kb)
{
return virCgroupV1SetMemory(group, kb);
static int
-virCgroupV1GetMemoryHardLimit(virCgroupPtr group,
+virCgroupV1GetMemoryHardLimit(virCgroup *group,
unsigned long long *kb)
{
long long unsigned int limit_in_bytes;
static int
-virCgroupV1SetMemorySoftLimit(virCgroupPtr group,
+virCgroupV1SetMemorySoftLimit(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV1GetMemorySoftLimit(virCgroupPtr group,
+virCgroupV1GetMemorySoftLimit(virCgroup *group,
unsigned long long *kb)
{
long long unsigned int limit_in_bytes;
static int
-virCgroupV1SetMemSwapHardLimit(virCgroupPtr group,
+virCgroupV1SetMemSwapHardLimit(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV1GetMemSwapHardLimit(virCgroupPtr group,
+virCgroupV1GetMemSwapHardLimit(virCgroup *group,
unsigned long long *kb)
{
long long unsigned int limit_in_bytes;
static int
-virCgroupV1GetMemSwapUsage(virCgroupPtr group,
+virCgroupV1GetMemSwapUsage(virCgroup *group,
unsigned long long *kb)
{
long long unsigned int usage_in_bytes;
static int
-virCgroupV1AllowDevice(virCgroupPtr group,
+virCgroupV1AllowDevice(virCgroup *group,
char type,
int major,
int minor,
static int
-virCgroupV1DenyDevice(virCgroupPtr group,
+virCgroupV1DenyDevice(virCgroup *group,
char type,
int major,
int minor,
static int
-virCgroupV1AllowAllDevices(virCgroupPtr group,
+virCgroupV1AllowAllDevices(virCgroup *group,
int perms)
{
if (virCgroupV1AllowDevice(group, 'b', -1, -1, perms) < 0)
static int
-virCgroupV1DenyAllDevices(virCgroupPtr group)
+virCgroupV1DenyAllDevices(virCgroup *group)
{
return virCgroupSetValueStr(group,
VIR_CGROUP_CONTROLLER_DEVICES,
static int
-virCgroupV1SetCpuShares(virCgroupPtr group,
+virCgroupV1SetCpuShares(virCgroup *group,
unsigned long long shares)
{
if (shares < VIR_CGROUP_CPU_SHARES_MIN ||
static int
-virCgroupV1GetCpuShares(virCgroupPtr group,
+virCgroupV1GetCpuShares(virCgroup *group,
unsigned long long *shares)
{
return virCgroupGetValueU64(group,
static int
-virCgroupV1SetCpuCfsPeriod(virCgroupPtr group,
+virCgroupV1SetCpuCfsPeriod(virCgroup *group,
unsigned long long cfs_period)
{
if (cfs_period < VIR_CGROUP_CPU_PERIOD_MIN ||
static int
-virCgroupV1GetCpuCfsPeriod(virCgroupPtr group,
+virCgroupV1GetCpuCfsPeriod(virCgroup *group,
unsigned long long *cfs_period)
{
return virCgroupGetValueU64(group,
static int
-virCgroupV1SetCpuCfsQuota(virCgroupPtr group,
+virCgroupV1SetCpuCfsQuota(virCgroup *group,
long long cfs_quota)
{
if (cfs_quota >= 0 &&
static int
-virCgroupV1GetCpuCfsQuota(virCgroupPtr group,
+virCgroupV1GetCpuCfsQuota(virCgroup *group,
long long *cfs_quota)
{
return virCgroupGetValueI64(group,
static bool
-virCgroupV1SupportsCpuBW(virCgroupPtr cgroup)
+virCgroupV1SupportsCpuBW(virCgroup *cgroup)
{
g_autofree char *path = NULL;
static int
-virCgroupV1GetCpuacctUsage(virCgroupPtr group,
+virCgroupV1GetCpuacctUsage(virCgroup *group,
unsigned long long *usage)
{
return virCgroupGetValueU64(group,
static int
-virCgroupV1GetCpuacctPercpuUsage(virCgroupPtr group,
+virCgroupV1GetCpuacctPercpuUsage(virCgroup *group,
char **usage)
{
return virCgroupGetValueStr(group, VIR_CGROUP_CONTROLLER_CPUACCT,
static int
-virCgroupV1GetCpuacctStat(virCgroupPtr group,
+virCgroupV1GetCpuacctStat(virCgroup *group,
unsigned long long *user,
unsigned long long *sys)
{
static int
-virCgroupV1SetFreezerState(virCgroupPtr group,
+virCgroupV1SetFreezerState(virCgroup *group,
const char *state)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV1GetFreezerState(virCgroupPtr group,
+virCgroupV1GetFreezerState(virCgroup *group,
char **state)
{
return virCgroupGetValueStr(group,
static int
-virCgroupV1SetCpusetMems(virCgroupPtr group,
+virCgroupV1SetCpusetMems(virCgroup *group,
const char *mems)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV1GetCpusetMems(virCgroupPtr group,
+virCgroupV1GetCpusetMems(virCgroup *group,
char **mems)
{
return virCgroupGetValueStr(group,
static int
-virCgroupV1SetCpusetMemoryMigrate(virCgroupPtr group,
+virCgroupV1SetCpusetMemoryMigrate(virCgroup *group,
bool migrate)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV1GetCpusetMemoryMigrate(virCgroupPtr group,
+virCgroupV1GetCpusetMemoryMigrate(virCgroup *group,
bool *migrate)
{
unsigned long long value = 0;
static int
-virCgroupV1SetCpusetCpus(virCgroupPtr group,
+virCgroupV1SetCpusetCpus(virCgroup *group,
const char *cpus)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV1GetCpusetCpus(virCgroupPtr group,
+virCgroupV1GetCpusetCpus(virCgroup *group,
char **cpus)
{
return virCgroupGetValueStr(group,
static bool
-virCgroupV2ValidateMachineGroup(virCgroupPtr group,
+virCgroupV2ValidateMachineGroup(virCgroup *group,
const char *name G_GNUC_UNUSED,
const char *drivername,
const char *machinename)
static int
-virCgroupV2CopyMounts(virCgroupPtr group,
- virCgroupPtr parent)
+virCgroupV2CopyMounts(virCgroup *group,
+ virCgroup *parent)
{
group->unified.mountPoint = g_strdup(parent->unified.mountPoint);
return 0;
static int
-virCgroupV2CopyPlacement(virCgroupPtr group,
+virCgroupV2CopyPlacement(virCgroup *group,
const char *path,
- virCgroupPtr parent)
+ virCgroup *parent)
{
bool delim = STREQ(parent->unified.placement, "/") || STREQ(path, "");
static int
-virCgroupV2DetectMounts(virCgroupPtr group,
+virCgroupV2DetectMounts(virCgroup *group,
const char *mntType,
const char *mntOpts G_GNUC_UNUSED,
const char *mntDir)
static int
-virCgroupV2DetectPlacement(virCgroupPtr group,
+virCgroupV2DetectPlacement(virCgroup *group,
const char *path,
const char *controllers,
const char *selfpath)
static int
-virCgroupV2SetPlacement(virCgroupPtr group,
+virCgroupV2SetPlacement(virCgroup *group,
const char *path)
{
group->unified.placement = g_strdup(path);
static int
-virCgroupV2ValidatePlacement(virCgroupPtr group,
+virCgroupV2ValidatePlacement(virCgroup *group,
pid_t pid G_GNUC_UNUSED)
{
if (!group->unified.placement) {
static char *
-virCgroupV2StealPlacement(virCgroupPtr group)
+virCgroupV2StealPlacement(virCgroup *group)
{
return g_steal_pointer(&group->unified.placement);
}
static int
-virCgroupV2ParseControllersFile(virCgroupPtr group,
- virCgroupPtr parent)
+virCgroupV2ParseControllersFile(virCgroup *group,
+ virCgroup *parent)
{
int rc;
g_autofree char *contStr = NULL;
static int
-virCgroupV2DetectControllers(virCgroupPtr group,
+virCgroupV2DetectControllers(virCgroup *group,
int controllers,
- virCgroupPtr parent,
+ virCgroup *parent,
int detected)
{
size_t i;
static bool
-virCgroupV2HasController(virCgroupPtr group,
+virCgroupV2HasController(virCgroup *group,
int controller)
{
return group->unified.controllers & (1 << controller);
static int
-virCgroupV2GetAnyController(virCgroupPtr group)
+virCgroupV2GetAnyController(virCgroup *group)
{
/* The least significant bit is position 1. */
return __builtin_ffs(group->unified.controllers) - 1;
static int
-virCgroupV2PathOfController(virCgroupPtr group,
+virCgroupV2PathOfController(virCgroup *group,
int controller,
const char *key,
char **path)
* 0 on success
*/
static int
-virCgroupV2EnableController(virCgroupPtr group,
- virCgroupPtr parent,
+virCgroupV2EnableController(virCgroup *group,
+ virCgroup *parent,
int controller,
bool report)
{
static int
-virCgroupV2AddTask(virCgroupPtr group,
+virCgroupV2AddTask(virCgroup *group,
pid_t pid,
unsigned int flags);
static int
-virCgroupV2MakeGroup(virCgroupPtr parent,
- virCgroupPtr group,
+virCgroupV2MakeGroup(virCgroup *parent,
+ virCgroup *group,
bool create,
pid_t pid,
unsigned int flags)
static bool
-virCgroupV2Exists(virCgroupPtr group)
+virCgroupV2Exists(virCgroup *group)
{
g_autofree char *path = NULL;
int controller;
static int
-virCgroupV2Remove(virCgroupPtr group)
+virCgroupV2Remove(virCgroup *group)
{
g_autofree char *grppath = NULL;
int controller;
static int
-virCgroupV2AddTask(virCgroupPtr group,
+virCgroupV2AddTask(virCgroup *group,
pid_t pid,
unsigned int flags)
{
static int
-virCgroupV2HasEmptyTasks(virCgroupPtr cgroup,
+virCgroupV2HasEmptyTasks(virCgroup *cgroup,
int controller)
{
int ret = -1;
static int
-virCgroupV2KillRecursive(virCgroupPtr group,
+virCgroupV2KillRecursive(virCgroup *group,
int signum,
GHashTable *pids)
{
static int
-virCgroupV2BindMount(virCgroupPtr group,
+virCgroupV2BindMount(virCgroup *group,
const char *oldroot,
const char *mountopts G_GNUC_UNUSED)
{
static int
-virCgroupV2SetOwner(virCgroupPtr cgroup,
+virCgroupV2SetOwner(virCgroup *cgroup,
uid_t uid,
gid_t gid,
int controllers G_GNUC_UNUSED)
static int
-virCgroupV2SetBlkioWeight(virCgroupPtr group,
+virCgroupV2SetBlkioWeight(virCgroup *group,
unsigned int weight)
{
g_autofree char *path = NULL;
static int
-virCgroupV2GetBlkioWeight(virCgroupPtr group,
+virCgroupV2GetBlkioWeight(virCgroup *group,
unsigned int *weight)
{
g_autofree char *path = NULL;
static int
-virCgroupV2GetBlkioIoServiced(virCgroupPtr group,
+virCgroupV2GetBlkioIoServiced(virCgroup *group,
long long *bytes_read,
long long *bytes_write,
long long *requests_read,
static int
-virCgroupV2GetBlkioIoDeviceServiced(virCgroupPtr group,
+virCgroupV2GetBlkioIoDeviceServiced(virCgroup *group,
const char *path,
long long *bytes_read,
long long *bytes_write,
static int
-virCgroupV2SetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupV2SetBlkioDeviceWeight(virCgroup *group,
const char *devPath,
unsigned int weight)
{
static int
-virCgroupV2GetBlkioDeviceWeight(virCgroupPtr group,
+virCgroupV2GetBlkioDeviceWeight(virCgroup *group,
const char *devPath,
unsigned int *weight)
{
static int
-virCgroupV2SetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupV2SetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int riops)
{
static int
-virCgroupV2GetBlkioDeviceReadIops(virCgroupPtr group,
+virCgroupV2GetBlkioDeviceReadIops(virCgroup *group,
const char *path,
unsigned int *riops)
{
static int
-virCgroupV2SetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupV2SetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int wiops)
{
static int
-virCgroupV2GetBlkioDeviceWriteIops(virCgroupPtr group,
+virCgroupV2GetBlkioDeviceWriteIops(virCgroup *group,
const char *path,
unsigned int *wiops)
{
static int
-virCgroupV2SetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupV2SetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long rbps)
{
static int
-virCgroupV2GetBlkioDeviceReadBps(virCgroupPtr group,
+virCgroupV2GetBlkioDeviceReadBps(virCgroup *group,
const char *path,
unsigned long long *rbps)
{
static int
-virCgroupV2SetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupV2SetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long wbps)
{
static int
-virCgroupV2GetBlkioDeviceWriteBps(virCgroupPtr group,
+virCgroupV2GetBlkioDeviceWriteBps(virCgroup *group,
const char *path,
unsigned long long *wbps)
{
static int
-virCgroupV2SetMemory(virCgroupPtr group,
+virCgroupV2SetMemory(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV2GetMemoryStat(virCgroupPtr group,
+virCgroupV2GetMemoryStat(virCgroup *group,
unsigned long long *cache,
unsigned long long *activeAnon,
unsigned long long *inactiveAnon,
static int
-virCgroupV2GetMemoryUsage(virCgroupPtr group,
+virCgroupV2GetMemoryUsage(virCgroup *group,
unsigned long *kb)
{
unsigned long long usage_in_bytes;
static int
-virCgroupV2SetMemoryHardLimit(virCgroupPtr group,
+virCgroupV2SetMemoryHardLimit(virCgroup *group,
unsigned long long kb)
{
return virCgroupV2SetMemory(group, kb);
static int
-virCgroupV2GetMemoryHardLimit(virCgroupPtr group,
+virCgroupV2GetMemoryHardLimit(virCgroup *group,
unsigned long long *kb)
{
g_autofree char *value = NULL;
static int
-virCgroupV2SetMemorySoftLimit(virCgroupPtr group,
+virCgroupV2SetMemorySoftLimit(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV2GetMemorySoftLimit(virCgroupPtr group,
+virCgroupV2GetMemorySoftLimit(virCgroup *group,
unsigned long long *kb)
{
g_autofree char *value = NULL;
static int
-virCgroupV2SetMemSwapHardLimit(virCgroupPtr group,
+virCgroupV2SetMemSwapHardLimit(virCgroup *group,
unsigned long long kb)
{
unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
static int
-virCgroupV2GetMemSwapHardLimit(virCgroupPtr group,
+virCgroupV2GetMemSwapHardLimit(virCgroup *group,
unsigned long long *kb)
{
g_autofree char *value = NULL;
static int
-virCgroupV2GetMemSwapUsage(virCgroupPtr group,
+virCgroupV2GetMemSwapUsage(virCgroup *group,
unsigned long long *kb)
{
unsigned long long usage_in_bytes;
static int
-virCgroupV2SetCpuShares(virCgroupPtr group,
+virCgroupV2SetCpuShares(virCgroup *group,
unsigned long long shares)
{
if (shares < VIR_CGROUP_CPU_SHARES_MIN ||
static int
-virCgroupV2GetCpuShares(virCgroupPtr group,
+virCgroupV2GetCpuShares(virCgroup *group,
unsigned long long *shares)
{
return virCgroupGetValueU64(group,
static int
-virCgroupV2SetCpuCfsPeriod(virCgroupPtr group,
+virCgroupV2SetCpuCfsPeriod(virCgroup *group,
unsigned long long cfs_period)
{
g_autofree char *value = NULL;
static int
-virCgroupV2GetCpuCfsPeriod(virCgroupPtr group,
+virCgroupV2GetCpuCfsPeriod(virCgroup *group,
unsigned long long *cfs_period)
{
g_autofree char *str = NULL;
static int
-virCgroupV2SetCpuCfsQuota(virCgroupPtr group,
+virCgroupV2SetCpuCfsQuota(virCgroup *group,
long long cfs_quota)
{
if (cfs_quota >= 0 &&
static int
-virCgroupV2GetCpuCfsQuota(virCgroupPtr group,
+virCgroupV2GetCpuCfsQuota(virCgroup *group,
long long *cfs_quota)
{
g_autofree char *str = NULL;
static bool
-virCgroupV2SupportsCpuBW(virCgroupPtr cgroup)
+virCgroupV2SupportsCpuBW(virCgroup *cgroup)
{
g_autofree char *path = NULL;
static int
-virCgroupV2GetCpuacctUsage(virCgroupPtr group,
+virCgroupV2GetCpuacctUsage(virCgroup *group,
unsigned long long *usage)
{
g_autofree char *str = NULL;
static int
-virCgroupV2GetCpuacctStat(virCgroupPtr group,
+virCgroupV2GetCpuacctStat(virCgroup *group,
unsigned long long *user,
unsigned long long *sys)
{
static int
-virCgroupV2SetCpusetMems(virCgroupPtr group,
+virCgroupV2SetCpusetMems(virCgroup *group,
const char *mems)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV2GetCpusetMems(virCgroupPtr group,
+virCgroupV2GetCpusetMems(virCgroup *group,
char **mems)
{
return virCgroupGetValueStr(group,
static int
-virCgroupV2SetCpusetMemoryMigrate(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupV2SetCpusetMemoryMigrate(virCgroup *group G_GNUC_UNUSED,
bool migrate G_GNUC_UNUSED)
{
return 0;
static int
-virCgroupV2GetCpusetMemoryMigrate(virCgroupPtr group G_GNUC_UNUSED,
+virCgroupV2GetCpusetMemoryMigrate(virCgroup *group G_GNUC_UNUSED,
bool *migrate)
{
*migrate = true;
static int
-virCgroupV2SetCpusetCpus(virCgroupPtr group,
+virCgroupV2SetCpusetCpus(virCgroup *group,
const char *cpus)
{
return virCgroupSetValueStr(group,
static int
-virCgroupV2GetCpusetCpus(virCgroupPtr group,
+virCgroupV2GetCpusetCpus(virCgroup *group,
char **cpus)
{
return virCgroupGetValueStr(group,
static int
-virCgroupV2AllowDevice(virCgroupPtr group,
+virCgroupV2AllowDevice(virCgroup *group,
char type,
int major,
int minor,
static int
-virCgroupV2DenyDevice(virCgroupPtr group,
+virCgroupV2DenyDevice(virCgroup *group,
char type,
int major,
int minor,
static int
-virCgroupV2AllowAllDevices(virCgroupPtr group,
+virCgroupV2AllowAllDevices(virCgroup *group,
int perms)
{
if (virCgroupV2DevicesPrepareProg(group) < 0)
static int
-virCgroupV2DenyAllDevices(virCgroupPtr group)
+virCgroupV2DenyAllDevices(virCgroup *group)
{
if (virCgroupV2DevicesDetectProg(group) < 0)
return -1;
#if WITH_DECL_BPF_CGROUP_DEVICE
bool
-virCgroupV2DevicesAvailable(virCgroupPtr group)
+virCgroupV2DevicesAvailable(virCgroup *group)
{
VIR_AUTOCLOSE cgroupfd = -1;
unsigned int progCnt = 0;
static int
-virCgroupV2DevicesAttachProg(virCgroupPtr group,
+virCgroupV2DevicesAttachProg(virCgroup *group,
int mapfd,
size_t max)
{
# define MAX_PROG_IDS 10
int
-virCgroupV2DevicesDetectProg(virCgroupPtr group)
+virCgroupV2DevicesDetectProg(virCgroup *group)
{
g_autofree char *path = NULL;
VIR_AUTOCLOSE cgroupfd = -1;
int
-virCgroupV2DevicesCreateProg(virCgroupPtr group)
+virCgroupV2DevicesCreateProg(virCgroup *group)
{
int mapfd = -1;
int
-virCgroupV2DevicesPrepareProg(virCgroupPtr group)
+virCgroupV2DevicesPrepareProg(virCgroup *group)
{
if (virCgroupV2DevicesDetectProg(group) < 0)
return -1;
int
-virCgroupV2DevicesRemoveProg(virCgroupPtr group)
+virCgroupV2DevicesRemoveProg(virCgroup *group)
{
if (virCgroupV2DevicesDetectProg(group) < 0)
return -1;
}
#else /* !WITH_DECL_BPF_CGROUP_DEVICE */
bool
-virCgroupV2DevicesAvailable(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesAvailable(virCgroup *group G_GNUC_UNUSED)
{
return false;
}
int
-virCgroupV2DevicesDetectProg(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesDetectProg(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("cgroups v2 BPF devices not supported "
int
-virCgroupV2DevicesCreateProg(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesCreateProg(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("cgroups v2 BPF devices not supported "
int
-virCgroupV2DevicesPrepareProg(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesPrepareProg(virCgroup *group G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("cgroups v2 BPF devices not supported "
int
-virCgroupV2DevicesRemoveProg(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesRemoveProg(virCgroup *group G_GNUC_UNUSED)
{
return 0;
}
#include "vircgroup.h"
bool
-virCgroupV2DevicesAvailable(virCgroupPtr group)
+virCgroupV2DevicesAvailable(virCgroup *group)
G_GNUC_NO_INLINE;
int
-virCgroupV2DevicesDetectProg(virCgroupPtr group);
+virCgroupV2DevicesDetectProg(virCgroup *group);
int
-virCgroupV2DevicesCreateProg(virCgroupPtr group);
+virCgroupV2DevicesCreateProg(virCgroup *group);
int
-virCgroupV2DevicesPrepareProg(virCgroupPtr group);
+virCgroupV2DevicesPrepareProg(virCgroup *group);
int
-virCgroupV2DevicesRemoveProg(virCgroupPtr group);
+virCgroupV2DevicesRemoveProg(virCgroup *group);
uint32_t
virCgroupV2DevicesGetPerms(int perms,
};
typedef struct _virCommandFD virCommandFD;
-typedef virCommandFD *virCommandFDPtr;
-
struct _virCommandFD {
int fd;
unsigned int flags;
};
typedef struct _virCommandSendBuffer virCommandSendBuffer;
-typedef virCommandSendBuffer *virCommandSendBufferPtr;
-
struct _virCommandSendBuffer {
int fd;
unsigned char *buffer;
char *pwd;
size_t npassfd;
- virCommandFDPtr passfd;
+ virCommandFD *passfd;
unsigned int flags;
int *outfdptr;
int *errfdptr;
- virThreadPtr asyncioThread;
+ virThread *asyncioThread;
bool handshake;
int handshakeWait[2];
#endif
int mask;
- virCommandSendBufferPtr sendBuffers;
+ virCommandSendBuffer *sendBuffers;
size_t numSendBuffers;
};
/* See virCommandSetDryRun for description for this variable */
-static virBufferPtr dryRunBuffer;
+static virBuffer *dryRunBuffer;
static bool dryRunBufferArgLinebreaks;
static bool dryRunBufferCommandStripPath;
static virCommandDryRunCallback dryRunCallback;
static bool
-virCommandHasError(virCommandPtr cmd)
+virCommandHasError(virCommand *cmd)
{
return !cmd || cmd->has_error != 0;
}
static int
-virCommandRaiseError(virCommandPtr cmd)
+virCommandRaiseError(virCommand *cmd)
{
if (!cmd || cmd->has_error != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
* false otherwise.
*/
static bool
-virCommandFDIsSet(virCommandPtr cmd,
+virCommandFDIsSet(virCommand *cmd,
int fd)
{
size_t i = 0;
* by FD_SETSIZE.
*/
static void
-virCommandFDSet(virCommandPtr cmd,
+virCommandFDSet(virCommand *cmd,
int fd,
unsigned int flags)
{
* completed its pre-exec initialization.
*/
static int
-virCommandHandshakeChild(virCommandPtr cmd)
+virCommandHandshakeChild(virCommand *cmd)
{
char c = '1';
int rv;
}
static int
-virExecCommon(virCommandPtr cmd, gid_t *groups, int ngroups)
+virExecCommon(virCommand *cmd, gid_t *groups, int ngroups)
{
if (cmd->uid != (uid_t)-1 || cmd->gid != (gid_t)-1 ||
cmd->capabilities || (cmd->flags & VIR_EXEC_CLEAR_CAPS)) {
* onto child process (well, the one we will exec soon since this
* is called from the child). */
static int
-virCommandMassCloseGetFDsLinux(virCommandPtr cmd G_GNUC_UNUSED,
- virBitmapPtr fds)
+virCommandMassCloseGetFDsLinux(virCommand *cmd G_GNUC_UNUSED,
+ virBitmap *fds)
{
g_autoptr(DIR) dp = NULL;
struct dirent *entry;
# else /* !__linux__ */
static int
-virCommandMassCloseGetFDsGeneric(virCommandPtr cmd G_GNUC_UNUSED,
- virBitmapPtr fds)
+virCommandMassCloseGetFDsGeneric(virCommand *cmd G_GNUC_UNUSED,
+ virBitmap *fds)
{
virBitmapSetAll(fds);
return 0;
# ifdef __FreeBSD__
static int
-virCommandMassClose(virCommandPtr cmd,
+virCommandMassClose(virCommand *cmd,
int childin,
int childout,
int childerr)
# else /* ! __FreeBSD__ */
static int
-virCommandMassClose(virCommandPtr cmd,
+virCommandMassClose(virCommand *cmd,
int childin,
int childout,
int childerr)
/*
* virExec:
- * @cmd virCommandPtr containing all information about the program to
+ * @cmd virCommand * containing all information about the program to
* exec.
*/
static int
-virExec(virCommandPtr cmd)
+virExec(virCommand *cmd)
{
pid_t pid;
int null = -1;
* it will be found via a PATH search of the parent's PATH (and not
* any altered PATH set by virCommandAddEnv* commands).
*/
-virCommandPtr
+virCommand *
virCommandNew(const char *binary)
{
const char *const args[] = { binary, NULL };
* set of args, taking binary from args[0]. More arguments can
* be added later. @args[0] is handled like @binary of virCommandNew.
*/
-virCommandPtr
+virCommand *
virCommandNewArgs(const char *const*args)
{
- virCommandPtr cmd;
+ virCommand *cmd;
cmd = g_new0(virCommand, 1);
* list of args, starting with the binary to run. More arguments can
* be added later. @binary is handled as in virCommandNew.
*/
-virCommandPtr
+virCommand *
virCommandNewArgList(const char *binary, ...)
{
- virCommandPtr cmd;
+ virCommand *cmd;
va_list list;
va_start(list, binary);
* Create a new command with a NULL terminated
* variable argument list. @binary is handled as in virCommandNew.
*/
-virCommandPtr
+virCommand *
virCommandNewVAList(const char *binary, va_list list)
{
- virCommandPtr cmd = virCommandNew(binary);
+ virCommand *cmd = virCommandNew(binary);
const char *arg;
if (virCommandHasError(cmd))
* should cease using the @fd when this call completes
*/
void
-virCommandPassFDIndex(virCommandPtr cmd, int fd, unsigned int flags, size_t *idx)
+virCommandPassFDIndex(virCommand *cmd, int fd, unsigned int flags, size_t *idx)
{
if (!cmd) {
VIR_COMMAND_MAYBE_CLOSE_FD(fd, flags);
* should cease using the @fd when this call completes
*/
void
-virCommandPassFD(virCommandPtr cmd, int fd, unsigned int flags)
+virCommandPassFD(virCommand *cmd, int fd, unsigned int flags)
{
virCommandPassFDIndex(cmd, fd, flags, NULL);
}
* -1 otherwise.
*/
int
-virCommandPassFDGetFDIndex(virCommandPtr cmd, int fd)
+virCommandPassFDGetFDIndex(virCommand *cmd, int fd)
{
size_t i = 0;
* pidfile.
*/
void
-virCommandSetPidFile(virCommandPtr cmd, const char *pidfile)
+virCommandSetPidFile(virCommand *cmd, const char *pidfile)
{
if (virCommandHasError(cmd))
return;
gid_t
-virCommandGetGID(virCommandPtr cmd)
+virCommandGetGID(virCommand *cmd)
{
return cmd->gid;
}
uid_t
-virCommandGetUID(virCommandPtr cmd)
+virCommandGetUID(virCommand *cmd)
{
return cmd->uid;
}
void
-virCommandSetGID(virCommandPtr cmd, gid_t gid)
+virCommandSetGID(virCommand *cmd, gid_t gid)
{
if (virCommandHasError(cmd))
return;
}
void
-virCommandSetUID(virCommandPtr cmd, uid_t uid)
+virCommandSetUID(virCommand *cmd, uid_t uid)
{
if (virCommandHasError(cmd))
return;
}
void
-virCommandSetMaxMemLock(virCommandPtr cmd, unsigned long long bytes)
+virCommandSetMaxMemLock(virCommand *cmd, unsigned long long bytes)
{
if (virCommandHasError(cmd))
return;
}
void
-virCommandSetMaxProcesses(virCommandPtr cmd, unsigned int procs)
+virCommandSetMaxProcesses(virCommand *cmd, unsigned int procs)
{
if (virCommandHasError(cmd))
return;
}
void
-virCommandSetMaxFiles(virCommandPtr cmd, unsigned int files)
+virCommandSetMaxFiles(virCommand *cmd, unsigned int files)
{
if (virCommandHasError(cmd))
return;
cmd->setMaxFiles = true;
}
-void virCommandSetMaxCoreSize(virCommandPtr cmd, unsigned long long bytes)
+void virCommandSetMaxCoreSize(virCommand *cmd, unsigned long long bytes)
{
if (virCommandHasError(cmd))
return;
cmd->setMaxCore = true;
}
-void virCommandSetUmask(virCommandPtr cmd, int mask)
+void virCommandSetUmask(virCommand *cmd, int mask)
{
if (virCommandHasError(cmd))
return;
* Remove all capabilities from the child, after any hooks have been run.
*/
void
-virCommandClearCaps(virCommandPtr cmd)
+virCommandClearCaps(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* Allow specific capabilities
*/
void
-virCommandAllowCap(virCommandPtr cmd,
+virCommandAllowCap(virCommand *cmd,
int capability)
{
if (virCommandHasError(cmd))
* NULL, nothing will be done.
*/
void
-virCommandSetSELinuxLabel(virCommandPtr cmd,
+virCommandSetSELinuxLabel(virCommand *cmd,
const char *label G_GNUC_UNUSED)
{
if (virCommandHasError(cmd))
* configured into libvirt, or if profile is NULL, nothing will be done.
*/
void
-virCommandSetAppArmorProfile(virCommandPtr cmd,
+virCommandSetAppArmorProfile(virCommand *cmd,
const char *profile G_GNUC_UNUSED)
{
if (virCommandHasError(cmd))
* complete as soon as the daemon grandchild has started.
*/
void
-virCommandDaemonize(virCommandPtr cmd)
+virCommandDaemonize(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* as non-blocking in the parent.
*/
void
-virCommandNonblockingFDs(virCommandPtr cmd)
+virCommandNonblockingFDs(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* signals returns -1).
*/
void
-virCommandRawStatus(virCommandPtr cmd)
+virCommandRawStatus(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* already set, then it is replaced in the list.
*/
static void
-virCommandAddEnv(virCommandPtr cmd,
+virCommandAddEnv(virCommand *cmd,
char *envstr)
{
g_autofree char *env = envstr;
* Add an environment variable to the child created by a printf-style format.
*/
void
-virCommandAddEnvFormat(virCommandPtr cmd, const char *format, ...)
+virCommandAddEnvFormat(virCommand *cmd, const char *format, ...)
{
char *env;
va_list list;
* using separate name & value strings
*/
void
-virCommandAddEnvPair(virCommandPtr cmd, const char *name, const char *value)
+virCommandAddEnvPair(virCommand *cmd, const char *name, const char *value)
{
virCommandAddEnvFormat(cmd, "%s=%s", name, value);
}
* using a preformatted env string FOO=BAR
*/
void
-virCommandAddEnvString(virCommandPtr cmd, const char *str)
+virCommandAddEnvString(virCommand *cmd, const char *str)
{
char *env;
* using current process's value
*/
void
-virCommandAddEnvPass(virCommandPtr cmd, const char *name)
+virCommandAddEnvPass(virCommand *cmd, const char *name)
{
const char *value;
if (virCommandHasError(cmd))
* variables (such as PATH) from the parent process.
*/
void
-virCommandAddEnvPassCommon(virCommandPtr cmd)
+virCommandAddEnvPassCommon(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
void
-virCommandAddEnvXDG(virCommandPtr cmd, const char *baseDir)
+virCommandAddEnvXDG(virCommand *cmd, const char *baseDir)
{
if (virCommandHasError(cmd))
return;
* Add a command line argument to the child
*/
void
-virCommandAddArg(virCommandPtr cmd, const char *val)
+virCommandAddArg(virCommand *cmd, const char *val)
{
if (virCommandHasError(cmd))
return;
* Correctly transfers memory errors or contents from buf to cmd.
*/
void
-virCommandAddArgBuffer(virCommandPtr cmd, virBufferPtr buf)
+virCommandAddArgBuffer(virCommand *cmd, virBuffer *buf)
{
g_autofree char *str = virBufferContentAndReset(buf);
* Add a command line argument created by a printf-style format.
*/
void
-virCommandAddArgFormat(virCommandPtr cmd, const char *format, ...)
+virCommandAddArgFormat(virCommand *cmd, const char *format, ...)
{
char *arg;
va_list list;
* Add "NAME=VAL" as a single command line argument to the child
*/
void
-virCommandAddArgPair(virCommandPtr cmd, const char *name, const char *val)
+virCommandAddArgPair(virCommand *cmd, const char *name, const char *val)
{
if (name == NULL || val == NULL) {
cmd->has_error = EINVAL;
* Add a NULL terminated list of args
*/
void
-virCommandAddArgSet(virCommandPtr cmd, const char *const*vals)
+virCommandAddArgSet(virCommand *cmd, const char *const*vals)
{
int narg = 0;
* Add a NULL terminated list of args.
*/
void
-virCommandAddArgList(virCommandPtr cmd, ...)
+virCommandAddArgList(virCommand *cmd, ...)
{
va_list list;
int narg = 0;
* without using this call.
*/
void
-virCommandSetWorkingDirectory(virCommandPtr cmd, const char *pwd)
+virCommandSetWorkingDirectory(virCommand *cmd, const char *pwd)
{
if (virCommandHasError(cmd))
return;
static int
-virCommandGetNumSendBuffers(virCommandPtr cmd)
+virCommandGetNumSendBuffers(virCommand *cmd)
{
return cmd->numSendBuffers;
}
static void
-virCommandFreeSendBuffers(virCommandPtr cmd)
+virCommandFreeSendBuffers(virCommand *cmd)
{
size_t i;
* Thus callers don't need to take a special action if -1 is returned.
*/
int
-virCommandSetSendBuffer(virCommandPtr cmd,
+virCommandSetSendBuffer(virCommand *cmd,
unsigned char *buffer,
size_t buflen)
{
static int
-virCommandSendBuffersFillPollfd(virCommandPtr cmd,
+virCommandSendBuffersFillPollfd(virCommand *cmd,
struct pollfd *fds,
int startidx)
{
static int
-virCommandSendBuffersHandlePoll(virCommandPtr cmd,
+virCommandSendBuffersHandlePoll(virCommand *cmd,
struct pollfd *fds)
{
size_t i;
* virCommandRunAsync. The buffer is forgotten after each @cmd run.
*/
void
-virCommandSetInputBuffer(virCommandPtr cmd, const char *inbuf)
+virCommandSetInputBuffer(virCommand *cmd, const char *inbuf)
{
if (virCommandHasError(cmd))
return;
* buffer is forgotten after each @cmd run.
*/
void
-virCommandSetOutputBuffer(virCommandPtr cmd, char **outbuf)
+virCommandSetOutputBuffer(virCommand *cmd, char **outbuf)
{
*outbuf = NULL;
if (virCommandHasError(cmd))
* forgotten after each @cmd run.
*/
void
-virCommandSetErrorBuffer(virCommandPtr cmd, char **errbuf)
+virCommandSetErrorBuffer(virCommand *cmd, char **errbuf)
{
*errbuf = NULL;
if (virCommandHasError(cmd))
* Attach a file descriptor to the child's stdin
*/
void
-virCommandSetInputFD(virCommandPtr cmd, int infd)
+virCommandSetInputFD(virCommand *cmd, int infd)
{
if (virCommandHasError(cmd))
return;
* the child is run. Otherwise, *@outfd is used as the output.
*/
void
-virCommandSetOutputFD(virCommandPtr cmd, int *outfd)
+virCommandSetOutputFD(virCommand *cmd, int *outfd)
{
if (virCommandHasError(cmd))
return;
* and may be the same as outfd given to virCommandSetOutputFD().
*/
void
-virCommandSetErrorFD(virCommandPtr cmd, int *errfd)
+virCommandSetErrorFD(virCommand *cmd, int *errfd)
{
if (virCommandHasError(cmd))
return;
* any functions that are not async-signal-safe.
*/
void
-virCommandSetPreExecHook(virCommandPtr cmd, virExecHook hook, void *opaque)
+virCommandSetPreExecHook(virCommand *cmd, virExecHook hook, void *opaque)
{
if (virCommandHasError(cmd))
return;
* out-of-memory condition while building cmd), nothing will be logged.
*/
void
-virCommandWriteArgLog(virCommandPtr cmd, int logfd)
+virCommandWriteArgLog(virCommand *cmd, int logfd)
{
int ioError = 0;
size_t i;
* Caller is responsible for freeing the resulting string.
*/
char *
-virCommandToStringFull(virCommandPtr cmd,
+virCommandToStringFull(virCommand *cmd,
bool linebreaks,
bool stripCommandPath)
{
char *
-virCommandToString(virCommandPtr cmd,
+virCommandToString(virCommand *cmd,
bool linebreaks)
{
return virCommandToStringFull(cmd, linebreaks, false);
int
-virCommandGetArgList(virCommandPtr cmd,
+virCommandGetArgList(virCommand *cmd,
char ***args,
size_t *nargs)
{
* Manage input and output to the child process.
*/
static int
-virCommandProcessIO(virCommandPtr cmd)
+virCommandProcessIO(virCommand *cmd)
{
int outfd = -1, errfd = -1;
size_t inlen = 0, outlen = 0, errlen = 0;
* Returns -1 on any error executing the command.
* Will not return on success.
*/
-int virCommandExec(virCommandPtr cmd, gid_t *groups, int ngroups)
+int virCommandExec(virCommand *cmd, gid_t *groups, int ngroups)
{
if (virCommandHasError(cmd)) {
virCommandRaiseError(cmd);
* status that the caller must then decipher using WIFEXITED() and friends.
*/
int
-virCommandRun(virCommandPtr cmd, int *exitstatus)
+virCommandRun(virCommand *cmd, int *exitstatus)
{
int ret = 0;
char *outbuf = NULL;
static void
virCommandDoAsyncIOHelper(void *opaque)
{
- virCommandPtr cmd = opaque;
+ virCommand *cmd = opaque;
if (virCommandProcessIO(cmd) < 0) {
/* If something went wrong, save errno or -1 */
cmd->has_error = errno ? errno : -1;
* you call virProcessWait or virProcessAbort.
*/
int
-virCommandRunAsync(virCommandPtr cmd, pid_t *pid)
+virCommandRunAsync(virCommand *cmd, pid_t *pid)
{
int ret = -1;
g_autofree char *str = NULL;
* status that the caller must then decipher using WIFEXITED() and friends.
*/
int
-virCommandWait(virCommandPtr cmd, int *exitstatus)
+virCommandWait(virCommand *cmd, int *exitstatus)
{
int ret;
int status = 0;
* have started the child process.
*/
void
-virCommandAbort(virCommandPtr cmd)
+virCommandAbort(virCommand *cmd)
{
if (!cmd || cmd->pid == -1)
return;
* execution. The child will not exec() until the
* parent has notified
*/
-void virCommandRequireHandshake(virCommandPtr cmd)
+void virCommandRequireHandshake(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* Wait for the child to complete execution of its
* hook function. To be called in the parent.
*/
-int virCommandHandshakeWait(virCommandPtr cmd)
+int virCommandHandshakeWait(virCommand *cmd)
{
char c;
int rv;
* Notify the child that it is OK to exec() the
* real binary now. To be called in the parent.
*/
-int virCommandHandshakeNotify(virCommandPtr cmd)
+int virCommandHandshakeNotify(virCommand *cmd)
{
char c = '1';
}
#else /* WIN32 */
int
-virCommandSetSendBuffer(virCommandPtr cmd,
+virCommandSetSendBuffer(virCommand *cmd,
unsigned char *buffer G_GNUC_UNUSED,
size_t buflen G_GNUC_UNUSED)
{
int
-virCommandExec(virCommandPtr cmd G_GNUC_UNUSED, gid_t *groups G_GNUC_UNUSED,
+virCommandExec(virCommand *cmd G_GNUC_UNUSED, gid_t *groups G_GNUC_UNUSED,
int ngroups G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
int
-virCommandRun(virCommandPtr cmd G_GNUC_UNUSED, int *exitstatus G_GNUC_UNUSED)
+virCommandRun(virCommand *cmd G_GNUC_UNUSED, int *exitstatus G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Executing new processes is not supported on Win32 platform"));
int
-virCommandRunAsync(virCommandPtr cmd G_GNUC_UNUSED, pid_t *pid G_GNUC_UNUSED)
+virCommandRunAsync(virCommand *cmd G_GNUC_UNUSED, pid_t *pid G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Executing new processes is not supported on Win32 platform"));
int
-virCommandWait(virCommandPtr cmd G_GNUC_UNUSED, int *exitstatus G_GNUC_UNUSED)
+virCommandWait(virCommand *cmd G_GNUC_UNUSED, int *exitstatus G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Executing new processes is not supported on Win32 platform"));
void
-virCommandAbort(virCommandPtr cmd G_GNUC_UNUSED)
+virCommandAbort(virCommand *cmd G_GNUC_UNUSED)
{
/* Mingw lacks WNOHANG and kill(). But since we haven't ported
* virExec to mingw yet, there's no process to be killed,
}
-void virCommandRequireHandshake(virCommandPtr cmd)
+void virCommandRequireHandshake(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
}
-int virCommandHandshakeWait(virCommandPtr cmd G_GNUC_UNUSED)
+int virCommandHandshakeWait(virCommand *cmd G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Executing new processes is not supported on Win32 platform"));
}
-int virCommandHandshakeNotify(virCommandPtr cmd G_GNUC_UNUSED)
+int virCommandHandshakeNotify(virCommand *cmd G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Executing new processes is not supported on Win32 platform"));
* is not reaped, and you must call virProcessWait() or virProcessAbort() yourself.
*/
void
-virCommandFree(virCommandPtr cmd)
+virCommandFree(virCommand *cmd)
{
size_t i;
if (!cmd)
* buffer setting functions (virCommandSet.*Buffer) prior each run.
*/
void
-virCommandDoAsyncIO(virCommandPtr cmd)
+virCommandDoAsyncIO(virCommand *cmd)
{
if (virCommandHasError(cmd))
return;
* virBuffer buffer = VIR_BUFFER_INITIALIZER;
* virCommandSetDryRun(&buffer);
*
- * virCommandPtr echocmd = virCommandNewArgList("/bin/echo", "Hello world", NULL);
+ * virCommand *echocmd = virCommandNewArgList("/bin/echo", "Hello world", NULL);
* virCommandRun(echocmd, NULL);
*
* After this, the @buffer should contain:
*/
void
virCommandSetDryRun(virCommandDryRunToken *tok,
- virBufferPtr buf,
+ virBuffer *buf,
bool bufArgLinebreaks,
bool bufCommandStripPath,
virCommandDryRunCallback cb,
* error or callback function error
*/
int
-virCommandRunRegex(virCommandPtr cmd,
+virCommandRunRegex(virCommand *cmd,
int nregex,
const char **regex,
int *nvars,
* If there are no input tokens (empty input), call FUNC with N_COLUMNS == 0.
*/
int
-virCommandRunNul(virCommandPtr cmd,
+virCommandRunNul(virCommand *cmd,
size_t n_columns,
virCommandRunNulFunc func,
void *data)
#else /* WIN32 */
int
-virCommandRunRegex(virCommandPtr cmd G_GNUC_UNUSED,
+virCommandRunRegex(virCommand *cmd G_GNUC_UNUSED,
int nregex G_GNUC_UNUSED,
const char **regex G_GNUC_UNUSED,
int *nvars G_GNUC_UNUSED,
}
int
-virCommandRunNul(virCommandPtr cmd G_GNUC_UNUSED,
+virCommandRunNul(virCommand *cmd G_GNUC_UNUSED,
size_t n_columns G_GNUC_UNUSED,
virCommandRunNulFunc func G_GNUC_UNUSED,
void *data G_GNUC_UNUSED)
#include "virbuffer.h"
typedef struct _virCommand virCommand;
-typedef virCommand *virCommandPtr;
/* This will execute in the context of the first child
* after fork() but before execve(). As such, it is unsafe to
pid_t virFork(void) G_GNUC_WARN_UNUSED_RESULT;
-virCommandPtr virCommandNew(const char *binary) ATTRIBUTE_NONNULL(1);
+virCommand *virCommandNew(const char *binary) ATTRIBUTE_NONNULL(1);
-virCommandPtr virCommandNewArgs(const char *const*args) ATTRIBUTE_NONNULL(1);
+virCommand *virCommandNewArgs(const char *const*args) ATTRIBUTE_NONNULL(1);
-virCommandPtr virCommandNewArgList(const char *binary, ...)
+virCommand *virCommandNewArgList(const char *binary, ...)
ATTRIBUTE_NONNULL(1) G_GNUC_NULL_TERMINATED;
-virCommandPtr virCommandNewVAList(const char *binary, va_list list)
+virCommand *virCommandNewVAList(const char *binary, va_list list)
ATTRIBUTE_NONNULL(1);
/* All error report from these setup APIs is
VIR_COMMAND_PASS_FD_CLOSE_PARENT = (1 << 0),
} virCommandPassFDFlags;
-void virCommandPassFD(virCommandPtr cmd,
+void virCommandPassFD(virCommand *cmd,
int fd,
unsigned int flags) G_GNUC_NO_INLINE;
-void virCommandPassFDIndex(virCommandPtr cmd,
+void virCommandPassFDIndex(virCommand *cmd,
int fd,
unsigned int flags,
size_t *idx) G_GNUC_NO_INLINE;
-int virCommandPassFDGetFDIndex(virCommandPtr cmd,
+int virCommandPassFDGetFDIndex(virCommand *cmd,
int fd);
-void virCommandSetPidFile(virCommandPtr cmd,
+void virCommandSetPidFile(virCommand *cmd,
const char *pidfile) ATTRIBUTE_NONNULL(2);
-gid_t virCommandGetGID(virCommandPtr cmd) ATTRIBUTE_NONNULL(1);
+gid_t virCommandGetGID(virCommand *cmd) ATTRIBUTE_NONNULL(1);
-uid_t virCommandGetUID(virCommandPtr cmd) ATTRIBUTE_NONNULL(1);
+uid_t virCommandGetUID(virCommand *cmd) ATTRIBUTE_NONNULL(1);
-void virCommandSetGID(virCommandPtr cmd, gid_t gid);
+void virCommandSetGID(virCommand *cmd, gid_t gid);
-void virCommandSetUID(virCommandPtr cmd, uid_t uid);
+void virCommandSetUID(virCommand *cmd, uid_t uid);
-void virCommandSetMaxMemLock(virCommandPtr cmd, unsigned long long bytes);
-void virCommandSetMaxProcesses(virCommandPtr cmd, unsigned int procs);
-void virCommandSetMaxFiles(virCommandPtr cmd, unsigned int files);
-void virCommandSetMaxCoreSize(virCommandPtr cmd, unsigned long long bytes);
-void virCommandSetUmask(virCommandPtr cmd, int umask);
+void virCommandSetMaxMemLock(virCommand *cmd, unsigned long long bytes);
+void virCommandSetMaxProcesses(virCommand *cmd, unsigned int procs);
+void virCommandSetMaxFiles(virCommand *cmd, unsigned int files);
+void virCommandSetMaxCoreSize(virCommand *cmd, unsigned long long bytes);
+void virCommandSetUmask(virCommand *cmd, int umask);
-void virCommandClearCaps(virCommandPtr cmd);
+void virCommandClearCaps(virCommand *cmd);
-void virCommandAllowCap(virCommandPtr cmd,
+void virCommandAllowCap(virCommand *cmd,
int capability);
-void virCommandSetSELinuxLabel(virCommandPtr cmd,
+void virCommandSetSELinuxLabel(virCommand *cmd,
const char *label);
-void virCommandSetAppArmorProfile(virCommandPtr cmd,
+void virCommandSetAppArmorProfile(virCommand *cmd,
const char *profile);
-void virCommandDaemonize(virCommandPtr cmd);
+void virCommandDaemonize(virCommand *cmd);
-void virCommandNonblockingFDs(virCommandPtr cmd);
+void virCommandNonblockingFDs(virCommand *cmd);
-void virCommandRawStatus(virCommandPtr cmd);
+void virCommandRawStatus(virCommand *cmd);
-void virCommandAddEnvFormat(virCommandPtr cmd, const char *format, ...)
+void virCommandAddEnvFormat(virCommand *cmd, const char *format, ...)
ATTRIBUTE_NONNULL(2) G_GNUC_PRINTF(2, 3);
-void virCommandAddEnvPair(virCommandPtr cmd,
+void virCommandAddEnvPair(virCommand *cmd,
const char *name,
const char *value) ATTRIBUTE_NONNULL(2);
-void virCommandAddEnvString(virCommandPtr cmd,
+void virCommandAddEnvString(virCommand *cmd,
const char *str) ATTRIBUTE_NONNULL(2);
-void virCommandAddEnvPass(virCommandPtr cmd,
+void virCommandAddEnvPass(virCommand *cmd,
const char *name) ATTRIBUTE_NONNULL(2);
-void virCommandAddEnvPassCommon(virCommandPtr cmd);
+void virCommandAddEnvPassCommon(virCommand *cmd);
-void virCommandAddEnvXDG(virCommandPtr cmd, const char *baseDir);
+void virCommandAddEnvXDG(virCommand *cmd, const char *baseDir);
-void virCommandAddArg(virCommandPtr cmd,
+void virCommandAddArg(virCommand *cmd,
const char *val) ATTRIBUTE_NONNULL(2);
-void virCommandAddArgBuffer(virCommandPtr cmd,
- virBufferPtr buf);
+void virCommandAddArgBuffer(virCommand *cmd,
+ virBuffer *buf);
-void virCommandAddArgFormat(virCommandPtr cmd,
+void virCommandAddArgFormat(virCommand *cmd,
const char *format, ...)
ATTRIBUTE_NONNULL(2) G_GNUC_PRINTF(2, 3);
-void virCommandAddArgPair(virCommandPtr cmd,
+void virCommandAddArgPair(virCommand *cmd,
const char *name,
const char *val);
-void virCommandAddArgSet(virCommandPtr cmd,
+void virCommandAddArgSet(virCommand *cmd,
const char *const*vals) ATTRIBUTE_NONNULL(2);
-void virCommandAddArgList(virCommandPtr cmd,
+void virCommandAddArgList(virCommand *cmd,
... /* const char *arg, ..., NULL */)
G_GNUC_NULL_TERMINATED;
-void virCommandSetWorkingDirectory(virCommandPtr cmd,
+void virCommandSetWorkingDirectory(virCommand *cmd,
const char *pwd) ATTRIBUTE_NONNULL(2);
-int virCommandSetSendBuffer(virCommandPtr cmd,
+int virCommandSetSendBuffer(virCommand *cmd,
unsigned char *buffer,
size_t buflen)
ATTRIBUTE_NONNULL(2);
-void virCommandSetInputBuffer(virCommandPtr cmd,
+void virCommandSetInputBuffer(virCommand *cmd,
const char *inbuf) ATTRIBUTE_NONNULL(2);
-void virCommandSetOutputBuffer(virCommandPtr cmd,
+void virCommandSetOutputBuffer(virCommand *cmd,
char **outbuf) ATTRIBUTE_NONNULL(2);
-void virCommandSetErrorBuffer(virCommandPtr cmd,
+void virCommandSetErrorBuffer(virCommand *cmd,
char **errbuf) ATTRIBUTE_NONNULL(2);
-void virCommandSetInputFD(virCommandPtr cmd,
+void virCommandSetInputFD(virCommand *cmd,
int infd);
-void virCommandSetOutputFD(virCommandPtr cmd,
+void virCommandSetOutputFD(virCommand *cmd,
int *outfd) ATTRIBUTE_NONNULL(2);
-void virCommandSetErrorFD(virCommandPtr cmd,
+void virCommandSetErrorFD(virCommand *cmd,
int *errfd) ATTRIBUTE_NONNULL(2);
-void virCommandSetPreExecHook(virCommandPtr cmd,
+void virCommandSetPreExecHook(virCommand *cmd,
virExecHook hook,
void *opaque) ATTRIBUTE_NONNULL(2);
-void virCommandWriteArgLog(virCommandPtr cmd,
+void virCommandWriteArgLog(virCommand *cmd,
int logfd);
-char *virCommandToString(virCommandPtr cmd, bool linebreaks) G_GNUC_WARN_UNUSED_RESULT;
-char *virCommandToStringFull(virCommandPtr cmd,
+char *virCommandToString(virCommand *cmd, bool linebreaks) G_GNUC_WARN_UNUSED_RESULT;
+char *virCommandToStringFull(virCommand *cmd,
bool linebreaks,
bool stripCommandPath);
-int virCommandGetArgList(virCommandPtr cmd, char ***args, size_t *nargs);
+int virCommandGetArgList(virCommand *cmd, char ***args, size_t *nargs);
-int virCommandExec(virCommandPtr cmd, gid_t *groups, int ngroups) G_GNUC_WARN_UNUSED_RESULT;
+int virCommandExec(virCommand *cmd, gid_t *groups, int ngroups) G_GNUC_WARN_UNUSED_RESULT;
-int virCommandRun(virCommandPtr cmd,
+int virCommandRun(virCommand *cmd,
int *exitstatus) G_GNUC_WARN_UNUSED_RESULT;
-int virCommandRunAsync(virCommandPtr cmd,
+int virCommandRunAsync(virCommand *cmd,
pid_t *pid) G_GNUC_WARN_UNUSED_RESULT;
-int virCommandWait(virCommandPtr cmd,
+int virCommandWait(virCommand *cmd,
int *exitstatus) G_GNUC_WARN_UNUSED_RESULT;
-void virCommandRequireHandshake(virCommandPtr cmd);
+void virCommandRequireHandshake(virCommand *cmd);
-int virCommandHandshakeWait(virCommandPtr cmd)
+int virCommandHandshakeWait(virCommand *cmd)
G_GNUC_WARN_UNUSED_RESULT;
-int virCommandHandshakeNotify(virCommandPtr cmd)
+int virCommandHandshakeNotify(virCommand *cmd)
G_GNUC_WARN_UNUSED_RESULT;
-void virCommandAbort(virCommandPtr cmd);
+void virCommandAbort(virCommand *cmd);
-void virCommandFree(virCommandPtr cmd);
+void virCommandFree(virCommand *cmd);
-void virCommandDoAsyncIO(virCommandPtr cmd);
+void virCommandDoAsyncIO(virCommand *cmd);
typedef int (*virCommandRunRegexFunc)(char **const groups,
void *data);
char **const groups,
void *data);
-int virCommandRunRegex(virCommandPtr cmd,
+int virCommandRunRegex(virCommand *cmd,
int nregex,
const char **regex,
int *nvars,
const char *cmd_to_ignore,
int *exitstatus);
-int virCommandRunNul(virCommandPtr cmd,
+int virCommandRunNul(virCommand *cmd,
size_t n_columns,
virCommandRunNulFunc func,
void *data);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCommandDryRunToken, virCommandDryRunTokenFree);
void virCommandSetDryRun(virCommandDryRunToken *tok,
- virBufferPtr buf,
+ virBuffer *buf,
bool bufArgLinebreaks,
bool bufCommandStripPath,
virCommandDryRunCallback cb,
VIR_LOG_INIT("util.conf");
typedef struct _virConfParserCtxt virConfParserCtxt;
-typedef virConfParserCtxt *virConfParserCtxtPtr;
-
struct _virConfParserCtxt {
const char* filename;
const char* base;
const char *end;
int line;
- virConfPtr conf;
+ virConf *conf;
};
#define CUR (*ctxt->cur)
);
typedef struct _virConfEntry virConfEntry;
-typedef virConfEntry *virConfEntryPtr;
-
struct _virConfEntry {
- virConfEntryPtr next;
+ virConfEntry *next;
char* name;
char* comment;
- virConfValuePtr value;
+ virConfValue *value;
};
struct _virConf {
char *filename;
unsigned int flags;
- virConfEntryPtr entries;
+ virConfEntry *entries;
};
/**
virConfErrorHelper(__FILE__, __FUNCTION__, __LINE__, ctxt, error, info)
static void
virConfErrorHelper(const char *file, const char *func, size_t line,
- virConfParserCtxtPtr ctxt,
+ virConfParserCtxt *ctxt,
virErrorNumber error, const char *info)
{
if (error == VIR_ERR_OK)
* Free a list
*/
static void
-virConfFreeList(virConfValuePtr list)
+virConfFreeList(virConfValue *list)
{
- virConfValuePtr next;
+ virConfValue *next;
while (list != NULL) {
next = g_steal_pointer(&list->next);
* Free a value
*/
void
-virConfFreeValue(virConfValuePtr val)
+virConfFreeValue(virConfValue *val)
{
if (val == NULL)
return;
g_free(val);
}
-virConfPtr
+virConf *
virConfNew(void)
{
- virConfPtr ret;
+ virConf *ret;
ret = g_new0(virConf, 1);
ret->filename = NULL;
*
* Returns a pointer or NULL in case of error.
*/
-static virConfPtr
+static virConf *
virConfCreate(const char *filename, unsigned int flags)
{
- virConfPtr ret = virConfNew();
+ virConf *ret = virConfNew();
if (!ret)
return NULL;
*
* Returns a pointer to the entry or NULL in case of failure
*/
-static virConfEntryPtr
-virConfAddEntry(virConfPtr conf, char *name, virConfValuePtr value, char *comm)
+static virConfEntry *
+virConfAddEntry(virConf *conf, char *name, virConfValue *value, char *comm)
{
- virConfEntryPtr ret;
- virConfEntryPtr prev;
+ virConfEntry *ret;
+ virConfEntry *prev;
if (conf == NULL)
return NULL;
* Returns 0 in case of success, -1 in case of error.
*/
static int
-virConfSaveValue(virBufferPtr buf, virConfValuePtr val)
+virConfSaveValue(virBuffer *buf, virConfValue *val)
{
if (val == NULL)
return -1;
}
break;
case VIR_CONF_LIST: {
- virConfValuePtr cur;
+ virConfValue *cur;
cur = val->list;
virBufferAddLit(buf, "[ ");
* Returns 0 in case of success, -1 in case of error.
*/
static int
-virConfSaveEntry(virBufferPtr buf, virConfEntryPtr cur)
+virConfSaveEntry(virBuffer *buf, virConfEntry *cur)
{
if (cur->name != NULL) {
virBufferAdd(buf, cur->name, -1);
* Returns 0 in case of success and -1 in case of error
*/
static int
-virConfParseLong(virConfParserCtxtPtr ctxt, long long *val)
+virConfParseLong(virConfParserCtxt *ctxt, long long *val)
{
long long l = 0;
int neg = 0;
* Returns a pointer to the string or NULL in case of error
*/
static char *
-virConfParseString(virConfParserCtxtPtr ctxt)
+virConfParseString(virConfParserCtxt *ctxt)
{
const char *base;
char *ret = NULL;
*
* Returns a pointer to the value or NULL in case of error
*/
-static virConfValuePtr
-virConfParseValue(virConfParserCtxtPtr ctxt)
+static virConfValue *
+virConfParseValue(virConfParserCtxt *ctxt)
{
- virConfValuePtr ret;
- virConfValuePtr lst = NULL;
- virConfValuePtr tmp;
- virConfValuePtr prev;
+ virConfValue *ret;
+ virConfValue *lst = NULL;
+ virConfValue *tmp;
+ virConfValue *prev;
virConfType type = VIR_CONF_NONE;
char *str = NULL;
long long l = 0;
* Returns a copy of the new string, NULL in case of error
*/
static char *
-virConfParseName(virConfParserCtxtPtr ctxt)
+virConfParseName(virConfParserCtxt *ctxt)
{
const char *base;
char *ret;
* Returns 0 in case of success and -1 in case of error
*/
static int
-virConfParseComment(virConfParserCtxtPtr ctxt)
+virConfParseComment(virConfParserCtxt *ctxt)
{
const char *base;
char *comm;
* Returns 0 in case of success and -1 in case of error
*/
static int
-virConfParseSeparator(virConfParserCtxtPtr ctxt)
+virConfParseSeparator(virConfParserCtxt *ctxt)
{
SKIP_BLANKS;
if (ctxt->cur >= ctxt->end)
* Returns 0 in case of success and -1 in case of error
*/
static int
-virConfParseStatement(virConfParserCtxtPtr ctxt)
+virConfParseStatement(virConfParserCtxt *ctxt)
{
const char *base;
char *name;
- virConfValuePtr value;
+ virConfValue *value;
char *comm = NULL;
SKIP_BLANKS_AND_EOL;
* Returns a handle to lookup settings or NULL if it failed to
* read or parse the file, use virConfFree() to free the data.
*/
-static virConfPtr
+static virConf *
virConfParse(const char *filename, const char *content, int len,
unsigned int flags)
{
* Returns a handle to lookup settings or NULL if it failed to
* read or parse the file, use virConfFree() to free the data.
*/
-virConfPtr
+virConf *
virConfReadFile(const char *filename, unsigned int flags)
{
char *content;
int len;
- virConfPtr conf;
+ virConf *conf;
VIR_DEBUG("filename=%s", NULLSTR(filename));
* Returns a handle to lookup settings or NULL if it failed to
* parse the content, use virConfFree() to free the data.
*/
-virConfPtr
+virConf *
virConfReadString(const char *memory, unsigned int flags)
{
size_t len;
* Returns 0 in case of success, -1 in case of error.
*/
int
-virConfFree(virConfPtr conf)
+virConfFree(virConf *conf)
{
- virConfEntryPtr tmp;
+ virConfEntry *tmp;
if (conf == NULL)
return 0;
tmp = conf->entries;
while (tmp) {
- virConfEntryPtr next;
+ virConfEntry *next;
g_free(tmp->name);
virConfFreeValue(tmp->value);
g_free(tmp->comment);
* Returns a pointer to the value or NULL if the lookup failed, the data
* associated will be freed when virConfFree() is called
*/
-virConfValuePtr
-virConfGetValue(virConfPtr conf, const char *setting)
+virConfValue *
+virConfGetValue(virConf *conf, const char *setting)
{
- virConfEntryPtr cur;
+ virConfEntry *cur;
if (conf == NULL)
return NULL;
*
* Returns: the entry type, or VIR_CONF_NONE if not set.
*/
-virConfType virConfGetValueType(virConfPtr conf,
+virConfType virConfGetValueType(virConf *conf,
const char *setting)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
if (!cval)
return VIR_CONF_NONE;
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueString(virConfPtr conf,
+int virConfGetValueString(virConf *conf,
const char *setting,
char **value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value string %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueStringList(virConfPtr conf,
+int virConfGetValueStringList(virConf *conf,
const char *setting,
bool compatString,
char ***values)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
size_t len;
- virConfValuePtr eval;
+ virConfValue *eval;
VIR_DEBUG("Get value string list %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueBool(virConfPtr conf,
+int virConfGetValueBool(virConf *conf,
const char *setting,
bool *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value bool %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueInt(virConfPtr conf,
+int virConfGetValueInt(virConf *conf,
const char *setting,
int *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value int %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueUInt(virConfPtr conf,
+int virConfGetValueUInt(virConf *conf,
const char *setting,
unsigned int *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value uint %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueSizeT(virConfPtr conf,
+int virConfGetValueSizeT(virConf *conf,
const char *setting,
size_t *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value size_t %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueSSizeT(virConfPtr conf,
+int virConfGetValueSSizeT(virConf *conf,
const char *setting,
ssize_t *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value ssize_t %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueLLong(virConfPtr conf,
+int virConfGetValueLLong(virConf *conf,
const char *setting,
long long *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value long long %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
-int virConfGetValueULLong(virConfPtr conf,
+int virConfGetValueULLong(virConf *conf,
const char *setting,
unsigned long long *value)
{
- virConfValuePtr cval = virConfGetValue(conf, setting);
+ virConfValue *cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value unsigned long long %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
* Returns 0 on success, or -1 on failure.
*/
int
-virConfSetValue(virConfPtr conf,
+virConfSetValue(virConf *conf,
const char *setting,
- virConfValuePtr value)
+ virConfValue *value)
{
- virConfEntryPtr cur;
- virConfEntryPtr prev = NULL;
+ virConfEntry *cur;
+ virConfEntry *prev = NULL;
if (value && value->type == VIR_CONF_STRING && value->str == NULL) {
virConfFreeValue(value);
*
* Returns 0 on success, or -1 on failure.
*/
-int virConfWalk(virConfPtr conf,
+int virConfWalk(virConf *conf,
virConfWalkCallback callback,
void *opaque)
{
- virConfEntryPtr cur;
+ virConfEntry *cur;
if (!conf)
return 0;
* Returns the number of bytes written or -1 in case of error.
*/
int
-virConfWriteFile(const char *filename, virConfPtr conf)
+virConfWriteFile(const char *filename, virConf *conf)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfEntryPtr cur;
+ virConfEntry *cur;
int ret;
int fd;
char *content;
* Returns the number of bytes written or -1 in case of error.
*/
int
-virConfWriteMem(char *memory, int *len, virConfPtr conf)
+virConfWriteMem(char *memory, int *len, virConf *conf)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfEntryPtr cur;
+ virConfEntry *cur;
char *content;
unsigned int use;
}
int
-virConfLoadConfig(virConfPtr *conf, const char *name)
+virConfLoadConfig(virConf **conf, const char *name)
{
char *path = NULL;
int ret = -1;
* a value from the configuration file
*/
typedef struct _virConfValue virConfValue;
-typedef virConfValue *virConfValuePtr;
-
struct _virConfValue {
virConfType type; /* the virConfType */
- virConfValuePtr next; /* next element if in a list */
+ virConfValue *next; /* next element if in a list */
long long l; /* very long integer */
char *str; /* pointer to 0 terminated string */
- virConfValuePtr list; /* list of a list */
+ virConfValue *list; /* list of a list */
};
/**
- * virConfPtr:
+ * virConf *:
* a pointer to a parsed configuration file
*/
typedef struct _virConf virConf;
-typedef virConf *virConfPtr;
typedef int (*virConfWalkCallback)(const char* name,
- virConfValuePtr value,
+ virConfValue *value,
void *opaque);
-virConfPtr virConfNew(void);
-virConfPtr virConfReadFile(const char *filename, unsigned int flags);
-virConfPtr virConfReadString(const char *memory,
+virConf *virConfNew(void);
+virConf *virConfReadFile(const char *filename, unsigned int flags);
+virConf *virConfReadString(const char *memory,
unsigned int flags);
-int virConfFree(virConfPtr conf);
+int virConfFree(virConf *conf);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virConf, virConfFree);
-void virConfFreeValue(virConfValuePtr val);
-virConfValuePtr virConfGetValue(virConfPtr conf,
+void virConfFreeValue(virConfValue *val);
+virConfValue *virConfGetValue(virConf *conf,
const char *setting);
-virConfType virConfGetValueType(virConfPtr conf,
+virConfType virConfGetValueType(virConf *conf,
const char *setting);
-int virConfGetValueString(virConfPtr conf,
+int virConfGetValueString(virConf *conf,
const char *setting,
char **value);
-int virConfGetValueStringList(virConfPtr conf,
+int virConfGetValueStringList(virConf *conf,
const char *setting,
bool compatString,
char ***values);
-int virConfGetValueBool(virConfPtr conf,
+int virConfGetValueBool(virConf *conf,
const char *setting,
bool *value);
-int virConfGetValueInt(virConfPtr conf,
+int virConfGetValueInt(virConf *conf,
const char *setting,
int *value);
-int virConfGetValueUInt(virConfPtr conf,
+int virConfGetValueUInt(virConf *conf,
const char *setting,
unsigned int *value);
-int virConfGetValueSizeT(virConfPtr conf,
+int virConfGetValueSizeT(virConf *conf,
const char *setting,
size_t *value);
-int virConfGetValueSSizeT(virConfPtr conf,
+int virConfGetValueSSizeT(virConf *conf,
const char *setting,
ssize_t *value);
-int virConfGetValueLLong(virConfPtr conf,
+int virConfGetValueLLong(virConf *conf,
const char *setting,
long long *value);
-int virConfGetValueULLong(virConfPtr conf,
+int virConfGetValueULLong(virConf *conf,
const char *setting,
unsigned long long *value);
-int virConfSetValue(virConfPtr conf,
+int virConfSetValue(virConf *conf,
const char *setting,
- virConfValuePtr value);
-int virConfWalk(virConfPtr conf,
+ virConfValue *value);
+int virConfWalk(virConf *conf,
virConfWalkCallback callback,
void *opaque);
int virConfWriteFile(const char *filename,
- virConfPtr conf);
+ virConf *conf);
int virConfWriteMem(char *memory,
int *len,
- virConfPtr conf);
-int virConfLoadConfig(virConfPtr *conf, const char *name);
+ virConf *conf);
+int virConfLoadConfig(virConf **conf, const char *name);
char *binaryPath;
bool noRefresh;
time_t mtime;
- virBitmapPtr flags;
+ virBitmap *flags;
unsigned long version;
};
-static virClassPtr dnsmasqCapsClass;
+static virClass *dnsmasqCapsClass;
static void
dnsmasqCapsDispose(void *obj)
{
- dnsmasqCapsPtr caps = obj;
+ dnsmasqCaps *caps = obj;
virBitmapFree(caps->flags);
g_free(caps->binaryPath);
VIR_ONCE_GLOBAL_INIT(dnsmasqCaps);
static void
-dnsmasqCapsSet(dnsmasqCapsPtr caps,
+dnsmasqCapsSet(dnsmasqCaps *caps,
dnsmasqCapsFlags flag)
{
ignore_value(virBitmapSetBit(caps->flags, flag));
#define DNSMASQ_VERSION_STR "Dnsmasq version "
static int
-dnsmasqCapsSetFromBuffer(dnsmasqCapsPtr caps, const char *buf)
+dnsmasqCapsSetFromBuffer(dnsmasqCaps *caps, const char *buf)
{
int len;
const char *p;
}
static int
-dnsmasqCapsSetFromFile(dnsmasqCapsPtr caps, const char *path)
+dnsmasqCapsSetFromFile(dnsmasqCaps *caps, const char *path)
{
int ret = -1;
g_autofree char *buf = NULL;
}
static int
-dnsmasqCapsRefreshInternal(dnsmasqCapsPtr caps, bool force)
+dnsmasqCapsRefreshInternal(dnsmasqCaps *caps, bool force)
{
int ret = -1;
struct stat sb;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
g_autofree char *help = NULL;
g_autofree char *version = NULL;
g_autofree char *complete = NULL;
return ret;
}
-static dnsmasqCapsPtr
+static dnsmasqCaps *
dnsmasqCapsNewEmpty(const char *binaryPath)
{
- dnsmasqCapsPtr caps;
+ dnsmasqCaps *caps;
if (dnsmasqCapsInitialize() < 0)
return NULL;
return caps;
}
-dnsmasqCapsPtr
+dnsmasqCaps *
dnsmasqCapsNewFromBuffer(const char *buf, const char *binaryPath)
{
- dnsmasqCapsPtr caps = dnsmasqCapsNewEmpty(binaryPath);
+ dnsmasqCaps *caps = dnsmasqCapsNewEmpty(binaryPath);
if (!caps)
return NULL;
return caps;
}
-dnsmasqCapsPtr
+dnsmasqCaps *
dnsmasqCapsNewFromFile(const char *dataPath, const char *binaryPath)
{
- dnsmasqCapsPtr caps = dnsmasqCapsNewEmpty(binaryPath);
+ dnsmasqCaps *caps = dnsmasqCapsNewEmpty(binaryPath);
if (!caps)
return NULL;
return caps;
}
-dnsmasqCapsPtr
+dnsmasqCaps *
dnsmasqCapsNewFromBinary(const char *binaryPath)
{
- dnsmasqCapsPtr caps = dnsmasqCapsNewEmpty(binaryPath);
+ dnsmasqCaps *caps = dnsmasqCapsNewEmpty(binaryPath);
if (!caps)
return NULL;
* Returns 0 on success, -1 on failure
*/
int
-dnsmasqCapsRefresh(dnsmasqCapsPtr *caps, const char *binaryPath)
+dnsmasqCapsRefresh(dnsmasqCaps **caps, const char *binaryPath)
{
if (!*caps) {
*caps = dnsmasqCapsNewFromBinary(binaryPath);
}
const char *
-dnsmasqCapsGetBinaryPath(dnsmasqCapsPtr caps)
+dnsmasqCapsGetBinaryPath(dnsmasqCaps *caps)
{
return caps ? caps->binaryPath : DNSMASQ;
}
unsigned long
-dnsmasqCapsGetVersion(dnsmasqCapsPtr caps)
+dnsmasqCapsGetVersion(dnsmasqCaps *caps)
{
if (caps)
return caps->version;
}
bool
-dnsmasqCapsGet(dnsmasqCapsPtr caps, dnsmasqCapsFlags flag)
+dnsmasqCapsGet(dnsmasqCaps *caps, dnsmasqCapsFlags flag)
{
return caps && virBitmapIsBitSet(caps->flags, flag);
}
} dnsmasqCapsFlags;
typedef struct _dnsmasqCaps dnsmasqCaps;
-typedef dnsmasqCaps *dnsmasqCapsPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(dnsmasqCaps, virObjectUnref);
int dnsmasqDelete(const dnsmasqContext *ctx);
int dnsmasqReload(pid_t pid);
-dnsmasqCapsPtr dnsmasqCapsNewFromBuffer(const char *buf,
+dnsmasqCaps *dnsmasqCapsNewFromBuffer(const char *buf,
const char *binaryPath);
-dnsmasqCapsPtr dnsmasqCapsNewFromFile(const char *dataPath,
+dnsmasqCaps *dnsmasqCapsNewFromFile(const char *dataPath,
const char *binaryPath);
-dnsmasqCapsPtr dnsmasqCapsNewFromBinary(const char *binaryPath);
-int dnsmasqCapsRefresh(dnsmasqCapsPtr *caps, const char *binaryPath);
-bool dnsmasqCapsGet(dnsmasqCapsPtr caps, dnsmasqCapsFlags flag);
-const char *dnsmasqCapsGetBinaryPath(dnsmasqCapsPtr caps);
-unsigned long dnsmasqCapsGetVersion(dnsmasqCapsPtr caps);
+dnsmasqCaps *dnsmasqCapsNewFromBinary(const char *binaryPath);
+int dnsmasqCapsRefresh(dnsmasqCaps **caps, const char *binaryPath);
+bool dnsmasqCapsGet(dnsmasqCaps *caps, dnsmasqCapsFlags flag);
+const char *dnsmasqCapsGetBinaryPath(dnsmasqCaps *caps);
+unsigned long dnsmasqCapsGetVersion(dnsmasqCaps *caps);
char *dnsmasqDhcpHostsToString(dnsmasqDhcpHost *hosts,
unsigned int nhosts);
} virFDStreamMsgType;
typedef struct _virFDStreamMsg virFDStreamMsg;
-typedef virFDStreamMsg *virFDStreamMsgPtr;
struct _virFDStreamMsg {
- virFDStreamMsgPtr next;
+ virFDStreamMsg *next;
virFDStreamMsgType type;
/* Tunnelled migration stream support */
typedef struct virFDStreamData virFDStreamData;
-typedef virFDStreamData *virFDStreamDataPtr;
struct virFDStreamData {
virObjectLockable parent;
void *icbOpaque;
/* Thread data */
- virThreadPtr thread;
+ virThread *thread;
virCond threadCond;
virErrorPtr threadErr;
bool threadQuit;
bool threadAbort;
bool threadDoRead;
- virFDStreamMsgPtr msg;
+ virFDStreamMsg *msg;
};
-static virClassPtr virFDStreamDataClass;
+static virClass *virFDStreamDataClass;
static __thread bool virFDStreamDataDisposed;
-static void virFDStreamMsgQueueFree(virFDStreamMsgPtr *queue);
+static void virFDStreamMsgQueueFree(virFDStreamMsg **queue);
static void
virFDStreamDataDispose(void *obj)
{
- virFDStreamDataPtr fdst = obj;
+ virFDStreamData *fdst = obj;
VIR_DEBUG("obj=%p", fdst);
virFDStreamDataDisposed = true;
static int
-virFDStreamMsgQueuePush(virFDStreamDataPtr fdst,
- virFDStreamMsgPtr *msg,
+virFDStreamMsgQueuePush(virFDStreamData *fdst,
+ virFDStreamMsg **msg,
int fd,
const char *fdname)
{
- virFDStreamMsgPtr *tmp = &fdst->msg;
+ virFDStreamMsg **tmp = &fdst->msg;
char c = '1';
while (*tmp)
}
-static virFDStreamMsgPtr
-virFDStreamMsgQueuePop(virFDStreamDataPtr fdst,
+static virFDStreamMsg *
+virFDStreamMsgQueuePop(virFDStreamData *fdst,
int fd,
const char *fdname)
{
- virFDStreamMsgPtr tmp = fdst->msg;
+ virFDStreamMsg *tmp = fdst->msg;
char c;
if (tmp) {
static void
-virFDStreamMsgFree(virFDStreamMsgPtr msg)
+virFDStreamMsgFree(virFDStreamMsg *msg)
{
if (!msg)
return;
static void
-virFDStreamMsgQueueFree(virFDStreamMsgPtr *queue)
+virFDStreamMsgQueueFree(virFDStreamMsg **queue)
{
- virFDStreamMsgPtr tmp = *queue;
+ virFDStreamMsg *tmp = *queue;
while (tmp) {
- virFDStreamMsgPtr next = tmp->next;
+ virFDStreamMsg *next = tmp->next;
virFDStreamMsgFree(tmp);
tmp = next;
}
static int virFDStreamRemoveCallback(virStreamPtr stream)
{
- virFDStreamDataPtr fdst = stream->privateData;
+ virFDStreamData *fdst = stream->privateData;
int ret = -1;
if (!fdst) {
static int virFDStreamUpdateCallback(virStreamPtr stream, int events)
{
- virFDStreamDataPtr fdst = stream->privateData;
+ virFDStreamData *fdst = stream->privateData;
int ret = -1;
if (!fdst) {
void *opaque)
{
virStreamPtr stream = opaque;
- virFDStreamDataPtr fdst = stream->privateData;
+ virFDStreamData *fdst = stream->privateData;
virStreamEventCallback cb;
void *cbopaque;
virFreeCallback ff;
void *opaque,
virFreeCallback ff)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
int ret = -1;
if (!fdst) {
typedef struct _virFDStreamThreadData virFDStreamThreadData;
-typedef virFDStreamThreadData *virFDStreamThreadDataPtr;
struct _virFDStreamThreadData {
virStreamPtr st;
size_t length;
static void
-virFDStreamThreadDataFree(virFDStreamThreadDataPtr data)
+virFDStreamThreadDataFree(virFDStreamThreadData *data)
{
if (!data)
return;
static ssize_t
-virFDStreamThreadDoRead(virFDStreamDataPtr fdst,
+virFDStreamThreadDoRead(virFDStreamData *fdst,
bool sparse,
bool isBlock,
const int fdin,
static ssize_t
-virFDStreamThreadDoWrite(virFDStreamDataPtr fdst,
+virFDStreamThreadDoWrite(virFDStreamData *fdst,
bool sparse,
bool isBlock,
const int fdin,
const char *fdoutname)
{
ssize_t got = 0;
- virFDStreamMsgPtr msg = fdst->msg;
+ virFDStreamMsg *msg = fdst->msg;
bool pop = false;
switch (msg->type) {
static void
virFDStreamThread(void *opaque)
{
- virFDStreamThreadDataPtr data = opaque;
+ virFDStreamThreadData *data = opaque;
virStreamPtr st = data->st;
size_t length = data->length;
bool sparse = data->sparse;
char *fdinname = data->fdinname;
VIR_AUTOCLOSE fdout = data->fdout;
char *fdoutname = data->fdoutname;
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
bool doRead = fdst->threadDoRead;
size_t buflen = 256 * 1024;
size_t total = 0;
static int
-virFDStreamJoinWorker(virFDStreamDataPtr fdst,
+virFDStreamJoinWorker(virFDStreamData *fdst,
bool streamAbort)
{
int ret = -1;
static int
virFDStreamCloseInt(virStreamPtr st, bool streamAbort)
{
- virFDStreamDataPtr fdst;
+ virFDStreamData *fdst;
virStreamEventCallback cb;
void *opaque;
int ret;
static int virFDStreamWrite(virStreamPtr st, const char *bytes, size_t nbytes)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
g_autoptr(virFDStreamMsg) msg = NULL;
int ret = -1;
static int virFDStreamRead(virStreamPtr st, char *bytes, size_t nbytes)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
int ret = -1;
if (nbytes > INT_MAX) {
}
if (fdst->thread) {
- virFDStreamMsgPtr msg = NULL;
+ virFDStreamMsg *msg = NULL;
while (!(msg = fdst->msg)) {
if (fdst->threadQuit || fdst->threadErr) {
long long length,
unsigned int flags)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
g_autoptr(virFDStreamMsg) msg = NULL;
off_t off;
int ret = -1;
int *inData,
long long *length)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
int ret = -1;
virObjectLock(fdst);
if (fdst->thread) {
- virFDStreamMsgPtr msg;
+ virFDStreamMsg *msg;
if (fdst->threadErr)
goto cleanup;
static int virFDStreamOpenInternal(virStreamPtr st,
int fd,
- virFDStreamThreadDataPtr threadData,
+ virFDStreamThreadData *threadData,
unsigned long long length)
{
- virFDStreamDataPtr fdst;
+ virFDStreamData *fdst;
VIR_DEBUG("st=%p fd=%d threadData=%p length=%llu",
st, fd, threadData, length);
int pipefds[2] = { -1, -1 };
int tmpfd = -1;
struct stat sb;
- virFDStreamThreadDataPtr threadData = NULL;
+ virFDStreamThreadData *threadData = NULL;
VIR_DEBUG("st=%p path=%s oflags=0x%x offset=%llu length=%llu mode=0%o",
st, path, oflags, offset, length, mode);
unsigned long long length,
int oflags)
{
- virFDStreamDataPtr fdst = NULL;
+ virFDStreamData *fdst = NULL;
struct termios rawattr;
if (virFDStreamOpenFileInternal(st, path,
void *opaque,
virFDStreamInternalCloseCbFreeOpaque fcb)
{
- virFDStreamDataPtr fdst = st->privateData;
+ virFDStreamData *fdst = st->privateData;
virObjectLock(fdst);
* read-write is not supported, just a single direction. */
struct _virFileWrapperFd {
bool closed; /* Whether virFileWrapperFdClose() has been already called */
- virCommandPtr cmd; /* Child iohelper process to do the I/O. */
+ virCommand *cmd; /* Child iohelper process to do the I/O. */
char *err_msg; /* stderr of @cmd */
};
* freed with virFileWrapperFdFree(). On failure, @fd is unchanged, an
* error message is output, and NULL is returned.
*/
-virFileWrapperFdPtr
+virFileWrapperFd *
virFileWrapperFdNew(int *fd, const char *name, unsigned int flags)
{
- virFileWrapperFdPtr ret = NULL;
+ virFileWrapperFd *ret = NULL;
bool output = false;
int pipefd[2] = { -1, -1 };
int mode = -1;
return NULL;
}
#else /* WIN32 */
-virFileWrapperFdPtr
+virFileWrapperFd *
virFileWrapperFdNew(int *fd G_GNUC_UNUSED,
const char *name G_GNUC_UNUSED,
unsigned int fdflags G_GNUC_UNUSED)
* This function can be safely called multiple times on the same @wfd.
*/
int
-virFileWrapperFdClose(virFileWrapperFdPtr wfd)
+virFileWrapperFdClose(virFileWrapperFd *wfd)
{
int ret;
* closing the fd resulting from virFileWrapperFdNew().
*/
void
-virFileWrapperFdFree(virFileWrapperFdPtr wfd)
+virFileWrapperFdFree(virFileWrapperFd *wfd)
{
if (!wfd)
return;
}
int
-virFileFindHugeTLBFS(virHugeTLBFSPtr *ret_fs,
+virFileFindHugeTLBFS(virHugeTLBFS **ret_fs,
size_t *ret_nfs)
{
int ret = -1;
FILE *f = NULL;
struct mntent mb;
char mntbuf[1024];
- virHugeTLBFSPtr fs = NULL;
+ virHugeTLBFS *fs = NULL;
size_t nfs = 0;
unsigned long long default_hugepagesz = 0;
}
while (getmntent_r(f, &mb, mntbuf, sizeof(mntbuf))) {
- virHugeTLBFSPtr tmp;
+ virHugeTLBFS *tmp;
if (STRNEQ(mb.mnt_type, "hugetlbfs"))
continue;
}
int
-virFileFindHugeTLBFS(virHugeTLBFSPtr *ret_fs G_GNUC_UNUSED,
+virFileFindHugeTLBFS(virHugeTLBFS **ret_fs G_GNUC_UNUSED,
size_t *ret_nfs G_GNUC_UNUSED)
{
/* XXX implement me :-) */
* Returns: default hugepage, or
* NULL if none found
*/
-virHugeTLBFSPtr
-virFileGetDefaultHugepage(virHugeTLBFSPtr fs,
+virHugeTLBFS *
+virFileGetDefaultHugepage(virHugeTLBFS *fs,
size_t nfs)
{
size_t i;
/**
* virFileReadValueBitmap:
- * @value: pointer to virBitmapPtr to be allocated and filled in with the value
+ * @value: pointer to virBitmap * to be allocated and filled in with the value
* @format, ...: file to read from
*
* Read int from @format and put it into @value.
* fine.
*/
int
-virFileReadValueBitmap(virBitmapPtr *value, const char *format, ...)
+virFileReadValueBitmap(virBitmap **value, const char *format, ...)
{
g_autofree char *str = NULL;
g_autofree char *path = NULL;
struct _virFileWrapperFd;
typedef struct _virFileWrapperFd virFileWrapperFd;
-typedef virFileWrapperFd *virFileWrapperFdPtr;
int virFileDirectFdFlag(void);
VIR_FILE_WRAPPER_NON_BLOCKING = (1 << 1),
} virFileWrapperFdFlags;
-virFileWrapperFdPtr virFileWrapperFdNew(int *fd,
+virFileWrapperFd *virFileWrapperFdNew(int *fd,
const char *name,
unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virFileWrapperFdClose(virFileWrapperFdPtr dfd);
+int virFileWrapperFdClose(virFileWrapperFd *dfd);
-void virFileWrapperFdFree(virFileWrapperFdPtr dfd);
+void virFileWrapperFdFree(virFileWrapperFd *dfd);
int virFileLock(int fd, bool shared, off_t start, off_t len, bool waitForLock)
G_GNUC_NO_INLINE;
void virBuildPathInternal(char **path, ...) G_GNUC_NULL_TERMINATED;
typedef struct _virHugeTLBFS virHugeTLBFS;
-typedef virHugeTLBFS *virHugeTLBFSPtr;
struct _virHugeTLBFS {
char *mnt_dir; /* Where the FS is mount to */
unsigned long long size; /* page size in kibibytes */
int virFileGetHugepageSize(const char *path,
unsigned long long *size);
-int virFileFindHugeTLBFS(virHugeTLBFSPtr *ret_fs,
+int virFileFindHugeTLBFS(virHugeTLBFS **ret_fs,
size_t *ret_nfs);
-virHugeTLBFSPtr virFileGetDefaultHugepage(virHugeTLBFSPtr fs,
+virHugeTLBFS *virFileGetDefaultHugepage(virHugeTLBFS *fs,
size_t nfs);
int virFileSetupDev(const char *path,
G_GNUC_PRINTF(2, 3);
int virFileReadValueUllong(unsigned long long *value, const char *format, ...)
G_GNUC_PRINTF(2, 3);
-int virFileReadValueBitmap(virBitmapPtr *value, const char *format, ...)
+int virFileReadValueBitmap(virBitmap **value, const char *format, ...)
G_GNUC_PRINTF(2, 3);
int virFileReadValueScaledInt(unsigned long long *value, const char *format, ...)
G_GNUC_PRINTF(2, 3);
};
-static virClassPtr virFileCacheClass;
+static virClass *virFileCacheClass;
static void
-virFileCachePrivFree(virFileCachePtr cache)
+virFileCachePrivFree(virFileCache *cache)
{
if (cache->priv && cache->handlers.privFree)
cache->handlers.privFree(cache->priv);
static void
virFileCacheDispose(void *obj)
{
- virFileCachePtr cache = obj;
+ virFileCache *cache = obj;
g_free(cache->dir);
g_free(cache->suffix);
static char *
-virFileCacheGetFileName(virFileCachePtr cache,
+virFileCacheGetFileName(virFileCache *cache,
const char *name)
{
g_autofree char *namehash = NULL;
static int
-virFileCacheLoad(virFileCachePtr cache,
+virFileCacheLoad(virFileCache *cache,
const char *name,
void **data)
{
static int
-virFileCacheSave(virFileCachePtr cache,
+virFileCacheSave(virFileCache *cache,
const char *name,
void *data)
{
static void *
-virFileCacheNewData(virFileCachePtr cache,
+virFileCacheNewData(virFileCache *cache,
const char *name)
{
void *data = NULL;
*
* Returns new cache object or NULL on error.
*/
-virFileCachePtr
+virFileCache *
virFileCacheNew(const char *dir,
const char *suffix,
virFileCacheHandlers *handlers)
{
- virFileCachePtr cache;
+ virFileCache *cache;
if (virFileCacheInitialize() < 0)
return NULL;
static void
-virFileCacheValidate(virFileCachePtr cache,
+virFileCacheValidate(virFileCache *cache,
const char *name,
void **data)
{
* unrefing the data.
*/
void *
-virFileCacheLookup(virFileCachePtr cache,
+virFileCacheLookup(virFileCache *cache,
const char *name)
{
void *data = NULL;
* unrefing the data.
*/
void *
-virFileCacheLookupByFunc(virFileCachePtr cache,
+virFileCacheLookupByFunc(virFileCache *cache,
virHashSearcher iter,
const void *iterData)
{
* Returns private data used by @handlers.
*/
void *
-virFileCacheGetPriv(virFileCachePtr cache)
+virFileCacheGetPriv(virFileCache *cache)
{
void *priv;
* set, privFree() will be called on the old @priv before setting a new one.
*/
void
-virFileCacheSetPriv(virFileCachePtr cache,
+virFileCacheSetPriv(virFileCache *cache,
void *priv)
{
virObjectLock(cache);
* Returns 0 on success, -1 on error.
*/
int
-virFileCacheInsertData(virFileCachePtr cache,
+virFileCacheInsertData(virFileCache *cache,
const char *name,
void *data)
{
#include "virhash.h"
typedef struct _virFileCache virFileCache;
-typedef virFileCache *virFileCachePtr;
/**
* virFileCacheIsValidPtr:
(*virFileCachePrivFreePtr)(void *priv);
typedef struct _virFileCacheHandlers virFileCacheHandlers;
-typedef virFileCacheHandlers *virFileCacheHandlersPtr;
struct _virFileCacheHandlers {
virFileCacheIsValidPtr isValid;
virFileCacheNewDataPtr newData;
virFileCachePrivFreePtr privFree;
};
-virFileCachePtr
+virFileCache *
virFileCacheNew(const char *dir,
const char *suffix,
virFileCacheHandlers *handlers);
void *
-virFileCacheLookup(virFileCachePtr cache,
+virFileCacheLookup(virFileCache *cache,
const char *name);
void *
-virFileCacheLookupByFunc(virFileCachePtr cache,
+virFileCacheLookupByFunc(virFileCache *cache,
virHashSearcher iter,
const void *iterData);
void *
-virFileCacheGetPriv(virFileCachePtr cache);
+virFileCacheGetPriv(virFileCache *cache);
void
-virFileCacheSetPriv(virFileCachePtr cache,
+virFileCacheSetPriv(virFileCache *cache,
void *priv);
int
-virFileCacheInsertData(virFileCachePtr cache,
+virFileCacheInsertData(virFileCache *cache,
const char *name,
void *data);
VIR_LOG_INIT("util.firewall");
typedef struct _virFirewallGroup virFirewallGroup;
-typedef virFirewallGroup *virFirewallGroupPtr;
VIR_ENUM_DECL(virFirewallLayerCommand);
VIR_ENUM_IMPL(virFirewallLayerCommand,
unsigned int rollbackFlags;
size_t naction;
- virFirewallRulePtr *action;
+ virFirewallRule **action;
size_t nrollback;
- virFirewallRulePtr *rollback;
+ virFirewallRule **rollback;
bool addingRollback;
};
int err;
size_t ngroups;
- virFirewallGroupPtr *groups;
+ virFirewallGroup **groups;
size_t currentGroup;
};
return virFirewallValidateBackend(backend);
}
-static virFirewallGroupPtr
+static virFirewallGroup *
virFirewallGroupNew(void)
{
- virFirewallGroupPtr group;
+ virFirewallGroup *group;
group = g_new0(virFirewallGroup, 1);
*
* Returns the new firewall ruleset
*/
-virFirewallPtr virFirewallNew(void)
+virFirewall *virFirewallNew(void)
{
- virFirewallPtr firewall;
+ virFirewall *firewall;
if (virFirewallInitialize() < 0)
return NULL;
static void
-virFirewallRuleFree(virFirewallRulePtr rule)
+virFirewallRuleFree(virFirewallRule *rule)
{
size_t i;
static void
-virFirewallGroupFree(virFirewallGroupPtr group)
+virFirewallGroupFree(virFirewallGroup *group)
{
size_t i;
* Release all memory associated with the firewall
* ruleset
*/
-void virFirewallFree(virFirewallPtr firewall)
+void virFirewallFree(virFirewall *firewall)
{
size_t i;
rule->args[rule->argsLen++] = g_strdup(str); \
} while (0)
-static virFirewallRulePtr
-virFirewallAddRuleFullV(virFirewallPtr firewall,
+static virFirewallRule *
+virFirewallAddRuleFullV(virFirewall *firewall,
virFirewallLayer layer,
bool ignoreErrors,
virFirewallQueryCallback cb,
void *opaque,
va_list args)
{
- virFirewallGroupPtr group;
- virFirewallRulePtr rule;
+ virFirewallGroup *group;
+ virFirewallRule *rule;
char *str;
VIR_FIREWALL_RETURN_NULL_IF_ERROR(firewall);
*
* Returns the new rule
*/
-virFirewallRulePtr virFirewallAddRuleFull(virFirewallPtr firewall,
+virFirewallRule *virFirewallAddRuleFull(virFirewall *firewall,
virFirewallLayer layer,
bool ignoreErrors,
virFirewallQueryCallback cb,
void *opaque,
...)
{
- virFirewallRulePtr rule;
+ virFirewallRule *rule;
va_list args;
va_start(args, opaque);
rule = virFirewallAddRuleFullV(firewall, layer, ignoreErrors, cb, opaque, args);
*
* Remove a rule from the current transaction
*/
-void virFirewallRemoveRule(virFirewallPtr firewall,
- virFirewallRulePtr rule)
+void virFirewallRemoveRule(virFirewall *firewall,
+ virFirewallRule *rule)
{
size_t i;
- virFirewallGroupPtr group;
+ virFirewallGroup *group;
/* Explicitly not checking firewall->err too,
* because if rule was partially created
}
-void virFirewallRuleAddArg(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArg(virFirewall *firewall,
+ virFirewallRule *rule,
const char *arg)
{
VIR_FIREWALL_RULE_RETURN_IF_ERROR(firewall, rule);
}
-void virFirewallRuleAddArgFormat(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgFormat(virFirewall *firewall,
+ virFirewallRule *rule,
const char *fmt, ...)
{
g_autofree char *arg = NULL;
}
-void virFirewallRuleAddArgSet(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgSet(virFirewall *firewall,
+ virFirewallRule *rule,
const char *const *args)
{
VIR_FIREWALL_RULE_RETURN_IF_ERROR(firewall, rule);
}
-void virFirewallRuleAddArgList(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgList(virFirewall *firewall,
+ virFirewallRule *rule,
...)
{
va_list list;
}
-size_t virFirewallRuleGetArgCount(virFirewallRulePtr rule)
+size_t virFirewallRuleGetArgCount(virFirewallRule *rule)
{
if (!rule)
return 0;
* be used to provide rules to rollback upon transaction
* failure
*/
-void virFirewallStartTransaction(virFirewallPtr firewall,
+void virFirewallStartTransaction(virFirewall *firewall,
unsigned int flags)
{
- virFirewallGroupPtr group;
+ virFirewallGroup *group;
VIR_FIREWALL_RETURN_IF_ERROR(firewall);
* should be used to indicate the beginning of the next
* transactional ruleset.
*/
-void virFirewallStartRollback(virFirewallPtr firewall,
+void virFirewallStartRollback(virFirewall *firewall,
unsigned int flags)
{
- virFirewallGroupPtr group;
+ virFirewallGroup *group;
VIR_FIREWALL_RETURN_IF_ERROR(firewall);
static char *
-virFirewallRuleToString(virFirewallRulePtr rule)
+virFirewallRuleToString(virFirewallRule *rule)
{
const char *bin = virFirewallLayerCommandTypeToString(rule->layer);
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
static int
-virFirewallApplyRuleDirect(virFirewallRulePtr rule,
+virFirewallApplyRuleDirect(virFirewallRule *rule,
bool ignoreErrors,
char **output)
{
static int G_GNUC_UNUSED
-virFirewallApplyRuleFirewallD(virFirewallRulePtr rule,
+virFirewallApplyRuleFirewallD(virFirewallRule *rule,
bool ignoreErrors,
char **output)
{
static int
-virFirewallApplyRule(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+virFirewallApplyRule(virFirewall *firewall,
+ virFirewallRule *rule,
bool ignoreErrors)
{
g_autofree char *output = NULL;
}
static int
-virFirewallApplyGroup(virFirewallPtr firewall,
+virFirewallApplyGroup(virFirewall *firewall,
size_t idx)
{
- virFirewallGroupPtr group = firewall->groups[idx];
+ virFirewallGroup *group = firewall->groups[idx];
bool ignoreErrors = (group->actionFlags & VIR_FIREWALL_TRANSACTION_IGNORE_ERRORS);
size_t i;
static void
-virFirewallRollbackGroup(virFirewallPtr firewall,
+virFirewallRollbackGroup(virFirewall *firewall,
size_t idx)
{
- virFirewallGroupPtr group = firewall->groups[idx];
+ virFirewallGroup *group = firewall->groups[idx];
size_t i;
VIR_INFO("Starting rollback for group %p", group);
int
-virFirewallApply(virFirewallPtr firewall)
+virFirewallApply(virFirewall *firewall)
{
size_t i, j;
int ret = -1;
#include "internal.h"
typedef struct _virFirewall virFirewall;
-typedef virFirewall *virFirewallPtr;
typedef struct _virFirewallRule virFirewallRule;
-typedef virFirewallRule *virFirewallRulePtr;
typedef enum {
VIR_FIREWALL_LAYER_ETHERNET,
VIR_FIREWALL_LAYER_LAST,
} virFirewallLayer;
-virFirewallPtr virFirewallNew(void);
+virFirewall *virFirewallNew(void);
-void virFirewallFree(virFirewallPtr firewall);
+void virFirewallFree(virFirewall *firewall);
/**
* virFirewallAddRule:
#define virFirewallAddRule(firewall, layer, ...) \
virFirewallAddRuleFull(firewall, layer, false, NULL, NULL, __VA_ARGS__)
-typedef int (*virFirewallQueryCallback)(virFirewallPtr firewall,
+typedef int (*virFirewallQueryCallback)(virFirewall *firewall,
virFirewallLayer layer,
const char *const *lines,
void *opaque);
-virFirewallRulePtr virFirewallAddRuleFull(virFirewallPtr firewall,
+virFirewallRule *virFirewallAddRuleFull(virFirewall *firewall,
virFirewallLayer layer,
bool ignoreErrors,
virFirewallQueryCallback cb,
...)
G_GNUC_NULL_TERMINATED;
-void virFirewallRemoveRule(virFirewallPtr firewall,
- virFirewallRulePtr rule);
+void virFirewallRemoveRule(virFirewall *firewall,
+ virFirewallRule *rule);
-void virFirewallRuleAddArg(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArg(virFirewall *firewall,
+ virFirewallRule *rule,
const char *arg)
ATTRIBUTE_NONNULL(3);
-void virFirewallRuleAddArgFormat(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgFormat(virFirewall *firewall,
+ virFirewallRule *rule,
const char *fmt, ...)
ATTRIBUTE_NONNULL(3) G_GNUC_PRINTF(3, 4);
-void virFirewallRuleAddArgSet(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgSet(virFirewall *firewall,
+ virFirewallRule *rule,
const char *const *args)
ATTRIBUTE_NONNULL(3);
-void virFirewallRuleAddArgList(virFirewallPtr firewall,
- virFirewallRulePtr rule,
+void virFirewallRuleAddArgList(virFirewall *firewall,
+ virFirewallRule *rule,
...)
G_GNUC_NULL_TERMINATED;
-size_t virFirewallRuleGetArgCount(virFirewallRulePtr rule);
+size_t virFirewallRuleGetArgCount(virFirewallRule *rule);
typedef enum {
/* Ignore all errors when applying rules, so no
VIR_FIREWALL_TRANSACTION_IGNORE_ERRORS = (1 << 0),
} virFirewallTransactionFlags;
-void virFirewallStartTransaction(virFirewallPtr firewall,
+void virFirewallStartTransaction(virFirewall *firewall,
unsigned int flags);
typedef enum {
VIR_FIREWALL_ROLLBACK_INHERIT_PREVIOUS = (1 << 0),
} virFirewallRollbackFlags;
-void virFirewallStartRollback(virFirewallPtr firewall,
+void virFirewallStartRollback(virFirewall *firewall,
unsigned int flags);
-int virFirewallApply(virFirewallPtr firewall);
+int virFirewallApply(virFirewall *firewall);
void virFirewallBackendSynchronize(void);
void
-virFirmwareFree(virFirmwarePtr firmware)
+virFirmwareFree(virFirmware *firmware)
{
if (!firmware)
return;
void
-virFirmwareFreeList(virFirmwarePtr *firmwares, size_t nfirmwares)
+virFirmwareFreeList(virFirmware **firmwares, size_t nfirmwares)
{
size_t i;
int
-virFirmwareParse(const char *str, virFirmwarePtr firmware)
+virFirmwareParse(const char *str, virFirmware *firmware)
{
int ret = -1;
char **token;
int
virFirmwareParseList(const char *list,
- virFirmwarePtr **firmwares,
+ virFirmware ***firmwares,
size_t *nfirmwares)
{
int ret = -1;
}
if (i) {
- *firmwares = g_new0(virFirmwarePtr, i / 2);
+ *firmwares = g_new0(virFirmware *, i / 2);
*nfirmwares = i / 2;
for (j = 0; j < i / 2; j++) {
- virFirmwarePtr *fws = *firmwares;
+ virFirmware **fws = *firmwares;
fws[j] = g_new0(virFirmware, 1);
fws[j]->name = g_strdup(token[2 * j]);
#include "internal.h"
typedef struct _virFirmware virFirmware;
-typedef virFirmware *virFirmwarePtr;
-
struct _virFirmware {
char *name;
char *nvram;
void
-virFirmwareFree(virFirmwarePtr firmware);
+virFirmwareFree(virFirmware *firmware);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virFirmware, virFirmwareFree);
void
-virFirmwareFreeList(virFirmwarePtr *firmwares, size_t nfirmwares);
+virFirmwareFreeList(virFirmware **firmwares, size_t nfirmwares);
int
-virFirmwareParse(const char *str, virFirmwarePtr firmware)
+virFirmwareParse(const char *str, virFirmware *firmware)
ATTRIBUTE_NONNULL(2);
int
virFirmwareParseList(const char *list,
- virFirmwarePtr **firmwares,
+ virFirmware ***firmwares,
size_t *nfirmwares)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
} virGICImplementation;
typedef struct _virGICCapability virGICCapability;
-typedef virGICCapability *virGICCapabilityPtr;
struct _virGICCapability {
virGICVersion version;
virGICImplementation implementation;
GHashTable *hash;
};
-static virClassPtr virHashAtomicClass;
+static virClass *virHashAtomicClass;
static void virHashAtomicDispose(void *obj);
static int virHashAtomicOnceInit(void)
}
-virHashAtomicPtr
+virHashAtomic *
virHashAtomicNew(virHashDataFree dataFree)
{
- virHashAtomicPtr hash;
+ virHashAtomic *hash;
if (virHashAtomicInitialize() < 0)
return NULL;
static void
virHashAtomicDispose(void *obj)
{
- virHashAtomicPtr hash = obj;
+ virHashAtomic *hash = obj;
virHashFree(hash->hash);
}
}
int
-virHashAtomicUpdate(virHashAtomicPtr table,
+virHashAtomicUpdate(virHashAtomic *table,
const char *name,
void *userdata)
{
}
void *
-virHashAtomicSteal(virHashAtomicPtr table,
+virHashAtomicSteal(virHashAtomic *table,
const char *name)
{
void *data;
virHashIterator iter,
void *opaque)
{
- g_autofree virHashKeyValuePairPtr items = virHashGetItems(table, NULL, false);
+ g_autofree virHashKeyValuePair *items = virHashGetItems(table, NULL, false);
size_t i;
if (!items)
virHashIterator iter,
void *opaque)
{
- g_autofree virHashKeyValuePairPtr items = virHashGetItems(table, NULL, true);
+ g_autofree virHashKeyValuePair *items = virHashGetItems(table, NULL, true);
size_t i;
if (!items)
}
-virHashKeyValuePairPtr
+virHashKeyValuePair *
virHashGetItems(GHashTable *table,
size_t *nitems,
bool sortKeys)
#pragma once
typedef struct _virHashAtomic virHashAtomic;
-typedef virHashAtomic *virHashAtomicPtr;
/*
* function types:
* Constructor and destructor.
*/
GHashTable *virHashNew(virHashDataFree dataFree);
-virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree);
+virHashAtomic *virHashAtomicNew(virHashDataFree dataFree);
void virHashFree(GHashTable *table);
ssize_t virHashSize(GHashTable *table);
int virHashUpdateEntry(GHashTable *table,
const char *name,
void *userdata);
-int virHashAtomicUpdate(virHashAtomicPtr table,
+int virHashAtomicUpdate(virHashAtomic *table,
const char *name,
void *userdata);
* Retrieve & remove the userdata.
*/
void *virHashSteal(GHashTable *table, const char *name);
-void *virHashAtomicSteal(virHashAtomicPtr table,
+void *virHashAtomicSteal(virHashAtomic *table,
const char *name);
/*
* to be used somewhere else.
*/
typedef struct _virHashKeyValuePair virHashKeyValuePair;
-typedef virHashKeyValuePair *virHashKeyValuePairPtr;
struct _virHashKeyValuePair {
const void *key;
const void *value;
};
-virHashKeyValuePairPtr virHashGetItems(GHashTable *table,
+virHashKeyValuePair *virHashGetItems(GHashTable *table,
size_t *nitems,
bool sortedKeys);
return 0;
}
-virBitmapPtr
+virBitmap *
virHostCPUGetSiblingsList(unsigned int cpu)
{
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
int rv = -1;
rv = virFileReadValueBitmap(&ret,
static unsigned long
virHostCPUCountThreadSiblings(unsigned int cpu)
{
- virBitmapPtr siblings_map;
+ virBitmap *siblings_map;
unsigned long ret = 0;
if (!(siblings_map = virHostCPUGetSiblingsList(cpu)))
ATTRIBUTE_NONNULL(9)
virHostCPUParseNode(const char *node,
virArch arch,
- virBitmapPtr present_cpus_map,
- virBitmapPtr online_cpus_map,
+ virBitmap *present_cpus_map,
+ virBitmap *online_cpus_map,
int threads_per_subcore,
int *sockets,
int *cores,
int processors = 0;
g_autoptr(DIR) cpudir = NULL;
struct dirent *cpudirent = NULL;
- virBitmapPtr node_cpus_map = NULL;
- virBitmapPtr sockets_map = NULL;
- virBitmapPtr *cores_maps = NULL;
+ virBitmap *node_cpus_map = NULL;
+ virBitmap *sockets_map = NULL;
+ virBitmap **cores_maps = NULL;
int npresent_cpus = virBitmapSize(present_cpus_map);
unsigned int sock_max = 0;
unsigned int sock;
sock_max++;
/* allocate cores maps for each socket */
- cores_maps = g_new0(virBitmapPtr, sock_max);
+ cores_maps = g_new0(virBitmap *, sock_max);
for (i = 0; i < sock_max; i++)
cores_maps[i] = virBitmapNew(0);
static bool
virHostCPUHasValidSubcoreConfiguration(int threads_per_subcore)
{
- virBitmapPtr online_cpus = NULL;
+ virBitmap *online_cpus = NULL;
int cpu = -1;
bool ret = false;
unsigned int *cores,
unsigned int *threads)
{
- virBitmapPtr present_cpus_map = NULL;
- virBitmapPtr online_cpus_map = NULL;
+ virBitmap *present_cpus_map = NULL;
+ virBitmap *online_cpus_map = NULL;
g_autoptr(DIR) nodedir = NULL;
struct dirent *nodedirent = NULL;
int nodecpus, nodecores, nodesockets, nodethreads, offline = 0;
#endif
}
-virBitmapPtr
+virBitmap *
virHostCPUGetPresentBitmap(void)
{
#ifdef __linux__
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
virFileReadValueBitmap(&ret, "%s/cpu/present", SYSFS_SYSTEM_PATH);
#endif
}
-virBitmapPtr
+virBitmap *
virHostCPUGetOnlineBitmap(void)
{
#ifdef __linux__
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
virFileReadValueBitmap(&ret, "%s/cpu/online", SYSFS_SYSTEM_PATH);
* the caller having to handle it outside the function, returns
* a virBitmap with all the possible CPUs in the host, up to
* virHostCPUGetCount(). */
-virBitmapPtr
+virBitmap *
virHostCPUGetAvailableCPUsBitmap(void)
{
g_autoptr(virBitmap) bitmap = NULL;
* Returns pointer to the TSC info structure on success,
* NULL when TSC cannot be probed otherwise.
*/
-virHostCPUTscInfoPtr
+virHostCPUTscInfo *
virHostCPUGetTscInfo(void)
{
- virHostCPUTscInfoPtr info;
+ virHostCPUTscInfo *info;
VIR_AUTOCLOSE kvmFd = -1;
VIR_AUTOCLOSE vmFd = -1;
VIR_AUTOCLOSE vcpuFd = -1;
return -1;
}
-virHostCPUTscInfoPtr
+virHostCPUTscInfo *
virHostCPUGetTscInfo(void)
{
virReportSystemError(ENOSYS, "%s",
typedef struct _virHostCPUTscInfo virHostCPUTscInfo;
-typedef virHostCPUTscInfo *virHostCPUTscInfoPtr;
struct _virHostCPUTscInfo {
unsigned long long frequency;
virTristateBool scaling;
unsigned int flags);
bool virHostCPUHasBitmap(void);
-virBitmapPtr virHostCPUGetPresentBitmap(void);
-virBitmapPtr virHostCPUGetOnlineBitmap(void);
-virBitmapPtr virHostCPUGetAvailableCPUsBitmap(void);
+virBitmap *virHostCPUGetPresentBitmap(void);
+virBitmap *virHostCPUGetOnlineBitmap(void);
+virBitmap *virHostCPUGetAvailableCPUsBitmap(void);
int virHostCPUGetCount(void);
int virHostCPUGetThreadsPerSubcore(virArch arch) G_GNUC_NO_INLINE;
int virHostCPUGetDie(unsigned int cpu, unsigned int *die);
int virHostCPUGetCore(unsigned int cpu, unsigned int *core);
-virBitmapPtr virHostCPUGetSiblingsList(unsigned int cpu);
+virBitmap *virHostCPUGetSiblingsList(unsigned int cpu);
#endif
int virHostCPUGetOnline(unsigned int cpu, bool *online);
int virHostCPUGetMSR(unsigned long index,
uint64_t *msr);
-virHostCPUTscInfoPtr virHostCPUGetTscInfo(void);
+virHostCPUTscInfo *virHostCPUGetTscInfo(void);
int virHostCPUGetSignature(char **signature);
*
* Returns: a reference to the current identity, or NULL
*/
-virIdentityPtr virIdentityGetCurrent(void)
+virIdentity *virIdentityGetCurrent(void)
{
- virIdentityPtr ident;
+ virIdentity *ident;
if (virIdentityInitialize() < 0)
return NULL;
*
* Returns 0 on success, or -1 on error
*/
-int virIdentitySetCurrent(virIdentityPtr ident)
+int virIdentitySetCurrent(virIdentity *ident)
{
g_autoptr(virIdentity) old = NULL;
*
* Returns a reference to the system identity, or NULL
*/
-virIdentityPtr virIdentityGetSystem(void)
+virIdentity *virIdentityGetSystem(void)
{
g_autofree char *username = NULL;
g_autofree char *groupname = NULL;
*
* Returns: a new empty identity
*/
-virIdentityPtr virIdentityNew(void)
+virIdentity *virIdentityNew(void)
{
return VIR_IDENTITY(g_object_new(VIR_TYPE_IDENTITY, NULL));
}
static void virIdentityFinalize(GObject *object)
{
- virIdentityPtr ident = VIR_IDENTITY(object);
+ virIdentity *ident = VIR_IDENTITY(object);
virTypedParamsFree(ident->params, ident->nparams);
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetUserName(virIdentityPtr ident,
+int virIdentityGetUserName(virIdentity *ident,
const char **username)
{
*username = NULL;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetUNIXUserID(virIdentityPtr ident,
+int virIdentityGetUNIXUserID(virIdentity *ident,
uid_t *uid)
{
unsigned long long val;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetGroupName(virIdentityPtr ident,
+int virIdentityGetGroupName(virIdentity *ident,
const char **groupname)
{
*groupname = NULL;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetUNIXGroupID(virIdentityPtr ident,
+int virIdentityGetUNIXGroupID(virIdentity *ident,
gid_t *gid)
{
unsigned long long val;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetProcessID(virIdentityPtr ident,
+int virIdentityGetProcessID(virIdentity *ident,
pid_t *pid)
{
long long val;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetProcessTime(virIdentityPtr ident,
+int virIdentityGetProcessTime(virIdentity *ident,
unsigned long long *timestamp)
{
*timestamp = 0;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetSASLUserName(virIdentityPtr ident,
+int virIdentityGetSASLUserName(virIdentity *ident,
const char **username)
{
*username = NULL;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetX509DName(virIdentityPtr ident,
+int virIdentityGetX509DName(virIdentity *ident,
const char **dname)
{
*dname = NULL;
/*
* Returns: 0 if not present, 1 if present, -1 on error
*/
-int virIdentityGetSELinuxContext(virIdentityPtr ident,
+int virIdentityGetSELinuxContext(virIdentity *ident,
const char **context)
{
*context = NULL;
}
-int virIdentitySetUserName(virIdentityPtr ident,
+int virIdentitySetUserName(virIdentity *ident,
const char *username)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetUNIXUserID(virIdentityPtr ident,
+int virIdentitySetUNIXUserID(virIdentity *ident,
uid_t uid)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetGroupName(virIdentityPtr ident,
+int virIdentitySetGroupName(virIdentity *ident,
const char *groupname)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetUNIXGroupID(virIdentityPtr ident,
+int virIdentitySetUNIXGroupID(virIdentity *ident,
gid_t gid)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetProcessID(virIdentityPtr ident,
+int virIdentitySetProcessID(virIdentity *ident,
pid_t pid)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetProcessTime(virIdentityPtr ident,
+int virIdentitySetProcessTime(virIdentity *ident,
unsigned long long timestamp)
{
if (virTypedParamsGet(ident->params,
-int virIdentitySetSASLUserName(virIdentityPtr ident,
+int virIdentitySetSASLUserName(virIdentity *ident,
const char *username)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetX509DName(virIdentityPtr ident,
+int virIdentitySetX509DName(virIdentity *ident,
const char *dname)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetSELinuxContext(virIdentityPtr ident,
+int virIdentitySetSELinuxContext(virIdentity *ident,
const char *context)
{
if (virTypedParamsGet(ident->params,
}
-int virIdentitySetParameters(virIdentityPtr ident,
+int virIdentitySetParameters(virIdentity *ident,
virTypedParameterPtr params,
int nparams)
{
}
-int virIdentityGetParameters(virIdentityPtr ident,
+int virIdentityGetParameters(virIdentity *ident,
virTypedParameterPtr *params,
int *nparams)
{
#define VIR_TYPE_IDENTITY vir_identity_get_type()
G_DECLARE_FINAL_TYPE(virIdentity, vir_identity, VIR, IDENTITY, GObject);
-typedef virIdentity *virIdentityPtr;
+virIdentity *virIdentityGetCurrent(void);
+int virIdentitySetCurrent(virIdentity *ident);
-virIdentityPtr virIdentityGetCurrent(void);
-int virIdentitySetCurrent(virIdentityPtr ident);
+virIdentity *virIdentityGetSystem(void);
-virIdentityPtr virIdentityGetSystem(void);
+virIdentity *virIdentityNew(void);
-virIdentityPtr virIdentityNew(void);
-
-int virIdentityGetUserName(virIdentityPtr ident,
+int virIdentityGetUserName(virIdentity *ident,
const char **username);
-int virIdentityGetUNIXUserID(virIdentityPtr ident,
+int virIdentityGetUNIXUserID(virIdentity *ident,
uid_t *uid);
-int virIdentityGetGroupName(virIdentityPtr ident,
+int virIdentityGetGroupName(virIdentity *ident,
const char **groupname);
-int virIdentityGetUNIXGroupID(virIdentityPtr ident,
+int virIdentityGetUNIXGroupID(virIdentity *ident,
gid_t *gid);
-int virIdentityGetProcessID(virIdentityPtr ident,
+int virIdentityGetProcessID(virIdentity *ident,
pid_t *pid);
-int virIdentityGetProcessTime(virIdentityPtr ident,
+int virIdentityGetProcessTime(virIdentity *ident,
unsigned long long *timestamp);
-int virIdentityGetSASLUserName(virIdentityPtr ident,
+int virIdentityGetSASLUserName(virIdentity *ident,
const char **username);
-int virIdentityGetX509DName(virIdentityPtr ident,
+int virIdentityGetX509DName(virIdentity *ident,
const char **dname);
-int virIdentityGetSELinuxContext(virIdentityPtr ident,
+int virIdentityGetSELinuxContext(virIdentity *ident,
const char **context);
-int virIdentitySetUserName(virIdentityPtr ident,
+int virIdentitySetUserName(virIdentity *ident,
const char *username);
-int virIdentitySetUNIXUserID(virIdentityPtr ident,
+int virIdentitySetUNIXUserID(virIdentity *ident,
uid_t uid);
-int virIdentitySetGroupName(virIdentityPtr ident,
+int virIdentitySetGroupName(virIdentity *ident,
const char *groupname);
-int virIdentitySetUNIXGroupID(virIdentityPtr ident,
+int virIdentitySetUNIXGroupID(virIdentity *ident,
gid_t gid);
-int virIdentitySetProcessID(virIdentityPtr ident,
+int virIdentitySetProcessID(virIdentity *ident,
pid_t pid);
-int virIdentitySetProcessTime(virIdentityPtr ident,
+int virIdentitySetProcessTime(virIdentity *ident,
unsigned long long timestamp);
-int virIdentitySetSASLUserName(virIdentityPtr ident,
+int virIdentitySetSASLUserName(virIdentity *ident,
const char *username);
-int virIdentitySetX509DName(virIdentityPtr ident,
+int virIdentitySetX509DName(virIdentity *ident,
const char *dname);
-int virIdentitySetSELinuxContext(virIdentityPtr ident,
+int virIdentitySetSELinuxContext(virIdentity *ident,
const char *context);
-int virIdentitySetParameters(virIdentityPtr ident,
+int virIdentitySetParameters(virIdentity *ident,
virTypedParameterPtr params,
int nparams);
-int virIdentityGetParameters(virIdentityPtr ident,
+int virIdentityGetParameters(virIdentity *ident,
virTypedParameterPtr *params,
int *nparams);
static int
-iptablesPrivateChainCreate(virFirewallPtr fw,
+iptablesPrivateChainCreate(virFirewall *fw,
virFirewallLayer layer,
const char *const *lines,
void *opaque)
static void
-iptablesInput(virFirewallPtr fw,
+iptablesInput(virFirewall *fw,
virFirewallLayer layer,
bool pvt,
const char *iface,
}
static void
-iptablesOutput(virFirewallPtr fw,
+iptablesOutput(virFirewall *fw,
virFirewallLayer layer,
bool pvt,
const char *iface,
* the given @iface interface for TCP packets
*/
void
-iptablesAddTcpInput(virFirewallPtr fw,
+iptablesAddTcpInput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* @port on the given @iface interface for TCP packets
*/
void
-iptablesRemoveTcpInput(virFirewallPtr fw,
+iptablesRemoveTcpInput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* the given @iface interface for UDP packets
*/
void
-iptablesAddUdpInput(virFirewallPtr fw,
+iptablesAddUdpInput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* @port on the given @iface interface for UDP packets
*/
void
-iptablesRemoveUdpInput(virFirewallPtr fw,
+iptablesRemoveUdpInput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* the given @iface interface for TCP packets
*/
void
-iptablesAddTcpOutput(virFirewallPtr fw,
+iptablesAddTcpOutput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* @port from the given @iface interface for TCP packets
*/
void
-iptablesRemoveTcpOutput(virFirewallPtr fw,
+iptablesRemoveTcpOutput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* the given @iface interface for UDP packets
*/
void
-iptablesAddUdpOutput(virFirewallPtr fw,
+iptablesAddUdpOutput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* @port from the given @iface interface for UDP packets
*/
void
-iptablesRemoveUdpOutput(virFirewallPtr fw,
+iptablesRemoveUdpOutput(virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port)
* to proceed to WAN
*/
static int
-iptablesForwardAllowOut(virFirewallPtr fw,
+iptablesForwardAllowOut(virFirewall *fw,
bool pvt,
virSocketAddr *netaddr,
unsigned int prefix,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesAddForwardAllowOut(virFirewallPtr fw,
+iptablesAddForwardAllowOut(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesRemoveForwardAllowOut(virFirewallPtr fw,
+iptablesRemoveForwardAllowOut(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
* and associated with an existing connection
*/
static int
-iptablesForwardAllowRelatedIn(virFirewallPtr fw,
+iptablesForwardAllowRelatedIn(virFirewall *fw,
bool pvt,
virSocketAddr *netaddr,
unsigned int prefix,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesAddForwardAllowRelatedIn(virFirewallPtr fw,
+iptablesAddForwardAllowRelatedIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesRemoveForwardAllowRelatedIn(virFirewallPtr fw,
+iptablesRemoveForwardAllowRelatedIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
/* Allow all traffic destined to the bridge, with a valid network address
*/
static int
-iptablesForwardAllowIn(virFirewallPtr fw,
+iptablesForwardAllowIn(virFirewall *fw,
bool pvt,
virSocketAddr *netaddr,
unsigned int prefix,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesAddForwardAllowIn(virFirewallPtr fw,
+iptablesAddForwardAllowIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesRemoveForwardAllowIn(virFirewallPtr fw,
+iptablesRemoveForwardAllowIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
}
static void
-iptablesForwardAllowCross(virFirewallPtr fw,
+iptablesForwardAllowCross(virFirewall *fw,
virFirewallLayer layer,
bool pvt,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesAddForwardAllowCross(virFirewallPtr fw,
+iptablesAddForwardAllowCross(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesRemoveForwardAllowCross(virFirewallPtr fw,
+iptablesRemoveForwardAllowCross(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
}
static void
-iptablesForwardRejectOut(virFirewallPtr fw,
+iptablesForwardRejectOut(virFirewall *fw,
virFirewallLayer layer,
bool pvt,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesAddForwardRejectOut(virFirewallPtr fw,
+iptablesAddForwardRejectOut(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesRemoveForwardRejectOut(virFirewallPtr fw,
+iptablesRemoveForwardRejectOut(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
static void
-iptablesForwardRejectIn(virFirewallPtr fw,
+iptablesForwardRejectIn(virFirewall *fw,
virFirewallLayer layer,
bool pvt,
const char *iface,
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesAddForwardRejectIn(virFirewallPtr fw,
+iptablesAddForwardRejectIn(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
* Returns 0 in case of success or an error code otherwise
*/
void
-iptablesRemoveForwardRejectIn(virFirewallPtr fw,
+iptablesRemoveForwardRejectIn(virFirewall *fw,
virFirewallLayer layer,
const char *iface)
{
* with the bridge
*/
static int
-iptablesForwardMasquerade(virFirewallPtr fw,
+iptablesForwardMasquerade(virFirewall *fw,
bool pvt,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
- virSocketAddrRangePtr addr,
- virPortRangePtr port,
+ virSocketAddrRange *addr,
+ virPortRange *port,
const char *protocol,
int action)
{
g_autofree char *addrEndStr = NULL;
g_autofree char *portRangeStr = NULL;
g_autofree char *natRangeStr = NULL;
- virFirewallRulePtr rule;
+ virFirewallRule *rule;
int af = VIR_SOCKET_ADDR_FAMILY(netaddr);
virFirewallLayer layer = af == AF_INET ?
VIR_FIREWALL_LAYER_IPV4 : VIR_FIREWALL_LAYER_IPV6;
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesAddForwardMasquerade(virFirewallPtr fw,
+iptablesAddForwardMasquerade(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
- virSocketAddrRangePtr addr,
- virPortRangePtr port,
+ virSocketAddrRange *addr,
+ virPortRange *port,
const char *protocol)
{
return iptablesForwardMasquerade(fw, true, netaddr, prefix,
* Returns 0 in case of success or an error code otherwise
*/
int
-iptablesRemoveForwardMasquerade(virFirewallPtr fw,
+iptablesRemoveForwardMasquerade(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
- virSocketAddrRangePtr addr,
- virPortRangePtr port,
+ virSocketAddrRange *addr,
+ virPortRange *port,
const char *protocol)
{
return iptablesForwardMasquerade(fw, deletePrivate, netaddr, prefix,
* if said traffic targets @destaddr.
*/
static int
-iptablesForwardDontMasquerade(virFirewallPtr fw,
+iptablesForwardDontMasquerade(virFirewall *fw,
bool pvt,
virSocketAddr *netaddr,
unsigned int prefix,
* Returns 0 in case of success or an error code otherwise.
*/
int
-iptablesAddDontMasquerade(virFirewallPtr fw,
+iptablesAddDontMasquerade(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
* Returns 0 in case of success or an error code otherwise.
*/
int
-iptablesRemoveDontMasquerade(virFirewallPtr fw,
+iptablesRemoveDontMasquerade(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
static void
-iptablesOutputFixUdpChecksum(virFirewallPtr fw,
+iptablesOutputFixUdpChecksum(virFirewall *fw,
bool pvt,
const char *iface,
int port,
*
*/
void
-iptablesAddOutputFixUdpChecksum(virFirewallPtr fw,
+iptablesAddOutputFixUdpChecksum(virFirewall *fw,
const char *iface,
int port)
{
* iptablesAddOutputFixUdpChecksum.
*/
void
-iptablesRemoveOutputFixUdpChecksum(virFirewallPtr fw,
+iptablesRemoveOutputFixUdpChecksum(virFirewall *fw,
const char *iface,
int port)
{
void iptablesSetDeletePrivate (bool pvt);
-void iptablesAddTcpInput (virFirewallPtr fw,
+void iptablesAddTcpInput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesRemoveTcpInput (virFirewallPtr fw,
+void iptablesRemoveTcpInput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesAddUdpInput (virFirewallPtr fw,
+void iptablesAddUdpInput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesRemoveUdpInput (virFirewallPtr fw,
+void iptablesRemoveUdpInput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesAddTcpOutput (virFirewallPtr fw,
+void iptablesAddTcpOutput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesRemoveTcpOutput (virFirewallPtr fw,
+void iptablesRemoveTcpOutput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesAddUdpOutput (virFirewallPtr fw,
+void iptablesAddUdpOutput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-void iptablesRemoveUdpOutput (virFirewallPtr fw,
+void iptablesRemoveUdpOutput (virFirewall *fw,
virFirewallLayer layer,
const char *iface,
int port);
-int iptablesAddForwardAllowOut (virFirewallPtr fw,
+int iptablesAddForwardAllowOut (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesRemoveForwardAllowOut (virFirewallPtr fw,
+int iptablesRemoveForwardAllowOut (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesAddForwardAllowRelatedIn(virFirewallPtr fw,
+int iptablesAddForwardAllowRelatedIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesRemoveForwardAllowRelatedIn(virFirewallPtr fw,
+int iptablesRemoveForwardAllowRelatedIn(virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesAddForwardAllowIn (virFirewallPtr fw,
+int iptablesAddForwardAllowIn (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesRemoveForwardAllowIn (virFirewallPtr fw,
+int iptablesRemoveForwardAllowIn (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *iface,
const char *physdev)
G_GNUC_WARN_UNUSED_RESULT;
-void iptablesAddForwardAllowCross (virFirewallPtr fw,
+void iptablesAddForwardAllowCross (virFirewall *fw,
virFirewallLayer layer,
const char *iface);
-void iptablesRemoveForwardAllowCross (virFirewallPtr fw,
+void iptablesRemoveForwardAllowCross (virFirewall *fw,
virFirewallLayer layer,
const char *iface);
-void iptablesAddForwardRejectOut (virFirewallPtr fw,
+void iptablesAddForwardRejectOut (virFirewall *fw,
virFirewallLayer layer,
const char *iface);
-void iptablesRemoveForwardRejectOut (virFirewallPtr fw,
+void iptablesRemoveForwardRejectOut (virFirewall *fw,
virFirewallLayer layer,
const char *iface);
-void iptablesAddForwardRejectIn (virFirewallPtr fw,
+void iptablesAddForwardRejectIn (virFirewall *fw,
virFirewallLayer layer,
const char *iface);
-void iptablesRemoveForwardRejectIn (virFirewallPtr fw,
+void iptablesRemoveForwardRejectIn (virFirewall *fw,
virFirewallLayer layery,
const char *iface);
-int iptablesAddForwardMasquerade (virFirewallPtr fw,
+int iptablesAddForwardMasquerade (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
- virSocketAddrRangePtr addr,
- virPortRangePtr port,
+ virSocketAddrRange *addr,
+ virPortRange *port,
const char *protocol)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesRemoveForwardMasquerade (virFirewallPtr fw,
+int iptablesRemoveForwardMasquerade (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
- virSocketAddrRangePtr addr,
- virPortRangePtr port,
+ virSocketAddrRange *addr,
+ virPortRange *port,
const char *protocol)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesAddDontMasquerade (virFirewallPtr fw,
+int iptablesAddDontMasquerade (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
const char *destaddr)
G_GNUC_WARN_UNUSED_RESULT;
-int iptablesRemoveDontMasquerade (virFirewallPtr fw,
+int iptablesRemoveDontMasquerade (virFirewall *fw,
virSocketAddr *netaddr,
unsigned int prefix,
const char *physdev,
const char *destaddr)
G_GNUC_WARN_UNUSED_RESULT;
-void iptablesAddOutputFixUdpChecksum (virFirewallPtr fw,
+void iptablesAddOutputFixUdpChecksum (virFirewall *fw,
const char *iface,
int port);
-void iptablesRemoveOutputFixUdpChecksum (virFirewallPtr fw,
+void iptablesRemoveOutputFixUdpChecksum (virFirewall *fw,
const char *iface,
int port);
VIR_LOG_INIT("util.json");
typedef struct _virJSONObject virJSONObject;
-typedef virJSONObject *virJSONObjectPtr;
typedef struct _virJSONObjectPair virJSONObjectPair;
-typedef virJSONObjectPair *virJSONObjectPairPtr;
typedef struct _virJSONArray virJSONArray;
-typedef virJSONArray *virJSONArrayPtr;
struct _virJSONObjectPair {
char *key;
- virJSONValuePtr value;
+ virJSONValue *value;
};
struct _virJSONObject {
size_t npairs;
- virJSONObjectPairPtr pairs;
+ virJSONObjectPair *pairs;
};
struct _virJSONArray {
size_t nvalues;
- virJSONValuePtr *values;
+ virJSONValue **values;
};
struct _virJSONValue {
typedef struct _virJSONParserState virJSONParserState;
-typedef virJSONParserState *virJSONParserStatePtr;
struct _virJSONParserState {
- virJSONValuePtr value;
+ virJSONValue *value;
char *key;
};
typedef struct _virJSONParser virJSONParser;
-typedef virJSONParser *virJSONParserPtr;
struct _virJSONParser {
- virJSONValuePtr head;
- virJSONParserStatePtr state;
+ virJSONValue *head;
+ virJSONParserState *state;
size_t nstate;
int wrap;
};
* d: double precision floating point number
* n: json null value
*
- * The following two cases take a pointer to a pointer to a virJSONValuePtr. The
- * pointer is cleared when the virJSONValuePtr is stolen into the object.
+ * The following two cases take a pointer to a pointer to a virJSONValue *. The
+ * pointer is cleared when the virJSONValue *is stolen into the object.
* a: json object, must be non-NULL
* A: json object, omitted if NULL
*
* in case of no error but nothing was filled.
*/
int
-virJSONValueObjectAddVArgs(virJSONValuePtr obj,
+virJSONValueObjectAddVArgs(virJSONValue *obj,
va_list args)
{
char type;
case 'A':
case 'a': {
- virJSONValuePtr *val = va_arg(args, virJSONValuePtr *);
+ virJSONValue **val = va_arg(args, virJSONValue **);
if (!(*val)) {
if (type == 'A')
case 'M':
case 'm': {
- virBitmapPtr map = va_arg(args, virBitmapPtr);
+ virBitmap *map = va_arg(args, virBitmap *);
g_autoptr(virJSONValue) jsonMap = virJSONValueNewArray();
ssize_t pos = -1;
int
-virJSONValueObjectAdd(virJSONValuePtr obj, ...)
+virJSONValueObjectAdd(virJSONValue *obj, ...)
{
va_list args;
int ret;
int
-virJSONValueObjectCreateVArgs(virJSONValuePtr *obj,
+virJSONValueObjectCreateVArgs(virJSONValue **obj,
va_list args)
{
int ret;
int
-virJSONValueObjectCreate(virJSONValuePtr *obj, ...)
+virJSONValueObjectCreate(virJSONValue **obj, ...)
{
va_list args;
int ret;
void
-virJSONValueFree(virJSONValuePtr value)
+virJSONValueFree(virJSONValue *value)
{
size_t i;
if (!value)
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewString(const char *data)
{
- virJSONValuePtr val;
+ virJSONValue *val;
if (!data)
return virJSONValueNewNull();
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewStringLen(const char *data,
size_t length)
{
- virJSONValuePtr val;
+ virJSONValue *val;
if (!data)
return virJSONValueNewNull();
* Creates a new virJSONValue of VIR_JSON_TYPE_NUMBER type. Note that this
* function takes ownership of @data.
*/
-static virJSONValuePtr
+static virJSONValue *
virJSONValueNewNumber(char *data)
{
- virJSONValuePtr val;
+ virJSONValue *val;
val = g_new0(virJSONValue, 1);
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNumberInt(int data)
{
return virJSONValueNewNumber(g_strdup_printf("%i", data));
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNumberUint(unsigned int data)
{
return virJSONValueNewNumber(g_strdup_printf("%u", data));
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNumberLong(long long data)
{
return virJSONValueNewNumber(g_strdup_printf("%lld", data));
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNumberUlong(unsigned long long data)
{
return virJSONValueNewNumber(g_strdup_printf("%llu", data));
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNumberDouble(double data)
{
char *str = NULL;
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewBoolean(int boolean_)
{
- virJSONValuePtr val;
+ virJSONValue *val;
val = g_new0(virJSONValue, 1);
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewNull(void)
{
- virJSONValuePtr val;
+ virJSONValue *val;
val = g_new0(virJSONValue, 1);
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewArray(void)
{
- virJSONValuePtr val = g_new0(virJSONValue, 1);
+ virJSONValue *val = g_new0(virJSONValue, 1);
val->type = VIR_JSON_TYPE_ARRAY;
}
-virJSONValuePtr
+virJSONValue *
virJSONValueNewObject(void)
{
- virJSONValuePtr val = g_new0(virJSONValue, 1);
+ virJSONValue *val = g_new0(virJSONValue, 1);
val->type = VIR_JSON_TYPE_OBJECT;
static int
-virJSONValueObjectInsert(virJSONValuePtr object,
+virJSONValueObjectInsert(virJSONValue *object,
const char *key,
- virJSONValuePtr *value,
+ virJSONValue **value,
bool prepend)
{
virJSONObjectPair pair = { NULL, *value };
int
-virJSONValueObjectAppend(virJSONValuePtr object,
+virJSONValueObjectAppend(virJSONValue *object,
const char *key,
- virJSONValuePtr *value)
+ virJSONValue **value)
{
return virJSONValueObjectInsert(object, key, value, false);
}
static int
-virJSONValueObjectInsertString(virJSONValuePtr object,
+virJSONValueObjectInsertString(virJSONValue *object,
const char *key,
const char *value,
bool prepend)
{
- virJSONValuePtr jvalue = virJSONValueNewString(value);
+ virJSONValue *jvalue = virJSONValueNewString(value);
if (!jvalue)
return -1;
if (virJSONValueObjectInsert(object, key, &jvalue, prepend) < 0)
int
-virJSONValueObjectAppendString(virJSONValuePtr object,
+virJSONValueObjectAppendString(virJSONValue *object,
const char *key,
const char *value)
{
int
-virJSONValueObjectAppendStringPrintf(virJSONValuePtr object,
+virJSONValueObjectAppendStringPrintf(virJSONValue *object,
const char *key,
const char *fmt,
...)
int
-virJSONValueObjectPrependString(virJSONValuePtr object,
+virJSONValueObjectPrependString(virJSONValue *object,
const char *key,
const char *value)
{
int
-virJSONValueObjectAppendNumberInt(virJSONValuePtr object,
+virJSONValueObjectAppendNumberInt(virJSONValue *object,
const char *key,
int number)
{
int
-virJSONValueObjectAppendNumberUint(virJSONValuePtr object,
+virJSONValueObjectAppendNumberUint(virJSONValue *object,
const char *key,
unsigned int number)
{
int
-virJSONValueObjectAppendNumberLong(virJSONValuePtr object,
+virJSONValueObjectAppendNumberLong(virJSONValue *object,
const char *key,
long long number)
{
int
-virJSONValueObjectAppendNumberUlong(virJSONValuePtr object,
+virJSONValueObjectAppendNumberUlong(virJSONValue *object,
const char *key,
unsigned long long number)
{
int
-virJSONValueObjectAppendNumberDouble(virJSONValuePtr object,
+virJSONValueObjectAppendNumberDouble(virJSONValue *object,
const char *key,
double number)
{
int
-virJSONValueObjectAppendBoolean(virJSONValuePtr object,
+virJSONValueObjectAppendBoolean(virJSONValue *object,
const char *key,
int boolean_)
{
int
-virJSONValueObjectAppendNull(virJSONValuePtr object,
+virJSONValueObjectAppendNull(virJSONValue *object,
const char *key)
{
g_autoptr(virJSONValue) jvalue = virJSONValueNewNull();
int
-virJSONValueArrayAppend(virJSONValuePtr array,
- virJSONValuePtr *value)
+virJSONValueArrayAppend(virJSONValue *array,
+ virJSONValue **value)
{
if (array->type != VIR_JSON_TYPE_ARRAY) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("expecting JSON array"));
int
-virJSONValueArrayAppendString(virJSONValuePtr object,
+virJSONValueArrayAppendString(virJSONValue *object,
const char *value)
{
g_autoptr(virJSONValue) jvalue = virJSONValueNewString(value);
* Merges the members of @c array into @a. The values are stolen from @c.
*/
int
-virJSONValueArrayConcat(virJSONValuePtr a,
- virJSONValuePtr c)
+virJSONValueArrayConcat(virJSONValue *a,
+ virJSONValue *c)
{
size_t i;
return -1;
}
- a->data.array.values = g_renew(virJSONValuePtr, a->data.array.values,
+ a->data.array.values = g_renew(virJSONValue *, a->data.array.values,
a->data.array.nvalues + c->data.array.nvalues);
for (i = 0; i < c->data.array.nvalues; i++)
int
-virJSONValueObjectHasKey(virJSONValuePtr object,
+virJSONValueObjectHasKey(virJSONValue *object,
const char *key)
{
size_t i;
}
-virJSONValuePtr
-virJSONValueObjectGet(virJSONValuePtr object,
+virJSONValue *
+virJSONValueObjectGet(virJSONValue *object,
const char *key)
{
size_t i;
/* Return the value associated with KEY within OBJECT, but return NULL
* if the key is missing or if value is not the correct TYPE. */
-virJSONValuePtr
-virJSONValueObjectGetByType(virJSONValuePtr object,
+virJSONValue *
+virJSONValueObjectGetByType(virJSONValue *object,
const char *key,
virJSONType type)
{
- virJSONValuePtr value = virJSONValueObjectGet(object, key);
+ virJSONValue *value = virJSONValueObjectGet(object, key);
if (value && value->type == type)
return value;
/* Steal the value associated with KEY within OBJECT, but return NULL
* if the key is missing or if value is not the correct TYPE. */
-static virJSONValuePtr
-virJSONValueObjectStealByType(virJSONValuePtr object,
+static virJSONValue *
+virJSONValueObjectStealByType(virJSONValue *object,
const char *key,
virJSONType type)
{
- virJSONValuePtr value;
+ virJSONValue *value;
if (virJSONValueObjectRemoveKey(object, key, &value) <= 0)
return NULL;
int
-virJSONValueObjectKeysNumber(virJSONValuePtr object)
+virJSONValueObjectKeysNumber(virJSONValue *object)
{
if (object->type != VIR_JSON_TYPE_OBJECT)
return -1;
const char *
-virJSONValueObjectGetKey(virJSONValuePtr object,
+virJSONValueObjectGetKey(virJSONValue *object,
unsigned int n)
{
if (object->type != VIR_JSON_TYPE_OBJECT)
* not NULL, the dropped value object is returned instead of freed.
* Returns 1 on success, 0 if no key was found, and -1 on error. */
int
-virJSONValueObjectRemoveKey(virJSONValuePtr object,
+virJSONValueObjectRemoveKey(virJSONValue *object,
const char *key,
- virJSONValuePtr *value)
+ virJSONValue **value)
{
size_t i;
}
-virJSONValuePtr
-virJSONValueObjectGetValue(virJSONValuePtr object,
+virJSONValue *
+virJSONValueObjectGetValue(virJSONValue *object,
unsigned int n)
{
if (object->type != VIR_JSON_TYPE_OBJECT)
bool
-virJSONValueIsObject(virJSONValuePtr object)
+virJSONValueIsObject(virJSONValue *object)
{
if (object)
return object->type == VIR_JSON_TYPE_OBJECT;
bool
-virJSONValueIsArray(virJSONValuePtr array)
+virJSONValueIsArray(virJSONValue *array)
{
return array->type == VIR_JSON_TYPE_ARRAY;
}
}
-virJSONValuePtr
-virJSONValueArrayGet(virJSONValuePtr array,
+virJSONValue *
+virJSONValueArrayGet(virJSONValue *array,
unsigned int element)
{
if (array->type != VIR_JSON_TYPE_ARRAY)
}
-virJSONValuePtr
-virJSONValueArraySteal(virJSONValuePtr array,
+virJSONValue *
+virJSONValueArraySteal(virJSONValue *array,
unsigned int element)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
if (array->type != VIR_JSON_TYPE_ARRAY)
return NULL;
* The rest of the members stay in possession of the array and it's condensed.
*/
int
-virJSONValueArrayForeachSteal(virJSONValuePtr array,
+virJSONValueArrayForeachSteal(virJSONValue *array,
virJSONArrayIteratorFunc cb,
void *opaque)
{
const char *
-virJSONValueGetString(virJSONValuePtr string)
+virJSONValueGetString(virJSONValue *string)
{
if (string->type != VIR_JSON_TYPE_STRING)
return NULL;
const char *
-virJSONValueGetNumberString(virJSONValuePtr number)
+virJSONValueGetNumberString(virJSONValue *number)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
return NULL;
int
-virJSONValueGetNumberInt(virJSONValuePtr number,
+virJSONValueGetNumberInt(virJSONValue *number,
int *value)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
int
-virJSONValueGetNumberUint(virJSONValuePtr number,
+virJSONValueGetNumberUint(virJSONValue *number,
unsigned int *value)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
int
-virJSONValueGetNumberLong(virJSONValuePtr number,
+virJSONValueGetNumberLong(virJSONValue *number,
long long *value)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
int
-virJSONValueGetNumberUlong(virJSONValuePtr number,
+virJSONValueGetNumberUlong(virJSONValue *number,
unsigned long long *value)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
int
-virJSONValueGetNumberDouble(virJSONValuePtr number,
+virJSONValueGetNumberDouble(virJSONValue *number,
double *value)
{
if (number->type != VIR_JSON_TYPE_NUMBER)
int
-virJSONValueGetBoolean(virJSONValuePtr val,
+virJSONValueGetBoolean(virJSONValue *val,
bool *value)
{
if (val->type != VIR_JSON_TYPE_BOOLEAN)
bool
-virJSONValueIsNull(virJSONValuePtr val)
+virJSONValueIsNull(virJSONValue *val)
{
return val->type == VIR_JSON_TYPE_NULL;
}
const char *
-virJSONValueObjectGetString(virJSONValuePtr object,
+virJSONValueObjectGetString(virJSONValue *object,
const char *key)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return NULL;
* is not present or is not a string or number NULL is returned.
*/
const char *
-virJSONValueObjectGetStringOrNumber(virJSONValuePtr object,
+virJSONValueObjectGetStringOrNumber(virJSONValue *object,
const char *key)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return NULL;
int
-virJSONValueObjectGetNumberInt(virJSONValuePtr object,
+virJSONValueObjectGetNumberInt(virJSONValue *object,
const char *key,
int *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
int
-virJSONValueObjectGetNumberUint(virJSONValuePtr object,
+virJSONValueObjectGetNumberUint(virJSONValue *object,
const char *key,
unsigned int *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
int
-virJSONValueObjectGetNumberLong(virJSONValuePtr object,
+virJSONValueObjectGetNumberLong(virJSONValue *object,
const char *key,
long long *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
int
-virJSONValueObjectGetNumberUlong(virJSONValuePtr object,
+virJSONValueObjectGetNumberUlong(virJSONValue *object,
const char *key,
unsigned long long *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
int
-virJSONValueObjectGetNumberDouble(virJSONValuePtr object,
+virJSONValueObjectGetNumberDouble(virJSONValue *object,
const char *key,
double *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
int
-virJSONValueObjectGetBoolean(virJSONValuePtr object,
+virJSONValueObjectGetBoolean(virJSONValue *object,
const char *key,
bool *value)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
}
-virJSONValuePtr
-virJSONValueObjectGetObject(virJSONValuePtr object, const char *key)
+virJSONValue *
+virJSONValueObjectGetObject(virJSONValue *object, const char *key)
{
return virJSONValueObjectGetByType(object, key, VIR_JSON_TYPE_OBJECT);
}
-virJSONValuePtr
-virJSONValueObjectGetArray(virJSONValuePtr object, const char *key)
+virJSONValue *
+virJSONValueObjectGetArray(virJSONValue *object, const char *key)
{
return virJSONValueObjectGetByType(object, key, VIR_JSON_TYPE_ARRAY);
}
-virJSONValuePtr
-virJSONValueObjectStealArray(virJSONValuePtr object, const char *key)
+virJSONValue *
+virJSONValueObjectStealArray(virJSONValue *object, const char *key)
{
return virJSONValueObjectStealByType(object, key, VIR_JSON_TYPE_ARRAY);
}
-virJSONValuePtr
-virJSONValueObjectStealObject(virJSONValuePtr object,
+virJSONValue *
+virJSONValueObjectStealObject(virJSONValue *object,
const char *key)
{
return virJSONValueObjectStealByType(object, key, VIR_JSON_TYPE_OBJECT);
int
-virJSONValueObjectIsNull(virJSONValuePtr object,
+virJSONValueObjectIsNull(virJSONValue *object,
const char *key)
{
- virJSONValuePtr val = virJSONValueObjectGet(object, key);
+ virJSONValue *val = virJSONValueObjectGet(object, key);
if (!val)
return -1;
}
char **
-virJSONValueObjectGetStringArray(virJSONValuePtr object, const char *key)
+virJSONValueObjectGetStringArray(virJSONValue *object, const char *key)
{
g_auto(GStrv) ret = NULL;
- virJSONValuePtr data;
+ virJSONValue *data;
size_t n;
size_t i;
n = virJSONValueArraySize(data);
ret = g_new0(char *, n + 1);
for (i = 0; i < n; i++) {
- virJSONValuePtr child = virJSONValueArrayGet(data, i);
+ virJSONValue *child = virJSONValueArrayGet(data, i);
const char *tmp;
if (!child) {
* during iteration and -1 on generic errors.
*/
int
-virJSONValueObjectForeachKeyValue(virJSONValuePtr object,
+virJSONValueObjectForeachKeyValue(virJSONValue *object,
virJSONValueObjectIteratorFunc cb,
void *opaque)
{
return -1;
for (i = 0; i < object->data.object.npairs; i++) {
- virJSONObjectPairPtr elem = object->data.object.pairs + i;
+ virJSONObjectPair *elem = object->data.object.pairs + i;
if (cb(elem->key, elem->value, opaque) < 0)
return -2;
}
-virJSONValuePtr
+virJSONValue *
virJSONValueCopy(const virJSONValue *in)
{
size_t i;
- virJSONValuePtr out = NULL;
+ virJSONValue *out = NULL;
if (!in)
return NULL;
case VIR_JSON_TYPE_ARRAY:
out = virJSONValueNewArray();
- out->data.array.values = g_new0(virJSONValuePtr, in->data.array.nvalues);
+ out->data.array.values = g_new0(virJSONValue *, in->data.array.nvalues);
out->data.array.nvalues = in->data.array.nvalues;
for (i = 0; i < in->data.array.nvalues; i++) {
#if WITH_YAJL
static int
-virJSONParserInsertValue(virJSONParserPtr parser,
- virJSONValuePtr *value)
+virJSONParserInsertValue(virJSONParser *parser,
+ virJSONValue **value)
{
if (!parser->head) {
parser->head = g_steal_pointer(value);
} else {
- virJSONParserStatePtr state;
+ virJSONParserState *state;
if (!parser->nstate) {
VIR_DEBUG("got a value to insert without a container");
return -1;
static int
virJSONParserHandleNull(void *ctx)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewNull();
VIR_DEBUG("parser=%p", parser);
virJSONParserHandleBoolean(void *ctx,
int boolean_)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewBoolean(boolean_);
VIR_DEBUG("parser=%p boolean=%d", parser, boolean_);
const char *s,
size_t l)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewNumber(g_strndup(s, l));
VIR_DEBUG("parser=%p str=%s", parser, value->data.number);
const unsigned char *stringVal,
size_t stringLen)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewStringLen((const char *)stringVal,
stringLen);
const unsigned char *stringVal,
size_t stringLen)
{
- virJSONParserPtr parser = ctx;
- virJSONParserStatePtr state;
+ virJSONParser *parser = ctx;
+ virJSONParserState *state;
VIR_DEBUG("parser=%p key=%p", parser, (const char *)stringVal);
static int
virJSONParserHandleStartMap(void *ctx)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewObject();
- virJSONValuePtr tmp = value;
+ virJSONValue *tmp = value;
VIR_DEBUG("parser=%p", parser);
static int
virJSONParserHandleEndMap(void *ctx)
{
- virJSONParserPtr parser = ctx;
- virJSONParserStatePtr state;
+ virJSONParser *parser = ctx;
+ virJSONParserState *state;
VIR_DEBUG("parser=%p", parser);
static int
virJSONParserHandleStartArray(void *ctx)
{
- virJSONParserPtr parser = ctx;
+ virJSONParser *parser = ctx;
g_autoptr(virJSONValue) value = virJSONValueNewArray();
- virJSONValuePtr tmp = value;
+ virJSONValue *tmp = value;
VIR_DEBUG("parser=%p", parser);
static int
virJSONParserHandleEndArray(void *ctx)
{
- virJSONParserPtr parser = ctx;
- virJSONParserStatePtr state;
+ virJSONParser *parser = ctx;
+ virJSONParserState *state;
VIR_DEBUG("parser=%p", parser);
/* XXX add an incremental streaming parser - yajl trivially supports it */
-virJSONValuePtr
+virJSONValue *
virJSONValueFromString(const char *jsonstring)
{
yajl_handle hand;
virJSONParser parser = { NULL, NULL, 0, 0 };
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
int rc;
size_t len = strlen(jsonstring);
static int
-virJSONValueToStringOne(virJSONValuePtr object,
+virJSONValueToStringOne(virJSONValue *object,
yajl_gen g)
{
size_t i;
int
-virJSONValueToBuffer(virJSONValuePtr object,
- virBufferPtr buf,
+virJSONValueToBuffer(virJSONValue *object,
+ virBuffer *buf,
bool pretty)
{
yajl_gen g;
#else
-virJSONValuePtr
+virJSONValue *
virJSONValueFromString(const char *jsonstring G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
int
-virJSONValueToBuffer(virJSONValuePtr object G_GNUC_UNUSED,
- virBufferPtr buf G_GNUC_UNUSED,
+virJSONValueToBuffer(virJSONValue *object G_GNUC_UNUSED,
+ virBuffer *buf G_GNUC_UNUSED,
bool pretty G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
char *
-virJSONValueToString(virJSONValuePtr object,
+virJSONValueToString(virJSONValue *object,
bool pretty)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
}
-static virJSONValuePtr
-virJSONValueObjectDeflattenKeys(virJSONValuePtr json);
+static virJSONValue *
+virJSONValueObjectDeflattenKeys(virJSONValue *json);
static int
virJSONValueObjectDeflattenWorker(const char *key,
- virJSONValuePtr value,
+ virJSONValue *value,
void *opaque)
{
- virJSONValuePtr retobj = opaque;
+ virJSONValue *retobj = opaque;
g_autoptr(virJSONValue) newval = NULL;
- virJSONValuePtr existobj;
+ virJSONValue *existobj;
g_auto(GStrv) tokens = NULL;
/* non-nested keys only need to be copied */
}
if (!(existobj = virJSONValueObjectGet(retobj, tokens[0]))) {
- virJSONValuePtr newobj = virJSONValueNewObject();
+ virJSONValue *newobj = virJSONValueNewObject();
existobj = newobj;
if (virJSONValueObjectAppend(retobj, tokens[0], &newobj) < 0)
}
-static virJSONValuePtr
-virJSONValueObjectDeflattenKeys(virJSONValuePtr json)
+static virJSONValue *
+virJSONValueObjectDeflattenKeys(virJSONValue *json)
{
g_autoptr(virJSONValue) deflattened = virJSONValueNewObject();
* keys starting from 0.
*/
static void
-virJSONValueObjectDeflattenArrays(virJSONValuePtr json)
+virJSONValueObjectDeflattenArrays(virJSONValue *json)
{
- g_autofree virJSONValuePtr *arraymembers = NULL;
- virJSONObjectPtr obj;
+ g_autofree virJSONValue **arraymembers = NULL;
+ virJSONObject *obj;
size_t i;
if (!json ||
obj = &json->data.object;
- arraymembers = g_new0(virJSONValuePtr, obj->npairs);
+ arraymembers = g_new0(virJSONValue *, obj->npairs);
for (i = 0; i < obj->npairs; i++)
virJSONValueObjectDeflattenArrays(obj->pairs[i].value);
for (i = 0; i < obj->npairs; i++) {
- virJSONObjectPairPtr pair = obj->pairs + i;
+ virJSONObjectPair *pair = obj->pairs + i;
unsigned int keynum;
if (virStrToLong_uip(pair->key, NULL, 10, &keynum) < 0)
* hierarchy so that the parsers can be kept simple and we still can use the
* weird syntax some users might use.
*/
-virJSONValuePtr
-virJSONValueObjectDeflatten(virJSONValuePtr json)
+virJSONValue *
+virJSONValueObjectDeflatten(virJSONValue *json)
{
- virJSONValuePtr deflattened;
+ virJSONValue *deflattened;
if (!(deflattened = virJSONValueObjectDeflattenKeys(json)))
return NULL;
} virJSONType;
typedef struct _virJSONValue virJSONValue;
-typedef virJSONValue *virJSONValuePtr;
-void virJSONValueFree(virJSONValuePtr value);
+void virJSONValueFree(virJSONValue *value);
void virJSONValueHashFree(void *opaque);
virJSONType virJSONValueGetType(const virJSONValue *value);
-int virJSONValueObjectCreate(virJSONValuePtr *obj, ...)
+int virJSONValueObjectCreate(virJSONValue **obj, ...)
ATTRIBUTE_NONNULL(1) G_GNUC_NULL_TERMINATED;
-int virJSONValueObjectCreateVArgs(virJSONValuePtr *obj, va_list args)
+int virJSONValueObjectCreateVArgs(virJSONValue **obj, va_list args)
ATTRIBUTE_NONNULL(1);
-int virJSONValueObjectAdd(virJSONValuePtr obj, ...)
+int virJSONValueObjectAdd(virJSONValue *obj, ...)
ATTRIBUTE_NONNULL(1) G_GNUC_NULL_TERMINATED;
-int virJSONValueObjectAddVArgs(virJSONValuePtr obj, va_list args)
+int virJSONValueObjectAddVArgs(virJSONValue *obj, va_list args)
ATTRIBUTE_NONNULL(1);
-virJSONValuePtr virJSONValueNewString(const char *data);
-virJSONValuePtr virJSONValueNewStringLen(const char *data, size_t length);
-virJSONValuePtr virJSONValueNewNumberInt(int data);
-virJSONValuePtr virJSONValueNewNumberUint(unsigned int data);
-virJSONValuePtr virJSONValueNewNumberLong(long long data);
-virJSONValuePtr virJSONValueNewNumberUlong(unsigned long long data);
-virJSONValuePtr virJSONValueNewNumberDouble(double data);
-virJSONValuePtr virJSONValueNewBoolean(int boolean);
-virJSONValuePtr virJSONValueNewNull(void);
-virJSONValuePtr virJSONValueNewArray(void);
-virJSONValuePtr virJSONValueNewObject(void);
+virJSONValue *virJSONValueNewString(const char *data);
+virJSONValue *virJSONValueNewStringLen(const char *data, size_t length);
+virJSONValue *virJSONValueNewNumberInt(int data);
+virJSONValue *virJSONValueNewNumberUint(unsigned int data);
+virJSONValue *virJSONValueNewNumberLong(long long data);
+virJSONValue *virJSONValueNewNumberUlong(unsigned long long data);
+virJSONValue *virJSONValueNewNumberDouble(double data);
+virJSONValue *virJSONValueNewBoolean(int boolean);
+virJSONValue *virJSONValueNewNull(void);
+virJSONValue *virJSONValueNewArray(void);
+virJSONValue *virJSONValueNewObject(void);
-int virJSONValueObjectAppend(virJSONValuePtr object,
+int virJSONValueObjectAppend(virJSONValue *object,
const char *key,
- virJSONValuePtr *value);
-int virJSONValueArrayAppend(virJSONValuePtr object,
- virJSONValuePtr *value);
-int virJSONValueArrayConcat(virJSONValuePtr a,
- virJSONValuePtr c);
-
-int virJSONValueObjectHasKey(virJSONValuePtr object, const char *key);
-virJSONValuePtr virJSONValueObjectGet(virJSONValuePtr object, const char *key);
-virJSONValuePtr virJSONValueObjectGetByType(virJSONValuePtr object,
+ virJSONValue **value);
+int virJSONValueArrayAppend(virJSONValue *object,
+ virJSONValue **value);
+int virJSONValueArrayConcat(virJSONValue *a,
+ virJSONValue *c);
+
+int virJSONValueObjectHasKey(virJSONValue *object, const char *key);
+virJSONValue *virJSONValueObjectGet(virJSONValue *object, const char *key);
+virJSONValue *virJSONValueObjectGetByType(virJSONValue *object,
const char *key, virJSONType type);
-bool virJSONValueIsObject(virJSONValuePtr object);
+bool virJSONValueIsObject(virJSONValue *object);
-bool virJSONValueIsArray(virJSONValuePtr array);
+bool virJSONValueIsArray(virJSONValue *array);
size_t virJSONValueArraySize(const virJSONValue *array);
-virJSONValuePtr virJSONValueArrayGet(virJSONValuePtr object, unsigned int element);
-virJSONValuePtr virJSONValueArraySteal(virJSONValuePtr object, unsigned int element);
+virJSONValue *virJSONValueArrayGet(virJSONValue *object, unsigned int element);
+virJSONValue *virJSONValueArraySteal(virJSONValue *object, unsigned int element);
typedef int (*virJSONArrayIteratorFunc)(size_t pos,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque);
-int virJSONValueArrayForeachSteal(virJSONValuePtr array,
+int virJSONValueArrayForeachSteal(virJSONValue *array,
virJSONArrayIteratorFunc cb,
void *opaque);
-int virJSONValueObjectKeysNumber(virJSONValuePtr object);
-const char *virJSONValueObjectGetKey(virJSONValuePtr object, unsigned int n);
-virJSONValuePtr virJSONValueObjectGetValue(virJSONValuePtr object, unsigned int n);
-
-const char *virJSONValueGetString(virJSONValuePtr object);
-const char *virJSONValueGetNumberString(virJSONValuePtr number);
-int virJSONValueGetNumberInt(virJSONValuePtr object, int *value);
-int virJSONValueGetNumberUint(virJSONValuePtr object, unsigned int *value);
-int virJSONValueGetNumberLong(virJSONValuePtr object, long long *value);
-int virJSONValueGetNumberUlong(virJSONValuePtr object, unsigned long long *value);
-int virJSONValueGetNumberDouble(virJSONValuePtr object, double *value);
-int virJSONValueGetBoolean(virJSONValuePtr object, bool *value);
-bool virJSONValueIsNull(virJSONValuePtr object);
-virJSONValuePtr virJSONValueObjectGetObject(virJSONValuePtr object,
+int virJSONValueObjectKeysNumber(virJSONValue *object);
+const char *virJSONValueObjectGetKey(virJSONValue *object, unsigned int n);
+virJSONValue *virJSONValueObjectGetValue(virJSONValue *object, unsigned int n);
+
+const char *virJSONValueGetString(virJSONValue *object);
+const char *virJSONValueGetNumberString(virJSONValue *number);
+int virJSONValueGetNumberInt(virJSONValue *object, int *value);
+int virJSONValueGetNumberUint(virJSONValue *object, unsigned int *value);
+int virJSONValueGetNumberLong(virJSONValue *object, long long *value);
+int virJSONValueGetNumberUlong(virJSONValue *object, unsigned long long *value);
+int virJSONValueGetNumberDouble(virJSONValue *object, double *value);
+int virJSONValueGetBoolean(virJSONValue *object, bool *value);
+bool virJSONValueIsNull(virJSONValue *object);
+virJSONValue *virJSONValueObjectGetObject(virJSONValue *object,
const char *key);
-virJSONValuePtr virJSONValueObjectGetArray(virJSONValuePtr object,
+virJSONValue *virJSONValueObjectGetArray(virJSONValue *object,
const char *key);
-virJSONValuePtr virJSONValueObjectStealArray(virJSONValuePtr object,
+virJSONValue *virJSONValueObjectStealArray(virJSONValue *object,
const char *key);
-virJSONValuePtr virJSONValueObjectStealObject(virJSONValuePtr object,
+virJSONValue *virJSONValueObjectStealObject(virJSONValue *object,
const char *key);
-const char *virJSONValueObjectGetString(virJSONValuePtr object, const char *key);
-char **virJSONValueObjectGetStringArray(virJSONValuePtr object, const char *key);
-const char *virJSONValueObjectGetStringOrNumber(virJSONValuePtr object, const char *key);
-int virJSONValueObjectGetNumberInt(virJSONValuePtr object, const char *key, int *value);
-int virJSONValueObjectGetNumberUint(virJSONValuePtr object, const char *key, unsigned int *value);
-int virJSONValueObjectGetNumberLong(virJSONValuePtr object, const char *key, long long *value);
-int virJSONValueObjectGetNumberUlong(virJSONValuePtr object, const char *key, unsigned long long *value);
-int virJSONValueObjectGetNumberDouble(virJSONValuePtr object, const char *key, double *value);
-int virJSONValueObjectGetBoolean(virJSONValuePtr object, const char *key, bool *value);
-int virJSONValueObjectIsNull(virJSONValuePtr object, const char *key);
-
-int virJSONValueObjectAppendString(virJSONValuePtr object, const char *key, const char *value);
-int virJSONValueObjectAppendStringPrintf(virJSONValuePtr object, const char *key, const char *fmt, ...)
+const char *virJSONValueObjectGetString(virJSONValue *object, const char *key);
+char **virJSONValueObjectGetStringArray(virJSONValue *object, const char *key);
+const char *virJSONValueObjectGetStringOrNumber(virJSONValue *object, const char *key);
+int virJSONValueObjectGetNumberInt(virJSONValue *object, const char *key, int *value);
+int virJSONValueObjectGetNumberUint(virJSONValue *object, const char *key, unsigned int *value);
+int virJSONValueObjectGetNumberLong(virJSONValue *object, const char *key, long long *value);
+int virJSONValueObjectGetNumberUlong(virJSONValue *object, const char *key, unsigned long long *value);
+int virJSONValueObjectGetNumberDouble(virJSONValue *object, const char *key, double *value);
+int virJSONValueObjectGetBoolean(virJSONValue *object, const char *key, bool *value);
+int virJSONValueObjectIsNull(virJSONValue *object, const char *key);
+
+int virJSONValueObjectAppendString(virJSONValue *object, const char *key, const char *value);
+int virJSONValueObjectAppendStringPrintf(virJSONValue *object, const char *key, const char *fmt, ...)
G_GNUC_PRINTF(3, 4);
-int virJSONValueObjectPrependString(virJSONValuePtr object, const char *key, const char *value);
-int virJSONValueObjectAppendNumberInt(virJSONValuePtr object, const char *key, int number);
-int virJSONValueObjectAppendNumberUint(virJSONValuePtr object, const char *key, unsigned int number);
-int virJSONValueObjectAppendNumberLong(virJSONValuePtr object, const char *key, long long number);
-int virJSONValueObjectAppendNumberUlong(virJSONValuePtr object, const char *key, unsigned long long number);
-int virJSONValueObjectAppendNumberDouble(virJSONValuePtr object, const char *key, double number);
-int virJSONValueObjectAppendBoolean(virJSONValuePtr object, const char *key, int boolean);
-int virJSONValueObjectAppendNull(virJSONValuePtr object, const char *key);
-
-int virJSONValueObjectRemoveKey(virJSONValuePtr object, const char *key,
- virJSONValuePtr *value)
+int virJSONValueObjectPrependString(virJSONValue *object, const char *key, const char *value);
+int virJSONValueObjectAppendNumberInt(virJSONValue *object, const char *key, int number);
+int virJSONValueObjectAppendNumberUint(virJSONValue *object, const char *key, unsigned int number);
+int virJSONValueObjectAppendNumberLong(virJSONValue *object, const char *key, long long number);
+int virJSONValueObjectAppendNumberUlong(virJSONValue *object, const char *key, unsigned long long number);
+int virJSONValueObjectAppendNumberDouble(virJSONValue *object, const char *key, double number);
+int virJSONValueObjectAppendBoolean(virJSONValue *object, const char *key, int boolean);
+int virJSONValueObjectAppendNull(virJSONValue *object, const char *key);
+
+int virJSONValueObjectRemoveKey(virJSONValue *object, const char *key,
+ virJSONValue **value)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virJSONValueArrayAppendString(virJSONValuePtr object, const char *value);
+int virJSONValueArrayAppendString(virJSONValue *object, const char *value);
-virJSONValuePtr virJSONValueFromString(const char *jsonstring);
-char *virJSONValueToString(virJSONValuePtr object,
+virJSONValue *virJSONValueFromString(const char *jsonstring);
+char *virJSONValueToString(virJSONValue *object,
bool pretty);
-int virJSONValueToBuffer(virJSONValuePtr object,
- virBufferPtr buf,
+int virJSONValueToBuffer(virJSONValue *object,
+ virBuffer *buf,
bool pretty)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
typedef int (*virJSONValueObjectIteratorFunc)(const char *key,
- virJSONValuePtr value,
+ virJSONValue *value,
void *opaque);
-int virJSONValueObjectForeachKeyValue(virJSONValuePtr object,
+int virJSONValueObjectForeachKeyValue(virJSONValue *object,
virJSONValueObjectIteratorFunc cb,
void *opaque);
-virJSONValuePtr virJSONValueCopy(const virJSONValue *in);
+virJSONValue *virJSONValueCopy(const virJSONValue *in);
char *virJSONStringReformat(const char *jsonstr, bool pretty);
-virJSONValuePtr virJSONValueObjectDeflatten(virJSONValuePtr json);
+virJSONValue *virJSONValueObjectDeflatten(virJSONValue *json);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virJSONValue, virJSONValueFree);
int
-virLeaseReadCustomLeaseFile(virJSONValuePtr leases_array_new,
+virLeaseReadCustomLeaseFile(virJSONValue *leases_array_new,
const char *custom_lease_file,
const char *ip_to_delete,
char **server_duid)
i = 0;
while (i < virJSONValueArraySize(leases_array)) {
- virJSONValuePtr lease_tmp = virJSONValueArrayGet(leases_array, i);
+ virJSONValue *lease_tmp = virJSONValueArrayGet(leases_array, i);
long long expirytime;
const char *ip_tmp = NULL;
int
-virLeasePrintLeases(virJSONValuePtr leases_array_new,
+virLeasePrintLeases(virJSONValue *leases_array_new,
const char *server_duid)
{
- virJSONValuePtr lease_tmp = NULL;
+ virJSONValue *lease_tmp = NULL;
const char *ip_tmp = NULL;
long long expirytime = 0;
size_t i;
int
-virLeaseNew(virJSONValuePtr *lease_ret,
+virLeaseNew(virJSONValue **lease_ret,
const char *mac,
const char *clientid,
const char *ip,
#include "virjson.h"
-int virLeaseReadCustomLeaseFile(virJSONValuePtr leases_array_new,
+int virLeaseReadCustomLeaseFile(virJSONValue *leases_array_new,
const char *custom_lease_file,
const char *ip_to_delete,
char **server_duid);
-int virLeasePrintLeases(virJSONValuePtr leases_array_new,
+int virLeasePrintLeases(virJSONValue *leases_array_new,
const char *server_duid);
-int virLeaseNew(virJSONValuePtr *lease_ret,
+int virLeaseNew(virJSONValue **lease_ret,
const char *mac,
const char *clientid,
const char *ip,
#define VIR_LOCKSPACE_TABLE_SIZE 10
typedef struct _virLockSpaceResource virLockSpaceResource;
-typedef virLockSpaceResource *virLockSpaceResourcePtr;
-
struct _virLockSpaceResource {
char *name;
char *path;
};
-static char *virLockSpaceGetResourcePath(virLockSpacePtr lockspace,
+static char *virLockSpaceGetResourcePath(virLockSpace *lockspace,
const char *resname)
{
char *ret;
}
-static void virLockSpaceResourceFree(virLockSpaceResourcePtr res)
+static void virLockSpaceResourceFree(virLockSpaceResource *res)
{
if (!res)
return;
}
-static virLockSpaceResourcePtr
-virLockSpaceResourceNew(virLockSpacePtr lockspace,
+static virLockSpaceResource *
+virLockSpaceResourceNew(virLockSpace *lockspace,
const char *resname,
unsigned int flags,
pid_t owner)
{
- virLockSpaceResourcePtr res;
+ virLockSpaceResource *res;
bool shared = !!(flags & VIR_LOCK_SPACE_ACQUIRE_SHARED);
res = g_new0(virLockSpaceResource, 1);
static void virLockSpaceResourceDataFree(void *opaque)
{
- virLockSpaceResourcePtr res = opaque;
+ virLockSpaceResource *res = opaque;
virLockSpaceResourceFree(res);
}
-virLockSpacePtr virLockSpaceNew(const char *directory)
+virLockSpace *virLockSpaceNew(const char *directory)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
VIR_DEBUG("directory=%s", NULLSTR(directory));
-virLockSpacePtr virLockSpaceNewPostExecRestart(virJSONValuePtr object)
+virLockSpace *virLockSpaceNewPostExecRestart(virJSONValue *object)
{
- virLockSpacePtr lockspace;
- virJSONValuePtr resources;
+ virLockSpace *lockspace;
+ virJSONValue *resources;
size_t i;
VIR_DEBUG("object=%p", object);
}
for (i = 0; i < virJSONValueArraySize(resources); i++) {
- virJSONValuePtr child = virJSONValueArrayGet(resources, i);
- virLockSpaceResourcePtr res;
+ virJSONValue *child = virJSONValueArrayGet(resources, i);
+ virLockSpaceResource *res;
const char *tmp;
- virJSONValuePtr owners;
+ virJSONValue *owners;
size_t j;
res = g_new0(virLockSpaceResource, 1);
for (j = 0; j < res->nOwners; j++) {
unsigned long long int owner;
- virJSONValuePtr ownerval = virJSONValueArrayGet(owners, j);
+ virJSONValue *ownerval = virJSONValueArrayGet(owners, j);
if (virJSONValueGetNumberUlong(ownerval, &owner) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
-virJSONValuePtr virLockSpacePreExecRestart(virLockSpacePtr lockspace)
+virJSONValue *virLockSpacePreExecRestart(virLockSpace *lockspace)
{
g_autoptr(virJSONValue) object = virJSONValueNewObject();
g_autoptr(virJSONValue) resources = virJSONValueNewArray();
- g_autofree virHashKeyValuePairPtr pairs = NULL;
- virHashKeyValuePairPtr tmp;
+ g_autofree virHashKeyValuePair *pairs = NULL;
+ virHashKeyValuePair *tmp;
virMutexLock(&lockspace->lock);
tmp = pairs = virHashGetItems(lockspace->resources, NULL, false);
while (tmp && tmp->value) {
- virLockSpaceResourcePtr res = (virLockSpaceResourcePtr)tmp->value;
+ virLockSpaceResource *res = (virLockSpaceResource *)tmp->value;
g_autoptr(virJSONValue) child = virJSONValueNewObject();
g_autoptr(virJSONValue) owners = virJSONValueNewArray();
size_t i;
}
-void virLockSpaceFree(virLockSpacePtr lockspace)
+void virLockSpaceFree(virLockSpace *lockspace)
{
if (!lockspace)
return;
}
-const char *virLockSpaceGetDirectory(virLockSpacePtr lockspace)
+const char *virLockSpaceGetDirectory(virLockSpace *lockspace)
{
return lockspace->dir;
}
-int virLockSpaceCreateResource(virLockSpacePtr lockspace,
+int virLockSpaceCreateResource(virLockSpace *lockspace,
const char *resname)
{
int ret = -1;
}
-int virLockSpaceDeleteResource(virLockSpacePtr lockspace,
+int virLockSpaceDeleteResource(virLockSpace *lockspace,
const char *resname)
{
int ret = -1;
}
-int virLockSpaceAcquireResource(virLockSpacePtr lockspace,
+int virLockSpaceAcquireResource(virLockSpace *lockspace,
const char *resname,
pid_t owner,
unsigned int flags)
{
int ret = -1;
- virLockSpaceResourcePtr res;
+ virLockSpaceResource *res;
VIR_DEBUG("lockspace=%p resname=%s flags=0x%x owner=%lld",
lockspace, resname, flags, (unsigned long long)owner);
}
-int virLockSpaceReleaseResource(virLockSpacePtr lockspace,
+int virLockSpaceReleaseResource(virLockSpace *lockspace,
const char *resname,
pid_t owner)
{
int ret = -1;
- virLockSpaceResourcePtr res;
+ virLockSpaceResource *res;
size_t i;
VIR_DEBUG("lockspace=%p resname=%s owner=%lld",
const char *name G_GNUC_UNUSED,
const void *opaque)
{
- virLockSpaceResourcePtr res = (virLockSpaceResourcePtr)payload;
+ virLockSpaceResource *res = (virLockSpaceResource *)payload;
struct virLockSpaceRemoveData *data = (struct virLockSpaceRemoveData *)opaque;
size_t i;
}
-int virLockSpaceReleaseResourcesForOwner(virLockSpacePtr lockspace,
+int virLockSpaceReleaseResourcesForOwner(virLockSpace *lockspace,
pid_t owner)
{
int ret = 0;
#include "virjson.h"
typedef struct _virLockSpace virLockSpace;
-typedef virLockSpace *virLockSpacePtr;
-virLockSpacePtr virLockSpaceNew(const char *directory);
-virLockSpacePtr virLockSpaceNewPostExecRestart(virJSONValuePtr object);
+virLockSpace *virLockSpaceNew(const char *directory);
+virLockSpace *virLockSpaceNewPostExecRestart(virJSONValue *object);
-virJSONValuePtr virLockSpacePreExecRestart(virLockSpacePtr lockspace);
+virJSONValue *virLockSpacePreExecRestart(virLockSpace *lockspace);
-void virLockSpaceFree(virLockSpacePtr lockspace);
+void virLockSpaceFree(virLockSpace *lockspace);
-const char *virLockSpaceGetDirectory(virLockSpacePtr lockspace);
+const char *virLockSpaceGetDirectory(virLockSpace *lockspace);
-int virLockSpaceCreateResource(virLockSpacePtr lockspace,
+int virLockSpaceCreateResource(virLockSpace *lockspace,
const char *resname);
-int virLockSpaceDeleteResource(virLockSpacePtr lockspace,
+int virLockSpaceDeleteResource(virLockSpace *lockspace,
const char *resname);
typedef enum {
VIR_LOCK_SPACE_ACQUIRE_AUTOCREATE = (1 << 1),
} virLockSpaceAcquireFlags;
-int virLockSpaceAcquireResource(virLockSpacePtr lockspace,
+int virLockSpaceAcquireResource(virLockSpace *lockspace,
const char *resname,
pid_t owner,
unsigned int flags);
-int virLockSpaceReleaseResource(virLockSpacePtr lockspace,
+int virLockSpaceReleaseResource(virLockSpace *lockspace,
const char *resname,
pid_t owner);
-int virLockSpaceReleaseResourcesForOwner(virLockSpacePtr lockspace,
+int virLockSpaceReleaseResourcesForOwner(virLockSpace *lockspace,
pid_t owner);
};
static int virLogFiltersSerial = 1;
-static virLogFilterPtr *virLogFilters;
+static virLogFilter **virLogFilters;
static size_t virLogNbFilters;
/*
};
static char *virLogDefaultOutput;
-static virLogOutputPtr *virLogOutputs;
+static virLogOutput **virLogOutputs;
static size_t virLogNbOutputs;
/*
static void virLogResetFilters(void);
static void virLogResetOutputs(void);
-static void virLogOutputToFd(virLogSourcePtr src,
+static void virLogOutputToFd(virLogSource *src,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
const char *timestamp,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *rawstr,
const char *str,
void *data);
void
-virLogFilterFree(virLogFilterPtr filter)
+virLogFilterFree(virLogFilter *filter)
{
if (!filter)
return;
* Frees a list of filters.
*/
void
-virLogFilterListFree(virLogFilterPtr *list, int count)
+virLogFilterListFree(virLogFilter **list, int count)
{
size_t i;
void
-virLogOutputFree(virLogOutputPtr output)
+virLogOutputFree(virLogOutput *output)
{
if (!output)
return;
* Frees a list of outputs.
*/
void
-virLogOutputListFree(virLogOutputPtr *list, int count)
+virLogOutputListFree(virLogOutput **list, int count)
{
size_t i;
static void
-virLogSourceUpdate(virLogSourcePtr source)
+virLogSourceUpdate(virLogSource *source)
{
virLogLock();
if (source->serial < virLogFiltersSerial) {
*/
static void
G_GNUC_PRINTF(7, 0)
-virLogVMessage(virLogSourcePtr source,
+virLogVMessage(virLogSource *source,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *fmt,
va_list vargs)
{
* the message may be stored, sent to output or just discarded
*/
void
-virLogMessage(virLogSourcePtr source,
+virLogMessage(virLogSource *source,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *fmt, ...)
{
va_list ap;
static void
-virLogOutputToFd(virLogSourcePtr source G_GNUC_UNUSED,
+virLogOutputToFd(virLogSource *source G_GNUC_UNUSED,
virLogPriority priority G_GNUC_UNUSED,
const char *filename G_GNUC_UNUSED,
int linenr G_GNUC_UNUSED,
const char *funcname G_GNUC_UNUSED,
const char *timestamp,
- virLogMetadataPtr metadata G_GNUC_UNUSED,
+ struct _virLogMetadata *metadata G_GNUC_UNUSED,
const char *rawstr G_GNUC_UNUSED,
const char *str,
void *data)
}
-static virLogOutputPtr
+static virLogOutput *
virLogNewOutputToStderr(virLogPriority priority)
{
return virLogOutputNew(virLogOutputToFd, NULL, (void *)STDERR_FILENO,
}
-static virLogOutputPtr
+static virLogOutput *
virLogNewOutputToFile(virLogPriority priority,
const char *file)
{
int fd;
- virLogOutputPtr ret = NULL;
+ virLogOutput *ret = NULL;
fd = open(file, O_CREAT | O_APPEND | O_WRONLY, S_IRUSR | S_IWUSR);
if (fd < 0) {
#if WITH_SYSLOG_H
static void
-virLogOutputToSyslog(virLogSourcePtr source G_GNUC_UNUSED,
+virLogOutputToSyslog(virLogSource *source G_GNUC_UNUSED,
virLogPriority priority,
const char *filename G_GNUC_UNUSED,
int linenr G_GNUC_UNUSED,
const char *funcname G_GNUC_UNUSED,
const char *timestamp G_GNUC_UNUSED,
- virLogMetadataPtr metadata G_GNUC_UNUSED,
+ struct _virLogMetadata *metadata G_GNUC_UNUSED,
const char *rawstr G_GNUC_UNUSED,
const char *str,
void *data G_GNUC_UNUSED)
}
-static virLogOutputPtr
+static virLogOutput *
virLogNewOutputToSyslog(virLogPriority priority,
const char *ident)
{
- virLogOutputPtr ret = NULL;
+ virLogOutput *ret = NULL;
int at = -1;
/* There are a couple of issues with syslog:
}
static void
-virLogOutputToJournald(virLogSourcePtr source,
+virLogOutputToJournald(virLogSource *source,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
const char *timestamp G_GNUC_UNUSED,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *rawstr,
const char *str G_GNUC_UNUSED,
void *data)
}
-static virLogOutputPtr
+static virLogOutput *
virLogNewOutputToJournald(int priority)
{
int journalfd;
- virLogOutputPtr ret = NULL;
+ virLogOutput *ret = NULL;
if ((journalfd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
return NULL;
*
* Returns reference to a newly created object or NULL in case of failure.
*/
-virLogOutputPtr
+virLogOutput *
virLogOutputNew(virLogOutputFunc f,
virLogCloseFunc c,
void *data,
virLogDestination dest,
const char *name)
{
- virLogOutputPtr ret = NULL;
+ virLogOutput *ret = NULL;
char *ndup = NULL;
if (dest == VIR_LOG_TO_SYSLOG || dest == VIR_LOG_TO_FILE) {
* Returns a reference to a newly created filter that needs to be defined using
* virLogDefineFilters, or NULL in case of an error.
*/
-virLogFilterPtr
+virLogFilter *
virLogFilterNew(const char *match,
virLogPriority priority)
{
- virLogFilterPtr ret = NULL;
+ virLogFilter *ret = NULL;
size_t mlen = strlen(match);
if (priority < VIR_LOG_DEBUG || priority > VIR_LOG_ERROR) {
* specified @dest type and/or @opaque data one was found.
*/
int
-virLogFindOutput(virLogOutputPtr *outputs, size_t noutputs,
+virLogFindOutput(virLogOutput **outputs, size_t noutputs,
virLogDestination dest, const void *opaque)
{
size_t i;
* Returns number of outputs successfully defined or -1 in case of error;
*/
int
-virLogDefineOutputs(virLogOutputPtr *outputs, size_t noutputs)
+virLogDefineOutputs(virLogOutput **outputs, size_t noutputs)
{
#if WITH_SYSLOG_H
int id;
* Returns 0 on success or -1 in case of error.
*/
int
-virLogDefineFilters(virLogFilterPtr *filters, size_t nfilters)
+virLogDefineFilters(virLogFilter **filters, size_t nfilters)
{
if (virLogInitialize() < 0)
return -1;
* Returns a newly created logging object from @src on success or NULL in case
* of an error.
*/
-virLogOutputPtr
+virLogOutput *
virLogParseOutput(const char *src)
{
- virLogOutputPtr ret = NULL;
+ virLogOutput *ret = NULL;
g_auto(GStrv) tokens = NULL;
char *abspath = NULL;
size_t count = 0;
* Returns a newly created logging object from @src on success or NULL in case
* of an error.
*/
-virLogFilterPtr
+virLogFilter *
virLogParseFilter(const char *src)
{
virLogPriority prio;
* Returns the number of outputs parsed or -1 in case of error.
*/
int
-virLogParseOutputs(const char *src, virLogOutputPtr **outputs)
+virLogParseOutputs(const char *src, virLogOutput ***outputs)
{
int at = -1;
size_t noutputs = 0;
g_auto(GStrv) strings = NULL;
GStrv next;
- virLogOutputPtr output = NULL;
- virLogOutputPtr *list = NULL;
+ virLogOutput *output = NULL;
+ virLogOutput **list = NULL;
VIR_DEBUG("outputs=%s", src);
* Returns the number of filter parsed or -1 in case of error.
*/
int
-virLogParseFilters(const char *src, virLogFilterPtr **filters)
+virLogParseFilters(const char *src, virLogFilter ***filters)
{
size_t nfilters = 0;
g_auto(GStrv) strings = NULL;
GStrv next;
- virLogFilterPtr filter = NULL;
- virLogFilterPtr *list = NULL;
+ virLogFilter *filter = NULL;
+ virLogFilter **list = NULL;
VIR_DEBUG("filters=%s", src);
int ret = -1;
int noutputs = 0;
const char *outputstr = virLogDefaultOutput;
- virLogOutputPtr *outputs = NULL;
+ virLogOutput **outputs = NULL;
if (virLogInitialize() < 0)
return -1;
{
int ret = -1;
int nfilters = 0;
- virLogFilterPtr *filters = NULL;
+ virLogFilter **filters = NULL;
if (virLogInitialize() < 0)
return -1;
} virLogDestination;
typedef struct _virLogSource virLogSource;
-typedef virLogSource *virLogSourcePtr;
-
struct _virLogSource {
const char *name;
unsigned int priority;
};
typedef struct _virLogMetadata virLogMetadata;
-typedef struct _virLogMetadata *virLogMetadataPtr;
typedef struct _virLogOutput virLogOutput;
-typedef virLogOutput *virLogOutputPtr;
typedef struct _virLogFilter virLogFilter;
-typedef virLogFilter *virLogFilterPtr;
/**
* virLogOutputFunc:
*
* Callback function used to output messages
*/
-typedef void (*virLogOutputFunc) (virLogSourcePtr src,
+typedef void (*virLogOutputFunc) (virLogSource *src,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
const char *timestamp,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *rawstr,
const char *str,
void *data);
virLogPriority virLogGetDefaultPriority(void);
int virLogSetDefaultPriority(virLogPriority priority);
void virLogSetFromEnv(void);
-void virLogOutputFree(virLogOutputPtr output);
-void virLogOutputListFree(virLogOutputPtr *list, int count);
-void virLogFilterFree(virLogFilterPtr filter);
-void virLogFilterListFree(virLogFilterPtr *list, int count);
+void virLogOutputFree(virLogOutput *output);
+void virLogOutputListFree(virLogOutput **list, int count);
+void virLogFilterFree(virLogFilter *filter);
+void virLogFilterListFree(virLogFilter **list, int count);
int virLogSetOutputs(const char *outputs);
int virLogSetFilters(const char *filters);
char *virLogGetDefaultOutput(void);
int virLogReset(void);
int virLogParseDefaultPriority(const char *priority);
int virLogPriorityFromSyslog(int priority);
-void virLogMessage(virLogSourcePtr source,
+void virLogMessage(virLogSource *source,
virLogPriority priority,
const char *filename,
int linenr,
const char *funcname,
- virLogMetadataPtr metadata,
+ struct _virLogMetadata *metadata,
const char *fmt, ...) G_GNUC_PRINTF(7, 8);
bool virLogProbablyLogMessage(const char *str);
-virLogOutputPtr virLogOutputNew(virLogOutputFunc f,
+virLogOutput *virLogOutputNew(virLogOutputFunc f,
virLogCloseFunc c,
void *data,
virLogPriority priority,
virLogDestination dest,
const char *name) ATTRIBUTE_NONNULL(1);
-virLogFilterPtr virLogFilterNew(const char *match,
+virLogFilter *virLogFilterNew(const char *match,
virLogPriority priority) ATTRIBUTE_NONNULL(1);
-int virLogFindOutput(virLogOutputPtr *outputs, size_t noutputs,
+int virLogFindOutput(virLogOutput **outputs, size_t noutputs,
virLogDestination dest, const void *opaque);
-int virLogDefineOutputs(virLogOutputPtr *outputs,
+int virLogDefineOutputs(virLogOutput **outputs,
size_t noutputs) ATTRIBUTE_NONNULL(1);
-int virLogDefineFilters(virLogFilterPtr *filters, size_t nfilters);
-virLogOutputPtr virLogParseOutput(const char *src) ATTRIBUTE_NONNULL(1);
-virLogFilterPtr virLogParseFilter(const char *src) ATTRIBUTE_NONNULL(1);
+int virLogDefineFilters(virLogFilter **filters, size_t nfilters);
+virLogOutput *virLogParseOutput(const char *src) ATTRIBUTE_NONNULL(1);
+virLogFilter *virLogParseFilter(const char *src) ATTRIBUTE_NONNULL(1);
int virLogParseOutputs(const char *src,
- virLogOutputPtr **outputs) ATTRIBUTE_NONNULL(1);
+ virLogOutput ***outputs) ATTRIBUTE_NONNULL(1);
int virLogParseFilters(const char *src,
- virLogFilterPtr **filters) ATTRIBUTE_NONNULL(1);
+ virLogFilter ***filters) ATTRIBUTE_NONNULL(1);
* Copy src to dst
*/
void
-virMacAddrSet(virMacAddrPtr dst, const virMacAddr *src)
+virMacAddrSet(virMacAddr *dst, const virMacAddr *src)
{
memcpy(dst, src, sizeof(*src));
}
* Set the MAC address to the given value
*/
void
-virMacAddrSetRaw(virMacAddrPtr dst, const unsigned char src[VIR_MAC_BUFLEN])
+virMacAddrSetRaw(virMacAddr *dst, const unsigned char src[VIR_MAC_BUFLEN])
{
memcpy(dst->addr, src, VIR_MAC_BUFLEN);
}
* Return 0 upon success, or -1 in case of error.
*/
int
-virMacAddrParse(const char* str, virMacAddrPtr addr)
+virMacAddrParse(const char* str, virMacAddr *addr)
{
size_t i;
* Return 0 upon success, or -1 in case of error.
*/
int
-virMacAddrParseHex(const char *str, virMacAddrPtr addr)
+virMacAddrParseHex(const char *str, virMacAddr *addr)
{
size_t i;
}
void virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
- virMacAddrPtr addr)
+ virMacAddr *addr)
{
addr->addr[0] = prefix[0];
addr->addr[1] = prefix[1];
}
void
-virMacAddrFree(virMacAddrPtr addr)
+virMacAddrFree(virMacAddr *addr)
{
g_free(addr);
}
#define VIR_MAC_STRING_BUFLEN (VIR_MAC_BUFLEN * 3)
typedef struct _virMacAddr virMacAddr;
-typedef virMacAddr *virMacAddrPtr;
-
struct _virMacAddr {
unsigned char addr[VIR_MAC_BUFLEN];
};
int virMacAddrCmp(const virMacAddr *mac1, const virMacAddr *mac2);
int virMacAddrCmpRaw(const virMacAddr *mac1,
const unsigned char s[VIR_MAC_BUFLEN]);
-void virMacAddrSet(virMacAddrPtr dst, const virMacAddr *src);
-void virMacAddrSetRaw(virMacAddrPtr dst, const unsigned char s[VIR_MAC_BUFLEN]);
+void virMacAddrSet(virMacAddr *dst, const virMacAddr *src);
+void virMacAddrSetRaw(virMacAddr *dst, const unsigned char s[VIR_MAC_BUFLEN]);
void virMacAddrGetRaw(const virMacAddr *src, unsigned char dst[VIR_MAC_BUFLEN]);
const char *virMacAddrFormat(const virMacAddr *addr,
char *str);
void virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
- virMacAddrPtr addr) G_GNUC_NO_INLINE;
+ virMacAddr *addr) G_GNUC_NO_INLINE;
int virMacAddrParse(const char* str,
- virMacAddrPtr addr) G_GNUC_WARN_UNUSED_RESULT;
+ virMacAddr *addr) G_GNUC_WARN_UNUSED_RESULT;
int virMacAddrParseHex(const char* str,
- virMacAddrPtr addr)
+ virMacAddr *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
bool virMacAddrIsUnicast(const virMacAddr *addr);
bool virMacAddrIsMulticast(const virMacAddr *addr);
bool virMacAddrIsBroadcastRaw(const unsigned char s[VIR_MAC_BUFLEN]);
-void virMacAddrFree(virMacAddrPtr addr);
+void virMacAddrFree(virMacAddr *addr);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virMacAddr, virMacAddrFree);
};
-static virClassPtr virMacMapClass;
+static virClass *virMacMapClass;
static void
virMacMapDispose(void *obj)
{
- virMacMapPtr mgr = obj;
+ virMacMap *mgr = obj;
GHashTableIter htitr;
void *value;
static void
-virMacMapAddLocked(virMacMapPtr mgr,
+virMacMapAddLocked(virMacMap *mgr,
const char *domain,
const char *mac)
{
static void
-virMacMapRemoveLocked(virMacMapPtr mgr,
+virMacMapRemoveLocked(virMacMap *mgr,
const char *domain,
const char *mac)
{
static int
-virMacMapLoadFile(virMacMapPtr mgr,
+virMacMapLoadFile(virMacMap *mgr,
const char *file)
{
g_autofree char *map_str = NULL;
}
for (i = 0; i < virJSONValueArraySize(map); i++) {
- virJSONValuePtr tmp = virJSONValueArrayGet(map, i);
- virJSONValuePtr macs;
+ virJSONValue *tmp = virJSONValueArrayGet(map, i);
+ virJSONValue *macs;
const char *domain;
size_t j;
GSList *vals = NULL;
}
for (j = 0; j < virJSONValueArraySize(macs); j++) {
- virJSONValuePtr macJSON = virJSONValueArrayGet(macs, j);
+ virJSONValue *macJSON = virJSONValueArrayGet(macs, j);
vals = g_slist_prepend(vals, g_strdup(virJSONValueGetString(macJSON)));
}
static int
-virMacMapDumpStrLocked(virMacMapPtr mgr,
+virMacMapDumpStrLocked(virMacMap *mgr,
char **str)
{
g_autoptr(virJSONValue) arr = virJSONValueNewArray();
static int
-virMacMapWriteFileLocked(virMacMapPtr mgr,
+virMacMapWriteFileLocked(virMacMap *mgr,
const char *file)
{
g_autofree char *str = NULL;
#define VIR_MAC_HASH_TABLE_SIZE 10
-virMacMapPtr
+virMacMap *
virMacMapNew(const char *file)
{
- virMacMapPtr mgr;
+ virMacMap *mgr;
if (virMacMapInitialize() < 0)
return NULL;
int
-virMacMapAdd(virMacMapPtr mgr,
+virMacMapAdd(virMacMap *mgr,
const char *domain,
const char *mac)
{
int
-virMacMapRemove(virMacMapPtr mgr,
+virMacMapRemove(virMacMap *mgr,
const char *domain,
const char *mac)
{
/* note that the returned pointer may be invalidated by other APIs in this module */
GSList *
-virMacMapLookup(virMacMapPtr mgr,
+virMacMapLookup(virMacMap *mgr,
const char *domain)
{
GSList *ret;
int
-virMacMapWriteFile(virMacMapPtr mgr,
+virMacMapWriteFile(virMacMap *mgr,
const char *filename)
{
int ret;
int
-virMacMapDumpStr(virMacMapPtr mgr,
+virMacMapDumpStr(virMacMap *mgr,
char **str)
{
int ret;
#include "internal.h"
typedef struct virMacMap virMacMap;
-typedef virMacMap *virMacMapPtr;
char *
virMacMapFileName(const char *dnsmasqStateDir,
const char *bridge);
-virMacMapPtr virMacMapNew(const char *file);
+virMacMap *virMacMapNew(const char *file);
-int virMacMapAdd(virMacMapPtr mgr,
+int virMacMapAdd(virMacMap *mgr,
const char *domain,
const char *mac);
-int virMacMapRemove(virMacMapPtr mgr,
+int virMacMapRemove(virMacMap *mgr,
const char *domain,
const char *mac);
-GSList *virMacMapLookup(virMacMapPtr mgr,
+GSList *virMacMapLookup(virMacMap *mgr,
const char *domain);
-int virMacMapWriteFile(virMacMapPtr mgr,
+int virMacMapWriteFile(virMacMap *mgr,
const char *filename);
-int virMacMapDumpStr(virMacMapPtr mgr,
+int virMacMapDumpStr(virMacMap *mgr,
char **str);
virObjectLockable parent;
size_t count;
- virMediatedDevicePtr *devs;
+ virMediatedDevice **devs;
};
VIR_ENUM_IMPL(virMediatedDeviceModel,
"vfio-ap",
);
-static virClassPtr virMediatedDeviceListClass;
+static virClass *virMediatedDeviceListClass;
static void
virMediatedDeviceListDispose(void *obj);
#ifdef __linux__
static int
-virMediatedDeviceGetSysfsDeviceAPI(virMediatedDevicePtr dev,
+virMediatedDeviceGetSysfsDeviceAPI(virMediatedDevice *dev,
char **device_api)
{
g_autofree char *buf = NULL;
static int
-virMediatedDeviceCheckModel(virMediatedDevicePtr dev,
+virMediatedDeviceCheckModel(virMediatedDevice *dev,
virMediatedDeviceModelType model)
{
g_autofree char *dev_api = NULL;
}
-virMediatedDevicePtr
+virMediatedDevice *
virMediatedDeviceNew(const char *uuidstr, virMediatedDeviceModelType model)
{
g_autoptr(virMediatedDevice) dev = NULL;
#else
-virMediatedDevicePtr
+virMediatedDevice *
virMediatedDeviceNew(const char *uuidstr G_GNUC_UNUSED,
virMediatedDeviceModelType model G_GNUC_UNUSED)
{
#endif /* __linux__ */
void
-virMediatedDeviceFree(virMediatedDevicePtr dev)
+virMediatedDeviceFree(virMediatedDevice *dev)
{
if (!dev)
return;
const char *
-virMediatedDeviceGetPath(virMediatedDevicePtr dev)
+virMediatedDeviceGetPath(virMediatedDevice *dev)
{
return dev->path;
}
void
-virMediatedDeviceGetUsedBy(virMediatedDevicePtr dev,
+virMediatedDeviceGetUsedBy(virMediatedDevice *dev,
const char **drvname, const char **domname)
{
*drvname = dev->used_by_drvname;
int
-virMediatedDeviceSetUsedBy(virMediatedDevicePtr dev,
+virMediatedDeviceSetUsedBy(virMediatedDevice *dev,
const char *drvname,
const char *domname)
{
}
-virMediatedDeviceListPtr
+virMediatedDeviceList *
virMediatedDeviceListNew(void)
{
- virMediatedDeviceListPtr list;
+ virMediatedDeviceList *list;
if (virMediatedInitialize() < 0)
return NULL;
static void
virMediatedDeviceListDispose(void *obj)
{
- virMediatedDeviceListPtr list = obj;
+ virMediatedDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++) {
* the pointer and we need to clear the original not a copy on the stack
*/
int
-virMediatedDeviceListAdd(virMediatedDeviceListPtr list,
- virMediatedDevicePtr *dev)
+virMediatedDeviceListAdd(virMediatedDeviceList *list,
+ virMediatedDevice **dev)
{
if (virMediatedDeviceListFind(list, (*dev)->path)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
-virMediatedDevicePtr
-virMediatedDeviceListGet(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListGet(virMediatedDeviceList *list,
ssize_t idx)
{
if (idx < 0 || idx >= list->count)
size_t
-virMediatedDeviceListCount(virMediatedDeviceListPtr list)
+virMediatedDeviceListCount(virMediatedDeviceList *list)
{
return list->count;
}
-virMediatedDevicePtr
-virMediatedDeviceListStealIndex(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListStealIndex(virMediatedDeviceList *list,
ssize_t idx)
{
- virMediatedDevicePtr ret;
+ virMediatedDevice *ret;
if (idx < 0 || idx >= list->count)
return NULL;
}
-virMediatedDevicePtr
-virMediatedDeviceListSteal(virMediatedDeviceListPtr list,
- virMediatedDevicePtr dev)
+virMediatedDevice *
+virMediatedDeviceListSteal(virMediatedDeviceList *list,
+ virMediatedDevice *dev)
{
int idx = -1;
void
-virMediatedDeviceListDel(virMediatedDeviceListPtr list,
- virMediatedDevicePtr dev)
+virMediatedDeviceListDel(virMediatedDeviceList *list,
+ virMediatedDevice *dev)
{
virMediatedDeviceFree(virMediatedDeviceListSteal(list, dev));
}
int
-virMediatedDeviceListFindIndex(virMediatedDeviceListPtr list,
+virMediatedDeviceListFindIndex(virMediatedDeviceList *list,
const char *sysfspath)
{
size_t i;
for (i = 0; i < list->count; i++) {
- virMediatedDevicePtr dev = list->devs[i];
+ virMediatedDevice *dev = list->devs[i];
if (STREQ(sysfspath, dev->path))
return i;
}
}
-virMediatedDevicePtr
-virMediatedDeviceListFind(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListFind(virMediatedDeviceList *list,
const char *sysfspath)
{
int idx;
bool
-virMediatedDeviceIsUsed(virMediatedDevicePtr dev,
- virMediatedDeviceListPtr list)
+virMediatedDeviceIsUsed(virMediatedDevice *dev,
+ virMediatedDeviceList *list)
{
const char *drvname, *domname;
- virMediatedDevicePtr tmp = NULL;
+ virMediatedDevice *tmp = NULL;
if ((tmp = virMediatedDeviceListFind(list, dev->path))) {
virMediatedDeviceGetUsedBy(tmp, &drvname, &domname);
int
-virMediatedDeviceListMarkDevices(virMediatedDeviceListPtr dst,
- virMediatedDeviceListPtr src,
+virMediatedDeviceListMarkDevices(virMediatedDeviceList *dst,
+ virMediatedDeviceList *src,
const char *drvname,
const char *domname)
{
virObjectLock(dst);
for (i = 0; i < count; i++) {
- virMediatedDevicePtr mdev = virMediatedDeviceListGet(src, i);
+ virMediatedDevice *mdev = virMediatedDeviceListGet(src, i);
if (virMediatedDeviceIsUsed(mdev, dst) ||
virMediatedDeviceSetUsedBy(mdev, drvname, domname) < 0)
rollback:
for (j = 0; j < i; j++) {
- virMediatedDevicePtr tmp = virMediatedDeviceListGet(src, j);
+ virMediatedDevice *tmp = virMediatedDeviceListGet(src, j);
virMediatedDeviceListSteal(dst, tmp);
}
goto cleanup;
void
-virMediatedDeviceTypeFree(virMediatedDeviceTypePtr type)
+virMediatedDeviceTypeFree(virMediatedDeviceType *type)
{
if (!type)
return;
int
virMediatedDeviceTypeReadAttrs(const char *sysfspath,
- virMediatedDeviceTypePtr *type)
+ virMediatedDeviceType **type)
{
g_autoptr(virMediatedDeviceType) tmp = NULL;
return 0;
}
-virMediatedDeviceAttrPtr virMediatedDeviceAttrNew(void)
+virMediatedDeviceAttr *virMediatedDeviceAttrNew(void)
{
return g_new0(virMediatedDeviceAttr, 1);
}
-void virMediatedDeviceAttrFree(virMediatedDeviceAttrPtr attr)
+void virMediatedDeviceAttrFree(virMediatedDeviceAttr *attr)
{
g_free(attr->name);
g_free(attr->value);
ssize_t
virMediatedDeviceGetMdevTypes(const char *sysfspath,
- virMediatedDeviceTypePtr **types,
+ virMediatedDeviceType ***types,
size_t *ntypes)
{
ssize_t ret = -1;
struct dirent *entry;
g_autofree char *types_path = NULL;
g_autoptr(virMediatedDeviceType) mdev_type = NULL;
- virMediatedDeviceTypePtr *mdev_types = NULL;
+ virMediatedDeviceType **mdev_types = NULL;
size_t nmdev_types = 0;
size_t i;
ssize_t
virMediatedDeviceGetMdevTypes(const char *sysfspath G_GNUC_UNUSED,
- virMediatedDeviceTypePtr **types G_GNUC_UNUSED,
+ virMediatedDeviceType ***types G_GNUC_UNUSED,
size_t *ntypes G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported));
typedef struct _virMediatedDevice virMediatedDevice;
-typedef virMediatedDevice *virMediatedDevicePtr;
typedef struct _virMediatedDeviceList virMediatedDeviceList;
-typedef virMediatedDeviceList *virMediatedDeviceListPtr;
typedef struct _virMediatedDeviceAttr virMediatedDeviceAttr;
-typedef virMediatedDeviceAttr *virMediatedDeviceAttrPtr;
-
struct _virMediatedDeviceAttr {
char *name;
char *value;
};
-virMediatedDeviceAttrPtr virMediatedDeviceAttrNew(void);
-void virMediatedDeviceAttrFree(virMediatedDeviceAttrPtr attr);
+virMediatedDeviceAttr *virMediatedDeviceAttrNew(void);
+void virMediatedDeviceAttrFree(virMediatedDeviceAttr *attr);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virMediatedDeviceAttr, virMediatedDeviceAttrFree);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virMediatedDeviceList, virObjectUnref);
typedef struct _virMediatedDeviceType virMediatedDeviceType;
-typedef virMediatedDeviceType *virMediatedDeviceTypePtr;
struct _virMediatedDeviceType {
char *id;
char *name;
unsigned int available_instances;
};
-typedef int (*virMediatedDeviceCallback)(virMediatedDevicePtr dev,
+typedef int (*virMediatedDeviceCallback)(virMediatedDevice *dev,
const char *path, void *opaque);
-virMediatedDevicePtr
+virMediatedDevice *
virMediatedDeviceNew(const char *uuidstr, virMediatedDeviceModelType model);
-virMediatedDevicePtr
-virMediatedDeviceCopy(virMediatedDevicePtr dev);
+virMediatedDevice *
+virMediatedDeviceCopy(virMediatedDevice *dev);
void
-virMediatedDeviceFree(virMediatedDevicePtr dev);
+virMediatedDeviceFree(virMediatedDevice *dev);
const char *
-virMediatedDeviceGetPath(virMediatedDevicePtr dev);
+virMediatedDeviceGetPath(virMediatedDevice *dev);
void
-virMediatedDeviceGetUsedBy(virMediatedDevicePtr dev,
+virMediatedDeviceGetUsedBy(virMediatedDevice *dev,
const char **drvname, const char **domname);
int
-virMediatedDeviceSetUsedBy(virMediatedDevicePtr dev,
+virMediatedDeviceSetUsedBy(virMediatedDevice *dev,
const char *drvname,
const char *domname);
virMediatedDeviceGetSysfsPath(const char *uuidstr);
bool
-virMediatedDeviceIsUsed(virMediatedDevicePtr dev,
- virMediatedDeviceListPtr list);
+virMediatedDeviceIsUsed(virMediatedDevice *dev,
+ virMediatedDeviceList *list);
bool
-virMediatedDeviceIsUsed(virMediatedDevicePtr dev,
- virMediatedDeviceListPtr list);
+virMediatedDeviceIsUsed(virMediatedDevice *dev,
+ virMediatedDeviceList *list);
-virMediatedDeviceListPtr
+virMediatedDeviceList *
virMediatedDeviceListNew(void);
int
-virMediatedDeviceListAdd(virMediatedDeviceListPtr list,
- virMediatedDevicePtr *dev);
+virMediatedDeviceListAdd(virMediatedDeviceList *list,
+ virMediatedDevice **dev);
-virMediatedDevicePtr
-virMediatedDeviceListGet(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListGet(virMediatedDeviceList *list,
ssize_t idx);
size_t
-virMediatedDeviceListCount(virMediatedDeviceListPtr list);
+virMediatedDeviceListCount(virMediatedDeviceList *list);
-virMediatedDevicePtr
-virMediatedDeviceListSteal(virMediatedDeviceListPtr list,
- virMediatedDevicePtr dev);
+virMediatedDevice *
+virMediatedDeviceListSteal(virMediatedDeviceList *list,
+ virMediatedDevice *dev);
-virMediatedDevicePtr
-virMediatedDeviceListStealIndex(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListStealIndex(virMediatedDeviceList *list,
ssize_t idx);
void
-virMediatedDeviceListDel(virMediatedDeviceListPtr list,
- virMediatedDevicePtr dev);
+virMediatedDeviceListDel(virMediatedDeviceList *list,
+ virMediatedDevice *dev);
-virMediatedDevicePtr
-virMediatedDeviceListFind(virMediatedDeviceListPtr list,
+virMediatedDevice *
+virMediatedDeviceListFind(virMediatedDeviceList *list,
const char *sysfspath);
int
-virMediatedDeviceListFindIndex(virMediatedDeviceListPtr list,
+virMediatedDeviceListFindIndex(virMediatedDeviceList *list,
const char *sysfspath);
int
-virMediatedDeviceListMarkDevices(virMediatedDeviceListPtr dst,
- virMediatedDeviceListPtr src,
+virMediatedDeviceListMarkDevices(virMediatedDeviceList *dst,
+ virMediatedDeviceList *src,
const char *drvname,
const char *domname);
void
-virMediatedDeviceTypeFree(virMediatedDeviceTypePtr type);
+virMediatedDeviceTypeFree(virMediatedDeviceType *type);
int
virMediatedDeviceTypeReadAttrs(const char *sysfspath,
- virMediatedDeviceTypePtr *type);
+ virMediatedDeviceType **type);
ssize_t
virMediatedDeviceGetMdevTypes(const char *sysfspath,
- virMediatedDeviceTypePtr **types,
+ virMediatedDeviceType ***types,
size_t *ntypes);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virMediatedDevice, virMediatedDeviceFree);
} virMCastType;
typedef struct _virNetDevMcastEntry virNetDevMcastEntry;
-typedef virNetDevMcastEntry *virNetDevMcastEntryPtr;
struct _virNetDevMcastEntry {
int idx;
char name[VIR_MCAST_NAME_LEN];
};
static void
-virNetDevMcastEntryFree(virNetDevMcastEntryPtr entry)
+virNetDevMcastEntryFree(virNetDevMcastEntry *entry)
{
g_free(entry);
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetDevMcastEntry, virNetDevMcastEntryFree);
typedef struct _virNetDevMcastList virNetDevMcastList;
-typedef virNetDevMcastList *virNetDevMcastListPtr;
struct _virNetDevMcastList {
size_t nentries;
- virNetDevMcastEntryPtr *entries;
+ virNetDevMcastEntry **entries;
};
#if defined(WITH_STRUCT_IFREQ)
* Returns 0 in case of success or -1 on failure
*/
int virNetDevGetMAC(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
{
struct ifreq ifr;
VIR_AUTOCLOSE fd = -1;
}
#else
int virNetDevGetMAC(const char *ifname,
- virMacAddrPtr macaddr G_GNUC_UNUSED)
+ virMacAddr *macaddr G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS,
_("Cannot get interface MAC on '%s'"),
}
-static virPCIDevicePtr
+static virPCIDevice *
virNetDevGetPCIDevice(const char *devName)
{
g_autofree char *vfSysfsDevicePath = NULL;
int
virNetDevGetVirtualFunctions(const char *pfname,
char ***vfname,
- virPCIDeviceAddressPtr **virt_fns,
+ virPCIDeviceAddress ***virt_fns,
size_t *n_vfname,
unsigned int *max_vfs)
{
int
virNetDevGetVirtualFunctions(const char *pfname G_GNUC_UNUSED,
char ***vfname G_GNUC_UNUSED,
- virPCIDeviceAddressPtr **virt_fns G_GNUC_UNUSED,
+ virPCIDeviceAddress ***virt_fns G_GNUC_UNUSED,
size_t *n_vfname G_GNUC_UNUSED,
unsigned int *max_vfs G_GNUC_UNUSED)
{
* data is better than add a new function.
*/
static int
-virNetDevParseVfInfo(struct nlattr **tb, int32_t vf, virMacAddrPtr mac,
+virNetDevParseVfInfo(struct nlattr **tb, int32_t vf, virMacAddr *mac,
int *vlanid, virDomainInterfaceStatsPtr stats)
{
int rc = -1;
}
static int
-virNetDevGetVfConfig(const char *ifname, int vf, virMacAddrPtr mac,
+virNetDevGetVfConfig(const char *ifname, int vf, virMacAddr *mac,
int *vlanid)
{
g_autofree void *nlData = NULL;
* Returns 0 on success, -1 on failure.
*/
int
-virNetDevVFInterfaceStats(virPCIDeviceAddressPtr vfAddr,
+virNetDevVFInterfaceStats(virPCIDeviceAddress *vfAddr,
virDomainInterfaceStatsPtr stats)
{
g_autofree void *nlData = NULL;
int
virNetDevReadNetConfig(const char *linkdev, int vf,
const char *stateDir,
- virMacAddrPtr *adminMAC,
- virNetDevVlanPtr *vlan,
- virMacAddrPtr *MAC)
+ virMacAddr **adminMAC,
+ virNetDevVlan **vlan,
+ virMacAddr **MAC)
{
int ret = -1;
const char *pfDevName = NULL;
virNetDevReadNetConfig(const char *linkdev G_GNUC_UNUSED,
int vf G_GNUC_UNUSED,
const char *stateDir G_GNUC_UNUSED,
- virMacAddrPtr *adminMAC G_GNUC_UNUSED,
- virNetDevVlanPtr *vlan G_GNUC_UNUSED,
- virMacAddrPtr *MAC G_GNUC_UNUSED)
+ virMacAddr **adminMAC G_GNUC_UNUSED,
+ virNetDevVlan **vlan G_GNUC_UNUSED,
+ virMacAddr **MAC G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Unable to read net device config on this platform"));
int
-virNetDevVFInterfaceStats(virPCIDeviceAddressPtr vfAddr G_GNUC_UNUSED,
+virNetDevVFInterfaceStats(virPCIDeviceAddress *vfAddr G_GNUC_UNUSED,
virDomainInterfaceStatsPtr stats G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
#ifdef __linux__
int
virNetDevGetLinkInfo(const char *ifname,
- virNetDevIfLinkPtr lnk)
+ virNetDevIfLink *lnk)
{
g_autofree char *path = NULL;
g_autofree char *buf = NULL;
int
virNetDevGetLinkInfo(const char *ifname,
- virNetDevIfLinkPtr lnk)
+ virNetDevIfLink *lnk)
{
/* Port me */
VIR_DEBUG("Getting link info on %s is not implemented on this platform",
* Returns 0 in case of success or -1 on failure
*/
int virNetDevAddMulti(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
{
struct ifreq ifr;
VIR_AUTOCLOSE fd = -1;
}
#else
int virNetDevAddMulti(const char *ifname G_GNUC_UNUSED,
- virMacAddrPtr macaddr G_GNUC_UNUSED)
+ virMacAddr *macaddr G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Unable to add address to interface "
* Returns 0 in case of success or -1 on failure
*/
int virNetDevDelMulti(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
{
struct ifreq ifr;
VIR_AUTOCLOSE fd = -1;
}
#else
int virNetDevDelMulti(const char *ifname G_GNUC_UNUSED,
- virMacAddrPtr macaddr G_GNUC_UNUSED)
+ virMacAddr *macaddr G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
_("Unable to delete address from interface "
}
#endif
-static int virNetDevParseMcast(char *buf, virNetDevMcastEntryPtr mcast)
+static int virNetDevParseMcast(char *buf, virNetDevMcastEntry *mcast)
{
int ifindex;
int num;
}
-static void virNetDevMcastListClear(virNetDevMcastListPtr mcast)
+static void virNetDevMcastListClear(virNetDevMcastList *mcast)
{
size_t i;
static int virNetDevGetMcastList(const char *ifname,
- virNetDevMcastListPtr mcast)
+ virNetDevMcastList *mcast)
{
char *cur = NULL;
g_autofree char *buf = NULL;
static int virNetDevGetMulticastTable(const char *ifname,
- virNetDevRxFilterPtr filter)
+ virNetDevRxFilter *filter)
{
size_t i;
int ret = -1;
}
-virNetDevRxFilterPtr
+virNetDevRxFilter *
virNetDevRxFilterNew(void)
{
- virNetDevRxFilterPtr filter;
+ virNetDevRxFilter *filter;
filter = g_new0(virNetDevRxFilter, 1);
return filter;
void
-virNetDevRxFilterFree(virNetDevRxFilterPtr filter)
+virNetDevRxFilterFree(virNetDevRxFilter *filter)
{
if (filter) {
g_free(filter->name);
* Returns 0 or -1 on failure.
*/
int virNetDevGetRxFilter(const char *ifname,
- virNetDevRxFilterPtr *filter)
+ virNetDevRxFilter **filter)
{
int ret = -1;
bool receive = false;
- virNetDevRxFilterPtr fil = virNetDevRxFilterNew();
+ virNetDevRxFilter *fil = virNetDevRxFilterNew();
if (!fil)
goto cleanup;
*/
static int
virNetDevRDMAFeature(const char *ifname,
- virBitmapPtr *out)
+ virBitmap **out)
{
g_autofree char *eth_devpath = NULL;
g_autofree char *eth_res_buf = NULL;
static void
virNetDevGetEthtoolFeatures(const char *ifname,
- virBitmapPtr bitmap,
+ virBitmap *bitmap,
int fd,
struct ifreq *ifr)
{
*/
static int
virNetDevSwitchdevFeature(const char *ifname,
- virBitmapPtr *out)
+ virBitmap **out)
{
struct nl_msg *nl_msg = NULL;
g_autofree struct nlmsghdr *resp = NULL;
# else
static int
virNetDevSwitchdevFeature(const char *ifname G_GNUC_UNUSED,
- virBitmapPtr *out G_GNUC_UNUSED)
+ virBitmap **out G_GNUC_UNUSED)
{
return 0;
}
static int
virNetDevGetEthtoolGFeatures(const char *ifname,
- virBitmapPtr bitmap,
+ virBitmap *bitmap,
int fd,
struct ifreq *ifr)
{
# else
static int
virNetDevGetEthtoolGFeatures(const char *ifname G_GNUC_UNUSED,
- virBitmapPtr bitmap G_GNUC_UNUSED,
+ virBitmap *bitmap G_GNUC_UNUSED,
int fd G_GNUC_UNUSED,
struct ifreq *ifr G_GNUC_UNUSED)
{
* Returns 0 in case of success or -1 on failure
*/
int virNetDevSetCoalesce(const char *ifname,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
bool update)
{
struct ifreq ifr;
}
# else
int virNetDevSetCoalesce(const char *ifname,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
bool update)
{
if (!coalesce && !update)
*/
int
virNetDevGetFeatures(const char *ifname,
- virBitmapPtr *out)
+ virBitmap **out)
{
struct ifreq ifr;
VIR_AUTOCLOSE fd = -1;
#else
int
virNetDevGetFeatures(const char *ifname G_GNUC_UNUSED,
- virBitmapPtr *out G_GNUC_UNUSED)
+ virBitmap **out G_GNUC_UNUSED)
{
VIR_DEBUG("Getting network device features on %s is not implemented on this platform",
ifname);
}
int virNetDevSetCoalesce(const char *ifname,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
bool update)
{
if (!coalesce && !update)
VIR_ENUM_DECL(virNetDevRxFilterMode);
typedef struct _virNetDevRxFilter virNetDevRxFilter;
-typedef virNetDevRxFilter *virNetDevRxFilterPtr;
struct _virNetDevRxFilter {
char *name; /* the alias used by qemu, *not* name used by guest */
virMacAddr mac;
struct {
int mode; /* enum virNetDevRxFilterMode */
bool overflow;
- virMacAddrPtr table;
+ virMacAddr *table;
size_t nTable;
} unicast;
struct {
int mode; /* enum virNetDevRxFilterMode */
bool overflow;
- virMacAddrPtr table;
+ virMacAddr *table;
size_t nTable;
} multicast;
struct {
VIR_ENUM_DECL(virNetDevIfState);
typedef struct _virNetDevIfLink virNetDevIfLink;
-typedef virNetDevIfLink *virNetDevIfLinkPtr;
struct _virNetDevIfLink {
virNetDevIfState state; /* link state */
unsigned int speed; /* link speed in Mbits per second */
/* Modeled after struct ethtool_coalesce, see linux/ethtool.h for explanations
* of particular fields */
typedef struct _virNetDevCoalesce virNetDevCoalesce;
-typedef virNetDevCoalesce *virNetDevCoalescePtr;
struct _virNetDevCoalesce {
uint32_t rx_coalesce_usecs;
uint32_t rx_max_coalesced_frames;
} virNetDevGenNameType;
typedef struct _virNetDevGenName virNetDevGenName;
-typedef virNetDevGenName *virNetDevGenNamePtr;
struct _virNetDevGenName {
int lastID; /* not "unsigned" because callers use %d */
const char *prefix;
const virMacAddr *macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT G_GNUC_NO_INLINE;
int virNetDevGetMAC(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevReplaceMacAddress(const char *linkdev,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevSetCoalesce(const char *ifname,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
bool update)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevGetVirtualFunctions(const char *pfname,
char ***vfname,
- virPCIDeviceAddressPtr **virt_fns,
+ virPCIDeviceAddress ***virt_fns,
size_t *n_vfname,
unsigned int *max_vfs)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
int
virNetDevReadNetConfig(const char *linkdev, int vf,
const char *stateDir,
- virMacAddrPtr *adminMAC,
- virNetDevVlanPtr *vlan,
- virMacAddrPtr *MAC)
+ virMacAddr **adminMAC,
+ virNetDevVlan **vlan,
+ virMacAddr **MAC)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6) G_GNUC_WARN_UNUSED_RESULT;
ATTRIBUTE_NONNULL(1);
int virNetDevGetFeatures(const char *ifname,
- virBitmapPtr *out)
+ virBitmap **out)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevGetLinkInfo(const char *ifname,
- virNetDevIfLinkPtr lnk)
+ virNetDevIfLink *lnk)
ATTRIBUTE_NONNULL(1);
-virNetDevRxFilterPtr virNetDevRxFilterNew(void)
+virNetDevRxFilter *virNetDevRxFilterNew(void)
G_GNUC_WARN_UNUSED_RESULT;
-void virNetDevRxFilterFree(virNetDevRxFilterPtr filter);
+void virNetDevRxFilterFree(virNetDevRxFilter *filter);
int virNetDevGetRxFilter(const char *ifname,
- virNetDevRxFilterPtr *filter)
+ virNetDevRxFilter **filter)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevAddMulti(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevDelMulti(const char *ifname,
- virMacAddrPtr macaddr)
+ virMacAddr *macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int virNetDevSetPromiscuous(const char *ifname, bool promiscuous)
const char *qdisc)
G_GNUC_NO_INLINE;
-int virNetDevVFInterfaceStats(virPCIDeviceAddressPtr vfAddr,
+int virNetDevVFInterfaceStats(virPCIDeviceAddress *vfAddr,
virDomainInterfaceStatsPtr stats)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
#define VIR_FROM_THIS VIR_FROM_NONE
void
-virNetDevBandwidthFree(virNetDevBandwidthPtr def)
+virNetDevBandwidthFree(virNetDevBandwidth *def)
{
if (!def)
return;
}
static void
-virNetDevBandwidthCmdAddOptimalQuantum(virCommandPtr cmd,
+virNetDevBandwidthCmdAddOptimalQuantum(virCommand *cmd,
const virNetDevBandwidthRate *rate)
{
const unsigned long long mtu = 1500;
{
int ret = -1;
char *filter_id = NULL;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
unsigned char ifmac[VIR_MAC_BUFLEN];
char *mac[2] = {NULL, NULL};
bool swapped)
{
int ret = -1;
- virNetDevBandwidthRatePtr rx = NULL; /* From domain POV */
- virNetDevBandwidthRatePtr tx = NULL; /* From domain POV */
- virCommandPtr cmd = NULL;
+ virNetDevBandwidthRate *rx = NULL; /* From domain POV */
+ virNetDevBandwidthRate *tx = NULL; /* From domain POV */
+ virCommand *cmd = NULL;
char *average = NULL;
char *peak = NULL;
char *burst = NULL;
{
int ret = 0;
int dummy; /* for ignoring the exit status */
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
if (!ifname)
return 0;
* 0 otherwise.
*/
int
-virNetDevBandwidthCopy(virNetDevBandwidthPtr *dest,
+virNetDevBandwidthCopy(virNetDevBandwidth **dest,
const virNetDevBandwidth *src)
{
*dest = NULL;
*/
int
virNetDevBandwidthPlug(const char *brname,
- virNetDevBandwidthPtr net_bandwidth,
+ virNetDevBandwidth *net_bandwidth,
const virMacAddr *ifmac_ptr,
- virNetDevBandwidthPtr bandwidth,
+ virNetDevBandwidth *bandwidth,
unsigned int id)
{
int ret = -1;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char *class_id = NULL;
char *qdisc_id = NULL;
char *floor = NULL;
{
int ret = -1;
int cmd_ret = 0;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char *class_id = NULL;
char *qdisc_id = NULL;
int
virNetDevBandwidthUpdateRate(const char *ifname,
unsigned int id,
- virNetDevBandwidthPtr bandwidth,
+ virNetDevBandwidth *bandwidth,
unsigned long long new_rate)
{
int ret = -1;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char *class_id = NULL;
char *rate = NULL;
char *ceil = NULL;
#include "virmacaddr.h"
typedef struct _virNetDevBandwidthRate virNetDevBandwidthRate;
-typedef virNetDevBandwidthRate *virNetDevBandwidthRatePtr;
struct _virNetDevBandwidthRate {
unsigned long long average; /* kbytes/s */
unsigned long long peak; /* kbytes/s */
};
typedef struct _virNetDevBandwidth virNetDevBandwidth;
-typedef virNetDevBandwidth *virNetDevBandwidthPtr;
struct _virNetDevBandwidth {
- virNetDevBandwidthRatePtr in;
- virNetDevBandwidthRatePtr out;
+ virNetDevBandwidthRate *in;
+ virNetDevBandwidthRate *out;
};
-void virNetDevBandwidthFree(virNetDevBandwidthPtr def);
+void virNetDevBandwidthFree(virNetDevBandwidth *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetDevBandwidth, virNetDevBandwidthFree);
bool swapped)
G_GNUC_WARN_UNUSED_RESULT;
int virNetDevBandwidthClear(const char *ifname);
-int virNetDevBandwidthCopy(virNetDevBandwidthPtr *dest,
+int virNetDevBandwidthCopy(virNetDevBandwidth **dest,
const virNetDevBandwidth *src)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
bool virNetDevBandwidthEqual(const virNetDevBandwidth *a, const virNetDevBandwidth *b);
int virNetDevBandwidthPlug(const char *brname,
- virNetDevBandwidthPtr net_bandwidth,
+ virNetDevBandwidth *net_bandwidth,
const virMacAddr *ifmac_ptr,
- virNetDevBandwidthPtr bandwidth,
+ virNetDevBandwidth *bandwidth,
unsigned int id)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
G_GNUC_WARN_UNUSED_RESULT;
int virNetDevBandwidthUpdateRate(const char *ifname,
unsigned int id,
- virNetDevBandwidthPtr bandwidth,
+ virNetDevBandwidth *bandwidth,
unsigned long long new_rate)
ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT;
*/
int
virNetDevIPRouteAdd(const char *ifname,
- virSocketAddrPtr addr,
+ virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr gateway,
+ virSocketAddr *gateway,
unsigned int metric)
{
unsigned int recvbuflen;
size_t addrDataLen;
int errCode;
virSocketAddr defaultAddr;
- virSocketAddrPtr actualAddr;
+ virSocketAddr *actualAddr;
g_autoptr(virNetlinkMsg) nlmsg = NULL;
g_autofree char *toStr = NULL;
g_autofree char *viaStr = NULL;
int
virNetDevIPRouteAdd(const char *ifname,
- virSocketAddrPtr addr,
+ virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr gateway,
+ virSocketAddr *gateway,
unsigned int metric)
{
g_autoptr(virCommand) cmd = NULL;
#if defined(SIOCGIFADDR) && defined(WITH_STRUCT_IFREQ)
static int
virNetDevGetIPv4AddressIoctl(const char *ifname,
- virSocketAddrPtr addr)
+ virSocketAddr *addr)
{
int fd = -1;
int ret = -1;
static int
virNetDevGetIPv4AddressIoctl(const char *ifname G_GNUC_UNUSED,
- virSocketAddrPtr addr G_GNUC_UNUSED)
+ virSocketAddr *addr G_GNUC_UNUSED)
{
return -2;
}
#if WITH_GETIFADDRS
static int
virNetDevGetifaddrsAddress(const char *ifname,
- virSocketAddrPtr addr)
+ virSocketAddr *addr)
{
struct ifaddrs *ifap, *ifa;
int ret = -1;
static int
virNetDevGetifaddrsAddress(const char *ifname G_GNUC_UNUSED,
- virSocketAddrPtr addr G_GNUC_UNUSED)
+ virSocketAddr *addr G_GNUC_UNUSED)
{
return -2;
}
*/
int
virNetDevIPAddrGet(const char *ifname,
- virSocketAddrPtr addr)
+ virSocketAddr *addr)
{
int ret;
/* manipulating the virNetDevIPRoute object */
void
-virNetDevIPRouteFree(virNetDevIPRoutePtr def)
+virNetDevIPRouteFree(virNetDevIPRoute *def)
{
if (!def)
return;
g_free(def);
}
-virSocketAddrPtr
-virNetDevIPRouteGetAddress(virNetDevIPRoutePtr def)
+virSocketAddr *
+virNetDevIPRouteGetAddress(virNetDevIPRoute *def)
{
if (def)
return &def->address;
}
int
-virNetDevIPRouteGetPrefix(virNetDevIPRoutePtr def)
+virNetDevIPRouteGetPrefix(virNetDevIPRoute *def)
{
int prefix = 0;
virSocketAddr zero;
}
unsigned int
-virNetDevIPRouteGetMetric(virNetDevIPRoutePtr def)
+virNetDevIPRouteGetMetric(virNetDevIPRoute *def)
{
if (def && def->has_metric && def->metric > 0)
return def->metric;
return 1;
}
-virSocketAddrPtr
-virNetDevIPRouteGetGateway(virNetDevIPRoutePtr def)
+virSocketAddr *
+virNetDevIPRouteGetGateway(virNetDevIPRoute *def)
{
if (def)
return &def->gateway;
/* manipulating the virNetDevIPInfo object */
void
-virNetDevIPInfoClear(virNetDevIPInfoPtr ip)
+virNetDevIPInfoClear(virNetDevIPInfo *ip)
{
size_t i;
/* add all IP addresses */
for (i = 0; i < ipInfo->nips; i++) {
- virNetDevIPAddrPtr ip = ipInfo->ips[i];
+ virNetDevIPAddr *ip = ipInfo->ips[i];
if ((prefix = virSocketAddrGetIPPrefix(&ip->address,
NULL, ip->prefix)) < 0) {
/* add all routes */
for (i = 0; i < ipInfo->nroutes; i++) {
- virNetDevIPRoutePtr route = ipInfo->routes[i];
+ virNetDevIPRoute *route = ipInfo->routes[i];
if ((prefix = virNetDevIPRouteGetPrefix(route)) < 0) {
ipStr = virSocketAddrFormat(&route->address);
}
void
-virNetDevIPAddrFree(virNetDevIPAddrPtr ip)
+virNetDevIPAddrFree(virNetDevIPAddr *ip)
{
g_free(ip);
}
#include "virsocketaddr.h"
typedef struct _virNetDevIPAddr virNetDevIPAddr;
-typedef virNetDevIPAddr *virNetDevIPAddrPtr;
struct _virNetDevIPAddr {
virSocketAddr address; /* ipv4 or ipv6 address */
virSocketAddr peer; /* ipv4 or ipv6 address of peer */
};
typedef struct _virNetDevIPRoute virNetDevIPRoute;
-typedef virNetDevIPRoute *virNetDevIPRoutePtr;
struct _virNetDevIPRoute {
char *family; /* ipv4 or ipv6 - default is ipv4 */
virSocketAddr address; /* Routed Network IP address */
/* A full set of all IP config info for a network device */
typedef struct _virNetDevIPInfo virNetDevIPInfo;
-typedef virNetDevIPInfo *virNetDevIPInfoPtr;
struct _virNetDevIPInfo {
size_t nips;
- virNetDevIPAddrPtr *ips;
+ virNetDevIPAddr **ips;
size_t nroutes;
- virNetDevIPRoutePtr *routes;
+ virNetDevIPRoute **routes;
};
/* manipulating/querying the netdev */
unsigned int prefix)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT G_GNUC_NO_INLINE;
int virNetDevIPRouteAdd(const char *ifname,
- virSocketAddrPtr addr,
+ virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr gateway,
+ virSocketAddr *gateway,
unsigned int metric)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4)
G_GNUC_WARN_UNUSED_RESULT;
virSocketAddr *addr,
unsigned int prefix)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virNetDevIPAddrGet(const char *ifname, virSocketAddrPtr addr)
+int virNetDevIPAddrGet(const char *ifname, virSocketAddr *addr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
bool virNetDevIPCheckIPv6Forwarding(void);
-void virNetDevIPAddrFree(virNetDevIPAddrPtr ip);
+void virNetDevIPAddrFree(virNetDevIPAddr *ip);
/* virNetDevIPRoute object */
-void virNetDevIPRouteFree(virNetDevIPRoutePtr def);
-virSocketAddrPtr virNetDevIPRouteGetAddress(virNetDevIPRoutePtr def);
-int virNetDevIPRouteGetPrefix(virNetDevIPRoutePtr def);
-unsigned int virNetDevIPRouteGetMetric(virNetDevIPRoutePtr def);
-virSocketAddrPtr virNetDevIPRouteGetGateway(virNetDevIPRoutePtr def);
+void virNetDevIPRouteFree(virNetDevIPRoute *def);
+virSocketAddr *virNetDevIPRouteGetAddress(virNetDevIPRoute *def);
+int virNetDevIPRouteGetPrefix(virNetDevIPRoute *def);
+unsigned int virNetDevIPRouteGetMetric(virNetDevIPRoute *def);
+virSocketAddr *virNetDevIPRouteGetGateway(virNetDevIPRoute *def);
/* virNetDevIPInfo object */
-void virNetDevIPInfoClear(virNetDevIPInfoPtr ip);
+void virNetDevIPInfoClear(virNetDevIPInfo *ip);
int virNetDevIPInfoAddToDev(const char *ifname,
virNetDevIPInfo const *ipInfo);
/* Struct to hold the state and configuration of a 802.1qbg port */
struct virNetlinkCallbackData {
char *cr_ifname;
- virNetDevVPortProfilePtr virtPortProfile;
+ virNetDevVPortProfile *virtPortProfile;
virMacAddr macaddress;
char *linkdev;
int vf;
unsigned int linkState;
};
-typedef struct virNetlinkCallbackData *virNetlinkCallbackDataPtr;
-
# define INSTANCE_STRLEN 36
static int instance2str(const unsigned char *p, char *dst, size_t size)
int rem;
char *ifname;
bool indicate = false;
- virNetlinkCallbackDataPtr calld = opaque;
+ struct virNetlinkCallbackData *calld = opaque;
pid_t lldpad_pid = 0;
pid_t virip_pid = 0;
char macaddr[VIR_MAC_STRING_BUFLEN];
* Returns nothing.
*/
static void
-virNetlinkCallbackDataFree(virNetlinkCallbackDataPtr calld)
+virNetlinkCallbackDataFree(struct virNetlinkCallbackData *calld)
{
if (calld) {
g_free(calld->cr_ifname);
const virMacAddr *macaddr G_GNUC_UNUSED,
void *opaque)
{
- virNetlinkCallbackDataFree((virNetlinkCallbackDataPtr)opaque);
+ virNetlinkCallbackDataFree((struct virNetlinkCallbackData *)opaque);
}
int
const virNetDevVPortProfile *virtPortProfile,
virNetDevVPortProfileOp vmOp)
{
- virNetlinkCallbackDataPtr calld = NULL;
+ struct virNetlinkCallbackData *calld = NULL;
if (virtPortProfile && virNetlinkEventServiceIsRunning(NETLINK_ROUTE)) {
calld = g_new0(struct virNetlinkCallbackData, 1);
const virNetDevVPortProfile *virtualport)
{
int ret = -1;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char virtportuuid[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(virtualport->interfaceID, virtportuuid);
virNetDevMidonetUnbindPort(const virNetDevVPortProfile *virtualport)
{
int ret = -1;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char virtportuuid[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(virtualport->interfaceID, virtportuuid);
virNetDevOpenvswitchTimeout = timeout;
}
-static virCommandPtr
+static virCommand *
virNetDevOpenvswitchCreateCmd(void)
{
- virCommandPtr cmd = virCommandNew(OVS_VSCTL);
+ virCommand *cmd = virCommandNew(OVS_VSCTL);
virCommandAddArgFormat(cmd, "--timeout=%u", virNetDevOpenvswitchTimeout);
return cmd;
}
* ovs-vsctl command.
*/
static void
-virNetDevOpenvswitchConstructVlans(virCommandPtr cmd, const virNetDevVlan *virtVlan)
+virNetDevOpenvswitchConstructVlans(virCommand *cmd, const virNetDevVlan *virtVlan)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virDomainInterfaceStatsPtr stats)
{
g_autoptr(virJSONValue) jsonStats = NULL;
- virJSONValuePtr jsonMap = NULL;
+ virJSONValue *jsonMap = NULL;
size_t i;
stats->rx_bytes = stats->rx_packets = stats->rx_errs = stats->rx_drop = -1;
}
for (i = 0; i < virJSONValueArraySize(jsonMap); i++) {
- virJSONValuePtr item = virJSONValueArrayGet(jsonMap, i);
- virJSONValuePtr jsonKey;
- virJSONValuePtr jsonVal;
+ virJSONValue *item = virJSONValueArrayGet(jsonMap, i);
+ virJSONValue *jsonKey;
+ virJSONValue *jsonVal;
const char *key;
long long val;
const virNetDevVPortProfile *virtPortProfile,
const virNetDevVlan *virtVlan,
virTristateBool isolatedPort,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
unsigned int mtu,
unsigned int *actualMTU,
unsigned int flags)
const virNetDevVPortProfile *virtPortProfile,
const virNetDevVlan *virtVlan,
virTristateBool isolatedPort,
- virNetDevCoalescePtr coalesce,
+ virNetDevCoalesce *coalesce,
unsigned int mtu,
unsigned int *actualMTU,
unsigned int flags)
#define VIR_FROM_THIS VIR_FROM_NONE
void
-virNetDevVlanClear(virNetDevVlanPtr vlan)
+virNetDevVlanClear(virNetDevVlan *vlan)
{
VIR_FREE(vlan->tag);
vlan->nTags = 0;
}
void
-virNetDevVlanFree(virNetDevVlanPtr vlan)
+virNetDevVlanFree(virNetDevVlan *vlan)
{
if (vlan)
virNetDevVlanClear(vlan);
* dst is assumed to be empty on entry.
*/
int
-virNetDevVlanCopy(virNetDevVlanPtr dst, const virNetDevVlan *src)
+virNetDevVlanCopy(virNetDevVlan *dst, const virNetDevVlan *src)
{
if (!src || src->nTags == 0)
return 0;
VIR_ENUM_DECL(virNativeVlanMode);
typedef struct _virNetDevVlan virNetDevVlan;
-typedef virNetDevVlan *virNetDevVlanPtr;
struct _virNetDevVlan {
bool trunk; /* true if this is a trunk */
int nTags; /* number of tags in array */
unsigned int nativeTag;
};
-void virNetDevVlanClear(virNetDevVlanPtr vlan);
-void virNetDevVlanFree(virNetDevVlanPtr vlan);
+void virNetDevVlanClear(virNetDevVlan *vlan);
+void virNetDevVlanFree(virNetDevVlan *vlan);
int virNetDevVlanEqual(const virNetDevVlan *a, const virNetDevVlan *b);
-int virNetDevVlanCopy(virNetDevVlanPtr dst, const virNetDevVlan *src);
+int virNetDevVlanCopy(virNetDevVlan *dst, const virNetDevVlan *src);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetDevVlan, virNetDevVlanFree);
}
-int virNetDevVPortProfileCopy(virNetDevVPortProfilePtr *dst, const virNetDevVPortProfile *src)
+int virNetDevVPortProfileCopy(virNetDevVPortProfile **dst, const virNetDevVPortProfile *src)
{
if (!src) {
*dst = NULL;
* and -1 is returned.
*/
int
-virNetDevVPortProfileCheckComplete(virNetDevVPortProfilePtr virtport,
+virNetDevVPortProfileCheckComplete(virNetDevVPortProfile *virtport,
bool generateMissing)
{
const char *missing = NULL;
* *and doesn't match*, log an error and return -1, otherwise return 0.
*/
static int
-virNetDevVPortProfileMerge(virNetDevVPortProfilePtr orig,
+virNetDevVPortProfileMerge(virNetDevVPortProfile *orig,
const virNetDevVPortProfile *mods)
{
enum virNetDevVPortProfile otype;
* change it, that is an error.
*/
-int virNetDevVPortProfileMerge3(virNetDevVPortProfilePtr *result,
+int virNetDevVPortProfileMerge3(virNetDevVPortProfile **result,
const virNetDevVPortProfile *fromInterface,
const virNetDevVPortProfile *fromNetwork,
const virNetDevVPortProfile *fromPortgroup)
/* profile data for macvtap (VEPA) and openvswitch */
typedef struct _virNetDevVPortProfile virNetDevVPortProfile;
-typedef virNetDevVPortProfile *virNetDevVPortProfilePtr;
struct _virNetDevVPortProfile {
int virtPortType; /* enum virNetDevVPortProfile */
/* these members are used when virtPortType == 802.1Qbg */
bool virNetDevVPortProfileEqual(const virNetDevVPortProfile *a,
const virNetDevVPortProfile *b);
-int virNetDevVPortProfileCopy(virNetDevVPortProfilePtr *dst,
+int virNetDevVPortProfileCopy(virNetDevVPortProfile **dst,
const virNetDevVPortProfile *src);
-int virNetDevVPortProfileCheckComplete(virNetDevVPortProfilePtr virtport,
+int virNetDevVPortProfileCheckComplete(virNetDevVPortProfile *virtport,
bool generateMissing);
int virNetDevVPortProfileCheckNoExtras(const virNetDevVPortProfile *virtport);
-int virNetDevVPortProfileMerge3(virNetDevVPortProfilePtr *result,
+int virNetDevVPortProfileMerge3(virNetDevVPortProfile **result,
const virNetDevVPortProfile *fromInterface,
const virNetDevVPortProfile *fromNetwork,
const virNetDevVPortProfile *fromPortgroup);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetlinkHandle, virNetlinkFree);
typedef struct _virNetlinkEventSrvPrivate virNetlinkEventSrvPrivate;
-typedef virNetlinkEventSrvPrivate *virNetlinkEventSrvPrivatePtr;
struct _virNetlinkEventSrvPrivate {
/* Server */
virMutex lock;
/* Linux kernel supports up to MAX_LINKS (32 at the time) individual
* netlink protocols. */
-static virNetlinkEventSrvPrivatePtr server[MAX_LINKS] = {NULL};
+static virNetlinkEventSrvPrivate *server[MAX_LINKS] = {NULL};
static virNetlinkHandle *placeholder_nlhandle;
/* Function definitions */
int
virNetlinkNewLink(const char *ifname,
const char *type,
- virNetlinkNewLinkDataPtr extra_args,
+ virNetlinkNewLinkData *extra_args,
int *error)
{
struct nlattr *linkinfo = NULL;
static void
-virNetlinkEventServerLock(virNetlinkEventSrvPrivatePtr driver)
+virNetlinkEventServerLock(virNetlinkEventSrvPrivate *driver)
{
virMutexLock(&driver->lock);
}
static void
-virNetlinkEventServerUnlock(virNetlinkEventSrvPrivatePtr driver)
+virNetlinkEventServerUnlock(virNetlinkEventSrvPrivate *driver)
{
virMutexUnlock(&driver->lock);
}
int events G_GNUC_UNUSED,
void *opaque)
{
- virNetlinkEventSrvPrivatePtr srv = opaque;
+ virNetlinkEventSrvPrivate *srv = opaque;
struct sockaddr_nl peer;
struct ucred *creds = NULL;
size_t i;
int
virNetlinkEventServiceStop(unsigned int protocol)
{
- virNetlinkEventSrvPrivatePtr srv;
+ virNetlinkEventSrvPrivate *srv;
size_t i;
if (protocol >= MAX_LINKS)
int
virNetlinkEventServiceStart(unsigned int protocol, unsigned int groups)
{
- virNetlinkEventSrvPrivatePtr srv;
+ virNetlinkEventSrvPrivate *srv;
int fd;
int ret = -1;
{
size_t i;
int r, ret = -1;
- virNetlinkEventSrvPrivatePtr srv = NULL;
+ virNetlinkEventSrvPrivate *srv = NULL;
if (protocol >= MAX_LINKS)
return -EINVAL;
{
size_t i;
int ret = -1;
- virNetlinkEventSrvPrivatePtr srv = NULL;
+ virNetlinkEventSrvPrivate *srv = NULL;
if (protocol >= MAX_LINKS)
return -EINVAL;
int
virNetlinkNewLink(const char *ifname G_GNUC_UNUSED,
const char *type G_GNUC_UNUSED,
- virNetlinkNewLinkDataPtr extra_args G_GNUC_UNUSED,
+ virNetlinkNewLinkData *extra_args G_GNUC_UNUSED,
int *error G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported));
void *opaque);
typedef struct _virNetlinkNewLinkData virNetlinkNewLinkData;
-typedef virNetlinkNewLinkData *virNetlinkNewLinkDataPtr;
struct _virNetlinkNewLinkData {
const int *ifindex; /* The index for the 'link' device */
const virMacAddr *mac; /* The MAC address of the device */
int virNetlinkNewLink(const char *ifname,
const char *type,
- virNetlinkNewLinkDataPtr data,
+ virNetlinkNewLinkData *data,
int *error);
typedef int (*virNetlinkTalkFallback)(const char *ifname);
*/
static int virNodeSuspendSetNodeWakeup(unsigned long long alarmTime)
{
- virCommandPtr setAlarmCmd;
+ virCommand *setAlarmCmd;
int ret = -1;
if (alarmTime < MIN_TIME_REQ_FOR_SUSPEND) {
*/
static void virNodeSuspendHelper(void *cmdString)
{
- virCommandPtr suspendCmd = virCommandNew((const char *)cmdString);
+ virCommand *suspendCmd = virCommandNew((const char *)cmdString);
/*
* Delay for sometime so that the function virNodeSuspend()
#if WITH_NUMACTL
int
virNumaSetupMemoryPolicy(virDomainNumatuneMemMode mode,
- virBitmapPtr nodeset)
+ virBitmap *nodeset)
{
nodemask_t mask;
int node = -1;
(((mask)[((cpu) / n_bits(*(mask)))] >> ((cpu) % n_bits(*(mask)))) & 1)
int
virNumaGetNodeCPUs(int node,
- virBitmapPtr *cpus)
+ virBitmap **cpus)
{
int ncpus = 0;
int max_n_cpus = virNumaGetMaxCPUs();
* Returns 0 on success, <0 on failure.
*/
int
-virNumaNodesetToCPUset(virBitmapPtr nodeset,
- virBitmapPtr *cpuset)
+virNumaNodesetToCPUset(virBitmap *nodeset,
+ virBitmap **cpuset)
{
g_autoptr(virBitmap) allNodesCPUs = NULL;
size_t nodesetSize;
int
virNumaSetupMemoryPolicy(virDomainNumatuneMemMode mode G_GNUC_UNUSED,
- virBitmapPtr nodeset)
+ virBitmap *nodeset)
{
if (!virNumaNodesetIsAvailable(nodeset))
return -1;
int
virNumaGetNodeCPUs(int node G_GNUC_UNUSED,
- virBitmapPtr *cpus)
+ virBitmap **cpus)
{
*cpus = NULL;
}
int
-virNumaNodesetToCPUset(virBitmapPtr nodeset G_GNUC_UNUSED,
- virBitmapPtr *cpuset)
+virNumaNodesetToCPUset(virBitmap *nodeset G_GNUC_UNUSED,
+ virBitmap **cpuset)
{
*cpuset = NULL;
#endif /* #ifdef __linux__ */
bool
-virNumaNodesetIsAvailable(virBitmapPtr nodeset)
+virNumaNodesetIsAvailable(virBitmap *nodeset)
{
ssize_t bit = -1;
*
* Returns a bitmap of guest numa node ids that contain memory.
*/
-virBitmapPtr
+virBitmap *
virNumaGetHostMemoryNodeset(void)
{
int maxnode = virNumaGetMaxNode();
unsigned long long nodesize;
size_t i = 0;
- virBitmapPtr nodeset = NULL;
+ virBitmap *nodeset = NULL;
if (maxnode < 0)
return NULL;
unsigned long long balloon);
int virNumaSetupMemoryPolicy(virDomainNumatuneMemMode mode,
- virBitmapPtr nodeset);
+ virBitmap *nodeset);
-virBitmapPtr virNumaGetHostMemoryNodeset(void);
-bool virNumaNodesetIsAvailable(virBitmapPtr nodeset) G_GNUC_NO_INLINE;
+virBitmap *virNumaGetHostMemoryNodeset(void);
+bool virNumaNodesetIsAvailable(virBitmap *nodeset) G_GNUC_NO_INLINE;
bool virNumaIsAvailable(void) G_GNUC_NO_INLINE;
int virNumaGetMaxNode(void) G_GNUC_NO_INLINE;
bool virNumaNodeIsAvailable(int node) G_GNUC_NO_INLINE;
unsigned int virNumaGetMaxCPUs(void);
-int virNumaGetNodeCPUs(int node, virBitmapPtr *cpus) G_GNUC_NO_INLINE;
-int virNumaNodesetToCPUset(virBitmapPtr nodeset,
- virBitmapPtr *cpuset);
+int virNumaGetNodeCPUs(int node, virBitmap **cpus) G_GNUC_NO_INLINE;
+int virNumaNodesetToCPUset(virBitmap *nodeset,
+ virBitmap **cpuset);
int virNumaGetPageInfo(int node,
unsigned int page_size,
virObjectLockable parent;
size_t count;
- virNVMeDevicePtr *devs;
+ virNVMeDevice **devs;
};
-static virClassPtr virNVMeDeviceListClass;
+static virClass *virNVMeDeviceListClass;
static void virNVMeDeviceListDispose(void *obj);
VIR_ONCE_GLOBAL_INIT(virNVMe);
-virNVMeDevicePtr
+virNVMeDevice *
virNVMeDeviceNew(const virPCIDeviceAddress *address,
unsigned long namespace,
bool managed)
{
- virNVMeDevicePtr dev = NULL;
+ virNVMeDevice *dev = NULL;
dev = g_new0(virNVMeDevice, 1);
void
-virNVMeDeviceFree(virNVMeDevicePtr dev)
+virNVMeDeviceFree(virNVMeDevice *dev)
{
if (!dev)
return;
}
-virNVMeDevicePtr
+virNVMeDevice *
virNVMeDeviceCopy(const virNVMeDevice *dev)
{
- virNVMeDevicePtr copy = NULL;
+ virNVMeDevice *copy = NULL;
copy = g_new0(virNVMeDevice, 1);
copy->drvname = g_strdup(dev->drvname);
void
-virNVMeDeviceUsedByClear(virNVMeDevicePtr dev)
+virNVMeDeviceUsedByClear(virNVMeDevice *dev)
{
VIR_FREE(dev->drvname);
VIR_FREE(dev->domname);
void
-virNVMeDeviceUsedBySet(virNVMeDevicePtr dev,
+virNVMeDeviceUsedBySet(virNVMeDevice *dev,
const char *drv,
const char *dom)
{
}
-virNVMeDeviceListPtr
+virNVMeDeviceList *
virNVMeDeviceListNew(void)
{
- virNVMeDeviceListPtr list;
+ virNVMeDeviceList *list;
if (virNVMeInitialize() < 0)
return NULL;
static void
virNVMeDeviceListDispose(void *obj)
{
- virNVMeDeviceListPtr list = obj;
+ virNVMeDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++)
int
-virNVMeDeviceListAdd(virNVMeDeviceListPtr list,
+virNVMeDeviceListAdd(virNVMeDeviceList *list,
const virNVMeDevice *dev)
{
- virNVMeDevicePtr tmp;
+ virNVMeDevice *tmp;
if ((tmp = virNVMeDeviceListLookup(list, dev))) {
g_autofree char *addrStr = virPCIDeviceAddressAsString(&tmp->address);
int
-virNVMeDeviceListDel(virNVMeDeviceListPtr list,
+virNVMeDeviceListDel(virNVMeDeviceList *list,
const virNVMeDevice *dev)
{
ssize_t idx;
- virNVMeDevicePtr tmp = NULL;
+ virNVMeDevice *tmp = NULL;
if ((idx = virNVMeDeviceListLookupIndex(list, dev)) < 0) {
g_autofree char *addrStr = virPCIDeviceAddressAsString(&dev->address);
}
-virNVMeDevicePtr
-virNVMeDeviceListGet(virNVMeDeviceListPtr list,
+virNVMeDevice *
+virNVMeDeviceListGet(virNVMeDeviceList *list,
size_t i)
{
return i < list->count ? list->devs[i] : NULL;
}
-virNVMeDevicePtr
-virNVMeDeviceListLookup(virNVMeDeviceListPtr list,
+virNVMeDevice *
+virNVMeDeviceListLookup(virNVMeDeviceList *list,
const virNVMeDevice *dev)
{
ssize_t idx;
ssize_t
-virNVMeDeviceListLookupIndex(virNVMeDeviceListPtr list,
+virNVMeDeviceListLookupIndex(virNVMeDeviceList *list,
const virNVMeDevice *dev)
{
size_t i;
return -1;
for (i = 0; i < list->count; i++) {
- virNVMeDevicePtr other = list->devs[i];
+ virNVMeDevice *other = list->devs[i];
if (virPCIDeviceAddressEqual(&dev->address, &other->address) &&
dev->namespace == other->namespace)
}
-static virNVMeDevicePtr
-virNVMeDeviceListLookupByPCIAddress(virNVMeDeviceListPtr list,
+static virNVMeDevice *
+virNVMeDeviceListLookupByPCIAddress(virNVMeDeviceList *list,
const virPCIDeviceAddress *address)
{
size_t i;
return NULL;
for (i = 0; i < list->count; i++) {
- virNVMeDevicePtr other = list->devs[i];
+ virNVMeDevice *other = list->devs[i];
if (virPCIDeviceAddressEqual(address, &other->address))
return other;
}
-static virPCIDevicePtr
+static virPCIDevice *
virNVMeDeviceCreatePCIDevice(const virNVMeDevice *nvme)
{
g_autoptr(virPCIDevice) pci = NULL;
* Returns: a list on success,
* NULL otherwise.
*/
-virPCIDeviceListPtr
-virNVMeDeviceListCreateDetachList(virNVMeDeviceListPtr activeList,
- virNVMeDeviceListPtr toDetachList)
+virPCIDeviceList *
+virNVMeDeviceListCreateDetachList(virNVMeDeviceList *activeList,
+ virNVMeDeviceList *toDetachList)
{
g_autoptr(virPCIDeviceList) pciDevices = NULL;
size_t i;
* Returns: a list on success,
* NULL otherwise.
*/
-virPCIDeviceListPtr
-virNVMeDeviceListCreateReAttachList(virNVMeDeviceListPtr activeList,
- virNVMeDeviceListPtr toReAttachList)
+virPCIDeviceList *
+virNVMeDeviceListCreateReAttachList(virNVMeDeviceList *activeList,
+ virNVMeDeviceList *toReAttachList)
{
g_autoptr(virPCIDeviceList) pciDevices = NULL;
size_t i;
* @d. To simplify this, let's just count how many NVMe devices with
* the same PCI address there are on the @activeList. */
for (i = 0; i < activeList->count; i++) {
- virNVMeDevicePtr other = activeList->devs[i];
+ virNVMeDevice *other = activeList->devs[i];
if (!virPCIDeviceAddressEqual(&d->address, &other->address))
continue;
#include "virpci.h"
typedef struct _virNVMeDevice virNVMeDevice;
-typedef virNVMeDevice *virNVMeDevicePtr;
/* Note that this list is lockable, and in fact, it is caller's
* responsibility to acquire the lock and release it. The reason
* API calls and therefore only caller knows when it is safe to
* finally release the lock. */
typedef struct _virNVMeDeviceList virNVMeDeviceList;
-typedef virNVMeDeviceList *virNVMeDeviceListPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNVMeDeviceList, virObjectUnref);
-virNVMeDevicePtr
+virNVMeDevice *
virNVMeDeviceNew(const virPCIDeviceAddress *address,
unsigned long namespace,
bool managed);
void
-virNVMeDeviceFree(virNVMeDevicePtr dev);
+virNVMeDeviceFree(virNVMeDevice *dev);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNVMeDevice, virNVMeDeviceFree);
-virNVMeDevicePtr
+virNVMeDevice *
virNVMeDeviceCopy(const virNVMeDevice *dev);
const virPCIDeviceAddress *
virNVMeDeviceAddressGet(const virNVMeDevice *dev);
void
-virNVMeDeviceUsedByClear(virNVMeDevicePtr dev);
+virNVMeDeviceUsedByClear(virNVMeDevice *dev);
void
virNVMeDeviceUsedByGet(const virNVMeDevice *dev,
const char **dom);
void
-virNVMeDeviceUsedBySet(virNVMeDevicePtr dev,
+virNVMeDeviceUsedBySet(virNVMeDevice *dev,
const char *drv,
const char *dom);
-virNVMeDeviceListPtr
+virNVMeDeviceList *
virNVMeDeviceListNew(void);
size_t
virNVMeDeviceListCount(const virNVMeDeviceList *list);
int
-virNVMeDeviceListAdd(virNVMeDeviceListPtr list,
+virNVMeDeviceListAdd(virNVMeDeviceList *list,
const virNVMeDevice *dev);
int
-virNVMeDeviceListDel(virNVMeDeviceListPtr list,
+virNVMeDeviceListDel(virNVMeDeviceList *list,
const virNVMeDevice *dev);
-virNVMeDevicePtr
-virNVMeDeviceListGet(virNVMeDeviceListPtr list,
+virNVMeDevice *
+virNVMeDeviceListGet(virNVMeDeviceList *list,
size_t i);
-virNVMeDevicePtr
-virNVMeDeviceListLookup(virNVMeDeviceListPtr list,
+virNVMeDevice *
+virNVMeDeviceListLookup(virNVMeDeviceList *list,
const virNVMeDevice *dev);
ssize_t
-virNVMeDeviceListLookupIndex(virNVMeDeviceListPtr list,
+virNVMeDeviceListLookupIndex(virNVMeDeviceList *list,
const virNVMeDevice *dev);
-virPCIDeviceListPtr
-virNVMeDeviceListCreateDetachList(virNVMeDeviceListPtr activeList,
- virNVMeDeviceListPtr toDetachList);
+virPCIDeviceList *
+virNVMeDeviceListCreateDetachList(virNVMeDeviceList *activeList,
+ virNVMeDeviceList *toDetachList);
-virPCIDeviceListPtr
-virNVMeDeviceListCreateReAttachList(virNVMeDeviceListPtr activeList,
- virNVMeDeviceListPtr toReAttachList);
+virPCIDeviceList *
+virNVMeDeviceListCreateReAttachList(virNVMeDeviceList *activeList,
+ virNVMeDeviceList *toReAttachList);
static unsigned int magicCounter = 0xCAFE0000;
struct _virClass {
- virClassPtr parent;
+ virClass *parent;
GType type;
unsigned int magic;
typedef struct _virObjectPrivate virObjectPrivate;
struct _virObjectPrivate {
- virClassPtr klass;
+ virClass *klass;
};
#define VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, objclass) \
do { \
- virObjectPtr obj = anyobj; \
+ virObject *obj = anyobj; \
if (!obj) \
VIR_WARN("Object cannot be NULL"); \
if (VIR_OBJECT_NOTVALID(obj)) \
} while (0)
-static virClassPtr virObjectClassImpl;
-static virClassPtr virObjectLockableClass;
-static virClassPtr virObjectRWLockableClass;
+static virClass *virObjectClassImpl;
+static virClass *virObjectLockableClass;
+static virClass *virObjectRWLockableClass;
static void virObjectLockableDispose(void *anyobj);
static void virObjectRWLockableDispose(void *anyobj);
*
* Returns the class instance for the base virObject type
*/
-virClassPtr
+virClass *
virClassForObject(void)
{
if (virObjectInitialize() < 0)
*
* Returns the class instance for the virObjectLockable type
*/
-virClassPtr
+virClass *
virClassForObjectLockable(void)
{
if (virObjectInitialize() < 0)
*
* Returns the class instance for the virObjectRWLockable type
*/
-virClassPtr
+virClass *
virClassForObjectRWLockable(void)
{
if (virObjectInitialize() < 0)
*
* Returns a new class instance
*/
-virClassPtr
-virClassNew(virClassPtr parent,
+virClass *
+virClassNew(virClass *parent,
const char *name,
size_t objectSize,
size_t parentSize,
virObjectDisposeCallback dispose)
{
- virClassPtr klass;
+ virClass *klass;
if (parent == NULL &&
STRNEQ(name, "virObject")) {
* Return true if @klass is derived from @parent, false otherwise
*/
bool
-virClassIsDerivedFrom(virClassPtr klass,
- virClassPtr parent)
+virClassIsDerivedFrom(virClass *klass,
+ virClass *parent)
{
while (klass) {
if (klass->magic == parent->magic)
* @klass: the klass of object to create
*
* Allocates a new object of type @klass. The returned
- * object will be an instance of "virObjectPtr", which
+ * object will be an instance of "virObject *", which
* can be cast to the struct associated with @klass.
*
* The initial reference count of the object will be 1.
* Returns the new object
*/
void *
-virObjectNew(virClassPtr klass)
+virObjectNew(virClass *klass)
{
- virObjectPtr obj = NULL;
+ virObject *obj = NULL;
virObjectPrivate *priv;
obj = g_object_new(klass->type, NULL);
void *
-virObjectLockableNew(virClassPtr klass)
+virObjectLockableNew(virClass *klass)
{
- virObjectLockablePtr obj;
+ virObjectLockable *obj;
if (!virClassIsDerivedFrom(klass, virClassForObjectLockable())) {
virReportInvalidArg(klass,
void *
-virObjectRWLockableNew(virClassPtr klass)
+virObjectRWLockableNew(virClass *klass)
{
- virObjectRWLockablePtr obj;
+ virObjectRWLockable *obj;
if (!virClassIsDerivedFrom(klass, virClassForObjectRWLockable())) {
virReportInvalidArg(klass,
static void vir_object_finalize(GObject *gobj)
{
- virObjectPtr obj = VIR_OBJECT(gobj);
+ virObject *obj = VIR_OBJECT(gobj);
virObjectPrivate *priv = vir_object_get_instance_private(obj);
- virClassPtr klass = priv->klass;
+ virClass *klass = priv->klass;
PROBE(OBJECT_DISPOSE, "obj=%p", gobj);
static void
virObjectLockableDispose(void *anyobj)
{
- virObjectLockablePtr obj = anyobj;
+ virObjectLockable *obj = anyobj;
virMutexDestroy(&obj->lock);
}
static void
virObjectRWLockableDispose(void *anyobj)
{
- virObjectRWLockablePtr obj = anyobj;
+ virObjectRWLockable *obj = anyobj;
virRWLockDestroy(&obj->lock);
}
/**
* virObjectUnref:
- * @anyobj: any instance of virObjectPtr
+ * @anyobj: any instance of virObject *
*
* Decrement the reference count on @anyobj and if
* it hits zero, runs the "dispose" callbacks associated
void
virObjectUnref(void *anyobj)
{
- virObjectPtr obj = anyobj;
+ virObject *obj = anyobj;
if (VIR_OBJECT_NOTVALID(obj))
return;
/**
* virObjectRef:
- * @anyobj: any instance of virObjectPtr
+ * @anyobj: any instance of virObject *
*
* Increment the reference count on @anyobj and return
* the same pointer
void *
virObjectRef(void *anyobj)
{
- virObjectPtr obj = anyobj;
+ virObject *obj = anyobj;
if (VIR_OBJECT_NOTVALID(obj))
return NULL;
}
-static virObjectLockablePtr
+static virObjectLockable *
virObjectGetLockableObj(void *anyobj)
{
if (virObjectIsClass(anyobj, virObjectLockableClass))
}
-static virObjectRWLockablePtr
+static virObjectRWLockable *
virObjectGetRWLockableObj(void *anyobj)
{
if (virObjectIsClass(anyobj, virObjectRWLockableClass))
void
virObjectLock(void *anyobj)
{
- virObjectLockablePtr obj = virObjectGetLockableObj(anyobj);
+ virObjectLockable *obj = virObjectGetLockableObj(anyobj);
if (!obj)
return;
void
virObjectRWLockRead(void *anyobj)
{
- virObjectRWLockablePtr obj = virObjectGetRWLockableObj(anyobj);
+ virObjectRWLockable *obj = virObjectGetRWLockableObj(anyobj);
if (!obj)
return;
void
virObjectRWLockWrite(void *anyobj)
{
- virObjectRWLockablePtr obj = virObjectGetRWLockableObj(anyobj);
+ virObjectRWLockable *obj = virObjectGetRWLockableObj(anyobj);
if (!obj)
return;
void
virObjectUnlock(void *anyobj)
{
- virObjectLockablePtr obj = virObjectGetLockableObj(anyobj);
+ virObjectLockable *obj = virObjectGetLockableObj(anyobj);
if (!obj)
return;
void
virObjectRWUnlock(void *anyobj)
{
- virObjectRWLockablePtr obj = virObjectGetRWLockableObj(anyobj);
+ virObjectRWLockable *obj = virObjectGetRWLockableObj(anyobj);
if (!obj)
return;
/**
* virObjectIsClass:
- * @anyobj: any instance of virObjectPtr
+ * @anyobj: any instance of virObject *
* @klass: the class to check
*
* Checks whether @anyobj is an instance of
*/
bool
virObjectIsClass(void *anyobj,
- virClassPtr klass)
+ virClass *klass)
{
- virObjectPtr obj = anyobj;
+ virObject *obj = anyobj;
virObjectPrivate *priv;
if (VIR_OBJECT_NOTVALID(obj))
* Returns the name of @klass
*/
const char *
-virClassName(virClassPtr klass)
+virClassName(virClass *klass)
{
return klass->name;
}
#include <glib-object.h>
typedef struct _virClass virClass;
-typedef virClass *virClassPtr;
typedef struct _virObject virObject;
-typedef virObject *virObjectPtr;
typedef struct _virObjectLockable virObjectLockable;
-typedef virObjectLockable *virObjectLockablePtr;
typedef struct _virObjectRWLockable virObjectRWLockable;
-typedef virObjectRWLockable *virObjectRWLockablePtr;
typedef void (*virObjectDisposeCallback)(void *obj);
virRWLock lock;
};
-virClassPtr virClassForObject(void);
-virClassPtr virClassForObjectLockable(void);
-virClassPtr virClassForObjectRWLockable(void);
+virClass *virClassForObject(void);
+virClass *virClassForObjectLockable(void);
+virClass *virClassForObjectRWLockable(void);
#ifndef VIR_PARENT_REQUIRED
# define VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(1)
sizeof(((name *)NULL)->parent), \
name##Dispose)))
-virClassPtr
-virClassNew(virClassPtr parent,
+virClass *
+virClassNew(virClass *parent,
const char *name,
size_t objectSize,
size_t parentSize,
VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(2);
const char *
-virClassName(virClassPtr klass)
+virClassName(virClass *klass)
ATTRIBUTE_NONNULL(1);
bool
-virClassIsDerivedFrom(virClassPtr klass,
- virClassPtr parent)
+virClassIsDerivedFrom(virClass *klass,
+ virClass *parent)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void *
-virObjectNew(virClassPtr klass)
+virObjectNew(virClass *klass)
ATTRIBUTE_NONNULL(1);
void
bool
virObjectIsClass(void *obj,
- virClassPtr klass)
+ virClass *klass)
ATTRIBUTE_NONNULL(2);
void
virObjectFreeHashData(void *opaque);
void *
-virObjectLockableNew(virClassPtr klass)
+virObjectLockableNew(virClass *klass)
ATTRIBUTE_NONNULL(1);
void *
-virObjectRWLockableNew(virClassPtr klass)
+virObjectRWLockableNew(virClass *klass)
ATTRIBUTE_NONNULL(1);
void
virObjectLockable parent;
size_t count;
- virPCIDevicePtr *devs;
+ virPCIDevice **devs;
};
#define PCI_EXP_TYPE_ROOT_INT_EP 0x9 /* Root Complex Integrated Endpoint */
#define PCI_EXP_TYPE_ROOT_EC 0xa /* Root Complex Event Collector */
-static virClassPtr virPCIDeviceListClass;
+static virClass *virPCIDeviceListClass;
static void virPCIDeviceListDispose(void *obj);
* Return 0 for success, -1 for error.
*/
int
-virPCIDeviceGetDriverPathAndName(virPCIDevicePtr dev, char **path, char **name)
+virPCIDeviceGetDriverPathAndName(virPCIDevice *dev, char **path, char **name)
{
int ret = -1;
g_autofree char *drvlink = NULL;
static int
-virPCIDeviceConfigOpenInternal(virPCIDevicePtr dev, bool readonly, bool fatal)
+virPCIDeviceConfigOpenInternal(virPCIDevice *dev, bool readonly, bool fatal)
{
int fd;
}
static int
-virPCIDeviceConfigOpen(virPCIDevicePtr dev)
+virPCIDeviceConfigOpen(virPCIDevice *dev)
{
return virPCIDeviceConfigOpenInternal(dev, true, true);
}
static int
-virPCIDeviceConfigOpenTry(virPCIDevicePtr dev)
+virPCIDeviceConfigOpenTry(virPCIDevice *dev)
{
return virPCIDeviceConfigOpenInternal(dev, true, false);
}
static int
-virPCIDeviceConfigOpenWrite(virPCIDevicePtr dev)
+virPCIDeviceConfigOpenWrite(virPCIDevice *dev)
{
return virPCIDeviceConfigOpenInternal(dev, false, true);
}
static void
-virPCIDeviceConfigClose(virPCIDevicePtr dev, int cfgfd)
+virPCIDeviceConfigClose(virPCIDevice *dev, int cfgfd)
{
if (VIR_CLOSE(cfgfd) < 0) {
VIR_WARN("Failed to close config space file '%s': %s",
static int
-virPCIDeviceRead(virPCIDevicePtr dev,
+virPCIDeviceRead(virPCIDevice *dev,
int cfgfd,
unsigned int pos,
uint8_t *buf,
* the value 0 at @pos.
*/
static uint8_t
-virPCIDeviceRead8(virPCIDevicePtr dev, int cfgfd, unsigned int pos)
+virPCIDeviceRead8(virPCIDevice *dev, int cfgfd, unsigned int pos)
{
uint8_t buf;
virPCIDeviceRead(dev, cfgfd, pos, &buf, sizeof(buf));
}
static uint16_t
-virPCIDeviceRead16(virPCIDevicePtr dev, int cfgfd, unsigned int pos)
+virPCIDeviceRead16(virPCIDevice *dev, int cfgfd, unsigned int pos)
{
uint8_t buf[2];
virPCIDeviceRead(dev, cfgfd, pos, &buf[0], sizeof(buf));
}
static uint32_t
-virPCIDeviceRead32(virPCIDevicePtr dev, int cfgfd, unsigned int pos)
+virPCIDeviceRead32(virPCIDevice *dev, int cfgfd, unsigned int pos)
{
uint8_t buf[4];
virPCIDeviceRead(dev, cfgfd, pos, &buf[0], sizeof(buf));
}
static int
-virPCIDeviceReadClass(virPCIDevicePtr dev, uint16_t *device_class)
+virPCIDeviceReadClass(virPCIDevice *dev, uint16_t *device_class)
{
g_autofree char *path = NULL;
g_autofree char *id_str = NULL;
}
static int
-virPCIDeviceWrite(virPCIDevicePtr dev,
+virPCIDeviceWrite(virPCIDevice *dev,
int cfgfd,
unsigned int pos,
uint8_t *buf,
}
static void
-virPCIDeviceWrite16(virPCIDevicePtr dev, int cfgfd, unsigned int pos, uint16_t val)
+virPCIDeviceWrite16(virPCIDevice *dev, int cfgfd, unsigned int pos, uint16_t val)
{
uint8_t buf[2] = { (val >> 0), (val >> 8) };
virPCIDeviceWrite(dev, cfgfd, pos, &buf[0], sizeof(buf));
}
static void
-virPCIDeviceWrite32(virPCIDevicePtr dev, int cfgfd, unsigned int pos, uint32_t val)
+virPCIDeviceWrite32(virPCIDevice *dev, int cfgfd, unsigned int pos, uint32_t val)
{
uint8_t buf[4] = { (val >> 0), (val >> 8), (val >> 16), (val >> 24) };
virPCIDeviceWrite(dev, cfgfd, pos, &buf[0], sizeof(buf));
}
-typedef int (*virPCIDeviceIterPredicate)(virPCIDevicePtr, virPCIDevicePtr,
+typedef int (*virPCIDeviceIterPredicate)(virPCIDevice *, virPCIDevice *,
void *);
/* Iterate over available PCI devices calling @predicate
*/
static int
virPCIDeviceIterDevices(virPCIDeviceIterPredicate predicate,
- virPCIDevicePtr dev,
- virPCIDevicePtr *matched,
+ virPCIDevice *dev,
+ virPCIDevice **matched,
void *data)
{
g_autoptr(DIR) dir = NULL;
* Returns 0 on success, -1 on failure.
*/
static int
-virPCIDeviceFindCapabilityOffset(virPCIDevicePtr dev,
+virPCIDeviceFindCapabilityOffset(virPCIDevice *dev,
int cfgfd,
unsigned int capability,
unsigned int *offset)
}
static unsigned int
-virPCIDeviceFindExtendedCapabilityOffset(virPCIDevicePtr dev,
+virPCIDeviceFindExtendedCapabilityOffset(virPCIDevice *dev,
int cfgfd,
unsigned int capability)
{
* not have FLR, 1 if it does, and -1 on error
*/
static bool
-virPCIDeviceDetectFunctionLevelReset(virPCIDevicePtr dev, int cfgfd)
+virPCIDeviceDetectFunctionLevelReset(virPCIDevice *dev, int cfgfd)
{
uint32_t caps;
unsigned int pos;
* internal reset, not just a soft reset.
*/
static bool
-virPCIDeviceDetectPowerManagementReset(virPCIDevicePtr dev, int cfgfd)
+virPCIDeviceDetectPowerManagementReset(virPCIDevice *dev, int cfgfd)
{
if (dev->pci_pm_cap_pos) {
uint32_t ctl;
/* Any active devices on the same domain/bus ? */
static int
-virPCIDeviceSharesBusWithActive(virPCIDevicePtr dev, virPCIDevicePtr check, void *data)
+virPCIDeviceSharesBusWithActive(virPCIDevice *dev, virPCIDevice *check, void *data)
{
virPCIDeviceList *inactiveDevs = data;
return 1;
}
-static virPCIDevicePtr
-virPCIDeviceBusContainsActiveDevices(virPCIDevicePtr dev,
+static virPCIDevice *
+virPCIDeviceBusContainsActiveDevices(virPCIDevice *dev,
virPCIDeviceList *inactiveDevs)
{
- virPCIDevicePtr active = NULL;
+ virPCIDevice *active = NULL;
if (virPCIDeviceIterDevices(virPCIDeviceSharesBusWithActive,
dev, &active, inactiveDevs) < 0)
return NULL;
/* Is @check the parent of @dev ? */
static int
-virPCIDeviceIsParent(virPCIDevicePtr dev, virPCIDevicePtr check, void *data)
+virPCIDeviceIsParent(virPCIDevice *dev, virPCIDevice *check, void *data)
{
uint16_t device_class;
uint8_t header_type, secondary, subordinate;
- virPCIDevicePtr *best = data;
+ virPCIDevice **best = data;
int ret = 0;
int fd;
}
static int
-virPCIDeviceGetParent(virPCIDevicePtr dev, virPCIDevicePtr *parent)
+virPCIDeviceGetParent(virPCIDevice *dev, virPCIDevice **parent)
{
- virPCIDevicePtr best = NULL;
+ virPCIDevice *best = NULL;
int ret;
*parent = NULL;
* devices behind a bus.
*/
static int
-virPCIDeviceTrySecondaryBusReset(virPCIDevicePtr dev,
+virPCIDeviceTrySecondaryBusReset(virPCIDevice *dev,
int cfgfd,
virPCIDeviceList *inactiveDevs)
{
* above we require the device supports a full internal reset.
*/
static int
-virPCIDeviceTryPowerManagementReset(virPCIDevicePtr dev, int cfgfd)
+virPCIDeviceTryPowerManagementReset(virPCIDevice *dev, int cfgfd)
{
uint8_t config_space[PCI_CONF_LEN];
uint32_t ctl;
* Always returns success (0) (for now)
*/
static int
-virPCIDeviceInit(virPCIDevicePtr dev, int cfgfd)
+virPCIDeviceInit(virPCIDevice *dev, int cfgfd)
{
dev->is_pcie = false;
if (virPCIDeviceFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_EXP, &dev->pcie_cap_pos) < 0) {
}
int
-virPCIDeviceReset(virPCIDevicePtr dev,
+virPCIDeviceReset(virPCIDevice *dev,
virPCIDeviceList *activeDevs,
virPCIDeviceList *inactiveDevs)
{
}
int
-virPCIDeviceUnbind(virPCIDevicePtr dev)
+virPCIDeviceUnbind(virPCIDevice *dev)
{
g_autofree char *path = NULL;
g_autofree char *drvpath = NULL;
*
* Returns 0 on success, -1 on failure
*/
-int virPCIDeviceRebind(virPCIDevicePtr dev)
+int virPCIDeviceRebind(virPCIDevice *dev)
{
if (virPCIDeviceUnbind(dev) < 0)
return -1;
* preferred driver.
*/
static int
-virPCIDeviceBindWithDriverOverride(virPCIDevicePtr dev,
+virPCIDeviceBindWithDriverOverride(virPCIDevice *dev,
const char *driverName)
{
g_autofree char *path = NULL;
}
static int
-virPCIDeviceUnbindFromStub(virPCIDevicePtr dev)
+virPCIDeviceUnbindFromStub(virPCIDevice *dev)
{
if (!dev->unbind_from_stub) {
VIR_DEBUG("Unbind from stub skipped for PCI device %s", dev->name);
}
static int
-virPCIDeviceBindToStub(virPCIDevicePtr dev)
+virPCIDeviceBindToStub(virPCIDevice *dev)
{
const char *stubDriverName;
g_autofree char *stubDriverPath = NULL;
* list.
*/
int
-virPCIDeviceDetach(virPCIDevicePtr dev,
+virPCIDeviceDetach(virPCIDevice *dev,
virPCIDeviceList *activeDevs,
virPCIDeviceList *inactiveDevs)
{
* are locked
*/
int
-virPCIDeviceReattach(virPCIDevicePtr dev,
- virPCIDeviceListPtr activeDevs,
- virPCIDeviceListPtr inactiveDevs)
+virPCIDeviceReattach(virPCIDevice *dev,
+ virPCIDeviceList *activeDevs,
+ virPCIDeviceList *inactiveDevs)
{
if (activeDevs && virPCIDeviceListFind(activeDevs, &dev->address)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
static char *
-virPCIDeviceReadID(virPCIDevicePtr dev, const char *id_name)
+virPCIDeviceReadID(virPCIDevice *dev, const char *id_name)
{
g_autofree char *path = NULL;
g_autofree char *id_str = NULL;
}
bool
-virPCIDeviceAddressIsValid(virPCIDeviceAddressPtr addr,
+virPCIDeviceAddressIsValid(virPCIDeviceAddress *addr,
bool report)
{
if (addr->bus > 0xFF) {
* Creates a deep copy of given @src address and stores it into
* @dst which has to be pre-allocated by caller.
*/
-void virPCIDeviceAddressCopy(virPCIDeviceAddressPtr dst,
+void virPCIDeviceAddressCopy(virPCIDeviceAddress *dst,
const virPCIDeviceAddress *src)
{
memcpy(dst, src, sizeof(*src));
return virFileExists(devPath);
}
-virPCIDevicePtr
+virPCIDevice *
virPCIDeviceNew(const virPCIDeviceAddress *address)
{
g_autoptr(virPCIDevice) dev = NULL;
}
-virPCIDevicePtr
-virPCIDeviceCopy(virPCIDevicePtr dev)
+virPCIDevice *
+virPCIDeviceCopy(virPCIDevice *dev)
{
- virPCIDevicePtr copy;
+ virPCIDevice *copy;
copy = g_new0(virPCIDevice, 1);
void
-virPCIDeviceFree(virPCIDevicePtr dev)
+virPCIDeviceFree(virPCIDevice *dev)
{
if (!dev)
return;
*
* Returns: a pointer to the address, which can never be NULL.
*/
-virPCIDeviceAddressPtr
-virPCIDeviceGetAddress(virPCIDevicePtr dev)
+virPCIDeviceAddress *
+virPCIDeviceGetAddress(virPCIDevice *dev)
{
return &(dev->address);
}
const char *
-virPCIDeviceGetName(virPCIDevicePtr dev)
+virPCIDeviceGetName(virPCIDevice *dev)
{
return dev->name;
}
* config file.
*/
const char *
-virPCIDeviceGetConfigPath(virPCIDevicePtr dev)
+virPCIDeviceGetConfigPath(virPCIDevice *dev)
{
return dev->path;
}
-void virPCIDeviceSetManaged(virPCIDevicePtr dev, bool managed)
+void virPCIDeviceSetManaged(virPCIDevice *dev, bool managed)
{
dev->managed = managed;
}
bool
-virPCIDeviceGetManaged(virPCIDevicePtr dev)
+virPCIDeviceGetManaged(virPCIDevice *dev)
{
return dev->managed;
}
void
-virPCIDeviceSetStubDriver(virPCIDevicePtr dev, virPCIStubDriver driver)
+virPCIDeviceSetStubDriver(virPCIDevice *dev, virPCIStubDriver driver)
{
dev->stubDriver = driver;
}
virPCIStubDriver
-virPCIDeviceGetStubDriver(virPCIDevicePtr dev)
+virPCIDeviceGetStubDriver(virPCIDevice *dev)
{
return dev->stubDriver;
}
bool
-virPCIDeviceGetUnbindFromStub(virPCIDevicePtr dev)
+virPCIDeviceGetUnbindFromStub(virPCIDevice *dev)
{
return dev->unbind_from_stub;
}
void
-virPCIDeviceSetUnbindFromStub(virPCIDevicePtr dev, bool unbind)
+virPCIDeviceSetUnbindFromStub(virPCIDevice *dev, bool unbind)
{
dev->unbind_from_stub = unbind;
}
bool
-virPCIDeviceGetRemoveSlot(virPCIDevicePtr dev)
+virPCIDeviceGetRemoveSlot(virPCIDevice *dev)
{
return dev->remove_slot;
}
void
-virPCIDeviceSetRemoveSlot(virPCIDevicePtr dev, bool remove_slot)
+virPCIDeviceSetRemoveSlot(virPCIDevice *dev, bool remove_slot)
{
dev->remove_slot = remove_slot;
}
bool
-virPCIDeviceGetReprobe(virPCIDevicePtr dev)
+virPCIDeviceGetReprobe(virPCIDevice *dev)
{
return dev->reprobe;
}
void
-virPCIDeviceSetReprobe(virPCIDevicePtr dev, bool reprobe)
+virPCIDeviceSetReprobe(virPCIDevice *dev, bool reprobe)
{
dev->reprobe = reprobe;
}
int
-virPCIDeviceSetUsedBy(virPCIDevicePtr dev,
+virPCIDeviceSetUsedBy(virPCIDevice *dev,
const char *drv_name,
const char *dom_name)
{
}
void
-virPCIDeviceGetUsedBy(virPCIDevicePtr dev,
+virPCIDeviceGetUsedBy(virPCIDevice *dev,
const char **drv_name,
const char **dom_name)
{
*dom_name = dev->used_by_domname;
}
-virPCIDeviceListPtr
+virPCIDeviceList *
virPCIDeviceListNew(void)
{
- virPCIDeviceListPtr list;
+ virPCIDeviceList *list;
if (virPCIInitialize() < 0)
return NULL;
static void
virPCIDeviceListDispose(void *obj)
{
- virPCIDeviceListPtr list = obj;
+ virPCIDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++) {
}
int
-virPCIDeviceListAdd(virPCIDeviceListPtr list,
- virPCIDevicePtr dev)
+virPCIDeviceListAdd(virPCIDeviceList *list,
+ virPCIDevice *dev)
{
if (virPCIDeviceListFind(list, &dev->address)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
/* virPCIDeviceListAddCopy - add a *copy* of the device to this list */
int
-virPCIDeviceListAddCopy(virPCIDeviceListPtr list, virPCIDevicePtr dev)
+virPCIDeviceListAddCopy(virPCIDeviceList *list, virPCIDevice *dev)
{
g_autoptr(virPCIDevice) copy = virPCIDeviceCopy(dev);
}
-virPCIDevicePtr
-virPCIDeviceListGet(virPCIDeviceListPtr list,
+virPCIDevice *
+virPCIDeviceListGet(virPCIDeviceList *list,
int idx)
{
if (idx >= list->count)
}
size_t
-virPCIDeviceListCount(virPCIDeviceListPtr list)
+virPCIDeviceListCount(virPCIDeviceList *list)
{
return list->count;
}
-virPCIDevicePtr
-virPCIDeviceListStealIndex(virPCIDeviceListPtr list,
+virPCIDevice *
+virPCIDeviceListStealIndex(virPCIDeviceList *list,
int idx)
{
- virPCIDevicePtr ret;
+ virPCIDevice *ret;
if (idx < 0 || idx >= list->count)
return NULL;
return ret;
}
-virPCIDevicePtr
-virPCIDeviceListSteal(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr)
+virPCIDevice *
+virPCIDeviceListSteal(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr)
{
return virPCIDeviceListStealIndex(list, virPCIDeviceListFindIndex(list, devAddr));
}
void
-virPCIDeviceListDel(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr)
+virPCIDeviceListDel(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr)
{
virPCIDeviceFree(virPCIDeviceListSteal(list, devAddr));
}
int
-virPCIDeviceListFindIndex(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr)
+virPCIDeviceListFindIndex(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr)
{
size_t i;
for (i = 0; i < list->count; i++) {
- virPCIDevicePtr other = list->devs[i];
+ virPCIDevice *other = list->devs[i];
if (other->address.domain == devAddr->domain &&
other->address.bus == devAddr->bus &&
other->address.slot == devAddr->slot &&
}
-virPCIDevicePtr
-virPCIDeviceListFindByIDs(virPCIDeviceListPtr list,
+virPCIDevice *
+virPCIDeviceListFindByIDs(virPCIDeviceList *list,
unsigned int domain,
unsigned int bus,
unsigned int slot,
size_t i;
for (i = 0; i < list->count; i++) {
- virPCIDevicePtr other = list->devs[i];
+ virPCIDevice *other = list->devs[i];
if (other->address.domain == domain &&
other->address.bus == bus &&
other->address.slot == slot &&
}
-virPCIDevicePtr
-virPCIDeviceListFind(virPCIDeviceListPtr list, virPCIDeviceAddressPtr devAddr)
+virPCIDevice *
+virPCIDeviceListFind(virPCIDeviceList *list, virPCIDeviceAddress *devAddr)
{
int idx;
}
-int virPCIDeviceFileIterate(virPCIDevicePtr dev,
+int virPCIDeviceFileIterate(virPCIDevice *dev,
virPCIDeviceFileActor actor,
void *opaque)
{
* device, call @actor once for orig.
*/
int
-virPCIDeviceAddressIOMMUGroupIterate(virPCIDeviceAddressPtr orig,
+virPCIDeviceAddressIOMMUGroupIterate(virPCIDeviceAddress *orig,
virPCIDeviceAddressActor actor,
void *opaque)
{
static int
-virPCIDeviceGetIOMMUGroupAddOne(virPCIDeviceAddressPtr newDevAddr, void *opaque)
+virPCIDeviceGetIOMMUGroupAddOne(virPCIDeviceAddress *newDevAddr, void *opaque)
{
- virPCIDeviceListPtr groupList = opaque;
+ virPCIDeviceList *groupList = opaque;
g_autoptr(virPCIDevice) newDev = NULL;
if (!(newDev = virPCIDeviceNew(newDevAddr)))
*
* Return the new list, or NULL on failure
*/
-virPCIDeviceListPtr
-virPCIDeviceGetIOMMUGroupList(virPCIDevicePtr dev)
+virPCIDeviceList *
+virPCIDeviceGetIOMMUGroupList(virPCIDevice *dev)
{
- virPCIDeviceListPtr groupList = virPCIDeviceListNew();
+ virPCIDeviceList *groupList = virPCIDeviceListNew();
if (!groupList)
goto error;
typedef struct {
- virPCIDeviceAddressPtr **iommuGroupDevices;
+ virPCIDeviceAddress ***iommuGroupDevices;
size_t *nIommuGroupDevices;
} virPCIDeviceAddressList;
-typedef virPCIDeviceAddressList *virPCIDeviceAddressListPtr;
static int
-virPCIGetIOMMUGroupAddressesAddOne(virPCIDeviceAddressPtr newDevAddr, void *opaque)
+virPCIGetIOMMUGroupAddressesAddOne(virPCIDeviceAddress *newDevAddr, void *opaque)
{
- virPCIDeviceAddressListPtr addrList = opaque;
- g_autofree virPCIDeviceAddressPtr copyAddr = NULL;
+ virPCIDeviceAddressList *addrList = opaque;
+ g_autofree virPCIDeviceAddress *copyAddr = NULL;
/* make a copy to insert onto the list */
copyAddr = g_new0(virPCIDeviceAddress, 1);
* Return the new list, or NULL on failure
*/
int
-virPCIDeviceAddressGetIOMMUGroupAddresses(virPCIDeviceAddressPtr devAddr,
- virPCIDeviceAddressPtr **iommuGroupDevices,
+virPCIDeviceAddressGetIOMMUGroupAddresses(virPCIDeviceAddress *devAddr,
+ virPCIDeviceAddress ***iommuGroupDevices,
size_t *nIommuGroupDevices)
{
virPCIDeviceAddressList addrList = { iommuGroupDevices,
* the device (or -1 if there was any other error)
*/
int
-virPCIDeviceAddressGetIOMMUGroupNum(virPCIDeviceAddressPtr addr)
+virPCIDeviceAddressGetIOMMUGroupNum(virPCIDeviceAddress *addr)
{
g_autofree char *devName = NULL;
g_autofree char *devPath = NULL;
* to control this PCI device's group (e.g. "/dev/vfio/15")
*/
char *
-virPCIDeviceGetIOMMUGroupDev(virPCIDevicePtr dev)
+virPCIDeviceGetIOMMUGroupDev(virPCIDevice *dev)
{
g_autofree char *devPath = NULL;
g_autofree char *groupPath = NULL;
}
static int
-virPCIDeviceDownstreamLacksACS(virPCIDevicePtr dev)
+virPCIDeviceDownstreamLacksACS(virPCIDevice *dev)
{
uint16_t flags;
uint16_t ctrl;
}
static int
-virPCIDeviceIsBehindSwitchLackingACS(virPCIDevicePtr dev)
+virPCIDeviceIsBehindSwitchLackingACS(virPCIDevice *dev)
{
g_autoptr(virPCIDevice) parent = NULL;
return 0;
}
-int virPCIDeviceIsAssignable(virPCIDevicePtr dev,
+int virPCIDeviceIsAssignable(virPCIDevice *dev,
int strict_acs_check)
{
int ret;
int
virPCIDeviceAddressParse(char *address,
- virPCIDeviceAddressPtr bdf)
+ virPCIDeviceAddress *bdf)
{
char *p = NULL;
#ifdef __linux__
-virPCIDeviceAddressPtr
+virPCIDeviceAddress *
virPCIGetDeviceAddressFromSysfsLink(const char *device_link)
{
- g_autofree virPCIDeviceAddressPtr bdf = NULL;
+ g_autofree virPCIDeviceAddress *bdf = NULL;
g_autofree char *config_address = NULL;
g_autofree char *device_path = NULL;
*/
int
virPCIGetPhysicalFunction(const char *vf_sysfs_path,
- virPCIDeviceAddressPtr *pf)
+ virPCIDeviceAddress **pf)
{
g_autofree char *device_link = NULL;
*/
int
virPCIGetVirtualFunctions(const char *sysfs_path,
- virPCIDeviceAddressPtr **virtual_functions,
+ virPCIDeviceAddress ***virtual_functions,
size_t *num_virtual_functions,
unsigned int *max_virtual_functions)
{
size_t i;
g_autofree char *totalvfs_file = NULL;
g_autofree char *totalvfs_str = NULL;
- g_autofree virPCIDeviceAddressPtr config_addr = NULL;
+ g_autofree virPCIDeviceAddress *config_addr = NULL;
*virtual_functions = NULL;
*num_virtual_functions = 0;
size_t i;
size_t num_virt_fns = 0;
unsigned int max_virt_fns = 0;
- g_autofree virPCIDeviceAddressPtr vf_bdf = NULL;
- virPCIDeviceAddressPtr *virt_fns = NULL;
+ g_autofree virPCIDeviceAddress *vf_bdf = NULL;
+ virPCIDeviceAddress **virt_fns = NULL;
if (!(vf_bdf = virPCIGetDeviceAddressFromSysfsLink(vf_sysfs_device_link)))
return ret;
*/
int
-virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr addr,
+virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddress *addr,
char **pci_sysfs_device_link)
{
*pci_sysfs_device_link = g_strdup_printf(PCI_SYSFS "devices/" VIR_PCI_DEVICE_ADDRESS_FMT, addr->domain,
char **pfname,
int *vf_index)
{
- g_autofree virPCIDeviceAddressPtr pf_config_address = NULL;
+ g_autofree virPCIDeviceAddress *pf_config_address = NULL;
g_autofree char *pf_sysfs_device_path = NULL;
g_autofree char *vfname = NULL;
g_autofree char *vfPhysPortID = NULL;
#else
static const char *unsupported = N_("not supported on non-linux platforms");
-virPCIDeviceAddressPtr
+virPCIDeviceAddress *
virPCIGetDeviceAddressFromSysfsLink(const char *device_link G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported));
int
virPCIGetPhysicalFunction(const char *vf_sysfs_path G_GNUC_UNUSED,
- virPCIDeviceAddressPtr *pf G_GNUC_UNUSED)
+ virPCIDeviceAddress **pf G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported));
return -1;
int
virPCIGetVirtualFunctions(const char *sysfs_path G_GNUC_UNUSED,
- virPCIDeviceAddressPtr **virtual_functions G_GNUC_UNUSED,
+ virPCIDeviceAddress ***virtual_functions G_GNUC_UNUSED,
size_t *num_virtual_functions G_GNUC_UNUSED,
unsigned int *max_virtual_functions G_GNUC_UNUSED)
{
int
-virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr dev G_GNUC_UNUSED,
+virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddress *dev G_GNUC_UNUSED,
char **pci_sysfs_device_link G_GNUC_UNUSED)
{
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported));
#endif /* __linux__ */
int
-virPCIDeviceIsPCIExpress(virPCIDevicePtr dev)
+virPCIDeviceIsPCIExpress(virPCIDevice *dev)
{
int fd;
int ret = -1;
}
int
-virPCIDeviceHasPCIExpressLink(virPCIDevicePtr dev)
+virPCIDeviceHasPCIExpressLink(virPCIDevice *dev)
{
int fd;
int ret = -1;
}
int
-virPCIDeviceGetLinkCapSta(virPCIDevicePtr dev,
+virPCIDeviceGetLinkCapSta(virPCIDevice *dev,
int *cap_port,
unsigned int *cap_speed,
unsigned int *cap_width,
}
-int virPCIGetHeaderType(virPCIDevicePtr dev, int *hdrType)
+int virPCIGetHeaderType(virPCIDevice *dev, int *hdrType)
{
int fd;
uint8_t type;
void
-virPCIEDeviceInfoFree(virPCIEDeviceInfoPtr dev)
+virPCIEDeviceInfoFree(virPCIEDeviceInfo *dev)
{
if (!dev)
return;
}
void
-virPCIDeviceAddressFree(virPCIDeviceAddressPtr address)
+virPCIDeviceAddressFree(virPCIDeviceAddress *address)
{
g_free(address);
}
#include "virenum.h"
typedef struct _virPCIDevice virPCIDevice;
-typedef virPCIDevice *virPCIDevicePtr;
typedef struct _virPCIDeviceAddress virPCIDeviceAddress;
-typedef virPCIDeviceAddress *virPCIDeviceAddressPtr;
typedef struct _virPCIDeviceList virPCIDeviceList;
-typedef virPCIDeviceList *virPCIDeviceListPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virPCIDeviceList, virObjectUnref);
typedef struct _virZPCIDeviceAddressID virZPCIDeviceAddressID;
typedef struct _virZPCIDeviceAddress virZPCIDeviceAddress;
-typedef virZPCIDeviceAddress *virZPCIDeviceAddressPtr;
struct _virZPCIDeviceAddressID {
unsigned int value;
VIR_ENUM_DECL(virPCIHeader);
typedef struct _virPCIELink virPCIELink;
-typedef virPCIELink *virPCIELinkPtr;
struct _virPCIELink {
int port;
virPCIELinkSpeed speed;
};
typedef struct _virPCIEDeviceInfo virPCIEDeviceInfo;
-typedef virPCIEDeviceInfo *virPCIEDeviceInfoPtr;
struct _virPCIEDeviceInfo {
/* Not all PCI Express devices have link. For example this 'Root Complex
* Integrated Endpoint' and 'Root Complex Event Collector' don't have it. */
virPCIELink *link_sta; /* Actually negotiated capabilities */
};
-virPCIDevicePtr virPCIDeviceNew(const virPCIDeviceAddress *address);
-virPCIDevicePtr virPCIDeviceCopy(virPCIDevicePtr dev);
-void virPCIDeviceFree(virPCIDevicePtr dev);
-const char *virPCIDeviceGetName(virPCIDevicePtr dev);
-const char *virPCIDeviceGetConfigPath(virPCIDevicePtr dev);
-
-int virPCIDeviceDetach(virPCIDevicePtr dev,
- virPCIDeviceListPtr activeDevs,
- virPCIDeviceListPtr inactiveDevs);
-int virPCIDeviceReattach(virPCIDevicePtr dev,
- virPCIDeviceListPtr activeDevs,
- virPCIDeviceListPtr inactiveDevs);
-int virPCIDeviceReset(virPCIDevicePtr dev,
- virPCIDeviceListPtr activeDevs,
- virPCIDeviceListPtr inactiveDevs);
+virPCIDevice *virPCIDeviceNew(const virPCIDeviceAddress *address);
+virPCIDevice *virPCIDeviceCopy(virPCIDevice *dev);
+void virPCIDeviceFree(virPCIDevice *dev);
+const char *virPCIDeviceGetName(virPCIDevice *dev);
+const char *virPCIDeviceGetConfigPath(virPCIDevice *dev);
+
+int virPCIDeviceDetach(virPCIDevice *dev,
+ virPCIDeviceList *activeDevs,
+ virPCIDeviceList *inactiveDevs);
+int virPCIDeviceReattach(virPCIDevice *dev,
+ virPCIDeviceList *activeDevs,
+ virPCIDeviceList *inactiveDevs);
+int virPCIDeviceReset(virPCIDevice *dev,
+ virPCIDeviceList *activeDevs,
+ virPCIDeviceList *inactiveDevs);
void virPCIDeviceSetManaged(virPCIDevice *dev,
bool managed);
bool virPCIDeviceGetManaged(virPCIDevice *dev);
-void virPCIDeviceSetStubDriver(virPCIDevicePtr dev,
+void virPCIDeviceSetStubDriver(virPCIDevice *dev,
virPCIStubDriver driver);
-virPCIStubDriver virPCIDeviceGetStubDriver(virPCIDevicePtr dev);
-virPCIDeviceAddressPtr virPCIDeviceGetAddress(virPCIDevicePtr dev);
+virPCIStubDriver virPCIDeviceGetStubDriver(virPCIDevice *dev);
+virPCIDeviceAddress *virPCIDeviceGetAddress(virPCIDevice *dev);
int virPCIDeviceSetUsedBy(virPCIDevice *dev,
const char *drv_name,
const char *dom_name);
void virPCIDeviceGetUsedBy(virPCIDevice *dev,
const char **drv_name,
const char **dom_name);
-bool virPCIDeviceGetUnbindFromStub(virPCIDevicePtr dev);
+bool virPCIDeviceGetUnbindFromStub(virPCIDevice *dev);
void virPCIDeviceSetUnbindFromStub(virPCIDevice *dev,
bool unbind);
-bool virPCIDeviceGetRemoveSlot(virPCIDevicePtr dev);
+bool virPCIDeviceGetRemoveSlot(virPCIDevice *dev);
void virPCIDeviceSetRemoveSlot(virPCIDevice *dev,
bool remove_slot);
-bool virPCIDeviceGetReprobe(virPCIDevicePtr dev);
+bool virPCIDeviceGetReprobe(virPCIDevice *dev);
void virPCIDeviceSetReprobe(virPCIDevice *dev,
bool reprobe);
-virPCIDeviceListPtr virPCIDeviceListNew(void);
-int virPCIDeviceListAdd(virPCIDeviceListPtr list,
- virPCIDevicePtr dev);
-int virPCIDeviceListAddCopy(virPCIDeviceListPtr list, virPCIDevicePtr dev);
-virPCIDevicePtr virPCIDeviceListGet(virPCIDeviceListPtr list,
+virPCIDeviceList *virPCIDeviceListNew(void);
+int virPCIDeviceListAdd(virPCIDeviceList *list,
+ virPCIDevice *dev);
+int virPCIDeviceListAddCopy(virPCIDeviceList *list, virPCIDevice *dev);
+virPCIDevice *virPCIDeviceListGet(virPCIDeviceList *list,
int idx);
-size_t virPCIDeviceListCount(virPCIDeviceListPtr list);
-virPCIDevicePtr virPCIDeviceListSteal(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr);
-virPCIDevicePtr virPCIDeviceListStealIndex(virPCIDeviceListPtr list,
+size_t virPCIDeviceListCount(virPCIDeviceList *list);
+virPCIDevice *virPCIDeviceListSteal(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr);
+virPCIDevice *virPCIDeviceListStealIndex(virPCIDeviceList *list,
int idx);
-void virPCIDeviceListDel(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr);
-virPCIDevicePtr virPCIDeviceListFind(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr);
-virPCIDevicePtr
-virPCIDeviceListFindByIDs(virPCIDeviceListPtr list,
+void virPCIDeviceListDel(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr);
+virPCIDevice *virPCIDeviceListFind(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr);
+virPCIDevice *
+virPCIDeviceListFindByIDs(virPCIDeviceList *list,
unsigned int domain,
unsigned int bus,
unsigned int slot,
unsigned int function);
-int virPCIDeviceListFindIndex(virPCIDeviceListPtr list,
- virPCIDeviceAddressPtr devAddr);
+int virPCIDeviceListFindIndex(virPCIDeviceList *list,
+ virPCIDeviceAddress *devAddr);
/*
* Callback that will be invoked once for each file
* Should return 0 if successfully processed, or
* -1 to indicate error and abort iteration
*/
-typedef int (*virPCIDeviceFileActor)(virPCIDevicePtr dev,
+typedef int (*virPCIDeviceFileActor)(virPCIDevice *dev,
const char *path, void *opaque);
-int virPCIDeviceFileIterate(virPCIDevicePtr dev,
+int virPCIDeviceFileIterate(virPCIDevice *dev,
virPCIDeviceFileActor actor,
void *opaque);
-typedef int (*virPCIDeviceAddressActor)(virPCIDeviceAddressPtr addr,
+typedef int (*virPCIDeviceAddressActor)(virPCIDeviceAddress *addr,
void *opaque);
-int virPCIDeviceAddressIOMMUGroupIterate(virPCIDeviceAddressPtr orig,
+int virPCIDeviceAddressIOMMUGroupIterate(virPCIDeviceAddress *orig,
virPCIDeviceAddressActor actor,
void *opaque);
-virPCIDeviceListPtr virPCIDeviceGetIOMMUGroupList(virPCIDevicePtr dev);
-int virPCIDeviceAddressGetIOMMUGroupAddresses(virPCIDeviceAddressPtr devAddr,
- virPCIDeviceAddressPtr **iommuGroupDevices,
+virPCIDeviceList *virPCIDeviceGetIOMMUGroupList(virPCIDevice *dev);
+int virPCIDeviceAddressGetIOMMUGroupAddresses(virPCIDeviceAddress *devAddr,
+ virPCIDeviceAddress ***iommuGroupDevices,
size_t *nIommuGroupDevices);
-int virPCIDeviceAddressGetIOMMUGroupNum(virPCIDeviceAddressPtr addr);
+int virPCIDeviceAddressGetIOMMUGroupNum(virPCIDeviceAddress *addr);
char *virPCIDeviceAddressGetIOMMUGroupDev(const virPCIDeviceAddress *devAddr);
bool virPCIDeviceExists(const virPCIDeviceAddress *addr);
-char *virPCIDeviceGetIOMMUGroupDev(virPCIDevicePtr dev);
+char *virPCIDeviceGetIOMMUGroupDev(virPCIDevice *dev);
-int virPCIDeviceIsAssignable(virPCIDevicePtr dev,
+int virPCIDeviceIsAssignable(virPCIDevice *dev,
int strict_acs_check);
-virPCIDeviceAddressPtr
+virPCIDeviceAddress *
virPCIGetDeviceAddressFromSysfsLink(const char *device_link);
int virPCIGetPhysicalFunction(const char *vf_sysfs_path,
- virPCIDeviceAddressPtr *pf);
+ virPCIDeviceAddress **pf);
int virPCIGetVirtualFunctions(const char *sysfs_path,
- virPCIDeviceAddressPtr **virtual_functions,
+ virPCIDeviceAddress ***virtual_functions,
size_t *num_virtual_functions,
unsigned int *max_virtual_functions);
const char *vf_sysfs_device_link,
int *vf_index);
-int virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr addr,
+int virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddress *addr,
char **pci_sysfs_device_link);
int virPCIGetNetName(const char *device_link_sysfs_path,
char *physPortID,
char **netname);
-bool virPCIDeviceAddressIsValid(virPCIDeviceAddressPtr addr,
+bool virPCIDeviceAddressIsValid(virPCIDeviceAddress *addr,
bool report);
bool virPCIDeviceAddressIsEmpty(const virPCIDeviceAddress *addr);
bool virPCIDeviceAddressEqual(const virPCIDeviceAddress *addr1,
const virPCIDeviceAddress *addr2);
-void virPCIDeviceAddressCopy(virPCIDeviceAddressPtr dst,
+void virPCIDeviceAddressCopy(virPCIDeviceAddress *dst,
const virPCIDeviceAddress *src);
char *virPCIDeviceAddressAsString(const virPCIDeviceAddress *addr)
ATTRIBUTE_NONNULL(1);
-int virPCIDeviceAddressParse(char *address, virPCIDeviceAddressPtr bdf);
+int virPCIDeviceAddressParse(char *address, virPCIDeviceAddress *bdf);
bool virZPCIDeviceAddressIsIncomplete(const virZPCIDeviceAddress *addr);
bool virZPCIDeviceAddressIsPresent(const virZPCIDeviceAddress *addr);
char **pfname,
int *vf_index);
-int virPCIDeviceUnbind(virPCIDevicePtr dev);
-int virPCIDeviceRebind(virPCIDevicePtr dev);
-int virPCIDeviceGetDriverPathAndName(virPCIDevicePtr dev,
+int virPCIDeviceUnbind(virPCIDevice *dev);
+int virPCIDeviceRebind(virPCIDevice *dev);
+int virPCIDeviceGetDriverPathAndName(virPCIDevice *dev,
char **path,
char **name);
-int virPCIDeviceIsPCIExpress(virPCIDevicePtr dev);
-int virPCIDeviceHasPCIExpressLink(virPCIDevicePtr dev);
-int virPCIDeviceGetLinkCapSta(virPCIDevicePtr dev,
+int virPCIDeviceIsPCIExpress(virPCIDevice *dev);
+int virPCIDeviceHasPCIExpressLink(virPCIDevice *dev);
+int virPCIDeviceGetLinkCapSta(virPCIDevice *dev,
int *ca_port,
unsigned int *cap_speed,
unsigned int *cap_width,
unsigned int *sta_speed,
unsigned int *sta_width);
-int virPCIGetHeaderType(virPCIDevicePtr dev, int *hdrType);
+int virPCIGetHeaderType(virPCIDevice *dev, int *hdrType);
-void virPCIEDeviceInfoFree(virPCIEDeviceInfoPtr dev);
+void virPCIEDeviceInfoFree(virPCIEDeviceInfo *dev);
-void virPCIDeviceAddressFree(virPCIDeviceAddressPtr address);
+void virPCIDeviceAddressFree(virPCIDeviceAddress *address);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virPCIDevice, virPCIDeviceFree);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virPCIDeviceAddress, virPCIDeviceAddressFree);
} cmt;
} efields;
};
-typedef struct virPerfEvent *virPerfEventPtr;
struct _virPerf {
struct virPerfEvent events[VIR_PERF_EVENT_LAST];
},
};
G_STATIC_ASSERT(G_N_ELEMENTS(attrs) == VIR_PERF_EVENT_LAST);
-typedef struct virPerfEventAttr *virPerfEventAttrPtr;
static int
int
-virPerfEventEnable(virPerfPtr perf,
+virPerfEventEnable(virPerf *perf,
virPerfEventType type,
pid_t pid)
{
struct perf_event_attr attr;
- virPerfEventPtr event = &(perf->events[type]);
- virPerfEventAttrPtr event_attr = &attrs[type];
+ struct virPerfEvent *event = &(perf->events[type]);
+ struct virPerfEventAttr *event_attr = &attrs[type];
if (event->enabled)
return 0;
}
int
-virPerfEventDisable(virPerfPtr perf,
+virPerfEventDisable(virPerf *perf,
virPerfEventType type)
{
- virPerfEventPtr event = &(perf->events[type]);
+ struct virPerfEvent *event = &(perf->events[type]);
if (!event->enabled)
return 0;
return 0;
}
-bool virPerfEventIsEnabled(virPerfPtr perf,
+bool virPerfEventIsEnabled(virPerf *perf,
virPerfEventType type)
{
return perf && perf->events[type].enabled;
}
int
-virPerfReadEvent(virPerfPtr perf,
+virPerfReadEvent(virPerf *perf,
virPerfEventType type,
uint64_t *value)
{
- virPerfEventPtr event = &perf->events[type];
+ struct virPerfEvent *event = &perf->events[type];
if (!event->enabled)
return -1;
int
-virPerfEventEnable(virPerfPtr perf G_GNUC_UNUSED,
+virPerfEventEnable(virPerf *perf G_GNUC_UNUSED,
virPerfEventType type G_GNUC_UNUSED,
pid_t pid G_GNUC_UNUSED)
{
}
int
-virPerfEventDisable(virPerfPtr perf G_GNUC_UNUSED,
+virPerfEventDisable(virPerf *perf G_GNUC_UNUSED,
virPerfEventType type G_GNUC_UNUSED)
{
virReportSystemError(ENXIO, "%s",
}
bool
-virPerfEventIsEnabled(virPerfPtr perf G_GNUC_UNUSED,
+virPerfEventIsEnabled(virPerf *perf G_GNUC_UNUSED,
virPerfEventType type G_GNUC_UNUSED)
{
return false;
}
int
-virPerfReadEvent(virPerfPtr perf G_GNUC_UNUSED,
+virPerfReadEvent(virPerf *perf G_GNUC_UNUSED,
virPerfEventType type G_GNUC_UNUSED,
uint64_t *value G_GNUC_UNUSED)
{
#endif
-virPerfPtr
+virPerf *
virPerfNew(void)
{
size_t i;
- virPerfPtr perf;
+ virPerf *perf;
perf = g_new0(virPerf, 1);
}
void
-virPerfFree(virPerfPtr perf)
+virPerfFree(virPerf *perf)
{
size_t i;
struct _virPerf;
typedef struct _virPerf virPerf;
-typedef virPerf *virPerfPtr;
-virPerfPtr virPerfNew(void);
+virPerf *virPerfNew(void);
-void virPerfFree(virPerfPtr perf);
+void virPerfFree(virPerf *perf);
-int virPerfEventEnable(virPerfPtr perf,
+int virPerfEventEnable(virPerf *perf,
virPerfEventType type,
pid_t pid);
-int virPerfEventDisable(virPerfPtr perf,
+int virPerfEventDisable(virPerf *perf,
virPerfEventType type);
-bool virPerfEventIsEnabled(virPerfPtr perf,
+bool virPerfEventIsEnabled(virPerf *perf,
virPerfEventType type);
-int virPerfReadEvent(virPerfPtr perf,
+int virPerfReadEvent(virPerf *perf,
virPerfEventType type,
uint64_t *value);
# include <poll.h>
struct _virPolkitAgent {
- virCommandPtr cmd;
+ virCommand *cmd;
};
/*
/* virPolkitAgentDestroy:
- * @cmd: Pointer to the virCommandPtr created during virPolkitAgentCreate
+ * @cmd: Pointer to the virCommand * created during virPolkitAgentCreate
*
* Destroy resources used by Polkit Agent
*/
void
-virPolkitAgentDestroy(virPolkitAgentPtr agent)
+virPolkitAgentDestroy(virPolkitAgent *agent)
{
if (!agent)
return;
*
* Allocate and setup a polkit agent
*
- * Returns a virCommandPtr on success and NULL on failure
+ * Returns a virCommand *on success and NULL on failure
*/
-virPolkitAgentPtr
+virPolkitAgent *
virPolkitAgentCreate(void)
{
- virPolkitAgentPtr agent = NULL;
+ virPolkitAgent *agent = NULL;
int pipe_fd[2] = {-1, -1};
struct pollfd pollfd;
int outfd = STDOUT_FILENO;
void
-virPolkitAgentDestroy(virPolkitAgentPtr agent G_GNUC_UNUSED)
+virPolkitAgentDestroy(virPolkitAgent *agent G_GNUC_UNUSED)
{
return; /* do nothing */
}
-virPolkitAgentPtr
+virPolkitAgent *
virPolkitAgentCreate(void)
{
virReportError(VIR_ERR_AUTH_FAILED, "%s",
bool allowInteraction);
typedef struct _virPolkitAgent virPolkitAgent;
-typedef virPolkitAgent *virPolkitAgentPtr;
-void virPolkitAgentDestroy(virPolkitAgentPtr cmd);
-virPolkitAgentPtr virPolkitAgentCreate(void);
+void virPolkitAgentDestroy(virPolkitAgent *cmd);
+virPolkitAgent *virPolkitAgentCreate(void);
#define VIR_PORT_ALLOCATOR_NUM_PORTS 65536
typedef struct _virPortAllocator virPortAllocator;
-typedef virPortAllocator *virPortAllocatorPtr;
struct _virPortAllocator {
virObjectLockable parent;
- virBitmapPtr bitmap;
+ virBitmap *bitmap;
};
struct _virPortAllocatorRange {
unsigned short end;
};
-static virClassPtr virPortAllocatorClass;
-static virPortAllocatorPtr virPortAllocatorInstance;
+static virClass *virPortAllocatorClass;
+static virPortAllocator *virPortAllocatorInstance;
static void
virPortAllocatorDispose(void *obj)
{
- virPortAllocatorPtr pa = obj;
+ virPortAllocator *pa = obj;
virBitmapFree(pa->bitmap);
}
-static virPortAllocatorPtr
+static virPortAllocator *
virPortAllocatorNew(void)
{
- virPortAllocatorPtr pa;
+ virPortAllocator *pa;
if (!(pa = virObjectLockableNew(virPortAllocatorClass)))
return NULL;
VIR_ONCE_GLOBAL_INIT(virPortAllocator);
-virPortAllocatorRangePtr
+virPortAllocatorRange *
virPortAllocatorRangeNew(const char *name,
unsigned short start,
unsigned short end)
{
- virPortAllocatorRangePtr range;
+ virPortAllocatorRange *range;
if (start >= end) {
virReportInvalidArg(start, "start port %d must be less than end port %d",
}
void
-virPortAllocatorRangeFree(virPortAllocatorRangePtr range)
+virPortAllocatorRangeFree(virPortAllocatorRange *range)
{
if (!range)
return;
return ret;
}
-static virPortAllocatorPtr
+static virPortAllocator *
virPortAllocatorGet(void)
{
if (virPortAllocatorInitialize() < 0)
{
int ret = -1;
size_t i;
- virPortAllocatorPtr pa = virPortAllocatorGet();
+ virPortAllocator *pa = virPortAllocatorGet();
*port = 0;
virPortAllocatorRelease(unsigned short port)
{
int ret = -1;
- virPortAllocatorPtr pa = virPortAllocatorGet();
+ virPortAllocator *pa = virPortAllocatorGet();
if (!pa)
return -1;
virPortAllocatorSetUsed(unsigned short port)
{
int ret = -1;
- virPortAllocatorPtr pa = virPortAllocatorGet();
+ virPortAllocator *pa = virPortAllocatorGet();
if (!pa)
return -1;
#include "virobject.h"
typedef struct _virPortAllocatorRange virPortAllocatorRange;
-typedef virPortAllocatorRange *virPortAllocatorRangePtr;
-virPortAllocatorRangePtr
+virPortAllocatorRange *
virPortAllocatorRangeNew(const char *name,
unsigned short start,
unsigned short end);
-void virPortAllocatorRangeFree(virPortAllocatorRangePtr range);
+void virPortAllocatorRangeFree(virPortAllocatorRange *range);
int virPortAllocatorAcquire(const virPortAllocatorRange *range,
unsigned short *port);
#if WITH_SCHED_GETAFFINITY
-int virProcessSetAffinity(pid_t pid, virBitmapPtr map, bool quiet)
+int virProcessSetAffinity(pid_t pid, virBitmap *map, bool quiet)
{
size_t i;
int numcpus = 1024;
return 0;
}
-virBitmapPtr
+virBitmap *
virProcessGetAffinity(pid_t pid)
{
size_t i;
cpu_set_t *mask;
size_t masklen;
size_t ncpus;
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
/* 262144 cpus ought to be enough for anyone */
ncpus = 1024 << 8;
#elif defined(WITH_BSD_CPU_AFFINITY)
int virProcessSetAffinity(pid_t pid,
- virBitmapPtr map,
+ virBitmap *map,
bool quiet)
{
size_t i;
return 0;
}
-virBitmapPtr
+virBitmap *
virProcessGetAffinity(pid_t pid)
{
size_t i;
cpuset_t mask;
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
CPU_ZERO(&mask);
if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, pid,
#else /* WITH_SCHED_GETAFFINITY */
int virProcessSetAffinity(pid_t pid G_GNUC_UNUSED,
- virBitmapPtr map G_GNUC_UNUSED,
+ virBitmap *map G_GNUC_UNUSED,
bool quiet G_GNUC_UNUSED)
{
/* The @quiet parameter is ignored here, it is used only for silencing
return -1;
}
-virBitmapPtr
+virBitmap *
virProcessGetAffinity(pid_t pid G_GNUC_UNUSED)
{
virReportSystemError(ENOSYS, "%s",
bool force,
unsigned int extradelay);
-int virProcessSetAffinity(pid_t pid, virBitmapPtr map, bool quiet);
+int virProcessSetAffinity(pid_t pid, virBitmap *map, bool quiet);
-virBitmapPtr virProcessGetAffinity(pid_t pid);
+virBitmap *virProcessGetAffinity(pid_t pid);
int virProcessGetPids(pid_t pid, size_t *npids, pid_t **pids);
struct virQEMUCommandLineJSONIteratorData {
const char *prefix;
- virBufferPtr buf;
+ virBuffer *buf;
const char *skipKey;
virQEMUBuildCommandLineJSONArrayFormatFunc arrayFunc;
};
static int
virQEMUBuildCommandLineJSONRecurse(const char *key,
- virJSONValuePtr value,
- virBufferPtr buf,
+ virJSONValue *value,
+ virBuffer *buf,
const char *skipKey,
virQEMUBuildCommandLineJSONArrayFormatFunc arrayFunc,
bool nested);
int
virQEMUBuildCommandLineJSONArrayBitmap(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey G_GNUC_UNUSED)
{
ssize_t pos = -1;
int
virQEMUBuildCommandLineJSONArrayNumbered(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey)
{
- virJSONValuePtr member;
+ virJSONValue *member;
size_t i;
for (i = 0; i < virJSONValueArraySize(array); i++) {
g_autofree char *prefix = NULL;
- member = virJSONValueArrayGet((virJSONValuePtr) array, i);
+ member = virJSONValueArrayGet((virJSONValue *) array, i);
prefix = g_strdup_printf("%s.%zu", key, i);
if (virQEMUBuildCommandLineJSONRecurse(prefix, member, buf, skipKey,
*/
static int
virQEMUBuildCommandLineJSONArrayObjectsStr(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey G_GNUC_UNUSED)
{
g_auto(virBuffer) tmp = VIR_BUFFER_INITIALIZER;
size_t i;
for (i = 0; i < virJSONValueArraySize(array); i++) {
- virJSONValuePtr member = virJSONValueArrayGet(array, i);
+ virJSONValue *member = virJSONValueArrayGet(array, i);
const char *str = virJSONValueObjectGetString(member, "str");
if (!str)
/* internal iterator to handle nested object formatting */
static int
virQEMUBuildCommandLineJSONIterate(const char *key,
- virJSONValuePtr value,
+ virJSONValue *value,
void *opaque)
{
struct virQEMUCommandLineJSONIteratorData *data = opaque;
static int
virQEMUBuildCommandLineJSONRecurse(const char *key,
- virJSONValuePtr value,
- virBufferPtr buf,
+ virJSONValue *value,
+ virBuffer *buf,
const char *skipKey,
virQEMUBuildCommandLineJSONArrayFormatFunc arrayFunc,
bool nested)
{
struct virQEMUCommandLineJSONIteratorData data = { key, buf, skipKey, arrayFunc };
virJSONType type = virJSONValueGetType(value);
- virJSONValuePtr elem;
+ virJSONValue *elem;
bool tmp;
size_t i;
/* fallback, treat the array as a non-bitmap, adding the key
* for each member */
for (i = 0; i < virJSONValueArraySize(value); i++) {
- elem = virJSONValueArrayGet((virJSONValuePtr)value, i);
+ elem = virJSONValueArrayGet((virJSONValue *)value, i);
/* recurse to avoid duplicating code */
if (virQEMUBuildCommandLineJSONRecurse(key, elem, buf, skipKey,
* Returns 0 on success -1 on error.
*/
int
-virQEMUBuildCommandLineJSON(virJSONValuePtr value,
- virBufferPtr buf,
+virQEMUBuildCommandLineJSON(virJSONValue *value,
+ virBuffer *buf,
const char *skipKey,
virQEMUBuildCommandLineJSONArrayFormatFunc array)
{
* @rawjson is meant for testing of the schema in the xml2argvtest
*/
char *
-virQEMUBuildNetdevCommandlineFromJSON(virJSONValuePtr props,
+virQEMUBuildNetdevCommandlineFromJSON(virJSONValue *props,
bool rawjson)
{
const char *type = virJSONValueObjectGetString(props, "type");
char *
-virQEMUBuildDriveCommandlineFromJSON(virJSONValuePtr srcdef)
+virQEMUBuildDriveCommandlineFromJSON(virJSONValue *srcdef)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
* a ',' must escape it using an extra ',' as the escape character
*/
void
-virQEMUBuildBufferEscapeComma(virBufferPtr buf, const char *str)
+virQEMUBuildBufferEscapeComma(virBuffer *buf, const char *str)
{
virBufferEscape(buf, ',', ",", "%s", str);
}
#include "virjson.h"
typedef int (*virQEMUBuildCommandLineJSONArrayFormatFunc)(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey);
int virQEMUBuildCommandLineJSONArrayBitmap(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey);
int virQEMUBuildCommandLineJSONArrayNumbered(const char *key,
- virJSONValuePtr array,
- virBufferPtr buf,
+ virJSONValue *array,
+ virBuffer *buf,
const char *skipKey);
-int virQEMUBuildCommandLineJSON(virJSONValuePtr value,
- virBufferPtr buf,
+int virQEMUBuildCommandLineJSON(virJSONValue *value,
+ virBuffer *buf,
const char *skipKey,
virQEMUBuildCommandLineJSONArrayFormatFunc array);
char *
-virQEMUBuildNetdevCommandlineFromJSON(virJSONValuePtr props,
+virQEMUBuildNetdevCommandlineFromJSON(virJSONValue *props,
bool rawjson);
-char *virQEMUBuildDriveCommandlineFromJSON(virJSONValuePtr src);
+char *virQEMUBuildDriveCommandlineFromJSON(virJSONValue *src);
-void virQEMUBuildBufferEscapeComma(virBufferPtr buf, const char *str);
+void virQEMUBuildBufferEscapeComma(virBuffer *buf, const char *str);
* structs can be included in one or another without reorganizing the code every
* time. */
typedef struct _virResctrlInfoPerType virResctrlInfoPerType;
-typedef virResctrlInfoPerType *virResctrlInfoPerTypePtr;
typedef struct _virResctrlInfoPerLevel virResctrlInfoPerLevel;
-typedef virResctrlInfoPerLevel *virResctrlInfoPerLevelPtr;
typedef struct _virResctrlInfoMemBW virResctrlInfoMemBW;
-typedef virResctrlInfoMemBW *virResctrlInfoMemBWPtr;
typedef struct _virResctrlInfoMongrp virResctrlInfoMongrp;
-typedef virResctrlInfoMongrp *virResctrlInfoMongrpPtr;
typedef struct _virResctrlAllocPerType virResctrlAllocPerType;
-typedef virResctrlAllocPerType *virResctrlAllocPerTypePtr;
typedef struct _virResctrlAllocPerLevel virResctrlAllocPerLevel;
-typedef virResctrlAllocPerLevel *virResctrlAllocPerLevelPtr;
typedef struct _virResctrlAllocMemBW virResctrlAllocMemBW;
-typedef virResctrlAllocMemBW *virResctrlAllocMemBWPtr;
/* Class definitions and initializations */
-static virClassPtr virResctrlInfoClass;
-static virClassPtr virResctrlAllocClass;
-static virClassPtr virResctrlMonitorClass;
+static virClass *virResctrlInfoClass;
+static virClass *virResctrlAllocClass;
+static virClass *virResctrlMonitorClass;
/* virResctrlInfo */
};
struct _virResctrlInfoPerLevel {
- virResctrlInfoPerTypePtr *types;
+ virResctrlInfoPerType **types;
};
/* Information about memory bandwidth allocation */
struct _virResctrlInfo {
virObject parent;
- virResctrlInfoPerLevelPtr *levels;
+ virResctrlInfoPerLevel **levels;
size_t nlevels;
- virResctrlInfoMemBWPtr membw_info;
+ virResctrlInfoMemBW *membw_info;
- virResctrlInfoMongrpPtr monitor_info;
+ virResctrlInfoMongrp *monitor_info;
};
size_t i = 0;
size_t j = 0;
- virResctrlInfoPtr resctrl = obj;
+ virResctrlInfo *resctrl = obj;
for (i = 0; i < resctrl->nlevels; i++) {
- virResctrlInfoPerLevelPtr level = resctrl->levels[i];
+ virResctrlInfoPerLevel *level = resctrl->levels[i];
if (!level)
continue;
void
-virResctrlInfoMonFree(virResctrlInfoMonPtr mon)
+virResctrlInfoMonFree(virResctrlInfoMon *mon)
{
if (!mon)
return;
size_t nsizes;
/* Mask for each cache */
- virBitmapPtr *masks;
+ virBitmap **masks;
size_t nmasks;
};
struct _virResctrlAllocPerLevel {
- virResctrlAllocPerTypePtr *types; /* Indexed with enum virCacheType */
+ virResctrlAllocPerType **types; /* Indexed with enum virCacheType */
/* There is no `ntypes` member variable as it is always allocated for
* VIR_CACHE_TYPE_LAST number of items */
};
struct _virResctrlAlloc {
virObject parent;
- virResctrlAllocPerLevelPtr *levels;
+ virResctrlAllocPerLevel **levels;
size_t nlevels;
- virResctrlAllocMemBWPtr mem_bw;
+ virResctrlAllocMemBW *mem_bw;
/* The identifier (any unique string for now) */
char *id;
* specific allocation defined under the root directory.
* This pointer points to the allocation this monitor is associated with.
*/
- virResctrlAllocPtr alloc;
+ virResctrlAlloc *alloc;
/* The monitor identifier. For a monitor has the same @path name as its
* @alloc, the @id will be set to the same value as it is in @alloc->id.
*/
size_t j = 0;
size_t k = 0;
- virResctrlAllocPtr alloc = obj;
+ virResctrlAlloc *alloc = obj;
for (i = 0; i < alloc->nlevels; i++) {
- virResctrlAllocPerLevelPtr level = alloc->levels[i];
+ virResctrlAllocPerLevel *level = alloc->levels[i];
if (!level)
continue;
for (j = 0; j < VIR_CACHE_TYPE_LAST; j++) {
- virResctrlAllocPerTypePtr type = level->types[j];
+ virResctrlAllocPerType *type = level->types[j];
if (!type)
continue;
}
if (alloc->mem_bw) {
- virResctrlAllocMemBWPtr mem_bw = alloc->mem_bw;
+ virResctrlAllocMemBW *mem_bw = alloc->mem_bw;
for (i = 0; i < mem_bw->nbandwidths; i++)
g_free(mem_bw->bandwidths[i]);
g_free(alloc->mem_bw->bandwidths);
static void
virResctrlMonitorDispose(void *obj)
{
- virResctrlMonitorPtr monitor = obj;
+ virResctrlMonitor *monitor = obj;
virObjectUnref(monitor->alloc);
g_free(monitor->id);
/* virResctrlInfo-related definitions */
static int
-virResctrlGetCacheInfo(virResctrlInfoPtr resctrl,
+virResctrlGetCacheInfo(virResctrlInfo *resctrl,
DIR *dirp)
{
int rv = -1;
char *endptr = NULL;
int type = 0;
unsigned int level = 0;
- virResctrlInfoPerLevelPtr i_level = NULL;
- g_autofree virResctrlInfoPerTypePtr i_type = NULL;
+ virResctrlInfoPerLevel *i_level = NULL;
+ g_autofree virResctrlInfoPerType *i_type = NULL;
VIR_DEBUG("Parsing info type '%s'", ent->d_name);
if (ent->d_name[0] != 'L')
level - resctrl->nlevels + 1);
if (!resctrl->levels[level]) {
- virResctrlInfoPerTypePtr *types = NULL;
+ virResctrlInfoPerType **types = NULL;
- types = g_new0(virResctrlInfoPerTypePtr, VIR_CACHE_TYPE_LAST);
+ types = g_new0(virResctrlInfoPerType *, VIR_CACHE_TYPE_LAST);
resctrl->levels[level] = g_new0(virResctrlInfoPerLevel, 1);
resctrl->levels[level]->types = types;
static int
-virResctrlGetMemoryBandwidthInfo(virResctrlInfoPtr resctrl)
+virResctrlGetMemoryBandwidthInfo(virResctrlInfo *resctrl)
{
int rv = -1;
- g_autofree virResctrlInfoMemBWPtr i_membw = NULL;
+ g_autofree virResctrlInfoMemBW *i_membw = NULL;
/* query memory bandwidth allocation info */
i_membw = g_new0(virResctrlInfoMemBW, 1);
* @resctrl->monitor_info empty if not supported.
*/
static int
-virResctrlGetMonitorInfo(virResctrlInfoPtr resctrl)
+virResctrlGetMonitorInfo(virResctrlInfo *resctrl)
{
int rv = -1;
g_autofree char *featurestr = NULL;
- g_autofree virResctrlInfoMongrpPtr info_monitor = NULL;
+ g_autofree virResctrlInfoMongrp *info_monitor = NULL;
info_monitor = g_new0(virResctrlInfoMongrp, 1);
static int
-virResctrlGetInfo(virResctrlInfoPtr resctrl)
+virResctrlGetInfo(virResctrlInfo *resctrl)
{
g_autoptr(DIR) dirp = NULL;
int ret = -1;
}
-virResctrlInfoPtr
+virResctrlInfo *
virResctrlInfoNew(void)
{
- virResctrlInfoPtr ret = NULL;
+ virResctrlInfo *ret = NULL;
if (virResctrlInitialize() < 0)
return NULL;
static bool
-virResctrlInfoIsEmpty(virResctrlInfoPtr resctrl)
+virResctrlInfoIsEmpty(virResctrlInfo *resctrl)
{
size_t i = 0;
size_t j = 0;
return false;
for (i = 0; i < resctrl->nlevels; i++) {
- virResctrlInfoPerLevelPtr i_level = resctrl->levels[i];
+ virResctrlInfoPerLevel *i_level = resctrl->levels[i];
if (!i_level)
continue;
int
-virResctrlInfoGetMemoryBandwidth(virResctrlInfoPtr resctrl,
+virResctrlInfoGetMemoryBandwidth(virResctrlInfo *resctrl,
unsigned int level,
- virResctrlInfoMemBWPerNodePtr control)
+ virResctrlInfoMemBWPerNode *control)
{
- virResctrlInfoMemBWPtr membw_info = resctrl->membw_info;
+ virResctrlInfoMemBW *membw_info = resctrl->membw_info;
if (!membw_info)
return 0;
int
-virResctrlInfoGetCache(virResctrlInfoPtr resctrl,
+virResctrlInfoGetCache(virResctrlInfo *resctrl,
unsigned int level,
unsigned long long size,
size_t *ncontrols,
- virResctrlInfoPerCachePtr **controls)
+ virResctrlInfoPerCache ***controls)
{
- virResctrlInfoPerLevelPtr i_level = NULL;
- virResctrlInfoPerTypePtr i_type = NULL;
+ virResctrlInfoPerLevel *i_level = NULL;
+ virResctrlInfoPerType *i_type = NULL;
size_t i = 0;
if (virResctrlInfoIsEmpty(resctrl))
* cache. This number of memory bandwidth controller is same with
* last level cache */
if (resctrl->membw_info) {
- virResctrlInfoMemBWPtr membw_info = resctrl->membw_info;
+ virResctrlInfoMemBW *membw_info = resctrl->membw_info;
if (level > membw_info->last_level_cache) {
membw_info->last_level_cache = level;
* supported by host, -1 on failure with error message set.
*/
int
-virResctrlInfoGetMonitorPrefix(virResctrlInfoPtr resctrl,
+virResctrlInfoGetMonitorPrefix(virResctrlInfo *resctrl,
const char *prefix,
- virResctrlInfoMonPtr *monitor)
+ virResctrlInfoMon **monitor)
{
size_t i = 0;
- virResctrlInfoMongrpPtr mongrp_info = NULL;
- virResctrlInfoMonPtr mon = NULL;
+ virResctrlInfoMongrp *mongrp_info = NULL;
+ virResctrlInfoMon *mon = NULL;
int ret = -1;
if (!prefix) {
/* virResctrlAlloc-related definitions */
-virResctrlAllocPtr
+virResctrlAlloc *
virResctrlAllocNew(void)
{
if (virResctrlInitialize() < 0)
bool
-virResctrlAllocIsEmpty(virResctrlAllocPtr alloc)
+virResctrlAllocIsEmpty(virResctrlAlloc *alloc)
{
size_t i = 0;
size_t j = 0;
return false;
for (i = 0; i < alloc->nlevels; i++) {
- virResctrlAllocPerLevelPtr a_level = alloc->levels[i];
+ virResctrlAllocPerLevel *a_level = alloc->levels[i];
if (!a_level)
continue;
for (j = 0; j < VIR_CACHE_TYPE_LAST; j++) {
- virResctrlAllocPerTypePtr a_type = a_level->types[j];
+ virResctrlAllocPerType *a_type = a_level->types[j];
if (!a_type)
continue;
}
-static virResctrlAllocPerTypePtr
-virResctrlAllocGetType(virResctrlAllocPtr alloc,
+static virResctrlAllocPerType *
+virResctrlAllocGetType(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type)
{
- virResctrlAllocPerLevelPtr a_level = NULL;
+ virResctrlAllocPerLevel *a_level = NULL;
if (alloc->nlevels <= level)
VIR_EXPAND_N(alloc->levels, alloc->nlevels, level - alloc->nlevels + 1);
if (!alloc->levels[level]) {
- virResctrlAllocPerTypePtr *types = NULL;
+ virResctrlAllocPerType **types = NULL;
- types = g_new0(virResctrlAllocPerTypePtr, VIR_CACHE_TYPE_LAST);
+ types = g_new0(virResctrlAllocPerType *, VIR_CACHE_TYPE_LAST);
alloc->levels[level] = g_new0(virResctrlAllocPerLevel, 1);
alloc->levels[level]->types = types;
static int
-virResctrlAllocUpdateMask(virResctrlAllocPtr alloc,
+virResctrlAllocUpdateMask(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
unsigned int cache,
- virBitmapPtr mask)
+ virBitmap *mask)
{
- virResctrlAllocPerTypePtr a_type = virResctrlAllocGetType(alloc, level, type);
+ virResctrlAllocPerType *a_type = virResctrlAllocGetType(alloc, level, type);
if (!a_type)
return -1;
static int
-virResctrlAllocUpdateSize(virResctrlAllocPtr alloc,
+virResctrlAllocUpdateSize(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
unsigned int cache,
unsigned long long size)
{
- virResctrlAllocPerTypePtr a_type = virResctrlAllocGetType(alloc, level, type);
+ virResctrlAllocPerType *a_type = virResctrlAllocGetType(alloc, level, type);
if (!a_type)
return -1;
* the way.
*/
static bool
-virResctrlAllocCheckCollision(virResctrlAllocPtr alloc,
+virResctrlAllocCheckCollision(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
unsigned int cache)
{
- virResctrlAllocPerLevelPtr a_level = NULL;
- virResctrlAllocPerTypePtr a_type = NULL;
+ virResctrlAllocPerLevel *a_level = NULL;
+ virResctrlAllocPerType *a_type = NULL;
if (!alloc)
return false;
int
-virResctrlAllocSetCacheSize(virResctrlAllocPtr alloc,
+virResctrlAllocSetCacheSize(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
unsigned int cache,
int
-virResctrlAllocForeachCache(virResctrlAllocPtr alloc,
+virResctrlAllocForeachCache(virResctrlAlloc *alloc,
virResctrlAllocForeachCacheCallback cb,
void *opaque)
{
return 0;
for (level = 0; level < alloc->nlevels; level++) {
- virResctrlAllocPerLevelPtr a_level = alloc->levels[level];
+ virResctrlAllocPerLevel *a_level = alloc->levels[level];
if (!a_level)
continue;
for (type = 0; type < VIR_CACHE_TYPE_LAST; type++) {
- virResctrlAllocPerTypePtr a_type = a_level->types[type];
+ virResctrlAllocPerType *a_type = a_level->types[type];
if (!a_type)
continue;
* Returns 0 on success, -1 on failure with error message set.
*/
int
-virResctrlAllocSetMemoryBandwidth(virResctrlAllocPtr alloc,
+virResctrlAllocSetMemoryBandwidth(virResctrlAlloc *alloc,
unsigned int id,
unsigned int memory_bandwidth)
{
- virResctrlAllocMemBWPtr mem_bw = alloc->mem_bw;
+ virResctrlAllocMemBW *mem_bw = alloc->mem_bw;
if (memory_bandwidth > 100) {
virReportError(VIR_ERR_XML_ERROR, "%s",
* Returns 0 on success, -1 and immediate failure if the @cb has any failure.
*/
int
-virResctrlAllocForeachMemory(virResctrlAllocPtr alloc,
+virResctrlAllocForeachMemory(virResctrlAlloc *alloc,
virResctrlAllocForeachMemoryCallback cb,
void *opaque)
{
size_t i = 0;
- virResctrlAllocMemBWPtr mem_bw;
+ virResctrlAllocMemBW *mem_bw;
if (!alloc || !alloc->mem_bw)
return 0;
int
-virResctrlAllocSetID(virResctrlAllocPtr alloc,
+virResctrlAllocSetID(virResctrlAlloc *alloc,
const char *id)
{
return virResctrlSetID(&alloc->id, id);
const char *
-virResctrlAllocGetID(virResctrlAllocPtr alloc)
+virResctrlAllocGetID(virResctrlAlloc *alloc)
{
return alloc->id;
}
* has 100 percent bandwidth. A trailing semi-colon is not formatted.
*/
static int
-virResctrlAllocMemoryBandwidthFormat(virResctrlAllocPtr alloc,
- virBufferPtr buf)
+virResctrlAllocMemoryBandwidthFormat(virResctrlAlloc *alloc,
+ virBuffer *buf)
{
size_t i;
static int
-virResctrlAllocParseProcessMemoryBandwidth(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocParseProcessMemoryBandwidth(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
char *mem_bw)
{
unsigned int bandwidth;
* virResctrlAllocMemoryBandwidthFormat.
*/
static int
-virResctrlAllocParseMemoryBandwidthLine(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocParseMemoryBandwidthLine(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
char *line)
{
g_auto(GStrv) mbs = NULL;
static int
-virResctrlAllocFormatCache(virResctrlAllocPtr alloc,
- virBufferPtr buf)
+virResctrlAllocFormatCache(virResctrlAlloc *alloc,
+ virBuffer *buf)
{
unsigned int level = 0;
unsigned int type = 0;
unsigned int cache = 0;
for (level = 0; level < alloc->nlevels; level++) {
- virResctrlAllocPerLevelPtr a_level = alloc->levels[level];
+ virResctrlAllocPerLevel *a_level = alloc->levels[level];
if (!a_level)
continue;
for (type = 0; type < VIR_CACHE_TYPE_LAST; type++) {
- virResctrlAllocPerTypePtr a_type = a_level->types[type];
+ virResctrlAllocPerType *a_type = a_level->types[type];
if (!a_type)
continue;
virBufferAsprintf(buf, "L%u%s:", level, virResctrlTypeToString(type));
for (cache = 0; cache < a_type->nmasks; cache++) {
- virBitmapPtr mask = a_type->masks[cache];
+ virBitmap *mask = a_type->masks[cache];
char *mask_str = NULL;
if (!mask)
char *
-virResctrlAllocFormat(virResctrlAllocPtr alloc)
+virResctrlAllocFormat(virResctrlAlloc *alloc)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-virResctrlAllocParseProcessCache(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocParseProcessCache(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
char *cache)
static int
-virResctrlAllocParseCacheLine(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocParseCacheLine(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
char *line)
{
g_auto(GStrv) caches = NULL;
static int
-virResctrlAllocParse(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocParse(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
const char *schemata)
{
g_auto(GStrv) lines = NULL;
static int
-virResctrlAllocGetGroup(virResctrlInfoPtr resctrl,
+virResctrlAllocGetGroup(virResctrlInfo *resctrl,
const char *groupname,
- virResctrlAllocPtr *alloc)
+ virResctrlAlloc **alloc)
{
char *schemata = NULL;
int rv = virFileReadValueString(&schemata,
}
-static virResctrlAllocPtr
-virResctrlAllocGetDefault(virResctrlInfoPtr resctrl)
+static virResctrlAlloc *
+virResctrlAllocGetDefault(virResctrlInfo *resctrl)
{
- virResctrlAllocPtr ret = NULL;
+ virResctrlAlloc *ret = NULL;
int rv = virResctrlAllocGetGroup(resctrl, ".", &ret);
if (rv == -2) {
static void
-virResctrlAllocSubtractPerType(virResctrlAllocPerTypePtr dst,
- virResctrlAllocPerTypePtr src)
+virResctrlAllocSubtractPerType(virResctrlAllocPerType *dst,
+ virResctrlAllocPerType *src)
{
size_t i = 0;
static void
-virResctrlAllocSubtract(virResctrlAllocPtr dst,
- virResctrlAllocPtr src)
+virResctrlAllocSubtract(virResctrlAlloc *dst,
+ virResctrlAlloc *src)
{
size_t i = 0;
size_t j = 0;
}
-static virResctrlAllocPtr
-virResctrlAllocNewFromInfo(virResctrlInfoPtr info)
+static virResctrlAlloc *
+virResctrlAllocNewFromInfo(virResctrlInfo *info)
{
size_t i = 0;
g_autoptr(virResctrlAlloc) ret = virResctrlAllocNew();
return NULL;
for (i = 0; i < info->nlevels; i++) {
- virResctrlInfoPerLevelPtr i_level = info->levels[i];
+ virResctrlInfoPerLevel *i_level = info->levels[i];
size_t j = 0;
if (!i_level)
continue;
for (j = 0; j < VIR_CACHE_TYPE_LAST; j++) {
- virResctrlInfoPerTypePtr i_type = i_level->types[j];
+ virResctrlInfoPerType *i_type = i_level->types[j];
g_autoptr(virBitmap) mask = NULL;
size_t k = 0;
* limiting setting, not an allocating one. The way it works is also vastly
* different from CAT.
*/
-virResctrlAllocPtr
-virResctrlAllocGetUnused(virResctrlInfoPtr resctrl)
+virResctrlAlloc *
+virResctrlAllocGetUnused(virResctrlInfo *resctrl)
{
g_autoptr(virResctrlAlloc) ret = NULL;
g_autoptr(virResctrlAlloc) alloc_default = NULL;
* allocated for @alloc (does not have to exist though).
*/
static int
-virResctrlAllocFindUnused(virResctrlAllocPtr alloc,
- virResctrlInfoPerTypePtr i_type,
- virResctrlAllocPerTypePtr f_type,
+virResctrlAllocFindUnused(virResctrlAlloc *alloc,
+ virResctrlInfoPerType *i_type,
+ virResctrlAllocPerType *f_type,
unsigned int level,
unsigned int type,
unsigned int cache)
{
unsigned long long *size = alloc->levels[level]->types[type]->sizes[cache];
g_autoptr(virBitmap) a_mask = NULL;
- virBitmapPtr f_mask = NULL;
+ virBitmap *f_mask = NULL;
unsigned long long need_bits;
size_t i = 0;
ssize_t pos = -1;
static int
-virResctrlAllocMemoryBandwidth(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc)
+virResctrlAllocMemoryBandwidth(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc)
{
size_t i;
- virResctrlAllocMemBWPtr mem_bw_alloc = alloc->mem_bw;
- virResctrlInfoMemBWPtr mem_bw_info = resctrl->membw_info;
+ virResctrlAllocMemBW *mem_bw_alloc = alloc->mem_bw;
+ virResctrlInfoMemBW *mem_bw_info = resctrl->membw_info;
if (!mem_bw_alloc)
return 0;
static int
-virResctrlAllocCopyMemBW(virResctrlAllocPtr dst,
- virResctrlAllocPtr src)
+virResctrlAllocCopyMemBW(virResctrlAlloc *dst,
+ virResctrlAlloc *src)
{
size_t i = 0;
- virResctrlAllocMemBWPtr dst_bw = NULL;
- virResctrlAllocMemBWPtr src_bw = src->mem_bw;
+ virResctrlAllocMemBW *dst_bw = NULL;
+ virResctrlAllocMemBW *src_bw = src->mem_bw;
if (!src->mem_bw)
return 0;
static int
-virResctrlAllocCopyMasks(virResctrlAllocPtr dst,
- virResctrlAllocPtr src)
+virResctrlAllocCopyMasks(virResctrlAlloc *dst,
+ virResctrlAlloc *src)
{
unsigned int level = 0;
for (level = 0; level < src->nlevels; level++) {
- virResctrlAllocPerLevelPtr s_level = src->levels[level];
+ virResctrlAllocPerLevel *s_level = src->levels[level];
unsigned int type = 0;
if (!s_level)
continue;
for (type = 0; type < VIR_CACHE_TYPE_LAST; type++) {
- virResctrlAllocPerTypePtr s_type = s_level->types[type];
- virResctrlAllocPerTypePtr d_type = NULL;
+ virResctrlAllocPerType *s_type = s_level->types[type];
+ virResctrlAllocPerType *d_type = NULL;
unsigned int cache = 0;
if (!s_type)
return -1;
for (cache = 0; cache < s_type->nmasks; cache++) {
- virBitmapPtr mask = s_type->masks[cache];
+ virBitmap *mask = s_type->masks[cache];
if (mask && virResctrlAllocUpdateMask(dst, level, type, cache, mask) < 0)
return -1;
* every requested allocation effectively transforming `sizes` into `masks`.
*/
static int
-virResctrlAllocAssign(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc)
+virResctrlAllocAssign(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc)
{
unsigned int level = 0;
g_autoptr(virResctrlAlloc) alloc_free = NULL;
return -1;
for (level = 0; level < alloc->nlevels; level++) {
- virResctrlAllocPerLevelPtr a_level = alloc->levels[level];
- virResctrlAllocPerLevelPtr f_level = NULL;
+ virResctrlAllocPerLevel *a_level = alloc->levels[level];
+ virResctrlAllocPerLevel *f_level = NULL;
unsigned int type = 0;
if (!a_level)
}
for (type = 0; type < VIR_CACHE_TYPE_LAST; type++) {
- virResctrlAllocPerTypePtr a_type = a_level->types[type];
- virResctrlAllocPerTypePtr f_type = f_level->types[type];
+ virResctrlAllocPerType *a_type = a_level->types[type];
+ virResctrlAllocPerType *f_type = f_level->types[type];
unsigned int cache = 0;
if (!a_type)
}
for (cache = 0; cache < a_type->nsizes; cache++) {
- virResctrlInfoPerLevelPtr i_level = resctrl->levels[level];
- virResctrlInfoPerTypePtr i_type = i_level->types[type];
+ virResctrlInfoPerLevel *i_level = resctrl->levels[level];
+ virResctrlInfoPerType *i_type = i_level->types[type];
if (virResctrlAllocFindUnused(alloc, i_type, f_type, level, type, cache) < 0)
return -1;
int
-virResctrlAllocDeterminePath(virResctrlAllocPtr alloc,
+virResctrlAllocDeterminePath(virResctrlAlloc *alloc,
const char *machinename)
{
if (alloc->path) {
/* This checks if the directory for the alloc exists. If not it tries to create
* it and apply appropriate alloc settings. */
int
-virResctrlAllocCreate(virResctrlInfoPtr resctrl,
- virResctrlAllocPtr alloc,
+virResctrlAllocCreate(virResctrlInfo *resctrl,
+ virResctrlAlloc *alloc,
const char *machinename)
{
g_autofree char *schemata_path = NULL;
int
-virResctrlAllocAddPID(virResctrlAllocPtr alloc,
+virResctrlAllocAddPID(virResctrlAlloc *alloc,
pid_t pid)
{
/* If the allocation is empty, then it is impossible to add a PID to
int
-virResctrlAllocRemove(virResctrlAllocPtr alloc)
+virResctrlAllocRemove(virResctrlAlloc *alloc)
{
int ret = 0;
/* virResctrlMonitor-related definitions */
-virResctrlMonitorPtr
+virResctrlMonitor *
virResctrlMonitorNew(void)
{
if (virResctrlInitialize() < 0)
* Returns 0 on success, -1 on error.
*/
int
-virResctrlMonitorDeterminePath(virResctrlMonitorPtr monitor,
+virResctrlMonitorDeterminePath(virResctrlMonitor *monitor,
const char *machinename)
{
g_autofree char *parentpath = NULL;
int
-virResctrlMonitorAddPID(virResctrlMonitorPtr monitor,
+virResctrlMonitorAddPID(virResctrlMonitor *monitor,
pid_t pid)
{
return virResctrlAddPID(monitor->path, pid);
int
-virResctrlMonitorCreate(virResctrlMonitorPtr monitor,
+virResctrlMonitorCreate(virResctrlMonitor *monitor,
const char *machinename)
{
int lockfd = -1;
int
-virResctrlMonitorSetID(virResctrlMonitorPtr monitor,
+virResctrlMonitorSetID(virResctrlMonitor *monitor,
const char *id)
{
const char *
-virResctrlMonitorGetID(virResctrlMonitorPtr monitor)
+virResctrlMonitorGetID(virResctrlMonitor *monitor)
{
return monitor->id;
}
void
-virResctrlMonitorSetAlloc(virResctrlMonitorPtr monitor,
- virResctrlAllocPtr alloc)
+virResctrlMonitorSetAlloc(virResctrlMonitor *monitor,
+ virResctrlAlloc *alloc)
{
monitor->alloc = virObjectRef(alloc);
}
int
-virResctrlMonitorRemove(virResctrlMonitorPtr monitor)
+virResctrlMonitorRemove(virResctrlMonitor *monitor)
{
int ret = 0;
virResctrlMonitorStatsSorter(const void *a,
const void *b)
{
- return (*(virResctrlMonitorStatsPtr *)a)->id
- - (*(virResctrlMonitorStatsPtr *)b)->id;
+ return (*(virResctrlMonitorStats **)a)->id
+ - (*(virResctrlMonitorStats **)b)->id;
}
*
* @monitor: The monitor that the statistic data will be retrieved from.
* @resources: A string list for the monitor feature names.
- * @stats: Pointer of of virResctrlMonitorStatsPtr array for holding cache or
+ * @stats: Pointer of of virResctrlMonitorStats * array for holding cache or
* memory bandwidth usage data.
* @nstats: A size_t pointer to hold the returned array length of @stats
*
* Returns 0 on success, -1 on error.
*/
int
-virResctrlMonitorGetStats(virResctrlMonitorPtr monitor,
+virResctrlMonitorGetStats(virResctrlMonitor *monitor,
const char **resources,
- virResctrlMonitorStatsPtr **stats,
+ virResctrlMonitorStats ***stats,
size_t *nstats)
{
int rv = -1;
g_autoptr(DIR) dirp = NULL;
g_autofree char *datapath = NULL;
struct dirent *ent = NULL;
- virResctrlMonitorStatsPtr stat = NULL;
+ virResctrlMonitorStats *stat = NULL;
size_t nresources = g_strv_length((char **) resources);
if (!monitor) {
void
-virResctrlMonitorStatsFree(virResctrlMonitorStatsPtr stat)
+virResctrlMonitorStatsFree(virResctrlMonitorStats *stat)
{
if (!stat)
return;
typedef struct _virResctrlInfoPerCache virResctrlInfoPerCache;
-typedef virResctrlInfoPerCache *virResctrlInfoPerCachePtr;
struct _virResctrlInfoPerCache {
/* Smallest possible increase of the allocation size in bytes */
unsigned long long granularity;
};
typedef struct _virResctrlInfoMemBWPerNode virResctrlInfoMemBWPerNode;
-typedef virResctrlInfoMemBWPerNode *virResctrlInfoMemBWPerNodePtr;
struct _virResctrlInfoMemBWPerNode {
/* Smallest possible increase of the allocation bandwidth in percentage */
unsigned int granularity;
};
typedef struct _virResctrlInfoMon virResctrlInfoMon;
-typedef virResctrlInfoMon *virResctrlInfoMonPtr;
struct _virResctrlInfoMon {
/* Maximum number of simultaneous monitors */
unsigned int max_monitor;
};
typedef struct _virResctrlInfo virResctrlInfo;
-typedef virResctrlInfo *virResctrlInfoPtr;
-virResctrlInfoPtr
+virResctrlInfo *
virResctrlInfoNew(void);
int
-virResctrlInfoGetCache(virResctrlInfoPtr resctrl,
+virResctrlInfoGetCache(virResctrlInfo *resctrl,
unsigned int level,
unsigned long long size,
size_t *ncontrols,
- virResctrlInfoPerCachePtr **controls);
+ virResctrlInfoPerCache ***controls);
int
-virResctrlInfoGetMemoryBandwidth(virResctrlInfoPtr resctrl,
+virResctrlInfoGetMemoryBandwidth(virResctrlInfo *resctrl,
unsigned int level,
- virResctrlInfoMemBWPerNodePtr control);
+ virResctrlInfoMemBWPerNode *control);
/* Alloc-related things */
typedef struct _virResctrlAlloc virResctrlAlloc;
-typedef virResctrlAlloc *virResctrlAllocPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virResctrlAlloc, virObjectUnref);
unsigned int size,
void *opaque);
-virResctrlAllocPtr
+virResctrlAlloc *
virResctrlAllocNew(void);
bool
-virResctrlAllocIsEmpty(virResctrlAllocPtr alloc);
+virResctrlAllocIsEmpty(virResctrlAlloc *alloc);
int
-virResctrlAllocSetCacheSize(virResctrlAllocPtr alloc,
+virResctrlAllocSetCacheSize(virResctrlAlloc *alloc,
unsigned int level,
virCacheType type,
unsigned int cache,
unsigned long long size);
int
-virResctrlAllocForeachCache(virResctrlAllocPtr alloc,
+virResctrlAllocForeachCache(virResctrlAlloc *alloc,
virResctrlAllocForeachCacheCallback cb,
void *opaque);
int
-virResctrlAllocSetMemoryBandwidth(virResctrlAllocPtr alloc,
+virResctrlAllocSetMemoryBandwidth(virResctrlAlloc *alloc,
unsigned int id,
unsigned int memory_bandwidth);
int
-virResctrlAllocForeachMemory(virResctrlAllocPtr alloc,
+virResctrlAllocForeachMemory(virResctrlAlloc *alloc,
virResctrlAllocForeachMemoryCallback cb,
void *opaque);
int
-virResctrlAllocSetID(virResctrlAllocPtr alloc,
+virResctrlAllocSetID(virResctrlAlloc *alloc,
const char *id);
const char *
-virResctrlAllocGetID(virResctrlAllocPtr alloc);
+virResctrlAllocGetID(virResctrlAlloc *alloc);
char *
-virResctrlAllocFormat(virResctrlAllocPtr alloc);
+virResctrlAllocFormat(virResctrlAlloc *alloc);
int
-virResctrlAllocDeterminePath(virResctrlAllocPtr alloc,
+virResctrlAllocDeterminePath(virResctrlAlloc *alloc,
const char *machinename);
int
-virResctrlAllocCreate(virResctrlInfoPtr r_info,
- virResctrlAllocPtr alloc,
+virResctrlAllocCreate(virResctrlInfo *r_info,
+ virResctrlAlloc *alloc,
const char *machinename);
int
-virResctrlAllocAddPID(virResctrlAllocPtr alloc,
+virResctrlAllocAddPID(virResctrlAlloc *alloc,
pid_t pid);
int
-virResctrlAllocRemove(virResctrlAllocPtr alloc);
+virResctrlAllocRemove(virResctrlAlloc *alloc);
void
-virResctrlInfoMonFree(virResctrlInfoMonPtr mon);
+virResctrlInfoMonFree(virResctrlInfoMon *mon);
int
-virResctrlInfoGetMonitorPrefix(virResctrlInfoPtr resctrl,
+virResctrlInfoGetMonitorPrefix(virResctrlInfo *resctrl,
const char *prefix,
- virResctrlInfoMonPtr *monitor);
+ virResctrlInfoMon **monitor);
/* Monitor-related things */
typedef struct _virResctrlMonitor virResctrlMonitor;
-typedef virResctrlMonitor *virResctrlMonitorPtr;
typedef struct _virResctrlMonitorStats virResctrlMonitorStats;
-typedef virResctrlMonitorStats *virResctrlMonitorStatsPtr;
struct _virResctrlMonitorStats {
/* The system assigned cache ID associated with statistical record */
unsigned int id;
size_t nvals;
};
-virResctrlMonitorPtr
+virResctrlMonitor *
virResctrlMonitorNew(void);
int
-virResctrlMonitorDeterminePath(virResctrlMonitorPtr monitor,
+virResctrlMonitorDeterminePath(virResctrlMonitor *monitor,
const char *machinename);
int
-virResctrlMonitorAddPID(virResctrlMonitorPtr monitor,
+virResctrlMonitorAddPID(virResctrlMonitor *monitor,
pid_t pid);
int
-virResctrlMonitorCreate(virResctrlMonitorPtr monitor,
+virResctrlMonitorCreate(virResctrlMonitor *monitor,
const char *machinename);
int
-virResctrlMonitorSetID(virResctrlMonitorPtr monitor,
+virResctrlMonitorSetID(virResctrlMonitor *monitor,
const char *id);
const char *
-virResctrlMonitorGetID(virResctrlMonitorPtr monitor);
+virResctrlMonitorGetID(virResctrlMonitor *monitor);
void
-virResctrlMonitorSetAlloc(virResctrlMonitorPtr monitor,
- virResctrlAllocPtr alloc);
+virResctrlMonitorSetAlloc(virResctrlMonitor *monitor,
+ virResctrlAlloc *alloc);
int
-virResctrlMonitorRemove(virResctrlMonitorPtr monitor);
+virResctrlMonitorRemove(virResctrlMonitor *monitor);
int
-virResctrlMonitorGetStats(virResctrlMonitorPtr monitor,
+virResctrlMonitorGetStats(virResctrlMonitor *monitor,
const char **resources,
- virResctrlMonitorStatsPtr **stats,
+ virResctrlMonitorStats ***stats,
size_t *nstats);
void
-virResctrlMonitorStatsFree(virResctrlMonitorStatsPtr stats);
+virResctrlMonitorStatsFree(virResctrlMonitorStats *stats);
#include "virresctrl.h"
-virResctrlAllocPtr
-virResctrlAllocGetUnused(virResctrlInfoPtr resctrl);
+virResctrlAlloc *
+virResctrlAllocGetUnused(virResctrlInfo *resctrl);
#define VIR_MAX_MAX_BACKUP 32
typedef struct virRotatingFileWriterEntry virRotatingFileWriterEntry;
-typedef virRotatingFileWriterEntry *virRotatingFileWriterEntryPtr;
typedef struct virRotatingFileReaderEntry virRotatingFileReaderEntry;
-typedef virRotatingFileReaderEntry *virRotatingFileReaderEntryPtr;
struct virRotatingFileWriterEntry {
int fd;
struct virRotatingFileWriter {
char *basepath;
- virRotatingFileWriterEntryPtr entry;
+ virRotatingFileWriterEntry *entry;
size_t maxbackup;
mode_t mode;
size_t maxlen;
};
struct virRotatingFileReader {
- virRotatingFileReaderEntryPtr *entries;
+ virRotatingFileReaderEntry **entries;
size_t nentries;
size_t current;
};
static void
-virRotatingFileWriterEntryFree(virRotatingFileWriterEntryPtr entry)
+virRotatingFileWriterEntryFree(virRotatingFileWriterEntry *entry)
{
if (!entry)
return;
static void
-virRotatingFileReaderEntryFree(virRotatingFileReaderEntryPtr entry)
+virRotatingFileReaderEntryFree(virRotatingFileReaderEntry *entry)
{
if (!entry)
return;
}
-static virRotatingFileWriterEntryPtr
+static virRotatingFileWriterEntry *
virRotatingFileWriterEntryNew(const char *path,
mode_t mode)
{
- virRotatingFileWriterEntryPtr entry;
+ virRotatingFileWriterEntry *entry;
struct stat sb;
VIR_DEBUG("Opening %s mode=0%02o", path, mode);
}
-static virRotatingFileReaderEntryPtr
+static virRotatingFileReaderEntry *
virRotatingFileReaderEntryNew(const char *path)
{
- virRotatingFileReaderEntryPtr entry;
+ virRotatingFileReaderEntry *entry;
struct stat sb;
VIR_DEBUG("Opening %s", path);
static int
-virRotatingFileWriterDelete(virRotatingFileWriterPtr file)
+virRotatingFileWriterDelete(virRotatingFileWriter *file)
{
size_t i;
* in order to avoid splitting lines. If @maxlen is
* zero then no rollover will be performed.
*/
-virRotatingFileWriterPtr
+virRotatingFileWriter *
virRotatingFileWriterNew(const char *path,
off_t maxlen,
size_t maxbackup,
bool trunc,
mode_t mode)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
file = g_new0(virRotatingFileWriter, 1);
*
* If @maxbackup is zero the only the newest file will be read.
*/
-virRotatingFileReaderPtr
+virRotatingFileReader *
virRotatingFileReaderNew(const char *path,
size_t maxbackup)
{
- virRotatingFileReaderPtr file;
+ virRotatingFileReader *file;
size_t i;
file = g_new0(virRotatingFileReader, 1);
}
file->nentries = maxbackup + 1;
- file->entries = g_new0(virRotatingFileReaderEntryPtr, file->nentries);
+ file->entries = g_new0(virRotatingFileReaderEntry *, file->nentries);
if (!(file->entries[file->nentries - 1] = virRotatingFileReaderEntryNew(path)))
goto error;
* Return the primary file path
*/
const char *
-virRotatingFileWriterGetPath(virRotatingFileWriterPtr file)
+virRotatingFileWriterGetPath(virRotatingFileWriter *file)
{
return file->basepath;
}
* Return the inode of the file currently being written to
*/
ino_t
-virRotatingFileWriterGetINode(virRotatingFileWriterPtr file)
+virRotatingFileWriterGetINode(virRotatingFileWriter *file)
{
return file->entry->inode;
}
* Return the offset at which data is currently being written
*/
off_t
-virRotatingFileWriterGetOffset(virRotatingFileWriterPtr file)
+virRotatingFileWriterGetOffset(virRotatingFileWriter *file)
{
return file->entry->pos;
}
static int
-virRotatingFileWriterRollover(virRotatingFileWriterPtr file)
+virRotatingFileWriterRollover(virRotatingFileWriter *file)
{
size_t i;
char *nextpath = NULL;
* Returns the number of bytes written, or -1 on error
*/
ssize_t
-virRotatingFileWriterAppend(virRotatingFileWriterPtr file,
+virRotatingFileWriterAppend(virRotatingFileWriter *file,
const char *buf,
size_t len)
{
if (file->maxlen != 0 &&
((file->entry->pos == file->maxlen && len) ||
forceRollover)) {
- virRotatingFileWriterEntryPtr tmp;
+ virRotatingFileWriterEntry *tmp;
VIR_DEBUG("Hit max size %zu on %s (force=%d)",
file->maxlen, file->basepath, forceRollover);
* probably been rotated out of existence
*/
int
-virRotatingFileReaderSeek(virRotatingFileReaderPtr file,
+virRotatingFileReaderSeek(virRotatingFileReader *file,
ino_t inode,
off_t offset)
{
off_t ret;
for (i = 0; i < file->nentries; i++) {
- virRotatingFileReaderEntryPtr entry = file->entries[i];
+ virRotatingFileReaderEntry *entry = file->entries[i];
if (entry->inode != inode ||
entry->fd == -1)
continue;
* Returns: the number of bytes read or -1 on error
*/
ssize_t
-virRotatingFileReaderConsume(virRotatingFileReaderPtr file,
+virRotatingFileReaderConsume(virRotatingFileReader *file,
char *buf,
size_t len)
{
VIR_DEBUG("Consume %p %zu", buf, len);
while (len) {
- virRotatingFileReaderEntryPtr entry;
+ virRotatingFileReaderEntry *entry;
ssize_t got;
if (file->current >= file->nentries)
* Close the current file and release all resources
*/
void
-virRotatingFileWriterFree(virRotatingFileWriterPtr file)
+virRotatingFileWriterFree(virRotatingFileWriter *file)
{
if (!file)
return;
* Close the files and release all resources
*/
void
-virRotatingFileReaderFree(virRotatingFileReaderPtr file)
+virRotatingFileReaderFree(virRotatingFileReader *file)
{
size_t i;
#include "internal.h"
typedef struct virRotatingFileWriter virRotatingFileWriter;
-typedef virRotatingFileWriter *virRotatingFileWriterPtr;
typedef struct virRotatingFileReader virRotatingFileReader;
-typedef virRotatingFileReader *virRotatingFileReaderPtr;
-virRotatingFileWriterPtr virRotatingFileWriterNew(const char *path,
+virRotatingFileWriter *virRotatingFileWriterNew(const char *path,
off_t maxlen,
size_t maxbackup,
bool trunc,
mode_t mode);
-virRotatingFileReaderPtr virRotatingFileReaderNew(const char *path,
+virRotatingFileReader *virRotatingFileReaderNew(const char *path,
size_t maxbackup);
-const char *virRotatingFileWriterGetPath(virRotatingFileWriterPtr file);
+const char *virRotatingFileWriterGetPath(virRotatingFileWriter *file);
-ino_t virRotatingFileWriterGetINode(virRotatingFileWriterPtr file);
-off_t virRotatingFileWriterGetOffset(virRotatingFileWriterPtr file);
+ino_t virRotatingFileWriterGetINode(virRotatingFileWriter *file);
+off_t virRotatingFileWriterGetOffset(virRotatingFileWriter *file);
-ssize_t virRotatingFileWriterAppend(virRotatingFileWriterPtr file,
+ssize_t virRotatingFileWriterAppend(virRotatingFileWriter *file,
const char *buf,
size_t len);
-int virRotatingFileReaderSeek(virRotatingFileReaderPtr file,
+int virRotatingFileReaderSeek(virRotatingFileReader *file,
ino_t inode,
off_t offset);
-ssize_t virRotatingFileReaderConsume(virRotatingFileReaderPtr file,
+ssize_t virRotatingFileReaderConsume(virRotatingFileReader *file,
char *buf,
size_t len);
-void virRotatingFileWriterFree(virRotatingFileWriterPtr file);
-void virRotatingFileReaderFree(virRotatingFileReaderPtr file);
+void virRotatingFileWriterFree(virRotatingFileWriter *file);
+void virRotatingFileReaderFree(virRotatingFileReader *file);
char *domname; /* which domain */
};
typedef struct _virUsedByInfo virUsedByInfo;
-typedef virUsedByInfo *virUsedByInfoPtr;
struct _virSCSIDevice {
unsigned int adapter;
char *name; /* adapter:bus:target:unit */
char *id; /* model:vendor */
char *sg_path; /* e.g. /dev/sg2 */
- virUsedByInfoPtr *used_by; /* driver:domain(s) using this dev */
+ virUsedByInfo **used_by; /* driver:domain(s) using this dev */
size_t n_used_by; /* how many domains are using this dev */
bool readonly;
struct _virSCSIDeviceList {
virObjectLockable parent;
size_t count;
- virSCSIDevicePtr *devs;
+ virSCSIDevice **devs;
};
-static virClassPtr virSCSIDeviceListClass;
+static virClass *virSCSIDeviceListClass;
static void virSCSIDeviceListDispose(void *obj);
return NULL;
}
-virSCSIDevicePtr
+virSCSIDevice *
virSCSIDeviceNew(const char *sysfs_prefix,
const char *adapter,
unsigned int bus,
}
static void
-virSCSIDeviceUsedByInfoFree(virUsedByInfoPtr used_by)
+virSCSIDeviceUsedByInfoFree(virUsedByInfo *used_by)
{
g_free(used_by->drvname);
g_free(used_by->domname);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virUsedByInfo, virSCSIDeviceUsedByInfoFree);
void
-virSCSIDeviceFree(virSCSIDevicePtr dev)
+virSCSIDeviceFree(virSCSIDevice *dev)
{
size_t i;
}
int
-virSCSIDeviceSetUsedBy(virSCSIDevicePtr dev,
+virSCSIDeviceSetUsedBy(virSCSIDevice *dev,
const char *drvname,
const char *domname)
{
}
bool
-virSCSIDeviceIsAvailable(virSCSIDevicePtr dev)
+virSCSIDeviceIsAvailable(virSCSIDevice *dev)
{
return dev->n_used_by == 0;
}
const char *
-virSCSIDeviceGetName(virSCSIDevicePtr dev)
+virSCSIDeviceGetName(virSCSIDevice *dev)
{
return dev->name;
}
const char *
-virSCSIDeviceGetPath(virSCSIDevicePtr dev)
+virSCSIDeviceGetPath(virSCSIDevice *dev)
{
return dev->sg_path;
}
unsigned int
-virSCSIDeviceGetAdapter(virSCSIDevicePtr dev)
+virSCSIDeviceGetAdapter(virSCSIDevice *dev)
{
return dev->adapter;
}
unsigned int
-virSCSIDeviceGetBus(virSCSIDevicePtr dev)
+virSCSIDeviceGetBus(virSCSIDevice *dev)
{
return dev->bus;
}
unsigned int
-virSCSIDeviceGetTarget(virSCSIDevicePtr dev)
+virSCSIDeviceGetTarget(virSCSIDevice *dev)
{
return dev->target;
}
unsigned long long
-virSCSIDeviceGetUnit(virSCSIDevicePtr dev)
+virSCSIDeviceGetUnit(virSCSIDevice *dev)
{
return dev->unit;
}
bool
-virSCSIDeviceGetReadonly(virSCSIDevicePtr dev)
+virSCSIDeviceGetReadonly(virSCSIDevice *dev)
{
return dev->readonly;
}
bool
-virSCSIDeviceGetShareable(virSCSIDevicePtr dev)
+virSCSIDeviceGetShareable(virSCSIDevice *dev)
{
return dev->shareable;
}
int
-virSCSIDeviceFileIterate(virSCSIDevicePtr dev,
+virSCSIDeviceFileIterate(virSCSIDevice *dev,
virSCSIDeviceFileActor actor,
void *opaque)
{
return (actor)(dev, dev->sg_path, opaque);
}
-virSCSIDeviceListPtr
+virSCSIDeviceList *
virSCSIDeviceListNew(void)
{
- virSCSIDeviceListPtr list;
+ virSCSIDeviceList *list;
if (virSCSIInitialize() < 0)
return NULL;
static void
virSCSIDeviceListDispose(void *obj)
{
- virSCSIDeviceListPtr list = obj;
+ virSCSIDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++)
}
int
-virSCSIDeviceListAdd(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev)
+virSCSIDeviceListAdd(virSCSIDeviceList *list,
+ virSCSIDevice *dev)
{
if (virSCSIDeviceListFind(list, dev)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return VIR_APPEND_ELEMENT(list->devs, list->count, dev);
}
-virSCSIDevicePtr
-virSCSIDeviceListGet(virSCSIDeviceListPtr list, int idx)
+virSCSIDevice *
+virSCSIDeviceListGet(virSCSIDeviceList *list, int idx)
{
if (idx >= list->count || idx < 0)
return NULL;
}
size_t
-virSCSIDeviceListCount(virSCSIDeviceListPtr list)
+virSCSIDeviceListCount(virSCSIDeviceList *list)
{
return list->count;
}
-virSCSIDevicePtr
-virSCSIDeviceListSteal(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev)
+virSCSIDevice *
+virSCSIDeviceListSteal(virSCSIDeviceList *list,
+ virSCSIDevice *dev)
{
- virSCSIDevicePtr ret = NULL;
+ virSCSIDevice *ret = NULL;
size_t i;
for (i = 0; i < list->count; i++) {
}
void
-virSCSIDeviceListDel(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev,
+virSCSIDeviceListDel(virSCSIDeviceList *list,
+ virSCSIDevice *dev,
const char *drvname,
const char *domname)
{
}
}
-virSCSIDevicePtr
-virSCSIDeviceListFind(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev)
+virSCSIDevice *
+virSCSIDeviceListFind(virSCSIDeviceList *list,
+ virSCSIDevice *dev)
{
size_t i;
#include "virobject.h"
typedef struct _virSCSIDevice virSCSIDevice;
-typedef virSCSIDevice *virSCSIDevicePtr;
typedef struct _virSCSIDeviceList virSCSIDeviceList;
-typedef virSCSIDeviceList *virSCSIDeviceListPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSCSIDeviceList, virObjectUnref);
unsigned int target,
unsigned long long unit);
-virSCSIDevicePtr virSCSIDeviceNew(const char *sysfs_prefix,
+virSCSIDevice *virSCSIDeviceNew(const char *sysfs_prefix,
const char *adapter,
unsigned int bus,
unsigned int target,
bool readonly,
bool shareable);
-void virSCSIDeviceFree(virSCSIDevicePtr dev);
-int virSCSIDeviceSetUsedBy(virSCSIDevicePtr dev,
+void virSCSIDeviceFree(virSCSIDevice *dev);
+int virSCSIDeviceSetUsedBy(virSCSIDevice *dev,
const char *drvname,
const char *domname);
-bool virSCSIDeviceIsAvailable(virSCSIDevicePtr dev);
-const char *virSCSIDeviceGetName(virSCSIDevicePtr dev);
-const char *virSCSIDeviceGetPath(virSCSIDevicePtr dev);
-unsigned int virSCSIDeviceGetAdapter(virSCSIDevicePtr dev);
-unsigned int virSCSIDeviceGetBus(virSCSIDevicePtr dev);
-unsigned int virSCSIDeviceGetTarget(virSCSIDevicePtr dev);
-unsigned long long virSCSIDeviceGetUnit(virSCSIDevicePtr dev);
-bool virSCSIDeviceGetReadonly(virSCSIDevicePtr dev);
-bool virSCSIDeviceGetShareable(virSCSIDevicePtr dev);
+bool virSCSIDeviceIsAvailable(virSCSIDevice *dev);
+const char *virSCSIDeviceGetName(virSCSIDevice *dev);
+const char *virSCSIDeviceGetPath(virSCSIDevice *dev);
+unsigned int virSCSIDeviceGetAdapter(virSCSIDevice *dev);
+unsigned int virSCSIDeviceGetBus(virSCSIDevice *dev);
+unsigned int virSCSIDeviceGetTarget(virSCSIDevice *dev);
+unsigned long long virSCSIDeviceGetUnit(virSCSIDevice *dev);
+bool virSCSIDeviceGetReadonly(virSCSIDevice *dev);
+bool virSCSIDeviceGetShareable(virSCSIDevice *dev);
/*
* Callback that will be invoked once for each file
* Should return 0 if successfully processed, or
* -1 to indicate error and abort iteration
*/
-typedef int (*virSCSIDeviceFileActor)(virSCSIDevicePtr dev,
+typedef int (*virSCSIDeviceFileActor)(virSCSIDevice *dev,
const char *path, void *opaque);
-int virSCSIDeviceFileIterate(virSCSIDevicePtr dev,
+int virSCSIDeviceFileIterate(virSCSIDevice *dev,
virSCSIDeviceFileActor actor,
void *opaque);
-virSCSIDeviceListPtr virSCSIDeviceListNew(void);
-int virSCSIDeviceListAdd(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev);
-virSCSIDevicePtr virSCSIDeviceListGet(virSCSIDeviceListPtr list,
+virSCSIDeviceList *virSCSIDeviceListNew(void);
+int virSCSIDeviceListAdd(virSCSIDeviceList *list,
+ virSCSIDevice *dev);
+virSCSIDevice *virSCSIDeviceListGet(virSCSIDeviceList *list,
int idx);
-size_t virSCSIDeviceListCount(virSCSIDeviceListPtr list);
-virSCSIDevicePtr virSCSIDeviceListSteal(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev);
-void virSCSIDeviceListDel(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev,
+size_t virSCSIDeviceListCount(virSCSIDeviceList *list);
+virSCSIDevice *virSCSIDeviceListSteal(virSCSIDeviceList *list,
+ virSCSIDevice *dev);
+void virSCSIDeviceListDel(virSCSIDeviceList *list,
+ virSCSIDevice *dev,
const char *drvname,
const char *domname);
-virSCSIDevicePtr virSCSIDeviceListFind(virSCSIDeviceListPtr list,
- virSCSIDevicePtr dev);
+virSCSIDevice *virSCSIDeviceListFind(virSCSIDeviceList *list,
+ virSCSIDevice *dev);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSCSIDevice, virSCSIDeviceFree);
struct _virSCSIVHostDeviceList {
virObjectLockable parent;
size_t count;
- virSCSIVHostDevicePtr *devs;
+ virSCSIVHostDevice **devs;
};
-static virClassPtr virSCSIVHostDeviceListClass;
+static virClass *virSCSIVHostDeviceListClass;
static void
virSCSIVHostDeviceListDispose(void *obj)
{
- virSCSIVHostDeviceListPtr list = obj;
+ virSCSIVHostDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++)
void
-virSCSIVHostDeviceListDel(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceListDel(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev)
{
virSCSIVHostDeviceFree(virSCSIVHostDeviceListSteal(list, dev));
}
static int
-virSCSIVHostDeviceListFindIndex(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceListFindIndex(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev)
{
size_t i;
for (i = 0; i < list->count; i++) {
- virSCSIVHostDevicePtr other = list->devs[i];
+ virSCSIVHostDevice *other = list->devs[i];
if (STREQ_NULLABLE(other->name, dev->name))
return i;
}
}
-virSCSIVHostDevicePtr
-virSCSIVHostDeviceListGet(virSCSIVHostDeviceListPtr list, int idx)
+virSCSIVHostDevice *
+virSCSIVHostDeviceListGet(virSCSIVHostDeviceList *list, int idx)
{
if (idx >= list->count || idx < 0)
return NULL;
size_t
-virSCSIVHostDeviceListCount(virSCSIVHostDeviceListPtr list)
+virSCSIVHostDeviceListCount(virSCSIVHostDeviceList *list)
{
return list->count;
}
-virSCSIVHostDevicePtr
-virSCSIVHostDeviceListSteal(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev)
+virSCSIVHostDevice *
+virSCSIVHostDeviceListSteal(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev)
{
- virSCSIVHostDevicePtr ret = NULL;
+ virSCSIVHostDevice *ret = NULL;
size_t i;
for (i = 0; i < list->count; i++) {
}
-virSCSIVHostDevicePtr
-virSCSIVHostDeviceListFind(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev)
+virSCSIVHostDevice *
+virSCSIVHostDeviceListFind(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev)
{
int idx;
int
-virSCSIVHostDeviceListAdd(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceListAdd(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev)
{
if (virSCSIVHostDeviceListFind(list, dev)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
-virSCSIVHostDeviceListPtr
+virSCSIVHostDeviceList *
virSCSIVHostDeviceListNew(void)
{
if (virSCSIVHostInitialize() < 0)
int
-virSCSIVHostDeviceSetUsedBy(virSCSIVHostDevicePtr dev,
+virSCSIVHostDeviceSetUsedBy(virSCSIVHostDevice *dev,
const char *drvname,
const char *domname)
{
void
-virSCSIVHostDeviceGetUsedBy(virSCSIVHostDevicePtr dev,
+virSCSIVHostDeviceGetUsedBy(virSCSIVHostDevice *dev,
const char **drv_name,
const char **dom_name)
{
int
-virSCSIVHostDeviceFileIterate(virSCSIVHostDevicePtr dev,
+virSCSIVHostDeviceFileIterate(virSCSIVHostDevice *dev,
virSCSIVHostDeviceFileActor actor,
void *opaque)
{
const char *
-virSCSIVHostDeviceGetName(virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceGetName(virSCSIVHostDevice *dev)
{
return dev->name;
}
const char *
-virSCSIVHostDeviceGetPath(virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceGetPath(virSCSIVHostDevice *dev)
{
return dev->path;
}
-virSCSIVHostDevicePtr
+virSCSIVHostDevice *
virSCSIVHostDeviceNew(const char *name)
{
g_autoptr(virSCSIVHostDevice) dev = NULL;
void
-virSCSIVHostDeviceFree(virSCSIVHostDevicePtr dev)
+virSCSIVHostDeviceFree(virSCSIVHostDevice *dev)
{
if (!dev)
return;
#include "virobject.h"
typedef struct _virSCSIVHostDevice virSCSIVHostDevice;
-typedef virSCSIVHostDevice *virSCSIVHostDevicePtr;
typedef struct _virSCSIVHostDeviceList virSCSIVHostDeviceList;
-typedef virSCSIVHostDeviceList *virSCSIVHostDeviceListPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSCSIVHostDeviceList, virObjectUnref);
-typedef int (*virSCSIVHostDeviceFileActor)(virSCSIVHostDevicePtr dev,
+typedef int (*virSCSIVHostDeviceFileActor)(virSCSIVHostDevice *dev,
const char *name, void *opaque);
-int virSCSIVHostDeviceFileIterate(virSCSIVHostDevicePtr dev,
+int virSCSIVHostDeviceFileIterate(virSCSIVHostDevice *dev,
virSCSIVHostDeviceFileActor actor,
void *opaque);
-const char *virSCSIVHostDeviceGetName(virSCSIVHostDevicePtr dev);
-const char *virSCSIVHostDeviceGetPath(virSCSIVHostDevicePtr dev);
-virSCSIVHostDevicePtr virSCSIVHostDeviceListGet(virSCSIVHostDeviceListPtr list,
+const char *virSCSIVHostDeviceGetName(virSCSIVHostDevice *dev);
+const char *virSCSIVHostDeviceGetPath(virSCSIVHostDevice *dev);
+virSCSIVHostDevice *virSCSIVHostDeviceListGet(virSCSIVHostDeviceList *list,
int idx);
-size_t virSCSIVHostDeviceListCount(virSCSIVHostDeviceListPtr list);
-virSCSIVHostDevicePtr virSCSIVHostDeviceListSteal(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev);
-virSCSIVHostDevicePtr virSCSIVHostDeviceListFind(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev);
-int virSCSIVHostDeviceListAdd(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev);
-void virSCSIVHostDeviceListDel(virSCSIVHostDeviceListPtr list,
- virSCSIVHostDevicePtr dev);
-virSCSIVHostDeviceListPtr virSCSIVHostDeviceListNew(void);
-virSCSIVHostDevicePtr virSCSIVHostDeviceNew(const char *name);
-int virSCSIVHostDeviceSetUsedBy(virSCSIVHostDevicePtr dev,
+size_t virSCSIVHostDeviceListCount(virSCSIVHostDeviceList *list);
+virSCSIVHostDevice *virSCSIVHostDeviceListSteal(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev);
+virSCSIVHostDevice *virSCSIVHostDeviceListFind(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev);
+int virSCSIVHostDeviceListAdd(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev);
+void virSCSIVHostDeviceListDel(virSCSIVHostDeviceList *list,
+ virSCSIVHostDevice *dev);
+virSCSIVHostDeviceList *virSCSIVHostDeviceListNew(void);
+virSCSIVHostDevice *virSCSIVHostDeviceNew(const char *name);
+int virSCSIVHostDeviceSetUsedBy(virSCSIVHostDevice *dev,
const char *drvname,
const char *domname);
-void virSCSIVHostDeviceGetUsedBy(virSCSIVHostDevicePtr dev,
+void virSCSIVHostDeviceGetUsedBy(virSCSIVHostDevice *dev,
const char **drv_name,
const char **dom_name);
-void virSCSIVHostDeviceFree(virSCSIVHostDevicePtr dev);
+void virSCSIVHostDeviceFree(virSCSIVHostDevice *dev);
int virSCSIVHostOpenVhostSCSI(int *vhostfd) G_GNUC_NO_INLINE;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSCSIVHostDevice, virSCSIVHostDeviceFree);
void
-virSecurityLabelDefFree(virSecurityLabelDefPtr def)
+virSecurityLabelDefFree(virSecurityLabelDef *def)
{
if (!def)
return;
void
-virSecurityDeviceLabelDefFree(virSecurityDeviceLabelDefPtr def)
+virSecurityDeviceLabelDefFree(virSecurityDeviceLabelDef *def)
{
if (!def)
return;
}
-virSecurityLabelDefPtr
+virSecurityLabelDef *
virSecurityLabelDefNew(const char *model)
{
- virSecurityLabelDefPtr seclabel = NULL;
+ virSecurityLabelDef *seclabel = NULL;
seclabel = g_new0(virSecurityLabelDef, 1);
return seclabel;
}
-virSecurityDeviceLabelDefPtr
+virSecurityDeviceLabelDef *
virSecurityDeviceLabelDefNew(const char *model)
{
- virSecurityDeviceLabelDefPtr seclabel = NULL;
+ virSecurityDeviceLabelDef *seclabel = NULL;
seclabel = g_new0(virSecurityDeviceLabelDef, 1);
}
-virSecurityDeviceLabelDefPtr
+virSecurityDeviceLabelDef *
virSecurityDeviceLabelDefCopy(const virSecurityDeviceLabelDef *src)
{
- virSecurityDeviceLabelDefPtr ret;
+ virSecurityDeviceLabelDef *ret;
ret = g_new0(virSecurityDeviceLabelDef, 1);
/* Security configuration for domain */
typedef struct _virSecurityLabelDef virSecurityLabelDef;
-typedef virSecurityLabelDef *virSecurityLabelDefPtr;
struct _virSecurityLabelDef {
char *model; /* name of security model */
char *label; /* security label string */
/* Security configuration for device */
typedef struct _virSecurityDeviceLabelDef virSecurityDeviceLabelDef;
-typedef virSecurityDeviceLabelDef *virSecurityDeviceLabelDefPtr;
struct _virSecurityDeviceLabelDef {
char *model;
char *label; /* image label string */
bool labelskip; /* live-only; true if skipping failed label attempt */
};
-virSecurityLabelDefPtr
+virSecurityLabelDef *
virSecurityLabelDefNew(const char *model);
-virSecurityDeviceLabelDefPtr
+virSecurityDeviceLabelDef *
virSecurityDeviceLabelDefNew(const char *model);
-virSecurityDeviceLabelDefPtr
+virSecurityDeviceLabelDef *
virSecurityDeviceLabelDefCopy(const virSecurityDeviceLabelDef *src)
ATTRIBUTE_NONNULL(1);
-void virSecurityLabelDefFree(virSecurityLabelDefPtr def);
-void virSecurityDeviceLabelDefFree(virSecurityDeviceLabelDefPtr def);
+void virSecurityLabelDefFree(virSecurityLabelDef *def);
+void virSecurityDeviceLabelDefFree(virSecurityDeviceLabelDef *def);
);
void
-virSecretLookupDefClear(virSecretLookupTypeDefPtr def)
+virSecretLookupDefClear(virSecretLookupTypeDef *def)
{
if (def->type == VIR_SECRET_LOOKUP_TYPE_USAGE)
VIR_FREE(def->u.usage);
void
-virSecretLookupDefCopy(virSecretLookupTypeDefPtr dst,
+virSecretLookupDefCopy(virSecretLookupTypeDef *dst,
const virSecretLookupTypeDef *src)
{
dst->type = src->type;
int
virSecretLookupParseSecret(xmlNodePtr secretnode,
- virSecretLookupTypeDefPtr def)
+ virSecretLookupTypeDef *def)
{
g_autofree char *uuid = NULL;
g_autofree char *usage = NULL;
void
-virSecretLookupFormatSecret(virBufferPtr buf,
+virSecretLookupFormatSecret(virBuffer *buf,
const char *secrettype,
- virSecretLookupTypeDefPtr def)
+ virSecretLookupTypeDef *def)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
*/
int
virSecretGetSecretString(virConnectPtr conn,
- virSecretLookupTypeDefPtr seclookupdef,
+ virSecretLookupTypeDef *seclookupdef,
virSecretUsageType secretUsageType,
uint8_t **secret,
size_t *secret_size)
} virSecretLookupType;
typedef struct _virSecretLookupTypeDef virSecretLookupTypeDef;
-typedef virSecretLookupTypeDef *virSecretLookupTypeDefPtr;
struct _virSecretLookupTypeDef {
int type; /* virSecretLookupType */
union {
};
-void virSecretLookupDefClear(virSecretLookupTypeDefPtr def);
-void virSecretLookupDefCopy(virSecretLookupTypeDefPtr dst,
+void virSecretLookupDefClear(virSecretLookupTypeDef *def);
+void virSecretLookupDefCopy(virSecretLookupTypeDef *dst,
const virSecretLookupTypeDef *src);
int virSecretLookupParseSecret(xmlNodePtr secretnode,
- virSecretLookupTypeDefPtr def);
-void virSecretLookupFormatSecret(virBufferPtr buf,
+ virSecretLookupTypeDef *def);
+void virSecretLookupFormatSecret(virBuffer *buf,
const char *secrettype,
- virSecretLookupTypeDefPtr def);
+ virSecretLookupTypeDef *def);
int virSecretGetSecretString(virConnectPtr conn,
- virSecretLookupTypeDefPtr seclookupdef,
+ virSecretLookupTypeDef *seclookupdef,
virSecretUsageType secretUsageType,
uint8_t **ret_secret,
size_t *ret_secret_size)
#define VIR_FROM_THIS VIR_FROM_NONE
/*
- * Helpers to extract the IP arrays from the virSocketAddrPtr
+ * Helpers to extract the IP arrays from the virSocketAddr *
* That part is the less portable of the module
*/
typedef unsigned char virSocketAddrIPv4[4];
-typedef virSocketAddrIPv4 *virSocketAddrIPv4Ptr;
typedef unsigned short virSocketAddrIPv6[8];
-typedef virSocketAddrIPv6 *virSocketAddrIPv6Ptr;
typedef unsigned char virSocketAddrIPv6Nibbles[32];
-typedef virSocketAddrIPv6Nibbles *virSocketAddrIPv6NibblesPtr;
static int
virSocketAddrGetIPv4Addr(const virSocketAddr *addr,
- virSocketAddrIPv4Ptr tab)
+ virSocketAddrIPv4 *tab)
{
unsigned long val;
size_t i;
}
static int
-virSocketAddrGetIPv6Addr(const virSocketAddr *addr, virSocketAddrIPv6Ptr tab)
+virSocketAddrGetIPv6Addr(const virSocketAddr *addr, virSocketAddrIPv6 *tab)
{
size_t i;
static int
virSocketAddrGetIPv6Nibbles(const virSocketAddr *addr,
- virSocketAddrIPv6NibblesPtr tab)
+ virSocketAddrIPv6Nibbles *tab)
{
size_t i;
*
* Returns the length of the network address or -1 in case of error.
*/
-int virSocketAddrParse(virSocketAddrPtr addr, const char *val, int family)
+int virSocketAddrParse(virSocketAddr *addr, const char *val, int family)
{
int len;
struct addrinfo *res;
*
* Returns the length of the network address or -1 in case of error.
*/
-int virSocketAddrParseAny(virSocketAddrPtr addr,
+int virSocketAddrParseAny(virSocketAddr *addr,
const char *val,
int family,
bool reportError)
* Returns the length of the network address or -1 in case of error.
*/
int
-virSocketAddrParseIPv4(virSocketAddrPtr addr, const char *val)
+virSocketAddrParseIPv4(virSocketAddr *addr, const char *val)
{
return virSocketAddrParse(addr, val, AF_INET);
}
* Returns the length of the network address or -1 in case of error.
*/
int
-virSocketAddrParseIPv6(virSocketAddrPtr addr, const char *val)
+virSocketAddrParseIPv6(virSocketAddr *addr, const char *val)
{
return virSocketAddrParse(addr, val, AF_INET6);
}
* touch any previously set port.
*/
void
-virSocketAddrSetIPv4AddrNetOrder(virSocketAddrPtr addr, uint32_t val)
+virSocketAddrSetIPv4AddrNetOrder(virSocketAddr *addr, uint32_t val)
{
addr->data.stor.ss_family = AF_INET;
addr->data.inet4.sin_addr.s_addr = val;
* touch any previously set port.
*/
void
-virSocketAddrSetIPv4Addr(virSocketAddrPtr addr, uint32_t val)
+virSocketAddrSetIPv4Addr(virSocketAddr *addr, uint32_t val)
{
virSocketAddrSetIPv4AddrNetOrder(addr, htonl(val));
}
* Set the IPv6 address given an integer in network order. This function does not
* touch any previously set port.
*/
-void virSocketAddrSetIPv6AddrNetOrder(virSocketAddrPtr addr, uint32_t val[4])
+void virSocketAddrSetIPv6AddrNetOrder(virSocketAddr *addr, uint32_t val[4])
{
addr->data.stor.ss_family = AF_INET6;
memcpy(addr->data.inet6.sin6_addr.s6_addr, val, 4 * sizeof(*val));
* Set the IPv6 address given an integer in host order. This function does not
* touch any previously set port.
*/
-void virSocketAddrSetIPv6Addr(virSocketAddrPtr addr, uint32_t val[4])
+void virSocketAddrSetIPv6Addr(virSocketAddr *addr, uint32_t val[4])
{
size_t i = 0;
uint32_t host_val[4];
/*
* virSocketAddrFormat:
- * @addr: an initialized virSocketAddrPtr
+ * @addr: an initialized virSocketAddr *
*
* Returns a string representation of the given address
* Returns NULL on any error
/*
* virSocketAddrFormatFull:
- * @addr: an initialized virSocketAddrPtr
+ * @addr: an initialized virSocketAddr *
* @withService: if true, then service info is appended
* @separator: separator between hostname & service.
*
/*
* virSocketAddrSetPort:
- * @addr: an initialized virSocketAddrPtr
+ * @addr: an initialized virSocketAddr *
* @port: the port number to set
*
* Set the transport layer port of the given virtSocketAddr
* Returns 0 on success, -1 on failure
*/
int
-virSocketAddrSetPort(virSocketAddrPtr addr, int port)
+virSocketAddrSetPort(virSocketAddr *addr, int port)
{
if (addr == NULL)
return -1;
/*
* virSocketGetPort:
- * @addr: an initialized virSocketAddrPtr
+ * @addr: an initialized virSocketAddr *
*
* Returns the transport layer port of the given virtSocketAddr
* Returns -1 if @addr is invalid
*/
int
-virSocketAddrGetPort(virSocketAddrPtr addr)
+virSocketAddrGetPort(virSocketAddr *addr)
{
if (addr == NULL)
return -1;
/*
* virSocketGetPath:
- * @addr: an initialized virSocketAddrPtr
+ * @addr: an initialized virSocketAddr *
*
* Returns the UNIX socket path of the given virtSocketAddr
*
* address of type AF_UNIX;
*/
char *
-virSocketAddrGetPath(virSocketAddrPtr addr G_GNUC_UNUSED)
+virSocketAddrGetPath(virSocketAddr *addr G_GNUC_UNUSED)
{
#ifndef WIN32
if (addr == NULL) {
*
* Returns 0 in case of success and -1 in case of error
*/
-int virSocketAddrIsNetmask(virSocketAddrPtr netmask)
+int virSocketAddrIsNetmask(virSocketAddr *netmask)
{
int n = virSocketAddrGetNumNetmaskBits(netmask);
if (n < 0)
int
virSocketAddrMask(const virSocketAddr *addr,
const virSocketAddr *netmask,
- virSocketAddrPtr network)
+ virSocketAddr *network)
{
memset(network, 0, sizeof(*network));
if (addr->data.stor.ss_family != netmask->data.stor.ss_family) {
int
virSocketAddrMaskByPrefix(const virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr network)
+ virSocketAddr *network)
{
virSocketAddr netmask;
int
virSocketAddrBroadcast(const virSocketAddr *addr,
const virSocketAddr *netmask,
- virSocketAddrPtr broadcast)
+ virSocketAddr *broadcast)
{
memset(broadcast, 0, sizeof(*broadcast));
int
virSocketAddrBroadcastByPrefix(const virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr broadcast)
+ virSocketAddr *broadcast)
{
virSocketAddr netmask;
* Returns 1 in case of success and 0 in case of failure and
* -1 in case of error
*/
-int virSocketAddrCheckNetmask(virSocketAddrPtr addr1, virSocketAddrPtr addr2,
- virSocketAddrPtr netmask)
+int virSocketAddrCheckNetmask(virSocketAddr *addr1, virSocketAddr *addr2,
+ virSocketAddr *netmask)
{
size_t i;
* Returns the size of the range or -1 in case of failure
*/
int
-virSocketAddrGetRange(virSocketAddrPtr start, virSocketAddrPtr end,
- virSocketAddrPtr network, int prefix)
+virSocketAddrGetRange(virSocketAddr *start, virSocketAddr *end,
+ virSocketAddr *network, int prefix)
{
int ret = 0;
size_t i;
int
virSocketAddrPrefixToNetmask(unsigned int prefix,
- virSocketAddrPtr netmask,
+ virSocketAddr *netmask,
int family)
{
memset(netmask, 0, sizeof(*netmask));
}
void
-virSocketAddrFree(virSocketAddrPtr addr)
+virSocketAddrFree(virSocketAddr *addr)
{
g_free(addr);
}
#define VIR_SOCKET_ADDR_IPV4_ARPA "in-addr.arpa"
#define VIR_SOCKET_ADDR_IPV6_ARPA "ip6.arpa"
-typedef virSocketAddr *virSocketAddrPtr;
-
typedef struct _virSocketAddrRange virSocketAddrRange;
-typedef virSocketAddrRange *virSocketAddrRangePtr;
struct _virSocketAddrRange {
virSocketAddr start;
virSocketAddr end;
};
typedef struct _virPortRange virPortRange;
-typedef virPortRange *virPortRangePtr;
struct _virPortRange {
unsigned int start;
unsigned int end;
};
-int virSocketAddrParse(virSocketAddrPtr addr,
+int virSocketAddrParse(virSocketAddr *addr,
const char *val,
int family);
-int virSocketAddrParseAny(virSocketAddrPtr addr,
+int virSocketAddrParseAny(virSocketAddr *addr,
const char *val,
int family,
bool reportError);
-int virSocketAddrParseIPv4(virSocketAddrPtr addr,
+int virSocketAddrParseIPv4(virSocketAddr *addr,
const char *val);
-int virSocketAddrParseIPv6(virSocketAddrPtr addr,
+int virSocketAddrParseIPv6(virSocketAddr *addr,
const char *val);
int virSocketAddrResolveService(const char *service);
-void virSocketAddrSetIPv4AddrNetOrder(virSocketAddrPtr addr, uint32_t val);
-void virSocketAddrSetIPv4Addr(virSocketAddrPtr addr, uint32_t val);
-void virSocketAddrSetIPv6AddrNetOrder(virSocketAddrPtr addr, uint32_t val[4]);
-void virSocketAddrSetIPv6Addr(virSocketAddrPtr addr, uint32_t val[4]);
+void virSocketAddrSetIPv4AddrNetOrder(virSocketAddr *addr, uint32_t val);
+void virSocketAddrSetIPv4Addr(virSocketAddr *addr, uint32_t val);
+void virSocketAddrSetIPv6AddrNetOrder(virSocketAddr *addr, uint32_t val[4]);
+void virSocketAddrSetIPv6Addr(virSocketAddr *addr, uint32_t val[4]);
char *virSocketAddrFormat(const virSocketAddr *addr);
char *virSocketAddrFormatFull(const virSocketAddr *addr,
bool withService,
const char *separator);
-char *virSocketAddrGetPath(virSocketAddrPtr addr);
+char *virSocketAddrGetPath(virSocketAddr *addr);
-int virSocketAddrSetPort(virSocketAddrPtr addr, int port);
+int virSocketAddrSetPort(virSocketAddr *addr, int port);
-int virSocketAddrGetPort(virSocketAddrPtr addr);
+int virSocketAddrGetPort(virSocketAddr *addr);
-int virSocketAddrGetRange(virSocketAddrPtr start,
- virSocketAddrPtr end,
- virSocketAddrPtr network,
+int virSocketAddrGetRange(virSocketAddr *start,
+ virSocketAddr *end,
+ virSocketAddr *network,
int prefix);
-int virSocketAddrIsNetmask(virSocketAddrPtr netmask);
+int virSocketAddrIsNetmask(virSocketAddr *netmask);
-int virSocketAddrCheckNetmask(virSocketAddrPtr addr1,
- virSocketAddrPtr addr2,
- virSocketAddrPtr netmask);
+int virSocketAddrCheckNetmask(virSocketAddr *addr1,
+ virSocketAddr *addr2,
+ virSocketAddr *netmask);
int virSocketAddrMask(const virSocketAddr *addr,
const virSocketAddr *netmask,
- virSocketAddrPtr network);
+ virSocketAddr *network);
int virSocketAddrMaskByPrefix(const virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr network);
+ virSocketAddr *network);
int virSocketAddrBroadcast(const virSocketAddr *addr,
const virSocketAddr *netmask,
- virSocketAddrPtr broadcast);
+ virSocketAddr *broadcast);
int virSocketAddrBroadcastByPrefix(const virSocketAddr *addr,
unsigned int prefix,
- virSocketAddrPtr broadcast);
+ virSocketAddr *broadcast);
int virSocketAddrGetNumNetmaskBits(const virSocketAddr *netmask);
int virSocketAddrPrefixToNetmask(unsigned int prefix,
- virSocketAddrPtr netmask,
+ virSocketAddr *netmask,
int family);
int virSocketAddrGetIPPrefix(const virSocketAddr *address,
const virSocketAddr *netmask,
char **ptr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
-void virSocketAddrFree(virSocketAddrPtr addr);
+void virSocketAddrFree(virSocketAddr *addr);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSocketAddr, virSocketAddrFree);
sysinfoCpuinfo = cpuinfo;
}
-void virSysinfoBIOSDefFree(virSysinfoBIOSDefPtr def)
+void virSysinfoBIOSDefFree(virSysinfoBIOSDef *def)
{
if (def == NULL)
return;
g_free(def);
}
-void virSysinfoSystemDefFree(virSysinfoSystemDefPtr def)
+void virSysinfoSystemDefFree(virSysinfoSystemDef *def)
{
if (def == NULL)
return;
g_free(def);
}
-void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDefPtr def)
+void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDef *def)
{
if (def == NULL)
return;
}
-void virSysinfoChassisDefFree(virSysinfoChassisDefPtr def)
+void virSysinfoChassisDefFree(virSysinfoChassisDef *def)
{
if (def == NULL)
return;
}
-void virSysinfoOEMStringsDefFree(virSysinfoOEMStringsDefPtr def)
+void virSysinfoOEMStringsDefFree(virSysinfoOEMStringsDef *def)
{
size_t i;
static void
-virSysinfoFWCfgDefClear(virSysinfoFWCfgDefPtr def)
+virSysinfoFWCfgDefClear(virSysinfoFWCfgDef *def)
{
if (!def)
return;
* Free up the sysinfo structure
*/
-void virSysinfoDefFree(virSysinfoDefPtr def)
+void virSysinfoDefFree(virSysinfoDef *def)
{
size_t i;
static int
-virSysinfoParsePPCSystem(const char *base, virSysinfoSystemDefPtr *sysdef)
+virSysinfoParsePPCSystem(const char *base, virSysinfoSystemDef **sysdef)
{
int ret = -1;
char *eol = NULL;
const char *cur;
- virSysinfoSystemDefPtr def;
+ virSysinfoSystemDef *def;
if ((cur = strstr(base, "platform")) == NULL)
return 0;
}
static int
-virSysinfoParsePPCProcessor(const char *base, virSysinfoDefPtr ret)
+virSysinfoParsePPCProcessor(const char *base, virSysinfoDef *ret)
{
const char *cur;
char *eol, *tmp_base;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
while ((tmp_base = strstr(base, "processor")) != NULL) {
base = tmp_base;
/* virSysinfoRead for PowerPC
* Gathers sysinfo data from /proc/cpuinfo */
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadPPC(void)
{
g_autoptr(virSysinfoDef) ret = NULL;
static int
-virSysinfoParseARMSystem(const char *base, virSysinfoSystemDefPtr *sysdef)
+virSysinfoParseARMSystem(const char *base, virSysinfoSystemDef **sysdef)
{
int ret = -1;
char *eol = NULL;
const char *cur;
- virSysinfoSystemDefPtr def;
+ virSysinfoSystemDef *def;
if ((cur = strstr(base, "platform")) == NULL)
return 0;
}
static int
-virSysinfoParseARMProcessor(const char *base, virSysinfoDefPtr ret)
+virSysinfoParseARMProcessor(const char *base, virSysinfoDef *ret)
{
const char *cur;
char *eol, *tmp_base;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
char *processor_type = NULL;
if (!(tmp_base = strstr(base, "model name")) &&
/* virSysinfoRead for ARMv7
* Gathers sysinfo data from /proc/cpuinfo */
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadARM(void)
{
g_autoptr(virSysinfoDef) ret = NULL;
}
static int
-virSysinfoParseS390System(const char *base, virSysinfoSystemDefPtr *sysdef)
+virSysinfoParseS390System(const char *base, virSysinfoSystemDef **sysdef)
{
int ret = -1;
- virSysinfoSystemDefPtr def;
+ virSysinfoSystemDef *def;
def = g_new0(virSysinfoSystemDef, 1);
}
static int
-virSysinfoParseS390Processor(const char *base, virSysinfoDefPtr ret)
+virSysinfoParseS390Processor(const char *base, virSysinfoDef *ret)
{
const char *tmp_base;
char *manufacturer = NULL;
char *procline = NULL;
char *ncpu = NULL;
int result = -1;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
if (!(tmp_base = virSysinfoParseS390Line(base, "vendor_id", &manufacturer)))
goto error;
/* virSysinfoRead for s390x
* Gathers sysinfo data from /proc/sysinfo and /proc/cpuinfo */
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadS390(void)
{
g_autoptr(virSysinfoDef) ret = NULL;
static int
-virSysinfoParseBIOS(const char *base, virSysinfoBIOSDefPtr *bios)
+virSysinfoParseBIOS(const char *base, virSysinfoBIOSDef **bios)
{
int ret = -1;
const char *cur;
char *eol = NULL;
- virSysinfoBIOSDefPtr def;
+ virSysinfoBIOSDef *def;
if ((cur = strstr(base, "BIOS Information")) == NULL)
return 0;
}
static int
-virSysinfoParseX86System(const char *base, virSysinfoSystemDefPtr *sysdef)
+virSysinfoParseX86System(const char *base, virSysinfoSystemDef **sysdef)
{
int ret = -1;
const char *cur;
char *eol = NULL;
- virSysinfoSystemDefPtr def;
+ virSysinfoSystemDef *def;
if ((cur = strstr(base, "System Information")) == NULL)
return 0;
static int
virSysinfoParseX86BaseBoard(const char *base,
- virSysinfoBaseBoardDefPtr *baseBoard,
+ virSysinfoBaseBoardDef **baseBoard,
size_t *nbaseBoard)
{
const char *cur;
char *eol = NULL;
- virSysinfoBaseBoardDefPtr boards = NULL;
+ virSysinfoBaseBoardDef *boards = NULL;
size_t nboards = 0;
while (base && (cur = strstr(base, "Base Board Information"))) {
- virSysinfoBaseBoardDefPtr def;
+ virSysinfoBaseBoardDef *def;
VIR_EXPAND_N(boards, nboards, 1);
static int
virSysinfoParseX86Chassis(const char *base,
- virSysinfoChassisDefPtr *chassisdef)
+ virSysinfoChassisDef **chassisdef)
{
int ret = -1;
const char *cur;
char *eol = NULL;
- virSysinfoChassisDefPtr def;
+ virSysinfoChassisDef *def;
if ((cur = strstr(base, "Chassis Information")) == NULL)
return 0;
static int
virSysinfoParseOEMStrings(const char *base,
- virSysinfoOEMStringsDefPtr *stringsRet)
+ virSysinfoOEMStringsDef **stringsRet)
{
- virSysinfoOEMStringsDefPtr strings = NULL;
+ virSysinfoOEMStringsDef *strings = NULL;
size_t i = 1;
int ret = -1;
const char *cur;
static int
-virSysinfoParseX86Processor(const char *base, virSysinfoDefPtr ret)
+virSysinfoParseX86Processor(const char *base, virSysinfoDef *ret)
{
const char *cur, *tmp_base;
char *eol;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
while ((tmp_base = strstr(base, "Processor Information")) != NULL) {
base = tmp_base;
}
static int
-virSysinfoParseX86Memory(const char *base, virSysinfoDefPtr ret)
+virSysinfoParseX86Memory(const char *base, virSysinfoDef *ret)
{
const char *cur, *tmp_base;
char *eol;
- virSysinfoMemoryDefPtr memory;
+ virSysinfoMemoryDef *memory;
while ((tmp_base = strstr(base, "Memory Device")) != NULL) {
base = tmp_base;
return 0;
}
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadDMI(void)
{
g_autoptr(virSysinfoDef) ret = NULL;
*
* Returns: a filled up sysinfo structure or NULL in case of error
*/
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoRead(void)
{
#if defined(__powerpc__)
static void
-virSysinfoBIOSFormat(virBufferPtr buf, virSysinfoBIOSDefPtr def)
+virSysinfoBIOSFormat(virBuffer *buf, virSysinfoBIOSDef *def)
{
if (!def)
return;
}
static void
-virSysinfoSystemFormat(virBufferPtr buf, virSysinfoSystemDefPtr def)
+virSysinfoSystemFormat(virBuffer *buf, virSysinfoSystemDef *def)
{
if (!def)
return;
}
static void
-virSysinfoBaseBoardFormat(virBufferPtr buf,
- virSysinfoBaseBoardDefPtr baseBoard,
+virSysinfoBaseBoardFormat(virBuffer *buf,
+ virSysinfoBaseBoardDef *baseBoard,
size_t nbaseBoard)
{
- virSysinfoBaseBoardDefPtr def;
+ virSysinfoBaseBoardDef *def;
size_t i;
for (i = 0; i < nbaseBoard; i++) {
static void
-virSysinfoChassisFormat(virBufferPtr buf,
- virSysinfoChassisDefPtr def)
+virSysinfoChassisFormat(virBuffer *buf,
+ virSysinfoChassisDef *def)
{
if (!def)
return;
static void
-virSysinfoProcessorFormat(virBufferPtr buf, virSysinfoDefPtr def)
+virSysinfoProcessorFormat(virBuffer *buf, virSysinfoDef *def)
{
size_t i;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
for (i = 0; i < def->nprocessor; i++) {
processor = &def->processor[i];
}
static void
-virSysinfoMemoryFormat(virBufferPtr buf, virSysinfoDefPtr def)
+virSysinfoMemoryFormat(virBuffer *buf, virSysinfoDef *def)
{
size_t i;
- virSysinfoMemoryDefPtr memory;
+ virSysinfoMemoryDef *memory;
for (i = 0; i < def->nmemory; i++) {
memory = &def->memory[i];
}
static void
-virSysinfoOEMStringsFormat(virBufferPtr buf, virSysinfoOEMStringsDefPtr def)
+virSysinfoOEMStringsFormat(virBuffer *buf, virSysinfoOEMStringsDef *def)
{
size_t i;
static void
-virSysinfoFormatSMBIOS(virBufferPtr buf,
- virSysinfoDefPtr def)
+virSysinfoFormatSMBIOS(virBuffer *buf,
+ virSysinfoDef *def)
{
virSysinfoBIOSFormat(buf, def->bios);
virSysinfoSystemFormat(buf, def->system);
static void
-virSysinfoFormatFWCfg(virBufferPtr buf,
- virSysinfoDefPtr def)
+virSysinfoFormatFWCfg(virBuffer *buf,
+ virSysinfoDef *def)
{
size_t i;
* Returns 0 on success, -1 on failure after generating an error message.
*/
int
-virSysinfoFormat(virBufferPtr buf, virSysinfoDefPtr def)
+virSysinfoFormat(virBuffer *buf, virSysinfoDef *def)
{
g_auto(virBuffer) attrBuf = VIR_BUFFER_INITIALIZER;
g_auto(virBuffer) childrenBuf = VIR_BUFFER_INIT_CHILD(buf);
} while (0)
static bool
-virSysinfoBIOSIsEqual(virSysinfoBIOSDefPtr src,
- virSysinfoBIOSDefPtr dst)
+virSysinfoBIOSIsEqual(virSysinfoBIOSDef *src,
+ virSysinfoBIOSDef *dst)
{
if (!src && !dst)
return true;
}
static bool
-virSysinfoSystemIsEqual(virSysinfoSystemDefPtr src,
- virSysinfoSystemDefPtr dst)
+virSysinfoSystemIsEqual(virSysinfoSystemDef *src,
+ virSysinfoSystemDef *dst)
{
if (!src && !dst)
return true;
}
static bool
-virSysinfoBaseBoardIsEqual(virSysinfoBaseBoardDefPtr src,
- virSysinfoBaseBoardDefPtr dst)
+virSysinfoBaseBoardIsEqual(virSysinfoBaseBoardDef *src,
+ virSysinfoBaseBoardDef *dst)
{
if (!src && !dst)
return true;
static bool
-virSysinfoChassisIsEqual(virSysinfoChassisDefPtr src,
- virSysinfoChassisDefPtr dst)
+virSysinfoChassisIsEqual(virSysinfoChassisDef *src,
+ virSysinfoChassisDef *dst)
{
if (!src && !dst)
return true;
#undef CHECK_FIELD
-bool virSysinfoIsEqual(virSysinfoDefPtr src,
- virSysinfoDefPtr dst)
+bool virSysinfoIsEqual(virSysinfoDef *src,
+ virSysinfoDef *dst)
{
size_t i;
} virSysinfoType;
typedef struct _virSysinfoProcessorDef virSysinfoProcessorDef;
-typedef virSysinfoProcessorDef *virSysinfoProcessorDefPtr;
struct _virSysinfoProcessorDef {
char *processor_socket_destination;
char *processor_type;
};
typedef struct _virSysinfoMemoryDef virSysinfoMemoryDef;
-typedef virSysinfoMemoryDef *virSysinfoMemoryDefPtr;
struct _virSysinfoMemoryDef {
char *memory_size;
char *memory_form_factor;
};
typedef struct _virSysinfoBIOSDef virSysinfoBIOSDef;
-typedef virSysinfoBIOSDef *virSysinfoBIOSDefPtr;
struct _virSysinfoBIOSDef {
char *vendor;
char *version;
};
typedef struct _virSysinfoSystemDef virSysinfoSystemDef;
-typedef virSysinfoSystemDef *virSysinfoSystemDefPtr;
struct _virSysinfoSystemDef {
char *manufacturer;
char *product;
};
typedef struct _virSysinfoBaseBoardDef virSysinfoBaseBoardDef;
-typedef virSysinfoBaseBoardDef *virSysinfoBaseBoardDefPtr;
struct _virSysinfoBaseBoardDef {
char *manufacturer;
char *product;
};
typedef struct _virSysinfoChassisDef virSysinfoChassisDef;
-typedef virSysinfoChassisDef *virSysinfoChassisDefPtr;
struct _virSysinfoChassisDef {
char *manufacturer;
char *version;
};
typedef struct _virSysinfoOEMStringsDef virSysinfoOEMStringsDef;
-typedef virSysinfoOEMStringsDef *virSysinfoOEMStringsDefPtr;
struct _virSysinfoOEMStringsDef {
size_t nvalues;
char **values;
};
typedef struct _virSysinfoFWCfgDef virSysinfoFWCfgDef;
-typedef virSysinfoFWCfgDef *virSysinfoFWCfgDefPtr;
struct _virSysinfoFWCfgDef {
char *name;
char *value;
};
typedef struct _virSysinfoDef virSysinfoDef;
-typedef virSysinfoDef *virSysinfoDefPtr;
struct _virSysinfoDef {
virSysinfoType type;
/* The following members are valid for type == VIR_SYSINFO_SMBIOS */
- virSysinfoBIOSDefPtr bios;
- virSysinfoSystemDefPtr system;
+ virSysinfoBIOSDef *bios;
+ virSysinfoSystemDef *system;
size_t nbaseBoard;
- virSysinfoBaseBoardDefPtr baseBoard;
+ virSysinfoBaseBoardDef *baseBoard;
- virSysinfoChassisDefPtr chassis;
+ virSysinfoChassisDef *chassis;
size_t nprocessor;
- virSysinfoProcessorDefPtr processor;
+ virSysinfoProcessorDef *processor;
size_t nmemory;
- virSysinfoMemoryDefPtr memory;
+ virSysinfoMemoryDef *memory;
- virSysinfoOEMStringsDefPtr oemStrings;
+ virSysinfoOEMStringsDef *oemStrings;
/* The following members are valid for type == VIR_SYSINFO_FWCFG */
size_t nfw_cfgs;
- virSysinfoFWCfgDefPtr fw_cfgs;
+ virSysinfoFWCfgDef *fw_cfgs;
};
-virSysinfoDefPtr virSysinfoRead(void);
+virSysinfoDef *virSysinfoRead(void);
-void virSysinfoBIOSDefFree(virSysinfoBIOSDefPtr def);
-void virSysinfoSystemDefFree(virSysinfoSystemDefPtr def);
-void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDefPtr def);
-void virSysinfoChassisDefFree(virSysinfoChassisDefPtr def);
-void virSysinfoOEMStringsDefFree(virSysinfoOEMStringsDefPtr def);
-void virSysinfoDefFree(virSysinfoDefPtr def);
+void virSysinfoBIOSDefFree(virSysinfoBIOSDef *def);
+void virSysinfoSystemDefFree(virSysinfoSystemDef *def);
+void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDef *def);
+void virSysinfoChassisDefFree(virSysinfoChassisDef *def);
+void virSysinfoOEMStringsDefFree(virSysinfoOEMStringsDef *def);
+void virSysinfoDefFree(virSysinfoDef *def);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSysinfoDef, virSysinfoDefFree);
-int virSysinfoFormat(virBufferPtr buf, virSysinfoDefPtr def)
+int virSysinfoFormat(virBuffer *buf, virSysinfoDef *def)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-bool virSysinfoIsEqual(virSysinfoDefPtr src,
- virSysinfoDefPtr dst);
+bool virSysinfoIsEqual(virSysinfoDef *src,
+ virSysinfoDef *dst);
VIR_ENUM_DECL(virSysinfo);
virSysinfoSetup(const char *sysinfo,
const char *cpuinfo);
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadPPC(void);
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadARM(void);
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadS390(void);
-virSysinfoDefPtr
+virSysinfoDef *
virSysinfoReadDMI(void);
};
typedef struct _virSystemdActivationEntry virSystemdActivationEntry;
-typedef virSystemdActivationEntry *virSystemdActivationEntryPtr;
-
struct _virSystemdActivationEntry {
int *fds;
size_t nfds;
};
-static void virSystemdEscapeName(virBufferPtr buf,
+static void virSystemdEscapeName(virBuffer *buf,
const char *name)
{
static const char hextable[16] = "0123456789abcdef";
static void
virSystemdActivationEntryFree(void *data)
{
- virSystemdActivationEntryPtr ent = data;
+ virSystemdActivationEntry *ent = data;
size_t i;
VIR_DEBUG("Closing activation FDs");
static int
-virSystemdActivationAddFD(virSystemdActivationPtr act,
+virSystemdActivationAddFD(virSystemdActivation *act,
const char *name,
int fd)
{
- virSystemdActivationEntryPtr ent = virHashLookup(act->fds, name);
+ virSystemdActivationEntry *ent = virHashLookup(act->fds, name);
if (!ent) {
ent = g_new0(virSystemdActivationEntry, 1);
static int
-virSystemdActivationInitFromNames(virSystemdActivationPtr act,
+virSystemdActivationInitFromNames(virSystemdActivation *act,
int nfds,
const char *fdnames)
{
* Delete when min systemd is increased ie RHEL7 dropped
*/
static int
-virSystemdActivationInitFromMap(virSystemdActivationPtr act,
+virSystemdActivationInitFromMap(virSystemdActivation *act,
int nfds,
virSystemdActivationMap *map,
size_t nmap)
#endif /* WIN32 */
-static virSystemdActivationPtr
+static virSystemdActivation *
virSystemdActivationNew(virSystemdActivationMap *map,
size_t nmap,
int nfds)
{
- virSystemdActivationPtr act;
+ virSystemdActivation *act;
const char *fdnames;
VIR_DEBUG("Activated with %d FDs", nfds);
int
virSystemdGetActivation(virSystemdActivationMap *map,
size_t nmap,
- virSystemdActivationPtr *act)
+ virSystemdActivation **act)
{
int nfds = 0;
* Returns: true if a FD is present, false otherwise
*/
bool
-virSystemdActivationHasName(virSystemdActivationPtr act,
+virSystemdActivationHasName(virSystemdActivation *act,
const char *name)
{
return virHashLookup(act->fds, name) != NULL;
* Returns: 0 on success, -1 if some FDs are unclaimed
*/
int
-virSystemdActivationComplete(virSystemdActivationPtr act)
+virSystemdActivationComplete(virSystemdActivation *act)
{
if (virHashSize(act->fds) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
* the array memory in @fds.
*/
void
-virSystemdActivationClaimFDs(virSystemdActivationPtr act,
+virSystemdActivationClaimFDs(virSystemdActivation *act,
const char *name,
int **fds,
size_t *nfds)
{
- virSystemdActivationEntryPtr ent = virHashSteal(act->fds, name);
+ virSystemdActivationEntry *ent = virHashSteal(act->fds, name);
if (!ent) {
*fds = NULL;
* associated with the activation object
*/
void
-virSystemdActivationFree(virSystemdActivationPtr act)
+virSystemdActivationFree(virSystemdActivation *act)
{
if (!act)
return;
#include "internal.h"
typedef struct _virSystemdActivation virSystemdActivation;
-typedef virSystemdActivation *virSystemdActivationPtr;
/*
* Back compat for systemd < v227 which lacks LISTEN_FDNAMES.
int virSystemdGetActivation(virSystemdActivationMap *map,
size_t nmap,
- virSystemdActivationPtr *act);
+ virSystemdActivation **act);
-bool virSystemdActivationHasName(virSystemdActivationPtr act,
+bool virSystemdActivationHasName(virSystemdActivation *act,
const char *name);
-int virSystemdActivationComplete(virSystemdActivationPtr act);
+int virSystemdActivationComplete(virSystemdActivation *act);
-void virSystemdActivationClaimFDs(virSystemdActivationPtr act,
+void virSystemdActivationClaimFDs(virSystemdActivation *act,
const char *name,
int **fds,
size_t *nfds);
-void virSystemdActivationFree(virSystemdActivationPtr act);
+void virSystemdActivationFree(virSystemdActivation *act);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virSystemdActivation, virSystemdActivationFree);
#include "virthreadjob.h"
-int virOnce(virOnceControlPtr once, virOnceFunc init)
+int virOnce(virOnceControl *once, virOnceFunc init)
{
return pthread_once(&once->once, init);
}
-int virMutexInit(virMutexPtr m)
+int virMutexInit(virMutex *m)
{
int ret;
pthread_mutexattr_t attr;
return 0;
}
-int virMutexInitRecursive(virMutexPtr m)
+int virMutexInitRecursive(virMutex *m)
{
int ret;
pthread_mutexattr_t attr;
return 0;
}
-void virMutexDestroy(virMutexPtr m)
+void virMutexDestroy(virMutex *m)
{
pthread_mutex_destroy(&m->lock);
}
-void virMutexLock(virMutexPtr m)
+void virMutexLock(virMutex *m)
{
pthread_mutex_lock(&m->lock);
}
-void virMutexUnlock(virMutexPtr m)
+void virMutexUnlock(virMutex *m)
{
pthread_mutex_unlock(&m->lock);
}
-int virRWLockInit(virRWLockPtr m)
+int virRWLockInit(virRWLock *m)
{
int ret;
ret = pthread_rwlock_init(&m->lock, NULL);
return 0;
}
-void virRWLockDestroy(virRWLockPtr m)
+void virRWLockDestroy(virRWLock *m)
{
pthread_rwlock_destroy(&m->lock);
}
-void virRWLockRead(virRWLockPtr m)
+void virRWLockRead(virRWLock *m)
{
pthread_rwlock_rdlock(&m->lock);
}
-void virRWLockWrite(virRWLockPtr m)
+void virRWLockWrite(virRWLock *m)
{
pthread_rwlock_wrlock(&m->lock);
}
-void virRWLockUnlock(virRWLockPtr m)
+void virRWLockUnlock(virRWLock *m)
{
pthread_rwlock_unlock(&m->lock);
}
-int virCondInit(virCondPtr c)
+int virCondInit(virCond *c)
{
int ret;
if ((ret = pthread_cond_init(&c->cond, NULL)) != 0) {
return 0;
}
-int virCondDestroy(virCondPtr c)
+int virCondDestroy(virCond *c)
{
int ret;
if ((ret = pthread_cond_destroy(&c->cond)) != 0) {
return 0;
}
-int virCondWait(virCondPtr c, virMutexPtr m)
+int virCondWait(virCond *c, virMutex *m)
{
int ret;
if ((ret = pthread_cond_wait(&c->cond, &m->lock)) != 0) {
return 0;
}
-int virCondWaitUntil(virCondPtr c, virMutexPtr m, unsigned long long whenms)
+int virCondWaitUntil(virCond *c, virMutex *m, unsigned long long whenms)
{
int ret;
struct timespec ts;
return 0;
}
-void virCondSignal(virCondPtr c)
+void virCondSignal(virCond *c)
{
pthread_cond_signal(&c->cond);
}
-void virCondBroadcast(virCondPtr c)
+void virCondBroadcast(virCond *c)
{
pthread_cond_broadcast(&c->cond);
}
return NULL;
}
-int virThreadCreateFull(virThreadPtr thread,
+int virThreadCreateFull(virThread *thread,
bool joinable,
virThreadFunc func,
const char *name,
return ret;
}
-void virThreadSelf(virThreadPtr thread)
+void virThreadSelf(virThread *thread)
{
thread->thread = pthread_self();
}
-bool virThreadIsSelf(virThreadPtr thread)
+bool virThreadIsSelf(virThread *thread)
{
return pthread_equal(pthread_self(), thread->thread) ? true : false;
}
/* For debugging use only; this result is not guaranteed unique if
* pthread_t is larger than a 64-bit pointer, nor does it always match
* the thread id of virThreadSelfID on Linux. */
-unsigned long long virThreadID(virThreadPtr thread)
+unsigned long long virThreadID(virThread *thread)
{
union {
unsigned long long l;
return u.l;
}
-void virThreadJoin(virThreadPtr thread)
+void virThreadJoin(virThread *thread)
{
pthread_join(thread->thread, NULL);
}
-void virThreadCancel(virThreadPtr thread)
+void virThreadCancel(virThread *thread)
{
pthread_cancel(thread->thread);
}
-int virThreadLocalInit(virThreadLocalPtr l,
+int virThreadLocalInit(virThreadLocal *l,
virThreadLocalCleanup c)
{
int ret;
return 0;
}
-void *virThreadLocalGet(virThreadLocalPtr l)
+void *virThreadLocalGet(virThreadLocal *l)
{
return pthread_getspecific(l->key);
}
-int virThreadLocalSet(virThreadLocalPtr l, void *val)
+int virThreadLocalSet(virThreadLocal *l, void *val)
{
int err = pthread_setspecific(l->key, val);
if (err) {
#include <pthread.h>
typedef struct virMutex virMutex;
-typedef virMutex *virMutexPtr;
-
struct virMutex {
pthread_mutex_t lock;
};
typedef struct virRWLock virRWLock;
-typedef virRWLock *virRWLockPtr;
-
struct virRWLock {
pthread_rwlock_t lock;
};
typedef struct virCond virCond;
-typedef virCond *virCondPtr;
-
struct virCond {
pthread_cond_t cond;
};
typedef struct virThreadLocal virThreadLocal;
-typedef virThreadLocal *virThreadLocalPtr;
-
struct virThreadLocal {
pthread_key_t key;
};
typedef struct virThread virThread;
-typedef virThread *virThreadPtr;
-
struct virThread {
pthread_t thread;
};
typedef struct virOnceControl virOnceControl;
-typedef virOnceControl *virOnceControlPtr;
-
struct virOnceControl {
pthread_once_t once;
};
#define virThreadCreate(thread, joinable, func, opaque) \
virThreadCreateFull(thread, joinable, func, #func, false, opaque)
-int virThreadCreateFull(virThreadPtr thread,
+int virThreadCreateFull(virThread *thread,
bool joinable,
virThreadFunc func,
const char *name,
bool worker,
void *opaque) G_GNUC_WARN_UNUSED_RESULT;
-void virThreadSelf(virThreadPtr thread);
-bool virThreadIsSelf(virThreadPtr thread);
-void virThreadJoin(virThreadPtr thread);
+void virThreadSelf(virThread *thread);
+bool virThreadIsSelf(virThread *thread);
+void virThreadJoin(virThread *thread);
size_t virThreadMaxName(void);
/* This API is *NOT* for general use. It exists solely as a stub
* for integration with libselinux AVC callbacks */
-void virThreadCancel(virThreadPtr thread);
+void virThreadCancel(virThread *thread);
/* These next two functions are for debugging only, since they are not
* guaranteed to give unique values for distinct threads on all
* architectures, nor are the two functions guaranteed to give the same
* value for the same thread. */
unsigned long long virThreadSelfID(void);
-unsigned long long virThreadID(virThreadPtr thread);
+unsigned long long virThreadID(virThread *thread);
/* Static initialization of mutexes is not possible, so we instead
* provide for guaranteed one-time initialization via a callback
* ...now guaranteed that initializer has completed exactly once
* }
*/
-int virOnce(virOnceControlPtr once, virOnceFunc init)
+int virOnce(virOnceControl *once, virOnceFunc init)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
-int virMutexInit(virMutexPtr m) G_GNUC_WARN_UNUSED_RESULT;
-int virMutexInitRecursive(virMutexPtr m) G_GNUC_WARN_UNUSED_RESULT;
-void virMutexDestroy(virMutexPtr m);
+int virMutexInit(virMutex *m) G_GNUC_WARN_UNUSED_RESULT;
+int virMutexInitRecursive(virMutex *m) G_GNUC_WARN_UNUSED_RESULT;
+void virMutexDestroy(virMutex *m);
-void virMutexLock(virMutexPtr m);
-void virMutexUnlock(virMutexPtr m);
+void virMutexLock(virMutex *m);
+void virMutexUnlock(virMutex *m);
-int virRWLockInit(virRWLockPtr m) G_GNUC_WARN_UNUSED_RESULT;
-void virRWLockDestroy(virRWLockPtr m);
+int virRWLockInit(virRWLock *m) G_GNUC_WARN_UNUSED_RESULT;
+void virRWLockDestroy(virRWLock *m);
-void virRWLockRead(virRWLockPtr m);
-void virRWLockWrite(virRWLockPtr m);
-void virRWLockUnlock(virRWLockPtr m);
+void virRWLockRead(virRWLock *m);
+void virRWLockWrite(virRWLock *m);
+void virRWLockUnlock(virRWLock *m);
-int virCondInit(virCondPtr c) G_GNUC_WARN_UNUSED_RESULT;
-int virCondDestroy(virCondPtr c);
+int virCondInit(virCond *c) G_GNUC_WARN_UNUSED_RESULT;
+int virCondDestroy(virCond *c);
/* virCondWait, virCondWaitUntil:
* These functions can return without the associated predicate
* changing value. Therefore in nearly all cases they
* should be enclosed in a while loop that checks the predicate.
*/
-int virCondWait(virCondPtr c, virMutexPtr m) G_GNUC_WARN_UNUSED_RESULT;
-int virCondWaitUntil(virCondPtr c, virMutexPtr m, unsigned long long whenms) G_GNUC_WARN_UNUSED_RESULT;
+int virCondWait(virCond *c, virMutex *m) G_GNUC_WARN_UNUSED_RESULT;
+int virCondWaitUntil(virCond *c, virMutex *m, unsigned long long whenms) G_GNUC_WARN_UNUSED_RESULT;
-void virCondSignal(virCondPtr c);
-void virCondBroadcast(virCondPtr c);
+void virCondSignal(virCond *c);
+void virCondBroadcast(virCond *c);
typedef void (*virThreadLocalCleanup)(void *);
-int virThreadLocalInit(virThreadLocalPtr l,
+int virThreadLocalInit(virThreadLocal *l,
virThreadLocalCleanup c) G_GNUC_WARN_UNUSED_RESULT;
-void *virThreadLocalGet(virThreadLocalPtr l);
-int virThreadLocalSet(virThreadLocalPtr l, void*) G_GNUC_WARN_UNUSED_RESULT;
+void *virThreadLocalGet(virThreadLocal *l);
+int virThreadLocalSet(virThreadLocal *l, void*) G_GNUC_WARN_UNUSED_RESULT;
/**
#define VIR_FROM_THIS VIR_FROM_NONE
typedef struct _virThreadPoolJob virThreadPoolJob;
-typedef virThreadPoolJob *virThreadPoolJobPtr;
-
struct _virThreadPoolJob {
- virThreadPoolJobPtr prev;
- virThreadPoolJobPtr next;
+ virThreadPoolJob *prev;
+ virThreadPoolJob *next;
unsigned int priority;
void *data;
};
typedef struct _virThreadPoolJobList virThreadPoolJobList;
-typedef virThreadPoolJobList *virThreadPoolJobListPtr;
-
struct _virThreadPoolJobList {
- virThreadPoolJobPtr head;
- virThreadPoolJobPtr tail;
- virThreadPoolJobPtr firstPrio;
+ virThreadPoolJob *head;
+ virThreadPoolJob *tail;
+ virThreadPoolJob *firstPrio;
};
size_t minWorkers;
size_t freeWorkers;
size_t nWorkers;
- virThreadPtr workers;
+ virThread *workers;
size_t maxPrioWorkers;
size_t nPrioWorkers;
- virThreadPtr prioWorkers;
+ virThread *prioWorkers;
virCond prioCond;
};
struct virThreadPoolWorkerData {
- virThreadPoolPtr pool;
- virCondPtr cond;
+ virThreadPool *pool;
+ virCond *cond;
bool priority;
};
static void virThreadPoolWorker(void *opaque)
{
struct virThreadPoolWorkerData *data = opaque;
- virThreadPoolPtr pool = data->pool;
- virCondPtr cond = data->cond;
+ virThreadPool *pool = data->pool;
+ virCond *cond = data->cond;
bool priority = data->priority;
size_t *curWorkers = priority ? &pool->nPrioWorkers : &pool->nWorkers;
size_t *maxLimit = priority ? &pool->maxPrioWorkers : &pool->maxWorkers;
- virThreadPoolJobPtr job = NULL;
+ virThreadPoolJob *job = NULL;
VIR_FREE(data);
}
if (job == pool->jobList.firstPrio) {
- virThreadPoolJobPtr tmp = job->next;
+ virThreadPoolJob *tmp = job->next;
while (tmp) {
if (tmp->priority)
break;
}
static int
-virThreadPoolExpand(virThreadPoolPtr pool, size_t gain, bool priority)
+virThreadPoolExpand(virThreadPool *pool, size_t gain, bool priority)
{
- virThreadPtr *workers = priority ? &pool->prioWorkers : &pool->workers;
+ virThread **workers = priority ? &pool->prioWorkers : &pool->workers;
size_t *curWorkers = priority ? &pool->nPrioWorkers : &pool->nWorkers;
size_t i = 0;
struct virThreadPoolWorkerData *data = NULL;
return -1;
}
-virThreadPoolPtr
+virThreadPool *
virThreadPoolNewFull(size_t minWorkers,
size_t maxWorkers,
size_t prioWorkers,
const char *name,
void *opaque)
{
- virThreadPoolPtr pool;
+ virThreadPool *pool;
if (minWorkers > maxWorkers)
minWorkers = maxWorkers;
static void
-virThreadPoolStopLocked(virThreadPoolPtr pool)
+virThreadPoolStopLocked(virThreadPool *pool)
{
if (pool->quit)
return;
static void
-virThreadPoolDrainLocked(virThreadPoolPtr pool)
+virThreadPoolDrainLocked(virThreadPool *pool)
{
- virThreadPoolJobPtr job;
+ virThreadPoolJob *job;
virThreadPoolStopLocked(pool);
}
}
-void virThreadPoolFree(virThreadPoolPtr pool)
+void virThreadPoolFree(virThreadPool *pool)
{
if (!pool)
return;
}
-size_t virThreadPoolGetMinWorkers(virThreadPoolPtr pool)
+size_t virThreadPoolGetMinWorkers(virThreadPool *pool)
{
size_t ret;
return ret;
}
-size_t virThreadPoolGetMaxWorkers(virThreadPoolPtr pool)
+size_t virThreadPoolGetMaxWorkers(virThreadPool *pool)
{
size_t ret;
return ret;
}
-size_t virThreadPoolGetPriorityWorkers(virThreadPoolPtr pool)
+size_t virThreadPoolGetPriorityWorkers(virThreadPool *pool)
{
size_t ret;
return ret;
}
-size_t virThreadPoolGetCurrentWorkers(virThreadPoolPtr pool)
+size_t virThreadPoolGetCurrentWorkers(virThreadPool *pool)
{
size_t ret;
return ret;
}
-size_t virThreadPoolGetFreeWorkers(virThreadPoolPtr pool)
+size_t virThreadPoolGetFreeWorkers(virThreadPool *pool)
{
size_t ret;
return ret;
}
-size_t virThreadPoolGetJobQueueDepth(virThreadPoolPtr pool)
+size_t virThreadPoolGetJobQueueDepth(virThreadPool *pool)
{
size_t ret;
* @priority - job priority
* Return: 0 on success, -1 otherwise
*/
-int virThreadPoolSendJob(virThreadPoolPtr pool,
+int virThreadPoolSendJob(virThreadPool *pool,
unsigned int priority,
void *jobData)
{
- virThreadPoolJobPtr job;
+ virThreadPoolJob *job;
virMutexLock(&pool->mutex);
if (pool->quit)
}
int
-virThreadPoolSetParameters(virThreadPoolPtr pool,
+virThreadPoolSetParameters(virThreadPool *pool,
long long int minWorkers,
long long int maxWorkers,
long long int prioWorkers)
}
void
-virThreadPoolStop(virThreadPoolPtr pool)
+virThreadPoolStop(virThreadPool *pool)
{
virMutexLock(&pool->mutex);
virThreadPoolStopLocked(pool);
}
void
-virThreadPoolDrain(virThreadPoolPtr pool)
+virThreadPoolDrain(virThreadPool *pool)
{
virMutexLock(&pool->mutex);
virThreadPoolDrainLocked(pool);
#include "internal.h"
typedef struct _virThreadPool virThreadPool;
-typedef virThreadPool *virThreadPoolPtr;
typedef void (*virThreadPoolJobFunc)(void *jobdata, void *opaque);
-virThreadPoolPtr virThreadPoolNewFull(size_t minWorkers,
+virThreadPool *virThreadPoolNewFull(size_t minWorkers,
size_t maxWorkers,
size_t prioWorkers,
virThreadPoolJobFunc func,
const char *name,
void *opaque) ATTRIBUTE_NONNULL(4);
-size_t virThreadPoolGetMinWorkers(virThreadPoolPtr pool);
-size_t virThreadPoolGetMaxWorkers(virThreadPoolPtr pool);
-size_t virThreadPoolGetPriorityWorkers(virThreadPoolPtr pool);
-size_t virThreadPoolGetCurrentWorkers(virThreadPoolPtr pool);
-size_t virThreadPoolGetFreeWorkers(virThreadPoolPtr pool);
-size_t virThreadPoolGetJobQueueDepth(virThreadPoolPtr pool);
+size_t virThreadPoolGetMinWorkers(virThreadPool *pool);
+size_t virThreadPoolGetMaxWorkers(virThreadPool *pool);
+size_t virThreadPoolGetPriorityWorkers(virThreadPool *pool);
+size_t virThreadPoolGetCurrentWorkers(virThreadPool *pool);
+size_t virThreadPoolGetFreeWorkers(virThreadPool *pool);
+size_t virThreadPoolGetJobQueueDepth(virThreadPool *pool);
-void virThreadPoolFree(virThreadPoolPtr pool);
+void virThreadPoolFree(virThreadPool *pool);
-int virThreadPoolSendJob(virThreadPoolPtr pool,
+int virThreadPoolSendJob(virThreadPool *pool,
unsigned int priority,
void *jobdata) ATTRIBUTE_NONNULL(1)
G_GNUC_WARN_UNUSED_RESULT;
-int virThreadPoolSetParameters(virThreadPoolPtr pool,
+int virThreadPoolSetParameters(virThreadPool *pool,
long long int minWorkers,
long long int maxWorkers,
long long int prioWorkers);
-void virThreadPoolStop(virThreadPoolPtr pool);
-void virThreadPoolDrain(virThreadPoolPtr pool);
+void virThreadPoolStop(virThreadPool *pool);
+void virThreadPoolDrain(virThreadPool *pool);
static virMutex swtpm_tools_lock = VIR_MUTEX_INITIALIZER;
static char *swtpm_path;
static struct stat swtpm_stat;
-static virBitmapPtr swtpm_caps;
+static virBitmap *swtpm_caps;
static char *swtpm_setup;
static struct stat swtpm_setup_stat;
-static virBitmapPtr swtpm_setup_caps;
+static virBitmap *swtpm_setup_caps;
static char *swtpm_ioctl;
static struct stat swtpm_ioctl_stat;
* ]
* }
*/
-static virBitmapPtr
-virTPMExecGetCaps(virCommandPtr cmd,
+static virBitmap *
+virTPMExecGetCaps(virCommand *cmd,
TypeFromStringFn typeFromStringFn)
{
int exitstatus;
- virBitmapPtr bitmap;
+ virBitmap *bitmap;
g_autofree char *outbuf = NULL;
g_autoptr(virJSONValue) json = NULL;
- virJSONValuePtr featureList;
- virJSONValuePtr item;
+ virJSONValue *featureList;
+ virJSONValue *item;
size_t idx;
const char *str;
int typ;
return bitmap;
}
-static virBitmapPtr
+static virBitmap *
virTPMGetCaps(TypeFromStringFn typeFromStringFn,
const char *exec, const char *param1)
{
char **path;
struct stat *stat;
const char *parm;
- virBitmapPtr *caps;
+ virBitmap **caps;
TypeFromStringFn typeFromStringFn;
} prgs[] = {
{
* Returns nothing.
*/
void
-virTypedParamsRemoteFree(virTypedParameterRemotePtr remote_params_val,
+virTypedParamsRemoteFree(struct _virTypedParameterRemote *remote_params_val,
unsigned int remote_params_len)
{
size_t i;
* Returns 0 on success or -1 in case of an error.
*/
int
-virTypedParamsDeserialize(virTypedParameterRemotePtr remote_params,
+virTypedParamsDeserialize(struct _virTypedParameterRemote *remote_params,
unsigned int remote_params_len,
int limit,
virTypedParameterPtr *params,
/* Deserialize the result. */
for (i = 0; i < remote_params_len; ++i) {
virTypedParameterPtr param = *params + i;
- virTypedParameterRemotePtr remote_param = remote_params + i;
+ struct _virTypedParameterRemote *remote_param = remote_params + i;
if (virStrcpyStatic(param->field,
remote_param->field) < 0) {
virTypedParamsSerialize(virTypedParameterPtr params,
int nparams,
int limit,
- virTypedParameterRemotePtr *remote_params_val,
+ struct _virTypedParameterRemote **remote_params_val,
unsigned int *remote_params_len,
unsigned int flags)
{
size_t i;
size_t j;
int rv = -1;
- virTypedParameterRemotePtr params_val = NULL;
+ struct _virTypedParameterRemote *params_val = NULL;
int params_len = nparams;
if (nparams > limit) {
for (i = 0, j = 0; i < nparams; ++i) {
virTypedParameterPtr param = params + i;
- virTypedParameterRemotePtr val = params_val + j;
+ struct _virTypedParameterRemote *val = params_val + j;
/* NOTE: Following snippet is relevant to server only, because
* virDomainGetCPUStats can return a sparse array; also, we can't pass
* back strings to older clients. */
void
-virTypedParamListFree(virTypedParamListPtr list)
+virTypedParamListFree(virTypedParamList *list)
{
if (!list)
return;
size_t
-virTypedParamListStealParams(virTypedParamListPtr list,
+virTypedParamListStealParams(virTypedParamList *list,
virTypedParameterPtr *params)
{
size_t ret = list->npar;
static virTypedParameterPtr
-virTypedParamListExtend(virTypedParamListPtr list)
+virTypedParamListExtend(virTypedParamList *list)
{
VIR_RESIZE_N(list->par, list->par_alloc, list->npar, 1);
int
-virTypedParamListAddInt(virTypedParamListPtr list,
+virTypedParamListAddInt(virTypedParamList *list,
int value,
const char *namefmt,
...)
int
-virTypedParamListAddUInt(virTypedParamListPtr list,
+virTypedParamListAddUInt(virTypedParamList *list,
unsigned int value,
const char *namefmt,
...)
int
-virTypedParamListAddLLong(virTypedParamListPtr list,
+virTypedParamListAddLLong(virTypedParamList *list,
long long value,
const char *namefmt,
...)
int
-virTypedParamListAddULLong(virTypedParamListPtr list,
+virTypedParamListAddULLong(virTypedParamList *list,
unsigned long long value,
const char *namefmt,
...)
int
-virTypedParamListAddString(virTypedParamListPtr list,
+virTypedParamListAddString(virTypedParamList *list,
const char *value,
const char *namefmt,
...)
int
-virTypedParamListAddBoolean(virTypedParamListPtr list,
+virTypedParamListAddBoolean(virTypedParamList *list,
bool value,
const char *namefmt,
...)
int
-virTypedParamListAddDouble(virTypedParamListPtr list,
+virTypedParamListAddDouble(virTypedParamList *list,
double value,
const char *namefmt,
...)
G_STATIC_ASSERT(!(VIR_TYPED_PARAM_LAST & VIR_TYPED_PARAM_MULTIPLE));
typedef struct _virTypedParameterRemoteValue virTypedParameterRemoteValue;
-typedef struct virTypedParameterRemoteValue *virTypedParameterRemoteValuePtr;
-
struct _virTypedParameterRemoteValue {
int type;
union {
} remote_typed_param_value;
};
-typedef struct _virTypedParameterRemote *virTypedParameterRemotePtr;
struct _virTypedParameterRemote {
char *field;
char *virTypedParameterToString(virTypedParameterPtr param);
-void virTypedParamsRemoteFree(virTypedParameterRemotePtr remote_params_val,
+void virTypedParamsRemoteFree(struct _virTypedParameterRemote *remote_params_val,
unsigned int remote_params_len);
-int virTypedParamsDeserialize(virTypedParameterRemotePtr remote_params,
+int virTypedParamsDeserialize(struct _virTypedParameterRemote *remote_params,
unsigned int remote_params_len,
int limit,
virTypedParameterPtr *params,
int virTypedParamsSerialize(virTypedParameterPtr params,
int nparams,
int limit,
- virTypedParameterRemotePtr *remote_params_val,
+ struct _virTypedParameterRemote **remote_params_val,
unsigned int *remote_params_len,
unsigned int flags);
} while (0)
typedef struct _virTypedParamList virTypedParamList;
-typedef virTypedParamList *virTypedParamListPtr;
-
struct _virTypedParamList {
virTypedParameterPtr par;
size_t npar;
size_t par_alloc;
};
-void virTypedParamListFree(virTypedParamListPtr list);
+void virTypedParamListFree(virTypedParamList *list);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virTypedParamList, virTypedParamListFree);
-size_t virTypedParamListStealParams(virTypedParamListPtr list,
+size_t virTypedParamListStealParams(virTypedParamList *list,
virTypedParameterPtr *params);
-int virTypedParamListAddInt(virTypedParamListPtr list,
+int virTypedParamListAddInt(virTypedParamList *list,
int value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddUInt(virTypedParamListPtr list,
+int virTypedParamListAddUInt(virTypedParamList *list,
unsigned int value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddLLong(virTypedParamListPtr list,
+int virTypedParamListAddLLong(virTypedParamList *list,
long long value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddULLong(virTypedParamListPtr list,
+int virTypedParamListAddULLong(virTypedParamList *list,
unsigned long long value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddString(virTypedParamListPtr list,
+int virTypedParamListAddString(virTypedParamList *list,
const char *value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddBoolean(virTypedParamListPtr list,
+int virTypedParamListAddBoolean(virTypedParamList *list,
bool value,
const char *namefmt,
...)
G_GNUC_PRINTF(3, 4) G_GNUC_WARN_UNUSED_RESULT;
-int virTypedParamListAddDouble(virTypedParamListPtr list,
+int virTypedParamListAddDouble(virTypedParamList *list,
double value,
const char *namefmt,
...)
VIR_LOG_INIT("util.uri");
static int
-virURIParamAppend(virURIPtr uri,
+virURIParamAppend(virURI *uri,
const char *name,
const char *value)
{
static int
-virURIParseParams(virURIPtr uri)
+virURIParseParams(virURI *uri)
{
const char *end, *eq;
const char *query = uri->query;
*
* @returns the parsed uri object with some fixes
*/
-virURIPtr
+virURI *
virURIParse(const char *uri)
{
xmlURIPtr xmluri;
- virURIPtr ret = NULL;
+ virURI *ret = NULL;
xmluri = xmlParseURI(uri);
* @returns the constructed uri as a string
*/
char *
-virURIFormat(virURIPtr uri)
+virURIFormat(virURI *uri)
{
xmlURI xmluri;
g_autofree char *tmpserver = NULL;
}
-char *virURIFormatParams(virURIPtr uri)
+char *virURIFormatParams(virURI *uri)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t i;
*
* Frees the URI
*/
-void virURIFree(virURIPtr uri)
+void virURIFree(virURI *uri)
{
size_t i;
* Returns 0 on success, -1 on error.
*/
int
-virURIResolveAlias(virConfPtr conf, const char *alias, char **uri)
+virURIResolveAlias(virConf *conf, const char *alias, char **uri)
{
int ret = -1;
char **aliases = NULL;
const char *
-virURIGetParam(virURIPtr uri, const char *name)
+virURIGetParam(virURI *uri, const char *name)
{
size_t i;
* Returns: true if the URI might be proxied to a remote server
*/
bool
-virURICheckUnixSocket(virURIPtr uri)
+virURICheckUnixSocket(virURI *uri)
{
size_t i = 0;
#include "virconf.h"
typedef struct _virURI virURI;
-typedef virURI *virURIPtr;
typedef struct _virURIParam virURIParam;
-typedef virURIParam *virURIParamPtr;
-
struct _virURIParam {
char *name; /* Name (unescaped). */
char *value; /* Value (unescaped). */
size_t paramsCount;
size_t paramsAlloc;
- virURIParamPtr params;
+ virURIParam *params;
};
-virURIPtr virURIParse(const char *uri)
+virURI *virURIParse(const char *uri)
ATTRIBUTE_NONNULL(1);
-char *virURIFormat(virURIPtr uri)
+char *virURIFormat(virURI *uri)
ATTRIBUTE_NONNULL(1);
-char *virURIFormatParams(virURIPtr uri);
+char *virURIFormatParams(virURI *uri);
-void virURIFree(virURIPtr uri);
+void virURIFree(virURI *uri);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virURI, virURIFree);
-int virURIResolveAlias(virConfPtr conf, const char *alias, char **uri);
+int virURIResolveAlias(virConf *conf, const char *alias, char **uri);
-const char *virURIGetParam(virURIPtr uri, const char *name);
+const char *virURIGetParam(virURI *uri, const char *name);
-bool virURICheckUnixSocket(virURIPtr uri);
+bool virURICheckUnixSocket(virURI *uri);
#define VIR_URI_SERVER(uri) ((uri) && (uri)->server ? (uri)->server : "localhost")
struct _virUSBDeviceList {
virObjectLockable parent;
size_t count;
- virUSBDevicePtr *devs;
+ virUSBDevice **devs;
};
typedef enum {
USB_DEVICE_FIND_BY_BUS = 1 << 1,
} virUSBDeviceFindFlags;
-static virClassPtr virUSBDeviceListClass;
+static virClass *virUSBDeviceListClass;
static void virUSBDeviceListDispose(void *obj);
return 0;
}
-static virUSBDeviceListPtr
+static virUSBDeviceList *
virUSBDeviceSearch(unsigned int vendor,
unsigned int product,
unsigned int bus,
bool found = false;
char *ignore = NULL;
struct dirent *de;
- virUSBDeviceListPtr list = NULL;
- virUSBDeviceListPtr ret = NULL;
+ virUSBDeviceList *list = NULL;
+ virUSBDeviceList *ret = NULL;
g_autoptr(virUSBDevice) usb = NULL;
int direrr;
unsigned int product,
const char *vroot,
bool mandatory,
- virUSBDeviceListPtr *devices)
+ virUSBDeviceList **devices)
{
- virUSBDeviceListPtr list;
+ virUSBDeviceList *list;
int count;
if (!(list = virUSBDeviceSearch(vendor, product, 0, 0,
unsigned int devno,
const char *vroot,
bool mandatory,
- virUSBDevicePtr *usb)
+ virUSBDevice **usb)
{
- virUSBDeviceListPtr list;
+ virUSBDeviceList *list;
if (!(list = virUSBDeviceSearch(0, 0, bus, devno,
vroot,
unsigned int devno,
const char *vroot,
bool mandatory,
- virUSBDevicePtr *usb)
+ virUSBDevice **usb)
{
- virUSBDeviceListPtr list;
+ virUSBDeviceList *list;
unsigned int flags = USB_DEVICE_FIND_BY_VENDOR|USB_DEVICE_FIND_BY_BUS;
if (!(list = virUSBDeviceSearch(vendor, product, bus, devno,
return 0;
}
-virUSBDevicePtr
+virUSBDevice *
virUSBDeviceNew(unsigned int bus,
unsigned int devno,
const char *vroot)
{
- virUSBDevicePtr dev;
+ virUSBDevice *dev;
dev = g_new0(virUSBDevice, 1);
}
void
-virUSBDeviceFree(virUSBDevicePtr dev)
+virUSBDeviceFree(virUSBDevice *dev)
{
if (!dev)
return;
}
int
-virUSBDeviceSetUsedBy(virUSBDevicePtr dev,
+virUSBDeviceSetUsedBy(virUSBDevice *dev,
const char *drv_name,
const char *dom_name)
{
}
void
-virUSBDeviceGetUsedBy(virUSBDevicePtr dev,
+virUSBDeviceGetUsedBy(virUSBDevice *dev,
const char **drv_name,
const char **dom_name)
{
*dom_name = dev->used_by_domname;
}
-const char *virUSBDeviceGetName(virUSBDevicePtr dev)
+const char *virUSBDeviceGetName(virUSBDevice *dev)
{
return dev->name;
}
-const char *virUSBDeviceGetPath(virUSBDevicePtr dev)
+const char *virUSBDeviceGetPath(virUSBDevice *dev)
{
return dev->path;
}
-unsigned int virUSBDeviceGetBus(virUSBDevicePtr dev)
+unsigned int virUSBDeviceGetBus(virUSBDevice *dev)
{
return dev->bus;
}
-unsigned int virUSBDeviceGetDevno(virUSBDevicePtr dev)
+unsigned int virUSBDeviceGetDevno(virUSBDevice *dev)
{
return dev->dev;
}
-int virUSBDeviceFileIterate(virUSBDevicePtr dev,
+int virUSBDeviceFileIterate(virUSBDevice *dev,
virUSBDeviceFileActor actor,
void *opaque)
{
return (actor)(dev, dev->path, opaque);
}
-virUSBDeviceListPtr
+virUSBDeviceList *
virUSBDeviceListNew(void)
{
- virUSBDeviceListPtr list;
+ virUSBDeviceList *list;
if (virUSBInitialize() < 0)
return NULL;
static void
virUSBDeviceListDispose(void *obj)
{
- virUSBDeviceListPtr list = obj;
+ virUSBDeviceList *list = obj;
size_t i;
for (i = 0; i < list->count; i++)
}
int
-virUSBDeviceListAdd(virUSBDeviceListPtr list,
- virUSBDevicePtr *dev)
+virUSBDeviceListAdd(virUSBDeviceList *list,
+ virUSBDevice **dev)
{
if (virUSBDeviceListFind(list, *dev)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return VIR_APPEND_ELEMENT(list->devs, list->count, *dev);
}
-virUSBDevicePtr
-virUSBDeviceListGet(virUSBDeviceListPtr list,
+virUSBDevice *
+virUSBDeviceListGet(virUSBDeviceList *list,
int idx)
{
if (idx >= list->count ||
}
size_t
-virUSBDeviceListCount(virUSBDeviceListPtr list)
+virUSBDeviceListCount(virUSBDeviceList *list)
{
return list->count;
}
-virUSBDevicePtr
-virUSBDeviceListSteal(virUSBDeviceListPtr list,
- virUSBDevicePtr dev)
+virUSBDevice *
+virUSBDeviceListSteal(virUSBDeviceList *list,
+ virUSBDevice *dev)
{
- virUSBDevicePtr ret = NULL;
+ virUSBDevice *ret = NULL;
size_t i;
for (i = 0; i < list->count; i++) {
}
void
-virUSBDeviceListDel(virUSBDeviceListPtr list,
- virUSBDevicePtr dev)
+virUSBDeviceListDel(virUSBDeviceList *list,
+ virUSBDevice *dev)
{
virUSBDeviceFree(virUSBDeviceListSteal(list, dev));
}
-virUSBDevicePtr
-virUSBDeviceListFind(virUSBDeviceListPtr list,
- virUSBDevicePtr dev)
+virUSBDevice *
+virUSBDeviceListFind(virUSBDeviceList *list,
+ virUSBDevice *dev)
{
size_t i;
#define USB_DEVFS "/dev/bus/usb/"
typedef struct _virUSBDevice virUSBDevice;
-typedef virUSBDevice *virUSBDevicePtr;
typedef struct _virUSBDeviceList virUSBDeviceList;
-typedef virUSBDeviceList *virUSBDeviceListPtr;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virUSBDeviceList, virObjectUnref);
-virUSBDevicePtr virUSBDeviceNew(unsigned int bus,
+virUSBDevice *virUSBDeviceNew(unsigned int bus,
unsigned int devno,
const char *vroot);
unsigned int devno,
const char *vroot,
bool mandatory,
- virUSBDevicePtr *usb);
+ virUSBDevice **usb);
int virUSBDeviceFindByVendor(unsigned int vendor,
unsigned int product,
const char *vroot,
bool mandatory,
- virUSBDeviceListPtr *devices);
+ virUSBDeviceList **devices);
int virUSBDeviceFind(unsigned int vendor,
unsigned int product,
unsigned int devno,
const char *vroot,
bool mandatory,
- virUSBDevicePtr *usb);
+ virUSBDevice **usb);
-void virUSBDeviceFree(virUSBDevicePtr dev);
-int virUSBDeviceSetUsedBy(virUSBDevicePtr dev,
+void virUSBDeviceFree(virUSBDevice *dev);
+int virUSBDeviceSetUsedBy(virUSBDevice *dev,
const char *drv_name,
const char *dom_name);
-void virUSBDeviceGetUsedBy(virUSBDevicePtr dev,
+void virUSBDeviceGetUsedBy(virUSBDevice *dev,
const char **drv_name,
const char **dom_name);
-const char *virUSBDeviceGetName(virUSBDevicePtr dev);
-const char *virUSBDeviceGetPath(virUSBDevicePtr usb);
+const char *virUSBDeviceGetName(virUSBDevice *dev);
+const char *virUSBDeviceGetPath(virUSBDevice *usb);
-unsigned int virUSBDeviceGetBus(virUSBDevicePtr dev);
-unsigned int virUSBDeviceGetDevno(virUSBDevicePtr dev);
+unsigned int virUSBDeviceGetBus(virUSBDevice *dev);
+unsigned int virUSBDeviceGetDevno(virUSBDevice *dev);
/*
* Callback that will be invoked once for each file
* Should return 0 if successfully processed, or
* -1 to indicate error and abort iteration
*/
-typedef int (*virUSBDeviceFileActor)(virUSBDevicePtr dev,
+typedef int (*virUSBDeviceFileActor)(virUSBDevice *dev,
const char *path, void *opaque);
-int virUSBDeviceFileIterate(virUSBDevicePtr dev,
+int virUSBDeviceFileIterate(virUSBDevice *dev,
virUSBDeviceFileActor actor,
void *opaque);
-virUSBDeviceListPtr virUSBDeviceListNew(void);
-int virUSBDeviceListAdd(virUSBDeviceListPtr list,
- virUSBDevicePtr *dev);
-virUSBDevicePtr virUSBDeviceListGet(virUSBDeviceListPtr list,
+virUSBDeviceList *virUSBDeviceListNew(void);
+int virUSBDeviceListAdd(virUSBDeviceList *list,
+ virUSBDevice **dev);
+virUSBDevice *virUSBDeviceListGet(virUSBDeviceList *list,
int idx);
-size_t virUSBDeviceListCount(virUSBDeviceListPtr list);
-virUSBDevicePtr virUSBDeviceListSteal(virUSBDeviceListPtr list,
- virUSBDevicePtr dev);
-void virUSBDeviceListDel(virUSBDeviceListPtr list,
- virUSBDevicePtr dev);
-virUSBDevicePtr virUSBDeviceListFind(virUSBDeviceListPtr list,
- virUSBDevicePtr dev);
+size_t virUSBDeviceListCount(virUSBDeviceList *list);
+virUSBDevice *virUSBDeviceListSteal(virUSBDeviceList *list,
+ virUSBDevice *dev);
+void virUSBDeviceListDel(virUSBDeviceList *list,
+ virUSBDevice *dev);
+virUSBDevice *virUSBDeviceListFind(virUSBDeviceList *list,
+ virUSBDevice *dev);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virUSBDevice, virUSBDeviceFree);
const char *msg,
...)
{
- virBufferPtr buf = ctx;
+ virBuffer *buf = ctx;
va_list args;
va_start(args, msg);
{}
-virXMLValidatorPtr
+virXMLValidator *
virXMLValidatorInit(const char *schemafile)
{
- virXMLValidatorPtr validator = NULL;
+ virXMLValidator *validator = NULL;
validator = g_new0(virXMLValidator, 1);
int
-virXMLValidatorValidate(virXMLValidatorPtr validator,
+virXMLValidatorValidate(virXMLValidator *validator,
xmlDocPtr doc)
{
if (xmlRelaxNGValidateDoc(validator->rngValid, doc) != 0) {
virXMLValidateAgainstSchema(const char *schemafile,
xmlDocPtr doc)
{
- virXMLValidatorPtr validator = NULL;
+ virXMLValidator *validator = NULL;
int ret = -1;
if (!(validator = virXMLValidatorInit(schemafile)))
void
-virXMLValidatorFree(virXMLValidatorPtr validator)
+virXMLValidatorFree(virXMLValidator *validator)
{
if (!validator)
return;
* Both passed buffers are always consumed and freed.
*/
void
-virXMLFormatElement(virBufferPtr buf,
+virXMLFormatElement(virBuffer *buf,
const char *name,
- virBufferPtr attrBuf,
- virBufferPtr childBuf)
+ virBuffer *attrBuf,
+ virBuffer *childBuf)
{
if ((!attrBuf || virBufferUse(attrBuf) == 0) &&
(!childBuf || virBufferUse(childBuf) == 0))
void
-virXPathContextNodeRestore(virXPathContextNodeSavePtr save)
+virXPathContextNodeRestore(virXPathContextNodeSave *save)
{
if (!save->ctxt)
return;
void
-virXMLNamespaceFormatNS(virBufferPtr buf,
+virXMLNamespaceFormatNS(virBuffer *buf,
virXMLNamespace const *ns)
{
virBufferAsprintf(buf, " xmlns:%s='%s'", ns->prefix, ns->uri);
char *schemafile;
};
typedef struct _virXMLValidator virXMLValidator;
-typedef virXMLValidator *virXMLValidatorPtr;
-virXMLValidatorPtr
+virXMLValidator *
virXMLValidatorInit(const char *schemafile);
int
-virXMLValidatorValidate(virXMLValidatorPtr validator,
+virXMLValidatorValidate(virXMLValidator *validator,
xmlDocPtr doc);
int
xmlNodePtr node);
void
-virXMLValidatorFree(virXMLValidatorPtr validator);
+virXMLValidatorFree(virXMLValidator *validator);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virXMLValidator, virXMLValidatorFree);
void
-virXMLFormatElement(virBufferPtr buf,
+virXMLFormatElement(virBuffer *buf,
const char *name,
- virBufferPtr attrBuf,
- virBufferPtr childBuf);
+ virBuffer *attrBuf,
+ virBuffer *childBuf);
struct _virXPathContextNodeSave {
xmlXPathContextPtr ctxt;
xmlNodePtr node;
};
typedef struct _virXPathContextNodeSave virXPathContextNodeSave;
-typedef virXPathContextNodeSave *virXPathContextNodeSavePtr;
void
-virXPathContextNodeRestore(virXPathContextNodeSavePtr save);
+virXPathContextNodeRestore(virXPathContextNodeSave *save);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(virXPathContextNodeSave, virXPathContextNodeRestore);
typedef int (*virXMLNamespaceParse)(xmlXPathContextPtr ctxt, void **nsdata);
typedef void (*virXMLNamespaceFree)(void *nsdata);
-typedef int (*virXMLNamespaceFormat)(virBufferPtr buf, void *nsdata);
+typedef int (*virXMLNamespaceFormat)(virBuffer *buf, void *nsdata);
typedef const char *(*virXMLNamespaceHref)(void);
struct _virXMLNamespace {
const char *uri;
};
typedef struct _virXMLNamespace virXMLNamespace;
-typedef virXMLNamespace *virXMLNamespacePtr;
void
-virXMLNamespaceFormatNS(virBufferPtr buf,
+virXMLNamespaceFormatNS(virBuffer *buf,
virXMLNamespace const *ns);
int
virXMLNamespaceRegister(xmlXPathContextPtr ctxt,
/* global vbox API, used for all common codes. */
static vboxUniformedAPI gVBoxAPI;
-static virClassPtr vboxDriverClass;
+static virClass *vboxDriverClass;
static virMutex vbox_driver_lock = VIR_MUTEX_INITIALIZER;
-static vboxDriverPtr vbox_driver;
-static vboxDriverPtr vboxDriverObjNew(void);
+static struct _vboxDriver *vbox_driver;
+static struct _vboxDriver *vboxDriverObjNew(void);
static __thread bool vboxDriverDisposed;
static int
-vboxDomainDevicesDefPostParse(virDomainDeviceDefPtr dev G_GNUC_UNUSED,
+vboxDomainDevicesDefPostParse(virDomainDeviceDef *dev G_GNUC_UNUSED,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
.devicesPostParseCallback = vboxDomainDevicesDefPostParse,
};
-static virCapsPtr
+static virCaps *
vboxCapsInit(void)
{
g_autoptr(virCaps) caps = NULL;
- virCapsGuestPtr guest = NULL;
+ virCapsGuest *guest = NULL;
if ((caps = virCapabilitiesNew(virArchFromHost(),
false, false)) == NULL)
static void
vboxDriverDispose(void *obj)
{
- vboxDriverPtr driver = obj;
+ struct _vboxDriver *driver = obj;
vboxDriverDisposed = true;
virObjectUnref(driver->caps);
VIR_ONCE_GLOBAL_INIT(vboxDriver);
-static vboxDriverPtr
+static struct _vboxDriver *
vboxDriverObjNew(void)
{
- vboxDriverPtr driver;
+ struct _vboxDriver *driver;
if (vboxDriverInitialize() < 0)
return NULL;
gVBoxAPI.UPFN.Uninitialize(vbox_driver);
}
-static vboxDriverPtr
+static struct _vboxDriver *
vboxGetDriverConnection(void)
{
virMutexLock(&vbox_driver_lock);
virMutexUnlock(&vbox_driver_lock);
}
-static int openSessionForMachine(vboxDriverPtr data, const unsigned char *dom_uuid,
+static int openSessionForMachine(struct _vboxDriver *data, const unsigned char *dom_uuid,
vboxIID *iid, IMachine **machine)
{
VBOX_IID_INITIALIZE(iid);
static int
-vboxSetStorageController(virDomainControllerDefPtr controller,
- vboxDriverPtr data,
+vboxSetStorageController(virDomainControllerDef *controller,
+ struct _vboxDriver *data,
IMachine *machine)
{
PRUnichar *controllerName = NULL;
static int
-vboxAttachStorageControllers(virDomainDefPtr def,
- vboxDriverPtr data,
+vboxAttachStorageControllers(virDomainDef *def,
+ struct _vboxDriver *data,
IMachine *machine)
{
size_t i;
static virDrvOpenStatus
vboxConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
- vboxDriverPtr driver = NULL;
+ struct _vboxDriver *driver = NULL;
uid_t uid = geteuid();
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int
vboxDomainSave(virDomainPtr dom, const char *path G_GNUC_UNUSED)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IConsole *console = NULL;
vboxIID iid;
IMachine *machine = NULL;
static int vboxConnectGetVersion(virConnectPtr conn, unsigned long *version)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
VIR_DEBUG("%s: in vboxGetVersion", conn->driver->name);
virObjectLock(data);
static int
vboxConnectGetMaxVcpus(virConnectPtr conn, const char *type G_GNUC_UNUSED)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
ISystemProperties *systemProperties = NULL;
PRUint32 maxCPUCount = 0;
int ret = -1;
static char *vboxConnectGetCapabilities(virConnectPtr conn)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
char *ret = NULL;
if (!data->vboxObj)
static int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
PRUint32 state;
nsresult rc;
static int vboxConnectNumOfDomains(virConnectPtr conn)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
PRUint32 state;
nsresult rc;
static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
IMachine *machine;
PRBool isAccessible = PR_FALSE;
virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
vboxIID iid;
char *machineNameUtf8 = NULL;
static virDomainPtr
vboxDomainLookupByName(virConnectPtr conn, const char *name)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
vboxIID iid;
char *machineNameUtf8 = NULL;
}
static void
-vboxSetBootDeviceOrder(virDomainDefPtr def, vboxDriverPtr data,
+vboxSetBootDeviceOrder(virDomainDef *def, struct _vboxDriver *data,
IMachine *machine)
{
ISystemProperties *systemProperties = NULL;
}
static int
-vboxAttachDrives(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachDrives(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
size_t i;
int type, ret = 0;
const char *src = NULL;
nsresult rc = 0;
- virDomainDiskDefPtr disk = NULL;
- virDomainControllerDefPtr cont;
+ virDomainDiskDef *disk = NULL;
+ virDomainControllerDef *cont;
PRUnichar *storageCtlName = NULL;
char *controllerName = NULL;
IMedium *medium = NULL;
}
static void
-vboxAttachSound(virDomainDefPtr def, IMachine *machine)
+vboxAttachSound(virDomainDef *def, IMachine *machine)
{
nsresult rc;
IAudioAdapter *audioAdapter = NULL;
}
static int
-vboxAttachNetwork(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachNetwork(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
ISystemProperties *systemProperties = NULL;
PRUint32 chipsetType = ChipsetType_Null;
}
static void
-vboxAttachSerial(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachSerial(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
ISystemProperties *systemProperties = NULL;
PRUint32 serialPortCount = 0;
}
static void
-vboxAttachParallel(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachParallel(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
ISystemProperties *systemProperties = NULL;
PRUint32 parallelPortCount = 0;
}
static void
-vboxAttachVideo(virDomainDefPtr def, IMachine *machine)
+vboxAttachVideo(virDomainDef *def, IMachine *machine)
{
if ((def->nvideos == 1) &&
(def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_VBOX)) {
}
static void
-vboxAttachDisplay(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachDisplay(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
int vrdpPresent = 0;
int sdlPresent = 0;
char *guiDisplay = NULL;
char *sdlDisplay = NULL;
size_t i = 0;
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
for (i = 0; i < def->ngraphics; i++) {
IVRDEServer *VRDEServer = NULL;
}
static void
-vboxAttachUSB(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachUSB(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
IUSBCommon *USBCommon = NULL;
size_t i = 0;
}
static void
-vboxAttachSharedFolder(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxAttachSharedFolder(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
size_t i;
PRUnichar *nameUtf16;
static virDomainPtr
vboxDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
IMachine *machine = NULL;
IBIOSSettings *bios = NULL;
vboxIID mchiid;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
nsresult rc;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virDomainPtr ret = NULL;
static int vboxDomainUndefineFlags(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
nsresult rc;
static int
vboxStartMachine(virDomainPtr dom, int maxDomID, IMachine *machine, vboxIID *iid)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
int vrdpPresent = 0;
int sdlPresent = 0;
int guiPresent = 0;
static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
unsigned char uuid[VIR_UUID_BUFLEN] = {0};
nsresult rc;
static int vboxDomainIsActive(virDomainPtr dom)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
vboxIID iid;
char *machineNameUtf8 = NULL;
{
/* All domains are persistent. However, we do want to check for
* existence. */
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
int ret = -1;
{
/* VBox domains never have a persistent state that differs from
* current state. However, we do want to check for existence. */
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
int ret = -1;
static int vboxDomainSuspend(virDomainPtr dom)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
IConsole *console = NULL;
static int vboxDomainResume(virDomainPtr dom)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
IConsole *console = NULL;
static int vboxDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
IConsole *console = NULL;
static int vboxDomainReboot(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
IConsole *console = NULL;
static int vboxDomainDestroyFlags(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
IConsole *console = NULL;
static int vboxDomainSetMemory(virDomainPtr dom, unsigned long memory)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
PRUint32 state;
static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
char *machineName = NULL;
PRUnichar *machineNameUtf16 = NULL;
static int vboxDomainGetState(virDomainPtr dom, int *state,
int *reason, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
PRUint32 mstate;
static int vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
PRUint32 CPUCount = nvcpus;
static int vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
ISystemProperties *systemProperties = NULL;
PRUint32 maxCPUCount = 0;
int ret = -1;
}
static void
-vboxHostDeviceGetXMLDesc(vboxDriverPtr data, virDomainDefPtr def, IMachine *machine)
+vboxHostDeviceGetXMLDesc(struct _vboxDriver *data, virDomainDef *def, IMachine *machine)
{
IUSBCommon *USBCommon = NULL;
PRBool enabled = PR_FALSE;
goto release_filters;
/* Alloc mem needed for the filters now */
- def->hostdevs = g_new0(virDomainHostdevDefPtr, def->nhostdevs);
+ def->hostdevs = g_new0(virDomainHostdevDef *, def->nhostdevs);
for (i = 0; i < def->nhostdevs; i++) {
def->hostdevs[i] = virDomainHostdevDefNew();
static int
-vboxDumpStorageControllers(virDomainDefPtr def, IMachine *machine)
+vboxDumpStorageControllers(virDomainDef *def, IMachine *machine)
{
vboxArray storageControllers = VBOX_ARRAY_INITIALIZER;
size_t i = 0;
}
if (type != VIR_DOMAIN_CONTROLLER_TYPE_LAST) {
- virDomainControllerDefPtr cont;
+ virDomainControllerDef *cont;
cont = virDomainDefAddController(def, type, -1, model);
if (!cont) {
static int
-vboxDumpDisks(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxDumpDisks(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER;
int ret = -1;
PRInt32 devicePort, deviceSlot;
PRBool readOnly;
nsresult rc;
- virDomainDiskDefPtr disk = NULL;
- virDomainControllerDefPtr ctrl = NULL;
+ virDomainDiskDef *disk = NULL;
+ virDomainControllerDef *ctrl = NULL;
char *mediumLocUtf8 = NULL;
size_t sdCount = 0, i, j;
}
/* Allocate mem, if fails return error */
- def->disks = g_new0(virDomainDiskDefPtr, def->ndisks);
+ def->disks = g_new0(virDomainDiskDef *, def->ndisks);
for (i = 0; i < def->ndisks; i++) {
disk = virDomainDiskDefNew(NULL);
}
static int
-vboxDumpVideo(virDomainDefPtr def, vboxDriverPtr data G_GNUC_UNUSED,
+vboxDumpVideo(virDomainDef *def, struct _vboxDriver *data G_GNUC_UNUSED,
IMachine *machine)
{
/* dump video options vram/2d/3d/directx/etc. */
PRBool accelerate2DEnabled = PR_FALSE;
/* Currently supports only one graphics card */
- def->videos = g_new0(virDomainVideoDefPtr, 1);
+ def->videos = g_new0(virDomainVideoDef *, 1);
def->nvideos = 1;
def->videos[0] = g_new0(virDomainVideoDef, 1);
}
static int
-vboxDumpDisplay(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxDumpDisplay(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
/* dump display options vrdp/gui/sdl */
PRUnichar *keyUtf16 = NULL;
char *netAddressUtf8 = NULL;
IVRDEServer *VRDEServer = NULL;
PRBool VRDxEnabled = PR_FALSE;
- virDomainGraphicsDefPtr graphics = NULL;
+ virDomainGraphicsDef *graphics = NULL;
int ret = -1;
def->ngraphics = 0;
}
static int
-vboxDumpSharedFolders(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine)
+vboxDumpSharedFolders(virDomainDef *def, struct _vboxDriver *data, IMachine *machine)
{
vboxArray sharedFolders = VBOX_ARRAY_INITIALIZER;
size_t i = 0;
goto cleanup;
}
- def->fss = g_new0(virDomainFSDefPtr, sharedFolders.count);
+ def->fss = g_new0(virDomainFSDef *, sharedFolders.count);
for (i = 0; i < sharedFolders.count; i++) {
ISharedFolder *sharedFolder = sharedFolders.items[i];
return ret;
}
-static virDomainNetDefPtr
-vboxDumpNetwork(vboxDriverPtr data, INetworkAdapter *adapter)
+static virDomainNetDef *
+vboxDumpNetwork(struct _vboxDriver *data, INetworkAdapter *adapter)
{
PRUint32 attachmentType = NetworkAttachmentType_Null;
PRUint32 adapterType = NetworkAdapterType_Null;
PRUnichar *utf16 = NULL;
char *utf8 = NULL;
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
if (!(net = virDomainNetDefNew(data->xmlopt)))
return NULL;
}
static int
-vboxDumpNetworks(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine, PRUint32 networkAdapterCount)
+vboxDumpNetworks(virDomainDef *def, struct _vboxDriver *data, IMachine *machine, PRUint32 networkAdapterCount)
{
size_t i = 0;
for (i = 0; i < networkAdapterCount; i++) {
INetworkAdapter *adapter = NULL;
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
PRBool enabled = PR_FALSE;
gVBoxAPI.UIMachine.GetNetworkAdapter(machine, i, &adapter);
}
static void
-vboxDumpAudio(virDomainDefPtr def, vboxDriverPtr data G_GNUC_UNUSED,
+vboxDumpAudio(virDomainDef *def, struct _vboxDriver *data G_GNUC_UNUSED,
IMachine *machine)
{
/* dump sound card if active */
PRUint32 audioController = AudioControllerType_AC97;
def->nsounds = 1;
- def->sounds = g_new0(virDomainSoundDefPtr, 1);
+ def->sounds = g_new0(virDomainSoundDef *, 1);
def->sounds[0] = g_new0(virDomainSoundDef, 1);
gVBoxAPI.UIAudioAdapter.GetAudioController(audioAdapter, &audioController);
}
static int
-vboxDumpSerial(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine, PRUint32 serialPortCount)
+vboxDumpSerial(virDomainDef *def, struct _vboxDriver *data, IMachine *machine, PRUint32 serialPortCount)
{
PRUint32 serialPortIncCount = 0;
size_t i = 0;
/* Allocate memory for the serial ports which are enabled */
if (def->nserials > 0) {
- def->serials = g_new0(virDomainChrDefPtr, def->nserials);
+ def->serials = g_new0(virDomainChrDef *, def->nserials);
for (i = 0; i < def->nserials; i++) {
def->serials[i] = virDomainChrDefNew(NULL);
}
static int
-vboxDumpParallel(virDomainDefPtr def, vboxDriverPtr data, IMachine *machine, PRUint32 parallelPortCount)
+vboxDumpParallel(virDomainDef *def, struct _vboxDriver *data, IMachine *machine, PRUint32 parallelPortCount)
{
PRUint32 parallelPortIncCount = 0;
size_t i = 0;
/* Allocate memory for the parallel ports which are enabled */
if (def->nparallels > 0) {
- def->parallels = g_new0(virDomainChrDefPtr, def->nparallels);
+ def->parallels = g_new0(virDomainChrDef *, def->nparallels);
for (i = 0; i < def->nparallels; i++) {
def->parallels[i] = virDomainChrDefNew(NULL);
static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
- virDomainDefPtr def = NULL;
+ struct _vboxDriver *data = dom->conn->privateData;
+ virDomainDef *def = NULL;
IMachine *machine = NULL;
vboxIID iid;
PRBool accessible = PR_FALSE;
static int vboxConnectListDefinedDomains(virConnectPtr conn,
char ** const names, int maxnames)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
char *machineName = NULL;
PRUnichar *machineNameUtf16 = NULL;
static int vboxConnectNumOfDefinedDomains(virConnectPtr conn)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
PRUint32 state;
nsresult rc;
const char *xml,
int mediaChangeOnly G_GNUC_UNUSED)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
PRUint32 state;
- virDomainDefPtr def = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ virDomainDef *def = NULL;
+ virDomainDeviceDef *dev = NULL;
nsresult rc;
int ret = -1;
static int vboxDomainDetachDevice(virDomainPtr dom, const char *xml)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IMachine *machine = NULL;
vboxIID iid;
PRUint32 state;
- virDomainDefPtr def = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ virDomainDef *def = NULL;
+ virDomainDeviceDef *dev = NULL;
nsresult rc;
int ret = -1;
static int vboxCloseDisksRecursively(virDomainPtr dom, char *location)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
nsresult rc;
size_t i = 0;
PRUnichar *locationUtf = NULL;
static int
vboxSnapshotRedefine(virDomainPtr dom,
- virDomainSnapshotDefPtr def,
+ virDomainSnapshotDef *def,
bool isCurrent)
{
/*
*
* Finally, we register the machine with the new virtualbox description file.
*/
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
nsresult rc;
PRUnichar *settingsFilePath = NULL;
char *settingsFilePath_Utf8 = NULL;
- virVBoxSnapshotConfMachinePtr snapshotMachineDesc = NULL;
+ virVBoxSnapshotConfMachine *snapshotMachineDesc = NULL;
char *currentSnapshotXmlFilePath = NULL;
PRUnichar *machineNameUtf16 = NULL;
char *machineName = NULL;
int realReadWriteDisksPathSize = 0;
char **realReadOnlyDisksPath = NULL;
int realReadOnlyDisksPathSize = 0;
- virVBoxSnapshotConfSnapshotPtr newSnapshotPtr = NULL;
+ virVBoxSnapshotConfSnapshot *newSnapshotPtr = NULL;
unsigned char snapshotUuid[VIR_UUID_BUFLEN];
- virVBoxSnapshotConfHardDiskPtr *hardDiskToOpen = NULL;
+ virVBoxSnapshotConfHardDisk **hardDiskToOpen = NULL;
size_t hardDiskToOpenSize = 0;
- virVBoxSnapshotConfHardDiskPtr newHardDisk = NULL;
+ virVBoxSnapshotConfHardDisk *newHardDisk = NULL;
char **searchResultTab = NULL;
ssize_t resultSize = 0;
int it = 0;
goto cleanup;
}
for (it = 0; it < realReadWriteDisksPathSize; it++) {
- virVBoxSnapshotConfHardDiskPtr readWriteDisk = NULL;
+ virVBoxSnapshotConfHardDisk *readWriteDisk = NULL;
PRUnichar *locationUtf = NULL;
IMedium *readWriteMedium = NULL;
char *uuid = NULL;
PRUnichar *formatUtf = NULL;
char *format = NULL;
char *parentUuid = NULL;
- virVBoxSnapshotConfHardDiskPtr readOnlyDisk = NULL;
+ virVBoxSnapshotConfHardDisk *readOnlyDisk = NULL;
vboxIID iid, parentiid;
IMedium *parentReadOnlyMedium = NULL;
for (it = 0; it < def->ndisks; it++) {
IMedium *medium = NULL;
PRUnichar *locationUtf16 = NULL;
- virVBoxSnapshotConfHardDiskPtr disk = NULL;
+ virVBoxSnapshotConfHardDisk *disk = NULL;
PRUnichar *formatUtf16 = NULL;
char *format = NULL;
char *uuid = NULL;
const char *xmlDesc,
unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
IConsole *console = NULL;
}
static ISnapshot *
-vboxDomainSnapshotGet(vboxDriverPtr data,
+vboxDomainSnapshotGet(struct _vboxDriver *data,
virDomainPtr dom,
IMachine *machine,
const char *name)
}
static int
-vboxSnapshotGetReadWriteDisks(virDomainSnapshotDefPtr def,
+vboxSnapshotGetReadWriteDisks(virDomainSnapshotDef *def,
virDomainSnapshotPtr snapshot)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
}
static int
-vboxSnapshotGetReadOnlyDisks(virDomainSnapshotDefPtr def,
+vboxSnapshotGetReadOnlyDisks(virDomainSnapshotDef *def,
virDomainSnapshotPtr snapshot)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
ISnapshot *snap = NULL;
IMachine *machine = NULL;
vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER;
size_t i = 0, diskCount = 0, sdCount = 0;
int ret = -1;
- virDomainDefPtr defdom = def->parent.dom;
+ virDomainDef *defdom = def->parent.dom;
if (!data->vboxObj)
return ret;
}
/* Allocate mem, if fails return error */
- defdom->disks = g_new0(virDomainDiskDefPtr, defdom->ndisks);
+ defdom->disks = g_new0(virDomainDiskDef *, defdom->ndisks);
for (i = 0; i < defdom->ndisks; i++) {
- virDomainDiskDefPtr diskDef = virDomainDiskDefNew(NULL);
+ virDomainDiskDef *diskDef = virDomainDiskDefNew(NULL);
if (!diskDef)
goto cleanup;
defdom->disks[i] = diskDef;
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
PRBool online = PR_FALSE;
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *ret = NULL;
- virDomainDefPtr defdom;
+ virDomainDef *defdom;
g_autoptr(virDomainSnapshotDef) def = NULL;
if (!data->vboxObj)
static int vboxDomainSnapshotNum(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
nsresult rc;
static int vboxDomainSnapshotListNames(virDomainPtr dom, char **names,
int nameslen, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
nsresult rc;
vboxDomainSnapshotLookupByName(virDomainPtr dom, const char *name,
unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snapshot = NULL;
static int vboxDomainHasCurrentSnapshot(virDomainPtr dom,
unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snapshot = NULL;
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
static virDomainSnapshotPtr
vboxDomainSnapshotCurrent(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snapshot = NULL;
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID iid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
ISnapshot *newSnapshot = NULL;
}
static int
-vboxDomainSnapshotDeleteSingle(vboxDriverPtr data,
+vboxDomainSnapshotDeleteSingle(struct _vboxDriver *data,
IConsole *console,
ISnapshot *snapshot)
{
}
static int
-vboxDomainSnapshotDeleteTree(vboxDriverPtr data,
+vboxDomainSnapshotDeleteTree(struct _vboxDriver *data,
IConsole *console,
ISnapshot *snapshot)
{
*/
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
- virDomainSnapshotDefPtr def = NULL;
+ struct _vboxDriver *data = dom->conn->privateData;
+ virDomainSnapshotDef *def = NULL;
char *defXml = NULL;
vboxIID domiid;
nsresult rc;
IMachine *machine = NULL;
PRUnichar *settingsFilePathUtf16 = NULL;
char *settingsFilepath = NULL;
- virVBoxSnapshotConfMachinePtr snapshotMachineDesc = NULL;
+ virVBoxSnapshotConfMachine *snapshotMachineDesc = NULL;
int isCurrent = -1;
char **searchResultTab = NULL;
ssize_t resultSize = 0;
VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE);
if (!def) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Unable to get a virDomainSnapshotDefPtr"));
+ _("Unable to get a virDomainSnapshotDef *"));
goto cleanup;
}
*/
if (def->parent.parent_name != NULL) {
for (it = 0; it < def->parent.dom->ndisks; it++) {
- virVBoxSnapshotConfHardDiskPtr readOnly = NULL;
+ virVBoxSnapshotConfHardDisk *readOnly = NULL;
IMedium *medium = NULL;
PRUnichar *locationUtf16 = NULL;
char *parentUuid = NULL;
PRUnichar *newLocation = NULL;
char *newLocationUtf8 = NULL;
IProgress *progress = NULL;
- virVBoxSnapshotConfHardDiskPtr disk = NULL;
+ virVBoxSnapshotConfHardDisk *disk = NULL;
char *uuid = NULL;
char *format = NULL;
char *tmp = NULL;
if (isCurrent) {
VIR_FREE(snapshotMachineDesc->currentSnapshot);
if (def->parent.parent_name != NULL) {
- virVBoxSnapshotConfSnapshotPtr snap = virVBoxSnapshotConfSnapshotByName(snapshotMachineDesc->snapshot, def->parent.parent_name);
+ virVBoxSnapshotConfSnapshot *snap = virVBoxSnapshotConfSnapshotByName(snapshotMachineDesc->snapshot, def->parent.parent_name);
if (!snap) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to get the snapshot to remove"));
unsigned int flags)
{
virDomainPtr dom = snapshot->domain;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxIID domiid;
IMachine *machine = NULL;
ISnapshot *snap = NULL;
unsigned int screen,
unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IConsole *console = NULL;
vboxIID iid;
IMachine *machine = NULL;
virDomainPtr **domains,
unsigned int flags)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
char *machineNameUtf8 = NULL;
PRUnichar *machineNameUtf16 = NULL;
static int
vboxDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
vboxArray machines = VBOX_ARRAY_INITIALIZER;
vboxIID iid;
char *machineNameUtf8 = NULL;
unsigned int flags)
{
int ret = -1;
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IConsole *console = NULL;
vboxIID iid;
IMachine *machine = NULL;
.domainScreenshot = vboxDomainScreenshot, /* 0.9.2 */
};
-virHypervisorDriverPtr vboxGetHypervisorDriver(uint32_t uVersion)
+virHypervisorDriver *vboxGetHypervisorDriver(uint32_t uVersion)
{
/* Install gVBoxAPI according to the vbox API version. */
int result = 0;
#if defined(VBOX_DRIVER)
static virDrvOpenStatus dummyConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
uid_t uid = geteuid();
#include "internal.h"
-virHypervisorDriverPtr vboxGetHypervisorDriver(uint32_t uVersion);
-virNetworkDriverPtr vboxGetNetworkDriver(uint32_t uVersion);
-virStorageDriverPtr vboxGetStorageDriver(uint32_t uVersion);
+virHypervisorDriver *vboxGetHypervisorDriver(uint32_t uVersion);
+virNetworkDriver *vboxGetNetworkDriver(uint32_t uVersion);
+virStorageDriver *vboxGetStorageDriver(uint32_t uVersion);
static int vboxConnectNumOfNetworks(virConnectPtr conn)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
IHost *host = NULL;
size_t i = 0;
static int vboxConnectListNetworks(virConnectPtr conn, char **const names, int nnames)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
IHost *host = NULL;
size_t i = 0;
static int vboxConnectNumOfDefinedNetworks(virConnectPtr conn)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
IHost *host = NULL;
size_t i = 0;
static int vboxConnectListDefinedNetworks(virConnectPtr conn, char **const names, int nnames)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
IHost *host = NULL;
size_t i = 0;
static virNetworkPtr vboxNetworkLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
PRUint32 interfaceType = 0;
char *nameUtf8 = NULL;
PRUnichar *nameUtf16 = NULL;
static virNetworkPtr vboxNetworkLookupByName(virConnectPtr conn, const char *name)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
PRUnichar *nameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
PRUint32 interfaceType = 0;
}
static PRUnichar *
-vboxSocketFormatAddrUtf16(vboxDriverPtr data, virSocketAddrPtr addr)
+vboxSocketFormatAddrUtf16(struct _vboxDriver *data, virSocketAddr *addr)
{
char *utf8 = NULL;
PRUnichar *utf16 = NULL;
static virNetworkPtr
vboxNetworkDefineCreateXML(virConnectPtr conn, const char *xml, bool start)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
PRUnichar *networkInterfaceNameUtf16 = NULL;
char *networkInterfaceNameUtf8 = NULL;
PRUnichar *networkNameUtf16 = NULL;
char *networkNameUtf8 = NULL;
IHostNetworkInterface *networkInterface = NULL;
- virNetworkDefPtr def = virNetworkDefParseString(xml, NULL);
- virNetworkIPDefPtr ipdef = NULL;
+ virNetworkDef *def = virNetworkDefParseString(xml, NULL);
+ virNetworkIPDef *ipdef = NULL;
unsigned char uuid[VIR_UUID_BUFLEN];
vboxIID vboxnetiid;
virSocketAddrRange addr;
static int
vboxNetworkUndefineDestroy(virNetworkPtr network, bool removeinterface)
{
- vboxDriverPtr data = network->conn->privateData;
+ struct _vboxDriver *data = network->conn->privateData;
char *networkNameUtf8 = NULL;
PRUnichar *networkInterfaceNameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
static int vboxNetworkCreate(virNetworkPtr network)
{
- vboxDriverPtr data = network->conn->privateData;
+ struct _vboxDriver *data = network->conn->privateData;
char *networkNameUtf8 = NULL;
PRUnichar *networkInterfaceNameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
}
static int
-vboxSocketParseAddrUtf16(vboxDriverPtr data, const PRUnichar *utf16,
- virSocketAddrPtr addr)
+vboxSocketParseAddrUtf16(struct _vboxDriver *data, const PRUnichar *utf16,
+ virSocketAddr *addr)
{
int result = -1;
char *utf8 = NULL;
static char *vboxNetworkGetXMLDesc(virNetworkPtr network, unsigned int flags)
{
- vboxDriverPtr data = network->conn->privateData;
- virNetworkDefPtr def = NULL;
- virNetworkIPDefPtr ipdef = NULL;
+ struct _vboxDriver *data = network->conn->privateData;
+ virNetworkDef *def = NULL;
+ virNetworkIPDef *ipdef = NULL;
char *networkNameUtf8 = NULL;
PRUnichar *networkInterfaceNameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
.networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
};
-virNetworkDriverPtr vboxGetNetworkDriver(uint32_t uVersion)
+virNetworkDriver *vboxGetNetworkDriver(uint32_t uVersion)
{
/* Install gVBoxAPI according to the vbox API version. */
int result = 0;
#define VIR_FROM_THIS VIR_FROM_VBOX
VIR_LOG_INIT("vbox.vbox_snapshot_conf");
-static virVBoxSnapshotConfHardDiskPtr
+static virVBoxSnapshotConfHardDisk *
virVBoxSnapshotConfCreateVBoxSnapshotConfHardDiskPtr(xmlNodePtr diskNode,
xmlXPathContextPtr xPathContext,
const char *machineLocation)
{
- virVBoxSnapshotConfHardDiskPtr hardDisk = NULL;
+ virVBoxSnapshotConfHardDisk *hardDisk = NULL;
xmlNodePtr *nodes = NULL;
char *uuid = NULL;
char **searchTabResult = NULL;
goto cleanup;
if (n)
- hardDisk->children = g_new0(virVBoxSnapshotConfHardDiskPtr, n);
+ hardDisk->children = g_new0(virVBoxSnapshotConfHardDisk *, n);
hardDisk->nchildren = n;
for (i = 0; i < hardDisk->nchildren; i++) {
hardDisk->children[i] = virVBoxSnapshotConfCreateVBoxSnapshotConfHardDiskPtr(nodes[i], xPathContext, machineLocation);
return hardDisk;
}
-static virVBoxSnapshotConfMediaRegistryPtr
+static virVBoxSnapshotConfMediaRegistry *
virVBoxSnapshotConfRetrieveMediaRegistry(xmlNodePtr mediaRegistryNode,
xmlXPathContextPtr xPathContext,
const char *machineLocation)
{
- virVBoxSnapshotConfMediaRegistryPtr mediaRegistry = NULL;
+ virVBoxSnapshotConfMediaRegistry *mediaRegistry = NULL;
xmlNodePtr hardDisksNode = NULL;
xmlNodePtr *nodes = NULL;
size_t i = 0;
if (n < 0)
goto cleanup;
if (n)
- mediaRegistry->disks = g_new0(virVBoxSnapshotConfHardDiskPtr, n);
+ mediaRegistry->disks = g_new0(virVBoxSnapshotConfHardDisk *, n);
mediaRegistry->ndisks = n;
for (i = 0; i < mediaRegistry->ndisks; i++) {
mediaRegistry->disks[i] = virVBoxSnapshotConfCreateVBoxSnapshotConfHardDiskPtr(nodes[i],
return mediaRegistry;
}
-static virVBoxSnapshotConfSnapshotPtr
+static virVBoxSnapshotConfSnapshot *
virVBoxSnapshotConfRetrieveSnapshot(xmlNodePtr snapshotNode,
xmlXPathContextPtr xPathContext)
{
- virVBoxSnapshotConfSnapshotPtr snapshot = NULL;
+ virVBoxSnapshotConfSnapshot *snapshot = NULL;
xmlNodePtr hardwareNode = NULL;
xmlNodePtr descriptionNode = NULL;
xmlNodePtr storageControllerNode = NULL;
if (n < 0)
goto cleanup;
if (n)
- snapshot->children = g_new0(virVBoxSnapshotConfSnapshotPtr, n);
+ snapshot->children = g_new0(virVBoxSnapshotConfSnapshot *, n);
snapshot->nchildren = n;
for (i = 0; i < snapshot->nchildren; i++) {
snapshot->children[i] = virVBoxSnapshotConfRetrieveSnapshot(nodes[i], xPathContext);
return snapshot;
}
-virVBoxSnapshotConfSnapshotPtr
-virVBoxSnapshotConfSnapshotByName(virVBoxSnapshotConfSnapshotPtr snapshot,
+virVBoxSnapshotConfSnapshot *
+virVBoxSnapshotConfSnapshotByName(virVBoxSnapshotConfSnapshot *snapshot,
const char *snapshotName)
{
size_t i = 0;
- virVBoxSnapshotConfSnapshotPtr ret = NULL;
+ virVBoxSnapshotConfSnapshot *ret = NULL;
if (STREQ(snapshot->name, snapshotName))
return snapshot;
for (i = 0; i < snapshot->nchildren; i++) {
return ret;
}
-static virVBoxSnapshotConfHardDiskPtr
-virVBoxSnapshotConfHardDiskById(virVBoxSnapshotConfHardDiskPtr disk,
+static virVBoxSnapshotConfHardDisk *
+virVBoxSnapshotConfHardDiskById(virVBoxSnapshotConfHardDisk *disk,
const char *parentHardDiskId)
{
size_t i = 0;
- virVBoxSnapshotConfHardDiskPtr ret = NULL;
+ virVBoxSnapshotConfHardDisk *ret = NULL;
if (STREQ(disk->uuid, parentHardDiskId))
return disk;
for (i = 0; i < disk->nchildren; i++) {
return ret;
}
-static virVBoxSnapshotConfHardDiskPtr
-virVBoxSnapshotConfHardDiskByLocation(virVBoxSnapshotConfHardDiskPtr disk,
+static virVBoxSnapshotConfHardDisk *
+virVBoxSnapshotConfHardDiskByLocation(virVBoxSnapshotConfHardDisk *disk,
const char *parentLocation)
{
size_t i = 0;
- virVBoxSnapshotConfHardDiskPtr ret = NULL;
+ virVBoxSnapshotConfHardDisk *ret = NULL;
if (STREQ(disk->location, parentLocation))
return disk;
for (i = 0; i < disk->nchildren; i++) {
}
static xmlNodePtr
-virVBoxSnapshotConfCreateHardDiskNode(virVBoxSnapshotConfHardDiskPtr hardDisk)
+virVBoxSnapshotConfCreateHardDiskNode(virVBoxSnapshotConfHardDisk *hardDisk)
{
int result = -1;
size_t i = 0;
static int
virVBoxSnapshotConfSerializeSnapshot(xmlNodePtr node,
- virVBoxSnapshotConfSnapshotPtr snapshot)
+ virVBoxSnapshotConfSnapshot *snapshot)
{
int result = -1;
size_t i = 0;
}
static size_t
-virVBoxSnapshotConfAllChildren(virVBoxSnapshotConfHardDiskPtr disk,
- virVBoxSnapshotConfHardDiskPtr **list)
+virVBoxSnapshotConfAllChildren(virVBoxSnapshotConfHardDisk *disk,
+ virVBoxSnapshotConfHardDisk ***list)
{
size_t returnSize = 0;
size_t tempSize = 0;
- virVBoxSnapshotConfHardDiskPtr *ret = NULL;
- virVBoxSnapshotConfHardDiskPtr *tempList = NULL;
+ virVBoxSnapshotConfHardDisk **ret = NULL;
+ virVBoxSnapshotConfHardDisk **tempList = NULL;
size_t i = 0;
size_t j = 0;
- ret = g_new0(virVBoxSnapshotConfHardDiskPtr, 0);
+ ret = g_new0(virVBoxSnapshotConfHardDisk *, 0);
for (i = 0; i < disk->nchildren; i++) {
tempSize = virVBoxSnapshotConfAllChildren(disk->children[i], &tempList);
}
void
-virVboxSnapshotConfHardDiskFree(virVBoxSnapshotConfHardDiskPtr disk)
+virVboxSnapshotConfHardDiskFree(virVBoxSnapshotConfHardDisk *disk)
{
size_t i = 0;
void
-virVBoxSnapshotConfMediaRegistryFree(virVBoxSnapshotConfMediaRegistryPtr mediaRegistry)
+virVBoxSnapshotConfMediaRegistryFree(virVBoxSnapshotConfMediaRegistry *mediaRegistry)
{
size_t i = 0;
}
void
-virVBoxSnapshotConfSnapshotFree(virVBoxSnapshotConfSnapshotPtr snapshot)
+virVBoxSnapshotConfSnapshotFree(virVBoxSnapshotConfSnapshot *snapshot)
{
size_t i = 0;
}
void
-virVBoxSnapshotConfMachineFree(virVBoxSnapshotConfMachinePtr machine)
+virVBoxSnapshotConfMachineFree(virVBoxSnapshotConfMachine *machine)
{
if (!machine)
return;
*return NULL on failure
*filePath must not be NULL.
*/
-virVBoxSnapshotConfMachinePtr
+virVBoxSnapshotConfMachine *
virVBoxSnapshotConfLoadVboxFile(const char *filePath,
const char *machineLocation)
{
int ret = -1;
- virVBoxSnapshotConfMachinePtr machineDescription = NULL;
+ virVBoxSnapshotConfMachine *machineDescription = NULL;
xmlDocPtr xml = NULL;
xmlNodePtr machineNode = NULL;
xmlNodePtr cur = NULL;
*return -1 on failure
*/
int
-virVBoxSnapshotConfAddSnapshotToXmlMachine(virVBoxSnapshotConfSnapshotPtr snapshot,
- virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfAddSnapshotToXmlMachine(virVBoxSnapshotConfSnapshot *snapshot,
+ virVBoxSnapshotConfMachine *machine,
const char *snapshotParentName)
{
- virVBoxSnapshotConfSnapshotPtr parentSnapshot = NULL;
+ virVBoxSnapshotConfSnapshot *parentSnapshot = NULL;
if (snapshot == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
*return -1 on failure
*/
int
-virVBoxSnapshotConfAddHardDiskToMediaRegistry(virVBoxSnapshotConfHardDiskPtr hardDisk,
- virVBoxSnapshotConfMediaRegistryPtr mediaRegistry,
+virVBoxSnapshotConfAddHardDiskToMediaRegistry(virVBoxSnapshotConfHardDisk *hardDisk,
+ virVBoxSnapshotConfMediaRegistry *mediaRegistry,
const char *parentHardDiskId)
{
size_t i = 0;
- virVBoxSnapshotConfHardDiskPtr parentDisk = NULL;
+ virVBoxSnapshotConfHardDisk *parentDisk = NULL;
if (hardDisk == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Hard disk is null"));
*return -1 on failure
*/
int
-virVBoxSnapshotConfRemoveSnapshot(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfRemoveSnapshot(virVBoxSnapshotConfMachine *machine,
const char *snapshotName)
{
size_t i = 0;
- virVBoxSnapshotConfSnapshotPtr snapshot = NULL;
- virVBoxSnapshotConfSnapshotPtr parentSnapshot = NULL;
+ virVBoxSnapshotConfSnapshot *snapshot = NULL;
+ virVBoxSnapshotConfSnapshot *parentSnapshot = NULL;
if (machine == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("machine is null"));
*return -1 on failure
*/
int
-virVBoxSnapshotConfRemoveHardDisk(virVBoxSnapshotConfMediaRegistryPtr mediaRegistry,
+virVBoxSnapshotConfRemoveHardDisk(virVBoxSnapshotConfMediaRegistry *mediaRegistry,
const char *uuid)
{
size_t i = 0;
- virVBoxSnapshotConfHardDiskPtr hardDisk = NULL;
- virVBoxSnapshotConfHardDiskPtr parentHardDisk = NULL;
+ virVBoxSnapshotConfHardDisk *hardDisk = NULL;
+ virVBoxSnapshotConfHardDisk *parentHardDisk = NULL;
if (mediaRegistry == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Media registry is null"));
*return -1 on failure
*/
int
-virVBoxSnapshotConfSaveVboxFile(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfSaveVboxFile(virVBoxSnapshotConfMachine *machine,
const char *filePath)
{
int ret = -1;
*vboxSnapshotXmlMachinePtr's current snapshot, return 0 otherwise.
*/
int
-virVBoxSnapshotConfIsCurrentSnapshot(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfIsCurrentSnapshot(virVBoxSnapshotConfMachine *machine,
const char *snapshotName)
{
- virVBoxSnapshotConfSnapshotPtr snapshot = NULL;
+ virVBoxSnapshotConfSnapshot *snapshot = NULL;
if (machine == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Machine is null"));
*return a valid uuid, or NULL on failure
*/
const char *
-virVBoxSnapshotConfHardDiskUuidByLocation(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfHardDiskUuidByLocation(virVBoxSnapshotConfMachine *machine,
const char *location)
{
size_t i = 0;
- virVBoxSnapshotConfHardDiskPtr hardDisk = NULL;
+ virVBoxSnapshotConfHardDisk *hardDisk = NULL;
for (i = 0; i < machine->mediaRegistry->ndisks; i++) {
hardDisk = virVBoxSnapshotConfHardDiskByLocation(machine->mediaRegistry->disks[i], location);
if (hardDisk != NULL)
*return array length on success, -1 on failure.*/
size_t
-virVBoxSnapshotConfDiskListToOpen(virVBoxSnapshotConfMachinePtr machine,
- virVBoxSnapshotConfHardDiskPtr **hardDiskToOpen,
+virVBoxSnapshotConfDiskListToOpen(virVBoxSnapshotConfMachine *machine,
+ virVBoxSnapshotConfHardDisk ***hardDiskToOpen,
const char *location)
{
size_t i = 0;
size_t returnSize = 0;
- virVBoxSnapshotConfHardDiskPtr *ret = NULL;
- virVBoxSnapshotConfHardDiskPtr hardDisk = NULL;
+ virVBoxSnapshotConfHardDisk **ret = NULL;
+ virVBoxSnapshotConfHardDisk *hardDisk = NULL;
for (i = 0; i < machine->mediaRegistry->ndisks; i++) {
hardDisk = virVBoxSnapshotConfHardDiskByLocation(machine->mediaRegistry->disks[i], location);
if (hardDisk != NULL)
}
if (hardDisk == NULL)
return 0;
- ret = g_new0(virVBoxSnapshotConfHardDiskPtr, 1);
+ ret = g_new0(virVBoxSnapshotConfHardDisk *, 1);
returnSize = 1;
ret[returnSize - 1] = hardDisk;
*return -1 on failure
*/
int
-virVBoxSnapshotConfRemoveFakeDisks(virVBoxSnapshotConfMachinePtr machine)
+virVBoxSnapshotConfRemoveFakeDisks(virVBoxSnapshotConfMachine *machine)
{
int ret = -1;
size_t i = 0;
size_t j = 0;
size_t tempSize = 0;
size_t diskSize = 0;
- virVBoxSnapshotConfHardDiskPtr *tempList = NULL;
- virVBoxSnapshotConfHardDiskPtr *diskList = NULL;
+ virVBoxSnapshotConfHardDisk **tempList = NULL;
+ virVBoxSnapshotConfHardDisk **diskList = NULL;
- diskList = g_new0(virVBoxSnapshotConfHardDiskPtr, 0);
+ diskList = g_new0(virVBoxSnapshotConfHardDisk *, 0);
for (i = 0; i < machine->mediaRegistry->ndisks; i++) {
tempSize = virVBoxSnapshotConfAllChildren(machine->mediaRegistry->disks[i], &tempList);
*return -1 on failure
*/
int
-virVBoxSnapshotConfDiskIsInMediaRegistry(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfDiskIsInMediaRegistry(virVBoxSnapshotConfMachine *machine,
const char *location)
{
int ret = -1;
size_t j = 0;
size_t tempSize = 0;
size_t diskSize = 0;
- virVBoxSnapshotConfHardDiskPtr *tempList = NULL;
- virVBoxSnapshotConfHardDiskPtr *diskList = NULL;
+ virVBoxSnapshotConfHardDisk **tempList = NULL;
+ virVBoxSnapshotConfHardDisk **diskList = NULL;
- diskList = g_new0(virVBoxSnapshotConfHardDiskPtr, 0);
+ diskList = g_new0(virVBoxSnapshotConfHardDisk *, 0);
for (i = 0; i < machine->mediaRegistry->ndisks; i++) {
tempSize = virVBoxSnapshotConfAllChildren(machine->mediaRegistry->disks[i], &tempList);
/*
*hardDisksPtrByLocation: Return a vboxSnapshotXmlHardDiskPtr whose location is 'location'
*/
-virVBoxSnapshotConfHardDiskPtr
-virVBoxSnapshotConfHardDiskPtrByLocation(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfHardDisk *
+virVBoxSnapshotConfHardDiskPtrByLocation(virVBoxSnapshotConfMachine *machine,
const char *location)
{
int it = 0;
- virVBoxSnapshotConfHardDiskPtr disk = NULL;
+ virVBoxSnapshotConfHardDisk *disk = NULL;
for (it = 0; it < machine->mediaRegistry->ndisks; it++) {
disk = virVBoxSnapshotConfHardDiskByLocation(machine->mediaRegistry->disks[it], location);
if (disk != NULL)
/*Stores VirtualBox xml hard disk information
A hard disk can have a parent and children*/
typedef struct _virVBoxSnapshotConfHardDisk virVBoxSnapshotConfHardDisk;
-typedef virVBoxSnapshotConfHardDisk *virVBoxSnapshotConfHardDiskPtr;
struct _virVBoxSnapshotConfHardDisk {
- virVBoxSnapshotConfHardDiskPtr parent;
+ virVBoxSnapshotConfHardDisk *parent;
char *uuid;
char *location;
char *format;
char *type;
size_t nchildren;
- virVBoxSnapshotConfHardDiskPtr *children;
+ virVBoxSnapshotConfHardDisk **children;
};
/*Stores Virtualbox xml media registry information
We separate disks from other media to manipulate them*/
typedef struct _virVBoxSnapshotConfMediaRegistry virVBoxSnapshotConfMediaRegistry;
-typedef virVBoxSnapshotConfMediaRegistry *virVBoxSnapshotConfMediaRegistryPtr;
struct _virVBoxSnapshotConfMediaRegistry {
size_t ndisks;
- virVBoxSnapshotConfHardDiskPtr *disks;
+ virVBoxSnapshotConfHardDisk **disks;
size_t notherMedia;
char **otherMedia;
};
/*Stores VirtualBox xml snapshot information
A snapshot can have a parent and children*/
typedef struct _virVBoxSnapshotConfSnapshot virVBoxSnapshotConfSnapshot;
-typedef virVBoxSnapshotConfSnapshot *virVBoxSnapshotConfSnapshotPtr;
struct _virVBoxSnapshotConfSnapshot {
- virVBoxSnapshotConfSnapshotPtr parent;
+ virVBoxSnapshotConfSnapshot *parent;
char *uuid;
char *name;
char *timeStamp;
char *hardware;
char *storageController;
size_t nchildren;
- virVBoxSnapshotConfSnapshotPtr *children;
+ virVBoxSnapshotConfSnapshot **children;
};
/*Stores VirtualBox xml Machine information*/
typedef struct _virVBoxSnapshotConfMachine virVBoxSnapshotConfMachine;
-typedef virVBoxSnapshotConfMachine *virVBoxSnapshotConfMachinePtr;
struct _virVBoxSnapshotConfMachine {
char *uuid;
char *name;
char *snapshotFolder;
int currentStateModified;
char *lastStateChange;
- virVBoxSnapshotConfMediaRegistryPtr mediaRegistry;
+ virVBoxSnapshotConfMediaRegistry *mediaRegistry;
char *hardware;
char *extraData;
- virVBoxSnapshotConfSnapshotPtr snapshot;
+ virVBoxSnapshotConfSnapshot *snapshot;
char *storageController;
};
void
-virVboxSnapshotConfHardDiskFree(virVBoxSnapshotConfHardDiskPtr disk);
+virVboxSnapshotConfHardDiskFree(virVBoxSnapshotConfHardDisk *disk);
void
-virVBoxSnapshotConfMediaRegistryFree(virVBoxSnapshotConfMediaRegistryPtr mediaRegistry);
+virVBoxSnapshotConfMediaRegistryFree(virVBoxSnapshotConfMediaRegistry *mediaRegistry);
void
-virVBoxSnapshotConfSnapshotFree(virVBoxSnapshotConfSnapshotPtr snapshot);
+virVBoxSnapshotConfSnapshotFree(virVBoxSnapshotConfSnapshot *snapshot);
void
-virVBoxSnapshotConfMachineFree(virVBoxSnapshotConfMachinePtr machine);
+virVBoxSnapshotConfMachineFree(virVBoxSnapshotConfMachine *machine);
-virVBoxSnapshotConfMachinePtr
+virVBoxSnapshotConfMachine *
virVBoxSnapshotConfLoadVboxFile(const char *filePath,
const char *machineLocation);
int
-virVBoxSnapshotConfAddSnapshotToXmlMachine(virVBoxSnapshotConfSnapshotPtr snapshot,
- virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfAddSnapshotToXmlMachine(virVBoxSnapshotConfSnapshot *snapshot,
+ virVBoxSnapshotConfMachine *machine,
const char *snapshotParentName);
int
-virVBoxSnapshotConfAddHardDiskToMediaRegistry(virVBoxSnapshotConfHardDiskPtr hardDisk,
- virVBoxSnapshotConfMediaRegistryPtr mediaRegistry,
+virVBoxSnapshotConfAddHardDiskToMediaRegistry(virVBoxSnapshotConfHardDisk *hardDisk,
+ virVBoxSnapshotConfMediaRegistry *mediaRegistry,
const char *parentHardDiskId);
int
-virVBoxSnapshotConfRemoveSnapshot(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfRemoveSnapshot(virVBoxSnapshotConfMachine *machine,
const char *snapshotName);
int
-virVBoxSnapshotConfRemoveHardDisk(virVBoxSnapshotConfMediaRegistryPtr mediaRegistry,
+virVBoxSnapshotConfRemoveHardDisk(virVBoxSnapshotConfMediaRegistry *mediaRegistry,
const char *uuid);
int
-virVBoxSnapshotConfSaveVboxFile(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfSaveVboxFile(virVBoxSnapshotConfMachine *machine,
const char *filePath);
int
-virVBoxSnapshotConfIsCurrentSnapshot(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfIsCurrentSnapshot(virVBoxSnapshotConfMachine *machine,
const char *snapshotName);
int
virVBoxSnapshotConfGetRWDisksPathsFromLibvirtXML(const char *filePath,
virVBoxSnapshotConfGetRODisksPathsFromLibvirtXML(const char *filePath,
char ***realReadOnlyDisksPath);
const char *
-virVBoxSnapshotConfHardDiskUuidByLocation(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfHardDiskUuidByLocation(virVBoxSnapshotConfMachine *machine,
const char *location);
size_t
-virVBoxSnapshotConfDiskListToOpen(virVBoxSnapshotConfMachinePtr machine,
- virVBoxSnapshotConfHardDiskPtr **hardDiskToOpen,
+virVBoxSnapshotConfDiskListToOpen(virVBoxSnapshotConfMachine *machine,
+ virVBoxSnapshotConfHardDisk ***hardDiskToOpen,
const char *location);
int
-virVBoxSnapshotConfRemoveFakeDisks(virVBoxSnapshotConfMachinePtr machine);
+virVBoxSnapshotConfRemoveFakeDisks(virVBoxSnapshotConfMachine *machine);
int
-virVBoxSnapshotConfDiskIsInMediaRegistry(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfDiskIsInMediaRegistry(virVBoxSnapshotConfMachine *machine,
const char *location);
-virVBoxSnapshotConfHardDiskPtr
-virVBoxSnapshotConfHardDiskPtrByLocation(virVBoxSnapshotConfMachinePtr machine,
+virVBoxSnapshotConfHardDisk *
+virVBoxSnapshotConfHardDiskPtrByLocation(virVBoxSnapshotConfMachine *machine,
const char *location);
-virVBoxSnapshotConfSnapshotPtr
-virVBoxSnapshotConfSnapshotByName(virVBoxSnapshotConfSnapshotPtr snapshot,
+virVBoxSnapshotConfSnapshot *
+virVBoxSnapshotConfSnapshotByName(virVBoxSnapshotConfSnapshot *snapshot,
const char *snapshotName);
static int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool)
{
- vboxDriverPtr data = pool->conn->privateData;
+ struct _vboxDriver *data = pool->conn->privateData;
vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
PRUint32 hardDiskAccessible = 0;
nsresult rc;
static int
vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames)
{
- vboxDriverPtr data = pool->conn->privateData;
+ struct _vboxDriver *data = pool->conn->privateData;
vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
PRUint32 numActive = 0;
nsresult rc;
static virStorageVolPtr
vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name)
{
- vboxDriverPtr data = pool->conn->privateData;
+ struct _vboxDriver *data = pool->conn->privateData;
vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
nsresult rc;
size_t i;
static virStorageVolPtr
vboxStorageVolLookupByKey(virConnectPtr conn, const char *key)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
vboxIID hddIID;
unsigned char uuid[VIR_UUID_BUFLEN];
IMedium *hardDisk = NULL;
static virStorageVolPtr
vboxStorageVolLookupByPath(virConnectPtr conn, const char *path)
{
- vboxDriverPtr data = conn->privateData;
+ struct _vboxDriver *data = conn->privateData;
PRUnichar *hddPathUtf16 = NULL;
IMedium *hardDisk = NULL;
PRUnichar *hddNameUtf16 = NULL;
vboxStorageVolCreateXML(virStoragePoolPtr pool,
const char *xml, unsigned int flags)
{
- vboxDriverPtr data = pool->conn->privateData;
+ struct _vboxDriver *data = pool->conn->privateData;
PRUnichar *hddFormatUtf16 = NULL;
PRUnichar *hddNameUtf16 = NULL;
virStoragePoolDef poolDef;
static int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
{
- vboxDriverPtr data = vol->conn->privateData;
+ struct _vboxDriver *data = vol->conn->privateData;
unsigned char uuid[VIR_UUID_BUFLEN];
IMedium *hardDisk = NULL;
int deregister = 0;
static int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info)
{
- vboxDriverPtr data = vol->conn->privateData;
+ struct _vboxDriver *data = vol->conn->privateData;
IMedium *hardDisk = NULL;
unsigned char uuid[VIR_UUID_BUFLEN];
PRUint32 hddstate;
static char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags)
{
- vboxDriverPtr data = vol->conn->privateData;
+ struct _vboxDriver *data = vol->conn->privateData;
IMedium *hardDisk = NULL;
unsigned char uuid[VIR_UUID_BUFLEN];
PRUnichar *hddFormatUtf16 = NULL;
static char *vboxStorageVolGetPath(virStorageVolPtr vol)
{
- vboxDriverPtr data = vol->conn->privateData;
+ struct _vboxDriver *data = vol->conn->privateData;
IMedium *hardDisk = NULL;
PRUnichar *hddLocationUtf16 = NULL;
char *hddLocationUtf8 = NULL;
.storageVolGetPath = vboxStorageVolGetPath /* 0.7.1 */
};
-virStorageDriverPtr vboxGetStorageDriver(uint32_t uVersion)
+virStorageDriver *vboxGetStorageDriver(uint32_t uVersion)
{
/* Install gVBoxAPI according to the vbox API version.
* Return -1 for unsupported version.
#define VBOX_RDP_AUTOPORT_RANGE "3389-3689"
static void
-_vboxIIDUnalloc(vboxDriverPtr data, vboxIID *iid)
+_vboxIIDUnalloc(struct _vboxDriver *data, vboxIID *iid)
{
if (iid->value != NULL && iid->owner)
data->pFuncs->pfnUtf16Free(iid->value);
}
static void
-_vboxIIDToUUID(vboxDriverPtr data, vboxIID *iid,
+_vboxIIDToUUID(struct _vboxDriver *data, vboxIID *iid,
unsigned char *uuid)
{
char *utf8 = NULL;
}
static void
-_vboxIIDFromUUID(vboxDriverPtr data, vboxIID *iid,
+_vboxIIDFromUUID(struct _vboxDriver *data, vboxIID *iid,
const unsigned char *uuid)
{
char utf8[VIR_UUID_STRING_BUFLEN];
}
static bool
-_vboxIIDIsEqual(vboxDriverPtr data, vboxIID *iid1,
+_vboxIIDIsEqual(struct _vboxDriver *data, vboxIID *iid1,
vboxIID *iid2)
{
unsigned char uuid1[VIR_UUID_BUFLEN];
}
static void
-_vboxIIDFromArrayItem(vboxDriverPtr data, vboxIID *iid,
+_vboxIIDFromArrayItem(struct _vboxDriver *data, vboxIID *iid,
vboxArray *array, int idx)
{
_vboxIIDUnalloc(data, iid);
IMachine *machine,
ISnapshot *snapshot)
{
- vboxDriverPtr data = dom->conn->privateData;
+ struct _vboxDriver *data = dom->conn->privateData;
IProgress *progress = NULL;
PRUint32 state;
nsresult rc;
}
static nsresult
-_unregisterMachine(vboxDriverPtr data, vboxIID *iid, IMachine **machine)
+_unregisterMachine(struct _vboxDriver *data, vboxIID *iid, IMachine **machine)
{
nsresult rc;
vboxArray media = VBOX_ARRAY_INITIALIZER;
}
}
-static int _pfnInitialize(vboxDriverPtr driver)
+static int _pfnInitialize(struct _vboxDriver *driver)
{
nsresult rc;
return 0;
}
-static void _pfnUninitialize(vboxDriverPtr data)
+static void _pfnUninitialize(struct _vboxDriver *data)
{
if (data->pFuncs) {
VBOX_RELEASE(data->vboxObj);
iid->owner = true;
}
-static void _DEBUGIID(vboxDriverPtr data, const char *msg, vboxIID *iid)
+static void _DEBUGIID(struct _vboxDriver *data, const char *msg, vboxIID *iid)
{
DEBUGPRUnichar(msg, iid->value);
}
static void
-_vboxIIDToUtf8(vboxDriverPtr data G_GNUC_UNUSED,
+_vboxIIDToUtf8(struct _vboxDriver *data G_GNUC_UNUSED,
vboxIID *iid G_GNUC_UNUSED,
char **utf8 G_GNUC_UNUSED)
{
}
static nsresult
-_virtualboxCreateMachine(vboxDriverPtr data, virDomainDefPtr def, IMachine **machine, char *uuidstr G_GNUC_UNUSED)
+_virtualboxCreateMachine(struct _vboxDriver *data, virDomainDef *def, IMachine **machine, char *uuidstr G_GNUC_UNUSED)
{
vboxIID iid = VBOX_IID_INITIALIZER;
PRUnichar *machineNameUtf16 = NULL;
}
static nsresult
-_machineLaunchVMProcess(vboxDriverPtr data,
+_machineLaunchVMProcess(struct _vboxDriver *data,
IMachine *machine G_GNUC_UNUSED,
vboxIID *iid G_GNUC_UNUSED,
PRUnichar *sessionType, PRUnichar *env,
}
static nsresult
-_sessionOpen(vboxDriverPtr data, vboxIID *iid G_GNUC_UNUSED, IMachine *machine)
+_sessionOpen(struct _vboxDriver *data, vboxIID *iid G_GNUC_UNUSED, IMachine *machine)
{
return machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Write);
}
static nsresult
-_sessionOpenExisting(vboxDriverPtr data, vboxIID *iid G_GNUC_UNUSED, IMachine *machine)
+_sessionOpenExisting(struct _vboxDriver *data, vboxIID *iid G_GNUC_UNUSED, IMachine *machine)
{
return machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Shared);
}
}
static nsresult
-_vrdeServerGetPorts(vboxDriverPtr data, IVRDEServer *VRDEServer,
- IMachine *machine, virDomainGraphicsDefPtr graphics)
+_vrdeServerGetPorts(struct _vboxDriver *data, IVRDEServer *VRDEServer,
+ IMachine *machine, virDomainGraphicsDef *graphics)
{
nsresult rc;
PRUnichar *VRDEPortsKey = NULL;
}
static nsresult
-_vrdeServerSetPorts(vboxDriverPtr data, IVRDEServer *VRDEServer,
- virDomainGraphicsDefPtr graphics)
+_vrdeServerSetPorts(struct _vboxDriver *data, IVRDEServer *VRDEServer,
+ virDomainGraphicsDef *graphics)
{
nsresult rc = 0;
PRUnichar *VRDEPortsKey = NULL;
}
static nsresult
-_vrdeServerGetNetAddress(vboxDriverPtr data G_GNUC_UNUSED,
+_vrdeServerGetNetAddress(struct _vboxDriver *data G_GNUC_UNUSED,
IVRDEServer *VRDEServer, PRUnichar **netAddress)
{
PRUnichar *VRDENetAddressKey = NULL;
}
static nsresult
-_vrdeServerSetNetAddress(vboxDriverPtr data G_GNUC_UNUSED,
+_vrdeServerSetNetAddress(struct _vboxDriver *data G_GNUC_UNUSED,
IVRDEServer *VRDEServer, PRUnichar *netAddress)
{
PRUnichar *netAddressKey = NULL;
}
static nsresult
-_hostCreateHostOnlyNetworkInterface(vboxDriverPtr data G_GNUC_UNUSED,
+_hostCreateHostOnlyNetworkInterface(struct _vboxDriver *data G_GNUC_UNUSED,
IHost *host, char *name G_GNUC_UNUSED,
IHostNetworkInterface **networkInterface)
{
struct _vboxDriver {
virObjectLockable parent;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
- virObjectEventStatePtr domainEventState;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
+ virObjectEventState *domainEventState;
/* vbox API initialization members */
PCVBOXXPCOM pFuncs;
};
typedef struct _vboxDriver vboxDriver;
-typedef struct _vboxDriver *vboxDriverPtr;
/* vboxUniformedAPI gives vbox_common.c a uniformed layer to see
* vbox API.
/* Functions for pFuncs */
typedef struct {
- int (*Initialize)(vboxDriverPtr driver);
- void (*Uninitialize)(vboxDriverPtr driver);
+ int (*Initialize)(struct _vboxDriver *driver);
+ void (*Uninitialize)(struct _vboxDriver *driver);
void (*ComUnallocMem)(PCVBOXXPCOM pFuncs, void *pv);
void (*Utf16Free)(PCVBOXXPCOM pFuncs, PRUnichar *pwszString);
void (*Utf8Free)(PCVBOXXPCOM pFuncs, char *pszString);
/* Functions for vboxIID */
typedef struct {
void (*vboxIIDInitialize)(vboxIID *iid);
- void (*vboxIIDUnalloc)(vboxDriverPtr driver, vboxIID *iid);
- void (*vboxIIDToUUID)(vboxDriverPtr driver, vboxIID *iid, unsigned char *uuid);
- void (*vboxIIDFromUUID)(vboxDriverPtr driver, vboxIID *iid, const unsigned char *uuid);
- bool (*vboxIIDIsEqual)(vboxDriverPtr driver, vboxIID *iid1, vboxIID *iid2);
- void (*vboxIIDFromArrayItem)(vboxDriverPtr driver, vboxIID *iid, vboxArray *array, int idx);
- void (*vboxIIDToUtf8)(vboxDriverPtr driver, vboxIID *iid, char **utf8);
- void (*DEBUGIID)(vboxDriverPtr driver, const char *msg, vboxIID *iid);
+ void (*vboxIIDUnalloc)(struct _vboxDriver *driver, vboxIID *iid);
+ void (*vboxIIDToUUID)(struct _vboxDriver *driver, vboxIID *iid, unsigned char *uuid);
+ void (*vboxIIDFromUUID)(struct _vboxDriver *driver, vboxIID *iid, const unsigned char *uuid);
+ bool (*vboxIIDIsEqual)(struct _vboxDriver *driver, vboxIID *iid1, vboxIID *iid2);
+ void (*vboxIIDFromArrayItem)(struct _vboxDriver *driver, vboxIID *iid, vboxArray *array, int idx);
+ void (*vboxIIDToUtf8)(struct _vboxDriver *driver, vboxIID *iid, char **utf8);
+ void (*DEBUGIID)(struct _vboxDriver *driver, const char *msg, vboxIID *iid);
} vboxUniformedIID;
/* Functions for vboxArray */
nsresult (*OpenMachine)(IVirtualBox *vboxObj, PRUnichar *settingsFile, IMachine **machine);
nsresult (*GetSystemProperties)(IVirtualBox *vboxObj, ISystemProperties **systemProperties);
nsresult (*GetHost)(IVirtualBox *vboxObj, IHost **host);
- nsresult (*CreateMachine)(vboxDriverPtr driver, virDomainDefPtr def, IMachine **machine, char *uuidstr);
+ nsresult (*CreateMachine)(struct _vboxDriver *driver, virDomainDef *def, IMachine **machine, char *uuidstr);
nsresult (*CreateHardDisk)(IVirtualBox *vboxObj, PRUnichar *format, PRUnichar *location, IMedium **medium);
nsresult (*RegisterMachine)(IVirtualBox *vboxObj, IMachine *machine);
nsresult (*FindHardDisk)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType,
PRUnichar *hostPath, PRBool writable,
PRBool automount);
nsresult (*RemoveSharedFolder)(IMachine *machine, PRUnichar *name);
- nsresult (*LaunchVMProcess)(vboxDriverPtr driver, IMachine *machine,
+ nsresult (*LaunchVMProcess)(struct _vboxDriver *driver, IMachine *machine,
vboxIID *iid,
PRUnichar *sessionType, PRUnichar *env,
IProgress **progress);
/* Functions for ISession */
typedef struct {
- nsresult (*Open)(vboxDriverPtr driver, vboxIID *iid, IMachine *machine);
- nsresult (*OpenExisting)(vboxDriverPtr driver, vboxIID *iid, IMachine *machine);
+ nsresult (*Open)(struct _vboxDriver *driver, vboxIID *iid, IMachine *machine);
+ nsresult (*OpenExisting)(struct _vboxDriver *driver, vboxIID *iid, IMachine *machine);
nsresult (*GetConsole)(ISession *session, IConsole **console);
nsresult (*GetMachine)(ISession *session, IMachine **machine);
nsresult (*Close)(ISession *session);
typedef struct {
nsresult (*GetEnabled)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetEnabled)(IVRDEServer *VRDEServer, PRBool enabled);
- nsresult (*GetPorts)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
- IMachine *machine, virDomainGraphicsDefPtr graphics);
- nsresult (*SetPorts)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
- virDomainGraphicsDefPtr graphics);
+ nsresult (*GetPorts)(struct _vboxDriver *driver, IVRDEServer *VRDEServer,
+ IMachine *machine, virDomainGraphicsDef *graphics);
+ nsresult (*SetPorts)(struct _vboxDriver *driver, IVRDEServer *VRDEServer,
+ virDomainGraphicsDef *graphics);
nsresult (*GetReuseSingleConnection)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetReuseSingleConnection)(IVRDEServer *VRDEServer, PRBool enabled);
nsresult (*GetAllowMultiConnection)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetAllowMultiConnection)(IVRDEServer *VRDEServer, PRBool enabled);
- nsresult (*GetNetAddress)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
+ nsresult (*GetNetAddress)(struct _vboxDriver *driver, IVRDEServer *VRDEServer,
PRUnichar **netAddress);
- nsresult (*SetNetAddress)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
+ nsresult (*SetNetAddress)(struct _vboxDriver *driver, IVRDEServer *VRDEServer,
PRUnichar *netAddress);
} vboxUniformedIVRDEServer;
IHostNetworkInterface **networkInterface);
nsresult (*FindHostNetworkInterfaceByName)(IHost *host, PRUnichar *name,
IHostNetworkInterface **networkInterface);
- nsresult (*CreateHostOnlyNetworkInterface)(vboxDriverPtr driver,
+ nsresult (*CreateHostOnlyNetworkInterface)(struct _vboxDriver *driver,
IHost *host, char *name,
IHostNetworkInterface **networkInterface);
nsresult (*RemoveHostOnlyNetworkInterface)(IHost *host, vboxIID *iid,
uint32_t APIVersion;
uint32_t XPCOMCVersion;
/* vbox APIs */
- nsresult (*unregisterMachine)(vboxDriverPtr driver, vboxIID *iid, IMachine **machine);
+ nsresult (*unregisterMachine)(struct _vboxDriver *driver, vboxIID *iid, IMachine **machine);
void (*deleteConfig)(IMachine *machine);
- void (*vboxAttachDrivesOld)(virDomainDefPtr def, vboxDriverPtr driver, IMachine *machine);
+ void (*vboxAttachDrivesOld)(virDomainDef *def, struct _vboxDriver *driver, IMachine *machine);
virDomainState (*vboxConvertState)(PRUint32 state);
int (*snapshotRestore)(virDomainPtr dom, IMachine *machine, ISnapshot *snapshot);
vboxUniformedPFN UPFN;
}
-virCapsPtr
+virCaps *
vmwareCapsInit(void)
{
- virCapsPtr caps = NULL;
- virCapsGuestPtr guest = NULL;
+ virCaps *caps = NULL;
+ virCapsGuest *guest = NULL;
if ((caps = virCapabilitiesNew(virArchFromHost(),
false, false)) == NULL)
int
vmwareLoadDomains(struct vmware_driver *driver)
{
- virDomainDefPtr vmdef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainObj *vm = NULL;
char *vmxPath = NULL;
char *vmx = NULL;
vmwareDomainPtr pDomain;
char *outbuf = NULL;
char *str;
char *saveptr = NULL;
- virCommandPtr cmd;
+ virCommand *cmd;
ctx.parseFileName = vmwareParseVMXFileName;
ctx.formatFileName = NULL;
vmwareExtractVersion(struct vmware_driver *driver)
{
int ret = -1;
- virCommandPtr cmd = NULL;
+ virCommand *cmd = NULL;
char * outbuf = NULL;
char *bin = NULL;
char *vmwarePath = NULL;
}
int
-vmwareDomainConfigDisplay(vmwareDomainPtr pDomain, virDomainDefPtr def)
+vmwareDomainConfigDisplay(vmwareDomainPtr pDomain, virDomainDef *def)
{
size_t i;
}
int
-vmwareVmxPath(virDomainDefPtr vmdef, char **vmxPath)
+vmwareVmxPath(virDomainDef *vmdef, char **vmxPath)
{
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
char *directoryName = NULL;
char *fileName = NULL;
int ret = -1;
struct vmware_driver {
virMutex lock;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
- virDomainObjListPtr domains;
+ virDomainObjList *domains;
unsigned long version;
int type;
char *vmrun;
void vmwareFreeDriver(struct vmware_driver *driver);
-virCapsPtr vmwareCapsInit(void);
+virCaps *vmwareCapsInit(void);
int vmwareLoadDomains(struct vmware_driver *driver);
int vmwareParseVersionStr(int type, const char *buf, unsigned long *version);
-int vmwareDomainConfigDisplay(vmwareDomainPtr domain, virDomainDefPtr vmdef);
+int vmwareDomainConfigDisplay(vmwareDomainPtr domain, virDomainDef *vmdef);
void vmwareConstructVmxPath(char *directoryName, char *name,
char **vmxPath);
-int vmwareVmxPath(virDomainDefPtr vmdef, char **vmxPath);
+int vmwareVmxPath(virDomainDef *vmdef, char **vmxPath);
int vmwareMoveFile(char *srcFile, char *dstFile);
}
-static virDomainObjPtr
+static virDomainObj *
vmwareDomObjFromDomainLocked(struct vmware_driver *driver,
const unsigned char *uuid)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
char uuidstr[VIR_UUID_STRING_BUFLEN];
if (!(vm = virDomainObjListFindByUUID(driver->domains, uuid))) {
}
-static virDomainObjPtr
+static virDomainObj *
vmwareDomObjFromDomain(struct vmware_driver *driver,
const unsigned char *uuid)
{
- virDomainObjPtr vm;
+ virDomainObj *vm;
vmwareDriverLock(driver);
vm = vmwareDomObjFromDomainLocked(driver, uuid);
}
static int
-vmwareDomainDefPostParse(virDomainDefPtr def,
+vmwareDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
void *parseOpaque G_GNUC_UNUSED)
}
static int
-vmwareDomainDeviceDefPostParse(virDomainDeviceDefPtr dev G_GNUC_UNUSED,
+vmwareDomainDeviceDefPostParse(virDomainDeviceDef *dev G_GNUC_UNUSED,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
.defArch = VIR_ARCH_I686,
};
-static virDomainXMLOptionPtr
+static virDomainXMLOption *
vmwareDomainXMLConfigInit(struct vmware_driver *driver)
{
virDomainXMLPrivateDataCallbacks priv = { .alloc = vmwareDataAllocFunc,
static virDrvOpenStatus
vmwareConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
struct vmware_driver *driver;
}
static int
-vmwareUpdateVMStatus(struct vmware_driver *driver, virDomainObjPtr vm)
+vmwareUpdateVMStatus(struct vmware_driver *driver, virDomainObj *vm)
{
- virCommandPtr cmd;
+ virCommand *cmd;
char *outbuf = NULL;
char *vmxAbsolutePath = NULL;
char *parsedVmxPath = NULL;
static int
vmwareStopVM(struct vmware_driver *driver,
- virDomainObjPtr vm,
+ virDomainObj *vm,
virDomainShutoffReason reason)
{
g_autoptr(virCommand) cmd = virCommandNew(driver->vmrun);
}
static int
-vmwareStartVM(struct vmware_driver *driver, virDomainObjPtr vm)
+vmwareStartVM(struct vmware_driver *driver, virDomainObj *vm)
{
g_autoptr(virCommand) cmd = virCommandNew(driver->vmrun);
const char *vmxPath = ((vmwareDomainPtr) vm->privateData)->vmxPath;
vmwareDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
struct vmware_driver *driver = conn->privateData;
- virDomainDefPtr vmdef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
char *vmx = NULL;
char *vmxPath = NULL;
unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
struct vmware_driver *driver = dom->conn->privateData;
g_autoptr(virCommand) cmd = virCommandNew(driver->vmrun);
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (driver->type == VMWARE_DRIVER_PLAYER) {
struct vmware_driver *driver = dom->conn->privateData;
g_autoptr(virCommand) cmd = virCommandNew(driver->vmrun);
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (driver->type == VMWARE_DRIVER_PLAYER) {
{
struct vmware_driver *driver = dom->conn->privateData;
g_autoptr(virCommand) cmd = virCommandNew(driver->vmrun);
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
unsigned int flags)
{
struct vmware_driver *driver = conn->privateData;
- virDomainDefPtr vmdef = NULL;
- virDomainObjPtr vm = NULL;
+ virDomainDef *vmdef = NULL;
+ virDomainObj *vm = NULL;
virDomainPtr dom = NULL;
char *vmx = NULL;
char *vmxPath = NULL;
unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
vmwareDomainLookupByID(virConnectPtr conn, int id)
{
struct vmware_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vmwareDriverLock(driver);
vmwareDomainGetOSType(virDomainPtr dom)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
if (!(vm = vmwareDomObjFromDomain(driver, dom->uuid)))
vmwareDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
struct vmware_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
if (!(vm = vmwareDomObjFromDomain(driver, uuid)))
vmwareDomainLookupByName(virConnectPtr conn, const char *name)
{
struct vmware_driver *driver = conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
virDomainPtr dom = NULL;
vmwareDriverLock(driver);
vmwareDomainIsActive(virDomainPtr dom)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = vmwareDomObjFromDomain(driver, dom->uuid)))
vmwareDomainIsPersistent(virDomainPtr dom)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
if (!(obj = vmwareDomObjFromDomain(driver, dom->uuid)))
vmwareDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
{
struct vmware_driver *driver = conn->privateData;
virVMXContext ctx;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *xml = NULL;
virCheckFlags(0, NULL);
return xml;
}
-static int vmwareDomainObjListUpdateDomain(virDomainObjPtr dom, void *data)
+static int vmwareDomainObjListUpdateDomain(virDomainObj *dom, void *data)
{
struct vmware_driver *driver = data;
virObjectLock(dom);
}
static void
-vmwareDomainObjListUpdateAll(virDomainObjListPtr doms, struct vmware_driver *driver)
+vmwareDomainObjListUpdateAll(virDomainObjList *doms, struct vmware_driver *driver)
{
virDomainObjListForEach(doms, false, vmwareDomainObjListUpdateDomain, driver);
}
vmwareDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
if (!(vm = vmwareDomObjFromDomain(driver, dom->uuid)))
unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObj *vm;
int ret = -1;
virCheckFlags(0, -1);
vmwareDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
- virDomainObjPtr obj;
+ virDomainObj *obj;
int ret = -1;
virCheckFlags(0, -1);
"UNUSED am53c974",
);
-static int virVMXParseVNC(virConfPtr conf, virDomainGraphicsDefPtr *def);
-static int virVMXParseSCSIController(virConfPtr conf, int controller, bool *present,
+static int virVMXParseVNC(virConf *conf, virDomainGraphicsDef **def);
+static int virVMXParseSCSIController(virConf *conf, int controller, bool *present,
int *virtualDev);
-static int virVMXParseSATAController(virConfPtr conf, int controller, bool *present);
-static int virVMXParseDisk(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt,
- virConfPtr conf, int device, int busType,
- int controllerOrBus, int unit, virDomainDiskDefPtr *def,
- virDomainDefPtr vmdef);
-static int virVMXParseFileSystem(virConfPtr conf, int number, virDomainFSDefPtr *def);
-static int virVMXParseEthernet(virConfPtr conf, int controller, virDomainNetDefPtr *def);
-static int virVMXParseSerial(virVMXContext *ctx, virConfPtr conf, int port,
- virDomainChrDefPtr *def);
-static int virVMXParseParallel(virVMXContext *ctx, virConfPtr conf, int port,
- virDomainChrDefPtr *def);
-static int virVMXParseSVGA(virConfPtr conf, virDomainVideoDefPtr *def);
-
-static int virVMXFormatVNC(virDomainGraphicsDefPtr def, virBufferPtr buffer);
-static int virVMXFormatDisk(virVMXContext *ctx, virDomainDiskDefPtr def,
- virBufferPtr buffer);
-static int virVMXFormatFloppy(virVMXContext *ctx, virDomainDiskDefPtr def,
- virBufferPtr buffer, bool floppy_present[2]);
-static int virVMXFormatFileSystem(virDomainFSDefPtr def, int number,
- virBufferPtr buffer);
-static int virVMXFormatEthernet(virDomainNetDefPtr def, int controller,
- virBufferPtr buffer, int virtualHW_version);
-static int virVMXFormatSerial(virVMXContext *ctx, virDomainChrDefPtr def,
- virBufferPtr buffer);
-static int virVMXFormatParallel(virVMXContext *ctx, virDomainChrDefPtr def,
- virBufferPtr buffer);
-static int virVMXFormatSVGA(virDomainVideoDefPtr def, virBufferPtr buffer);
+static int virVMXParseSATAController(virConf *conf, int controller, bool *present);
+static int virVMXParseDisk(virVMXContext *ctx, virDomainXMLOption *xmlopt,
+ virConf *conf, int device, int busType,
+ int controllerOrBus, int unit, virDomainDiskDef **def,
+ virDomainDef *vmdef);
+static int virVMXParseFileSystem(virConf *conf, int number, virDomainFSDef **def);
+static int virVMXParseEthernet(virConf *conf, int controller, virDomainNetDef **def);
+static int virVMXParseSerial(virVMXContext *ctx, virConf *conf, int port,
+ virDomainChrDef **def);
+static int virVMXParseParallel(virVMXContext *ctx, virConf *conf, int port,
+ virDomainChrDef **def);
+static int virVMXParseSVGA(virConf *conf, virDomainVideoDef **def);
+
+static int virVMXFormatVNC(virDomainGraphicsDef *def, virBuffer *buffer);
+static int virVMXFormatDisk(virVMXContext *ctx, virDomainDiskDef *def,
+ virBuffer *buffer);
+static int virVMXFormatFloppy(virVMXContext *ctx, virDomainDiskDef *def,
+ virBuffer *buffer, bool floppy_present[2]);
+static int virVMXFormatFileSystem(virDomainFSDef *def, int number,
+ virBuffer *buffer);
+static int virVMXFormatEthernet(virDomainNetDef *def, int controller,
+ virBuffer *buffer, int virtualHW_version);
+static int virVMXFormatSerial(virVMXContext *ctx, virDomainChrDef *def,
+ virBuffer *buffer);
+static int virVMXFormatParallel(virVMXContext *ctx, virDomainChrDef *def,
+ virBuffer *buffer);
+static int virVMXFormatSVGA(virDomainVideoDef *def, virBuffer *buffer);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Helpers
*/
static int
-virVMXDomainDefPostParse(virDomainDefPtr def,
+virVMXDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- virCapsPtr caps = opaque;
+ virCaps *caps = opaque;
if (!virCapabilitiesDomainSupported(caps, def->os.type,
def->os.arch,
def->virtType))
}
static int
-virVMXDomainDevicesDefPostParse(virDomainDeviceDefPtr dev G_GNUC_UNUSED,
+virVMXDomainDevicesDefPostParse(virDomainDeviceDef *dev G_GNUC_UNUSED,
const virDomainDef *def G_GNUC_UNUSED,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
}
static int
-virVMXDomainDefNamespaceFormatXML(virBufferPtr buf, void *nsdata)
+virVMXDomainDefNamespaceFormatXML(virBuffer *buf, void *nsdata)
{
struct virVMXDomainDefNamespaceData *data = nsdata;
.uri = "http://libvirt.org/schemas/domain/vmware/1.0",
};
-virDomainXMLOptionPtr
-virVMXDomainXMLConfInit(virCapsPtr caps)
+virDomainXMLOption *
+virVMXDomainXMLConfInit(virCaps *caps)
{
virVMXDomainDefParserConfig.priv = caps;
return virDomainXMLOptionNew(&virVMXDomainDefParserConfig, NULL,
static int
-virVMXGetConfigStringHelper(virConfPtr conf, const char *name, char **string,
+virVMXGetConfigStringHelper(virConf *conf, const char *name, char **string,
bool optional)
{
int rc;
static int
-virVMXGetConfigString(virConfPtr conf, const char *name, char **string,
+virVMXGetConfigString(virConf *conf, const char *name, char **string,
bool optional)
{
*string = NULL;
static int
-virVMXGetConfigUUID(virConfPtr conf, const char *name, unsigned char *uuid,
+virVMXGetConfigUUID(virConf *conf, const char *name, unsigned char *uuid,
bool optional)
{
char *string = NULL;
static int
-virVMXGetConfigLong(virConfPtr conf, const char *name, long long *number,
+virVMXGetConfigLong(virConf *conf, const char *name, long long *number,
long long default_, bool optional)
{
char *string = NULL;
static int
-virVMXGetConfigBoolean(virConfPtr conf, const char *name, bool *boolean_,
+virVMXGetConfigBoolean(virConf *conf, const char *name, bool *boolean_,
bool default_, bool optional)
{
char *string = NULL;
static int
-virVMXVerifyDiskAddress(virDomainXMLOptionPtr xmlopt,
- virDomainDiskDefPtr disk,
- virDomainDefPtr vmdef)
+virVMXVerifyDiskAddress(virDomainXMLOption *xmlopt,
+ virDomainDiskDef *disk,
+ virDomainDef *vmdef)
{
virDomainDiskDef def;
- virDomainDeviceDriveAddressPtr drive;
+ virDomainDeviceDriveAddress *drive;
memset(&def, 0, sizeof(def));
static int
-virVMXHandleLegacySCSIDiskDriverName(virDomainDefPtr def,
- virDomainDiskDefPtr disk)
+virVMXHandleLegacySCSIDiskDriverName(virDomainDef *def,
+ virDomainDiskDef *disk)
{
char *tmp;
int model;
size_t i;
- virDomainControllerDefPtr controller = NULL;
+ virDomainControllerDef *controller = NULL;
const char *driver = virDomainDiskGetDriver(disk);
char *copy;
static int
-virVMXGatherSCSIControllers(virVMXContext *ctx, virDomainDefPtr def,
+virVMXGatherSCSIControllers(virVMXContext *ctx, virDomainDef *def,
int virtualDev[4], bool present[4])
{
int result = -1;
size_t i, k;
- virDomainDiskDefPtr disk;
- virDomainControllerDefPtr controller;
+ virDomainDiskDef *disk;
+ virDomainControllerDef *controller;
bool controllerHasDisksAttached;
int count = 0;
int *autodetectedModels;
static int
virVMXConfigScanResultsCollector(const char* name,
- virConfValuePtr value G_GNUC_UNUSED,
+ virConfValue *value G_GNUC_UNUSED,
void *opaque)
{
struct virVMXConfigScanResults *results = opaque;
* VMX -> Domain XML
*/
-virDomainDefPtr
+virDomainDef *
virVMXParseConfig(virVMXContext *ctx,
- virDomainXMLOptionPtr xmlopt,
- virCapsPtr caps G_GNUC_UNUSED,
+ virDomainXMLOption *xmlopt,
+ virCaps *caps G_GNUC_UNUSED,
const char *vmx)
{
bool success = false;
g_autoptr(virConf) conf = NULL;
char *encoding = NULL;
char *utf8;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
long long config_version = 0;
long long virtualHW_version = 0;
long long memsize = 0;
long long sharedFolder_maxNum = 0;
struct virVMXConfigScanResults results = { -1 };
long long coresPerSocket = 0;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
char *firmware = NULL;
size_t saved_ndisks = 0;
/* FIXME */
/* def:graphics */
- def->graphics = g_new0(virDomainGraphicsDefPtr, 1);
+ def->graphics = g_new0(virDomainGraphicsDef *, 1);
def->ngraphics = 0;
if (virVMXParseVNC(conf, &def->graphics[def->ngraphics]) < 0)
++def->ngraphics;
/* def:disks: 4 * 15 scsi + 4 * 30 sata + 2 * 2 ide + 2 floppy = 186 */
- def->disks = g_new0(virDomainDiskDefPtr, 186);
+ def->disks = g_new0(virDomainDiskDef *, 186);
def->ndisks = 0;
/* def:disks (scsi) */
/* add all the SCSI controllers we've seen, up until the last one that is
* currently used by a disk */
if (def->ndisks != 0) {
- virDomainDeviceInfoPtr info = &def->disks[def->ndisks - 1]->info;
+ virDomainDeviceInfo *info = &def->disks[def->ndisks - 1]->info;
for (controller = 0; controller <= info->addr.drive.controller; controller++) {
if (!virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
controller, scsi_virtualDev[controller]))
/* add all the SATA controllers we've seen, up until the last one that is
* currently used by a disk */
if (def->ndisks - saved_ndisks != 0) {
- virDomainDeviceInfoPtr info = &def->disks[def->ndisks - 1]->info;
+ virDomainDeviceInfo *info = &def->disks[def->ndisks - 1]->info;
for (controller = 0; controller <= info->addr.drive.controller; controller++) {
if (!virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_SATA,
controller, -1))
if (sharedFolder_maxNum > 0) {
int number;
- def->fss = g_new0(virDomainFSDefPtr, sharedFolder_maxNum);
+ def->fss = g_new0(virDomainFSDef *, sharedFolder_maxNum);
def->nfss = 0;
for (number = 0; number < sharedFolder_maxNum; ++number) {
/* def:nets */
for (controller = 0; controller <= results.networks_max_index; ++controller) {
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
if (virVMXParseEthernet(conf, controller, &net) < 0)
goto cleanup;
/* FIXME */
/* def:videos */
- def->videos = g_new0(virDomainVideoDefPtr, 1);
+ def->videos = g_new0(virDomainVideoDef *, 1);
def->nvideos = 0;
if (virVMXParseSVGA(conf, &def->videos[def->nvideos]) < 0)
/* FIXME */
/* def:serials */
- def->serials = g_new0(virDomainChrDefPtr, 4);
+ def->serials = g_new0(virDomainChrDef *, 4);
def->nserials = 0;
for (port = 0; port < 4; ++port) {
}
/* def:parallels */
- def->parallels = g_new0(virDomainChrDefPtr, 3);
+ def->parallels = g_new0(virDomainChrDef *, 3);
def->nparallels = 0;
for (port = 0; port < 3; ++port) {
static int
-virVMXParseVNC(virConfPtr conf, virDomainGraphicsDefPtr *def)
+virVMXParseVNC(virConf *conf, virDomainGraphicsDef **def)
{
bool enabled = false;
long long port = 0;
static int
-virVMXParseSCSIController(virConfPtr conf, int controller, bool *present,
+virVMXParseSCSIController(virConf *conf, int controller, bool *present,
int *virtualDev)
{
int result = -1;
static int
-virVMXParseSATAController(virConfPtr conf, int controller, bool *present)
+virVMXParseSATAController(virConf *conf, int controller, bool *present)
{
char present_name[32];
static int
-virVMXParseDisk(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt, virConfPtr conf,
+virVMXParseDisk(virVMXContext *ctx, virDomainXMLOption *xmlopt, virConf *conf,
int device, int busType, int controllerOrBus, int unit,
- virDomainDiskDefPtr *def, virDomainDefPtr vmdef)
+ virDomainDiskDef **def, virDomainDef *vmdef)
{
/*
* device = {VIR_DOMAIN_DISK_DEVICE_DISK,
static int
-virVMXParseFileSystem(virConfPtr conf, int number, virDomainFSDefPtr *def)
+virVMXParseFileSystem(virConf *conf, int number, virDomainFSDef **def)
{
int result = -1;
char prefix[48] = "";
static int
-virVMXParseEthernet(virConfPtr conf, int controller, virDomainNetDefPtr *def)
+virVMXParseEthernet(virConf *conf, int controller, virDomainNetDef **def)
{
int result = -1;
char prefix[48] = "";
static int
-virVMXParseSerial(virVMXContext *ctx, virConfPtr conf, int port,
- virDomainChrDefPtr *def)
+virVMXParseSerial(virVMXContext *ctx, virConf *conf, int port,
+ virDomainChrDef **def)
{
int result = -1;
char prefix[48] = "";
char network_endPoint_name[48] = "";
char *network_endPoint = NULL;
- virURIPtr parsedUri = NULL;
+ virURI *parsedUri = NULL;
if (def == NULL || *def != NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
static int
-virVMXParseParallel(virVMXContext *ctx, virConfPtr conf, int port,
- virDomainChrDefPtr *def)
+virVMXParseParallel(virVMXContext *ctx, virConf *conf, int port,
+ virDomainChrDef **def)
{
int result = -1;
char prefix[48] = "";
static int
-virVMXParseSVGA(virConfPtr conf, virDomainVideoDefPtr *def)
+virVMXParseSVGA(virConf *conf, virDomainVideoDef **def)
{
int result = -1;
long long svga_vramSize = 0;
*/
char *
-virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt, virDomainDefPtr def,
+virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOption *xmlopt, virDomainDef *def,
int virtualHW_version)
{
char *vmx = NULL;
static int
-virVMXFormatVNC(virDomainGraphicsDefPtr def, virBufferPtr buffer)
+virVMXFormatVNC(virDomainGraphicsDef *def, virBuffer *buffer)
{
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
if (def->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
}
static int
-virVMXFormatDisk(virVMXContext *ctx, virDomainDiskDefPtr def,
- virBufferPtr buffer)
+virVMXFormatDisk(virVMXContext *ctx, virDomainDiskDef *def,
+ virBuffer *buffer)
{
int controllerOrBus, unit;
const char *vmxDeviceType = NULL;
}
static int
-virVMXFormatFloppy(virVMXContext *ctx, virDomainDiskDefPtr def,
- virBufferPtr buffer, bool floppy_present[2])
+virVMXFormatFloppy(virVMXContext *ctx, virDomainDiskDef *def,
+ virBuffer *buffer, bool floppy_present[2])
{
int unit;
char *fileName = NULL;
static int
-virVMXFormatFileSystem(virDomainFSDefPtr def, int number, virBufferPtr buffer)
+virVMXFormatFileSystem(virDomainFSDef *def, int number, virBuffer *buffer)
{
if (def->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
static int
-virVMXFormatEthernet(virDomainNetDefPtr def, int controller,
- virBufferPtr buffer, int virtualHW_version)
+virVMXFormatEthernet(virDomainNetDef *def, int controller,
+ virBuffer *buffer, int virtualHW_version)
{
char mac_string[VIR_MAC_STRING_BUFLEN];
virDomainNetMacType mac_type = VIR_DOMAIN_NET_MAC_TYPE_DEFAULT;
static int
-virVMXFormatSerial(virVMXContext *ctx, virDomainChrDefPtr def,
- virBufferPtr buffer)
+virVMXFormatSerial(virVMXContext *ctx, virDomainChrDef *def,
+ virBuffer *buffer)
{
char *fileName = NULL;
const char *protocol;
static int
-virVMXFormatParallel(virVMXContext *ctx, virDomainChrDefPtr def,
- virBufferPtr buffer)
+virVMXFormatParallel(virVMXContext *ctx, virDomainChrDef *def,
+ virBuffer *buffer)
{
char *fileName = NULL;
static int
-virVMXFormatSVGA(virDomainVideoDefPtr def, virBufferPtr buffer)
+virVMXFormatSVGA(virDomainVideoDef *def, virBuffer *buffer)
{
unsigned long long vram;
typedef struct _virVMXContext virVMXContext;
-virDomainXMLOptionPtr virVMXDomainXMLConfInit(virCapsPtr caps);
+virDomainXMLOption *virVMXDomainXMLConfInit(virCaps *caps);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
char **src,
bool allow_missing);
typedef char * (*virVMXFormatFileName)(const char *src, void *opaque);
-typedef int (*virVMXAutodetectSCSIControllerModel)(virDomainDiskDefPtr def,
+typedef int (*virVMXAutodetectSCSIControllerModel)(virDomainDiskDef *def,
int *model, void *opaque);
/*
* VMX -> Domain XML
*/
-virDomainDefPtr virVMXParseConfig(virVMXContext *ctx,
- virDomainXMLOptionPtr xmlopt,
- virCapsPtr caps,
+virDomainDef *virVMXParseConfig(virVMXContext *ctx,
+ virDomainXMLOption *xmlopt,
+ virCaps *caps,
const char *vmx);
* Domain XML -> VMX
*/
-char *virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt,
- virDomainDefPtr def, int virtualHW_version);
+char *virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOption *xmlopt,
+ virDomainDef *def, int virtualHW_version);
#define VZ_STATEDIR RUNSTATEDIR "/libvirt/vz"
-static virClassPtr vzDriverClass;
+static virClass *vzDriverClass;
static bool vz_driver_privileged;
/* pid file FD, ensures two copies of the driver can't use the same root */
static int vz_driver_lock_fd = -1;
static virMutex vz_driver_lock;
-static vzDriverPtr vz_driver;
-static vzConnPtr vz_conn_list;
+static struct _vzDriver *vz_driver;
+static struct _vzConn *vz_conn_list;
-static vzDriverPtr
+static struct _vzDriver *
vzDriverObjNew(void);
static int
-vzCapsAddGuestDomain(virCapsPtr caps,
+vzCapsAddGuestDomain(virCaps *caps,
virDomainOSType ostype,
virArch arch,
const char * emulator,
virDomainVirtType virt_type)
{
- virCapsGuestPtr guest;
+ virCapsGuest *guest;
if ((guest = virCapabilitiesAddGuest(caps, ostype, arch, emulator,
NULL, 0, NULL)) == NULL)
return 0;
}
-static virCapsPtr
+static virCaps *
vzBuildCapabilities(void)
{
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
virNodeInfo nodeinfo;
virDomainOSType ostypes[] = {
VIR_DOMAIN_OSTYPE_HVM,
static void vzDriverDispose(void * obj)
{
- vzDriverPtr driver = obj;
+ struct _vzDriver *driver = obj;
prlsdkDisconnect(driver);
virObjectUnref(driver->domains);
}
VIR_ONCE_GLOBAL_INIT(vzDriver);
-vzDriverPtr
+struct _vzDriver *
vzGetDriverConnection(void)
{
if (!vz_driver_privileged) {
void
vzDestroyDriverConnection(void)
{
- vzDriverPtr driver;
- vzConnPtr privconn_list;
+ struct _vzDriver *driver;
+ struct _vzConn *privconn_list;
virMutexLock(&vz_driver_lock);
driver = g_steal_pointer(&vz_driver);
virMutexUnlock(&vz_driver_lock);
while (privconn_list) {
- vzConnPtr privconn = privconn_list;
+ struct _vzConn *privconn = privconn_list;
privconn_list = privconn->next;
virConnectCloseCallbackDataCall(privconn->closeCallback,
VIR_CONNECT_CLOSE_REASON_EOF);
static char *
vzConnectGetCapabilities(virConnectPtr conn)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
return NULL;
}
static int
-vzDomainDefAddDefaultInputDevices(virDomainDefPtr def)
+vzDomainDefAddDefaultInputDevices(virDomainDef *def)
{
int bus = IS_CT(def) ? VIR_DOMAIN_INPUT_BUS_PARALLELS :
VIR_DOMAIN_INPUT_BUS_PS2;
}
static int
-vzDomainDefPostParse(virDomainDefPtr def,
+vzDomainDefPostParse(virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- vzDriverPtr driver = opaque;
+ struct _vzDriver *driver = opaque;
if (!virCapabilitiesDomainSupported(driver->caps, def->os.type,
def->os.arch,
def->virtType))
}
static int
-vzDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+vzDomainDeviceDefPostParse(virDomainDeviceDef *dev,
const virDomainDef *def,
unsigned int parseFlags G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED,
void *opaque,
void *parseOpaque G_GNUC_UNUSED)
{
- vzDriverPtr driver = opaque;
+ struct _vzDriver *driver = opaque;
if (dev->type == VIR_DOMAIN_DEVICE_DISK)
return vzCheckUnsupportedDisk(def, dev->data.disk, &driver->vzCaps);
.deviceValidateCallback = vzDomainDeviceDefValidate,
};
-static vzDriverPtr
+static struct _vzDriver *
vzDriverObjNew(void)
{
- vzDriverPtr driver;
+ struct _vzDriver *driver;
if (vzDriverInitialize() < 0)
return NULL;
static virDrvOpenStatus
vzConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth G_GNUC_UNUSED,
- virConfPtr conf G_GNUC_UNUSED,
+ virConf *conf G_GNUC_UNUSED,
unsigned int flags)
{
- vzDriverPtr driver = NULL;
- vzConnPtr privconn = NULL;
+ struct _vzDriver *driver = NULL;
+ struct _vzConn *privconn = NULL;
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
static int
vzConnectClose(virConnectPtr conn)
{
- vzConnPtr curr;
- vzConnPtr *prev = &vz_conn_list;
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *curr;
+ struct _vzConn **prev = &vz_conn_list;
+ struct _vzConn *privconn = conn->privateData;
if (!privconn)
return 0;
static int
vzConnectGetVersion(virConnectPtr conn, unsigned long *hvVer)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectGetVersionEnsureACL(conn) < 0)
return -1;
static char *
vzConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- vzConnPtr privconn = conn->privateData;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
static int
vzConnectListDomains(virConnectPtr conn, int *ids, int maxids)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectListDomainsEnsureACL(conn) < 0)
return -1;
static int
vzConnectNumOfDomains(virConnectPtr conn)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectNumOfDomainsEnsureACL(conn) < 0)
return -1;
static int
vzConnectListDefinedDomains(virConnectPtr conn, char **const names, int maxnames)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
return -1;
static int
vzConnectNumOfDefinedDomains(virConnectPtr conn)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
return -1;
virDomainPtr **domains,
unsigned int flags)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
static virDomainPtr
vzDomainLookupByID(virConnectPtr conn, int id)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
dom = virDomainObjListFindByID(privconn->driver->domains, id);
static virDomainPtr
vzDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
dom = virDomainObjListFindByUUID(privconn->driver->domains, uuid);
static virDomainPtr
vzDomainLookupByName(virConnectPtr conn, const char *name)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
virDomainPtr ret = NULL;
- virDomainObjPtr dom;
+ virDomainObj *dom;
dom = virDomainObjListFindByName(privconn->driver->domains, name);
static int
vzDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
{
- virDomainObjPtr dom;
- vzDomObjPtr privdom;
+ virDomainObj *dom;
+ struct vzDomObj *privdom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
static char *
vzDomainGetOSType(virDomainPtr domain)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
char *ret = NULL;
if (!(dom = vzDomObjFromDomain(domain)))
static int
vzDomainIsPersistent(virDomainPtr domain)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
vzDomainGetState(virDomainPtr domain,
int *state, int *reason, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
virCheckFlags(0, -1);
static char *
vzDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- vzDriverPtr driver = privconn->driver;
- virDomainDefPtr def;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
+ virDomainDef *def;
+ virDomainObj *dom;
char *ret = NULL;
virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
static int
vzDomainGetAutostart(virDomainPtr domain, int *autostart)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
}
static int
-vzEnsureDomainExists(virDomainObjPtr dom)
+vzEnsureDomainExists(virDomainObj *dom)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
static virDomainPtr
vzDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
virDomainPtr retdom = NULL;
- virDomainDefPtr def;
- virDomainObjPtr dom = NULL;
+ virDomainDef *def;
+ virDomainObj *dom = NULL;
unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
- vzDriverPtr driver = privconn->driver;
+ struct _vzDriver *driver = privconn->driver;
bool job = false;
virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
unsigned int ncpus,
unsigned int flags)
{
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *cpu = NULL;
char *cpustr = NULL;
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, NULL);
unsigned char *cpumaps,
int maplen)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
size_t i;
int ret = -1;
if (maxinfo >= 1) {
if (info != NULL) {
- vzDomObjPtr privdom;
+ struct vzDomObj *privdom;
memset(info, 0, sizeof(*info) * maxinfo);
privdom = dom->privateData;
virFreeCallback freecb)
{
int ret = -1;
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
return -1;
vzConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
return -1;
static int
vzDomainSuspend(virDomainPtr domain)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int
vzDomainResume(virDomainPtr domain)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int
vzDomainCreateWithFlags(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int
vzDomainDestroyFlags(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int
vzDomainShutdownFlags(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int
vzDomainReboot(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
static int vzDomainIsActive(virDomainPtr domain)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
vzDomainUndefineFlags(virDomainPtr domain,
unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom = NULL;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
static int
vzDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int state, reason;
int ret = -1;
static int
vzDomainManagedSave(virDomainPtr domain, unsigned int flags)
{
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom = NULL;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom = NULL;
int state, reason;
int ret = -1;
bool job = false;
static int
vzDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int state, reason;
int ret = -1;
return ret;
}
-static int vzCheckConfigUpdateFlags(virDomainObjPtr dom, unsigned int *flags)
+static int vzCheckConfigUpdateFlags(virDomainObj *dom, unsigned int *flags)
{
if (virDomainObjUpdateModificationImpact(dom, flags) < 0)
return -1;
unsigned int flags)
{
int ret = -1;
- vzConnPtr privconn = domain->conn->privateData;
- virDomainDeviceDefPtr dev = NULL;
- virDomainObjPtr dom = NULL;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainDeviceDef *dev = NULL;
+ virDomainObj *dom = NULL;
+ struct _vzDriver *driver = privconn->driver;
bool job = false;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
unsigned int flags)
{
int ret = -1;
- vzConnPtr privconn = domain->conn->privateData;
- virDomainDeviceDefPtr dev = NULL;
- virDomainObjPtr dom = NULL;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainDeviceDef *dev = NULL;
+ virDomainObj *dom = NULL;
+ struct _vzDriver *driver = privconn->driver;
bool job = false;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
const char *password,
unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
unsigned int flags)
{
int ret = -1;
- vzConnPtr privconn = domain->conn->privateData;
- virDomainObjPtr dom = NULL;
- virDomainDeviceDefPtr dev = NULL;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = domain->conn->privateData;
+ virDomainObj *dom = NULL;
+ virDomainDeviceDef *dev = NULL;
+ struct _vzDriver *driver = privconn->driver;
bool job = false;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
static unsigned long long
vzDomainGetMaxMemory(virDomainPtr domain)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
}
static int
-vzDomainBlockStatsImpl(virDomainObjPtr dom,
+vzDomainBlockStatsImpl(virDomainObj *dom,
const char *path,
virDomainBlockStatsPtr stats)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
size_t i;
int idx;
const char *path,
virDomainBlockStatsPtr stats)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
unsigned int flags)
{
virDomainBlockStatsStruct stats;
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
const char *device,
virDomainInterfaceStatsPtr stats)
{
- virDomainObjPtr dom = NULL;
- vzDomObjPtr privdom;
+ virDomainObj *dom = NULL;
+ struct vzDomObj *privdom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
unsigned int nr_stats,
unsigned int flags)
{
- virDomainObjPtr dom = NULL;
- vzDomObjPtr privdom;
+ virDomainObj *dom = NULL;
+ struct vzDomObj *privdom;
int ret = -1;
virCheckFlags(0, -1);
vzDomainGetVcpusFlags(virDomainPtr domain,
unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
static int vzDomainIsUpdated(virDomainPtr domain)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
/* As far as VZ domains are always updated (e.g. current==persistent),
void *opaque,
virFreeCallback freecb)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
int ret = -1;
if (virConnectRegisterCloseCallbackEnsureACL(conn) < 0)
static int
vzConnectUnregisterCloseCallback(virConnectPtr conn, virConnectCloseFunc cb)
{
- vzConnPtr privconn = conn->privateData;
+ struct _vzConn *privconn = conn->privateData;
int ret = -1;
if (virConnectUnregisterCloseCallbackEnsureACL(conn) < 0)
static int vzDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
static int vzDomainSetMemory(virDomainPtr domain, unsigned long memory)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
return ret;
}
-static virDomainMomentObjPtr
-vzSnapObjFromName(virDomainSnapshotObjListPtr snapshots, const char *name)
+static virDomainMomentObj *
+vzSnapObjFromName(virDomainSnapshotObjList *snapshots, const char *name)
{
- virDomainMomentObjPtr snap = NULL;
+ virDomainMomentObj *snap = NULL;
snap = virDomainSnapshotFindByName(snapshots, name);
if (!snap)
virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
return snap;
}
-static virDomainMomentObjPtr
-vzSnapObjFromSnapshot(virDomainSnapshotObjListPtr snapshots,
+static virDomainMomentObj *
+vzSnapObjFromSnapshot(virDomainSnapshotObjList *snapshots,
virDomainSnapshotPtr snapshot)
{
return vzSnapObjFromName(snapshots, snapshot->name);
static int
vzDomainSnapshotNum(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
int nameslen,
unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
static char *
vzDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
char *xml = NULL;
- virDomainMomentObjPtr snap;
+ virDomainMomentObj *snap;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- virDomainSnapshotObjListPtr snapshots = NULL;
- vzConnPtr privconn = snapshot->domain->conn->privateData;
+ virDomainSnapshotObjList *snapshots = NULL;
+ struct _vzConn *privconn = snapshot->domain->conn->privateData;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_XML_SECURE, NULL);
static int
vzDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainMomentObjPtr snap;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainMomentObj *snap;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
int nameslen,
unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainMomentObjPtr snap;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainMomentObj *snap;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
virDomainSnapshotPtr **snaps,
unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainMomentObjPtr snap;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainMomentObj *snap;
+ virDomainSnapshotObjList *snapshots = NULL;
int n = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS |
const char *name,
unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainMomentObjPtr snap;
+ virDomainObj *dom;
+ virDomainMomentObj *snap;
virDomainSnapshotPtr snapshot = NULL;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainSnapshotObjList *snapshots = NULL;
virCheckFlags(0, NULL);
static int
vzDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainObj *dom;
+ virDomainSnapshotObjList *snapshots = NULL;
int ret = -1;
virCheckFlags(0, -1);
static virDomainSnapshotPtr
vzDomainSnapshotGetParent(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
- virDomainMomentObjPtr snap;
+ virDomainObj *dom;
+ virDomainMomentObj *snap;
virDomainSnapshotPtr parent = NULL;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainSnapshotObjList *snapshots = NULL;
virCheckFlags(0, NULL);
static virDomainSnapshotPtr
vzDomainSnapshotCurrent(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
virDomainSnapshotPtr snapshot = NULL;
- virDomainSnapshotObjListPtr snapshots = NULL;
- virDomainMomentObjPtr current;
+ virDomainSnapshotObjList *snapshots = NULL;
+ virDomainMomentObj *current;
virCheckFlags(0, NULL);
static int
vzDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
- virDomainSnapshotObjListPtr snapshots = NULL;
- virDomainMomentObjPtr current;
+ virDomainSnapshotObjList *snapshots = NULL;
+ virDomainMomentObj *current;
virCheckFlags(0, -1);
vzDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
- virDomainMomentObjPtr snap;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainMomentObj *snap;
+ virDomainSnapshotObjList *snapshots = NULL;
virCheckFlags(0, -1);
unsigned int flags)
{
virDomainSnapshotPtr snapshot = NULL;
- virDomainObjPtr dom;
- vzConnPtr privconn = domain->conn->privateData;
- vzDriverPtr driver = privconn->driver;
+ virDomainObj *dom;
+ struct _vzConn *privconn = domain->conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
unsigned int parse_flags = VIR_DOMAIN_SNAPSHOT_PARSE_DISKS;
- virDomainSnapshotObjListPtr snapshots = NULL;
- virDomainMomentObjPtr current;
+ virDomainSnapshotObjList *snapshots = NULL;
+ virDomainMomentObj *current;
bool job = false;
g_autoptr(virDomainSnapshotDef) def = NULL;
static int
vzDomainSnapshotDelete(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN, -1);
static int
vzDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, unsigned int flags)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
bool job = false;
};
typedef struct _vzMigrationCookie vzMigrationCookie;
-typedef vzMigrationCookie *vzMigrationCookiePtr;
struct _vzMigrationCookie {
unsigned char *session_uuid;
unsigned char *uuid;
};
static void
-vzMigrationCookieFree(vzMigrationCookiePtr mig)
+vzMigrationCookieFree(vzMigrationCookie *mig)
{
if (!mig)
return;
}
static int
-vzBakeCookie(vzDriverPtr driver,
- virDomainObjPtr dom,
+vzBakeCookie(struct _vzDriver *driver,
+ virDomainObj *dom,
char **cookieout, int *cookieoutlen,
unsigned int flags)
{
return 0;
}
-static vzMigrationCookiePtr
+static vzMigrationCookie *
vzEatCookie(const char *cookiein, int cookieinlen, unsigned int flags)
{
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctx = NULL;
- vzMigrationCookiePtr mig = NULL;
+ vzMigrationCookie *mig = NULL;
mig = g_new0(vzMigrationCookie, 1);
NULL
static char *
-vzDomainMigrateBeginStep(virDomainObjPtr dom,
- vzDriverPtr driver,
+vzDomainMigrateBeginStep(virDomainObj *dom,
+ struct _vzDriver *driver,
virTypedParameterPtr params,
int nparams,
char **cookieout,
unsigned int flags)
{
char *xml = NULL;
- virDomainObjPtr dom = NULL;
- vzConnPtr privconn = domain->conn->privateData;
+ virDomainObj *dom = NULL;
+ struct _vzConn *privconn = domain->conn->privateData;
unsigned long long bandwidth = 0;
virCheckFlags(VZ_MIGRATION_FLAGS, NULL);
char **uri_out,
unsigned int flags)
{
- vzConnPtr privconn = conn->privateData;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
const char *miguri = NULL;
const char *dname = NULL;
const char *dom_xml = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
int ret = -1;
virCheckFlags(VZ_MIGRATION_FLAGS, -1);
}
}
-static virURIPtr
+static virURI *
vzParseVzURI(const char *uri_str)
{
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
if (!(uri = virURIParse(uri_str)))
goto error;
}
static int
-vzDomainMigratePerformStep(virDomainObjPtr dom,
- vzDriverPtr driver,
+vzDomainMigratePerformStep(virDomainObj *dom,
+ struct _vzDriver *driver,
virTypedParameterPtr params,
int nparams,
const char *cookiein,
unsigned int flags)
{
int ret = -1;
- vzDomObjPtr privdom = dom->privateData;
- virURIPtr vzuri = NULL;
+ struct vzDomObj *privdom = dom->privateData;
+ virURI *vzuri = NULL;
const char *miguri = NULL;
const char *dname = NULL;
- vzMigrationCookiePtr mig = NULL;
+ vzMigrationCookie *mig = NULL;
bool job = false;
if (virTypedParamsGetString(params, nparams,
}
static int
-vzDomainMigratePerformP2P(virDomainObjPtr dom,
- vzDriverPtr driver,
+vzDomainMigratePerformP2P(virDomainObj *dom,
+ struct _vzDriver *driver,
const char *dconnuri,
virTypedParameterPtr orig_params,
int nparams,
unsigned int flags)
{
int ret = -1;
- virDomainObjPtr dom;
- vzConnPtr privconn = domain->conn->privateData;
+ virDomainObj *dom;
+ struct _vzConn *privconn = domain->conn->privateData;
virCheckFlags(VZ_MIGRATION_FLAGS, -1);
unsigned int flags,
int cancelled)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
virDomainPtr domain = NULL;
- vzConnPtr privconn = dconn->privateData;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = dconn->privateData;
+ struct _vzDriver *driver = privconn->driver;
const char *name = NULL;
virCheckFlags(VZ_MIGRATION_FLAGS, NULL);
}
static int
-vzDomainGetJobInfoImpl(virDomainObjPtr dom, virDomainJobInfoPtr info)
+vzDomainGetJobInfoImpl(virDomainObj *dom, virDomainJobInfoPtr info)
{
- vzDomObjPtr privdom = dom->privateData;
- vzDomainJobObjPtr job = &privdom->job;
+ struct vzDomObj *privdom = dom->privateData;
+ struct _vzDomainJobObj *job = &privdom->job;
memset(info, 0, sizeof(*info));
static int
vzDomainGetJobInfo(virDomainPtr domain, virDomainJobInfoPtr info)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
unsigned int flags)
{
virDomainJobInfo info;
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
virCheckFlags(0, -1);
} while (0)
static int
-vzDomainGetBlockStats(virDomainObjPtr dom,
+vzDomainGetBlockStats(virDomainObj *dom,
virDomainStatsRecordPtr record,
int *maxparams)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
size_t i;
char param_name[VIR_TYPED_PARAM_FIELD_LENGTH];
for (i = 0; i < dom->def->ndisks; i++) {
virDomainBlockStatsStruct stat;
- virDomainDiskDefPtr disk = dom->def->disks[i];
+ virDomainDiskDef *disk = dom->def->disks[i];
if (prlsdkGetBlockStats(privdom->stats,
disk,
}
static int
-vzDomainGetNetStats(virDomainObjPtr dom,
+vzDomainGetNetStats(virDomainObj *dom,
virDomainStatsRecordPtr record,
int *maxparams)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
size_t i;
char param_name[VIR_TYPED_PARAM_FIELD_LENGTH];
for (i = 0; i < dom->def->nnets; i++) {
virDomainInterfaceStatsStruct stat;
- virDomainNetDefPtr net = dom->def->nets[i];
+ virDomainNetDef *net = dom->def->nets[i];
if (prlsdkGetNetStats(privdom->stats, privdom->sdkdom, net->ifname,
&stat) < 0)
}
static int
-vzDomainGetVCPUStats(virDomainObjPtr dom,
+vzDomainGetVCPUStats(virDomainObj *dom,
virDomainStatsRecordPtr record,
int *maxparams)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
size_t i;
char param_name[VIR_TYPED_PARAM_FIELD_LENGTH];
}
static int
-vzDomainGetBalloonStats(virDomainObjPtr dom,
+vzDomainGetBalloonStats(virDomainObj *dom,
virDomainStatsRecordPtr record,
int *maxparams)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
virDomainMemoryStatStruct stats[VIR_DOMAIN_MEMORY_STAT_NR];
size_t i;
int n;
}
static int
-vzDomainGetStateStats(virDomainObjPtr dom,
+vzDomainGetStateStats(virDomainObj *dom,
virDomainStatsRecordPtr record,
int *maxparams)
{
static virDomainStatsRecordPtr
vzDomainGetAllStats(virConnectPtr conn,
- virDomainObjPtr dom)
+ virDomainObj *dom)
{
virDomainStatsRecordPtr stat;
int maxparams = 0;
virDomainStatsRecordPtr **retStats,
unsigned int flags)
{
- vzConnPtr privconn = conn->privateData;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
unsigned int lflags = flags & (VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE |
VIR_CONNECT_LIST_DOMAINS_FILTERS_PERSISTENT |
VIR_CONNECT_LIST_DOMAINS_FILTERS_STATE);
VIR_DOMAIN_STATS_INTERFACE |
VIR_DOMAIN_STATS_BALLOON |
VIR_DOMAIN_STATS_BLOCK;
- virDomainObjPtr *doms = NULL;
+ virDomainObj **doms = NULL;
size_t ndoms;
virDomainStatsRecordPtr *tmpstats = NULL;
int nstats = 0;
for (i = 0; i < ndoms; i++) {
virDomainStatsRecordPtr tmp;
- virDomainObjPtr dom = doms[i];
+ virDomainObj *dom = doms[i];
virObjectLock(dom);
tmp = vzDomainGetAllStats(conn, dom);
static int
vzDomainAbortJob(virDomainPtr domain)
{
- virDomainObjPtr dom;
+ virDomainObj *dom;
int ret = -1;
if (!(dom = vzDomObjFromDomain(domain)))
static int
vzDomainReset(virDomainPtr domain, unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
static int vzDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
unsigned int flags)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
int ret = -1;
bool job = false;
unsigned long long size,
unsigned int flags)
{
- virDomainObjPtr dom = NULL;
- virDomainDiskDefPtr disk = NULL;
+ virDomainObj *dom = NULL;
+ virDomainDiskDef *disk = NULL;
int ret = -1;
bool job = false;
VIR_LOG_INIT("parallels.sdk");
static PRL_HANDLE
-prlsdkFindNetByMAC(PRL_HANDLE sdkdom, virMacAddrPtr mac);
+prlsdkFindNetByMAC(PRL_HANDLE sdkdom, virMacAddr *mac);
static PRL_HANDLE
-prlsdkGetDisk(PRL_HANDLE sdkdom, virDomainDiskDefPtr disk);
+prlsdkGetDisk(PRL_HANDLE sdkdom, virDomainDiskDef *disk);
static bool
prlsdkInBootList(PRL_HANDLE sdkdom,
PRL_HANDLE sdktargetdev);
result, __FILE__, __FUNCTION__, __LINE__)
static PRL_RESULT
-getDomainJobResultHelper(PRL_HANDLE job, virDomainObjPtr dom,
+getDomainJobResultHelper(PRL_HANDLE job, virDomainObj *dom,
unsigned int timeout, PRL_HANDLE *result,
const char *filename, const char *funcname,
size_t linenr)
__FUNCTION__, __LINE__)
static PRL_RESULT
-waitDomainJobHelper(PRL_HANDLE job, virDomainObjPtr dom, unsigned int timeout,
+waitDomainJobHelper(PRL_HANDLE job, virDomainObj *dom, unsigned int timeout,
const char *filename, const char *funcname,
size_t linenr)
{
- vzDomObjPtr pdom = dom->privateData;
+ struct vzDomObj *pdom = dom->privateData;
PRL_RESULT ret;
if (pdom->job.cancelled) {
typedef PRL_RESULT (*prlsdkParamGetterType)(PRL_HANDLE, char*, PRL_UINT32*);
int
-prlsdkCancelJob(virDomainObjPtr dom)
+prlsdkCancelJob(virDomainObj *dom)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
PRL_HANDLE job;
};
int
-prlsdkConnect(vzDriverPtr driver)
+prlsdkConnect(struct _vzDriver *driver)
{
int ret = -1;
PRL_RESULT pret;
}
void
-prlsdkDisconnect(vzDriverPtr driver)
+prlsdkDisconnect(struct _vzDriver *driver)
{
PRL_HANDLE job;
PRL_RESULT ret;
}
static int
-prlsdkSdkDomainLookup(vzDriverPtr driver,
+prlsdkSdkDomainLookup(struct _vzDriver *driver,
const char *id,
unsigned int flags,
PRL_HANDLE *sdkdom)
}
static PRL_HANDLE
-prlsdkSdkDomainLookupByUUID(vzDriverPtr driver, const unsigned char *uuid)
+prlsdkSdkDomainLookupByUUID(struct _vzDriver *driver, const unsigned char *uuid)
{
char uuidstr[VIR_UUID_STRING_BRACED_BUFLEN];
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
}
PRL_HANDLE
-prlsdkSdkDomainLookupByName(vzDriverPtr driver, const char *name)
+prlsdkSdkDomainLookupByName(struct _vzDriver *driver, const char *name)
{
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
}
static int
-prlsdkGetDomainState(virDomainObjPtr dom, PRL_HANDLE sdkdom, VIRTUAL_MACHINE_STATE_PTR vmState)
+prlsdkGetDomainState(virDomainObj *dom, PRL_HANDLE sdkdom, VIRTUAL_MACHINE_STATE_PTR vmState)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE result = PRL_INVALID_HANDLE;
}
static int
-prlsdkAddDomainVideoInfoCt(virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt)
+prlsdkAddDomainVideoInfoCt(virDomainDef *def,
+ virDomainXMLOption *xmlopt)
{
- virDomainVideoDefPtr video = NULL;
+ virDomainVideoDef *video = NULL;
int ret = -1;
if (def->ngraphics == 0)
}
static int
-prlsdkAddDomainVideoInfoVm(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkAddDomainVideoInfoVm(PRL_HANDLE sdkdom, virDomainDef *def)
{
- virDomainVideoDefPtr video = NULL;
- virDomainVideoAccelDefPtr accel = NULL;
+ virDomainVideoDef *video = NULL;
+ virDomainVideoAccelDef *accel = NULL;
PRL_RESULT ret;
PRL_UINT32 videoRam;
}
static int
-prlsdkGetDiskInfo(vzDriverPtr driver,
+prlsdkGetDiskInfo(struct _vzDriver *driver,
PRL_HANDLE prldisk,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
bool isCdrom,
bool isCt)
{
PRL_RESULT pret;
PRL_UINT32 emulatedType;
PRL_UINT32 size;
- virDomainDeviceDriveAddressPtr address;
+ virDomainDeviceDriveAddress *address;
int busIdx, devIdx;
int ret = -1;
static int
prlsdkGetFSInfo(PRL_HANDLE prldisk,
- virDomainFSDefPtr fs)
+ virDomainFSDef *fs)
{
char *buf = NULL;
int ret = -1;
char **matches = NULL;
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
fs->type = VIR_DOMAIN_FS_TYPE_FILE;
fs->fsdriver = VIR_DOMAIN_FS_DRIVER_TYPE_PLOOP;
}
static int
-prlsdkAddDomainHardDisksInfo(vzDriverPtr driver, PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkAddDomainHardDisksInfo(struct _vzDriver *driver, PRL_HANDLE sdkdom, virDomainDef *def)
{
PRL_RESULT pret;
PRL_UINT32 hddCount;
PRL_UINT32 i;
PRL_HANDLE hdd = PRL_INVALID_HANDLE;
- virDomainDiskDefPtr disk = NULL;
- virDomainFSDefPtr fs = NULL;
+ virDomainDiskDef *disk = NULL;
+ virDomainFSDef *fs = NULL;
pret = PrlVmCfg_GetHardDisksCount(sdkdom, &hddCount);
prlsdkCheckRetGoto(pret, error);
}
static int
-prlsdkAddDomainOpticalDisksInfo(vzDriverPtr driver, PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkAddDomainOpticalDisksInfo(struct _vzDriver *driver, PRL_HANDLE sdkdom, virDomainDef *def)
{
PRL_RESULT pret;
PRL_UINT32 cdromsCount;
PRL_UINT32 i;
PRL_HANDLE cdrom = PRL_INVALID_HANDLE;
- virDomainDiskDefPtr disk = NULL;
+ virDomainDiskDef *disk = NULL;
pret = PrlVmCfg_GetOpticalDisksCount(sdkdom, &cdromsCount);
prlsdkCheckRetGoto(pret, error);
return -1;
}
-static virNetDevIPAddrPtr
+static virNetDevIPAddr *
prlsdkParseNetAddress(char *addr)
{
char *maskstr = NULL;
int nbits;
virSocketAddr mask;
- virNetDevIPAddrPtr ip = NULL;
- virNetDevIPAddrPtr ret = NULL;
+ virNetDevIPAddr *ip = NULL;
+ virNetDevIPAddr *ret = NULL;
if (!(maskstr = strchr(addr, '/')))
goto cleanup;
}
static int
-prlsdkGetNetAddresses(PRL_HANDLE sdknet, virDomainNetDefPtr net)
+prlsdkGetNetAddresses(PRL_HANDLE sdknet, virDomainNetDef *net)
{
int ret = -1;
PRL_HANDLE addrlist = PRL_INVALID_HANDLE;
prlsdkCheckRetGoto(pret, cleanup);
for (i = 0; i < num; ++i) {
- virNetDevIPAddrPtr ip = NULL;
+ virNetDevIPAddr *ip = NULL;
PRL_UINT32 buflen = 0;
char *addr;
}
static int
-prlsdkGetRoutes(PRL_HANDLE sdknet, virDomainNetDefPtr net)
+prlsdkGetRoutes(PRL_HANDLE sdknet, virDomainNetDef *net)
{
int ret = -1;
char *gw = NULL;
}
static int
-prlsdkGetNetInfo(PRL_HANDLE netAdapter, virDomainNetDefPtr net, bool isCt)
+prlsdkGetNetInfo(PRL_HANDLE netAdapter, virDomainNetDef *net, bool isCt)
{
char macstr[VIR_MAC_STRING_BUFLEN];
PRL_UINT32 netAdapterIndex;
}
static int
-prlsdkAddDomainNetInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkAddDomainNetInfo(PRL_HANDLE sdkdom, virDomainDef *def)
{
- virDomainNetDefPtr net = NULL;
+ virDomainNetDef *net = NULL;
PRL_RESULT ret;
PRL_HANDLE netAdapter;
PRL_UINT32 netAdaptersCount;
}
static int
-prlsdkGetSerialInfo(PRL_HANDLE serialPort, virDomainChrDefPtr chr)
+prlsdkGetSerialInfo(PRL_HANDLE serialPort, virDomainChrDef *chr)
{
PRL_RESULT pret;
PRL_UINT32 serialPortIndex;
char *friendlyName = NULL;
PRL_SERIAL_PORT_SOCKET_OPERATION_MODE socket_mode;
char *uristr = NULL;
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
int ret = -1;
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
static int
prlsdkAddSerialInfo(PRL_HANDLE sdkdom,
- virDomainChrDefPtr **serials,
+ virDomainChrDef ***serials,
size_t *nserials)
{
PRL_RESULT ret;
PRL_HANDLE serialPort;
PRL_UINT32 serialPortsCount;
PRL_UINT32 i;
- virDomainChrDefPtr chr = NULL;
+ virDomainChrDef *chr = NULL;
ret = PrlVmCfg_GetSerialPortsCount(sdkdom, &serialPortsCount);
prlsdkCheckRetGoto(ret, cleanup);
static int
-prlsdkAddDomainHardware(vzDriverPtr driver,
+prlsdkAddDomainHardware(struct _vzDriver *driver,
PRL_HANDLE sdkdom,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt)
{
if (IS_CT(def)) {
if (prlsdkAddDomainVideoInfoCt(def, xmlopt) < 0)
static int
-prlsdkAddVNCInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkAddVNCInfo(PRL_HANDLE sdkdom, virDomainDef *def)
{
- virDomainGraphicsDefPtr gr = NULL;
+ virDomainGraphicsDef *gr = NULL;
PRL_VM_REMOTE_DISPLAY_MODE vncMode;
PRL_UINT32 port;
PRL_RESULT pret;
static void
prlsdkConvertDomainState(VIRTUAL_MACHINE_STATE domainState,
PRL_UINT32 envId,
- virDomainObjPtr dom)
+ virDomainObj *dom)
{
switch (domainState) {
case VMS_STOPPED:
static int
prlsdkConvertCpuInfo(PRL_HANDLE sdkdom,
- virDomainDefPtr def,
- virDomainXMLOptionPtr xmlopt)
+ virDomainDef *def,
+ virDomainXMLOption *xmlopt)
{
g_autofree char *buf = NULL;
int hostcpus;
}
static int
-prlsdkConvertDomainType(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkConvertDomainType(PRL_HANDLE sdkdom, virDomainDef *def)
{
PRL_VM_TYPE domainType;
PRL_RESULT pret;
}
static int
-prlsdkConvertCpuMode(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkConvertCpuMode(PRL_HANDLE sdkdom, virDomainDef *def)
{
PRL_RESULT pret;
PRL_CPU_MODE cpuMode;
return PRL_INVALID_HANDLE;
}
-static virDomainDiskDefPtr
-virFindDiskBootIndex(virDomainDefPtr def, virDomainDiskDevice type, int index)
+static virDomainDiskDef *
+virFindDiskBootIndex(virDomainDef *def, virDomainDiskDevice type, int index)
{
size_t i;
int c = 0;
}
static int
prlsdkBootOrderCheck(PRL_HANDLE sdkdom, PRL_DEVICE_TYPE sdkType, int sdkIndex,
- virDomainDefPtr def, int bootIndex)
+ virDomainDef *def, int bootIndex)
{
char *sdkName = NULL;
PRL_HANDLE dev = PRL_INVALID_HANDLE;
- virDomainDiskDefPtr disk;
+ virDomainDiskDef *disk;
virDomainDiskDevice device;
int bus;
char *dst = NULL;
}
static int
-prlsdkConvertBootOrderVm(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkConvertBootOrderVm(PRL_HANDLE sdkdom, virDomainDef *def)
{
int ret = -1;
PRL_RESULT pret;
* Returned object is locked and referenced.
*/
-static virDomainObjPtr
-prlsdkLoadDomain(vzDriverPtr driver,
+static virDomainObj *
+prlsdkLoadDomain(struct _vzDriver *driver,
PRL_HANDLE sdkdom,
- virDomainObjPtr dom)
+ virDomainObj *dom)
{
- virDomainDefPtr def = NULL;
- vzDomObjPtr pdom = NULL;
+ virDomainDef *def = NULL;
+ struct vzDomObj *pdom = NULL;
VIRTUAL_MACHINE_STATE domainState;
PRL_RESULT pret;
}
if (!dom) {
- virDomainObjPtr olddom = NULL;
+ virDomainObj *olddom = NULL;
job = PrlVm_SubscribeToPerfStats(sdkdom, NULL);
if (PRL_FAILED(waitJob(job)))
}
int
-prlsdkLoadDomains(vzDriverPtr driver)
+prlsdkLoadDomains(struct _vzDriver *driver)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE result;
PRL_UINT32 paramsCount;
PRL_RESULT pret;
size_t i = 0;
- virDomainObjPtr dom;
+ virDomainObj *dom;
job = PrlSrv_GetVmListEx(driver->server, PVTF_VM | PVTF_CT);
return -1;
}
-virDomainObjPtr
-prlsdkAddDomainByUUID(vzDriverPtr driver, const unsigned char *uuid)
+virDomainObj *
+prlsdkAddDomainByUUID(struct _vzDriver *driver, const unsigned char *uuid)
{
PRL_HANDLE sdkdom;
- virDomainObjPtr dom;
+ virDomainObj *dom;
sdkdom = prlsdkSdkDomainLookupByUUID(driver, uuid);
if (sdkdom == PRL_INVALID_HANDLE)
return dom;
}
-virDomainObjPtr
-prlsdkAddDomainByName(vzDriverPtr driver, const char *name)
+virDomainObj *
+prlsdkAddDomainByName(struct _vzDriver *driver, const char *name)
{
PRL_HANDLE sdkdom;
- virDomainObjPtr dom;
+ virDomainObj *dom;
sdkdom = prlsdkSdkDomainLookupByName(driver, name);
if (sdkdom == PRL_INVALID_HANDLE)
}
int
-prlsdkUpdateDomain(vzDriverPtr driver, virDomainObjPtr dom)
+prlsdkUpdateDomain(struct _vzDriver *driver, virDomainObj *dom)
{
PRL_HANDLE job;
- vzDomObjPtr pdom = dom->privateData;
+ struct vzDomObj *pdom = dom->privateData;
job = PrlVm_RefreshConfig(pdom->sdkdom);
if (waitDomainJob(job, dom))
}
static void
-prlsdkSendEvent(vzDriverPtr driver,
- virDomainObjPtr dom,
+prlsdkSendEvent(struct _vzDriver *driver,
+ virDomainObj *dom,
virDomainEventType lvEventType,
int lvEventTypeDetails)
{
- virObjectEventPtr event;
+ virObjectEvent *event;
event = virDomainEventLifecycleNewFromObj(dom,
lvEventType,
}
static void
-prlsdkHandleVmStateEvent(vzDriverPtr driver,
+prlsdkHandleVmStateEvent(struct _vzDriver *driver,
PRL_HANDLE prlEvent,
unsigned char *uuid)
{
PRL_RESULT pret = PRL_ERR_FAILURE;
PRL_HANDLE eventParam = PRL_INVALID_HANDLE;
PRL_INT32 domainState;
- virDomainObjPtr dom = NULL;
- vzDomObjPtr pdom;
+ virDomainObj *dom = NULL;
+ struct vzDomObj *pdom;
virDomainEventType lvEventType = 0;
int lvEventTypeDetails = 0;
}
static void
-prlsdkHandleVmConfigEvent(vzDriverPtr driver,
+prlsdkHandleVmConfigEvent(struct _vzDriver *driver,
unsigned char *uuid)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
bool job = false;
dom = virDomainObjListFindByUUID(driver->domains, uuid);
}
static void
-prlsdkHandleVmAddedEvent(vzDriverPtr driver,
+prlsdkHandleVmAddedEvent(struct _vzDriver *driver,
unsigned char *uuid)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
if (!(dom = virDomainObjListFindByUUID(driver->domains, uuid)) &&
!(dom = prlsdkAddDomainByUUID(driver, uuid)))
}
static void
-prlsdkHandleVmRemovedEvent(vzDriverPtr driver,
+prlsdkHandleVmRemovedEvent(struct _vzDriver *driver,
unsigned char *uuid)
{
- virDomainObjPtr dom = NULL;
+ virDomainObj *dom = NULL;
dom = virDomainObjListFindByUUID(driver->domains, uuid);
/* domain was removed from the list from the libvirt
}
static void
-prlsdkHandlePerfEvent(vzDriverPtr driver,
+prlsdkHandlePerfEvent(struct _vzDriver *driver,
PRL_HANDLE event,
unsigned char *uuid)
{
- virDomainObjPtr dom = NULL;
- vzDomObjPtr privdom = NULL;
+ virDomainObj *dom = NULL;
+ struct vzDomObj *privdom = NULL;
if (!(dom = virDomainObjListFindByUUID(driver->domains, uuid))) {
PrlHandle_Free(event);
}
static void
-prlsdkHandleMigrationProgress(vzDriverPtr driver,
+prlsdkHandleMigrationProgress(struct _vzDriver *driver,
PRL_HANDLE event,
unsigned char *uuid)
{
- virDomainObjPtr dom = NULL;
- vzDomObjPtr privdom = NULL;
+ virDomainObj *dom = NULL;
+ struct vzDomObj *privdom = NULL;
PRL_UINT32 progress;
PRL_HANDLE param = PRL_INVALID_HANDLE;
PRL_RESULT pret;
static PRL_RESULT
prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque)
{
- vzDriverPtr driver = opaque;
+ struct _vzDriver *driver = opaque;
PRL_RESULT pret = PRL_ERR_FAILURE;
PRL_HANDLE_TYPE handleType;
char uuidstr[VIR_UUID_STRING_BRACED_BUFLEN];
return PRL_ERR_SUCCESS;
}
-int prlsdkStart(virDomainObjPtr dom)
+int prlsdkStart(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_StartEx(privdom->sdkdom, PSM_VM_START, 0);
return 0;
}
-int prlsdkKill(virDomainObjPtr dom)
+int prlsdkKill(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_StopEx(privdom->sdkdom, PSM_KILL, 0);
return 0;
}
-int prlsdkStop(virDomainObjPtr dom)
+int prlsdkStop(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_StopEx(privdom->sdkdom, PSM_SHUTDOWN, 0);
return 0;
}
-int prlsdkPause(virDomainObjPtr dom)
+int prlsdkPause(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_Pause(privdom->sdkdom, false);
return 0;
}
-int prlsdkResume(virDomainObjPtr dom)
+int prlsdkResume(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_Resume(privdom->sdkdom);
return 0;
}
-int prlsdkSuspend(virDomainObjPtr dom)
+int prlsdkSuspend(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_Suspend(privdom->sdkdom);
return 0;
}
-int prlsdkRestart(virDomainObjPtr dom)
+int prlsdkRestart(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_Restart(privdom->sdkdom);
return 0;
}
-int prlsdkReset(virDomainObjPtr dom)
+int prlsdkReset(virDomainObj *dom)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_RESULT pret;
job = PrlVm_Reset(privdom->sdkdom);
}
static int
-prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
{
size_t i;
PRL_VM_TYPE vmType;
}
for (i = 0; i < virDomainDefGetVcpusMax(def); i++) {
- virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(def, i);
+ virDomainVcpuDef *vcpu = virDomainDefGetVcpu(def, i);
if (vcpu->cpumask &&
!virBitmapEqual(def->cpumask, vcpu->cpumask)) {
/*
* Though we don't support NUMA configuration at the moment
- * virDomainDefPtr always contain non zero NUMA configuration
+ * virDomainDef *always contain non zero NUMA configuration
* So, just make sure this configuration doesn't differ from auto generated.
*/
if ((virDomainNumatuneGetMode(def->numa, -1, &memMode) == 0 &&
return -1;
}
-static int prlsdkCheckVideoUnsupportedParams(virDomainDefPtr def)
+static int prlsdkCheckVideoUnsupportedParams(virDomainDef *def)
{
- virDomainVideoDefPtr v;
+ virDomainVideoDef *v;
if (IS_CT(def)) {
if (def->nvideos == 0) {
return 0;
}
-static int prlsdkCheckSerialUnsupportedParams(virDomainChrDefPtr chr)
+static int prlsdkCheckSerialUnsupportedParams(virDomainChrDef *chr)
{
if (chr->deviceType != VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
return 0;
}
-static int prlsdkCheckNetUnsupportedParams(virDomainNetDefPtr net)
+static int prlsdkCheckNetUnsupportedParams(virDomainNetDef *net)
{
if (net->type != VIR_DOMAIN_NET_TYPE_NETWORK &&
net->type != VIR_DOMAIN_NET_TYPE_BRIDGE) {
return 0;
}
-static int prlsdkCheckFSUnsupportedParams(virDomainFSDefPtr fs)
+static int prlsdkCheckFSUnsupportedParams(virDomainFSDef *fs)
{
if (fs->type != VIR_DOMAIN_FS_TYPE_FILE &&
fs->type != VIR_DOMAIN_FS_TYPE_VOLUME) {
}
static int prlsdkApplyGraphicsParams(PRL_HANDLE sdkdom,
- virDomainGraphicsDefPtr gr)
+ virDomainGraphicsDef *gr)
{
- virDomainGraphicsListenDefPtr glisten;
+ virDomainGraphicsListenDef *glisten;
PRL_RESULT pret;
if (!gr) {
return 0;
}
-static int prlsdkApplyVideoParams(PRL_HANDLE sdkdom G_GNUC_UNUSED, virDomainDefPtr def)
+static int prlsdkApplyVideoParams(PRL_HANDLE sdkdom G_GNUC_UNUSED, virDomainDef *def)
{
PRL_RESULT pret;
return 0;
}
-static int prlsdkAddSerial(PRL_HANDLE sdkdom, virDomainChrDefPtr chr)
+static int prlsdkAddSerial(PRL_HANDLE sdkdom, virDomainChrDef *chr)
{
PRL_RESULT pret;
PRL_HANDLE sdkchr = PRL_INVALID_HANDLE;
#define PRL_MAC_STRING_BUFNAME 13
-static const char * prlsdkFormatMac(virMacAddrPtr mac, char *macstr)
+static const char * prlsdkFormatMac(virMacAddr *mac, char *macstr)
{
g_snprintf(macstr, PRL_MAC_STRING_BUFNAME,
"%02X%02X%02X%02X%02X%02X",
return macstr;
}
-static int prlsdkConfigureGateways(PRL_HANDLE sdknet, virDomainNetDefPtr net)
+static int prlsdkConfigureGateways(PRL_HANDLE sdknet, virDomainNetDef *net)
{
int ret = -1;
size_t i;
- virNetDevIPRoutePtr route4 = NULL;
- virNetDevIPRoutePtr route6 = NULL;
+ virNetDevIPRoute *route4 = NULL;
+ virNetDevIPRoute *route6 = NULL;
char *gw4 = NULL, *gw6 = NULL;
PRL_RESULT pret;
for (i = 0; i < net->guestIP.nroutes; i++) {
- virSocketAddrPtr addrdst;
- virSocketAddrPtr gateway;
+ virSocketAddr *addrdst;
+ virSocketAddr *gateway;
virSocketAddr zero;
addrdst = virNetDevIPRouteGetAddress(net->guestIP.routes[i]);
return ret;
}
-static int prlsdkConfigureNet(vzDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr dom G_GNUC_UNUSED,
+static int prlsdkConfigureNet(struct _vzDriver *driver G_GNUC_UNUSED,
+ virDomainObj *dom G_GNUC_UNUSED,
PRL_HANDLE sdkdom,
- virDomainNetDefPtr net,
+ virDomainNetDef *net,
bool isCt, bool create)
{
PRL_RESULT pret;
}
static PRL_HANDLE
-prlsdkFindNetByMAC(PRL_HANDLE sdkdom, virMacAddrPtr mac)
+prlsdkFindNetByMAC(PRL_HANDLE sdkdom, virMacAddr *mac)
{
PRL_RESULT pret;
PRL_UINT32 adaptersCount;
return adapter;
}
-static int prlsdkConfigureDisk(vzDriverPtr driver,
+static int prlsdkConfigureDisk(struct _vzDriver *driver,
PRL_HANDLE sdkdom,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
bool create)
{
PRL_RESULT pret;
PRL_VM_DEV_EMULATION_TYPE emutype;
PRL_MASS_STORAGE_INTERFACE_TYPE sdkbus;
int idx;
- virDomainDeviceDriveAddressPtr drive;
+ virDomainDeviceDriveAddress *drive;
PRL_DEVICE_TYPE devType;
PRL_CLUSTERED_DEVICE_SUBTYPE scsiModel;
const char *path = disk->src->path ? : "";
}
static PRL_HANDLE
-prlsdkGetDisk(PRL_HANDLE sdkdom, virDomainDiskDefPtr disk)
+prlsdkGetDisk(PRL_HANDLE sdkdom, virDomainDiskDef *disk)
{
PRL_RESULT pret;
PRL_UINT32 num;
}
int
-prlsdkAttachDevice(vzDriverPtr driver,
- virDomainObjPtr dom,
- virDomainDeviceDefPtr dev)
+prlsdkAttachDevice(struct _vzDriver *driver,
+ virDomainObj *dom,
+ virDomainDeviceDef *dev)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
job = PrlVm_BeginEdit(privdom->sdkdom);
}
int
-prlsdkDetachDevice(vzDriverPtr driver G_GNUC_UNUSED,
- virDomainObjPtr dom,
- virDomainDeviceDefPtr dev)
+prlsdkDetachDevice(struct _vzDriver *driver G_GNUC_UNUSED,
+ virDomainObj *dom,
+ virDomainDeviceDef *dev)
{
int ret = -1;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE sdkdev = PRL_INVALID_HANDLE;
PRL_RESULT pret;
}
int
-prlsdkUpdateDevice(vzDriverPtr driver,
- virDomainObjPtr dom,
- virDomainDeviceDefPtr dev)
+prlsdkUpdateDevice(struct _vzDriver *driver,
+ virDomainObj *dom,
+ virDomainDeviceDef *dev)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
job = PrlVm_BeginEdit(privdom->sdkdom);
}
static int
-prlsdkAddFS(PRL_HANDLE sdkdom, virDomainFSDefPtr fs)
+prlsdkAddFS(PRL_HANDLE sdkdom, virDomainFSDef *fs)
{
PRL_RESULT pret;
PRL_HANDLE sdkdisk = PRL_INVALID_HANDLE;
}
static int
-prlsdkSetBootOrderCt(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkSetBootOrderCt(PRL_HANDLE sdkdom, virDomainDef *def)
{
size_t i;
PRL_HANDLE hdd = PRL_INVALID_HANDLE;
}
static int
-prlsdkSetBootOrderVm(PRL_HANDLE sdkdom, virDomainDefPtr def)
+prlsdkSetBootOrderVm(PRL_HANDLE sdkdom, virDomainDef *def)
{
size_t i;
int idx[VIR_DOMAIN_BOOT_LAST] = { 0 };
}
int
-prlsdkDomainSetUserPassword(virDomainObjPtr dom,
+prlsdkDomainSetUserPassword(virDomainObj *dom,
const char *user,
const char *password)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
job = PrlVm_SetUserPasswd(privdom->sdkdom,
}
static int
-prlsdkDoApplyConfig(vzDriverPtr driver,
- virDomainObjPtr dom,
+prlsdkDoApplyConfig(struct _vzDriver *driver,
+ virDomainObj *dom,
PRL_HANDLE sdkdom,
- virDomainDefPtr def)
+ virDomainDef *def)
{
PRL_RESULT pret;
size_t i;
}
int
-prlsdkApplyConfig(vzDriverPtr driver,
- virDomainObjPtr dom,
- virDomainDefPtr new)
+prlsdkApplyConfig(struct _vzDriver *driver,
+ virDomainObj *dom,
+ virDomainDef *new)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
int ret;
}
int
-prlsdkCreateVm(vzDriverPtr driver, virDomainDefPtr def)
+prlsdkCreateVm(struct _vzDriver *driver, virDomainDef *def)
{
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
PRL_HANDLE job = PRL_INVALID_HANDLE;
}
static int
-virStorageTranslatePoolLocal(virConnectPtr conn, virStorageSourcePtr src)
+virStorageTranslatePoolLocal(virConnectPtr conn, virStorageSource *src)
{
virStoragePoolPtr pool = NULL;
virStorageVolPtr vol = NULL;
int
-prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def)
+prlsdkCreateCt(virConnectPtr conn, virDomainDef *def)
{
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
PRL_GET_VM_CONFIG_PARAM_DATA confParam;
PRL_HANDLE result = PRL_INVALID_HANDLE;
PRL_RESULT pret;
PRL_UINT32 flags;
- vzConnPtr privconn = conn->privateData;
- vzDriverPtr driver = privconn->driver;
+ struct _vzConn *privconn = conn->privateData;
+ struct _vzDriver *driver = privconn->driver;
int ret = -1;
int useTemplate = 0;
size_t i;
* Returns 0 if hard disks were successfully detached or not detected.
*/
static int
-prlsdkDetachDomainHardDisks(virDomainObjPtr dom)
+prlsdkDetachDomainHardDisks(virDomainObj *dom)
{
int ret = -1;
PRL_RESULT pret;
PRL_UINT32 i;
PRL_HANDLE job;
PRL_HANDLE sdkdisk = PRL_INVALID_HANDLE;
- vzDomObjPtr pdom = dom->privateData;
+ struct vzDomObj *pdom = dom->privateData;
PRL_HANDLE sdkdom = pdom->sdkdom;
job = PrlVm_BeginEdit(sdkdom);
}
int
-prlsdkUnregisterDomain(vzDriverPtr driver, virDomainObjPtr dom, unsigned int flags)
+prlsdkUnregisterDomain(struct _vzDriver *driver, virDomainObj *dom, unsigned int flags)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainSnapshotObjList *snapshots = NULL;
VIRTUAL_MACHINE_STATE domainState;
int ret = -1;
int num;
}
int
-prlsdkDomainManagedSaveRemove(virDomainObjPtr dom)
+prlsdkDomainManagedSaveRemove(virDomainObj *dom)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
job = PrlVm_DropSuspendedState(privdom->sdkdom);
int
prlsdkGetBlockStats(PRL_HANDLE sdkstats,
- virDomainDiskDefPtr disk,
+ virDomainDiskDef *disk,
virDomainBlockStatsPtr stats,
bool isCt)
{
- virDomainDeviceDriveAddressPtr address;
+ virDomainDeviceDriveAddress *address;
int idx;
const char *prefix;
int ret = -1;
}
/* memsize is in MiB */
-int prlsdkSetMemsize(virDomainObjPtr dom, unsigned int memsize)
+int prlsdkSetMemsize(virDomainObj *dom, unsigned int memsize)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
PRL_RESULT pret;
return (long long)g_date_time_to_unix(then);
}
-static virDomainSnapshotObjListPtr
+static virDomainSnapshotObjList *
prlsdkParseSnapshotTree(const char *treexml)
{
- virDomainSnapshotObjListPtr ret = NULL;
+ virDomainSnapshotObjList *ret = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr root;
xmlNodePtr *nodes = NULL;
- virDomainSnapshotDefPtr def = NULL;
- virDomainMomentObjPtr snapshot;
- virDomainSnapshotObjListPtr snapshots = NULL;
+ virDomainSnapshotDef *def = NULL;
+ virDomainMomentObj *snapshot;
+ virDomainSnapshotObjList *snapshots = NULL;
char *xmlstr = NULL;
int n;
size_t i;
return ret;
}
-virDomainSnapshotObjListPtr
-prlsdkLoadSnapshots(virDomainObjPtr dom)
+virDomainSnapshotObjList *
+prlsdkLoadSnapshots(virDomainObj *dom)
{
- virDomainSnapshotObjListPtr ret = NULL;
+ virDomainSnapshotObjList *ret = NULL;
PRL_HANDLE job;
PRL_HANDLE result = PRL_INVALID_HANDLE;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
char *treexml = NULL;
job = PrlVm_GetSnapshotsTreeEx(privdom->sdkdom, PGST_WITHOUT_SCREENSHOTS);
return ret;
}
-int prlsdkCreateSnapshot(virDomainObjPtr dom, const char *description)
+int prlsdkCreateSnapshot(virDomainObj *dom, const char *description)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
job = PrlVm_CreateSnapshot(privdom->sdkdom, "",
return 0;
}
-int prlsdkDeleteSnapshot(virDomainObjPtr dom, const char *uuid, bool children)
+int prlsdkDeleteSnapshot(virDomainObj *dom, const char *uuid, bool children)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
job = PrlVm_DeleteSnapshot(privdom->sdkdom, uuid, children);
return 0;
}
-int prlsdkSwitchToSnapshot(virDomainObjPtr dom, const char *uuid, bool paused)
+int prlsdkSwitchToSnapshot(virDomainObj *dom, const char *uuid, bool paused)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
PRL_UINT32 flags = 0;
#define PRLSDK_MIGRATION_FLAGS (PSL_HIGH_SECURITY | PVMT_DONT_CREATE_DISK)
-int prlsdkMigrate(virDomainObjPtr dom, virURIPtr uri,
+int prlsdkMigrate(virDomainObj *dom, virURI *uri,
const unsigned char *session_uuid,
const char *dname,
unsigned int flags)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE;
char uuidstr[VIR_UUID_STRING_BRACED_BUFLEN];
PRL_UINT32 vzflags = PRLSDK_MIGRATION_FLAGS;
return 0;
}
-int prlsdkSetCpuCount(virDomainObjPtr dom, unsigned int count)
+int prlsdkSetCpuCount(virDomainObj *dom, unsigned int count)
{
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_HANDLE job;
PRL_RESULT pret;
return 0;
}
-int prlsdkResizeImage(virDomainObjPtr dom, virDomainDiskDefPtr disk,
+int prlsdkResizeImage(virDomainObj *dom, virDomainDiskDef *disk,
unsigned long long newsize)
{
int ret = -1;
PRL_RESULT pret;
- vzDomObjPtr privdom = dom->privateData;
+ struct vzDomObj *privdom = dom->privateData;
PRL_UINT32 emulatedType;
PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE prldisk = PRL_INVALID_HANDLE;
int prlsdkInit(void);
void prlsdkDeinit(void);
-int prlsdkConnect(vzDriverPtr driver);
-void prlsdkDisconnect(vzDriverPtr driver);
+int prlsdkConnect(struct _vzDriver *driver);
+void prlsdkDisconnect(struct _vzDriver *driver);
int
-prlsdkLoadDomains(vzDriverPtr driver);
-virDomainObjPtr
-prlsdkAddDomainByUUID(vzDriverPtr driver, const unsigned char *uuid);
-virDomainObjPtr
-prlsdkAddDomainByName(vzDriverPtr driver, const char *name);
-int prlsdkUpdateDomain(vzDriverPtr driver, virDomainObjPtr dom);
+prlsdkLoadDomains(struct _vzDriver *driver);
+virDomainObj *
+prlsdkAddDomainByUUID(struct _vzDriver *driver, const unsigned char *uuid);
+virDomainObj *
+prlsdkAddDomainByName(struct _vzDriver *driver, const char *name);
+int prlsdkUpdateDomain(struct _vzDriver *driver, virDomainObj *dom);
-int prlsdkStart(virDomainObjPtr dom);
-int prlsdkKill(virDomainObjPtr dom);
-int prlsdkStop(virDomainObjPtr dom);
-int prlsdkPause(virDomainObjPtr dom);
-int prlsdkResume(virDomainObjPtr dom);
-int prlsdkSuspend(virDomainObjPtr dom);
-int prlsdkRestart(virDomainObjPtr dom);
-int prlsdkReset(virDomainObjPtr dom);
+int prlsdkStart(virDomainObj *dom);
+int prlsdkKill(virDomainObj *dom);
+int prlsdkStop(virDomainObj *dom);
+int prlsdkPause(virDomainObj *dom);
+int prlsdkResume(virDomainObj *dom);
+int prlsdkSuspend(virDomainObj *dom);
+int prlsdkRestart(virDomainObj *dom);
+int prlsdkReset(virDomainObj *dom);
int
-prlsdkApplyConfig(vzDriverPtr driver,
- virDomainObjPtr dom,
- virDomainDefPtr new);
-int prlsdkCreateVm(vzDriverPtr driver, virDomainDefPtr def);
-int prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def);
+prlsdkApplyConfig(struct _vzDriver *driver,
+ virDomainObj *dom,
+ virDomainDef *new);
+int prlsdkCreateVm(struct _vzDriver *driver, virDomainDef *def);
+int prlsdkCreateCt(virConnectPtr conn, virDomainDef *def);
int
-prlsdkUnregisterDomain(vzDriverPtr driver, virDomainObjPtr dom, unsigned int flags);
+prlsdkUnregisterDomain(struct _vzDriver *driver, virDomainObj *dom, unsigned int flags);
int
-prlsdkDomainManagedSaveRemove(virDomainObjPtr dom);
+prlsdkDomainManagedSaveRemove(virDomainObj *dom);
int
-prlsdkAttachDevice(vzDriverPtr driver, virDomainObjPtr dom, virDomainDeviceDefPtr dev);
+prlsdkAttachDevice(struct _vzDriver *driver, virDomainObj *dom, virDomainDeviceDef *dev);
int
-prlsdkDetachDevice(vzDriverPtr driver, virDomainObjPtr dom, virDomainDeviceDefPtr dev);
+prlsdkDetachDevice(struct _vzDriver *driver, virDomainObj *dom, virDomainDeviceDef *dev);
int
-prlsdkUpdateDevice(vzDriverPtr driver, virDomainObjPtr dom, virDomainDeviceDefPtr dev);
+prlsdkUpdateDevice(struct _vzDriver *driver, virDomainObj *dom, virDomainDeviceDef *dev);
int
-prlsdkGetBlockStats(PRL_HANDLE sdkstats, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats, bool isCt);
+prlsdkGetBlockStats(PRL_HANDLE sdkstats, virDomainDiskDef *disk, virDomainBlockStatsPtr stats, bool isCt);
int
prlsdkGetNetStats(PRL_HANDLE sdkstas, PRL_HANDLE sdkdom, const char *path, virDomainInterfaceStatsPtr stats);
int
int
prlsdkGetMemoryStats(PRL_HANDLE sdkstas, virDomainMemoryStatPtr stats, unsigned int nr_stats);
/* memsize is in MiB */
-int prlsdkSetMemsize(virDomainObjPtr dom, unsigned int memsize);
-int prlsdkSetCpuCount(virDomainObjPtr dom, unsigned int count);
+int prlsdkSetMemsize(virDomainObj *dom, unsigned int memsize);
+int prlsdkSetCpuCount(virDomainObj *dom, unsigned int count);
int
-prlsdkDomainSetUserPassword(virDomainObjPtr dom,
+prlsdkDomainSetUserPassword(virDomainObj *dom,
const char *user,
const char *password);
-virDomainSnapshotObjListPtr prlsdkLoadSnapshots(virDomainObjPtr dom);
-int prlsdkCreateSnapshot(virDomainObjPtr dom, const char *description);
-int prlsdkDeleteSnapshot(virDomainObjPtr dom, const char *uuid, bool children);
-int prlsdkSwitchToSnapshot(virDomainObjPtr dom, const char *uuid, bool paused);
+virDomainSnapshotObjList *prlsdkLoadSnapshots(virDomainObj *dom);
+int prlsdkCreateSnapshot(virDomainObj *dom, const char *description);
+int prlsdkDeleteSnapshot(virDomainObj *dom, const char *uuid, bool children);
+int prlsdkSwitchToSnapshot(virDomainObj *dom, const char *uuid, bool paused);
int
-prlsdkMigrate(virDomainObjPtr dom,
- virURIPtr uri,
+prlsdkMigrate(virDomainObj *dom,
+ virURI *uri,
const char unsigned *session_uuid,
const char *dname,
unsigned int flags);
PRL_HANDLE
-prlsdkSdkDomainLookupByName(vzDriverPtr driver, const char *name);
-int prlsdkCancelJob(virDomainObjPtr dom);
-int prlsdkResizeImage(virDomainObjPtr dom, virDomainDiskDefPtr disk, unsigned long long newsize);
+prlsdkSdkDomainLookupByName(struct _vzDriver *driver, const char *name);
+int prlsdkCancelJob(virDomainObj *dom);
+int prlsdkResizeImage(virDomainObj *dom, virDomainDiskDef *disk, unsigned long long newsize);
* vzDomObjFromDomain:
* @domain: Domain pointer that has to be looked up
*
- * This function looks up @domain and returns the appropriate virDomainObjPtr
+ * This function looks up @domain and returns the appropriate virDomainObj *
* that has to be released by calling virDomainObjEndAPI().
*
* Returns the domain object with incremented reference counter which is locked
* on success, NULL otherwise.
*/
-virDomainObjPtr
+virDomainObj *
vzDomObjFromDomain(virDomainPtr domain)
{
- virDomainObjPtr vm;
- vzConnPtr privconn = domain->conn->privateData;
+ virDomainObj *vm;
+ struct _vzConn *privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- vzDriverPtr driver = privconn->driver;
+ struct _vzDriver *driver = privconn->driver;
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
static int
vzDoCmdRun(char **outbuf, const char *binary, va_list list)
{
- virCommandPtr cmd = virCommandNewVAList(binary, list);
+ virCommand *cmd = virCommandNewVAList(binary, list);
int ret = -1;
if (outbuf)
}
static void
-vzInitCaps(unsigned long vzVersion, vzCapabilitiesPtr vzCaps)
+vzInitCaps(unsigned long vzVersion, struct _vzCapabilities *vzCaps)
{
if (vzVersion < VIRTUOZZO_VER_7) {
vzCaps->ctDiskFormat = VIR_STORAGE_FILE_PLOOP;
}
int
-vzInitVersion(vzDriverPtr driver)
+vzInitVersion(struct _vzDriver *driver)
{
char *output, *sVer, *tmp;
const char *searchStr = "prlsrvctl version ";
}
static int
-vzCheckDiskAddressDriveUnsupportedParams(virDomainDiskDefPtr disk)
+vzCheckDiskAddressDriveUnsupportedParams(virDomainDiskDef *disk)
{
- virDomainDeviceDriveAddressPtr drive = &disk->info.addr.drive;
+ virDomainDeviceDriveAddress *drive = &disk->info.addr.drive;
int devIdx, busIdx;
if (drive->controller > 0) {
}
static int
-vzCheckDiskUnsupportedParams(virDomainDiskDefPtr disk)
+vzCheckDiskUnsupportedParams(virDomainDiskDef *disk)
{
if (disk->device != VIR_DOMAIN_DISK_DEVICE_DISK &&
disk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
int
vzCheckUnsupportedDisk(const virDomainDef *def,
- virDomainDiskDefPtr disk,
- vzCapabilitiesPtr vzCaps)
+ virDomainDiskDef *disk,
+ struct _vzCapabilities *vzCaps)
{
size_t i;
virStorageFileFormat diskFormat;
}
int
-vzCheckUnsupportedControllers(const virDomainDef *def, vzCapabilitiesPtr vzCaps)
+vzCheckUnsupportedControllers(const virDomainDef *def, struct _vzCapabilities *vzCaps)
{
size_t i, j;
- virDomainControllerDefPtr controller;
+ virDomainControllerDef *controller;
for (i = 0; i < def->ncontrollers; i++) {
controller = def->controllers[i];
return 0;
}
-int vzGetDefaultSCSIModel(vzDriverPtr driver,
+int vzGetDefaultSCSIModel(struct _vzDriver *driver,
PRL_CLUSTERED_DEVICE_SUBTYPE *scsiModel)
{
switch ((int)driver->vzCaps.scsiControllerModel) {
return 0;
}
-int vzCheckUnsupportedGraphics(virDomainGraphicsDefPtr gr)
+int vzCheckUnsupportedGraphics(virDomainGraphicsDef *gr)
{
if (gr->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
void*
vzDomObjAlloc(void *opaque G_GNUC_UNUSED)
{
- vzDomObjPtr pdom = NULL;
+ struct vzDomObj *pdom = NULL;
pdom = g_new0(struct vzDomObj, 1);
void
vzDomObjFree(void* p)
{
- vzDomObjPtr pdom = p;
+ struct vzDomObj *pdom = p;
if (!pdom)
return;
#define VZ_JOB_WAIT_TIME (1000 * 30)
int
-vzDomainObjBeginJob(virDomainObjPtr dom)
+vzDomainObjBeginJob(virDomainObj *dom)
{
- vzDomObjPtr pdom = dom->privateData;
+ struct vzDomObj *pdom = dom->privateData;
unsigned long long now;
unsigned long long then;
}
void
-vzDomainObjEndJob(virDomainObjPtr dom)
+vzDomainObjEndJob(virDomainObj *dom)
{
- vzDomObjPtr pdom = dom->privateData;
+ struct vzDomObj *pdom = dom->privateData;
pdom->job.active = false;
pdom->job.cancelled = false;
}
int
-vzDomainJobUpdateTime(vzDomainJobObjPtr job)
+vzDomainJobUpdateTime(struct _vzDomainJobObj *job)
{
unsigned long long now;
virDomainControllerModelSCSI scsiControllerModel;
};
typedef struct _vzCapabilities vzCapabilities;
-typedef struct _vzCapabilities *vzCapabilitiesPtr;
/* +2 to keep enclosing { and } */
#define VIR_UUID_STRING_BRACED_BUFLEN (VIR_UUID_STRING_BUFLEN + 2)
virObjectLockable parent;
/* Immutable pointer, self-locking APIs */
- virDomainObjListPtr domains;
+ virDomainObjList *domains;
unsigned char session_uuid[VIR_UUID_BUFLEN];
PRL_HANDLE server;
- virCapsPtr caps;
- virDomainXMLOptionPtr xmlopt;
- virObjectEventStatePtr domainEventState;
- virSysinfoDefPtr hostsysinfo;
+ virCaps *caps;
+ virDomainXMLOption *xmlopt;
+ virObjectEventState *domainEventState;
+ virSysinfoDef *hostsysinfo;
unsigned long vzVersion;
vzCapabilities vzCaps;
};
typedef struct _vzDriver vzDriver;
-typedef struct _vzDriver *vzDriverPtr;
struct _vzConn {
struct _vzConn* next;
- vzDriverPtr driver;
+ struct _vzDriver *driver;
/* Immutable pointer, self-locking APIs */
- virConnectCloseCallbackDataPtr closeCallback;
+ virConnectCloseCallbackData *closeCallback;
};
typedef struct _vzConn vzConn;
-typedef struct _vzConn *vzConnPtr;
struct _vzDomainJobObj {
virCond cond;
};
typedef struct _vzDomainJobObj vzDomainJobObj;
-typedef struct _vzDomainJobObj *vzDomainJobObjPtr;
struct vzDomObj {
int id;
vzDomainJobObj job;
};
-typedef struct vzDomObj *vzDomObjPtr;
-
void* vzDomObjAlloc(void *opaque);
void vzDomObjFree(void *p);
-virDomainObjPtr vzDomObjFromDomain(virDomainPtr domain);
+virDomainObj *vzDomObjFromDomain(virDomainPtr domain);
char * vzGetOutput(const char *binary, ...)
ATTRIBUTE_NONNULL(1) G_GNUC_NULL_TERMINATED;
-vzDriverPtr
+struct _vzDriver *
vzGetDriverConnection(void);
void
vzDestroyDriverConnection(void);
int
-vzInitVersion(vzDriverPtr driver);
+vzInitVersion(struct _vzDriver *driver);
int
vzCheckUnsupportedDisk(const virDomainDef *def,
- virDomainDiskDefPtr disk,
- vzCapabilitiesPtr vzCaps);
+ virDomainDiskDef *disk,
+ struct _vzCapabilities *vzCaps);
int
vzCheckUnsupportedControllers(const virDomainDef *def,
- vzCapabilitiesPtr vzCaps);
+ struct _vzCapabilities *vzCaps);
int
-vzGetDefaultSCSIModel(vzDriverPtr driver,
+vzGetDefaultSCSIModel(struct _vzDriver *driver,
PRL_CLUSTERED_DEVICE_SUBTYPE *scsiModel);
-int vzCheckUnsupportedGraphics(virDomainGraphicsDefPtr gr);
+int vzCheckUnsupportedGraphics(virDomainGraphicsDef *gr);
#define PARALLELS_BLOCK_STATS_FOREACH(OP) \
OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \
OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total")
int
-vzDomainObjBeginJob(virDomainObjPtr dom);
+vzDomainObjBeginJob(virDomainObj *dom);
void
-vzDomainObjEndJob(virDomainObjPtr dom);
+vzDomainObjEndJob(virDomainObj *dom);
int
-vzDomainJobUpdateTime(vzDomainJobObjPtr job);
+vzDomainJobUpdateTime(struct _vzDomainJobObj *job);
void
virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
- virMacAddrPtr addr)
+ virMacAddr *addr)
{
addr->addr[0] = prefix[0];
addr->addr[1] = prefix[1];
return 0;
}
-virCPUDefPtr
+virCPUDef *
virCPUProbeHost(virArch arch)
{
return testUtilsHostCpusGetDefForArch(arch);
}
void virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
- virMacAddrPtr addr)
+ virMacAddr *addr)
{
addr->addr[0] = prefix[0];
addr->addr[1] = prefix[1];
const virNetDevVPortProfile *virtPortProfile G_GNUC_UNUSED,
const virNetDevVlan *virtVlan G_GNUC_UNUSED,
virTristateBool isolatedPort G_GNUC_UNUSED,
- virNetDevCoalescePtr coalesce G_GNUC_UNUSED,
+ virNetDevCoalesce *coalesce G_GNUC_UNUSED,
unsigned int mtu G_GNUC_UNUSED,
unsigned int *actualMTU G_GNUC_UNUSED,
unsigned int fakeflags G_GNUC_UNUSED)
*/
static int test13(const void *unused G_GNUC_UNUSED)
{
- virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
+ virCommand *cmd = virCommandNew(abs_builddir "/commandhelper");
g_autofree char *outactual = NULL;
const char *outexpect = "BEGIN STDOUT\n"
"Hello World\n"
*/
static int test14(const void *unused G_GNUC_UNUSED)
{
- virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
+ virCommand *cmd = virCommandNew(abs_builddir "/commandhelper");
g_autofree char *outactual = NULL;
const char *outexpect = "BEGIN STDOUT\n"
"Hello World\n"
*/
static int test18(const void *unused G_GNUC_UNUSED)
{
- virCommandPtr cmd = virCommandNewArgList("sleep", "100", NULL);
+ virCommand *cmd = virCommandNewArgList("sleep", "100", NULL);
g_autofree char *pidfile = virPidFileBuildPath(abs_builddir, "commandhelper");
pid_t pid;
int ret = -1;
test22(const void *unused G_GNUC_UNUSED)
{
int ret = -1;
- virCommandPtr cmd;
+ virCommand *cmd;
int status = -1;
cmd = virCommandNewArgList("/bin/sh", "-c", "exit 3", NULL);
virArch arch;
const char *host;
const char *name;
- virDomainCapsCPUModelsPtr models;
+ virDomainCapsCPUModels *models;
const char *modelsName;
unsigned int flags;
int result;
#endif
-static virCPUDefPtr
+static virCPUDef *
cpuTestLoadXML(virArch arch, const char *name)
{
char *xml = NULL;
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
xml = g_strdup_printf("%s/cputestdata/%s-%s.xml", abs_srcdir,
virArchToString(arch), name);
}
-static virCPUDefPtr *
+static virCPUDef **
cpuTestLoadMultiXML(virArch arch,
const char *name,
unsigned int *count)
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr *nodes = NULL;
- virCPUDefPtr *cpus = NULL;
+ virCPUDef **cpus = NULL;
int n;
size_t i;
goto cleanup;
}
- cpus = g_new0(virCPUDefPtr, n);
+ cpus = g_new0(virCPUDef *, n);
for (i = 0; i < n; i++) {
ctxt->node = nodes[i];
{
const struct data *data = arg;
int ret = -1;
- virCPUDefPtr host = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *host = NULL;
+ virCPUDef *cpu = NULL;
virCPUCompareResult result;
if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
{
const struct data *data = arg;
int ret = -2;
- virCPUDefPtr host = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *host = NULL;
+ virCPUDef *cpu = NULL;
virCPUCompareResult cmpResult;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
char *result = NULL;
{
const struct data *data = arg;
int ret = -1;
- virCPUDefPtr *cpus = NULL;
- virCPUDefPtr baseline = NULL;
+ virCPUDef **cpus = NULL;
+ virCPUDef *baseline = NULL;
unsigned int ncpus = 0;
char *result = NULL;
const char *suffix;
{
const struct data *data = arg;
int ret = -1;
- virCPUDefPtr host = NULL;
- virCPUDefPtr migHost = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *host = NULL;
+ virCPUDef *migHost = NULL;
+ virCPUDef *cpu = NULL;
char *result = NULL;
if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
{
const struct data *data = arg;
int ret = -1;
- virCPUDefPtr host = NULL;
- virCPUDataPtr hostData = NULL;
+ virCPUDef *host = NULL;
+ virCPUData *hostData = NULL;
int result;
if (!(host = cpuTestLoadXML(data->arch, data->host)))
} cpuTestCPUIDJson;
#if WITH_QEMU
-static virQEMUCapsPtr
+static virQEMUCaps *
cpuTestMakeQEMUCaps(const struct data *data)
{
- virQEMUCapsPtr qemuCaps = NULL;
- qemuMonitorTestPtr testMon = NULL;
- qemuMonitorCPUModelInfoPtr model = NULL;
- virCPUDefPtr cpu = NULL;
+ virQEMUCaps *qemuCaps = NULL;
+ qemuMonitorTest *testMon = NULL;
+ qemuMonitorCPUModelInfo *model = NULL;
+ virCPUDef *cpu = NULL;
bool fail_no_props = true;
char *json = NULL;
static int
cpuTestGetCPUModels(const struct data *data,
- virDomainCapsCPUModelsPtr *models)
+ virDomainCapsCPUModels **models)
{
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
*models = NULL;
static int
cpuTestGetCPUModels(const struct data *data,
- virDomainCapsCPUModelsPtr *models)
+ virDomainCapsCPUModels **models)
{
*models = NULL;
{
const struct data *data = arg;
int ret = -1;
- virCPUDataPtr hostData = NULL;
+ virCPUData *hostData = NULL;
char *hostFile = NULL;
char *host = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
char *result = NULL;
- virDomainCapsCPUModelsPtr models = NULL;
+ virDomainCapsCPUModels *models = NULL;
hostFile = g_strdup_printf("%s/cputestdata/%s-cpuid-%s.xml", abs_srcdir,
virArchToString(data->arch), data->host);
static int
cpuTestCompareSignature(const struct data *data,
- virCPUDataPtr hostData)
+ virCPUData *hostData)
{
g_autofree char *result = NULL;
g_autofree char *sigStr = NULL;
cpuTestCPUIDSignature(const void *arg)
{
const struct data *data = arg;
- virCPUDataPtr hostData = NULL;
+ virCPUData *hostData = NULL;
char *hostFile = NULL;
char *host = NULL;
int ret = -1;
static int
cpuTestUpdateLiveCompare(virArch arch,
- virCPUDefPtr actual,
- virCPUDefPtr expected)
+ virCPUDef *actual,
+ virCPUDef *expected)
{
size_t i, j;
int ret = 0;
i = j = 0;
while (i < actual->nfeatures || j < expected->nfeatures) {
- virCPUFeatureDefPtr featAct = NULL;
- virCPUFeatureDefPtr featExp = NULL;
+ virCPUFeatureDef *featAct = NULL;
+ virCPUFeatureDef *featExp = NULL;
int cmp;
if (i < actual->nfeatures)
{
const struct data *data = arg;
char *cpuFile = NULL;
- virCPUDefPtr cpu = NULL;
+ virCPUDef *cpu = NULL;
char *enabledFile = NULL;
char *enabled = NULL;
- virCPUDataPtr enabledData = NULL;
+ virCPUData *enabledData = NULL;
char *disabledFile = NULL;
char *disabled = NULL;
- virCPUDataPtr disabledData = NULL;
+ virCPUData *disabledData = NULL;
char *expectedFile = NULL;
- virCPUDefPtr expected = NULL;
- virDomainCapsCPUModelsPtr hvModels = NULL;
- virDomainCapsCPUModelsPtr models = NULL;
+ virCPUDef *expected = NULL;
+ virDomainCapsCPUModels *hvModels = NULL;
+ virDomainCapsCPUModels *models = NULL;
int ret = -1;
cpuFile = g_strdup_printf("cpuid-%s-guest", data->host);
* use the CPU model from 'expected'.
*/
if (STRNEQ(cpu->model, expected->model)) {
- virDomainCapsCPUModelPtr hvModel;
+ virDomainCapsCPUModel *hvModel;
char **blockers = NULL;
virDomainCapsCPUUsable usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;
int rc;
cpuTestJSONCPUID(const void *arg)
{
const struct data *data = arg;
- virQEMUCapsPtr qemuCaps = NULL;
- virCPUDefPtr cpu = NULL;
+ virQEMUCaps *qemuCaps = NULL;
+ virCPUDef *cpu = NULL;
char *result = NULL;
int ret = -1;
cpuTestJSONSignature(const void *arg)
{
const struct data *data = arg;
- virQEMUCapsPtr qemuCaps = NULL;
- virCPUDataPtr hostData = NULL;
- qemuMonitorCPUModelInfoPtr modelInfo;
+ virQEMUCaps *qemuCaps = NULL;
+ virCPUData *hostData = NULL;
+ qemuMonitorCPUModelInfo *modelInfo;
int ret = -1;
if (!(qemuCaps = cpuTestMakeQEMUCaps(data)))
static const char *haswell_list[] = { "SandyBridge", "Haswell", NULL };
static const char *ppc_models_list[] = { "POWER6", "POWER7", "POWER8", NULL };
-static virDomainCapsCPUModelsPtr
+static virDomainCapsCPUModels *
cpuTestInitModels(const char **list)
{
- virDomainCapsCPUModelsPtr cpus;
+ virDomainCapsCPUModels *cpus;
const char **model;
if (!(cpus = virDomainCapsCPUModelsNew(0)))
static int
mymain(void)
{
- virDomainCapsCPUModelsPtr model486 = NULL;
- virDomainCapsCPUModelsPtr nomodel = NULL;
- virDomainCapsCPUModelsPtr models = NULL;
- virDomainCapsCPUModelsPtr haswell = NULL;
- virDomainCapsCPUModelsPtr ppc_models = NULL;
+ virDomainCapsCPUModels *model486 = NULL;
+ virDomainCapsCPUModels *nomodel = NULL;
+ virDomainCapsCPUModels *models = NULL;
+ virDomainCapsCPUModels *haswell = NULL;
+ virDomainCapsCPUModels *ppc_models = NULL;
int ret = 0;
#if WITH_QEMU
#if WITH_QEMU || WITH_BHYVE
static int G_GNUC_NULL_TERMINATED
-fillStringValues(virDomainCapsStringValuesPtr values, ...)
+fillStringValues(virDomainCapsStringValues *values, ...)
{
va_list list;
const char *str;
}
static int
-fillQemuCaps(virDomainCapsPtr domCaps,
+fillQemuCaps(virDomainCaps *domCaps,
const char *name,
const char *arch,
const char *machine,
- virQEMUDriverConfigPtr cfg)
+ virQEMUDriverConfig *cfg)
{
int ret = -1;
char *path = NULL;
- virQEMUCapsPtr qemuCaps = NULL;
- virDomainCapsLoaderPtr loader = &domCaps->os.loader;
+ virQEMUCaps *qemuCaps = NULL;
+ virDomainCapsLoader *loader = &domCaps->os.loader;
virDomainVirtType virtType;
if (fakeHostCPU(domCaps->arch) < 0)
# include "testutilsxen.h"
static int
-fillXenCaps(virDomainCapsPtr domCaps)
+fillXenCaps(virDomainCaps *domCaps)
{
- virFirmwarePtr *firmwares;
+ virFirmware **firmwares;
int ret = -1;
- firmwares = g_new0(virFirmwarePtr, 2);
+ firmwares = g_new0(virFirmware *, 2);
firmwares[0] = g_new0(virFirmware, 1);
firmwares[1] = g_new0(virFirmware, 1);
# include "bhyve/bhyve_capabilities.h"
static int
-fillBhyveCaps(virDomainCapsPtr domCaps, unsigned int *bhyve_caps)
+fillBhyveCaps(virDomainCaps *domCaps, unsigned int *bhyve_caps)
{
- virDomainCapsStringValuesPtr firmwares = NULL;
+ virDomainCapsStringValues *firmwares = NULL;
int ret = -1;
firmwares = g_new0(virDomainCapsStringValues, 1);
test_virDomainCapsFormat(const void *opaque)
{
const struct testData *data = opaque;
- virDomainCapsPtr domCaps = NULL;
+ virDomainCaps *domCaps = NULL;
char *path = NULL;
char *domCapsXML = NULL;
int ret = -1;
VIR_LOG_INIT("tests.domainconftest");
-static virCapsPtr caps;
-static virDomainXMLOptionPtr xmlopt;
+static virCaps *caps;
+static virDomainXMLOption *xmlopt;
struct testGetFilesystemData {
const char *filename;
static int testGetFilesystem(const void *opaque)
{
int ret = -1;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *filename = NULL;
const struct testGetFilesystemData *data = opaque;
- virDomainFSDefPtr fsdef;
+ virDomainFSDef *fsdef;
filename = g_strdup_printf("%s/domainconfdata/%s.xml", abs_srcdir,
data->filename);
#define VIR_FROM_THIS VIR_FROM_NONE
-static virCapsPtr caps;
-static virDomainXMLOptionPtr xmlopt;
+static virCaps *caps;
+static virDomainXMLOption *xmlopt;
struct testInfo {
const char *name;
};
-static virDomainDiskDefPtr
+static virDomainDiskDef *
testCompareBackupXMLGetFakeDomdisk(const char *dst)
{
- virDomainDiskDefPtr domdisk = NULL;
+ virDomainDiskDef *domdisk = NULL;
if (!(domdisk = virDomainDiskDefNew(NULL)))
abort();
return -1;
fakedef->ndisks = backup->ndisks + 1;
- fakedef->disks = g_new0(virDomainDiskDefPtr, fakedef->ndisks);
+ fakedef->disks = g_new0(virDomainDiskDef *, fakedef->ndisks);
for (i = 0; i < backup->ndisks; i++)
fakedef->disks[i] = testCompareBackupXMLGetFakeDomdisk(backup->disks[i].name);
char *xmlData = NULL;
char *actual = NULL;
int ret = -1;
- virInterfaceDefPtr dev = NULL;
+ virInterfaceDef *dev = NULL;
if (virTestLoadFile(xml, &xmlData) < 0)
goto fail;
# define VIR_FROM_THIS VIR_FROM_LIBXL
-static libxlDriverPrivatePtr driver;
+static libxlDriverPrivate *driver;
static int
testCompareXMLToDomConfig(const char *xmlfile,
libxl_domain_config actualconfig;
libxl_domain_config expectconfig;
xentoollog_logger *log = NULL;
- virPortAllocatorRangePtr gports = NULL;
- virDomainDefPtr vmdef = NULL;
+ virPortAllocatorRange *gports = NULL;
+ virDomainDef *vmdef = NULL;
char *actualjson = NULL;
char *tempjson = NULL;
char *expectjson = NULL;
# define VIR_FROM_THIS VIR_FROM_NONE
-static virLXCDriverPtr driver;
+static virLXCDriver *driver;
-static int testSanitizeDef(virDomainDefPtr vmdef)
+static int testSanitizeDef(virDomainDef *vmdef)
{
/* Remove UUID randomness */
if (virUUIDParse("c7a5fdbd-edaf-9455-926a-d65c16db1809", vmdef->uuid) < 0)
int ret = -1;
char *config = NULL;
char *actualxml = NULL;
- virDomainDefPtr vmdef = NULL;
+ virDomainDef *vmdef = NULL;
if (virTestLoadFile(configfile, &config) < 0)
goto fail;
# define VIR_FROM_THIS VIR_FROM_NONE
-static virLXCDriverPtr driver;
+static virLXCDriver *driver;
struct testInfo {
const char *name;
static int
testCompareXMLToConfFiles(const char *inxml, const char *outconf,
- char *outhostsfile, dnsmasqCapsPtr caps)
+ char *outhostsfile, dnsmasqCaps *caps)
{
char *confactual = NULL;
char *hostsfileactual = NULL;
int ret = -1;
- virNetworkDefPtr def = NULL;
- virNetworkObjPtr obj = NULL;
- virCommandPtr cmd = NULL;
+ virNetworkDef *def = NULL;
+ virNetworkObj *obj = NULL;
+ virCommand *cmd = NULL;
char *pidfile = NULL;
dnsmasqContext *dctx = NULL;
- virNetworkXMLOptionPtr xmlopt = NULL;
+ virNetworkXMLOption *xmlopt = NULL;
if (!(xmlopt = networkDnsmasqCreateXMLConf()))
goto fail;
typedef struct {
const char *name;
- dnsmasqCapsPtr caps;
+ dnsmasqCaps *caps;
} testInfo;
static int
mymain(void)
{
int ret = 0;
- dnsmasqCapsPtr restricted
+ dnsmasqCaps *restricted
= dnsmasqCapsNewFromBuffer("Dnsmasq version 2.48", DNSMASQ);
- dnsmasqCapsPtr full
+ dnsmasqCaps *full
= dnsmasqCapsNewFromBuffer("Dnsmasq version 2.63\n--bind-dynamic", DNSMASQ);
- dnsmasqCapsPtr dhcpv6
+ dnsmasqCaps *dhcpv6
= dnsmasqCapsNewFromBuffer("Dnsmasq version 2.64\n--bind-dynamic", DNSMASQ);
#define DO_TEST(xname, xcaps) \
{
char *actualargv = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virNetworkDefPtr def = NULL;
+ virNetworkDef *def = NULL;
int ret = -1;
char *actual;
g_autoptr(virCommandDryRunToken) dryRunToken = virCommandDryRunTokenNew();
char *actual = NULL;
int ret;
testCompareNetXML2XMLResult result = TEST_COMPARE_NET_XML2XML_RESULT_SUCCESS;
- virNetworkDefPtr dev = NULL;
- virNetworkXMLOptionPtr xmlopt = NULL;
+ virNetworkDef *dev = NULL;
+ virNetworkXMLOption *xmlopt = NULL;
if (!(xmlopt = networkDnsmasqCreateXMLConf()))
goto cleanup;
char *updateXmlData = NULL;
char *actual = NULL;
int ret = -1;
- virNetworkDefPtr def = NULL;
+ virNetworkDef *def = NULL;
if (virTestLoadFile(updatexml, &updateXmlData) < 0)
goto error;
const char *jsonfile)
{
g_autoptr(virNodeDeviceDef) def = NULL;
- virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObj *obj = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
const char *actualCmdline = NULL;
int ret = -1;
}
static void
-nodedevTestDriverFree(virNodeDeviceDriverStatePtr drv)
+nodedevTestDriverFree(virNodeDeviceDriverState *drv)
{
if (!drv)
return;
}
/* Add a fake root 'computer' device */
-static virNodeDeviceDefPtr
+static virNodeDeviceDef *
fakeRootDevice(void)
{
- virNodeDeviceDefPtr def = NULL;
+ virNodeDeviceDef *def = NULL;
def = g_new0(virNodeDeviceDef, 1);
def->caps = g_new0(virNodeDevCapsDef, 1);
* devices. For our purposes, it only needs to have a name that matches the
* parent of the mdev, and it needs a PCI address
*/
-static virNodeDeviceDefPtr
+static virNodeDeviceDef *
fakeParentDevice(void)
{
- virNodeDeviceDefPtr def = NULL;
- virNodeDevCapPCIDevPtr pci_dev;
+ virNodeDeviceDef *def = NULL;
+ virNodeDevCapPCIDev *pci_dev;
def = g_new0(virNodeDeviceDef, 1);
def->caps = g_new0(virNodeDevCapsDef, 1);
}
static int
-addDevice(virNodeDeviceDefPtr def)
+addDevice(virNodeDeviceDef *def)
{
- virNodeDeviceObjPtr obj;
+ virNodeDeviceObj *obj;
if (!def)
return -1;
char *xmlData = NULL;
char *actual = NULL;
int ret = -1;
- virNodeDeviceDefPtr dev = NULL;
- virNodeDevCapsDefPtr caps;
+ virNodeDeviceDef *dev = NULL;
+ virNodeDevCapsDef *caps;
if (virTestLoadFile(xml, &xmlData) < 0)
goto fail;
/* Calculate some things that are not read in */
for (caps = dev->caps; caps; caps = caps->next) {
- virNodeDevCapDataPtr data = &caps->data;
+ virNodeDevCapData *data = &caps->data;
if (caps->data.type == VIR_NODE_DEV_CAP_STORAGE) {
if (data->storage.flags & VIR_NODE_DEV_CAP_STORAGE_REMOVABLE) {
# endif
typedef struct _virNWFilterInst virNWFilterInst;
-typedef virNWFilterInst *virNWFilterInstPtr;
struct _virNWFilterInst {
- virNWFilterDefPtr *filters;
+ virNWFilterDef **filters;
size_t nfilters;
- virNWFilterRuleInstPtr *rules;
+ virNWFilterRuleInst **rules;
size_t nrules;
};
static void
-virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst)
+virNWFilterRuleInstFree(virNWFilterRuleInst *inst)
{
if (!inst)
return;
static void
-virNWFilterInstReset(virNWFilterInstPtr inst)
+virNWFilterInstReset(virNWFilterInst *inst)
{
size_t i;
static int
virNWFilterDefToInst(const char *xml,
GHashTable *vars,
- virNWFilterInstPtr inst);
+ virNWFilterInst *inst);
static int
-virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
- virNWFilterRuleDefPtr rule,
+virNWFilterRuleDefToRuleInst(virNWFilterDef *def,
+ virNWFilterRuleDef *rule,
GHashTable *vars,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
- virNWFilterRuleInstPtr ruleinst;
+ virNWFilterRuleInst *ruleinst;
int ret = -1;
ruleinst = g_new0(virNWFilterRuleInst, 1);
static int
-virNWFilterIncludeDefToRuleInst(virNWFilterIncludeDefPtr inc,
+virNWFilterIncludeDefToRuleInst(virNWFilterIncludeDef *inc,
GHashTable *vars,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
GHashTable *tmpvars = NULL;
int ret = -1;
static int
virNWFilterDefToInst(const char *xml,
GHashTable *vars,
- virNWFilterInstPtr inst)
+ virNWFilterInst *inst)
{
size_t i;
int ret = -1;
- virNWFilterDefPtr def = virNWFilterDefParseFile(xml);
+ virNWFilterDef *def = virNWFilterDefParseFile(xml);
if (!def)
return -1;
const char *name,
const char *value)
{
- virNWFilterVarValuePtr val;
+ virNWFilterVarValue *val;
if ((val = virHashLookup(vars, name)) == NULL) {
val = virNWFilterVarValueCreateSimpleCopyValue(value);
{
char *actual = NULL;
int ret = -1;
- virNWFilterDefPtr dev = NULL;
+ virNWFilterDef *dev = NULL;
virResetLastError();
testReadNetworkConf(const void *data G_GNUC_UNUSED)
{
int result = -1;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *actual = NULL;
const char *expected =
"<domain type='openvz'>\n"
static int
testQemuAgentSSHKeys(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
char **keys = NULL;
int nkeys = 0;
int ret = -1;
static int
testQemuAgentFSFreeze(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
const char *mountpoints[] = {"/fs1", "/fs2", "/fs3", "/fs4", "/fs5"};
int ret = -1;
static int
testQemuAgentFSThaw(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
if (!test)
static int
testQemuAgentFSTrim(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
if (!test)
static int
-testQemuAgentGetFSInfoCommon(virDomainXMLOptionPtr xmlopt,
- qemuMonitorTestPtr *test,
- virDomainDefPtr *def)
+testQemuAgentGetFSInfoCommon(virDomainXMLOption *xmlopt,
+ qemuMonitorTest **test,
+ virDomainDef **def)
{
int ret = -1;
g_autofree char *domain_filename = NULL;
- qemuMonitorTestPtr ret_test = NULL;
+ qemuMonitorTest *ret_test = NULL;
g_autoptr(virDomainDef) ret_def = NULL;
if (!test || !def)
static int
testQemuAgentGetFSInfo(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = NULL;
- virDomainDefPtr def = NULL;
- qemuAgentFSInfoPtr *info = NULL;
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = NULL;
+ virDomainDef *def = NULL;
+ qemuAgentFSInfo **info = NULL;
int ret = -1, ninfo = 0, i;
if (testQemuAgentGetFSInfoCommon(xmlopt, &test, &def) < 0)
static int
testQemuAgentSuspend(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
size_t i;
static int
-qemuAgentShutdownTestMonitorHandler(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+qemuAgentShutdownTestMonitorHandler(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *cmdstr)
{
struct qemuAgentShutdownTestData *data;
g_autoptr(virJSONValue) val = NULL;
- virJSONValuePtr args;
+ virJSONValue *args;
const char *cmdname;
const char *mode;
int ret = -1;
static int
testQemuAgentShutdown(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
struct qemuAgentShutdownTestData priv;
int ret = -1;
static int
testQemuAgentCPU(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
- qemuAgentCPUInfoPtr cpuinfo = NULL;
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
+ qemuAgentCPUInfo *cpuinfo = NULL;
int nvcpus;
int ret = -1;
static int
testQemuAgentArbitraryCommand(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
g_autofree char *reply = NULL;
static int
-qemuAgentTimeoutTestMonitorHandler(qemuMonitorTestPtr test G_GNUC_UNUSED,
- qemuMonitorTestItemPtr item G_GNUC_UNUSED,
+qemuAgentTimeoutTestMonitorHandler(qemuMonitorTest *test G_GNUC_UNUSED,
+ qemuMonitorTestItem *item G_GNUC_UNUSED,
const char *cmdstr G_GNUC_UNUSED)
{
return 0;
static int
testQemuAgentTimeout(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
g_autofree char *reply = NULL;
int ret = -1;
static int
testQemuAgentGetInterfaces(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
size_t i;
int ret = -1;
int ifaces_count = 0;
static int
testQemuAgentGetDisks(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
size_t i;
int ret = -1;
int disks_count = 0;
- qemuAgentDiskInfoPtr *disks = NULL;
+ qemuAgentDiskInfo **disks = NULL;
if (!test)
return -1;
static int
testQemuAgentUsers(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
virTypedParameterPtr params = NULL;
int nparams = 0;
int maxparams = 0;
static int
testQemuAgentOSInfo(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
virTypedParameterPtr params = NULL;
int nparams = 0;
int maxparams = 0;
static int
testQemuAgentTimezone(const void *data)
{
- virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
+ virDomainXMLOption *xmlopt = (virDomainXMLOption *)data;
+ qemuMonitorTest *test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
if (!test)
const char *xml;
bool legacy;
GHashTable *schema;
- virJSONValuePtr schemaroot;
+ virJSONValue *schemaroot;
};
static int
struct testJSONtoJSONData {
const char *name;
GHashTable *schema;
- virJSONValuePtr schemaroot;
+ virJSONValue *schemaroot;
};
static int
struct testQemuDiskXMLToJSONImageData {
- virJSONValuePtr formatprops;
- virJSONValuePtr storageprops;
- virJSONValuePtr storagepropssrc;
+ virJSONValue *formatprops;
+ virJSONValue *storageprops;
+ virJSONValue *storagepropssrc;
char *backingstore;
};
struct testQemuDiskXMLToJSONData {
- virQEMUDriverPtr driver;
+ virQEMUDriver *driver;
GHashTable *schema;
- virJSONValuePtr schemaroot;
+ virJSONValue *schemaroot;
const char *name;
bool fail;
struct testQemuDiskXMLToJSONImageData *images;
size_t nimages;
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
};
static int
-testQemuDiskXMLToJSONFakeSecrets(virStorageSourcePtr src)
+testQemuDiskXMLToJSONFakeSecrets(virStorageSource *src)
{
- qemuDomainStorageSourcePrivatePtr srcpriv;
+ qemuDomainStorageSourcePrivate *srcpriv;
if (!src->privateData &&
!(src->privateData = qemuDomainStorageSourcePrivateNew()))
{
struct testQemuDiskXMLToJSONData *data = (void *) opaque;
g_autoptr(virDomainDef) vmdef = NULL;
- virDomainDiskDefPtr disk = NULL;
- virStorageSourcePtr n;
+ virDomainDiskDef *disk = NULL;
+ virStorageSource *n;
g_autoptr(virJSONValue) formatProps = NULL;
g_autoptr(virJSONValue) storageProps = NULL;
g_autoptr(virJSONValue) storageSrcOnlyProps = NULL;
const char *name;
const char *backingname;
GHashTable *schema;
- virJSONValuePtr schemaroot;
- virQEMUDriverPtr driver;
- virQEMUCapsPtr qemuCaps;
+ virJSONValue *schemaroot;
+ virQEMUDriver *driver;
+ virQEMUCaps *qemuCaps;
};
static const char *testQemuImageCreatePath = abs_srcdir "/qemublocktestdata/imagecreate/";
-static virStorageSourcePtr
+static virStorageSource *
testQemuImageCreateLoadDiskXML(const char *name,
- virDomainXMLOptionPtr xmlopt)
+ virDomainXMLOption *xmlopt)
{
- virDomainSnapshotDiskDefPtr diskdef = NULL;
+ virDomainSnapshotDiskDef *diskdef = NULL;
g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr node;
g_autofree char *xmlpath = NULL;
- virStorageSourcePtr ret = NULL;
+ virStorageSource *ret = NULL;
xmlpath = g_strdup_printf("%s%s.xml", testQemuImageCreatePath, name);
static void
testQemuDetectBitmapsWorker(GHashTable *nodedata,
const char *nodename,
- virBufferPtr buf)
+ virBuffer *buf)
{
- qemuBlockNamedNodeDataPtr data;
+ qemuBlockNamedNodeData *data;
size_t i;
if (!(data = virHashLookup(nodedata, nodename)))
virBufferAdjustIndent(buf, 1);
for (i = 0; i < data->nbitmaps; i++) {
- qemuBlockNamedNodeDataBitmapPtr bitmap = data->bitmaps[i];
+ qemuBlockNamedNodeDataBitmap *bitmap = data->bitmaps[i];
virBufferAsprintf(buf, "%8s: record:%d busy:%d persist:%d inconsist:%d gran:%llu dirty:%llu\n",
bitmap->name, bitmap->recording, bitmap->busy,
static void
testQemuBitmapListPrint(const char *title,
GSList *next,
- virBufferPtr buf)
+ virBuffer *buf)
{
if (!next)
return;
virBufferAsprintf(buf, "%s\n", title);
for (; next; next = next->next) {
- virStorageSourcePtr src = next->data;
+ virStorageSource *src = next->data;
virBufferAsprintf(buf, "%s\n", src->nodeformat);
}
}
-static virStorageSourcePtr
+static virStorageSource *
testQemuBackupIncrementalBitmapCalculateGetFakeImage(size_t idx)
{
- virStorageSourcePtr ret = virStorageSourceNew();
+ virStorageSource *ret = virStorageSourceNew();
ret->id = idx;
ret->type = VIR_STORAGE_TYPE_FILE;
}
-static virStorageSourcePtr
+static virStorageSource *
testQemuBackupIncrementalBitmapCalculateGetFakeChain(void)
{
- virStorageSourcePtr ret;
- virStorageSourcePtr n;
+ virStorageSource *ret;
+ virStorageSource *n;
size_t i;
n = ret = testQemuBackupIncrementalBitmapCalculateGetFakeImage(1);
}
-static virStorageSourcePtr
-testQemuBitmapGetFakeChainEntry(virStorageSourcePtr src,
+static virStorageSource *
+testQemuBitmapGetFakeChainEntry(virStorageSource *src,
size_t idx)
{
- virStorageSourcePtr n;
+ virStorageSource *n;
for (n = src; n; n = n->backingStore) {
if (n->id == idx)
struct testQemuBackupIncrementalBitmapCalculateData {
const char *name;
- virStorageSourcePtr chain;
+ virStorageSource *chain;
const char *incremental;
const char *nodedatafile;
};
struct testQemuCheckpointDeleteData {
const char *name;
- virStorageSourcePtr chain;
+ virStorageSource *chain;
const char *deletebitmap;
const char *nodedatafile;
};
struct testQemuBlockBitmapValidateData {
const char *name;
const char *bitmapname;
- virStorageSourcePtr chain;
+ virStorageSource *chain;
bool expect;
};
struct testQemuBlockBitmapBlockcopyData {
const char *name;
bool shallow;
- virStorageSourcePtr chain;
+ virStorageSource *chain;
const char *nodedatafile;
};
struct testQemuBlockBitmapBlockcommitData {
const char *name;
- virStorageSourcePtr top;
- virStorageSourcePtr base;
- virStorageSourcePtr chain;
+ virStorageSource *top;
+ virStorageSource *base;
+ virStorageSource *chain;
const char *nodedatafile;
};
char *capslatest_x86_64 = NULL;
g_autoptr(virQEMUCaps) caps_x86_64 = NULL;
g_autoptr(GHashTable) qmp_schema_x86_64 = NULL;
- virJSONValuePtr qmp_schemaroot_x86_64_blockdev_add = NULL;
+ virJSONValue *qmp_schemaroot_x86_64_blockdev_add = NULL;
g_autoptr(virStorageSource) bitmapSourceChain = NULL;
if (qemuTestDriverInit(&driver) < 0)
#define VIR_FROM_THIS VIR_FROM_NONE
typedef struct _testQemuData testQemuData;
-typedef testQemuData *testQemuDataPtr;
struct _testQemuData {
virQEMUDriver driver;
const char *inputDir;
static int
-testQemuDataInit(testQemuDataPtr data)
+testQemuDataInit(testQemuData *data)
{
if (qemuTestDriverInit(&data->driver) < 0)
return -1;
static void
-testQemuDataReset(testQemuDataPtr data)
+testQemuDataReset(testQemuData *data)
{
qemuTestDriverFree(&data->driver);
}
testQemuData *data = (void *) opaque;
g_autofree char *repliesFile = NULL;
g_autofree char *capsFile = NULL;
- qemuMonitorTestPtr mon = NULL;
+ qemuMonitorTest *mon = NULL;
g_autoptr(virQEMUCaps) capsActual = NULL;
g_autofree char *binary = NULL;
g_autofree char *actual = NULL;
const char *suffix,
void *opaque)
{
- testQemuDataPtr data = (testQemuDataPtr) opaque;
+ testQemuData *data = (testQemuData *) opaque;
g_autofree char *title = NULL;
g_autofree char *copyTitle = NULL;
typedef struct _testQemuData testQemuData;
-typedef testQemuData *testQemuDataPtr;
struct _testQemuData {
const char *inputDir;
const char *outputDir;
};
static int
-testQemuDataInit(testQemuDataPtr data)
+testQemuDataInit(testQemuData *data)
{
data->outputDir = abs_srcdir "/qemucaps2xmloutdata";
return 0;
}
-static virQEMUCapsPtr
+static virQEMUCaps *
testQemuGetCaps(char *caps)
{
- virQEMUCapsPtr qemuCaps = NULL;
+ virQEMUCaps *qemuCaps = NULL;
xmlDocPtr xml;
xmlXPathContextPtr ctxt = NULL;
ssize_t i, n;
return NULL;
}
-static virCapsPtr
+static virCaps *
testGetCaps(char *capsData, const testQemuData *data)
{
g_autoptr(virQEMUCaps) qemuCaps = NULL;
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
virArch arch = virArchFromString(data->archName);
g_autofree char *binary = NULL;
const char *suffix,
void *opaque)
{
- testQemuDataPtr data = (testQemuDataPtr) opaque;
+ testQemuData *data = (testQemuData *) opaque;
g_autofree char *title = NULL;
title = g_strdup_printf("%s (%s)", version, archName);
main(int argc, char **argv)
{
virThread thread;
- virQEMUCapsPtr caps;
+ virQEMUCaps *caps;
virArch host;
virArch guest;
const char *mock = VIR_TEST_MOCK("qemucapsprobe");
}
-static int (*realQemuMonitorSend)(qemuMonitorPtr mon,
- qemuMonitorMessagePtr msg);
+static int (*realQemuMonitorSend)(qemuMonitor *mon,
+ qemuMonitorMessage *msg);
int
-qemuMonitorSend(qemuMonitorPtr mon,
- qemuMonitorMessagePtr msg)
+qemuMonitorSend(qemuMonitor *mon,
+ qemuMonitorMessage *msg)
{
char *reformatted;
}
-static int (*realQemuMonitorJSONIOProcessLine)(qemuMonitorPtr mon,
+static int (*realQemuMonitorJSONIOProcessLine)(qemuMonitor *mon,
const char *line,
- qemuMonitorMessagePtr msg);
+ qemuMonitorMessage *msg);
int
-qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon,
+qemuMonitorJSONIOProcessLine(qemuMonitor *mon,
const char *line,
- qemuMonitorMessagePtr msg)
+ qemuMonitorMessage *msg)
{
- virJSONValuePtr value = NULL;
+ virJSONValue *value = NULL;
char *json = NULL;
int ret;
testQemuCommandBuildFromJSON(const void *opaque)
{
const testQemuCommandBuildObjectFromJSONData *data = opaque;
- virJSONValuePtr val = NULL;
+ virJSONValue *val = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
char *result = NULL;
int ret = -1;
#include "virarch.h"
-virCPUDefPtr
+virCPUDef *
virQEMUCapsProbeHostCPU(virArch hostArch G_GNUC_UNUSED,
- virDomainCapsCPUModelsPtr models G_GNUC_UNUSED)
+ virDomainCapsCPUModels *models G_GNUC_UNUSED)
{
const char *model = getenv("VIR_TEST_MOCK_FAKE_HOST_CPU");
def->parent.parent_name = g_strdup("1525111885");
}
if (flags & TEST_VDA_BITMAP) {
- virDomainCheckpointDiskDefPtr disk;
+ virDomainCheckpointDiskDef *disk;
VIR_EXPAND_N(def->disks, def->ndisks, 1);
disk = &def->disks[0];
static long long mocktime;
static int
-testCheckpointPostParse(virDomainMomentDefPtr def)
+testCheckpointPostParse(virDomainMomentDef *def)
{
if (!mocktime)
return 0;
static long long mocktime;
static int
-testSnapshotPostParse(virDomainMomentDefPtr def)
+testSnapshotPostParse(virDomainMomentDef *def)
{
if (!mocktime)
return 0;
uint64_t actualInterfaces;
uint64_t expectedInterfaces = 0;
bool actualSecure;
- virFirmwarePtr *expFWs = NULL;
+ virFirmware **expFWs = NULL;
size_t nexpFWs = 0;
- virFirmwarePtr *actFWs = NULL;
+ virFirmware **actFWs = NULL;
size_t nactFWs = 0;
size_t i;
int ret = -1;
* Well, some images don't have a NVRAM store. In that case NULL was passed:
* ${FW}:NULL. Now iterate over expected firmwares and fix this. */
for (i = 0; i < nexpFWs; i++) {
- virFirmwarePtr tmp = expFWs[i];
+ virFirmware *tmp = expFWs[i];
if (STREQ(tmp->nvram, "NULL"))
VIR_FREE(tmp->nvram);
}
for (i = 0; i < nactFWs; i++) {
- virFirmwarePtr actFW = actFWs[i];
- virFirmwarePtr expFW = NULL;
+ virFirmware *actFW = actFWs[i];
+ virFirmware *expFW = NULL;
if (i >= nexpFWs) {
fprintf(stderr, "Unexpected FW image: %s NVRAM: %s\n",
}
unsigned long long
-qemuDomainGetUnplugTimeout(virDomainObjPtr vm)
+qemuDomainGetUnplugTimeout(virDomainObj *vm)
{
/* Wait only 100ms for DEVICE_DELETED event. Give a greater
* timeout in case of PSeries guest to be consistent with the
int
-qemuProcessStartManagedPRDaemon(virDomainObjPtr vm G_GNUC_UNUSED)
+qemuProcessStartManagedPRDaemon(virDomainObj *vm G_GNUC_UNUSED)
{
return 0;
}
void
-qemuProcessKillManagedPRDaemon(virDomainObjPtr vm G_GNUC_UNUSED)
+qemuProcessKillManagedPRDaemon(virDomainObj *vm G_GNUC_UNUSED)
{
}
int
-qemuInterfaceVDPAConnect(virDomainNetDefPtr net G_GNUC_UNUSED)
+qemuInterfaceVDPAConnect(virDomainNetDef *net G_GNUC_UNUSED)
{
/* need a valid fd or sendmsg won't work. Just open /dev/null */
return open("/dev/null", O_RDONLY);
const char *const *mon;
int action;
bool keep;
- virDomainObjPtr vm;
+ virDomainObj *vm;
bool deviceDeletedEvent;
};
static int
-qemuHotplugCreateObjects(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr *vm,
+qemuHotplugCreateObjects(virDomainXMLOption *xmlopt,
+ virDomainObj **vm,
const char *domxml)
{
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
const unsigned int parseFlags = 0;
if (!(*vm = virDomainObjNew(xmlopt)))
}
static int
-testQemuHotplugAttach(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+testQemuHotplugAttach(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int ret = -1;
}
static int
-testQemuHotplugDetach(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev,
+testQemuHotplugDetach(virDomainObj *vm,
+ virDomainDeviceDef *dev,
bool async)
{
int ret = -1;
}
static int
-testQemuHotplugUpdate(virDomainObjPtr vm,
- virDomainDeviceDefPtr dev)
+testQemuHotplugUpdate(virDomainObj *vm,
+ virDomainDeviceDef *dev)
{
int ret = -1;
}
static int
-testQemuHotplugCheckResult(virDomainObjPtr vm,
+testQemuHotplugCheckResult(virDomainObj *vm,
const char *expected,
const char *expectedFile,
bool fail)
bool fail = test->fail;
bool keep = test->keep;
unsigned int device_parse_flags = 0;
- virDomainObjPtr vm = NULL;
- virDomainDeviceDefPtr dev = NULL;
+ virDomainObj *vm = NULL;
+ virDomainDeviceDef *dev = NULL;
g_autoptr(virCaps) caps = NULL;
- qemuMonitorTestPtr test_mon = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuMonitorTest *test_mon = NULL;
+ qemuDomainObjPrivate *priv = NULL;
domain_filename = g_strdup_printf("%s/qemuhotplugtestdomains/qemuhotplug-%s.xml",
abs_srcdir, test->domain_filename);
char *xml_dom;
- virDomainObjPtr vm;
- qemuMonitorTestPtr mon;
+ virDomainObj *vm;
+ qemuMonitorTest *mon;
bool modern;
};
static void
testQemuHotplugCpuDataFree(struct testQemuHotplugCpuData *data)
{
- qemuDomainObjPrivatePtr priv;
- qemuMonitorPtr mon;
+ qemuDomainObjPrivate *priv;
+ qemuMonitor *mon;
if (!data)
return;
bool fail,
GHashTable *qmpschema)
{
- qemuDomainObjPrivatePtr priv = NULL;
- virCapsPtr caps = NULL;
+ qemuDomainObjPrivate *priv = NULL;
+ virCaps *caps = NULL;
g_autofree char *prefix = NULL;
struct testQemuHotplugCpuData *data = NULL;
typedef struct _qemuMigParamsData qemuMigParamsData;
struct _qemuMigParamsData {
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
const char *name;
GHashTable *qmpschema;
};
static void
-qemuMigParamsTestFormatXML(virBufferPtr buf,
- qemuMigrationParamsPtr migParams)
+qemuMigParamsTestFormatXML(virBuffer *buf,
+ qemuMigrationParams *migParams)
{
virBufferAddLit(buf, "<test>\n");
virBufferAdjustIndent(buf, 2);
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autofree char *replyFile = NULL;
g_autofree char *xmlFile = NULL;
- qemuMonitorTestPtr mon = NULL;
+ qemuMonitorTest *mon = NULL;
g_autoptr(virJSONValue) params = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
g_autofree char *actualXML = NULL;
const qemuMigParamsData *data = opaque;
g_autofree char *replyFile = NULL;
g_autofree char *jsonFile = NULL;
- qemuMonitorTestPtr mon = NULL;
+ qemuMonitorTest *mon = NULL;
g_autoptr(virJSONValue) paramsIn = NULL;
g_autoptr(virJSONValue) paramsOut = NULL;
g_autoptr(qemuMigrationParams) migParams = NULL;
struct testQemuMigrationCookieData {
const char *name;
char *inStatus;
- virDomainObjPtr vm;
+ virDomainObj *vm;
unsigned int cookiePopulateFlags;
unsigned int cookieParseFlags;
qemuMigrationParty cookiePopulateParty;
- qemuMigrationCookiePtr cookie;
+ qemuMigrationCookie *cookie;
char *xmlstr;
int xmlstrlen;
testQemuMigrationCookieParse(const void *opaque)
{
struct testQemuMigrationCookieData *data = (struct testQemuMigrationCookieData *) opaque;
- qemuDomainObjPrivatePtr priv = data->vm->privateData;
+ qemuDomainObjPrivate *priv = data->vm->privateData;
g_auto(virBuffer) actual = VIR_BUFFER_INITIALIZER;
if (!(data->cookie = qemuMigrationCookieParse(&driver,
return -1;
for (next = data->cookie->blockDirtyBitmaps; next; next = next->next) {
- qemuMigrationBlockDirtyBitmapsDiskPtr disk = next->data;
- qemuMigrationBlockDirtyBitmapsDiskBitmapPtr bitmap = disk->bitmaps->data;
+ qemuMigrationBlockDirtyBitmapsDisk *disk = next->data;
+ qemuMigrationBlockDirtyBitmapsDiskBitmap *bitmap = disk->bitmaps->data;
bitmap->persistent = VIR_TRISTATE_BOOL_YES;
}
#define VIR_FROM_THIS VIR_FROM_NONE
typedef struct _testQemuMonitorJSONSimpleFuncData testQemuMonitorJSONSimpleFuncData;
-typedef testQemuMonitorJSONSimpleFuncData *testQemuMonitorJSONSimpleFuncDataPtr;
struct _testQemuMonitorJSONSimpleFuncData {
const char *cmd;
- int (* func) (qemuMonitorPtr mon);
- virDomainXMLOptionPtr xmlopt;
+ int (* func) (qemuMonitor *mon);
+ virDomainXMLOption *xmlopt;
const char *reply;
GHashTable *schema;
bool allowDeprecated;
typedef struct _testGenericData testGenericData;
struct _testGenericData {
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
GHashTable *schema;
};
testQemuMonitorJSONGetStatus(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
bool running = false;
virDomainPausedReason reason = 0;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONGetVersion(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
int major;
int minor;
testQemuMonitorJSONGetMachines(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
- qemuMonitorMachineInfoPtr *info;
+ qemuMonitorMachineInfo **info;
int ninfo = 0;
const char *null = NULL;
size_t i;
testQemuMonitorJSONGetCPUDefinitions(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
g_autoptr(qemuMonitorCPUDefs) defs = NULL;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONGetCommands(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
char **commands = NULL;
int ncommands = 0;
testQemuMonitorJSONGetTPMModels(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
char **tpmmodels = NULL;
int ntpmmodels = 0;
struct qemuMonitorJSONTestAttachChardevData {
- qemuMonitorTestPtr test;
- virDomainChrSourceDefPtr chr;
+ qemuMonitorTest *test;
+ virDomainChrSourceDef *chr;
const char *expectPty;
bool fail;
};
static int
-qemuMonitorJSONTestAttachOneChardev(virDomainXMLOptionPtr xmlopt,
+qemuMonitorJSONTestAttachOneChardev(virDomainXMLOption *xmlopt,
GHashTable *schema,
const char *label,
- virDomainChrSourceDefPtr chr,
+ virDomainChrSourceDef *chr,
const char *expectargs,
const char *reply,
const char *expectPty,
}
static int
-qemuMonitorJSONTestAttachChardev(virDomainXMLOptionPtr xmlopt,
+qemuMonitorJSONTestAttachChardev(virDomainXMLOption *xmlopt,
GHashTable *schema)
{
virDomainChrSourceDef chr;
testQemuMonitorJSONDetachChardev(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
g_autoptr(qemuMonitorTest) test = NULL;
if (!(test = qemuMonitorTestNewSchema(xmlopt, data->schema)))
testQemuMonitorJSONGetListPaths(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
- qemuMonitorJSONListPathPtr *paths;
+ qemuMonitorJSONListPath **paths;
int npaths = 0;
size_t i;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONGetObjectProperty(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
qemuMonitorJSONObjectProperty prop;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONSetObjectProperty(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
qemuMonitorJSONObjectProperty prop;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONGetDeviceAliases(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
char **aliases = NULL;
const char **alias;
testQemuMonitorJSONCPU(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
bool running = false;
virDomainPausedReason reason = 0;
g_autoptr(qemuMonitorTest) test = NULL;
static int
testQemuMonitorJSONSimpleFunc(const void *opaque)
{
- testQemuMonitorJSONSimpleFuncDataPtr data =
- (testQemuMonitorJSONSimpleFuncDataPtr) opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ testQemuMonitorJSONSimpleFuncData *data =
+ (testQemuMonitorJSONSimpleFuncData *) opaque;
+ virDomainXMLOption *xmlopt = data->xmlopt;
const char *reply = data->reply;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSON ## funcName(const void *opaque) \
{ \
const testQemuMonitorJSONSimpleFuncData *data = opaque; \
- virDomainXMLOptionPtr xmlopt = data->xmlopt; \
+ virDomainXMLOption *xmlopt = data->xmlopt; \
const char *reply = data->reply; \
g_autoptr(qemuMonitorTest) test = NULL; \
\
testQemuMonitorJSONqemuMonitorJSONNBDServerStart(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
virStorageNetHostDef server_tcp = {
.name = (char *)"localhost",
.port = 12345,
static int
-testQEMUMonitorJSONqemuMonitorJSONQueryCPUsHelper(qemuMonitorTestPtr test,
+testQEMUMonitorJSONqemuMonitorJSONQueryCPUsHelper(qemuMonitorTest *test,
struct qemuMonitorQueryCpusEntry *expect,
bool fast,
size_t num)
testQemuMonitorJSONqemuMonitorJSONQueryCPUs(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
struct qemuMonitorQueryCpusEntry expect_slow[] = {
{0, 17622, (char *) "/machine/unattached/device[0]", true},
{1, 17624, (char *) "/machine/unattached/device[1]", true},
testQemuMonitorJSONqemuMonitorJSONQueryCPUsFast(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
struct qemuMonitorQueryCpusEntry expect_fast[] = {
{0, 17629, (char *) "/machine/unattached/device[0]", false},
{1, 17630, (char *) "/machine/unattached/device[1]", false},
testQemuMonitorJSONqemuMonitorJSONGetBalloonInfo(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
unsigned long long currmem;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONGetBlockInfo(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
GHashTable *blockDevices = NULL;
GHashTable *expectedBlockDevices = NULL;
testQemuMonitorJSONqemuMonitorJSONGetAllBlockStatsInfo(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
GHashTable *blockstats = NULL;
- qemuBlockStatsPtr stats;
+ qemuBlockStats *stats;
int ret = -1;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONGetMigrationCacheSize(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
unsigned long long cacheSize;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONGetMigrationStats(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
qemuMonitorMigrationStats stats, expectedStats;
char *error = NULL;
testQemuMonitorJSONqemuMonitorJSONGetChardevInfo(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
GHashTable *info = NULL;
GHashTable *expectedInfo = NULL;
testQemuMonitorJSONqemuMonitorJSONSetBlockIoThrottle(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int ret = -1;
virDomainBlockIoTuneInfo info, expectedInfo;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONGetTargetArch(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
g_autofree char *arch = NULL;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONGetMigrationCapabilities(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
const char *cap;
g_auto(GStrv) caps = NULL;
g_autoptr(virBitmap) bitmap = NULL;
testQemuMonitorJSONqemuMonitorJSONSendKey(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
unsigned int keycodes[] = {43, 26, 46, 32};
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorJSONSendKeyHoldtime(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
unsigned int keycodes[] = {43, 26, 46, 32};
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONqemuMonitorSupportsActiveCommit(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
const char *error1 =
"{"
" \"error\": {"
testQemuMonitorJSONqemuMonitorJSONGetDumpGuestMemoryCapability(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
+ virDomainXMLOption *xmlopt = data->xmlopt;
int cap;
const char *reply =
"{"
struct testCPUData {
const char *name;
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
GHashTable *schema;
};
testQemuMonitorJSONGetCPUData(const void *opaque)
{
const struct testCPUData *data = opaque;
- virCPUDataPtr cpuData = NULL;
+ virCPUData *cpuData = NULL;
char *jsonFile = NULL;
char *dataFile = NULL;
char *jsonStr = NULL;
testQemuMonitorJSONGetNonExistingCPUData(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
- virCPUDataPtr cpuData = NULL;
+ virDomainXMLOption *xmlopt = data->xmlopt;
+ virCPUData *cpuData = NULL;
int rv, ret = -1;
g_autoptr(qemuMonitorTest) test = NULL;
testQemuMonitorJSONGetIOThreads(const void *opaque)
{
const testGenericData *data = opaque;
- virDomainXMLOptionPtr xmlopt = data->xmlopt;
- qemuMonitorIOThreadInfoPtr *info;
+ virDomainXMLOption *xmlopt = data->xmlopt;
+ qemuMonitorIOThreadInfo **info;
int ninfo = 0;
int ret = -1;
size_t i;
struct testCPUInfoData {
const char *name;
size_t maxvcpus;
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
bool fast;
GHashTable *schema;
};
static char *
-testQemuMonitorCPUInfoFormat(qemuMonitorCPUInfoPtr vcpus,
+testQemuMonitorCPUInfoFormat(qemuMonitorCPUInfo *vcpus,
size_t nvcpus)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- qemuMonitorCPUInfoPtr vcpu;
+ qemuMonitorCPUInfo *vcpu;
size_t i;
for (i = 0; i < nvcpus; i++) {
testQemuMonitorCPUInfo(const void *opaque)
{
const struct testCPUInfoData *data = opaque;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
char *queryCpusFile = NULL;
char *queryHotpluggableFile = NULL;
char *dataFile = NULL;
char *queryHotpluggableStr = NULL;
char *actual = NULL;
const char *queryCpusFunction;
- qemuMonitorCPUInfoPtr vcpus = NULL;
+ qemuMonitorCPUInfo *vcpus = NULL;
int rc;
int ret = -1;
g_autoptr(qemuMonitorTest) test = NULL;
const char *name,
void *opaque)
{
- qemuBlockNodeNameBackingChainDataPtr entry = payload;
+ qemuBlockNodeNameBackingChainData *entry = payload;
const char *diskalias = name;
- virBufferPtr buf = opaque;
+ virBuffer *buf = opaque;
virBufferSetIndent(buf, 0);
const char *pathprefix = "qemumonitorjsondata/qemumonitorjson-nodename-";
char *resultFile = NULL;
char *actual = NULL;
- virJSONValuePtr namedNodesJson = NULL;
- virJSONValuePtr blockstatsJson = NULL;
+ virJSONValue *namedNodesJson = NULL;
+ virJSONValue *blockstatsJson = NULL;
GHashTable *nodedata = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int ret = -1;
testQAPISchemaQuery(const void *opaque)
{
const struct testQAPISchemaData *data = opaque;
- virJSONValuePtr replyobj = NULL;
+ virJSONValue *replyobj = NULL;
int rc;
rc = virQEMUQAPISchemaPathGet(data->query, data->schema, &replyobj);
{
const struct testQAPISchemaData *data = opaque;
g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
- virJSONValuePtr schemaroot;
- virJSONValuePtr json = NULL;
+ virJSONValue *schemaroot;
+ virJSONValue *json = NULL;
int ret = -1;
if (virQEMUQAPISchemaPathGet(data->query, data->schema, &schemaroot) < 0)
testQAPISchemaObjectDeviceAdd(const void *opaque)
{
GHashTable *schema = (GHashTable *) opaque;
- virJSONValuePtr entry;
+ virJSONValue *entry;
if (virQEMUQAPISchemaPathGet("device_add/arg-type", schema, &entry) < 0) {
fprintf(stderr, "schema for 'device_add' not found\n");
static void
-testQueryJobsPrintJob(virBufferPtr buf,
- qemuMonitorJobInfoPtr job)
+testQueryJobsPrintJob(virBuffer *buf,
+ qemuMonitorJobInfo *job)
{
virBufferAddLit(buf, "[job]\n");
virBufferAsprintf(buf, "id=%s\n", NULLSTR(job->id));
struct testQueryJobsData {
const char *name;
- virDomainXMLOptionPtr xmlopt;
+ virDomainXMLOption *xmlopt;
};
testQueryJobs(const void *opaque)
{
const struct testQueryJobsData *data = opaque;
- qemuMonitorTestPtr test = qemuMonitorTestNewSimple(data->xmlopt);
+ qemuMonitorTest *test = qemuMonitorTestNewSimple(data->xmlopt);
g_autofree char *filenameJSON = NULL;
g_autofree char *fileJSON = NULL;
g_autofree char *filenameResult = NULL;
g_autofree char *actual = NULL;
- qemuMonitorJobInfoPtr *jobs = NULL;
+ qemuMonitorJobInfo **jobs = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
size_t njobs = 0;
size_t i;
g_autoptr(qemuMonitorTest) test = NULL;
g_autoptr(virCPUDef) cpu_a = virCPUDefNew();
g_autoptr(virCPUDef) cpu_b = virCPUDefNew();
- qemuMonitorCPUModelInfoPtr baseline = NULL;
+ qemuMonitorCPUModelInfo *baseline = NULL;
int ret = -1;
if (!(test = qemuMonitorTestNewSchema(data->xmlopt, data->schema)))
virQEMUDriver driver;
testQemuMonitorJSONSimpleFuncData simpleFunc;
struct testQAPISchemaData qapiData;
- virJSONValuePtr metaschema = NULL;
+ virJSONValue *metaschema = NULL;
char *metaschemastr = NULL;
if (qemuTestDriverInit(&driver) < 0)
size_t outgoingLength;
size_t outgoingCapacity;
- virNetSocketPtr server;
- virNetSocketPtr client;
+ virNetSocket *server;
+ virNetSocket *client;
virEventThread *eventThread;
- qemuMonitorPtr mon;
- qemuAgentPtr agent;
+ qemuMonitor *mon;
+ qemuAgent *agent;
char *tmpdir;
size_t nitems;
- qemuMonitorTestItemPtr *items;
+ qemuMonitorTestItem **items;
- virDomainObjPtr vm;
+ virDomainObj *vm;
GHashTable *qapischema;
};
static void
-qemuMonitorTestItemFree(qemuMonitorTestItemPtr item)
+qemuMonitorTestItemFree(qemuMonitorTestItem *item)
{
if (!item)
return;
* Appends data for a reply to the outgoing buffer
*/
int
-qemuMonitorTestAddResponse(qemuMonitorTestPtr test,
+qemuMonitorTestAddResponse(qemuMonitorTest *test,
const char *response)
{
size_t want = strlen(response) + 2;
static int
-qemuMonitorTestAddErrorResponseInternal(qemuMonitorTestPtr test,
+qemuMonitorTestAddErrorResponseInternal(qemuMonitorTest *test,
const char *usermsg)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int
-qemuMonitorTestAddInvalidCommandResponse(qemuMonitorTestPtr test,
+qemuMonitorTestAddInvalidCommandResponse(qemuMonitorTest *test,
const char *expectedcommand,
const char *actualcommand)
{
int G_GNUC_PRINTF(2, 3)
-qemuMonitorTestAddErrorResponse(qemuMonitorTestPtr test, const char *errmsg, ...)
+qemuMonitorTestAddErrorResponse(qemuMonitorTest *test, const char *errmsg, ...)
{
va_list msgargs;
g_autofree char *msg = NULL;
static int
-qemuMonitorTestProcessCommand(qemuMonitorTestPtr test,
+qemuMonitorTestProcessCommand(qemuMonitorTest *test,
const char *cmdstr)
{
int ret;
if (test->nitems == 0) {
qemuMonitorTestError("unexpected command: '%s'", cmdstr);
} else {
- qemuMonitorTestItemPtr item = test->items[0];
+ qemuMonitorTestItem *item = test->items[0];
ret = (item->cb)(test, item, cmdstr);
qemuMonitorTestItemFree(item);
if (VIR_DELETE_ELEMENT(test->items, 0, test->nitems) < 0)
* Handles read/write of monitor data on the monitor server side
*/
static void
-qemuMonitorTestIO(virNetSocketPtr sock,
+qemuMonitorTestIO(virNetSocket *sock,
int events,
void *opaque)
{
- qemuMonitorTestPtr test = opaque;
+ qemuMonitorTest *test = opaque;
bool err = false;
virMutexLock(&test->lock);
static void
qemuMonitorTestWorker(void *opaque)
{
- qemuMonitorTestPtr test = opaque;
+ qemuMonitorTest *test = opaque;
virMutexLock(&test->lock);
void
-qemuMonitorTestFree(qemuMonitorTestPtr test)
+qemuMonitorTestFree(qemuMonitorTest *test)
{
size_t i;
int timer = -1;
int
-qemuMonitorTestAddHandler(qemuMonitorTestPtr test,
+qemuMonitorTestAddHandler(qemuMonitorTest *test,
const char *identifier,
qemuMonitorTestResponseCallback cb,
void *opaque,
virFreeCallback freecb)
{
- qemuMonitorTestItemPtr item;
+ qemuMonitorTestItem *item;
item = g_new0(qemuMonitorTestItem, 1);
}
void *
-qemuMonitorTestItemGetPrivateData(qemuMonitorTestItemPtr item)
+qemuMonitorTestItemGetPrivateData(qemuMonitorTestItem *item)
{
return item ? item->opaque : NULL;
}
typedef struct _qemuMonitorTestCommandArgs qemuMonitorTestCommandArgs;
-typedef qemuMonitorTestCommandArgs *qemuMonitorTestCommandArgsPtr;
struct _qemuMonitorTestCommandArgs {
char *argname;
char *argval;
char *cmderr;
char *response;
size_t nargs;
- qemuMonitorTestCommandArgsPtr args;
+ qemuMonitorTestCommandArgs *args;
char *expectArgs;
};
/* Returns -1 on error, 0 if validation was successful/not necessary */
static int
-qemuMonitorTestProcessCommandDefaultValidate(qemuMonitorTestPtr test,
+qemuMonitorTestProcessCommandDefaultValidate(qemuMonitorTest *test,
const char *cmdname,
- virJSONValuePtr args)
+ virJSONValue *args)
{
g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
static int
-qemuMonitorTestProcessCommandDefault(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+qemuMonitorTestProcessCommandDefault(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *cmdstr)
{
struct qemuMonitorTestHandlerData *data = item->opaque;
g_autoptr(virJSONValue) val = NULL;
- virJSONValuePtr cmdargs = NULL;
+ virJSONValue *cmdargs = NULL;
const char *cmdname;
if (!(val = virJSONValueFromString(cmdstr)))
int
-qemuMonitorTestAddItem(qemuMonitorTestPtr test,
+qemuMonitorTestAddItem(qemuMonitorTest *test,
const char *command_name,
const char *response)
{
static int
-qemuMonitorTestProcessCommandVerbatim(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+qemuMonitorTestProcessCommandVerbatim(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *cmdstr)
{
struct qemuMonitorTestHandlerData *data = item->opaque;
g_autofree char *reformatted = NULL;
g_autoptr(virJSONValue) json = NULL;
- virJSONValuePtr cmdargs;
+ virJSONValue *cmdargs;
const char *cmdname;
int ret = -1;
* Returns 0 when command was successfully added, -1 on error.
*/
int
-qemuMonitorTestAddItemVerbatim(qemuMonitorTestPtr test,
+qemuMonitorTestAddItemVerbatim(qemuMonitorTest *test,
const char *command,
const char *cmderr,
const char *response)
static int
-qemuMonitorTestProcessGuestAgentSync(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item G_GNUC_UNUSED,
+qemuMonitorTestProcessGuestAgentSync(qemuMonitorTest *test,
+ qemuMonitorTestItem *item G_GNUC_UNUSED,
const char *cmdstr)
{
g_autoptr(virJSONValue) val = NULL;
- virJSONValuePtr args;
+ virJSONValue *args;
unsigned long long id;
const char *cmdname;
g_autofree char *retmsg = NULL;
int
-qemuMonitorTestAddAgentSyncResponse(qemuMonitorTestPtr test)
+qemuMonitorTestAddAgentSyncResponse(qemuMonitorTest *test)
{
if (!test->agent) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
-qemuMonitorTestProcessCommandWithArgs(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+qemuMonitorTestProcessCommandWithArgs(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *cmdstr)
{
struct qemuMonitorTestHandlerData *data = item->opaque;
g_autoptr(virJSONValue) val = NULL;
- virJSONValuePtr args;
- virJSONValuePtr argobj;
+ virJSONValue *args;
+ virJSONValue *argobj;
const char *cmdname;
size_t i;
/* validate the args */
for (i = 0; i < data->nargs; i++) {
- qemuMonitorTestCommandArgsPtr arg = &data->args[i];
+ qemuMonitorTestCommandArgs *arg = &data->args[i];
g_autofree char *argstr = NULL;
if (!(argobj = virJSONValueObjectGet(args, arg->argname))) {
/* this allows to add a responder that is able to check
* a (shallow) structure of arguments for a command */
int
-qemuMonitorTestAddItemParams(qemuMonitorTestPtr test,
+qemuMonitorTestAddItemParams(qemuMonitorTest *test,
const char *cmdname,
const char *response,
...)
static int
-qemuMonitorTestProcessCommandWithArgStr(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+qemuMonitorTestProcessCommandWithArgStr(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *cmdstr)
{
struct qemuMonitorTestHandlerData *data = item->opaque;
g_autoptr(virJSONValue) val = NULL;
- virJSONValuePtr args;
+ virJSONValue *args;
g_autofree char *argstr = NULL;
const char *cmdname;
* quotes for simplification of writing the strings into code.
*/
int
-qemuMonitorTestAddItemExpect(qemuMonitorTestPtr test,
+qemuMonitorTestAddItemExpect(qemuMonitorTest *test,
const char *cmdname,
const char *cmdargs,
bool apostrophe,
static void
-qemuMonitorTestEOFNotify(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm G_GNUC_UNUSED,
+qemuMonitorTestEOFNotify(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static void
-qemuMonitorTestErrorNotify(qemuMonitorPtr mon G_GNUC_UNUSED,
- virDomainObjPtr vm G_GNUC_UNUSED,
+qemuMonitorTestErrorNotify(qemuMonitor *mon G_GNUC_UNUSED,
+ virDomainObj *vm G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
}
static void
-qemuMonitorTestAgentNotify(qemuAgentPtr agent G_GNUC_UNUSED,
- virDomainObjPtr vm G_GNUC_UNUSED)
+qemuMonitorTestAgentNotify(qemuAgent *agent G_GNUC_UNUSED,
+ virDomainObj *vm G_GNUC_UNUSED)
{
}
};
-static qemuMonitorTestPtr
-qemuMonitorCommonTestNew(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr vm,
- virDomainChrSourceDefPtr src)
+static qemuMonitorTest *
+qemuMonitorCommonTestNew(virDomainXMLOption *xmlopt,
+ virDomainObj *vm,
+ virDomainChrSourceDef *src)
{
- qemuMonitorTestPtr test = NULL;
+ qemuMonitorTest *test = NULL;
char *path = NULL;
char *tmpdir_template = NULL;
static int
-qemuMonitorCommonTestInit(qemuMonitorTestPtr test)
+qemuMonitorCommonTestInit(qemuMonitorTest *test)
{
int events = VIR_EVENT_HANDLE_READABLE;
/* We skip the normal handshake reply of "{\"execute\":\"qmp_capabilities\"}" */
-qemuMonitorTestPtr
-qemuMonitorTestNew(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
+qemuMonitorTest *
+qemuMonitorTestNew(virDomainXMLOption *xmlopt,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
const char *greeting,
GHashTable *schema)
{
- qemuMonitorTestPtr test = NULL;
+ qemuMonitorTest *test = NULL;
virDomainChrSourceDef src;
memset(&src, 0, sizeof(src));
*
* Returns the monitor object on success; NULL on error.
*/
-qemuMonitorTestPtr
+qemuMonitorTest *
qemuMonitorTestNewFromFile(const char *fileName,
- virDomainXMLOptionPtr xmlopt,
+ virDomainXMLOption *xmlopt,
bool simple)
{
- qemuMonitorTestPtr test = NULL;
+ qemuMonitorTest *test = NULL;
g_autofree char *json = NULL;
char *tmp;
char *singleReply;
* to test some negative scenarios which would not use all commands.
*/
void
-qemuMonitorTestAllowUnusedCommands(qemuMonitorTestPtr test)
+qemuMonitorTestAllowUnusedCommands(qemuMonitorTest *test)
{
test->allowUnusedCommands = true;
}
* argument is removed it will still fail validation.
*/
void
-qemuMonitorTestSkipDeprecatedValidation(qemuMonitorTestPtr test,
+qemuMonitorTestSkipDeprecatedValidation(qemuMonitorTest *test,
bool allowRemoved)
{
test->skipValidationDeprecated = true;
static int
-qemuMonitorTestFullAddItem(qemuMonitorTestPtr test,
+qemuMonitorTestFullAddItem(qemuMonitorTest *test,
const char *filename,
const char *command,
const char *response,
*
* Returns the monitor object on success; NULL on error.
*/
-qemuMonitorTestPtr
+qemuMonitorTest *
qemuMonitorTestNewFromFileFull(const char *fileName,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
GHashTable *qmpschema)
{
- qemuMonitorTestPtr ret = NULL;
+ qemuMonitorTest *ret = NULL;
g_autofree char *jsonstr = NULL;
char *tmp;
size_t line = 0;
}
-qemuMonitorTestPtr
-qemuMonitorTestNewAgent(virDomainXMLOptionPtr xmlopt)
+qemuMonitorTest *
+qemuMonitorTestNewAgent(virDomainXMLOption *xmlopt)
{
- qemuMonitorTestPtr test = NULL;
+ qemuMonitorTest *test = NULL;
virDomainChrSourceDef src;
memset(&src, 0, sizeof(src));
}
-qemuMonitorPtr
-qemuMonitorTestGetMonitor(qemuMonitorTestPtr test)
+qemuMonitor *
+qemuMonitorTestGetMonitor(qemuMonitorTest *test)
{
return test->mon;
}
-qemuAgentPtr
-qemuMonitorTestGetAgent(qemuMonitorTestPtr test)
+qemuAgent *
+qemuMonitorTestGetAgent(qemuMonitorTest *test)
{
return test->agent;
}
-virDomainObjPtr
-qemuMonitorTestGetDomainObj(qemuMonitorTestPtr test)
+virDomainObj *
+qemuMonitorTestGetDomainObj(qemuMonitorTest *test)
{
return test->vm;
}
#include "qemu/qemu_agent.h"
typedef struct _qemuMonitorTest qemuMonitorTest;
-typedef qemuMonitorTest *qemuMonitorTestPtr;
typedef struct _qemuMonitorTestItem qemuMonitorTestItem;
-typedef qemuMonitorTestItem *qemuMonitorTestItemPtr;
-typedef int (*qemuMonitorTestResponseCallback)(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item,
+typedef int (*qemuMonitorTestResponseCallback)(qemuMonitorTest *test,
+ qemuMonitorTestItem *item,
const char *message);
-int qemuMonitorTestAddHandler(qemuMonitorTestPtr test,
+int qemuMonitorTestAddHandler(qemuMonitorTest *test,
const char *identifier,
qemuMonitorTestResponseCallback cb,
void *opaque,
virFreeCallback freecb);
-int qemuMonitorTestAddResponse(qemuMonitorTestPtr test,
+int qemuMonitorTestAddResponse(qemuMonitorTest *test,
const char *response);
-int qemuMonitorTestAddInvalidCommandResponse(qemuMonitorTestPtr test,
+int qemuMonitorTestAddInvalidCommandResponse(qemuMonitorTest *test,
const char *expectedcommand,
const char *actualcommand);
-void *qemuMonitorTestItemGetPrivateData(qemuMonitorTestItemPtr item);
+void *qemuMonitorTestItemGetPrivateData(qemuMonitorTestItem *item);
-int qemuMonitorTestAddErrorResponse(qemuMonitorTestPtr test, const char *errmsg, ...);
+int qemuMonitorTestAddErrorResponse(qemuMonitorTest *test, const char *errmsg, ...);
-void qemuMonitorTestAllowUnusedCommands(qemuMonitorTestPtr test);
-void qemuMonitorTestSkipDeprecatedValidation(qemuMonitorTestPtr test,
+void qemuMonitorTestAllowUnusedCommands(qemuMonitorTest *test);
+void qemuMonitorTestSkipDeprecatedValidation(qemuMonitorTest *test,
bool allowRemoved);
-int qemuMonitorTestAddItem(qemuMonitorTestPtr test,
+int qemuMonitorTestAddItem(qemuMonitorTest *test,
const char *command_name,
const char *response);
-int qemuMonitorTestAddItemVerbatim(qemuMonitorTestPtr test,
+int qemuMonitorTestAddItemVerbatim(qemuMonitorTest *test,
const char *command,
const char *cmderr,
const char *response);
-int qemuMonitorTestAddAgentSyncResponse(qemuMonitorTestPtr test);
+int qemuMonitorTestAddAgentSyncResponse(qemuMonitorTest *test);
-int qemuMonitorTestAddItemParams(qemuMonitorTestPtr test,
+int qemuMonitorTestAddItemParams(qemuMonitorTest *test,
const char *cmdname,
const char *response,
...)
G_GNUC_NULL_TERMINATED;
-int qemuMonitorTestAddItemExpect(qemuMonitorTestPtr test,
+int qemuMonitorTestAddItemExpect(qemuMonitorTest *test,
const char *cmdname,
const char *cmdargs,
bool apostrophe,
#define qemuMonitorTestNewSchema(xmlopt, schema) \
qemuMonitorTestNew(xmlopt, NULL, NULL, NULL, schema)
-qemuMonitorTestPtr qemuMonitorTestNew(virDomainXMLOptionPtr xmlopt,
- virDomainObjPtr vm,
- virQEMUDriverPtr driver,
+qemuMonitorTest *qemuMonitorTestNew(virDomainXMLOption *xmlopt,
+ virDomainObj *vm,
+ virQEMUDriver *driver,
const char *greeting,
GHashTable *schema);
-qemuMonitorTestPtr qemuMonitorTestNewFromFile(const char *fileName,
- virDomainXMLOptionPtr xmlopt,
+qemuMonitorTest *qemuMonitorTestNewFromFile(const char *fileName,
+ virDomainXMLOption *xmlopt,
bool simple);
-qemuMonitorTestPtr qemuMonitorTestNewFromFileFull(const char *fileName,
- virQEMUDriverPtr driver,
- virDomainObjPtr vm,
+qemuMonitorTest *qemuMonitorTestNewFromFileFull(const char *fileName,
+ virQEMUDriver *driver,
+ virDomainObj *vm,
GHashTable *qmpschema);
-qemuMonitorTestPtr qemuMonitorTestNewAgent(virDomainXMLOptionPtr xmlopt);
+qemuMonitorTest *qemuMonitorTestNewAgent(virDomainXMLOption *xmlopt);
-void qemuMonitorTestFree(qemuMonitorTestPtr test);
+void qemuMonitorTestFree(qemuMonitorTest *test);
-qemuMonitorPtr qemuMonitorTestGetMonitor(qemuMonitorTestPtr test);
-qemuAgentPtr qemuMonitorTestGetAgent(qemuMonitorTestPtr test);
-virDomainObjPtr qemuMonitorTestGetDomainObj(qemuMonitorTestPtr test);
+qemuMonitor *qemuMonitorTestGetMonitor(qemuMonitorTest *test);
+qemuAgent *qemuMonitorTestGetAgent(qemuMonitorTest *test);
+virDomainObj *qemuMonitorTestGetDomainObj(qemuMonitorTest *test);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorTest, qemuMonitorTestFree);
#define VIR_FROM_THIS VIR_FROM_NONE
struct testData {
- virQEMUDriverPtr driver;
+ virQEMUDriver *driver;
const char *file; /* file name to load VM def XML from; qemuxml2argvdata/ */
};
static int
-prepareObjects(virQEMUDriverPtr driver,
+prepareObjects(virQEMUDriver *driver,
const char *xmlname,
- virDomainObjPtr *vm_ret)
+ virDomainObj **vm_ret)
{
- qemuDomainObjPrivatePtr priv;
+ qemuDomainObjPrivate *priv;
g_autoptr(virDomainObj) vm = NULL;
g_autofree char *filename = NULL;
g_autofree char *domxml = NULL;
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
- virStorageSourcePtr src = vm->def->disks[i]->src;
- virStorageSourcePtr n;
+ virStorageSource *src = vm->def->disks[i]->src;
+ virStorageSource *n;
if (!src)
continue;
mymain(void)
{
virQEMUDriver driver;
- virSecurityManagerPtr stack = NULL;
- virSecurityManagerPtr dac = NULL;
+ virSecurityManager *stack = NULL;
+ virSecurityManager *dac = NULL;
#ifdef WITH_SELINUX
- virSecurityManagerPtr selinux = NULL;
+ virSecurityManager *selinux = NULL;
#endif
int ret = 0;
testCompareStatusXMLToXMLFiles(const void *opaque)
{
const struct testQemuInfo *data = opaque;
- virDomainObjPtr obj = NULL;
+ virDomainObj *obj = NULL;
g_autofree char *actual = NULL;
int ret = -1;
}
bool
-virNumaNodesetIsAvailable(virBitmapPtr nodeset)
+virNumaNodesetIsAvailable(virBitmap *nodeset)
{
ssize_t bit = -1;
return g_strdup("/dev/dri/foo");
}
-static void (*real_virCommandPassFD)(virCommandPtr cmd, int fd, unsigned int flags);
+static void (*real_virCommandPassFD)(virCommand *cmd, int fd, unsigned int flags);
static const int testCommandPassSafeFDs[] = { 1730, 1731, 1732 };
void
-virCommandPassFD(virCommandPtr cmd,
+virCommandPassFD(virCommand *cmd,
int fd,
unsigned int flags)
{
}
int
-qemuInterfaceOpenVhostNet(virDomainDefPtr def G_GNUC_UNUSED,
- virDomainNetDefPtr net,
+qemuInterfaceOpenVhostNet(virDomainDef *def G_GNUC_UNUSED,
+ virDomainNetDef *net,
int *vhostfd,
size_t *vhostfdSize)
{
int
-qemuInterfaceVDPAConnect(virDomainNetDefPtr net G_GNUC_UNUSED)
+qemuInterfaceVDPAConnect(virDomainNetDef *net G_GNUC_UNUSED)
{
if (fcntl(1732, F_GETFD) != -1)
abort();
static int
-testAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy)
+testAddCPUModels(virQEMUCaps *caps, bool skipLegacy)
{
virArch arch = virQEMUCapsGetArch(caps);
const char *x86Models[] = {
static int
testUpdateQEMUCaps(const struct testQemuInfo *info,
virArch arch,
- virCapsPtr caps)
+ virCaps *caps)
{
if (!caps)
return -1;
}
-static virCommandPtr
-testCompareXMLToArgvCreateArgs(virQEMUDriverPtr drv,
- virDomainObjPtr vm,
+static virCommand *
+testCompareXMLToArgvCreateArgs(virQEMUDriver *drv,
+ virDomainObj *vm,
const char *migrateURI,
struct testQemuInfo *info,
unsigned int flags,
bool jsonPropsValidation)
{
- qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjPrivate *priv = vm->privateData;
bool enableFips = !!(flags & FLAG_FIPS_HOST);
size_t i;
return NULL;
for (i = 0; i < vm->def->ndisks; i++) {
- virDomainDiskDefPtr disk = vm->def->disks[i];
+ virDomainDiskDef *disk = vm->def->disks[i];
/* host cdrom requires special treatment in qemu, mock it */
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
}
for (i = 0; i < vm->def->nhostdevs; i++) {
- virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
+ virDomainHostdevDef *hostdev = vm->def->hostdevs[i];
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
}
if (virHostdevIsSCSIDevice(hostdev)) {
- virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
+ virDomainHostdevSubsysSCSI *scsisrc = &hostdev->source.subsys.u.scsi;
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE:
}
for (i = 0; i < vm->def->nfss; i++) {
- virDomainFSDefPtr fs = vm->def->fss[i];
+ virDomainFSDef *fs = vm->def->fss[i];
char *s;
if (fs->fsdriver != VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS ||
}
if (vm->def->vsock) {
- virDomainVsockDefPtr vsock = vm->def->vsock;
- qemuDomainVsockPrivatePtr vsockPriv =
- (qemuDomainVsockPrivatePtr)vsock->privateData;
+ virDomainVsockDef *vsock = vm->def->vsock;
+ qemuDomainVsockPrivate *vsockPriv =
+ (qemuDomainVsockPrivate *)vsock->privateData;
if (vsock->auto_cid == VIR_TRISTATE_BOOL_YES)
vsock->guest_cid = 42;
}
for (i = 0; i < vm->def->nvideos; i++) {
- virDomainVideoDefPtr video = vm->def->videos[i];
+ virDomainVideoDef *video = vm->def->videos[i];
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
- qemuDomainVideoPrivatePtr vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);
+ qemuDomainVideoPrivate *vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);
vpriv->vhost_user_fd = 1729;
}
if (flags & FLAG_SLIRP_HELPER) {
for (i = 0; i < vm->def->nnets; i++) {
- virDomainNetDefPtr net = vm->def->nets[i];
+ virDomainNetDef *net = vm->def->nets[i];
if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
- qemuSlirpPtr slirp = qemuSlirpNew();
+ qemuSlirp *slirp = qemuSlirpNew();
slirp->fd[0] = 42;
QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
}
static int
-testCompareXMLToArgvValidateSchema(virQEMUDriverPtr drv,
+testCompareXMLToArgvValidateSchema(virQEMUDriver *drv,
const char *migrateURI,
struct testQemuInfo *info,
unsigned int flags)
{
g_auto(GStrv) args = NULL;
g_autoptr(virDomainObj) vm = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
size_t nargs = 0;
size_t i;
GHashTable *schema = NULL;
unsigned int flags = info->flags;
unsigned int parseFlags = info->parseFlags;
int ret = -1;
- virDomainObjPtr vm = NULL;
+ virDomainObj *vm = NULL;
virDomainChrSourceDef monitor_chr;
g_autoptr(virConnect) conn = NULL;
virError *err = NULL;
char *log = NULL;
g_autoptr(virCommand) cmd = NULL;
- qemuDomainObjPrivatePtr priv = NULL;
+ qemuDomainObjPrivate *priv = NULL;
g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
xmlNodePtr root;
static int
mymain(void)
{
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
const char *doi, *model;
mgr = virSecurityManagerNew(NULL, "QEMU", VIR_SECURITY_MANAGER_DEFAULT_CONFINED);
{
char *actual = NULL;
int ret = -1;
- virSecretDefPtr secret = NULL;
+ virSecretDef *secret = NULL;
if (!(secret = virSecretDefParseFile(inxml)))
goto fail;
static virQEMUDriver driver;
-static virSecurityManagerPtr mgr;
+static virSecurityManager *mgr;
typedef struct testSELinuxFile testSELinuxFile;
}
-static virDomainDefPtr
+static virDomainDef *
testSELinuxLoadDef(const char *testname)
{
char *xmlfile = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
size_t i;
xmlfile = g_strdup_printf("%s/securityselinuxlabeldata/%s.xml", abs_srcdir,
testSELinuxFile *files = NULL;
size_t nfiles = 0;
size_t i;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
if (testSELinuxLoadFileList(testname, &files, &nfiles) < 0)
goto cleanup;
VIR_LOG_INIT("tests.securityselinuxtest");
struct testSELinuxGenLabelData {
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
const char *pidcon;
int catMax;
};
-static virDomainDefPtr
+static virDomainDef *
testBuildDomainDef(bool dynamic,
const char *label,
const char *baselabel)
{
- virDomainDefPtr def;
- virSecurityLabelDefPtr secdef = NULL;
+ virDomainDef *def;
+ virSecurityLabelDef *secdef = NULL;
if (!(def = virDomainDefNew()))
goto error;
def->virtType = VIR_DOMAIN_VIRT_KVM;
- def->seclabels = g_new0(virSecurityLabelDefPtr, 1);
+ def->seclabels = g_new0(virSecurityLabelDef *, 1);
secdef = g_new0(virSecurityLabelDef, 1);
{
const struct testSELinuxGenLabelData *data = opaque;
int ret = -1;
- virDomainDefPtr def;
+ virDomainDef *def;
context_t con = NULL;
context_t imgcon = NULL;
mymain(void)
{
int ret = 0;
- virSecurityManagerPtr mgr;
+ virSecurityManager *mgr;
if (!(mgr = virSecurityManagerNew("selinux", "QEMU",
VIR_SECURITY_MANAGER_DEFAULT_CONFINED |
struct test_virStoragePoolCapsFormatData {
const char *filename;
- virCapsPtr driverCaps;
+ virCaps *driverCaps;
};
static void
-test_virCapabilitiesAddFullStoragePool(virCapsPtr caps)
+test_virCapabilitiesAddFullStoragePool(virCaps *caps)
{
size_t i;
static void
-test_virCapabilitiesAddFSStoragePool(virCapsPtr caps)
+test_virCapabilitiesAddFSStoragePool(virCaps *caps)
{
virCapabilitiesAddStoragePool(caps, VIR_STORAGE_POOL_FS);
}
{
struct test_virStoragePoolCapsFormatData *data =
(struct test_virStoragePoolCapsFormatData *) opaque;
- virCapsPtr driverCaps = data->driverCaps;
+ virCaps *driverCaps = data->driverCaps;
g_autoptr(virStoragePoolCaps) poolCaps = NULL;
g_autofree char *path = NULL;
g_autofree char *poolCapsXML = NULL;
const char *cmdline)
{
int ret = -1;
- virStoragePoolDefPtr def = NULL;
- virStoragePoolObjPtr pool = NULL;
+ virStoragePoolDef *def = NULL;
+ virStoragePoolObj *pool = NULL;
const char *defTypeStr;
g_autofree char *actualCmdline = NULL;
g_autofree char *src = NULL;
/* createVol sets this on volume creation */
static void
-testSetVolumeType(virStorageVolDefPtr vol,
- virStoragePoolDefPtr pool)
+testSetVolumeType(virStorageVolDef *vol,
+ virStoragePoolDef *pool)
{
if (!vol || !pool)
return;
{
virStorageVolEncryptConvertStep convertStep = VIR_STORAGE_VOL_ENCRYPT_NONE;
int ret = -1;
- virStoragePoolDefPtr def = NULL;
- virStoragePoolObjPtr obj = NULL;
+ virStoragePoolDef *def = NULL;
+ virStoragePoolObj *obj = NULL;
g_autofree char *actualCmdline = NULL;
g_autoptr(virStorageVolDef) vol = NULL;
g_autoptr(virStorageVolDef) inputvol = NULL;
struct testSysinfoData {
const char *name; /* test name, also base name for result files */
- virSysinfoDefPtr (*func)(void); /* sysinfo gathering function */
+ virSysinfoDef *(*func)(void); /* sysinfo gathering function */
};
static size_t testCounter;
-static virBitmapPtr testBitmap;
-static virBitmapPtr failedTests;
+static virBitmap *testBitmap;
+static virBitmap *failedTests;
virArch virTestHostArch = VIR_ARCH_X86_64;
* Constructs the test file path from variable arguments and loads and parses
* the JSON file. 'abs_srcdir' is automatically prepended to the path.
*/
-virJSONValuePtr
+virJSONValue *
virTestLoadFileJSON(const char *p, ...)
{
- virJSONValuePtr ret = NULL;
+ virJSONValue *ret = NULL;
g_autofree char *jsonstr = NULL;
g_autofree char *path = NULL;
va_list ap;
static struct virtTestLogData testLog = { VIR_BUFFER_INITIALIZER };
static void
-virtTestLogOutput(virLogSourcePtr source G_GNUC_UNUSED,
+virtTestLogOutput(virLogSource *source G_GNUC_UNUSED,
virLogPriority priority G_GNUC_UNUSED,
const char *filename G_GNUC_UNUSED,
int lineno G_GNUC_UNUSED,
const char *funcname G_GNUC_UNUSED,
const char *timestamp,
- virLogMetadataPtr metadata G_GNUC_UNUSED,
+ struct _virLogMetadata *metadata G_GNUC_UNUSED,
const char *rawstr G_GNUC_UNUSED,
const char *str,
void *data)
int ret;
char *testRange = NULL;
size_t noutputs = 0;
- virLogOutputPtr output = NULL;
- virLogOutputPtr *outputs = NULL;
+ virLogOutput *output = NULL;
+ virLogOutput **outputs = NULL;
g_autofree char *baseprogname = NULL;
const char *progname;
g_autofree const char **preloads = NULL;
}
-virCapsPtr virTestGenericCapsInit(void)
+virCaps *
+virTestGenericCapsInit(void)
{
g_autoptr(virCaps) caps = NULL;
- virCapsGuestPtr guest;
+ virCapsGuest *guest;
if ((caps = virCapabilitiesNew(VIR_ARCH_X86_64,
false, false)) == NULL)
* Build NUMA topology with cell id starting from (0 + seq)
* for testing
*/
-virCapsHostNUMAPtr
+virCapsHostNUMA *
virTestCapsBuildNUMATopology(int seq)
{
g_autoptr(virCapsHostNUMA) caps = virCapabilitiesHostNUMANew();
- virCapsHostNUMACellCPUPtr cell_cpus = NULL;
+ virCapsHostNUMACellCPU *cell_cpus = NULL;
int core_id, cell_id;
int id;
.features = VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS,
};
-virDomainXMLOptionPtr virTestGenericDomainXMLConfInit(void)
+virDomainXMLOption *virTestGenericDomainXMLConfInit(void)
{
return virDomainXMLOptionNew(&virTestGenericDomainDefParserConfig,
NULL, NULL, NULL, NULL);
int
-testCompareDomXML2XMLFiles(virCapsPtr caps G_GNUC_UNUSED,
- virDomainXMLOptionPtr xmlopt,
+testCompareDomXML2XMLFiles(virCaps *caps G_GNUC_UNUSED,
+ virDomainXMLOption *xmlopt,
const char *infile, const char *outfile, bool live,
unsigned int parseFlags,
testCompareDomXML2XMLResult expectResult)
g_autofree char *actual = NULL;
int ret = -1;
testCompareDomXML2XMLResult result;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
unsigned int parse_flags = live ? 0 : VIR_DOMAIN_DEF_PARSE_INACTIVE;
unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
int virTestLoadFile(const char *file, char **buf);
char *virTestLoadFilePath(const char *p, ...)
G_GNUC_NULL_TERMINATED;
-virJSONValuePtr virTestLoadFileJSON(const char *p, ...)
+virJSONValue *virTestLoadFileJSON(const char *p, ...)
G_GNUC_NULL_TERMINATED;
int virTestDifference(FILE *stream,
#define VIR_TEST_MOCK(mock) (abs_builddir "/lib" mock "mock" MOCK_EXT)
-virCapsPtr virTestGenericCapsInit(void);
-virCapsHostNUMAPtr virTestCapsBuildNUMATopology(int seq);
-virDomainXMLOptionPtr virTestGenericDomainXMLConfInit(void);
+virCaps *virTestGenericCapsInit(void);
+virCapsHostNUMA *virTestCapsBuildNUMATopology(int seq);
+virDomainXMLOption *virTestGenericDomainXMLConfInit(void);
typedef enum {
TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS,
TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_COMPARE,
} testCompareDomXML2XMLResult;
-int testCompareDomXML2XMLFiles(virCapsPtr caps,
- virDomainXMLOptionPtr xmlopt,
+int testCompareDomXML2XMLFiles(virCaps *caps,
+ virDomainXMLOption *xmlopt,
const char *inxml,
const char *outfile,
bool live,
.threads = 1,
};
-static inline virCPUDefPtr
+static inline virCPUDef *
testUtilsHostCpusGetDefForModel(const char *model)
{
if (!model)
return NULL;
}
-static inline virCPUDefPtr
+static inline virCPUDef *
testUtilsHostCpusGetDefForArch(virArch arch)
{
if (ARCH_IS_X86(arch))
# define VIR_FROM_THIS VIR_FROM_LXC
-virCapsPtr
+virCaps *
testLXCCapsInit(void)
{
- virCapsPtr caps;
- virCapsGuestPtr guest;
+ virCaps *caps;
+ virCapsGuest *guest;
if ((caps = virCapabilitiesNew(VIR_ARCH_X86_64,
false, false)) == NULL)
}
-virLXCDriverPtr
+virLXCDriver *
testLXCDriverInit(void)
{
- virLXCDriverPtr driver = g_new0(virLXCDriver, 1);
+ virLXCDriver *driver = g_new0(virLXCDriver, 1);
if (virMutexInit(&driver->lock) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
void
-testLXCDriverFree(virLXCDriverPtr driver)
+testLXCDriverFree(virLXCDriver *driver)
{
virObjectUnref(driver->xmlopt);
virObjectUnref(driver->caps);
#define FAKEDEVDIR0 "/fakedevdir0/bla/fasl"
#define FAKEDEVDIR1 "/fakedevdir1/bla/fasl"
-virCapsPtr testLXCCapsInit(void);
-virLXCDriverPtr testLXCDriverInit(void);
-void testLXCDriverFree(virLXCDriverPtr driver);
+virCaps *testLXCCapsInit(void);
+virLXCDriver *testLXCDriverInit(void);
+void testLXCDriverFree(virLXCDriver *driver);
# define VIR_FROM_THIS VIR_FROM_QEMU
-virCPUDefPtr cpuDefault;
-virCPUDefPtr cpuHaswell;
-virCPUDefPtr cpuPower8;
-virCPUDefPtr cpuPower9;
+virCPUDef *cpuDefault;
+virCPUDef *cpuHaswell;
+virCPUDef *cpuPower8;
+virCPUDef *cpuPower9;
static const char *qemu_emulators[VIR_ARCH_LAST] = {
}
-virCapsHostNUMAPtr
+virCapsHostNUMA *
virCapabilitiesHostNUMANewHost(void)
{
/*
static int
-testQemuAddGuest(virCapsPtr caps,
+testQemuAddGuest(virCaps *caps,
virArch arch)
{
size_t nmachines;
- virCapsGuestMachinePtr *machines = NULL;
- virCapsGuestPtr guest;
+ virCapsGuestMachine **machines = NULL;
+ virCapsGuest *guest;
virArch emu_arch = arch;
if (arch_alias[arch] != VIR_ARCH_NONE)
}
-virCapsPtr testQemuCapsInit(void)
+virCaps *testQemuCapsInit(void)
{
- virCapsPtr caps;
+ virCaps *caps;
size_t i;
if (!(caps = virCapabilitiesNew(VIR_ARCH_X86_64, false, false)))
void
-qemuTestSetHostArch(virQEMUDriverPtr driver,
+qemuTestSetHostArch(virQEMUDriver *driver,
virArch arch)
{
if (arch == VIR_ARCH_NONE)
void
-qemuTestSetHostCPU(virQEMUDriverPtr driver,
+qemuTestSetHostCPU(virQEMUDriver *driver,
virArch arch,
- virCPUDefPtr cpu)
+ virCPUDef *cpu)
{
if (!cpu) {
if (ARCH_IS_X86(arch))
}
-virQEMUCapsPtr
+virQEMUCaps *
qemuTestParseCapabilitiesArch(virArch arch,
const char *capsFile)
{
- virQEMUCapsPtr qemuCaps = NULL;
+ virQEMUCaps *qemuCaps = NULL;
g_autofree char *binary = g_strdup_printf("/usr/bin/qemu-system-%s",
virArchToString(arch));
virObjectUnref(driver->securityManager);
}
-int qemuTestCapsCacheInsert(virFileCachePtr cache,
- virQEMUCapsPtr caps)
+int qemuTestCapsCacheInsert(virFileCache *cache,
+ virQEMUCaps *caps)
{
size_t i, j;
for (i = 0; i < G_N_ELEMENTS(qemu_emulators); i++) {
- virQEMUCapsPtr tmpCaps;
+ virQEMUCaps *tmpCaps;
if (qemu_emulators[i] == NULL)
continue;
if (caps) {
int qemuTestDriverInit(virQEMUDriver *driver)
{
- virSecurityManagerPtr mgr = NULL;
+ virSecurityManager *mgr = NULL;
char statedir[] = STATEDIRTEMPLATE;
char configdir[] = CONFIGDIRTEMPLATE;
}
int
-testQemuCapsSetGIC(virQEMUCapsPtr qemuCaps,
+testQemuCapsSetGIC(virQEMUCaps *qemuCaps,
int gic)
{
virGICCapability *gicCapabilities = NULL;
{
va_list argptr;
testQemuInfoArgName argname;
- virQEMUCapsPtr qemuCaps = NULL;
+ virQEMUCaps *qemuCaps = NULL;
int gic = GIC_NONE;
char *capsarch = NULL;
char *capsver = NULL;
if (!qemuCaps && capsarch && capsver) {
bool stripmachinealiases = false;
- virQEMUCapsPtr cachedcaps = NULL;
+ virQEMUCaps *cachedcaps = NULL;
info->arch = virArchFromString(capsarch);
char *infile;
char *outfile;
char *errfile;
- virQEMUCapsPtr qemuCaps;
+ virQEMUCaps *qemuCaps;
const char *migrateFrom;
int migrateFd;
unsigned int flags;
GHashTable *qapiSchemaCache;
};
-virCapsPtr testQemuCapsInit(void);
-virDomainXMLOptionPtr testQemuXMLConfInit(void);
+virCaps *testQemuCapsInit(void);
+virDomainXMLOption *testQemuXMLConfInit(void);
-virQEMUCapsPtr qemuTestParseCapabilitiesArch(virArch arch,
+virQEMUCaps *qemuTestParseCapabilitiesArch(virArch arch,
const char *capsFile);
-extern virCPUDefPtr cpuDefault;
-extern virCPUDefPtr cpuHaswell;
-extern virCPUDefPtr cpuPower8;
-extern virCPUDefPtr cpuPower9;
+extern virCPUDef *cpuDefault;
+extern virCPUDef *cpuHaswell;
+extern virCPUDef *cpuPower8;
+extern virCPUDef *cpuPower9;
-void qemuTestSetHostArch(virQEMUDriverPtr driver,
+void qemuTestSetHostArch(virQEMUDriver *driver,
virArch arch);
-void qemuTestSetHostCPU(virQEMUDriverPtr driver,
+void qemuTestSetHostCPU(virQEMUDriver *driver,
virArch arch,
- virCPUDefPtr cpu);
+ virCPUDef *cpu);
int qemuTestDriverInit(virQEMUDriver *driver);
void qemuTestDriverFree(virQEMUDriver *driver);
-int qemuTestCapsCacheInsert(virFileCachePtr cache,
- virQEMUCapsPtr caps);
+int qemuTestCapsCacheInsert(virFileCache *cache,
+ virQEMUCaps *caps);
-int testQemuCapsSetGIC(virQEMUCapsPtr qemuCaps,
+int testQemuCapsSetGIC(virQEMUCaps *qemuCaps,
int gic);
char *testQemuGetLatestCapsForArch(const char *arch,
struct testQEMUSchemaValidateCtxt {
GHashTable *schema;
- virBufferPtr debug;
+ virBuffer *debug;
bool allowDeprecated;
};
static int
-testQEMUSchemaValidateRecurse(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateRecurse(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt);
static int
-testQEMUSchemaValidateBuiltin(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateBuiltin(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
const char *t = virJSONValueObjectGetString(root, "json-type");
}
struct testQEMUSchemaValidateObjectMemberData {
- virJSONValuePtr rootmembers;
+ virJSONValue *rootmembers;
struct testQEMUSchemaValidateCtxt *ctxt;
bool missingMandatory;
};
-static virJSONValuePtr
+static virJSONValue *
testQEMUSchemaStealObjectMemberByName(const char *name,
- virJSONValuePtr members)
+ virJSONValue *members)
{
- virJSONValuePtr member;
- virJSONValuePtr ret = NULL;
+ virJSONValue *member;
+ virJSONValue *ret = NULL;
size_t i;
for (i = 0; i < virJSONValueArraySize(members); i++) {
static int
testQEMUSchemaValidateObjectMember(const char *key,
- virJSONValuePtr value,
+ virJSONValue *value,
void *opaque)
{
struct testQEMUSchemaValidateObjectMemberData *data = opaque;
g_autoptr(virJSONValue) keymember = NULL;
const char *keytype;
- virJSONValuePtr keyschema = NULL;
+ virJSONValue *keyschema = NULL;
int rc;
virBufferStrcat(data->ctxt->debug, key, ": ", NULL);
static int
testQEMUSchemaValidateObjectMergeVariantMember(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque)
{
- virJSONValuePtr array = opaque;
+ virJSONValue *array = opaque;
g_autoptr(virJSONValue) copy = NULL;
if (!(copy = virJSONValueCopy(item)))
* 'variants' array from @root.
*/
static int
-testQEMUSchemaValidateObjectMergeVariant(virJSONValuePtr root,
+testQEMUSchemaValidateObjectMergeVariant(virJSONValue *root,
const char *variantfield,
const char *variantname,
struct testQEMUSchemaValidateCtxt *ctxt)
{
size_t i;
g_autoptr(virJSONValue) variants = NULL;
- virJSONValuePtr variant;
- virJSONValuePtr variantschema;
- virJSONValuePtr variantschemamembers;
- virJSONValuePtr rootmembers;
+ virJSONValue *variant;
+ virJSONValue *variantschema;
+ virJSONValue *variantschemamembers;
+ virJSONValue *rootmembers;
const char *varianttype = NULL;
if (!(variants = virJSONValueObjectStealArray(root, "variants"))) {
static int
testQEMUSchemaValidateObjectMandatoryMember(size_t pos G_GNUC_UNUSED,
- virJSONValuePtr item,
+ virJSONValue *item,
void *opaque G_GNUC_UNUSED)
{
struct testQEMUSchemaValidateObjectMemberData *data = opaque;
static int
-testQEMUSchemaValidateObject(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateObject(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
struct testQEMUSchemaValidateObjectMemberData data = { NULL, ctxt, false };
static int
-testQEMUSchemaValidateEnum(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateEnum(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
const char *objstr;
- virJSONValuePtr values = NULL;
- virJSONValuePtr value;
+ virJSONValue *values = NULL;
+ virJSONValue *value;
size_t i;
if (virJSONValueGetType(obj) != VIR_JSON_TYPE_STRING) {
static int
-testQEMUSchemaValidateArray(virJSONValuePtr objs,
- virJSONValuePtr root,
+testQEMUSchemaValidateArray(virJSONValue *objs,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
const char *elemtypename = virJSONValueObjectGetString(root, "element-type");
- virJSONValuePtr elementschema;
- virJSONValuePtr obj;
+ virJSONValue *elementschema;
+ virJSONValue *obj;
size_t i;
if (virJSONValueGetType(objs) != VIR_JSON_TYPE_ARRAY) {
}
static int
-testQEMUSchemaValidateAlternate(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateAlternate(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
- virJSONValuePtr members;
- virJSONValuePtr member;
+ virJSONValue *members;
+ virJSONValue *member;
size_t i;
size_t n;
const char *membertype;
- virJSONValuePtr memberschema;
+ virJSONValue *memberschema;
int indent;
int rc;
static int
-testQEMUSchemaValidateDeprecated(virJSONValuePtr root,
+testQEMUSchemaValidateDeprecated(virJSONValue *root,
const char *name,
struct testQEMUSchemaValidateCtxt *ctxt)
{
- virJSONValuePtr features = virJSONValueObjectGetArray(root, "features");
+ virJSONValue *features = virJSONValueObjectGetArray(root, "features");
size_t nfeatures;
size_t i;
nfeatures = virJSONValueArraySize(features);
for (i = 0; i < nfeatures; i++) {
- virJSONValuePtr cur = virJSONValueArrayGet(features, i);
+ virJSONValue *cur = virJSONValueArrayGet(features, i);
const char *curstr;
if (!cur ||
static int
-testQEMUSchemaValidateRecurse(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidateRecurse(virJSONValue *obj,
+ virJSONValue *root,
struct testQEMUSchemaValidateCtxt *ctxt)
{
const char *n = virJSONValueObjectGetString(root, "name");
* @debug is filled with information regarding the validation process
*/
int
-testQEMUSchemaValidate(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidate(virJSONValue *obj,
+ virJSONValue *root,
GHashTable *schema,
bool allowDeprecated,
- virBufferPtr debug)
+ virBuffer *debug)
{
struct testQEMUSchemaValidateCtxt ctxt = { .schema = schema,
.debug = debug,
*/
int
testQEMUSchemaValidateCommand(const char *command,
- virJSONValuePtr arguments,
+ virJSONValue *arguments,
GHashTable *schema,
bool allowDeprecated,
bool allowRemoved,
- virBufferPtr debug)
+ virBuffer *debug)
{
struct testQEMUSchemaValidateCtxt ctxt = { .schema = schema,
.debug = debug,
.allowDeprecated = allowDeprecated };
g_autofree char *schemapatharguments = g_strdup_printf("%s/arg-type", command);
g_autoptr(virJSONValue) emptyargs = NULL;
- virJSONValuePtr schemarootcommand;
- virJSONValuePtr schemarootarguments;
+ virJSONValue *schemarootcommand;
+ virJSONValue *schemarootarguments;
int rc;
if (virQEMUQAPISchemaPathGet(command, schema, &schemarootcommand) < 0 ||
* members.
*/
int
-testQEMUSchemaEntryMatchTemplate(virJSONValuePtr schemaentry,
+testQEMUSchemaEntryMatchTemplate(virJSONValue *schemaentry,
...)
{
g_autoptr(virJSONValue) members = NULL;
}
for (i = 0; i < virJSONValueArraySize(members); i++) {
- virJSONValuePtr member = virJSONValueArrayGet(members, i);
+ virJSONValue *member = virJSONValueArrayGet(members, i);
const char *membername = virJSONValueObjectGetString(member, "name");
const char *membertype = virJSONValueObjectGetString(member, "type");
}
-static virJSONValuePtr
+static virJSONValue *
testQEMUSchemaLoadReplies(const char *filename)
{
g_autofree char *caps = NULL;
char *schemaReply;
char *end;
g_autoptr(virJSONValue) reply = NULL;
- virJSONValuePtr schema = NULL;
+ virJSONValue *schema = NULL;
if (virTestLoadFile(filename, &caps) < 0)
return NULL;
* Returns the schema data as the qemu monitor would reply from the latest
* replies file used for qemucapabilitiestest for the x86_64 architecture.
*/
-virJSONValuePtr
+virJSONValue *
testQEMUSchemaGetLatest(const char *arch)
{
g_autofree char *capsLatestFile = NULL;
GHashTable *
testQEMUSchemaLoadLatest(const char *arch)
{
- virJSONValuePtr schema;
+ virJSONValue *schema;
if (!(schema = testQEMUSchemaGetLatest(arch)))
return NULL;
GHashTable *
testQEMUSchemaLoad(const char *filename)
{
- virJSONValuePtr schema;
+ virJSONValue *schema;
if (!(schema = testQEMUSchemaLoadReplies(filename)))
return NULL;
#include "virbuffer.h"
int
-testQEMUSchemaValidate(virJSONValuePtr obj,
- virJSONValuePtr root,
+testQEMUSchemaValidate(virJSONValue *obj,
+ virJSONValue *root,
GHashTable *schema,
bool allowDeprecated,
- virBufferPtr debug);
+ virBuffer *debug);
int
testQEMUSchemaValidateCommand(const char *command,
- virJSONValuePtr arguments,
+ virJSONValue *arguments,
GHashTable *schema,
bool allowDeprecated,
bool allowRemoved,
- virBufferPtr debug);
+ virBuffer *debug);
int
-testQEMUSchemaEntryMatchTemplate(virJSONValuePtr schemaentry,
+testQEMUSchemaEntryMatchTemplate(virJSONValue *schemaentry,
...);
-virJSONValuePtr
+virJSONValue *
testQEMUSchemaGetLatest(const char* arch);
GHashTable *
#define VIR_FROM_THIS VIR_FROM_LIBXL
-static virCapsPtr
+static virCaps *
testXLInitCaps(void)
{
- virCapsPtr caps;
- virCapsGuestPtr guest;
- virCapsGuestMachinePtr *machines;
+ virCaps *caps;
+ virCapsGuest *guest;
+ virCapsGuestMachine **machines;
int nmachines;
static const char *const x86_machines[] = {
"xenfv"
}
-libxlDriverPrivatePtr testXLInitDriver(void)
+libxlDriverPrivate *testXLInitDriver(void)
{
- libxlDriverPrivatePtr driver = g_new0(libxlDriverPrivate, 1);
+ libxlDriverPrivate *driver = g_new0(libxlDriverPrivate, 1);
if (virMutexInit(&driver->lock) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return driver;
}
-void testXLFreeDriver(libxlDriverPrivatePtr driver)
+void testXLFreeDriver(libxlDriverPrivate *driver)
{
virObjectUnref(driver->config);
virObjectUnref(driver->xmlopt);
#ifdef WITH_LIBXL
# include "libxl/libxl_conf.h"
-libxlDriverPrivatePtr testXLInitDriver(void);
+libxlDriverPrivate *testXLInitDriver(void);
-void testXLFreeDriver(libxlDriverPrivatePtr driver);
+void testXLFreeDriver(libxlDriverPrivate *driver);
#endif /* WITH_LIBXL */
char *actual = NULL;
char *pathResult = NULL;
int ret = -1;
- virVBoxSnapshotConfMachinePtr machine = NULL;
+ virVBoxSnapshotConfMachine *machine = NULL;
pathResult = g_strdup(abs_builddir "/vboxsnapshotxmldata/testResult.vbox");
VIR_LOG_INIT("tests.authconfigtest");
struct ConfigLookupData {
- virAuthConfigPtr config;
+ virAuthConfig *config;
const char *hostname;
const char *service;
const char *credname;
{
int ret = 0;
- virAuthConfigPtr config;
+ virAuthConfig *config;
const char *confdata =
"[credentials-test]\n"
static int
-checkBitmap(virBitmapPtr map,
+checkBitmap(virBitmap *map,
const char *expect,
ssize_t expectedSize)
{
}
static int
-testBit(virBitmapPtr bitmap,
+testBit(virBitmap *bitmap,
unsigned int start,
unsigned int end,
bool expected)
static int testBufAutoIndent(const void *data G_GNUC_UNUSED)
{
g_auto(virBuffer) bufinit = VIR_BUFFER_INITIALIZER;
- virBufferPtr buf = &bufinit;
+ virBuffer *buf = &bufinit;
const char expected[] =
" 1\n 2\n 3\n 4\n 5\n 6\n 7\n &\n 8\n 9\n 10\n ' 11'\n";
g_autofree char *result = NULL;
static int testBufTrim(const void *data G_GNUC_UNUSED)
{
g_auto(virBuffer) bufinit = VIR_BUFFER_INITIALIZER;
- virBufferPtr buf = NULL;
+ virBuffer *buf = NULL;
g_autofree char *result = NULL;
const char *expected = "a,b";
{
struct virCapabilitiesData *data = (struct virCapabilitiesData *) opaque;
const char *archStr = virArchToString(data->arch);
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
char *capsXML = NULL;
char *path = NULL;
char *system = NULL;
test_virCapabilitiesGetCpusForNodemask(const void *data G_GNUC_UNUSED)
{
const char *nodestr = "3,4,5,6";
- virBitmapPtr nodemask = NULL;
- virBitmapPtr cpumap = NULL;
+ virBitmap *nodemask = NULL;
+ virBitmap *cpumap = NULL;
g_autoptr(virCapsHostNUMA) caps = NULL;
int mask_size = 8;
int ret = -1;
static bool G_GNUC_UNUSED
-doCapsExpectFailure(virCapsPtr caps,
+doCapsExpectFailure(virCaps *caps,
int ostype,
virArch arch,
int domaintype,
const char *emulator,
const char *machinetype)
{
- virCapsDomainDataPtr data = virCapabilitiesDomainDataLookup(caps, ostype,
+ virCapsDomainData *data = virCapabilitiesDomainDataLookup(caps, ostype,
arch, domaintype, emulator, machinetype);
if (data) {
}
static bool G_GNUC_UNUSED
-doCapsCompare(virCapsPtr caps,
+doCapsCompare(virCaps *caps,
int ostype,
virArch arch,
int domaintype,
const char *expect_machinetype)
{
bool ret = false;
- virCapsDomainDataPtr data = virCapabilitiesDomainDataLookup(caps, ostype,
+ virCapsDomainData *data = virCapabilitiesDomainDataLookup(caps, ostype,
arch, domaintype, emulator, machinetype);
if (!data)
test_virCapsDomainDataLookupQEMU(const void *data G_GNUC_UNUSED)
{
int ret = 0;
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
if (!(caps = testQemuCapsInit())) {
ret = -1;
test_virCapsDomainDataLookupLXC(const void *data G_GNUC_UNUSED)
{
int ret = 0;
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
if (!(caps = testLXCCapsInit())) {
ret = -1;
}
bool
-virCgroupV2DevicesAvailable(virCgroupPtr group G_GNUC_UNUSED)
+virCgroupV2DevicesAvailable(virCgroup *group G_GNUC_UNUSED)
{
return true;
}
VIR_LOG_INIT("tests.cgrouptest");
-static int validateCgroup(virCgroupPtr cgroup,
+static int validateCgroup(virCgroup *cgroup,
const char **expectMountPoint,
const char **expectLinkPoint,
const char **expectPlacement,
g_autoptr(virConf) conf = virConfReadString(srcdata, 0);
int ret = -1;
- virConfValuePtr val;
+ virConfValue *val;
unsigned long long llvalue;
char *str = NULL;
int uintvalue;
char *data;
};
typedef struct _testFileCacheObj testFileCacheObj;
-typedef testFileCacheObj *testFileCacheObjPtr;
-static virClassPtr testFileCacheObjClass;
+static virClass *testFileCacheObjClass;
static void
testFileCacheObjDispose(void *opaque)
{
- testFileCacheObjPtr obj = opaque;
+ testFileCacheObj *obj = opaque;
g_free(obj->data);
}
VIR_ONCE_GLOBAL_INIT(testFileCacheObj);
-static testFileCacheObjPtr
+static testFileCacheObj *
testFileCacheObjNew(const char *data)
{
- testFileCacheObjPtr obj;
+ testFileCacheObj *obj;
if (testFileCacheObjInitialize() < 0)
return NULL;
const char *expectData;
};
typedef struct _testFileCachePriv testFileCachePriv;
-typedef testFileCachePriv *testFileCachePrivPtr;
static bool
testFileCacheIsValid(void *data,
void *priv)
{
- testFileCachePrivPtr testPriv = priv;
- testFileCacheObjPtr obj = data;
+ testFileCachePriv *testPriv = priv;
+ testFileCacheObj *obj = data;
return STREQ(testPriv->expectData, obj->data);
}
testFileCacheNewData(const char *name G_GNUC_UNUSED,
void *priv)
{
- testFileCachePrivPtr testPriv = priv;
+ testFileCachePriv *testPriv = priv;
return testFileCacheObjNew(testPriv->newData);
}
void *priv G_GNUC_UNUSED,
bool *outdated G_GNUC_UNUSED)
{
- testFileCacheObjPtr obj;
+ testFileCacheObj *obj;
char *data;
if (virFileReadAll(filename, 20, &data) < 0)
const char *filename G_GNUC_UNUSED,
void *priv)
{
- testFileCachePrivPtr testPriv = priv;
+ testFileCachePriv *testPriv = priv;
testPriv->dataSaved = true;
struct _testFileCacheData {
- virFileCachePtr cache;
+ virFileCache *cache;
const char *name;
const char *newData;
const char *expectData;
bool expectSave;
};
typedef struct _testFileCacheData testFileCacheData;
-typedef testFileCacheData *testFileCacheDataPtr;
static int
{
int ret = -1;
const testFileCacheData *data = opaque;
- testFileCacheObjPtr obj = NULL;
- testFileCachePrivPtr testPriv = virFileCacheGetPriv(data->cache);
+ testFileCacheObj *obj = NULL;
+ testFileCachePriv *testPriv = virFileCacheGetPriv(data->cache);
testPriv->dataSaved = false;
testPriv->newData = data->newData;
{
int ret = 0;
testFileCachePriv testPriv = {0};
- virFileCachePtr cache = NULL;
+ virFileCache *cache = NULL;
if (!(cache = virFileCacheNew(abs_srcdir "/virfilecachedata",
"cache", &testFileCacheHandlers)))
# define VIR_FROM_THIS VIR_FROM_FIREWALL
static bool fwDisabled = true;
-static virBufferPtr fwBuf;
+static virBuffer *fwBuf;
static bool fwError;
# define TEST_FILTER_TABLE_LIST \
IPTABLES_PATH " -w -A INPUT --source 192.168.122.1 --jump ACCEPT\n"
IPTABLES_PATH " -w -A INPUT --source '!192.168.122.1' --jump REJECT\n";
const struct testFirewallData *data = opaque;
- virFirewallRulePtr fwrule;
+ virFirewallRule *fwrule;
g_autoptr(virCommandDryRunToken) dryRunToken = virCommandDryRunTokenNew();
fwDisabled = data->fwDisabled;
static int
-testFirewallQueryCallback(virFirewallPtr fw,
+testFirewallQueryCallback(virFirewall *fw,
virFirewallLayer layer,
const char *const *lines,
void *opaque G_GNUC_UNUSED)
static int
-linuxCPUStatsToBuf(virBufferPtr buf,
+linuxCPUStatsToBuf(virBuffer *buf,
int cpu,
virNodeCPUStatsPtr param,
size_t nparams)
static const unsigned char *uuid =
(unsigned char *)("f92360b0-2541-8791-fb32-d1f838811541");
static int nhostdevs = 3;
-static virDomainHostdevDefPtr hostdevs[] = {NULL, NULL, NULL};
-static virPCIDevicePtr dev[] = {NULL, NULL, NULL};
-static virHostdevManagerPtr mgr;
+static virDomainHostdevDef *hostdevs[] = {NULL, NULL, NULL};
+static virPCIDevice *dev[] = {NULL, NULL, NULL};
+static virHostdevManager *mgr;
static const size_t ndisks = 3;
-static virDomainDiskDefPtr disks[] = {NULL, NULL, NULL};
+static virDomainDiskDef *disks[] = {NULL, NULL, NULL};
static const char *diskXML[] = {
"<disk type='nvme' device='disk'>"
" <driver name='qemu' type='raw'/>"
{
const struct testInfo *info = data;
g_autoptr(virJSONValue) json = NULL;
- virJSONValuePtr value = NULL;
+ virJSONValue *value = NULL;
g_autofree char *result = NULL;
int rc;
int number;
# define VIR_FROM_THIS VIR_FROM_NONE
static int
-checkOutput(virBufferPtr buf, const char *exp_cmd)
+checkOutput(virBuffer *buf, const char *exp_cmd)
{
int ret = -1;
char *actual_cmd = NULL;
static int testLockSpaceCreate(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLifecycle(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLockExcl(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLockExclAuto(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLockShr(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLockShrAuto(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
static int testLockSpaceResourceLockPath(const void *args G_GNUC_UNUSED)
{
- virLockSpacePtr lockspace;
+ virLockSpace *lockspace;
int ret = -1;
rmdir(LOCKSPACE_DIR);
{
int ret = -1;
int noutputs;
- virLogOutputPtr *outputs = NULL;
+ virLogOutput **outputs = NULL;
const struct testLogData *data = opaque;
noutputs = virLogParseOutputs(data->str, &outputs);
{
int ret = -1;
int nfilters;
- virLogFilterPtr *filters = NULL;
+ virLogFilter **filters = NULL;
const struct testLogData *data = opaque;
nfilters = virLogParseFilters(data->str, &filters);
const char *file;
const char *domain;
const char * const * macs;
- virMacMapPtr mgr;
+ virMacMap *mgr;
};
testMACLookup(const void *opaque)
{
const struct testData *data = opaque;
- virMacMapPtr mgr = NULL;
+ virMacMap *mgr = NULL;
GSList *macs;
GSList *next;
size_t i, j;
testMACRemove(const void *opaque)
{
const struct testData *data = opaque;
- virMacMapPtr mgr = NULL;
+ virMacMap *mgr = NULL;
GSList *macs;
size_t i;
char *file = NULL;
mymain(void)
{
int ret = 0;
- virMacMapPtr mgr = NULL;
+ virMacMap *mgr = NULL;
#define DO_TEST_BASIC(f, d, ...) \
do { \
static void *
-testClientNew(virNetServerClientPtr client G_GNUC_UNUSED,
+testClientNew(virNetServerClient *client G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
struct testClientPriv *priv;
}
-static virJSONValuePtr
-testClientPreExec(virNetServerClientPtr client G_GNUC_UNUSED,
+static virJSONValue *
+testClientPreExec(virNetServerClient *client G_GNUC_UNUSED,
void *data)
{
struct testClientPriv *priv = data;
static void *
-testClientNewPostExec(virNetServerClientPtr client,
- virJSONValuePtr object,
+testClientNewPostExec(virNetServerClient *client,
+ virJSONValue *object,
void *opaque)
{
int magic;
}
-static virNetServerPtr
+static virNetServer *
testCreateServer(const char *server_name, const char *host, int family)
{
- virNetServerPtr srv = NULL;
- virNetServerServicePtr svc1 = NULL;
- virNetServerServicePtr svc2 = NULL;
- virNetServerClientPtr cln1 = NULL;
- virNetServerClientPtr cln2 = NULL;
- virNetSocketPtr sk1 = NULL;
- virNetSocketPtr sk2 = NULL;
+ virNetServer *srv = NULL;
+ virNetServerService *svc1 = NULL;
+ virNetServerService *svc2 = NULL;
+ virNetServerClient *cln1 = NULL;
+ virNetServerClient *cln2 = NULL;
+ virNetSocket *sk1 = NULL;
+ virNetSocket *sk2 = NULL;
int fdclient[2];
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdclient) < 0) {
static char *testGenerateJSON(const char *server_name)
{
- virNetDaemonPtr dmn = NULL;
- virNetServerPtr srv = NULL;
- virJSONValuePtr json = NULL;
+ virNetDaemon *dmn = NULL;
+ virNetServer *srv = NULL;
+ virJSONValue *json = NULL;
char *jsonstr = NULL;
bool has_ipv4, has_ipv6;
bool pass;
};
-static virNetServerPtr
-testNewServerPostExecRestart(virNetDaemonPtr dmn G_GNUC_UNUSED,
+static virNetServer *
+testNewServerPostExecRestart(virNetDaemon *dmn G_GNUC_UNUSED,
const char *name,
- virJSONValuePtr object,
+ virJSONValue *object,
void *opaque)
{
struct testExecRestartData *data = opaque;
{
size_t i;
int ret = -1;
- virNetDaemonPtr dmn = NULL;
+ virNetDaemon *dmn = NULL;
const struct testExecRestartData *data = opaque;
char *infile = NULL, *outfile = NULL;
char *injsonstr = NULL, *outjsonstr = NULL;
- virJSONValuePtr injson = NULL;
- virJSONValuePtr outjson = NULL;
+ virJSONValue *injson = NULL;
+ virJSONValue *outjson = NULL;
int fdclient[2] = { -1, -1 }, fdserver[2] = { -1, -1 };
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdclient) < 0) {
static int testMessageHeaderEncode(const void *args G_GNUC_UNUSED)
{
- virNetMessagePtr msg = virNetMessageNew(true);
+ virNetMessage *msg = virNetMessageNew(true);
static const char expect[] = {
0x00, 0x00, 0x00, 0x1c, /* Length */
0x11, 0x22, 0x33, 0x44, /* Program */
static int testMessageHeaderDecode(const void *args G_GNUC_UNUSED)
{
- virNetMessagePtr msg = virNetMessageNew(true);
+ virNetMessage *msg = virNetMessageNew(true);
static char input_buf [] = {
0x00, 0x00, 0x00, 0x1c, /* Length */
0x11, 0x22, 0x33, 0x44, /* Program */
static int testMessagePayloadEncode(const void *args G_GNUC_UNUSED)
{
virNetMessageError err;
- virNetMessagePtr msg = virNetMessageNew(true);
+ virNetMessage *msg = virNetMessageNew(true);
int ret = -1;
static const char expect[] = {
0x00, 0x00, 0x00, 0x74, /* Length */
static int testMessagePayloadDecode(const void *args G_GNUC_UNUSED)
{
virNetMessageError err;
- virNetMessagePtr msg = virNetMessageNew(true);
+ virNetMessage *msg = virNetMessageNew(true);
static char input_buffer[] = {
0x00, 0x00, 0x00, 0x74, /* Length */
0x11, 0x22, 0x33, 0x44, /* Program */
static int testMessagePayloadStreamEncode(const void *args G_GNUC_UNUSED)
{
char stream[] = "The quick brown fox jumps over the lazy dog";
- virNetMessagePtr msg = virNetMessageNew(true);
+ virNetMessage *msg = virNetMessageNew(true);
static const char expect[] = {
0x00, 0x00, 0x00, 0x47, /* Length */
0x11, 0x22, 0x33, 0x44, /* Program */
return 0;
}
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock G_GNUC_UNUSED,
+int virNetSocketGetUNIXIdentity(virNetSocket *sock G_GNUC_UNUSED,
uid_t *uid,
gid_t *gid,
pid_t *pid,
return strdup("fictionalusers");
}
-int virNetSocketGetSELinuxContext(virNetSocketPtr sock G_GNUC_UNUSED,
+int virNetSocketGetSELinuxContext(virNetSocket *sock G_GNUC_UNUSED,
char **context)
{
if (!(*context = strdup("foo_u:bar_r:wizz_t:s0-s0:c0.c1023")))
#ifndef WIN32
static void *
-testClientNew(virNetServerClientPtr client G_GNUC_UNUSED,
+testClientNew(virNetServerClient *client G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
char *dummy;
{
int sv[2];
int ret = -1;
- virNetSocketPtr sock = NULL;
- virNetServerClientPtr client = NULL;
+ virNetSocket *sock = NULL;
+ virNetServerClient *client = NULL;
g_autoptr(virIdentity) ident = NULL;
const char *gotUsername = NULL;
uid_t gotUserID;
{
struct testClientData *data = opaque;
char c;
- virNetSocketPtr csock = NULL;
+ virNetSocket *csock = NULL;
if (data->path) {
if (virNetSocketNewConnectUNIX(data->path, false,
static void
-testSocketIncoming(virNetSocketPtr sock,
+testSocketIncoming(virNetSocket *sock,
int events G_GNUC_UNUSED,
void *opaque)
{
- virNetSocketPtr *retsock = opaque;
+ virNetSocket **retsock = opaque;
VIR_DEBUG("Incoming sock=%p events=%d", sock, events);
*retsock = sock;
}
static int
testSocketAccept(const void *opaque)
{
- virNetSocketPtr *lsock = NULL; /* Listen socket */
+ virNetSocket **lsock = NULL; /* Listen socket */
size_t nlsock = 0, i;
- virNetSocketPtr ssock = NULL; /* Server socket */
- virNetSocketPtr rsock = NULL; /* Incoming client socket */
+ virNetSocket *ssock = NULL; /* Server socket */
+ virNetSocket *rsock = NULL; /* Incoming client socket */
const struct testSocketData *data = opaque;
int ret = -1;
char portstr[100];
char b = '\0';
if (!data) {
- virNetSocketPtr usock;
+ virNetSocket *usock;
tmpdir = g_mkdtemp(template);
if (tmpdir == NULL) {
VIR_WARN("Failed to create temporary directory");
if (virNetSocketNewListenUNIX(path, 0700, -1, getegid(), &usock) < 0)
goto cleanup;
- lsock = g_new0(virNetSocketPtr, 1);
+ lsock = g_new0(virNetSocket *, 1);
lsock[0] = usock;
nlsock = 1;
#ifndef WIN32
static int testSocketUNIXAddrs(const void *data G_GNUC_UNUSED)
{
- virNetSocketPtr lsock = NULL; /* Listen socket */
- virNetSocketPtr ssock = NULL; /* Server socket */
- virNetSocketPtr csock = NULL; /* Client socket */
+ virNetSocket *lsock = NULL; /* Listen socket */
+ virNetSocket *ssock = NULL; /* Server socket */
+ virNetSocket *csock = NULL; /* Client socket */
int ret = -1;
char *path = NULL;
static int testSocketCommandNormal(const void *data G_GNUC_UNUSED)
{
- virNetSocketPtr csock = NULL; /* Client socket */
+ virNetSocket *csock = NULL; /* Client socket */
char buf[100];
size_t i;
int ret = -1;
- virCommandPtr cmd = virCommandNewArgList("/bin/cat", "/dev/zero", NULL);
+ virCommand *cmd = virCommandNewArgList("/bin/cat", "/dev/zero", NULL);
virCommandAddEnvPassCommon(cmd);
if (virNetSocketNewConnectCommand(cmd, &csock) < 0)
static int testSocketCommandFail(const void *data G_GNUC_UNUSED)
{
- virNetSocketPtr csock = NULL; /* Client socket */
+ virNetSocket *csock = NULL; /* Client socket */
char buf[100];
int ret = -1;
- virCommandPtr cmd = virCommandNewArgList("/bin/cat", "/dev/does-not-exist", NULL);
+ virCommand *cmd = virCommandNewArgList("/bin/cat", "/dev/does-not-exist", NULL);
virCommandAddEnvPassCommon(cmd);
if (virNetSocketNewConnectCommand(cmd, &csock) < 0)
static int testSocketSSH(const void *opaque)
{
const struct testSSHData *data = opaque;
- virNetSocketPtr csock = NULL; /* Client socket */
+ virNetSocket *csock = NULL; /* Client socket */
int ret = -1;
char buf[1024];
g_autofree char *command = virNetClientSSHHelperCommand(VIR_NET_CLIENT_PROXY_AUTO,
*
* This code is done when libvirtd starts up, or before
* a libvirt client connects. The test is ensuring that
- * the creation of virNetTLSContextPtr fails if we
+ * the creation of virNetTLSContext *fails if we
* give bogus certs, or succeeds for good certs
*/
static int testTLSContextInit(const void *opaque)
{
struct testTLSContextData *data = (struct testTLSContextData *)opaque;
- virNetTLSContextPtr ctxt = NULL;
+ virNetTLSContext *ctxt = NULL;
int ret = -1;
if (data->isServer) {
static int testTLSSessionInit(const void *opaque)
{
struct testTLSSessionData *data = (struct testTLSSessionData *)opaque;
- virNetTLSContextPtr clientCtxt = NULL;
- virNetTLSContextPtr serverCtxt = NULL;
- virNetTLSSessionPtr clientSess = NULL;
- virNetTLSSessionPtr serverSess = NULL;
+ virNetTLSContext *clientCtxt = NULL;
+ virNetTLSContext *serverCtxt = NULL;
+ virNetTLSSession *clientSess = NULL;
+ virNetTLSSession *serverSess = NULL;
int ret = -1;
int channel[2];
bool clientShake = false;
virNumaGetMaxNode(void)
{
int ret = -1;
- virBitmapPtr map = NULL;
+ virBitmap *map = NULL;
if (virFileReadValueBitmap(&map, "%s/node/online", SYSFS_SYSTEM_PATH) < 0)
return -1;
virNumaNodeIsAvailable(int node)
{
bool ret = false;
- virBitmapPtr map = NULL;
+ virBitmap *map = NULL;
if (virFileReadValueBitmap(&map, "%s/node/online", SYSFS_SYSTEM_PATH) < 0)
return false;
}
int
-virNumaGetNodeCPUs(int node, virBitmapPtr *cpus)
+virNumaGetNodeCPUs(int node, virBitmap **cpus)
{
int ret = -1;
char *cpulist = NULL;
{
char *actual = NULL;
int ret = -1;
- virNWFilterBindingDefPtr dev = NULL;
+ virNWFilterBindingDef *dev = NULL;
virResetLastError();
# define VIR_FROM_THIS VIR_FROM_NONE
static int
-testVirPCIDeviceCheckDriver(virPCIDevicePtr dev, const char *expected)
+testVirPCIDeviceCheckDriver(virPCIDevice *dev, const char *expected)
{
char *path = NULL;
char *driver = NULL;
testVirPCIDeviceNew(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
const char *devName;
virPCIDeviceAddress devAddr = {.domain = 0, .bus = 0, .slot = 0, .function = 0};
testVirPCIDeviceDetach(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
- virPCIDevicePtr dev[] = {NULL, NULL, NULL};
+ virPCIDevice *dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL;
- virPCIDeviceListPtr inactiveDevs = NULL;
+ virPCIDeviceList *activeDevs = NULL;
+ virPCIDeviceList *inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||
testVirPCIDeviceReset(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
- virPCIDevicePtr dev[] = {NULL, NULL, NULL};
+ virPCIDevice *dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL;
- virPCIDeviceListPtr inactiveDevs = NULL;
+ virPCIDeviceList *activeDevs = NULL;
+ virPCIDeviceList *inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||
testVirPCIDeviceReattach(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
- virPCIDevicePtr dev[] = {NULL, NULL, NULL};
+ virPCIDevice *dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL;
- virPCIDeviceListPtr inactiveDevs = NULL;
+ virPCIDeviceList *activeDevs = NULL;
+ virPCIDeviceList *inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||
{
const struct testPCIDevData *data = opaque;
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
virPCIDeviceAddress devAddr = {.domain = data->domain, .bus = data->bus,
.slot = data->slot, .function = data->function};
{
const struct testPCIDevData *data = opaque;
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
virPCIDeviceAddress devAddr = {.domain = data->domain, .bus = data->bus,
.slot = data->slot, .function = data->function};
{
const struct testPCIDevData *data = opaque;
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
virPCIDeviceAddress devAddr = {.domain = data->domain, .bus = data->bus,
.slot = data->slot, .function = data->function};
{
const struct testPCIDevData *data = opaque;
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
virPCIDeviceAddress devAddr = {.domain = data->domain, .bus = data->bus,
.slot = data->slot, .function = data->function};
{
const struct testPCIDevData *data = opaque;
int ret = -1;
- virPCIDevicePtr dev;
+ virPCIDevice *dev;
virPCIDeviceAddress devAddr = {.domain = data->domain, .bus = data->bus,
.slot = data->slot, .function = data->function};
static int testAllocAll(const void *args G_GNUC_UNUSED)
{
- virPortAllocatorRangePtr ports = virPortAllocatorRangeNew("test", 5900, 5909);
+ virPortAllocatorRange *ports = virPortAllocatorRangeNew("test", 5900, 5909);
int ret = -1;
unsigned short p1 = 0, p2 = 0, p3 = 0, p4 = 0, p5 = 0, p6 = 0, p7 = 0;
static int testAllocReuse(const void *args G_GNUC_UNUSED)
{
- virPortAllocatorRangePtr ports = virPortAllocatorRangeNew("test", 5900, 5910);
+ virPortAllocatorRange *ports = virPortAllocatorRangeNew("test", 5900, 5910);
int ret = -1;
unsigned short p1 = 0, p2 = 0, p3 = 0, p4 = 0;
char *system_dir = NULL;
char *resctrl_dir = NULL;
int ret = -1;
- virResctrlAllocPtr alloc = NULL;
+ virResctrlAlloc *alloc = NULL;
char *schemata_str = NULL;
char *schemata_file;
- virCapsPtr caps = NULL;
+ virCaps *caps = NULL;
system_dir = g_strdup_printf("%s/vircaps2xmldata/linux-%s/system", abs_srcdir,
data->filename);
static int testRotatingFileWriterNew(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterAppend(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterTruncate(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterRolloverNone(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterRolloverOne(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterRolloverAppend(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterRolloverMany(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
char buf[512];
static int testRotatingFileWriterRolloverLineBreak(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
const char *buf = "The quick brown fox jumps over the lazy dog\n"
"The wizard quickly jinxed the gnomes before they vaporized\n";
static int testRotatingFileWriterLargeFile(const void *data G_GNUC_UNUSED)
{
- virRotatingFileWriterPtr file;
+ virRotatingFileWriter *file;
int ret = -1;
const char *buf = "The quick brown fox jumps over the lazy dog\n"
"The wizard quickly jinxed the gnomes before they vaporized\n";
static int testRotatingFileReaderOne(const void *data G_GNUC_UNUSED)
{
- virRotatingFileReaderPtr file;
+ virRotatingFileReader *file;
int ret = -1;
char buf[512];
ssize_t got;
static int testRotatingFileReaderAll(const void *data G_GNUC_UNUSED)
{
- virRotatingFileReaderPtr file;
+ virRotatingFileReader *file;
int ret = -1;
char buf[768];
ssize_t got;
static int testRotatingFileReaderPartial(const void *data G_GNUC_UNUSED)
{
- virRotatingFileReaderPtr file;
+ virRotatingFileReader *file;
int ret = -1;
char buf[600];
ssize_t got;
static int testRotatingFileReaderSeek(const void *data G_GNUC_UNUSED)
{
- virRotatingFileReaderPtr file;
+ virRotatingFileReader *file;
int ret = -1;
char buf[600];
ssize_t got;
struct testSchemaData {
- virXMLValidatorPtr validator;
+ virXMLValidator *validator;
const char *xml_path;
};
static int
testSchemaFile(const char *schema,
- virXMLValidatorPtr validator,
+ virXMLValidator *validator,
const char *path)
{
g_autofree char *test_name = NULL;
static int
testSchemaDir(const char *schema,
- virXMLValidatorPtr validator,
+ virXMLValidator *validator,
const char *dir_path,
const char *filterstr)
{
return 0;
}
-static virXMLValidatorPtr
+static virXMLValidator *
testSchemaGrammarLoad(const char *schema)
{
g_autofree char *schema_path = NULL;
g_autofree char *testname = NULL;
- virXMLValidatorPtr ret;
+ virXMLValidator *ret;
schema_path = g_strdup_printf("%s/%s", abs_top_srcdir, schema);
static int
test2(const void *data G_GNUC_UNUSED)
{
- virSCSIDeviceListPtr list = NULL;
- virSCSIDevicePtr dev = NULL;
- virSCSIDevicePtr dev1 = NULL;
+ virSCSIDeviceList *list = NULL;
+ virSCSIDevice *dev = NULL;
+ virSCSIDevice *dev1 = NULL;
bool free_dev = true;
bool free_dev1 = true;
- virSCSIDevicePtr tmp = NULL;
+ virSCSIDevice *tmp = NULL;
char *sgname = NULL;
int ret = -1;
}
-static virStorageSourcePtr
+static virStorageSource *
testStorageFileGetMetadata(const char *path,
int format,
uid_t uid, gid_t gid)
testStorageChain(const void *args)
{
const struct testChainData *data = args;
- virStorageSourcePtr elt;
+ virStorageSource *elt;
size_t i = 0;
g_autoptr(virStorageSource) meta = NULL;
struct testLookupData
{
- virStorageSourcePtr chain;
+ virStorageSource *chain;
const char *target;
- virStorageSourcePtr from;
+ virStorageSource *from;
const char *name;
unsigned int expIndex;
const char *expResult;
- virStorageSourcePtr expMeta;
- virStorageSourcePtr expParent;
+ virStorageSource *expMeta;
+ virStorageSource *expParent;
};
static int
{
const struct testLookupData *data = args;
int ret = 0;
- virStorageSourcePtr result;
- virStorageSourcePtr actualParent;
+ virStorageSource *result;
+ virStorageSource *actualParent;
result = virStorageSourceChainLookup(data->chain, data->from,
data->name, data->target, &actualParent);
struct testPathRelativeBacking
{
- virStorageSourcePtr top;
- virStorageSourcePtr base;
+ virStorageSource *top;
+ virStorageSource *base;
const char *expect;
};
struct testLookupData data2;
struct testPathRelativeBacking data4;
struct testBackingParseData data5;
- virStorageSourcePtr chain2; /* short for chain->backingStore */
- virStorageSourcePtr chain3; /* short for chain2->backingStore */
+ virStorageSource *chain2; /* short for chain->backingStore */
+ virStorageSource *chain3; /* short for chain2->backingStore */
g_autoptr(virCommand) cmd = NULL;
g_autoptr(virStorageSource) chain = NULL;
static int
-testActivationCreateFDs(virNetSocketPtr *sockUNIX,
- virNetSocketPtr **sockIP,
+testActivationCreateFDs(virNetSocket **sockUNIX,
+ virNetSocket ***sockIP,
size_t *nsockIP)
{
*sockUNIX = NULL;
static int
testActivation(bool useNames)
{
- virNetSocketPtr sockUNIX;
- virNetSocketPtr *sockIP;
+ virNetSocket *sockUNIX;
+ virNetSocket **sockIP;
size_t nsockIP;
int ret = -1;
size_t i;
static int
testActivationEmpty(const void *opaque G_GNUC_UNUSED)
{
- virSystemdActivationPtr act;
+ virSystemdActivation *act;
g_unsetenv("LISTEN_FDS");
const char *query;
const char *fragment;
const char *user;
- virURIParamPtr params;
+ virURIParam *params;
};
static int testURIParse(const void *args)
{
int ret = -1;
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
const struct URIParseData *data = args;
char *uristr = NULL;
size_t i;
bool expectFailure;
};
-static int testDeviceFileActor(virUSBDevicePtr dev,
+static int testDeviceFileActor(virUSBDevice *dev,
const char *path,
void *opaque G_GNUC_UNUSED)
{
{
const struct findTestInfo *info = opaque;
int ret = -1;
- virUSBDevicePtr dev = NULL;
- virUSBDeviceListPtr devs = NULL;
+ virUSBDevice *dev = NULL;
+ virUSBDeviceList *devs = NULL;
int rv = 0;
size_t i, ndevs = 0;
ndevs = virUSBDeviceListCount(devs);
for (i = 0; i < ndevs; i++) {
- virUSBDevicePtr device = virUSBDeviceListGet(devs, i);
+ virUSBDevice *device = virUSBDeviceListGet(devs, i);
if (virUSBDeviceFileIterate(device, testDeviceFileActor, NULL) < 0)
goto cleanup;
}
static int
testUSBList(const void *opaque G_GNUC_UNUSED)
{
- virUSBDeviceListPtr list = NULL;
- virUSBDeviceListPtr devlist = NULL;
- virUSBDevicePtr dev = NULL;
+ virUSBDeviceList *list = NULL;
+ virUSBDeviceList *devlist = NULL;
+ virUSBDevice *dev = NULL;
int ret = -1;
size_t i, ndevs;
# define VIR_FROM_THIS VIR_FROM_VMWARE
-static virCapsPtr caps;
-static virDomainXMLOptionPtr xmlopt;
+static virCaps *caps;
+static virDomainXMLOption *xmlopt;
static virVMXContext ctx;
static void
testCapsInit(void)
{
- virCapsGuestPtr guest = NULL;
+ virCapsGuest *guest = NULL;
caps = virCapabilitiesNew(VIR_ARCH_I686, true, true);
int ret = -1;
char *vmxData = NULL;
char *formatted = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
if (virTestLoadFile(vmx, &vmxData) < 0)
return -1;
" 1 fedora28 running\n"
" 2 rhel7.5 running\n";
- vshTablePtr table = vshTableNew("Id", "Name", "State",
+ vshTable *table = vshTableNew("Id", "Name", "State",
NULL); //to ask about return
if (!table)
goto cleanup;
{
int ret = 0;
- vshTablePtr table = vshTableNew("Id", "Name", NULL);
+ vshTable *table = vshTableNew("Id", "Name", NULL);
if (!table)
goto cleanup;
"-----------------------------------------\n"
" 1 fedora28 running\n"
" 2 つへソrhel7.5つへソ running\n";
- vshTablePtr table;
+ vshTable *table;
table = vshTableNew("Id", "名稱", "государство", NULL);
if (!table)
"-------------------------------------------------------------------------------------------\n"
" 1 ﻉﺪﻴﻟ ﺎﻠﺜﻘﻴﻟ ﻕﺎﻣ ﻊﻧ, ٣٠ ﻎﻴﻨﻳﺍ ﻮﺘﻧﺎﻤﺗ ﺎﻠﺛﺎﻠﺛ، ﺄﺳﺭ, ﺩﻮﻟ ﺩﻮﻟ. ﺄﻣﺎﻣ ﺍ ﺎﻧ ﻲﻜﻧ\n"
" ﺺﻔﺣﺓ ﺖﻜﺘﻴﻛﺍً ﻊﻟ, ﺎﻠﺠﻧﻭﺩ ﻭﺎﻠﻌﺗﺍﺩ ﺵﺭ\n";
- vshTablePtr table;
+ vshTable *table;
wchar_t wc;
/* If this char is not classed as printable, the actual
testUnicodeZeroWidthChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
const char *exp =
" I\u200Bd Name \u200BStatus\n"
"--------------------------\n"
testUnicodeCombiningChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
const char *exp =
" Id Náme Ⓢtatus\n"
"--------------------------\n"
testUnicodeNonPrintableChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
const char *exp =
" I\\x09d Name Status\n"
"----------------------------------\n"
testNTables(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
- vshTablePtr table1 = NULL;
- vshTablePtr table2 = NULL;
- vshTablePtr table3 = NULL;
+ vshTable *table1 = NULL;
+ vshTable *table2 = NULL;
+ vshTable *table3 = NULL;
const char *exp1 =
" Id Name Status\n"
"--------------------------\n"
#define VIR_FROM_THIS VIR_FROM_NONE
-static libxlDriverPrivatePtr driver;
+static libxlDriverPrivate *driver;
/*
* This function provides a mechanism to replace variables in test
virConnectPtr conn = NULL;
int wrote = 4096;
int ret = -1;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *replacedXML = NULL;
gotxlcfgData = g_new0(char, wrote);
g_autoptr(virConf) conf = NULL;
int ret = -1;
virConnectPtr conn;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
char *replacedXML = NULL;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
#define VIR_FROM_THIS VIR_FROM_NONE
-static libxlDriverPrivatePtr driver;
+static libxlDriverPrivate *driver;
static int
testCompareParseXML(const char *xmcfg, const char *xml)
int ret = -1;
virConnectPtr conn = NULL;
int wrote = 4096;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
gotxmcfgData = g_new0(char, wrote);
char *gotxml = NULL;
g_autoptr(virConf) conf = NULL;
int ret = -1;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver);
if (virTestLoadFile(xmcfg, &xmcfgData) < 0)
# define VIR_FROM_THIS VIR_FROM_VMWARE
-static virCapsPtr caps;
+static virCaps *caps;
static virVMXContext ctx;
-static virDomainXMLOptionPtr xmlopt;
+static virDomainXMLOption *xmlopt;
static void
testCapsInit(void)
{
- virCapsGuestPtr guest = NULL;
+ virCapsGuest *guest = NULL;
caps = virCapabilitiesNew(VIR_ARCH_I686, true, true);
{
int result = -1;
char *formatted = NULL;
- virDomainDefPtr def = NULL;
+ virDomainDef *def = NULL;
def = virDomainDefParseFile(xml, xmlopt, NULL,
VIR_DOMAIN_DEF_PARSE_INACTIVE);
}
static int
-testAutodetectSCSIControllerModel(virDomainDiskDefPtr def G_GNUC_UNUSED,
+testAutodetectSCSIControllerModel(virDomainDiskDef *def G_GNUC_UNUSED,
int *model, void *opaque G_GNUC_UNUSED)
{
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
*/
static int
virshParseCheckpointDiskspec(vshControl *ctl,
- virBufferPtr buf,
+ virBuffer *buf,
const char *str)
{
int ret = -1;
struct virshChk *chks;
int nchks;
};
-typedef struct virshCheckpointList *virshCheckpointListPtr;
static void
-virshCheckpointListFree(virshCheckpointListPtr checkpointlist)
+virshCheckpointListFree(struct virshCheckpointList *checkpointlist)
{
size_t i;
* list is limited to descendants of the given checkpoint. If FLAGS is
* given, the list is filtered. If TREE is specified, then all but
* FROM or the roots will also have parent information. */
-static virshCheckpointListPtr
+static struct virshCheckpointList *
virshCheckpointListCollect(vshControl *ctl,
virDomainPtr dom,
virDomainCheckpointPtr from,
size_t i;
int count = -1;
virDomainCheckpointPtr *chks;
- virshCheckpointListPtr checkpointlist = NULL;
- virshCheckpointListPtr ret = NULL;
+ struct virshCheckpointList *checkpointlist = NULL;
+ struct virshCheckpointList *ret = NULL;
unsigned int flags = orig_flags;
checkpointlist = g_new0(struct virshCheckpointList, 1);
bool parent,
void *opaque)
{
- virshCheckpointListPtr checkpointlist = opaque;
+ struct virshCheckpointList *checkpointlist = opaque;
if (parent)
return checkpointlist->chks[id].parent;
return virDomainCheckpointGetName(checkpointlist->chks[id].chk);
const char *from_chk = NULL;
char *parent_chk = NULL;
virDomainCheckpointPtr start = NULL;
- virshCheckpointListPtr checkpointlist = NULL;
- vshTablePtr table = NULL;
+ struct virshCheckpointList *checkpointlist = NULL;
+ vshTable *table = NULL;
VSH_EXCLUSIVE_OPTIONS_VAR(tree, name);
VSH_EXCLUSIVE_OPTIONS_VAR(parent, roots);
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virDomainPtr dom = NULL;
virDomainCheckpointPtr *checkpoints = NULL;
int ncheckpoints = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virDomainPtr *domains = NULL;
int ndomains = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virDomainPtr *domains = NULL;
int ndomains = 0;
size_t i = 0;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_autoptr(xmlDoc) xmldoc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int ninterfaces;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_autoptr(xmlDoc) xmldoc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
g_autofree xmlNodePtr *disks = NULL;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
const char *iface = NULL;
g_autoptr(xmlDoc) xml = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_autoptr(xmlDoc) xmldoc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int naliases;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
size_t i;
int cpunum;
g_autofree unsigned char *cpumap = NULL;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_autoptr(xmlDoc) xmldoc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
int nserials;
unsigned int flags)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
int npages = 0;
g_autofree xmlNodePtr *pages = NULL;
g_autoptr(xmlDoc) doc = NULL;
unsigned int flags)
{
g_autoptr(xmlXPathContext) ctxt = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
int ncells = 0;
g_autofree xmlNodePtr *cells = NULL;
g_autoptr(xmlDoc) doc = NULL;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_auto(GStrv) tmp = NULL;
size_t i;
int cpunum;
unsigned int flags,
virInterfaceStringCallback cb)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virInterfacePtr *ifaces = NULL;
int nifaces = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNetworkPtr *nets = NULL;
int nnets = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNetworkPtr net = NULL;
virNetworkPortPtr *ports = NULL;
int nports = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNetworkPtr *nets = NULL;
int nnets = 0;
size_t i = 0;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNetworkDHCPLeasePtr *leases = NULL;
virNetworkPtr network = NULL;
int nleases;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNodeDevicePtr *devs = NULL;
int ndevs = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNWFilterPtr *nwfilters = NULL;
int nnwfilters = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virNWFilterBindingPtr *bindings = NULL;
int nbindings = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virStoragePoolPtr *pools = NULL;
int npools = 0;
size_t i = 0;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virSecretPtr *secrets = NULL;
int nsecrets = 0;
size_t i = 0;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virDomainPtr dom = NULL;
virDomainSnapshotPtr *snapshots = NULL;
int rc;
const vshCmd *cmd,
unsigned int flags)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virStoragePoolPtr pool = NULL;
virStorageVolPtr *vols = NULL;
int rc;
typedef struct virConsole virConsole;
-typedef virConsole *virConsolePtr;
struct virConsole {
virObjectLockable parent;
virError error;
};
-static virClassPtr virConsoleClass;
+static virClass *virConsoleClass;
static void virConsoleDispose(void *obj);
static int
static void
-virConsoleShutdown(virConsolePtr con,
+virConsoleShutdown(virConsole *con,
bool graceful)
{
virErrorPtr err = virGetLastError();
static void
virConsoleDispose(void *obj)
{
- virConsolePtr con = obj;
+ virConsole *con = obj;
if (con->st)
virStreamFree(con->st);
virConsoleEventOnStream(virStreamPtr st,
int events, void *opaque)
{
- virConsolePtr con = opaque;
+ virConsole *con = opaque;
virObjectLock(con);
int events,
void *opaque)
{
- virConsolePtr con = opaque;
+ virConsole *con = opaque;
virObjectLock(con);
int events,
void *opaque)
{
- virConsolePtr con = opaque;
+ virConsole *con = opaque;
virObjectLock(con);
}
-static virConsolePtr
+static virConsole *
virConsoleNew(void)
{
- virConsolePtr con;
+ virConsole *con;
if (virConsoleInitialize() < 0)
return NULL;
const char *dev_name,
unsigned int flags)
{
- virConsolePtr con = NULL;
- virshControlPtr priv = ctl->privData;
+ virConsole *con = NULL;
+ virshControl *priv = ctl->privData;
int ret = -1;
struct sigaction old_sigquit;
char *cap = NULL;
char *alloc = NULL;
char *phy = NULL;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
VSH_EXCLUSIVE_OPTIONS("all", "device");
char *device = NULL;
char *target = NULL;
char *source = NULL;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (vshCommandOptBool(cmd, "inactive"))
flags |= VIR_DOMAIN_XML_INACTIVE;
int ninterfaces;
xmlNodePtr *interfaces = NULL;
size_t i;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (vshCommandOptBool(cmd, "inactive"))
flags |= VIR_DOMAIN_XML_INACTIVE;
unsigned int id;
char *str, uuid[VIR_UUID_STRING_BUFLEN];
int has_managed_save = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_auto(GStrv) messages = NULL;
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
virDomainPtr *domains;
size_t ndomains;
};
-typedef struct virshDomainList *virshDomainListPtr;
static void
-virshDomainListFree(virshDomainListPtr domlist)
+virshDomainListFree(struct virshDomainList *domlist)
{
size_t i;
g_free(domlist);
}
-static virshDomainListPtr
+static struct virshDomainList *
virshDomainListCollect(vshControl *ctl, unsigned int flags)
{
- virshDomainListPtr list = g_new0(struct virshDomainList, 1);
+ struct virshDomainList *list = g_new0(struct virshDomainList, 1);
size_t i;
int ret;
int *ids = NULL;
int nsnap;
int nchk;
int mansave;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.9.13 and later) */
if ((ret = virConnectListAllDomains(priv->conn, &list->domains,
char uuid[VIR_UUID_STRING_BUFLEN];
int state;
bool ret = false;
- virshDomainListPtr list = NULL;
+ struct virshDomainList *list = NULL;
virDomainPtr dom;
char id_buf[VIR_INT64_STR_BUFLEN];
unsigned int id;
unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
/* construct filter flags */
if (vshCommandOptBool(cmd, "inactive") ||
int flags = 0;
const vshCmdOpt *opt = NULL;
bool ret = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "state"))
stats |= VIR_DOMAIN_STATS_STATE;
static void
-virshAddressFormat(virBufferPtr buf,
+virshAddressFormat(virBuffer *buf,
struct virshAddress *addr)
{
switch ((enum virshAddressType) addr->type) {
static int
cmdAttachDiskFormatAddress(vshControl *ctl,
- virBufferPtr buf,
+ virBuffer *buf,
const char *straddr,
const char *target,
bool multifunction)
static int
virshParseRateStr(vshControl *ctl,
const char *rateStr,
- virNetDevBandwidthRatePtr rate)
+ virNetDevBandwidthRate *rate)
{
g_auto(GStrv) tok = NULL;
size_t ntok;
typedef struct _virshBlockJobWaitData virshBlockJobWaitData;
-typedef virshBlockJobWaitData *virshBlockJobWaitDataPtr;
struct _virshBlockJobWaitData {
vshControl *ctl;
virDomainPtr dom;
int status,
void *opaque)
{
- virshBlockJobWaitDataPtr data = opaque;
+ virshBlockJobWaitData *data = opaque;
if (STREQ_NULLABLE(disk, data->dev))
data->status = status;
* Returns the data structure that holds data needed for block job waiting or
* NULL in case of error.
*/
-static virshBlockJobWaitDataPtr
+static virshBlockJobWaitData *
virshBlockJobWaitInit(vshControl *ctl,
virDomainPtr dom,
const char *dev,
bool async_abort)
{
virConnectDomainEventGenericCallback cb;
- virshBlockJobWaitDataPtr ret;
- virshControlPtr priv = ctl->privData;
+ virshBlockJobWaitData *ret;
+ virshControl *priv = ctl->privData;
ret = g_new0(virshBlockJobWaitData, 1);
static void
-virshBlockJobWaitFree(virshBlockJobWaitDataPtr data)
+virshBlockJobWaitFree(virshBlockJobWaitData *data)
{
- virshControlPtr priv = NULL;
+ virshControl *priv = NULL;
if (!data)
return;
* VIR_DOMAIN_BLOCK_JOB_READY if the block job reaches 100%.
*/
static int
-virshBlockJobWait(virshBlockJobWaitDataPtr data)
+virshBlockJobWait(virshBlockJobWaitData *data)
{
/* For two phase jobs like active commit or block copy, the marker reaches
* 100% and an event fires. In case where virsh would not be able to match
int abort_flags = 0;
unsigned int flags = 0;
unsigned long bandwidth = 0;
- virshBlockJobWaitDataPtr bjWait = NULL;
+ virshBlockJobWaitData *bjWait = NULL;
VSH_EXCLUSIVE_OPTIONS("pivot", "keep-overlay");
const char *xml = NULL;
char *xmlstr = NULL;
virTypedParameterPtr params = NULL;
- virshBlockJobWaitDataPtr bjWait = NULL;
+ virshBlockJobWaitData *bjWait = NULL;
int nparams = 0;
if (vshCommandOptStringReq(ctl, cmd, "path", &path) < 0)
bool bytes)
{
virDomainBlockJobInfo info;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
unsigned long long speed;
unsigned int flags = 0;
int rc = -1;
const char *base = NULL;
unsigned long bandwidth = 0;
unsigned int flags = 0;
- virshBlockJobWaitDataPtr bjWait = NULL;
+ virshBlockJobWaitData *bjWait = NULL;
VSH_REQUIRE_OPTION("verbose", "wait");
VSH_REQUIRE_OPTION("async", "wait");
unsigned int flags)
{
int state;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if ((state = virshDomainState(ctl, dom, NULL)) < 0) {
vshError(ctl, "%s", _("Unable to get domain status"));
char *pool = NULL;
size_t i;
size_t j;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_REQUIRE_OPTION("delete-storage-volume-snapshots", "remove-all-storage");
VSH_EXCLUSIVE_OPTIONS("nvram", "keep-nvram");
bool ret = false;
unsigned int flags = 0;
char *xml = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "security-info"))
flags |= VIR_DOMAIN_XML_SECURE;
const char *xmlfile = NULL;
char *xml = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "running"))
flags |= VIR_DOMAIN_SAVE_RUNNING;
bool ret = false;
unsigned int getxml_flags = VIR_DOMAIN_XML_SECURE;
unsigned int define_flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "running"))
define_flags |= VIR_DOMAIN_SAVE_RUNNING;
unsigned int flags = 0;
const char *xmlfile = NULL;
char *xml = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
bool created = false;
bool generated = false;
char *mime = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virshStreamCallbackData cbdata;
if (vshCommandOptStringReq(ctl, cmd, "file", (const char **) &file) < 0)
}
-static virBitmapPtr
+static virBitmap *
virshDomainGetVcpuBitmap(vshControl *ctl,
virDomainPtr dom,
bool inactive)
{
unsigned int flags = 0;
- virBitmapPtr ret = NULL;
+ virBitmap *ret = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr *nodes = NULL;
size_t cpumaplen;
bool pretty = vshCommandOptBool(cmd, "pretty");
int n;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
size_t i;
int ncpus;
bool ret = false;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if ((ncpus = virshCPUCountCollect(ctl, dom, countFlags, true)) < 0) {
if (ncpus == -1) {
const char *cpulist, int maxcpu)
{
unsigned char *cpumap = NULL;
- virBitmapPtr map = NULL;
+ virBitmap *map = NULL;
if (cpulist[0] == 'r') {
map = virBitmapNew(maxcpu);
bool current = vshCommandOptBool(cmd, "current");
int got_vcpu;
unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(current, live);
VSH_EXCLUSIVE_OPTIONS_VAR(current, config);
bool current = vshCommandOptBool(cmd, "current");
bool query = false; /* Query mode if no cpulist */
unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(current, live);
VSH_EXCLUSIVE_OPTIONS_VAR(current, config);
virDomainIOThreadInfoPtr *info = NULL;
size_t i;
unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
bool ret = false;
int rc;
unsigned char *cpumap = NULL;
int cpumaplen;
unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(current, live);
VSH_EXCLUSIVE_OPTIONS_VAR(current, config);
unsigned int flags = 0;
size_t nfds = 0;
int *fds = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
bool ret = true;
char *buffer;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool pretty = vshCommandOptBool(cmd, "pretty");
bool returnval = vshCommandOptBool(cmd, "return-value");
- virJSONValuePtr formatjson;
+ virJSONValue *formatjson;
g_autofree char *jsonstr = NULL;
VSH_EXCLUSIVE_OPTIONS("hmp", "pretty");
void *opaque)
{
virshQemuEventData *data = opaque;
- virJSONValuePtr pretty = NULL;
+ virJSONValue *pretty = NULL;
char *str = NULL;
if (!data->loop && data->count)
int timeout = 0;
const char *event = NULL;
virshQemuEventData data;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "regex"))
flags |= VIR_CONNECT_DOMAIN_QEMU_MONITOR_EVENT_REGISTER_REGEX;
virDomainPtr dom = NULL;
unsigned int flags = 0;
unsigned int pid_value; /* API uses unsigned int, not pid_t */
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptUInt(ctl, cmd, "pid", &pid_value) <= 0)
return false;
unsigned int flags = 0;
const vshCmdOpt *opt = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virJSONValuePtr pretty = NULL;
+ virJSONValue *pretty = NULL;
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
bool setlabel = true;
virSecurityModelPtr secmodel = NULL;
virSecurityLabelPtr seclabel = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
char *configData;
char *xmlData;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "format", &format) < 0 ||
vshCommandOptStringReq(ctl, cmd, "config", &configFile) < 0)
char *configData = NULL;
char *xmlData = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virDomainPtr dom = NULL;
if (vshCommandOptStringReq(ctl, cmd, "format", &format) < 0 ||
unsigned int timeout = 0;
virshMigrateTimeoutAction timeoutAction = VIRSH_MIGRATE_TIMEOUT_DEFAULT;
bool live_flag = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
int iterEvent = -1;
g_autoptr(GMainContext) eventCtxt = g_main_context_new();
g_autoptr(GMainLoop) eventLoop = g_main_loop_new(eventCtxt, FALSE);
if (virSocketAddrParse(&addr, listen_addr, AF_UNSPEC) > 0 &&
virSocketAddrIsWildcard(&addr)) {
- virConnectPtr conn = ((virshControlPtr)(ctl->privData))->conn;
+ virConnectPtr conn = ((virshControl *)(ctl->privData))->conn;
char *uriStr = virConnectGetURI(conn);
- virURIPtr uri = NULL;
+ virURI *uri = NULL;
if (uriStr) {
uri = virURIParse(uriStr);
virDomainPtr dom_edited = NULL;
unsigned int query_flags = VIR_DOMAIN_XML_SECURE | VIR_DOMAIN_XML_INACTIVE;
unsigned int define_flags = VIR_DOMAIN_DEFINE_VALIDATE;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
*/
static void
virshEventPrint(virshDomEventData *data,
- virBufferPtr buf)
+ virBuffer *buf)
{
char *msg;
bool loop = vshCommandOptBool(cmd, "loop");
bool timestamp = vshCommandOptBool(cmd, "timestamp");
int count = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS("all", "event");
VSH_EXCLUSIVE_OPTIONS("list", "all");
int rc = -1;
size_t i, j;
virDomainFSInfoPtr *info = NULL;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
size_t ninfos = 0;
bool ret = false;
cmdCapabilities(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
char *caps;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if ((caps = virConnectGetCapabilities(priv->conn)) == NULL) {
vshError(ctl, "%s", _("failed to get capabilities"));
const char *arch = NULL;
const char *machine = NULL;
const unsigned int flags = 0; /* No flags so far */
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "virttype", &virttype) < 0 ||
vshCommandOptStringReq(ctl, cmd, "emulatorbin", &emulatorbin) < 0 ||
char *cap_xml = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
bool all = vshCommandOptBool(cmd, "all");
bool cellno = vshCommandOptBool(cmd, "cellno");
bool pagesz = vshCommandOptBool(cmd, "pagesize");
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr *nodes = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
char *caps = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
bool ret = false;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0)
cmdNodeinfo(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
virNodeInfo info;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (virNodeGetInfo(priv->conn, &info) < 0) {
vshError(ctl, "%s", _("failed to get node information"));
unsigned int online;
bool pretty = vshCommandOptBool(cmd, "pretty");
bool ret = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
cpunum = virNodeGetCPUMap(priv->conn, &cpumap, &online, 0);
if (cpunum < 0) {
bool ret = false;
unsigned long long cpu_stats[VIRSH_CPU_LAST] = { 0 };
bool present[VIRSH_CPU_LAST] = { false };
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptInt(ctl, cmd, "cpu", &cpuNum) < 0)
return false;
int cellNum = VIR_NODE_MEMORY_STATS_ALL_CELLS;
virNodeMemoryStatsPtr params = NULL;
bool ret = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptInt(ctl, cmd, "cell", &cellNum) < 0)
return false;
const char *target = NULL;
unsigned int suspendTarget;
long long duration;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "target", &target) < 0)
return false;
cmdSysinfo(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
char *sysinfo;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
sysinfo = virConnectGetSysinfo(priv->conn, 0);
if (sysinfo == NULL) {
cmdHostname(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
char *hostname;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
hostname = virConnectGetHostname(priv->conn);
if (hostname == NULL) {
cmdURI(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
char *uri;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
uri = virConnectGetURI(priv->conn);
if (uri == NULL) {
int result;
char **cpus = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "error"))
flags |= VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE;
char *result = NULL;
char **list = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "features"))
flags |= VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES;
size_t i;
int nmodels;
const char *arch = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "arch", &arch) < 0)
return false;
unsigned int major;
unsigned int minor;
unsigned int rel;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
hvType = virConnectGetType(priv->conn);
if (hvType == NULL) {
bool ret = false;
int rc = -1;
size_t i;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if ((rc = vshCommandOptUInt(ctl, cmd, "shm-pages-to-scan", &value)) < 0) {
goto cleanup;
int result;
char **cpus = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "error"))
flags |= VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE;
char *result = NULL;
char **list = NULL;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "features"))
flags |= VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES;
const char *n = NULL;
bool is_mac = false;
virMacAddr dummy;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYNAME | VIRSH_BYMAC, NULL);
virInterfacePtr iface = NULL;
virInterfacePtr iface_edited = NULL;
unsigned int flags = VIR_INTERFACE_XML_INACTIVE;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
iface = virshCommandOptInterface(ctl, cmd, NULL);
if (iface == NULL)
virInterfacePtr *ifaces;
size_t nifaces;
};
-typedef struct virshInterfaceList *virshInterfaceListPtr;
static void
-virshInterfaceListFree(virshInterfaceListPtr list)
+virshInterfaceListFree(struct virshInterfaceList *list)
{
size_t i;
g_free(list);
}
-static virshInterfaceListPtr
+static struct virshInterfaceList *
virshInterfaceListCollect(vshControl *ctl,
unsigned int flags)
{
- virshInterfaceListPtr list = g_new0(struct virshInterfaceList, 1);
+ struct virshInterfaceList *list = g_new0(struct virshInterfaceList, 1);
size_t i;
int ret;
char **activeNames = NULL;
int nActiveIfaces = 0;
int nInactiveIfaces = 0;
int nAllIfaces = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllInterfaces(priv->conn,
bool inactive = vshCommandOptBool(cmd, "inactive");
bool all = vshCommandOptBool(cmd, "all");
unsigned int flags = VIR_CONNECT_LIST_INTERFACES_ACTIVE;
- virshInterfaceListPtr list = NULL;
+ struct virshInterfaceList *list = NULL;
size_t i;
bool ret = false;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
VSH_EXCLUSIVE_OPTIONS_VAR(all, inactive);
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
static bool
cmdInterfaceBegin(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (virInterfaceChangeBegin(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to begin network config change transaction"));
static bool
cmdInterfaceCommit(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (virInterfaceChangeCommit(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to commit network config change transaction"));
static bool
cmdInterfaceRollback(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (virInterfaceChangeRollback(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to rollback network config change transaction"));
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr top_node, br_node, if_node, cur;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* Get a handle to the original device */
if (!(if_handle = virshCommandOptInterfaceBy(ctl, cmd, "interface",
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr top_node, if_node, cur;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* Get a handle to the original device */
if (!(br_handle = virshCommandOptInterfaceBy(ctl, cmd, "bridge",
virNetworkPtr network = NULL;
const char *n = NULL;
const char *optname = "network";
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
virNetworkPtr *nets;
size_t nnets;
};
-typedef struct virshNetworkList *virshNetworkListPtr;
static void
-virshNetworkListFree(virshNetworkListPtr list)
+virshNetworkListFree(struct virshNetworkList *list)
{
size_t i;
g_free(list);
}
-static virshNetworkListPtr
+static struct virshNetworkList *
virshNetworkListCollect(vshControl *ctl,
unsigned int flags)
{
- virshNetworkListPtr list = g_new0(struct virshNetworkList, 1);
+ struct virshNetworkList *list = g_new0(struct virshNetworkList, 1);
size_t i;
int ret;
char **names = NULL;
int nActiveNets = 0;
int nInactiveNets = 0;
int nAllNets = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNetworks(priv->conn,
static bool
cmdNetworkList(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
- virshNetworkListPtr list = NULL;
+ struct virshNetworkList *list = NULL;
size_t i;
bool ret = false;
bool optName = vshCommandOptBool(cmd, "name");
bool optUUID = vshCommandOptBool(cmd, "uuid");
char uuid[VIR_UUID_STRING_BUFLEN];
unsigned int flags = VIR_CONNECT_LIST_NETWORKS_ACTIVE;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (vshCommandOptBool(cmd, "inactive"))
flags = VIR_CONNECT_LIST_NETWORKS_INACTIVE;
bool ret = false;
virNetworkPtr network = NULL;
virNetworkPtr network_edited = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
network = virshCommandOptNetwork(ctl, cmd, NULL);
if (network == NULL)
virshNetEventData data;
const char *eventName = NULL;
int event;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "list")) {
size_t i;
size_t i;
unsigned int flags = 0;
virNetworkPtr network = NULL;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (vshCommandOptStringReq(ctl, cmd, "mac", &mac) < 0)
return false;
virNetworkPortPtr *ports;
size_t nports;
};
-typedef struct virshNetworkPortList *virshNetworkPortListPtr;
static void
-virshNetworkPortListFree(virshNetworkPortListPtr list)
+virshNetworkPortListFree(struct virshNetworkPortList *list)
{
size_t i;
g_free(list);
}
-static virshNetworkPortListPtr
+static struct virshNetworkPortList *
virshNetworkPortListCollect(vshControl *ctl,
const vshCmd *cmd,
unsigned int flags)
{
- virshNetworkPortListPtr list = g_new0(struct virshNetworkPortList, 1);
+ struct virshNetworkPortList *list = g_new0(struct virshNetworkPortList, 1);
int ret;
virNetworkPtr network = NULL;
bool success = false;
static bool
cmdNetworkPortList(vshControl *ctl, const vshCmd *cmd)
{
- virshNetworkPortListPtr list = NULL;
+ struct virshNetworkPortList *list = NULL;
size_t i;
bool ret = false;
bool optTable = vshCommandOptBool(cmd, "table");
bool optUUID = vshCommandOptBool(cmd, "uuid");
char uuid[VIR_UUID_STRING_BUFLEN];
unsigned int flags = 0;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (optTable + optUUID > 1) {
vshError(ctl, "%s",
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
virNodeDevicePtr dev = NULL;
char **arr = NULL;
int narr;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (strchr(value, ',')) {
narr = vshStringToArray(value, &arr);
virNodeDevicePtr *devices;
size_t ndevices;
};
-typedef struct virshNodeDeviceList *virshNodeDeviceListPtr;
static void
-virshNodeDeviceListFree(virshNodeDeviceListPtr list)
+virshNodeDeviceListFree(struct virshNodeDeviceList *list)
{
size_t i;
g_free(list);
}
-static virshNodeDeviceListPtr
+static struct virshNodeDeviceList *
virshNodeDeviceListCollect(vshControl *ctl,
char **capnames,
int ncapnames,
unsigned int flags)
{
- virshNodeDeviceListPtr list = g_new0(struct virshNodeDeviceList, 1);
+ struct virshNodeDeviceList *list = g_new0(struct virshNodeDeviceList, 1);
size_t i;
int ret;
virNodeDevicePtr device;
size_t deleted = 0;
int ndevices = 0;
char **names = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNodeDevices(priv->conn,
unsigned int flags = 0;
char **caps = NULL;
int ncaps = 0;
- virshNodeDeviceListPtr list = NULL;
+ struct virshNodeDeviceList *list = NULL;
int cap_type = -1;
bool inactive = vshCommandOptBool(cmd, "inactive");
bool all = vshCommandOptBool(cmd, "all");
const char *driverName = NULL;
virNodeDevicePtr device;
bool ret = true;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
const char *name = NULL;
virNodeDevicePtr device;
bool ret = true;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
const char *name = NULL;
virNodeDevicePtr device;
bool ret = true;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
const char *eventName = NULL;
const char *device_value = NULL;
int event;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "list")) {
size_t i;
virNWFilterPtr nwfilter = NULL;
const char *n = NULL;
const char *optname = "nwfilter";
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
virNWFilterPtr *filters;
size_t nfilters;
};
-typedef struct virshNWFilterList *virshNWFilterListPtr;
static void
-virshNWFilterListFree(virshNWFilterListPtr list)
+virshNWFilterListFree(struct virshNWFilterList *list)
{
size_t i;
g_free(list);
}
-static virshNWFilterListPtr
+static struct virshNWFilterList *
virshNWFilterListCollect(vshControl *ctl,
unsigned int flags)
{
- virshNWFilterListPtr list = g_new0(struct virshNWFilterList, 1);
+ struct virshNWFilterList *list = g_new0(struct virshNWFilterList, 1);
size_t i;
int ret;
virNWFilterPtr filter;
size_t deleted = 0;
int nfilters = 0;
char **names = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNWFilters(priv->conn,
size_t i;
char uuid[VIR_UUID_STRING_BUFLEN];
bool ret = false;
- virshNWFilterListPtr list = NULL;
- vshTablePtr table = NULL;
+ struct virshNWFilterList *list = NULL;
+ vshTable *table = NULL;
if (!(list = virshNWFilterListCollect(ctl, 0)))
return false;
bool ret = false;
virNWFilterPtr nwfilter = NULL;
virNWFilterPtr nwfilter_edited = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
nwfilter = virshCommandOptNWFilter(ctl, cmd, NULL);
if (nwfilter == NULL)
virNWFilterBindingPtr binding = NULL;
const char *n = NULL;
const char *optname = "binding";
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(0, NULL);
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
virNWFilterBindingPtr *bindings;
size_t nbindings;
};
-typedef struct virshNWFilterBindingList *virshNWFilterBindingListPtr;
static void
-virshNWFilterBindingListFree(virshNWFilterBindingListPtr list)
+virshNWFilterBindingListFree(struct virshNWFilterBindingList *list)
{
size_t i;
}
-static virshNWFilterBindingListPtr
+static struct virshNWFilterBindingList *
virshNWFilterBindingListCollect(vshControl *ctl,
unsigned int flags)
{
- virshNWFilterBindingListPtr list = g_new0(struct virshNWFilterBindingList, 1);
+ struct virshNWFilterBindingList *list = g_new0(struct virshNWFilterBindingList, 1);
int ret;
bool success = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if ((ret = virConnectListAllNWFilterBindings(priv->conn,
&list->bindings,
{
size_t i;
bool ret = false;
- virshNWFilterBindingListPtr list = NULL;
- vshTablePtr table = NULL;
+ struct virshNWFilterBindingList *list = NULL;
+ vshTable *table = NULL;
if (!(list = virshNWFilterBindingListCollect(ctl, 0)))
return false;
{
virStoragePoolPtr pool = NULL;
const char *n = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
bool overwrite;
bool no_overwrite;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
bool overwrite;
bool no_overwrite;
unsigned int flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
build = vshCommandOptBool(cmd, "build");
overwrite = vshCommandOptBool(cmd, "overwrite");
const char *from = NULL;
bool ret = true;
char *buffer;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
const char *name;
char *xml;
bool printXML = vshCommandOptBool(cmd, "print-xml");
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (!virshBuildPoolXML(ctl, cmd, &name, &xml))
return false;
virStoragePoolPtr *pools;
size_t npools;
};
-typedef struct virshStoragePoolList *virshStoragePoolListPtr;
static void
-virshStoragePoolListFree(virshStoragePoolListPtr list)
+virshStoragePoolListFree(struct virshStoragePoolList *list)
{
size_t i;
g_free(list);
}
-static virshStoragePoolListPtr
+static struct virshStoragePoolList *
virshStoragePoolListCollect(vshControl *ctl,
unsigned int flags)
{
- virshStoragePoolListPtr list = g_new0(struct virshStoragePoolList, 1);
+ struct virshStoragePoolList *list = g_new0(struct virshStoragePoolList, 1);
size_t i;
int ret;
char **names = NULL;
int nActivePools = 0;
int nInactivePools = 0;
int nAllPools = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllStoragePools(priv->conn,
};
struct poolInfoText *poolInfoTexts = NULL;
unsigned int flags = VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE;
- virshStoragePoolListPtr list = NULL;
+ struct virshStoragePoolList *list = NULL;
const char *type = NULL;
bool details = vshCommandOptBool(cmd, "details");
bool inactive, all;
bool uuid = false;
bool name = false;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
inactive = vshCommandOptBool(cmd, "inactive");
all = vshCommandOptBool(cmd, "all");
char *srcSpec = NULL;
char *srcList;
const char *initiator = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0 ||
vshCommandOptStringReq(ctl, cmd, "host", &host) < 0 ||
{
const char *type = NULL, *srcSpecFile = NULL;
char *srcSpec = NULL, *srcList;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0)
return false;
virStoragePoolPtr pool_edited = NULL;
unsigned int flags = VIR_STORAGE_XML_INACTIVE;
char *tmp_desc = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
pool = virshCommandOptPool(ctl, cmd, "pool", NULL);
if (pool == NULL)
virshPoolEventData data;
const char *eventName = NULL;
int event;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "list")) {
size_t i;
const vshCmd *cmd G_GNUC_UNUSED)
{
const unsigned int flags = 0; /* No flags so far */
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
g_autofree char *caps = NULL;
caps = virConnectGetStoragePoolCapabilities(priv->conn, flags);
virSecretPtr secret = NULL;
const char *n = NULL;
const char *optname = "secret";
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
virSecretPtr res;
char uuid[VIR_UUID_STRING_BUFLEN];
bool ret = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
virSecretPtr *secrets;
size_t nsecrets;
};
-typedef struct virshSecretList *virshSecretListPtr;
static void
-virshSecretListFree(virshSecretListPtr list)
+virshSecretListFree(struct virshSecretList *list)
{
size_t i;
g_free(list);
}
-static virshSecretListPtr
+static struct virshSecretList *
virshSecretListCollect(vshControl *ctl,
unsigned int flags)
{
- virshSecretListPtr list = g_new0(struct virshSecretList, 1);
+ struct virshSecretList *list = g_new0(struct virshSecretList, 1);
size_t i;
int ret;
virSecretPtr secret;
size_t deleted = 0;
int nsecrets = 0;
char **uuids = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllSecrets(priv->conn,
cmdSecretList(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
size_t i;
- virshSecretListPtr list = NULL;
+ struct virshSecretList *list = NULL;
bool ret = false;
unsigned int flags = 0;
- vshTablePtr table = NULL;
+ vshTable *table = NULL;
if (vshCommandOptBool(cmd, "ephemeral"))
flags |= VIR_CONNECT_LIST_SECRETS_EPHEMERAL;
virshSecretEventData data;
const char *eventName = NULL;
int event;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "list")) {
size_t i;
* "snapshot-create-as" command
*/
static int
-virshParseSnapshotMemspec(vshControl *ctl, virBufferPtr buf, const char *str)
+virshParseSnapshotMemspec(vshControl *ctl, virBuffer *buf, const char *str)
{
int ret = -1;
const char *snapshot = NULL;
}
static int
-virshParseSnapshotDiskspec(vshControl *ctl, virBufferPtr buf, const char *str)
+virshParseSnapshotDiskspec(vshControl *ctl, virBuffer *buf, const char *str)
{
int ret = -1;
const char *name = NULL;
xmlDocPtr xmldoc = NULL;
xmlXPathContextPtr ctxt = NULL;
int ret = -1;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
*parent_name = NULL;
unsigned int flags;
int current;
int metadata;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
struct virshSnap *snaps;
int nsnaps;
};
-typedef struct virshSnapshotList *virshSnapshotListPtr;
static void
-virshSnapshotListFree(virshSnapshotListPtr snaplist)
+virshSnapshotListFree(struct virshSnapshotList *snaplist)
{
size_t i;
* list is limited to descendants of the given snapshot. If FLAGS is
* given, the list is filtered. If TREE is specified, then all but
* FROM or the roots will also have parent information. */
-static virshSnapshotListPtr
+static struct virshSnapshotList *
virshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
virDomainSnapshotPtr from,
unsigned int orig_flags, bool tree)
bool descendants = false;
bool roots = false;
virDomainSnapshotPtr *snaps;
- virshSnapshotListPtr snaplist = g_new0(struct virshSnapshotList, 1);
- virshSnapshotListPtr ret = NULL;
+ struct virshSnapshotList *snaplist = g_new0(struct virshSnapshotList, 1);
+ struct virshSnapshotList *ret = NULL;
const char *fromname = NULL;
int start_index = -1;
int deleted = 0;
bool filter_fallback = false;
unsigned int flags = orig_flags;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* Try the interface available in 0.9.13 and newer. */
if (!priv->useSnapshotOld) {
static const char *
virshSnapshotListLookup(int id, bool parent, void *opaque)
{
- virshSnapshotListPtr snaplist = opaque;
+ struct virshSnapshotList *snaplist = opaque;
if (parent)
return snaplist->snaps[id].parent;
return virDomainSnapshotGetName(snaplist->snaps[id].snap);
const char *from_snap = NULL;
char *parent_snap = NULL;
virDomainSnapshotPtr start = NULL;
- virshSnapshotListPtr snaplist = NULL;
- vshTablePtr table = NULL;
+ struct virshSnapshotList *snaplist = NULL;
+ vshTable *table = NULL;
VSH_EXCLUSIVE_OPTIONS_VAR(tree, name);
VSH_EXCLUSIVE_OPTIONS_VAR(parent, roots);
{
virDomainPtr dom = NULL;
int id;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYID | VIRSH_BYUUID | VIRSH_BYNAME, NULL);
int *reason)
{
virDomainInfo info;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if (reason)
*reason = -1;
size_t nbytes,
void *opaque)
{
- virshStreamCallbackDataPtr cbData = opaque;
+ virshStreamCallbackData *cbData = opaque;
return safewrite(cbData->fd, bytes, nbytes);
}
size_t nbytes,
void *opaque)
{
- virshStreamCallbackDataPtr cbData = opaque;
+ virshStreamCallbackData *cbData = opaque;
int fd = cbData->fd;
return saferead(fd, bytes, nbytes);
long long offset,
void *opaque)
{
- virshStreamCallbackDataPtr cbData = opaque;
+ virshStreamCallbackData *cbData = opaque;
int fd = cbData->fd;
if (lseek(fd, offset, SEEK_CUR) == (off_t) -1)
long long offset,
void *opaque)
{
- virshStreamCallbackDataPtr cbData = opaque;
+ virshStreamCallbackData *cbData = opaque;
off_t cur;
if (cbData->isBlock) {
long long *offset,
void *opaque)
{
- virshStreamCallbackDataPtr cbData = opaque;
+ virshStreamCallbackData *cbData = opaque;
vshControl *ctl = cbData->ctl;
int fd = cbData->fd;
void *opaque);
typedef struct _virshStreamCallbackData virshStreamCallbackData;
-typedef virshStreamCallbackData *virshStreamCallbackDataPtr;
struct _virshStreamCallbackData {
vshControl *ctl;
int fd;
virStorageVolPtr vol = NULL;
virStoragePoolPtr pool = NULL;
const char *n = NULL, *p = NULL;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
unsigned long long capacity, allocation = 0;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
unsigned long flags = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
bool ret = false;
if (vshCommandOptBool(cmd, "prealloc-metadata"))
virStreamPtr st = NULL;
const char *name = NULL;
unsigned long long offset = 0, length = 0;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
unsigned int flags = 0;
virshStreamCallbackData cbData;
struct stat sb;
const char *name = NULL;
unsigned long long offset = 0, length = 0;
bool created = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
virshStreamCallbackData cbData;
unsigned int flags = 0;
struct stat sb;
virStorageVolPtr *vols;
size_t nvols;
};
-typedef struct virshStorageVolList *virshStorageVolListPtr;
static void
-virshStorageVolListFree(virshStorageVolListPtr list)
+virshStorageVolListFree(struct virshStorageVolList *list)
{
size_t i;
g_free(list);
}
-static virshStorageVolListPtr
+static struct virshStorageVolList *
virshStorageVolListCollect(vshControl *ctl,
virStoragePoolPtr pool,
unsigned int flags)
{
- virshStorageVolListPtr list = g_new0(struct virshStorageVolList, 1);
+ struct virshStorageVolList *list = g_new0(struct virshStorageVolList, 1);
size_t i;
char **names = NULL;
virStorageVolPtr vol = NULL;
char *type;
};
struct volInfoText *volInfoTexts = NULL;
- virshStorageVolListPtr list = NULL;
- vshTablePtr table = NULL;
+ struct virshStorageVolList *list = NULL;
+ vshTable *table = NULL;
/* Look up the pool information given to us by the user */
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
int interval = 5; /* Default */
int count = 6; /* Default */
bool keepalive_forced = false;
- virPolkitAgentPtr pkagent = NULL;
+ virPolkitAgent *pkagent = NULL;
int authfail = 0;
bool agentCreated = false;
virshReconnect(vshControl *ctl, const char *name, bool readonly, bool force)
{
bool connected = false;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* If the flag was not specified, then it depends on whether we are
* reconnecting to the current URI (in which case we want to keep the
static void *
virshConnectionHandler(vshControl *ctl)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
if ((!priv->conn || disconnected) &&
virshReconnect(ctl, NULL, false, false) < 0)
static bool
virshInit(vshControl *ctl)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
/* Since we have the commandline arguments parsed, we need to
* reload our initial settings to make debugging and readline
static bool
virshDeinit(vshControl *ctl)
{
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
vshDeinit(ctl);
VIR_FREE(ctl->connname);
int arg, len, debug, keepalive;
size_t i;
int longindex = -1;
- virshControlPtr priv = ctl->privData;
+ virshControl *priv = ctl->privData;
struct option opt[] = {
{"connect", required_argument, NULL, 'c'},
{"debug", required_argument, NULL, 'd'},
VIRSH_COMMON_OPT_DOMAIN_OT_ARGV(N_("domain name, id or uuid"), cflags)
typedef struct _virshControl virshControl;
-typedef virshControl *virshControlPtr;
typedef struct _virshCtrlData virshCtrlData;
const vshCmd *cmd G_GNUC_UNUSED,
unsigned int flags)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
virAdmServerPtr *srvs = NULL;
int nsrvs = 0;
size_t i = 0;
static int
vshAdmConnect(vshControl *ctl, unsigned int flags)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
priv->conn = virAdmConnectOpen(ctl->connname, flags);
vshAdmDisconnect(vshControl *ctl)
{
int ret = 0;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (!priv->conn)
return ret;
static void
vshAdmReconnect(vshControl *ctl)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (priv->conn)
priv->wantReconnect = true;
cmdURI(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
{
char *uri;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
uri = virAdmConnectGetURI(priv->conn);
if (!uri) {
unsigned int major;
unsigned int minor;
unsigned int rel;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
includeVersion = LIBVIR_VERSION_NUMBER;
major = includeVersion / 1000000;
cmdConnect(vshControl *ctl, const vshCmd *cmd)
{
const char *name = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
bool connected = priv->conn;
if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0)
bool ret = false;
char *uri = NULL;
virAdmServerPtr *srvs = NULL;
- vshAdmControlPtr priv = ctl->privData;
- vshTablePtr table = NULL;
+ vshAdmControl *priv = ctl->privData;
+ vshTable *table = NULL;
/* Obtain a list of available servers on the daemon */
if ((nsrvs = virAdmConnectListServers(priv->conn, &srvs, 0)) < 0) {
size_t i;
const char *srvname = NULL;
virAdmServerPtr srv = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
const char *srvname = NULL;
virTypedParameterPtr params = NULL;
virAdmServerPtr srv = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
virClientTransport transport;
virAdmServerPtr srv = NULL;
virAdmClientPtr *clts = NULL;
- vshAdmControlPtr priv = ctl->privData;
- vshTablePtr table = NULL;
+ vshAdmControl *priv = ctl->privData;
+ vshTable *table = NULL;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
virAdmClientPtr clnt = NULL;
virTypedParameterPtr params = NULL;
int nparams = 0;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptULongLong(ctl, cmd, "client", &id) < 0)
return false;
unsigned long long id = 0;
virAdmServerPtr srv = NULL;
virAdmClientPtr client = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
size_t i;
const char *srvname = NULL;
virAdmServerPtr srv = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
const char *srvname = NULL;
virAdmServerPtr srv = NULL;
virTypedParameterPtr params = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
const char *srvname = NULL;
virAdmServerPtr srv = NULL;
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
return false;
static bool
cmdDaemonLogFilters(vshControl *ctl, const vshCmd *cmd)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "filters")) {
const char *filters = NULL;
static bool
cmdDaemonLogOutputs(vshControl *ctl, const vshCmd *cmd)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (vshCommandOptBool(cmd, "outputs")) {
const char *outputs = NULL;
static void *
vshAdmConnectionHandler(vshControl *ctl)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
if (!virAdmConnectIsAlive(priv->conn))
vshAdmReconnect(ctl);
static bool
vshAdmInit(vshControl *ctl)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
/* Since we have the commandline arguments parsed, we need to
* reload our initial settings to make debugging and readline
static void
vshAdmDeinit(vshControl *ctl)
{
- vshAdmControlPtr priv = ctl->privData;
+ vshAdmControl *priv = ctl->privData;
vshDeinit(ctl);
VIR_FREE(ctl->connname);
*/
typedef struct _vshAdmControl vshAdmControl;
-typedef vshAdmControl *vshAdmControlPtr;
/*
* adminControl
}
-virBitmapPtr virHostValidateGetCPUFlags(void)
+virBitmap *virHostValidateGetCPUFlags(void)
{
FILE *fp;
- virBitmapPtr flags = NULL;
+ virBitmap *flags = NULL;
if (!(fp = fopen("/proc/cpuinfo", "r")))
return NULL;
int virHostValidateIOMMU(const char *hvname,
virHostValidateLevel level)
{
- virBitmapPtr flags;
+ virBitmap *flags;
struct stat sb;
const char *bootarg = NULL;
bool isAMD = false, isIntel = false;
int virHostValidateSecureGuests(const char *hvname,
virHostValidateLevel level)
{
- virBitmapPtr flags;
+ virBitmap *flags;
bool hasFac158 = false;
bool hasAMDSev = false;
virArch arch = virArchFromHost();
virHostValidateLevel level,
const char *hint);
-virBitmapPtr virHostValidateGetCPUFlags(void);
+virBitmap *virHostValidateGetCPUFlags(void);
int virHostValidateLinuxKernel(const char *hvname,
int version,
int virHostValidateQEMU(void)
{
- virBitmapPtr flags;
+ virBitmap *flags;
int ret = 0;
bool hasHwVirt = false;
bool hasVirtFlag = false;
static const char *conf_file = SYSCONFDIR "/libvirt/virt-login-shell.conf";
-static int virLoginShellAllowedUser(virConfPtr conf,
+static int virLoginShellAllowedUser(virConf *conf,
const char *name,
gid_t *groups,
size_t ngroups)
}
-static int virLoginShellGetShellArgv(virConfPtr conf,
+static int virLoginShellGetShellArgv(virConf *conf,
char ***shargv,
size_t *shargvlen)
{
struct _vshTable {
- vshTableRowPtr *rows;
+ vshTableRow **rows;
size_t nrows;
};
static void
-vshTableRowFree(vshTableRowPtr row)
+vshTableRowFree(vshTableRow *row)
{
size_t i;
void
-vshTableFree(vshTablePtr table)
+vshTableFree(vshTable *table)
{
size_t i;
* Create a new row in the table. Each argument passed
* represents a cell in the row.
*
- * Return: pointer to vshTableRowPtr row or NULL.
+ * Return: pointer to vshTableRow *row or NULL.
*/
-static vshTableRowPtr
+static vshTableRow *
vshTableRowNew(const char *arg, va_list ap)
{
- vshTableRowPtr row = NULL;
+ vshTableRow *row = NULL;
if (!arg) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
*
* Returns: pointer to table or NULL.
*/
-vshTablePtr
+vshTable *
vshTableNew(const char *arg, ...)
{
- vshTablePtr table = NULL;
- vshTableRowPtr header = NULL;
+ vshTable *table = NULL;
+ vshTableRow *header = NULL;
va_list ap;
table = g_new0(vshTable, 1);
* Returns: 0 if succeeded, -1 if failed.
*/
int
-vshTableRowAppend(vshTablePtr table, const char *arg, ...)
+vshTableRowAppend(vshTable *table, const char *arg, ...)
{
- vshTableRowPtr row = NULL;
+ vshTableRow *row = NULL;
size_t ncolumns = table->rows[0]->ncells;
va_list ap;
int ret = -1;
* Return 0 in case of success, -1 otherwise.
*/
static int
-vshTableGetColumnsWidths(vshTablePtr table,
+vshTableGetColumnsWidths(vshTable *table,
size_t *maxwidths,
size_t **widths,
bool header)
i = header? 0 : 1;
for (; i < table->nrows; i++) {
- vshTableRowPtr row = table->rows[i];
+ vshTableRow *row = table->rows[i];
size_t j;
for (j = 0; j < row->ncells; j++) {
* @buf: buffer to store table (only if @toStdout == true)
*/
static void
-vshTableRowPrint(vshTableRowPtr row,
+vshTableRowPrint(vshTableRow *row,
size_t *maxwidths,
size_t *widths,
- virBufferPtr buf)
+ virBuffer *buf)
{
size_t i;
size_t j;
* Return string containing table, or NULL
*/
static char *
-vshTablePrint(vshTablePtr table, bool header)
+vshTablePrint(vshTable *table, bool header)
{
size_t i;
size_t j;
* (apart from quiet mode) this code may need update
*/
void
-vshTablePrintToStdout(vshTablePtr table, vshControl *ctl)
+vshTablePrintToStdout(vshTable *table, vshControl *ctl)
{
bool header;
g_autofree char *out = NULL;
* stdout. User will have to free returned string.
*/
char *
-vshTablePrintToString(vshTablePtr table, bool header)
+vshTablePrintToString(vshTable *table, bool header)
{
return vshTablePrint(table, header);
}
typedef struct _vshTable vshTable;
typedef struct _vshTableRow vshTableRow;
-typedef vshTable *vshTablePtr;
-typedef vshTableRow *vshTableRowPtr;
-void vshTableFree(vshTablePtr table);
-vshTablePtr vshTableNew(const char *format, ...);
-int vshTableRowAppend(vshTablePtr table, const char *arg, ...);
-void vshTablePrintToStdout(vshTablePtr table, vshControl *ctl);
-char *vshTablePrintToString(vshTablePtr table, bool header);
+void vshTableFree(vshTable *table);
+vshTable *vshTableNew(const char *format, ...);
+int vshTableRowAppend(vshTable *table, const char *arg, ...);
+void vshTablePrintToStdout(vshTable *table, vshControl *ctl);
+char *vshTablePrintToString(vshTable *table, bool header);
vshEditFile(vshControl *ctl, const char *filename)
{
const char *editor;
- virCommandPtr cmd;
+ virCommand *cmd;
int ret = -1;
int outfd = STDOUT_FILENO;
int errfd = STDERR_FILENO;
int devid,
int lastdev,
bool root,
- virBufferPtr indent)
+ virBuffer *indent)
{
size_t i;
int nextlastdev = -1;
projects / libvirt.git / commitdiff