getDomainInfo(0);
- return(0);
+ return 0;
}
ret = virDomainGetInfo(dom, &info);
if (ret < 0) {
- return(-1);
+ return -1;
}
- return(info.state);
+ return info.state;
}
/**
error:
if (conn != NULL)
virConnectClose(conn);
- return(0);
+ return 0;
}
args[1][0])
else:
c_call = "\n %s(%s);\n" % (name, c_call);
- ret_convert = " Py_INCREF(Py_None);\n return(Py_None);\n"
+ ret_convert = " Py_INCREF(Py_None);\n return Py_None;\n"
elif py_types.has_key(ret[0]):
(f, t, n, c) = py_types[ret[0]]
c_return = " %s c_retval;\n" % (ret[0])
else:
c_call = "\n c_retval = %s(%s);\n" % (name, c_call);
ret_convert = " py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n,c)
- ret_convert = ret_convert + " return(py_retval);\n"
+ ret_convert = ret_convert + " return py_retval;\n"
elif py_return_types.has_key(ret[0]):
(f, t, n, c) = py_return_types[ret[0]]
c_return = " %s c_retval;\n" % (ret[0])
c_call = "\n c_retval = %s(%s);\n" % (name, c_call);
ret_convert = " py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n,c)
- ret_convert = ret_convert + " return(py_retval);\n"
+ ret_convert = ret_convert + " return py_retval;\n"
else:
if skipped_types.has_key(ret[0]):
return 0
if format != "":
output.write("\n if (!PyArg_ParseTuple(args, (char *)\"%s\"%s))\n" %
(format, format_args))
- output.write(" return(NULL);\n")
+ output.write(" return NULL;\n")
if c_convert != "":
output.write(c_convert + "\n")
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainBlockStats",
&pyobj_domain,&path))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyTuple_SetItem(info, 2, PyLong_FromLongLong(stats.wr_req));
PyTuple_SetItem(info, 3, PyLong_FromLongLong(stats.wr_bytes));
PyTuple_SetItem(info, 4, PyLong_FromLongLong(stats.errs));
- return(info);
+ return info;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainInterfaceStats",
&pyobj_domain,&path))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyTuple_SetItem(info, 5, PyLong_FromLongLong(stats.tx_packets));
PyTuple_SetItem(info, 6, PyLong_FromLongLong(stats.tx_errs));
PyTuple_SetItem(info, 7, PyLong_FromLongLong(stats.tx_drop));
- return(info);
+ return info;
}
static PyObject *
PyObject *info;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainMemoryStats", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
nr_stats = virDomainMemoryStats(domain, stats,
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetScedulerType",
&pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyTuple_SetItem(info, 0, libvirt_constcharPtrWrap(c_retval));
PyTuple_SetItem(info, 1, PyInt_FromLong((long)nparams));
VIR_FREE(c_retval);
- return(info);
+ return info;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetVcpus",
&pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(cpuinfo);
VIR_FREE(cpumap);
- return(pyretval);
+ return pyretval;
cleanup:
VIR_FREE(cpuinfo);
if (!PyArg_ParseTuple(args, (char *)"OiO:virDomainPinVcpu",
&pyobj_domain, &vcpu, &pycpumap))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
if (!PyArg_ParseTuple(args, (char *)"OiOi:virDomainPinVcpuFlags",
&pyobj_domain, &vcpu, &pycpumap, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainGetVcpuPinInfo",
&pyobj_domain, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyObject *pyobj_conn;
if (!PyArg_ParseTuple(args, (char *)"O:virConGetLastError", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
if (!PyArg_ParseTuple
(args, (char *) "OO:xmlRegisterErrorHandler", &pyobj_f,
&pyobj_ctx))
- return (NULL);
+ return NULL;
DEBUG("libvirt_virRegisterErrorHandler(%p, %p) called\n", pyobj_ctx,
pyobj_f);
}
py_retval = libvirt_intWrap(1);
- return (py_retval);
+ return py_retval;
}
static int virConnectCredCallbackWrapper(virConnectCredentialPtr cred,
virConnectAuth auth;
if (!PyArg_ParseTuple(args, (char *)"zOi:virConnectOpenAuth", &name, &pyauth, &flags))
- return(NULL);
+ return NULL;
pycredtype = PyList_GetItem(pyauth, 0);
pycredcb = PyList_GetItem(pyauth, 1);
LIBVIRT_END_ALLOW_THREADS;
VIR_FREE(auth.credtype);
py_retval = libvirt_virConnectPtrWrap((virConnectPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetVersion",
&pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetLibVersion",
&pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDomains", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(ids);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedDomains", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
unsigned int flags;
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainSnapshotListNames", &pyobj_dom, &flags))
- return(NULL);
+ return NULL;
dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
unsigned int flags;
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainSnapshotListChildrenNames", &pyobj_snap, &flags))
- return(NULL);
+ return NULL;
snap = (virDomainSnapshotPtr) PyvirDomainSnapshot_Get(pyobj_snap);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
unsigned int flags;
if (!PyArg_ParseTuple(args, (char *)"OOi:virDomainRevertToSnapshot", &pyobj_dom, &pyobj_snap, &flags))
- return(NULL);
+ return NULL;
snap = (virDomainSnapshotPtr) PyvirDomainSnapshot_Get(pyobj_snap);
LIBVIRT_BEGIN_ALLOW_THREADS;
virDomainInfo info;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetInfo", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyList_SetItem(py_retval, 3, libvirt_intWrap((int) info.nrVirtCpu));
PyList_SetItem(py_retval, 4,
libvirt_longlongWrap((unsigned long long) info.cpuTime));
- return(py_retval);
+ return py_retval;
}
static PyObject *
unsigned int flags;
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainGetInfo", &pyobj_domain, &path, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyList_SetItem(py_retval, 0, libvirt_ulonglongWrap(info.capacity));
PyList_SetItem(py_retval, 1, libvirt_ulonglongWrap(info.allocation));
PyList_SetItem(py_retval, 2, libvirt_ulonglongWrap(info.physical));
- return(py_retval);
+ return py_retval;
}
static PyObject *
virNodeInfo info;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetInfo", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyList_SetItem(py_retval, 5, libvirt_intWrap((int) info.sockets));
PyList_SetItem(py_retval, 6, libvirt_intWrap((int) info.cores));
PyList_SetItem(py_retval, 7, libvirt_intWrap((int) info.threads));
- return(py_retval);
+ return py_retval;
}
static PyObject *
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetUUID", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (domain == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromStringAndSize((char *) &uuid[0], VIR_UUID_BUFLEN);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetUUIDString",
&pyobj_dom))
- return(NULL);
+ return NULL;
dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
if (dom == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString((char *) &uuidstr[0]);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int len;
if (!PyArg_ParseTuple(args, (char *)"Oz#:virDomainLookupByUUID", &pyobj_conn, &uuid, &len))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
c_retval = virDomainLookupByUUID(conn, uuid);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListNetworks", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedNetworks", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetUUID", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virNetworkPtr) PyvirNetwork_Get(pyobj_domain);
if (domain == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromStringAndSize((char *) &uuid[0], VIR_UUID_BUFLEN);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetUUIDString",
&pyobj_net))
- return(NULL);
+ return NULL;
net = (virNetworkPtr) PyvirNetwork_Get(pyobj_net);
if (net == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString((char *) &uuidstr[0]);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int len;
if (!PyArg_ParseTuple(args, (char *)"Oz#:virNetworkLookupByUUID", &pyobj_conn, &uuid, &len))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
c_retval = virNetworkLookupByUUID(conn, uuid);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
PyObject *pyobj_domain;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetAutostart", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (c_retval < 0)
return VIR_PY_INT_FAIL;
py_retval = libvirt_intWrap(autostart);
- return(py_retval);
+ return py_retval;
}
PyObject *pyobj_network;
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetAutostart", &pyobj_network))
- return(NULL);
+ return NULL;
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
if (c_retval < 0)
return VIR_PY_INT_FAIL;
py_retval = libvirt_intWrap(autostart);
- return(py_retval);
+ return py_retval;
}
static PyObject *
unsigned long long *freeMems;
if (!PyArg_ParseTuple(args, (char *)"Oii:virNodeGetCellsFreeMemory", &pyobj_conn, &startCell, &maxCells))
- return(NULL);
+ return NULL;
if ((startCell < 0) || (maxCells <= 0) || (startCell + maxCells > 10000))
return VIR_PY_NONE;
libvirt_longlongWrap((long long) freeMems[i]));
}
VIR_FREE(freeMems);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListStoragePools", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedStoragePools", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolListVolumes", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
PyObject *pyobj_pool;
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetAutostart", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
return VIR_PY_NONE;
py_retval = libvirt_intWrap(autostart);
- return(py_retval);
+ return py_retval;
}
static PyObject *
virStoragePoolInfo info;
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetInfo", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
LIBVIRT_BEGIN_ALLOW_THREADS;
libvirt_longlongWrap((unsigned long long) info.allocation));
PyList_SetItem(py_retval, 3,
libvirt_longlongWrap((unsigned long long) info.available));
- return(py_retval);
+ return py_retval;
}
virStorageVolInfo info;
if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolGetInfo", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_pool);
LIBVIRT_BEGIN_ALLOW_THREADS;
libvirt_longlongWrap((unsigned long long) info.capacity));
PyList_SetItem(py_retval, 2,
libvirt_longlongWrap((unsigned long long) info.allocation));
- return(py_retval);
+ return py_retval;
}
static PyObject *
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetUUID", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
if (pool == NULL)
py_retval = PyString_FromStringAndSize((char *) &uuid[0], VIR_UUID_BUFLEN);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetUUIDString", &pyobj_pool))
- return(NULL);
+ return NULL;
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
if (pool == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString((char *) &uuidstr[0]);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int len;
if (!PyArg_ParseTuple(args, (char *)"Oz#:virStoragePoolLookupByUUID", &pyobj_conn, &uuid, &len))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
c_retval = virStoragePoolLookupByUUID(conn, uuid);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"Ozi:virNodeListDevices",
&pyobj_conn, &cap, &flags))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
PyObject *pyobj_dev;
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceListCaps", &pyobj_dev))
- return(NULL);
+ return NULL;
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
static PyObject *
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUUID", &pyobj_secret))
- return(NULL);
+ return NULL;
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
if (secret == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromStringAndSize((char *) &uuid[0], VIR_UUID_BUFLEN);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUUIDString",
&pyobj_dom))
- return(NULL);
+ return NULL;
dom = (virSecretPtr) PyvirSecret_Get(pyobj_dom);
if (dom == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString((char *) &uuidstr[0]);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int len;
if (!PyArg_ParseTuple(args, (char *)"Oz#:virSecretLookupByUUID", &pyobj_conn, &uuid, &len))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
c_retval = virSecretLookupByUUID(conn, uuid);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_virSecretPtrWrap((virSecretPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
int c_retval;
if (!PyArg_ParseTuple(args, (char *)"O:virNWFilterGetUUID", &pyobj_nwfilter))
- return(NULL);
+ return NULL;
nwfilter = (virNWFilterPtr) PyvirNWFilter_Get(pyobj_nwfilter);
if (nwfilter == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromStringAndSize((char *) &uuid[0], VIR_UUID_BUFLEN);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"O:virNWFilterGetUUIDString",
&pyobj_nwfilter))
- return(NULL);
+ return NULL;
nwfilter = (virNWFilterPtr) PyvirNWFilter_Get(pyobj_nwfilter);
if (nwfilter == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString((char *) &uuidstr[0]);
- return(py_retval);
+ return py_retval;
}
static PyObject *
int len;
if (!PyArg_ParseTuple(args, (char *)"Oz#:virNWFilterLookupByUUID", &pyobj_conn, &uuid, &len))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
c_retval = virNWFilterLookupByUUID(conn, uuid);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_virNWFilterPtrWrap((virNWFilterPtr) c_retval);
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListInterfaces", &pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedInterfaces",
&pyobj_conn))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
LIBVIRT_BEGIN_ALLOW_THREADS;
VIR_FREE(names);
}
- return(py_retval);
+ return py_retval;
}
if (!PyArg_ParseTuple(args, (char *)"OOi:virConnectBaselineCPU",
&pyobj_conn, &list, &flags))
- return(NULL);
+ return NULL;
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
if (PyList_Check(list)) {
virDomainJobInfo info;
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetJobInfo", &pyobj_domain))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
PyList_SetItem(py_retval, 10, libvirt_ulonglongWrap(info.fileProcessed));
PyList_SetItem(py_retval, 11, libvirt_ulonglongWrap(info.fileRemaining));
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainGetBlockJobInfo",
&pyobj_domain, &path, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
LIBVIRT_BEGIN_ALLOW_THREADS;
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_intWrap(ret);
- return (py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple
(args, (char *) "OO:virConnectDomainEventDeregister",
&pyobj_conn, &pyobj_conn_inst))
- return (NULL);
+ return NULL;
DEBUG("libvirt_virConnectDomainEventDeregister(%p) called\n", pyobj_conn);
Py_DECREF(pyobj_conn_inst);
py_retval = libvirt_intWrap(ret);
- return (py_retval);
+ return py_retval;
}
/*******************************************
}
py_retval = libvirt_intWrap(ret);
- return (py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple
(args, (char *) "Oi:virConnectDomainEventDeregister",
&pyobj_conn, &callbackID))
- return (NULL);
+ return NULL;
DEBUG("libvirt_virConnectDomainEventDeregister(%p) called\n", pyobj_conn);
LIBVIRT_END_ALLOW_THREADS;
py_retval = libvirt_intWrap(ret);
- return (py_retval);
+ return py_retval;
}
static void
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainMigrateGetMaxSpeed",
&pyobj_domain, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (c_retval < 0)
return VIR_PY_INT_FAIL;
py_retval = libvirt_ulongWrap(bandwidth);
- return(py_retval);
+ return py_retval;
}
static PyObject *
if (!PyArg_ParseTuple(args, (char *)"OzLni:virDomainBlockPeek", &pyobj_domain,
&disk, &offset, &size, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (!PyArg_ParseTuple(args, (char *)"OLni:virDomainMemoryPeek", &pyobj_domain,
&start, &size, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainQemuMonitorCommand",
&pyobj_domain, &cmd, &flags))
- return(NULL);
+ return NULL;
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
if (domain == NULL)
return VIR_PY_NONE;
py_retval = PyString_FromString(result);
- return(py_retval);
+ return py_retval;
}
/************************************************************************
{
PyObject *ret;
ret = PyInt_FromLong((long) val);
- return (ret);
+ return ret;
}
PyObject *
{
PyObject *ret;
ret = PyInt_FromLong(val);
- return (ret);
+ return ret;
}
PyObject *
{
PyObject *ret;
ret = PyLong_FromLong(val);
- return (ret);
+ return ret;
}
PyObject *
{
PyObject *ret;
ret = PyLong_FromUnsignedLongLong((unsigned long long) val);
- return (ret);
+ return ret;
}
PyObject *
{
PyObject *ret;
ret = PyLong_FromUnsignedLongLong(val);
- return (ret);
+ return ret;
}
PyObject *
if (str == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = PyString_FromStringAndSize(str, size);
VIR_FREE(str);
- return (ret);
+ return ret;
}
PyObject *
if (str == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = PyString_FromString(str);
VIR_FREE(str);
- return (ret);
+ return ret;
}
PyObject *
if (str == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = PyString_FromString(str);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virDomainPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virNetworkPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virInterfacePtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virStoragePoolPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virStorageVolPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virConnectPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virNodeDevicePtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
}
ret = libvirt_buildPyObject(node, "virSecretPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
}
ret = libvirt_buildPyObject(node, "virNWFilterPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
}
ret = libvirt_buildPyObject(node, "virStreamPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virDomainSnapshotPtr", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
printf("%s: WARNING - Wrapping None\n", __func__);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virEventHandleCallback", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
printf("%s: WARNING - Wrapping None\n", __func__);
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virEventTimeoutCallback", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "virFreeCallback", NULL);
- return (ret);
+ return ret;
}
PyObject *
if (node == NULL) {
Py_INCREF(Py_None);
- return (Py_None);
+ return Py_None;
}
ret = libvirt_buildPyObject(node, "void*", NULL);
- return (ret);
+ return ret;
}
if (!xmlStrEqual(node->name, BAD_CAST "sysinfo")) {
virDomainReportError(VIR_ERR_XML_ERROR, "%s",
_("XML does not contain expected 'sysinfo' element"));
- return(NULL);
+ return NULL;
}
if (VIR_ALLOC(def) < 0) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
type = virXMLPropString(node, "type");
cleanup:
VIR_FREE(type);
- return(def);
+ return def;
error:
virSysinfoDefFree(def);
}
if ((support3d == NULL) && (support2d == NULL))
- return(NULL);
+ return NULL;
if (VIR_ALLOC(def) < 0) {
virReportOOMError();
const char *cur = *str;
if (!c_isdigit(*cur))
- return (-1);
+ return -1;
while (c_isdigit(*cur)) {
ret = ret * 10 + (*cur - '0');
if (ret >= maxcpu)
- return (-1);
+ return -1;
cur++;
}
*str = cur;
- return (ret);
+ return ret;
}
/**
int first = 1;
if ((cpuset == NULL) || (maxcpu <= 0) || (maxcpu > 100000))
- return (NULL);
+ return NULL;
cur = 0;
start = -1;
if ((str == NULL) || (cpuset == NULL) || (maxcpu <= 0) ||
(maxcpu > 100000))
- return (-1);
+ return -1;
cur = str;
virSkipSpaces(&cur);
} else
goto parse_error;
}
- return (ret);
+ return ret;
parse_error:
virDomainReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("topology cpuset syntax error"));
- return (-1);
+ return -1;
}
if (tmp == NULL) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("interface has no name"));
- return(-1);
+ return -1;
}
def->name = tmp;
- return(0);
+ return 0;
}
static int
if ((ret == -2) || ((ret == 0) && (mtu > 100000))) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("interface mtu value is improper"));
- return(-1);
+ return -1;
} else if (ret == 0) {
def->mtu = (unsigned int) mtu;
}
- return(0);
+ return 0;
}
static int
virInterfaceReportError(VIR_ERR_XML_ERROR,
_("unknown interface startmode %s"), tmp);
VIR_FREE(tmp);
- return(-1);
+ return -1;
}
VIR_FREE(tmp);
- return(0);
+ return 0;
}
static int
tmp = virXPathString("string(./@mode)", ctxt);
if (tmp == NULL)
- return(VIR_INTERFACE_BOND_NONE);
+ return VIR_INTERFACE_BOND_NONE;
if (STREQ(tmp, "balance-rr"))
ret = VIR_INTERFACE_BOND_BALRR;
else if (STREQ(tmp, "active-backup"))
ret = -1;
}
VIR_FREE(tmp);
- return(ret);
+ return ret;
}
static int
tmp = virXPathString("string(./miimon/@carrier)", ctxt);
if (tmp == NULL)
- return(VIR_INTERFACE_BOND_MII_NONE);
+ return VIR_INTERFACE_BOND_MII_NONE;
if (STREQ(tmp, "ioctl"))
ret = VIR_INTERFACE_BOND_MII_IOCTL;
else if (STREQ(tmp, "netif"))
ret = -1;
}
VIR_FREE(tmp);
- return(ret);
+ return ret;
}
static int
tmp = virXPathString("string(./arpmon/@validate)", ctxt);
if (tmp == NULL)
- return(VIR_INTERFACE_BOND_ARP_NONE);
+ return VIR_INTERFACE_BOND_ARP_NONE;
if (STREQ(tmp, "active"))
ret = VIR_INTERFACE_BOND_ARP_ACTIVE;
else if (STREQ(tmp, "backup"))
ret = -1;
}
VIR_FREE(tmp);
- return(ret);
+ return ret;
}
static int
def->peerdns = -1;
ctxt->node = save;
- return(ret);
+ return ret;
}
static int
else if (ret == -2) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("Invalid ip address prefix value"));
- return(-1);
+ return -1;
}
}
- return(0);
+ return 0;
}
static int
if (dhcp != NULL) {
ret = virInterfaceDefParseDhcp(def, dhcp, ctxt);
if (ret != 0)
- return(ret);
+ return ret;
}
nIpNodes = virXPathNodeSet("./ip", ctxt, &ipNodes);
error:
VIR_FREE(ipNodes);
- return(ret);
+ return ret;
}
static int
if (dhcp != NULL) {
ret = virInterfaceDefParseDhcp(def, dhcp, ctxt);
if (ret != 0)
- return(ret);
+ return ret;
}
nIpNodes = virXPathNodeSet("./ip", ctxt, &ipNodes);
error:
VIR_FREE(ipNodes);
- return(ret);
+ return ret;
}
static int
error:
VIR_FREE(protoNodes);
ctxt->node = save;
- return(ret);
+ return ret;
}
error:
VIR_FREE(interfaces);
ctxt->node = bridge;
- return(ret);
+ return ret;
}
static int
error:
VIR_FREE(interfaces);
ctxt->node = bond;
- return(ret);
+ return ret;
}
static int
}
}
error:
- return(ret);
+ return ret;
}
static int
if (def->data.vlan.tag == NULL) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("vlan interface misses the tag attribute"));
- return(-1);
+ return -1;
}
def->data.vlan.devname =
if (def->data.vlan.devname == NULL) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("vlan interface misses name attribute"));
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
static virInterfaceDefPtr
if (tmp == NULL) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
"%s", _("interface misses the type attribute"));
- return(NULL);
+ return NULL;
}
type = virInterfaceTypeFromString(tmp);
if (type == -1) {
virInterfaceReportError(VIR_ERR_XML_ERROR,
_("unknown interface type %s"), tmp);
VIR_FREE(tmp);
- return(NULL);
+ return NULL;
}
VIR_FREE(tmp);
}
virBufferAsprintf(buf, "%*s </bridge>\n", level*2, "");
- return(ret);
+ return ret;
}
static int
if (def->data.bond.target == NULL) {
virInterfaceReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("bond arp monitoring has no target"));
- return(-1);
+ return -1;
}
virBufferAsprintf(buf, "%*s <arpmon interval='%d' target='%s'",
level*2, "",
}
virBufferAsprintf(buf, "%*s </bond>\n", level*2, "");
- return(ret);
+ return ret;
}
static int
if (def->data.vlan.tag == NULL) {
virInterfaceReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("vlan misses the tag name"));
- return(-1);
+ return -1;
}
virBufferAsprintf(buf, "%*s <vlan tag='%s'",
virBufferAsprintf(buf, "%*s </vlan>\n", level*2, "");
} else
virBufferAddLit(buf, "/>\n");
- return(0);
+ return 0;
}
static int
virBufferAsprintf(buf, "%*s </protocol>\n", level*2, "");
}
- return(0);
+ return 0;
}
static int
return -1;
}
virBufferAsprintf(buf, "%*s <start mode='%s'/>\n", level*2, "", mode);
- return(0);
+ return 0;
}
static int
a->u.index.intIterId == b->u.index.intIterId);
break;
case VIR_NWFILTER_VAR_ACCESS_ITERATOR:
- return (a->u.iterId == b->u.iterId);
+ return a->u.iterId == b->u.iterId;
break;
case VIR_NWFILTER_VAR_ACCESS_LAST:
break;
{
struct data_iterator iter = DATA_ITERATOR_INIT(data);
- return (x86DataCpuidNext(&iter) == NULL);
+ return x86DataCpuidNext(&iter) == NULL;
}
ret->interfacePrivateData = NULL;
ret->refs = 1;
- return(ret);
+ return ret;
failed:
if (ret != NULL) {
virMutexDestroy(&ret->lock);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
/**
if (refs == 0) {
virReleaseConnect(conn);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&conn->lock);
- return (refs);
+ return refs;
}
/**
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
/**
if (refs == 0) {
virReleaseDomain(domain);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&domain->conn->lock);
- return (refs);
+ return refs;
}
/**
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
/**
if (refs == 0) {
virReleaseNetwork(network);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&network->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->mac);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
/**
if (refs == 0) {
virReleaseInterface(iface);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&iface->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
if (refs == 0) {
virReleaseStoragePool(pool);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&pool->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->pool);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
if (refs == 0) {
virReleaseStorageVol(vol);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&vol->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
if (refs == 0) {
virReleaseNodeDevice(dev);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&dev->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
virMutexUnlock(&conn->lock);
VIR_FREE(ret);
- return(NULL);
+ return NULL;
}
static void
if (refs == 0) {
virReleaseStream(st);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&st->conn->lock);
- return (refs);
+ return refs;
}
conn->refs++;
ret->refs++;
virMutexUnlock(&conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
if (refs == 0) {
virReleaseNWFilter(nwfilter);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&nwfilter->conn->lock);
- return (refs);
+ return refs;
}
domain->refs++;
ret->refs++;
virMutexUnlock(&domain->conn->lock);
- return(ret);
+ return ret;
error:
if (ret != NULL) {
VIR_FREE(ret->name);
VIR_FREE(ret);
}
- return(NULL);
+ return NULL;
}
if (refs == 0) {
virReleaseDomainSnapshot(snapshot);
/* Already unlocked mutex */
- return (0);
+ return 0;
}
virMutexUnlock(&snapshot->domain->conn->lock);
- return (refs);
+ return refs;
}
* allocation failed return VIR ERR NO MEMORY
* though it should not be used now.
*/
- return(2);
+ return 2;
case NETCF_EXMLPARSER:
/* XML parser choked */
return VIR_ERR_XML_ERROR;
static int lxcShutdown(void)
{
if (lxc_driver == NULL)
- return(-1);
+ return -1;
lxcDriverLock(lxc_driver);
virDomainObjListDeinit(&lxc_driver->domains);
int active;
if (lxc_driver == NULL)
- return(0);
+ return 0;
lxcDriverLock(lxc_driver);
active = virDomainObjListNumOfDomains(&lxc_driver->domains, 1);
*/
static int
ebiptablesCanApplyBasicRules(void) {
- return (ebtables_cmd_path != NULL);
+ return ebtables_cmd_path != NULL;
}
/**
}
normal:
/* priorities are limited to range [-1000, 1000] */
- return (insta->priority - instb->priority);
+ return insta->priority - instb->priority;
}
static int
if ((def->bios_vendor == NULL) && (def->bios_version == NULL) &&
(def->bios_date == NULL) && (def->bios_release == NULL))
- return(NULL);
+ return NULL;
virBufferAddLit(&buf, "type=0");
error:
virBufferFreeAndReset(&buf);
- return(NULL);
+ return NULL;
}
static char *qemuBuildSmbiosSystemStr(virSysinfoDefPtr def, bool skip_uuid)
error:
virBufferFreeAndReset(&buf);
- return(NULL);
+ return NULL;
}
static char *
if (virAsprintf(&ret, "%s/%s.save", driver->saveDir, vm->def->name) < 0) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
- return(ret);
+ return ret;
}
static int
if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
virReportOOMError();
- return(-1);
+ return -1;
}
if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR)
const char *customDaemon = getenv("LIBVIRTD_PATH");
if (customDaemon)
- return(customDaemon);
+ return customDaemon;
for (i = 0; serverPaths[i]; i++) {
if (virFileIsExecutable(serverPaths[i])) {
context_free(con);
err:
freecon(scontext);
- return (newcontext);
+ return newcontext;
}
static int
char *offset;
int baseLen;
if (!filename || filename[0] == '\0')
- return (NULL);
+ return NULL;
if (filename[0] == '/')
return strdup(filename);
xmlFreeDoc(xml);
testDriverUnlock(privconn);
- return (0);
+ return 0;
error:
xmlXPathFreeContext(ctxt);
unsigned long *hvVer)
{
*hvVer = 2;
- return (0);
+ return 0;
}
static int testIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
testDriverLock(privconn);
memcpy(info, &privconn->nodeInfo, sizeof(virNodeInfo));
testDriverUnlock(privconn);
- return (0);
+ return 0;
}
static char *testGetCapabilities (virConnectPtr conn)
if (VIR_ALLOC(ret) < 0) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
ret->filename = NULL;
ret->flags = 0;
- return(ret);
+ return ret;
}
/**
ret->filename = filename;
ret->flags = flags;
}
- return(ret);
+ return ret;
}
/**
virConfEntryPtr ret, prev;
if (conf == NULL)
- return(NULL);
+ return NULL;
if ((comm == NULL) && (name == NULL))
- return(NULL);
+ return NULL;
if (VIR_ALLOC(ret) < 0) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
ret->name = name;
prev = prev->next;
prev->next = ret;
}
- return(ret);
+ return ret;
}
/************************************************************************
virConfSaveValue(virBufferPtr buf, virConfValuePtr val)
{
if (val == NULL)
- return(-1);
+ return -1;
switch (val->type) {
case VIR_CONF_NONE:
- return(-1);
+ return -1;
case VIR_CONF_LONG:
virBufferAsprintf(buf, "%ld", val->l);
break;
break;
}
default:
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/**
virBufferAdd(buf, cur->comment, -1);
}
virBufferAddLit(buf, "\n");
- return(0);
+ return 0;
}
/************************************************************************
}
if ((ctxt->cur >= ctxt->end) || (!c_isdigit(CUR))) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated number"));
- return(-1);
+ return -1;
}
while ((ctxt->cur < ctxt->end) && (c_isdigit(CUR))) {
l = l * 10 + (CUR - '0');
if (neg)
l = -l;
*val = l;
- return(0);
+ return 0;
}
/**
NEXT;
if (CUR != '\'') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
- return(NULL);
+ return NULL;
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
if (!STRPREFIX(ctxt->cur, "\"\"\"")) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
- return(NULL);
+ return NULL;
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
NEXT;
if (CUR != '"') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
- return(NULL);
+ return NULL;
}
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
}
NEXT;
}
- return(ret);
+ return ret;
}
/**
SKIP_BLANKS;
if (ctxt->cur >= ctxt->end) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
- return(NULL);
+ return NULL;
}
if ((CUR == '"') || (CUR == '\'')) {
type = VIR_CONF_STRING;
str = virConfParseString(ctxt);
if (str == NULL)
- return(NULL);
+ return NULL;
} else if (CUR == '[') {
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("lists not allowed in VMX format"));
- return(NULL);
+ return NULL;
}
type = VIR_CONF_LIST;
NEXT;
SKIP_BLANKS_AND_EOL;
if ((ctxt->cur < ctxt->end) && (CUR != ']')) {
if ((lst = virConfParseValue(ctxt)) == NULL)
- return(NULL);
+ return NULL;
SKIP_BLANKS_AND_EOL;
}
while ((ctxt->cur < ctxt->end) && (CUR != ']')) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("expecting a separator in list"));
virConfFreeList(lst);
- return(NULL);
+ return NULL;
}
NEXT;
SKIP_BLANKS_AND_EOL;
tmp = virConfParseValue(ctxt);
if (tmp == NULL) {
virConfFreeList(lst);
- return(NULL);
+ return NULL;
}
prev = lst;
while (prev->next != NULL) prev = prev->next;
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("list is not closed with ]"));
virConfFreeList(lst);
- return(NULL);
+ return NULL;
}
} else if (c_isdigit(CUR) || (CUR == '-') || (CUR == '+')) {
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("numbers not allowed in VMX format"));
- return(NULL);
+ return NULL;
}
if (virConfParseLong(ctxt, &l) < 0) {
- return(NULL);
+ return NULL;
}
type = VIR_CONF_LONG;
} else {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
- return(NULL);
+ return NULL;
}
if (VIR_ALLOC(ret) < 0) {
virReportOOMError();
virConfFreeList(lst);
VIR_FREE(str);
- return(NULL);
+ return NULL;
}
ret->type = type;
ret->l = l;
ret->str = str;
ret->list = lst;
- return(ret);
+ return ret;
}
/**
if (!c_isalpha(CUR) &&
!((ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) && (CUR == '.'))) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a name"));
- return(NULL);
+ return NULL;
}
while ((ctxt->cur < ctxt->end) &&
(c_isalnum(CUR) || (CUR == '_') ||
ret = strndup(base, ctxt->cur - base);
if (ret == NULL) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
- return(ret);
+ return ret;
}
/**
char *comm;
if (CUR != '#')
- return(-1);
+ return -1;
NEXT;
base = ctxt->cur;
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
comm = strndup(base, ctxt->cur - base);
if (comm == NULL) {
virReportOOMError();
- return(-1);
+ return -1;
}
virConfAddEntry(ctxt->conf, NULL, NULL, comm);
- return(0);
+ return 0;
}
/**
{
SKIP_BLANKS;
if (ctxt->cur >= ctxt->end)
- return(0);
+ return 0;
if (IS_EOL(CUR)) {
SKIP_BLANKS_AND_EOL;
} else if (CUR == ';') {
SKIP_BLANKS_AND_EOL;
} else {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a separator"));
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/**
ctxt.conf = virConfCreate(filename, flags);
if (ctxt.conf == NULL)
- return(NULL);
+ return NULL;
while (ctxt.cur < ctxt.end) {
if (virConfParseStatement(&ctxt) < 0)
goto error;
}
- return(ctxt.conf);
+ return ctxt.conf;
error:
virConfFree(ctxt.conf);
- return(NULL);
+ return NULL;
}
/************************************************************************
if (filename == NULL) {
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
if ((len = virFileReadAll(filename, MAX_CONFIG_FILE_SIZE, &content)) < 0) {
{
if ((memory == NULL) || (len < 0)) {
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
if (len == 0)
len = strlen(memory);
- return(virConfParse("memory conf", memory, len, flags));
+ return virConfParse("memory conf", memory, len, flags);
}
/**
tmp = next;
}
VIR_FREE(conf);
- return(0);
+ return 0;
}
/**
((conf->flags & VIR_CONF_FLAG_VMX_FORMAT &&
STRCASEEQ(cur->name, setting)) ||
STREQ(cur->name, setting)))
- return(cur->value);
+ return cur->value;
cur = cur->next;
}
- return(NULL);
+ return NULL;
}
/**
if (VIR_ALLOC(cur) < 0) {
virReportOOMError();
virConfFreeValue(value);
- return (-1);
+ return -1;
}
cur->comment = NULL;
if (!(cur->name = strdup(setting))) {
virReportOOMError();
virConfFreeValue(value);
VIR_FREE(cur);
- return (-1);
+ return -1;
}
cur->value = value;
if (prev) {
virConfFreeValue(cur->value);
cur->value = value;
}
- return (0);
+ return 0;
}
unsigned int use;
if (conf == NULL)
- return(-1);
+ return -1;
cur = conf->entries;
while (cur != NULL) {
unsigned int use;
if ((memory == NULL) || (len == NULL) || (*len <= 0) || (conf == NULL))
- return(-1);
+ return -1;
cur = conf->entries;
while (cur != NULL) {
for (i = 0;i < VIR_HOOK_DRIVER_LAST;i++) {
res = virHookCheck(i, virHookDriverTypeToString(i));
if (res < 0)
- return(-1);
+ return -1;
if (res == 1) {
virHooksFound |= (1 << i);
ret++;
}
}
- return(ret);
+ return ret;
}
/**
virHookPresent(int driver) {
if ((driver < VIR_HOOK_DRIVER_DAEMON) ||
(driver >= VIR_HOOK_DRIVER_LAST))
- return(0);
+ return 0;
if (virHooksFound == -1)
- return(0);
+ return 0;
if ((virHooksFound & (1 << driver)) == 0)
- return(0);
- return(1);
+ return 0;
+ return 1;
}
/**
if ((driver < VIR_HOOK_DRIVER_DAEMON) ||
(driver >= VIR_HOOK_DRIVER_LAST))
- return(1);
+ return 1;
/*
* We cache the availability of the script to minimize impact at
virHookInitialize();
if ((virHooksFound & (1 << driver)) == 0)
- return(1);
+ return 1;
drvstr = virHookDriverTypeToString(driver);
virHookReportError(VIR_ERR_INTERNAL_ERROR,
_("Hook for %s, failed to find operation #%d"),
drvstr, op);
- return(1);
+ return 1;
}
subopstr = virHookSubopTypeToString(sub_op);
if (subopstr == NULL)
virHookReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to build path for %s hook"),
drvstr);
- return(-1);
+ return -1;
}
cmd = virCommandNewArgList(path, id, opstr, subopstr, extra, NULL);
if (VIR_ALLOC(ret) < 0) {
virReportOOMError();
- return (NULL);
+ return NULL;
}
ret->kind = SEXPR_NIL;
return ret;
sexpr_append(struct sexpr *lst, const struct sexpr *value)
{
if (lst == NULL)
- return (NULL);
+ return NULL;
if (value == NULL)
- return (lst);
+ return lst;
if (append(lst, value) < 0)
- return (NULL);
- return (lst);
+ return NULL;
+ return lst;
}
/**
{
while (IS_SPACE(*string))
string++;
- return (string);
+ return string;
}
/**
error:
sexpr_free(ret);
- return (NULL);
+ return NULL;
}
/**
if (lstat(linkpath, &st) < 0)
return -errno;
- return (S_ISLNK(st.st_mode) != 0);
+ return S_ISLNK(st.st_mode) != 0;
}
const char *cur = *str;
if ((*cur < '0') || (*cur > '9'))
- return (-1);
+ return -1;
while (c_isdigit(*cur)) {
unsigned int c = *cur - '0';
if ((ret > INT_MAX / 10) ||
((ret == INT_MAX / 10) && (c > INT_MAX % 10)))
- return (-1);
+ return -1;
ret = ret * 10 + c;
cur++;
}
*str = cur;
- return (ret);
+ return ret;
}
int err;
if (uuid == NULL)
- return(-1);
+ return -1;
if ((err = virUUIDGenerateRandomBytes(uuid, VIR_UUID_BUFLEN))) {
char ebuf[1024];
err = virUUIDGeneratePseudoRandomBytes(uuid, VIR_UUID_BUFLEN);
}
- return(err);
+ return err;
}
/**
if (uuid[i] == c)
ctr++;
- return (ctr != VIR_UUID_BUFLEN);
+ return ctr != VIR_UUID_BUFLEN;
}
static int
virHashComputeKey(virHashTablePtr table, const void *name)
{
uint32_t value = table->keyCode(name, table->seed);
- return (value % table->size);
+ return value % table->size;
}
/**
#endif
if (table == NULL)
- return (-1);
+ return -1;
if (size < 8)
- return (-1);
+ return -1;
if (size > 8 * 2048)
- return (-1);
+ return -1;
oldsize = table->size;
oldtable = table->table;
if (oldtable == NULL)
- return (-1);
+ return -1;
if (VIR_ALLOC_N(table->table, size) < 0) {
virReportOOMError();
table->table = oldtable;
- return (-1);
+ return -1;
}
table->size = size;
size, nbElem);
#endif
- return (0);
+ return 0;
}
/**
char *new_name;
if ((table == NULL) || (name == NULL))
- return (-1);
+ return -1;
if (table->iterating)
virHashIterationError(-1);
virHashSize(virHashTablePtr table)
{
if (table == NULL)
- return (-1);
- return (table->nbElems);
+ return -1;
+ return table->nbElems;
}
/**
virHashEntryPtr *nextptr;
if (table == NULL || name == NULL)
- return (-1);
+ return -1;
nextptr = table->table + virHashComputeKey(table, name);
for (entry = *nextptr; entry; entry = entry->next) {
size_t i, count = 0;
if (table == NULL || iter == NULL)
- return (-1);
+ return -1;
if (table->iterating)
virHashIterationError(-1);
}
table->iterating = false;
- return (count);
+ return count;
}
/**
size_t i, count = 0;
if (table == NULL || iter == NULL)
- return (-1);
+ return -1;
if (table->iterating)
virHashIterationError(-1);
size_t i;
if (table == NULL || iter == NULL)
- return (NULL);
+ return NULL;
if (table->iterating)
virHashIterationError(NULL);
/* On machines where 'char' and 'int' are types of the same size, the
difference of two 'unsigned char' values - including the sign bit -
doesn't fit in an 'int'. */
- return (c > d ? 1 : c < d ? -1 : 0);
+ return c > d ? 1 : c < d ? -1 : 0;
}
/**
bool
virNetlinkEventServiceIsRunning(void)
{
- return (server != NULL);
+ return server != NULL;
}
/**
int i;
if ((addr == NULL) || (tab == NULL) || (addr->data.stor.ss_family != AF_INET))
- return(-1);
+ return -1;
val = ntohl(addr->data.inet4.sin_addr.s_addr);
val >>= 8;
}
- return(0);
+ return 0;
}
static int virSocketAddrGetIPv6Addr(virSocketAddrPtr addr, virSocketAddrIPv6Ptr tab) {
int i;
if ((addr == NULL) || (tab == NULL) || (addr->data.stor.ss_family != AF_INET6))
- return(-1);
+ return -1;
for (i = 0;i < 8;i++) {
(*tab)[i] = ((addr->data.inet6.sin6_addr.s6_addr[2 * i] << 8) |
addr->data.inet6.sin6_addr.s6_addr[2 * i + 1]);
}
- return(0);
+ return 0;
}
/**
}
freeaddrinfo(res);
- return(len);
+ return len;
}
/*
int i;
if ((addr1 == NULL) || (addr2 == NULL) || (netmask == NULL))
- return(-1);
+ return -1;
if ((addr1->data.stor.ss_family != addr2->data.stor.ss_family) ||
(addr1->data.stor.ss_family != netmask->data.stor.ss_family))
- return(-1);
+ return -1;
if (virSocketAddrIsNetmask(netmask) != 0)
- return(-1);
+ return -1;
if (addr1->data.stor.ss_family == AF_INET) {
virSocketAddrIPv4 t1, t2, tm;
if ((virSocketAddrGetIPv4Addr(addr1, &t1) < 0) ||
(virSocketAddrGetIPv4Addr(addr2, &t2) < 0) ||
(virSocketAddrGetIPv4Addr(netmask, &tm) < 0))
- return(-1);
+ return -1;
for (i = 0;i < 4;i++) {
if ((t1[i] & tm[i]) != (t2[i] & tm[i]))
- return(0);
+ return 0;
}
} else if (addr1->data.stor.ss_family == AF_INET6) {
if ((virSocketAddrGetIPv6Addr(addr1, &t1) < 0) ||
(virSocketAddrGetIPv6Addr(addr2, &t2) < 0) ||
(virSocketAddrGetIPv6Addr(netmask, &tm) < 0))
- return(-1);
+ return -1;
for (i = 0;i < 8;i++) {
if ((t1[i] & tm[i]) != (t2[i] & tm[i]))
- return(0);
+ return 0;
}
} else {
- return(-1);
+ return -1;
}
- return(1);
+ return 1;
}
/**
int ret = 0, i;
if ((start == NULL) || (end == NULL))
- return(-1);
+ return -1;
if (start->data.stor.ss_family != end->data.stor.ss_family)
- return(-1);
+ return -1;
if (start->data.stor.ss_family == AF_INET) {
virSocketAddrIPv4 t1, t2;
if ((virSocketAddrGetIPv4Addr(start, &t1) < 0) ||
(virSocketAddrGetIPv4Addr(end, &t2) < 0))
- return(-1);
+ return -1;
for (i = 0;i < 2;i++) {
if (t1[i] != t2[i])
- return(-1);
+ return -1;
}
ret = (t2[2] - t1[2]) * 256 + (t2[3] - t1[3]);
if (ret < 0)
- return(-1);
+ return -1;
ret++;
} else if (start->data.stor.ss_family == AF_INET6) {
virSocketAddrIPv6 t1, t2;
if ((virSocketAddrGetIPv6Addr(start, &t1) < 0) ||
(virSocketAddrGetIPv6Addr(end, &t2) < 0))
- return(-1);
+ return -1;
for (i = 0;i < 7;i++) {
if (t1[i] != t2[i])
- return(-1);
+ return -1;
}
ret = t2[7] - t1[7];
if (ret < 0)
- return(-1);
+ return -1;
ret++;
} else {
- return(-1);
+ return -1;
}
- return(ret);
+ return ret;
}
static virLogPriority virErrorLevelPriority(virErrorLevel level) {
switch (level) {
case VIR_ERR_NONE:
- return(VIR_LOG_INFO);
+ return VIR_LOG_INFO;
case VIR_ERR_WARNING:
- return(VIR_LOG_WARN);
+ return VIR_LOG_WARN;
case VIR_ERR_ERROR:
- return(VIR_LOG_ERROR);
+ return VIR_LOG_ERROR;
}
- return(VIR_LOG_ERROR);
+ return VIR_LOG_ERROR;
}
static const char *virErrorDomainName(virErrorDomain domain) {
dom = "Auth ";
break;
}
- return(dom);
+ return dom;
}
switch (error) {
case VIR_ERR_OK:
- return (NULL);
+ return NULL;
case VIR_ERR_INTERNAL_ERROR:
if (info != NULL)
errmsg = _("internal error %s");
errmsg = _("numerical overflow: %s");
break;
}
- return (errmsg);
+ return errmsg;
}
/**
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathString()"));
- return (NULL);
+ return NULL;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
if ((obj == NULL) || (obj->type != XPATH_STRING) ||
(obj->stringval == NULL) || (obj->stringval[0] == 0)) {
xmlXPathFreeObject(obj);
- return (NULL);
+ return NULL;
}
ret = strdup((char *) obj->stringval);
xmlXPathFreeObject(obj);
if (ret == NULL) {
virReportOOMError();
}
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNumber()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
if ((obj == NULL) || (obj->type != XPATH_NUMBER) ||
(isnan(obj->floatval))) {
xmlXPathFreeObject(obj);
- return (-1);
+ return -1;
}
*value = obj->floatval;
xmlXPathFreeObject(obj);
- return (0);
+ return 0;
}
static int
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathLong()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
}
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathULong()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
}
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathULong()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
}
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathLongLong()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
}
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
char *
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathBoolean()"));
- return (-1);
+ return -1;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
if ((obj == NULL) || (obj->type != XPATH_BOOLEAN) ||
(obj->boolval < 0) || (obj->boolval > 1)) {
xmlXPathFreeObject(obj);
- return (-1);
+ return -1;
}
ret = obj->boolval;
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNode()"));
- return (NULL);
+ return NULL;
}
relnode = ctxt->node;
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
(obj->nodesetval == NULL) || (obj->nodesetval->nodeNr <= 0) ||
(obj->nodesetval->nodeTab == NULL)) {
xmlXPathFreeObject(obj);
- return (NULL);
+ return NULL;
}
ret = obj->nodesetval->nodeTab[0];
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
/**
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Invalid parameter to virXPathNodeSet()"));
- return (-1);
+ return -1;
}
if (list != NULL)
obj = xmlXPathEval(BAD_CAST xpath, ctxt);
ctxt->node = relnode;
if (obj == NULL)
- return(0);
+ return 0;
if (obj->type != XPATH_NODESET) {
virXMLError(VIR_ERR_INTERNAL_ERROR,
_("Incorrect xpath '%s'"), xpath);
xmlXPathFreeObject(obj);
- return (-1);
+ return -1;
}
if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr < 0)) {
xmlXPathFreeObject(obj);
- return (0);
+ return 0;
}
ret = obj->nodesetval->nodeNr;
}
}
xmlXPathFreeObject(obj);
- return (ret);
+ return ret;
}
xenUnifiedPrivatePtr priv;
if (!VIR_IS_CONNECTED_DOMAIN(dom))
- return (NULL);
+ return NULL;
priv = dom->conn->privateData;
if (priv->nbNodeCpus <= 0)
- return(NULL);
+ return NULL;
nb_vcpu = xenUnifiedDomainGetMaxVcpus(dom);
if (nb_vcpu <= 0)
- return(NULL);
+ return NULL;
if (xenUnifiedNodeGetInfo(dom->conn, &nodeinfo) < 0)
- return(NULL);
+ return NULL;
if (VIR_ALLOC_N(cpulist, priv->nbNodeCpus) < 0) {
virReportOOMError();
VIR_FREE(cpulist);
VIR_FREE(cpumap);
VIR_FREE(cpuinfo);
- return(res);
+ return res;
}
#ifdef WITH_LIBVIRTD
xenUnifiedUnlock(priv);
res = xenDaemonDomainGetXMLDesc(dom, flags, cpus);
VIR_FREE(cpus);
- return(res);
+ return res;
}
}
if (priv->opened[i] && drivers[i]->xenDomainGetSchedulerType) {
schedulertype = drivers[i]->xenDomainGetSchedulerType (dom, nparams);
if (schedulertype != NULL)
- return(schedulertype);
+ return schedulertype;
}
}
- return(NULL);
+ return NULL;
}
static int
if (priv->opened[i] && drivers[i]->xenDomainGetSchedulerParameters) {
ret = drivers[i]->xenDomainGetSchedulerParameters(dom, params, nparams);
if (ret == 0)
- return(0);
+ return 0;
}
}
- return(-1);
+ return -1;
}
static int
}
}
- return(-1);
+ return -1;
}
static int
ret = xenHypervisorNodeGetCellsFreeMemory (conn, &freeMem,
-1, 1);
if (ret != 1)
- return (0);
- return(freeMem);
+ return 0;
+ return freeMem;
}
xenUnifiedError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
- return(0);
+ return 0;
}
callback, opaque, freefunc);
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
ret = -1;
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
static int
lock_pages(void *addr, size_t len)
{
#ifdef __linux__
- return (mlock(addr, len));
+ return mlock(addr, len);
#elif defined(__sun)
- return (0);
+ return 0;
#endif
}
unlock_pages(void *addr, size_t len)
{
#ifdef __linux__
- return (munlock(addr, len));
+ return munlock(addr, len);
#elif defined(__sun)
- return (0);
+ return 0;
#endif
}
if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
}
if (ret < 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
/**
* xenHypervisorDoV1Op:
if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
}
if (ret < 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
/**
if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
}
if (ret < 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
/**
if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
}
if (ret < 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
/**
if (lock_pages(XEN_GETDOMAININFOLIST_DATA(dominfos),
XEN_GETDOMAININFO_SIZE * maxids) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
if (hv_versions.hypervisor > 1) {
xen_op_v2_sys op;
virXenError(VIR_ERR_XEN_CALL, " release");
ret = -1;
}
- return(ret);
+ return ret;
}
static int
op.cmd = XEN_V2_OP_GETSCHEDULERID;
ret = xenHypervisorDoV2Sys(priv->handle, &op);
if (ret < 0)
- return(NULL);
+ return NULL;
switch (op.u.getschedulerid.sched_id){
case XEN_SCHEDULER_SEDF:
/* TODO: Implement for Xen/SEDF */
TODO
- return(-1);
+ return -1;
case XEN_SCHEDULER_CREDIT:
memset(&op_dom, 0, sizeof(op_dom));
op_dom.cmd = XEN_V2_OP_SCHEDULER;
op_dom.u.getschedinfo.cmd = XEN_DOMCTL_SCHEDOP_getinfo;
ret = xenHypervisorDoV2Dom(priv->handle, &op_dom);
if (ret < 0)
- return(-1);
+ return -1;
if (virTypedParameterAssign(¶ms[0],
VIR_DOMAIN_SCHEDULER_WEIGHT,
case XEN_SCHEDULER_SEDF:
/* TODO: Implement for Xen/SEDF */
TODO
- return(-1);
+ return -1;
case XEN_SCHEDULER_CREDIT: {
memset(&op_dom, 0, sizeof(op_dom));
op_dom.cmd = XEN_V2_OP_SCHEDULER;
virXenError(VIR_ERR_INVALID_ARG,
_("Credit scheduler weight parameter (%d) "
"is out of range (1-65535)"), val);
- return(-1);
+ return -1;
}
op_dom.u.getschedinfo.u.credit.weight = val;
} else if (STREQ(params[i].field, VIR_DOMAIN_SCHEDULER_CAP)) {
virXenError(VIR_ERR_INVALID_ARG,
_("Credit scheduler cap parameter (%d) is "
"out of range (0-65534)"), val);
- return(-1);
+ return -1;
}
op_dom.u.getschedinfo.u.credit.cap = val;
}
op.u.domain.domain = (domid_t) id;
ret = xenHypervisorDoV0Op(handle, &op);
}
- return(ret);
+ return ret;
}
/**
op.u.domain.domain = (domid_t) id;
ret = xenHypervisorDoV0Op(handle, &op);
}
- return(ret);
+ return ret;
}
/**
op.u.domain.domain = (domid_t) id;
ret = xenHypervisorDoV0Op(handle, &op);
}
- return(ret);
+ return ret;
}
/**
op.u.setmaxmem.maxmem = memory;
ret = xenHypervisorDoV0Op(handle, &op);
}
- return(ret);
+ return ret;
}
/**
op.u.setmaxvcpu.maxvcpu = vcpus;
ret = xenHypervisorDoV0Op(handle, &op);
}
- return(ret);
+ return ret;
}
/**
if (lock_pages(cpumap, maplen) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
memset(&op, 0, sizeof(op));
op.cmd = XEN_V2_OP_SETVCPUMAP;
if (maplen < 8) {
if (VIR_ALLOC_N(new, sizeof(uint64_t)) < 0) {
virReportOOMError();
- return (-1);
+ return -1;
}
memcpy(new, cpumap, maplen);
bitmap = new;
int j;
if ((maplen > (int)sizeof(cpumap_t)) || (sizeof(cpumap_t) & 7))
- return (-1);
+ return -1;
memset(pm, 0, sizeof(cpumap_t));
for (j = 0; j < maplen; j++)
ret = xenHypervisorDoV0Op(handle, &op);
}
}
- return(ret);
+ return ret;
}
ret = xenHypervisorDoV2Dom(handle, &op);
if (ret < 0)
- return(-1);
+ return -1;
ipt->number = vcpu;
if (hv_versions.dom_interface < 5) {
if (op.u.getvcpuinfo.online) {
if ((cpumap != NULL) && (maplen > 0)) {
if (lock_pages(cpumap, maplen) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking");
- return (-1);
+ return -1;
}
memset(cpumap, 0, maplen);
memset(&op, 0, sizeof(op));
op.u.getvcpuinfo.vcpu = vcpu;
ret = xenHypervisorDoV1Op(handle, &op);
if (ret < 0)
- return(-1);
+ return -1;
ipt->number = vcpu;
if (op.u.getvcpuinfo.online) {
if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
op.u.getvcpuinfo.vcpu = vcpu;
ret = xenHypervisorDoV0Op(handle, &op);
if (ret < 0)
- return(-1);
+ return -1;
ipt->number = vcpu;
if (op.u.getvcpuinfo.online) {
if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
}
}
}
- return(ret);
+ return ret;
}
/**
if (initialized) {
if (hv_versions.hypervisor == -1)
- return (-1);
- return(0);
+ return -1;
+ return 0;
}
initialized = 1;
in_init = 1;
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
if (ret < 0) {
hv_versions.hypervisor = -1;
- return(-1);
+ return -1;
}
fd = ret;
(unsigned long) IOCTL_PRIVCMD_HYPERCALL);
VIR_FORCE_CLOSE(fd);
in_init = 0;
- return(-1);
+ return -1;
detect_v2:
/*
if (VIR_ALLOC(ipt) < 0) {
virReportOOMError();
- return(-1);
+ return -1;
}
/* Currently consider RHEL5.0 Fedora7, xen-3.1, and xen-unstable */
hv_versions.sys_interface = 2; /* XEN_SYSCTL_INTERFACE_VERSION */
VIR_FORCE_CLOSE(fd);
in_init = 0;
VIR_FREE(ipt);
- return(-1);
+ return -1;
done:
VIR_FORCE_CLOSE(fd);
in_init = 0;
VIR_FREE(ipt);
- return(0);
+ return 0;
}
/**
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
if (ret < 0) {
virXenError(VIR_ERR_NO_XEN, "%s", XEN_HYPERVISOR_SOCKET);
- return (-1);
+ return -1;
}
priv->handle = ret;
- return(0);
+ return 0;
}
/**
xenUnifiedPrivatePtr priv;
if (conn == NULL)
- return (-1);
+ return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
ret = VIR_CLOSE(priv->handle);
if (ret < 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0 || hvVer == NULL)
- return (-1);
+ return -1;
*hvVer = (hv_versions.hv >> 16) * 1000000 + (hv_versions.hv & 0xFFFF) * 1000;
- return(0);
+ return 0;
}
struct guest_arch {
return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0)
- return (-1);
+ return -1;
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
virReportOOMError();
- return(-1);
+ return -1;
}
XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
XEN_GETDOMAININFOLIST_FREE(dominfos);
if (ret < 0)
- return (-1);
+ return -1;
nbids = ret;
/* Can't possibly have more than 65,000 concurrent guests
nbids = -1;
}
if ((nbids < 0) || (nbids > maxids))
- return(-1);
- return(nbids);
+ return -1;
+ return nbids;
}
/**
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0 ||
(ids == NULL) || (maxids < 0))
- return (-1);
+ return -1;
if (maxids == 0)
- return(0);
+ return 0;
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
virReportOOMError();
- return(-1);
+ return -1;
}
XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
if (ret < 0) {
XEN_GETDOMAININFOLIST_FREE(dominfos);
- return (-1);
+ return -1;
}
nbids = ret;
if ((nbids < 0) || (nbids > maxids)) {
XEN_GETDOMAININFOLIST_FREE(dominfos);
- return(-1);
+ return -1;
}
for (i = 0;i < nbids;i++) {
}
XEN_GETDOMAININFOLIST_FREE(dominfos);
- return (nbids);
+ return nbids;
}
if (priv->handle < 0) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("domain shut off or invalid"));
- return (NULL);
+ return NULL;
}
/* HV's earlier than 3.1.0 don't include the HVM flags in guests status*/
hv_versions.dom_interface < 4) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unsupported in dom interface < 4"));
- return (NULL);
+ return NULL;
}
XEN_GETDOMAININFO_CLEAR(dominfo);
if (virXen_getdomaininfo(priv->handle, dom->id, &dominfo) < 0) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get domain details"));
- return (NULL);
+ return NULL;
}
if (XEN_GETDOMAININFO_DOMAIN(dominfo) != dom->id) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get domain details"));
- return (NULL);
+ return NULL;
}
if (XEN_GETDOMAININFO_FLAGS(dominfo) & DOMFLAGS_HVM)
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0)
- return (NULL);
+ return NULL;
XEN_GETDOMAININFO_CLEAR(dominfo);
if (virXen_getdomaininfo(priv->handle, id, &dominfo) < 0)
- return (NULL);
+ return NULL;
if (XEN_GETDOMAININFO_DOMAIN(dominfo) != id)
- return (NULL);
+ return NULL;
xenUnifiedLock(priv);
name = xenStoreDomainGetName(conn, id);
xenUnifiedUnlock(priv);
if (!name)
- return (NULL);
+ return NULL;
ret = virGetDomain(conn, name, XEN_GETDOMAININFO_UUID(dominfo));
if (ret)
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0)
- return (NULL);
+ return NULL;
retry:
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
virReportOOMError();
- return(NULL);
+ return NULL;
}
XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
if (nids < 0) {
XEN_GETDOMAININFOLIST_FREE(dominfos);
- return (NULL);
+ return NULL;
}
/* Can't possibly have more than 65,000 concurrent guests
maxids *= 2;
goto retry;
}
- return (NULL);
+ return NULL;
}
id = -1;
XEN_GETDOMAININFOLIST_FREE(dominfos);
if (id == -1)
- return (NULL);
+ return NULL;
xenUnifiedLock(priv);
name = xenStoreDomainGetName(conn, id);
xenUnifiedUnlock(priv);
if (!name)
- return (NULL);
+ return NULL;
ret = virGetDomain(conn, name, uuid);
if (ret)
return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0)
- return (-1);
+ return -1;
return MAX_VIRT_CPUS;
}
ret = virXen_getdomaininfo(priv->handle, id, &dominfo);
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
- return (0);
+ return 0;
- return((unsigned long) XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages);
+ return (unsigned long) XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0)
- return (0);
+ return 0;
- return(xenHypervisorGetDomMaxMemory(domain->conn, domain->id));
+ return xenHypervisorGetDomMaxMemory(domain->conn, domain->id);
}
/**
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->handle < 0 || info == NULL)
- return (-1);
+ return -1;
memset(info, 0, sizeof(virDomainInfo));
XEN_GETDOMAININFO_CLEAR(dominfo);
ret = virXen_getdomaininfo(priv->handle, id, &dominfo);
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
- return (-1);
+ return -1;
domain_flags = XEN_GETDOMAININFO_FLAGS(dominfo);
domain_flags &= ~DOMFLAGS_HVM; /* Mask out HVM flags */
if(info->maxMem != UINT_MAX)
info->maxMem *= kb_per_pages;
info->nrVirtCpu = XEN_GETDOMAININFO_CPUCOUNT(dominfo);
- return (0);
+ return 0;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || info == NULL ||
(domain->id < 0))
- return (-1);
+ return -1;
- return(xenHypervisorGetDomInfo(domain->conn, domain->id, info));
+ return xenHypervisorGetDomInfo(domain->conn, domain->id, info);
}
if (priv->nbNodeCells < 0) {
virXenError(VIR_ERR_XEN_CALL, "%s",
_("cannot determine actual number of cells"));
- return(-1);
+ return -1;
}
if ((maxCells < 1) || (startCell >= priv->nbNodeCells)) {
op_sys.u.availheap.node = i;
ret = xenHypervisorDoV2Sys(priv->handle, &op_sys);
if (ret < 0) {
- return(-1);
+ return -1;
}
if (hv_versions.sys_interface >= 5)
freeMems[j] = op_sys.u.availheap5.avail_bytes;
else
freeMems[j] = op_sys.u.availheap.avail_bytes;
}
- return (j);
+ return j;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0)
- return (-1);
+ return -1;
ret = virXen_pausedomain(priv->handle, domain->id);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0)
- return (-1);
+ return -1;
ret = virXen_unpausedomain(priv->handle, domain->id);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0)
- return (-1);
+ return -1;
ret = virXen_destroydomain(priv->handle, domain->id);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0)
- return (-1);
+ return -1;
ret = virXen_setmaxmem(priv->handle, domain->id, memory);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || domain->id < 0 || nvcpus < 1)
- return (-1);
+ return -1;
ret = virXen_setmaxvcpus(priv->handle, domain->id, nvcpus);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0 || (domain->id < 0) ||
(cpumap == NULL) || (maplen < 1))
- return (-1);
+ return -1;
ret = virXen_setvcpumap(priv->handle, domain->id, vcpu,
cpumap, maplen);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
(sizeof(cpumap_t) & 7)) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("domain shut off or invalid"));
- return (-1);
+ return -1;
}
if ((cpumaps != NULL) && (maplen < 1)) {
virXenError(VIR_ERR_INVALID_ARG, "%s",
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id)) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get domain details"));
- return (-1);
+ return -1;
}
nbinfo = XEN_GETDOMAININFO_CPUCOUNT(dominfo) + 1;
if (nbinfo > maxinfo) nbinfo = maxinfo;
if (ret < 0) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get VCPUs info"));
- return(-1);
+ return -1;
}
} else {
ret = virXen_getvcpusinfo(priv->handle, domain->id, i,
if (ret < 0) {
virXenError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get VCPUs info"));
- return(-1);
+ return -1;
}
}
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->handle < 0)
- return (-1);
+ return -1;
/* inactive domain */
if (domain->id < 0) {
&dominfo);
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id))
- return (-1);
+ return -1;
maxcpu = XEN_GETDOMAININFO_MAXCPUID(dominfo) + 1;
}
virXendError(VIR_ERR_INTERNAL_ERROR,
"%s", _("failed to write to Xen Daemon"));
- return (-1);
+ return -1;
}
offset += len;
size_t offset;
if (n_buffer < 1)
- return (-1);
+ return -1;
for (offset = 0; offset < (n_buffer - 1); offset++) {
ssize_t ret;
xenUnifiedPrivatePtr priv;
if ((conn == NULL) || (path == NULL))
- return (-1);
+ return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
memset(&priv->addr, 0, sizeof(priv->addr));
if (virStrcpyStatic(addr->sun_path, path) == NULL)
return -1;
- return (0);
+ return 0;
}
int ret;
if ((conn == NULL) || (host == NULL) || (port == NULL))
- return (-1);
+ return -1;
priv = (xenUnifiedPrivatePtr) conn->privateData;
error:
sexpr_free(root);
- return (ret);
+ return ret;
}
}
sexpr_free(root);
- return (0);
+ return 0;
error:
sexpr_free(root);
if (domname)
VIR_FREE(*domname);
- return (-1);
+ return -1;
}
if (!VIR_IS_CONNECT(conn)) {
virXendError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) conn->privateData;
root = sexpr_get(conn, "/xend/node/");
if (root == NULL)
- return (-1);
+ return -1;
value = sexpr_node(root, "node/xend_config_format");
priv->xendConfigVersion = XEND_CONFIG_VERSION_3_0_2;
}
sexpr_free(root);
- return (0);
+ return 0;
}
int vcpus;
if ((root == NULL) || (info == NULL))
- return (-1);
+ return -1;
info->state = sexpr_to_xend_domain_state(domain, root);
info->memory = sexpr_u64(root, "domain/memory") << 10;
if (!info->nrVirtCpu || vcpus < info->nrVirtCpu)
info->nrVirtCpu = vcpus;
- return (0);
+ return 0;
}
/**
if ((root == NULL) || (info == NULL))
- return (-1);
+ return -1;
machine = sexpr_node(root, "node/machine");
if (machine == NULL) {
int nr_cpus = sexpr_int(root, "node/nr_cpus");
int procs = info->nodes * info->cores * info->threads;
if (procs == 0) /* Sanity check in case of Xen bugs in futures..*/
- return (-1);
+ return -1;
info->sockets = nr_cpus / procs;
}
info->sockets = info->cpus / (info->cores * info->threads);
}
- return (0);
+ return 0;
}
}
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
- return (0);
+ return 0;
parse_error:
virXendError(VIR_ERR_XEN_CALL, "%s", _("topology syntax error"));
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
- return (-1);
+ return -1;
memory_error:
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
virReportOOMError();
- return (-1);
+ return -1;
}
xenUnifiedPrivatePtr priv;
if ((conn == NULL) || (root == NULL))
- return(NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) conn->privateData;
else
ret->id = -1; /* An inactive domain */
- return (ret);
+ return ret;
error:
virXendError(VIR_ERR_INTERNAL_ERROR,
"%s", _("failed to parse Xend domain information"));
if (ret != NULL)
virUnrefDomain(ret);
- return(NULL);
+ return NULL;
}
{
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "pause", NULL);
{
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "unpause", NULL);
{
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "shutdown", "reason", "poweroff", NULL);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "shutdown", "reason", "reboot", NULL);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "destroy", NULL);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(NULL);
+ return NULL;
/* can we ask for a subset ? worth it ? */
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL)
- return(NULL);
+ return NULL;
if (sexpr_lookup(root, "domain/image/hvm")) {
type = strdup("hvm");
sexpr_free(root);
- return(type);
+ return type;
}
/**
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL) ||
(filename == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
/* We can't save the state of Domain-0, that would mean stopping it too */
if (domain->id == 0) {
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name, "op", "save", "file", filename, NULL);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL) ||
(filename == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id < 0) {
virXendError(VIR_ERR_OPERATION_INVALID,
_("Domain %s isn't running."), domain->name);
- return(-1);
+ return -1;
}
return xend_op(domain->conn, domain->name,
if ((conn == NULL) || (filename == NULL)) {
/* this should be caught at the interface but ... */
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
return xend_op(conn, "", "op", "restore", "file", filename, NULL);
}
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
snprintf(buf, sizeof(buf), "%lu", VIR_DIV_UP(memory, 1024));
return xend_op(domain->conn, domain->name, "op", "maxmem_set", "memory",
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
snprintf(buf, sizeof(buf), "%lu", VIR_DIV_UP(memory, 1024));
return xend_op(domain->conn, domain->name, "op", "mem_target_set",
else
root = sexpr_get(conn, "/xend/domain/%d?detail=1", domid);
if (root == NULL)
- return (NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) conn->privateData;
cleanup:
sexpr_free(root);
- return (def);
+ return def;
}
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) {
/* fall-through to the next driver to handle */
- return(NULL);
+ return NULL;
}
if (!(def = xenDaemonDomainFetch(domain->conn,
domain->id,
domain->name,
cpus)))
- return(NULL);
+ return NULL;
xml = virDomainDefFormat(def, flags);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL) ||
(info == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL)
- return (-1);
+ return -1;
ret = sexpr_to_xend_domain_info(domain, root, info);
sexpr_free(root);
- return (ret);
+ return ret;
}
if ((conn == NULL) || (domname == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
root = sexpr_get(conn, "/xend/domain/%s?detail=1", domname);
error:
sexpr_free(root);
- return(ret);
+ return ret;
}
if (!VIR_IS_CONNECT(conn)) {
virXendError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
if (info == NULL) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
root = sexpr_get(conn, "/xend/node/");
if (root == NULL)
- return (-1);
+ return -1;
ret = sexpr_to_xend_node_info(root, info);
sexpr_free(root);
- return (ret);
+ return ret;
}
/**
if (!VIR_IS_CONNECT(conn)) {
virXendError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
if (caps == NULL) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
root = sexpr_get(conn, "/xend/node/");
if (root == NULL) {
- return (-1);
+ return -1;
}
ret = sexpr_to_xend_topology(root, caps);
sexpr_free(root);
- return (ret);
+ return ret;
}
/**
if (!VIR_IS_CONNECT(conn)) {
virXendError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
if (hvVer == NULL) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
root = sexpr_get(conn, "/xend/node/");
if (root == NULL)
- return(-1);
+ return -1;
major = sexpr_int(root, "node/xen_major");
minor = sexpr_int(root, "node/xen_minor");
sexpr_free(root);
version = major * 1000000 + minor * 1000;
*hvVer = version;
- return(0);
+ return 0;
}
long id;
if (maxids == 0)
- return(0);
+ return 0;
if ((ids == NULL) || (maxids < 0))
goto error;
error:
sexpr_free(root);
- return(ret);
+ return ret;
}
/**
error:
sexpr_free(root);
- return(ret);
+ return ret;
}
ret->id = id;
VIR_FREE(name);
- return (ret);
+ return ret;
error:
VIR_FREE(name);
- return (NULL);
+ return NULL;
}
/**
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)
|| (vcpus < 1)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)
|| (cpumap == NULL) || (maplen < 1) || (maplen > (int)sizeof(cpumap_t))) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (virDomainVcpuPinAdd(def, cpumap, maplen, vcpu) < 0) {
virXendError(VIR_ERR_INTERNAL_ERROR,
"%s", _("failed to add vcpupin xml entry"));
- return (-1);
+ return -1;
}
}
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)
|| (info == NULL) || (maxinfo < 1)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
if (cpumaps != NULL && maplen < 1) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
root = sexpr_get(domain->conn, "/xend/domain/%s?op=vcpuinfo", domain->name);
if (root == NULL)
- return (-1);
+ return -1;
if (cpumaps != NULL)
memset(cpumaps, 0, maxinfo * maplen);
}
}
sexpr_free(root);
- return(nbinfo);
+ return nbinfo;
}
/**
tmp = names;
if (names == NULL) {
- return (NULL);
+ return NULL;
}
while (*tmp != NULL) {
id = xenDaemonDomainLookupByName_ids(conn, *tmp, &ident[0]);
virUUIDFormat(uuid, uuidstr);
root = sexpr_get(conn, "/xend/domain/%s?detail=1", uuidstr);
if (root == NULL)
- return (NULL);
+ return NULL;
domname = (char*)sexpr_node(root, "domain/name");
if (sexpr_node(root, "domain/domid")) /* only active domains have domid */
id = sexpr_int(root, "domain/domid");
}
if (name == NULL)
- return (NULL);
+ return NULL;
ret = virGetDomain(conn, name, uuid);
if (ret == NULL) goto cleanup;
cleanup:
VIR_FREE(name);
- return (ret);
+ return ret;
}
/**
if (!(def = virDomainDefParseString(priv->caps, xmlDesc,
1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
- return (NULL);
+ return NULL;
if (!(sexpr = xenFormatSxpr(conn, def, priv->xendConfigVersion))) {
virDomainDefFree(def);
- return (NULL);
+ return NULL;
}
ret = xenDaemonDomainCreateXML(conn, sexpr);
goto error;
virDomainDefFree(def);
- return (dom);
+ return dom;
error:
/* Make sure we don't leave a still-born domain around */
virUnrefDomain(dom);
}
virDomainDefFree(def);
- return (NULL);
+ return NULL;
}
/**
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
/* xm_internal.c (the support for defined domains from /etc/xen
*/
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL) {
virXendError(VIR_ERR_XEN_CALL,
"%s", _("xenDaemonGetAutostart failed to find this domain"));
- return (-1);
+ return -1;
}
*autostart = 0;
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INTERNAL_ERROR, __FUNCTION__);
- return (-1);
+ return -1;
}
/* xm_internal.c (the support for defined domains from /etc/xen
*/
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL) {
virXendError(VIR_ERR_XEN_CALL,
"%s", _("xenDaemonSetAutostart failed to find this domain"));
- return (-1);
+ return -1;
}
autonode = sexpr_lookup(root, "domain/on_xend_start");
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(NULL);
+ return NULL;
if (!(def = virDomainDefParseString(priv->caps, xmlDesc,
1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE))) {
virXendError(VIR_ERR_XML_ERROR,
"%s", _("failed to parse domain description"));
- return (NULL);
+ return NULL;
}
if (!(sexpr = xenFormatSxpr(conn, def, priv->xendConfigVersion))) {
goto error;
}
virDomainDefFree(def);
- return (dom);
+ return dom;
error:
virDomainDefFree(def);
- return (NULL);
+ return NULL;
}
int xenDaemonDomainCreate(virDomainPtr domain)
{
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
ret = xend_op(domain->conn, domain->name, "op", "start", NULL);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
return xend_op(domain->conn, domain->name, "op", "delete", NULL);
}
* config files used by old Xen) will handle this.
*/
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
root = sexpr_get(conn, "/xend/domain?state=halted");
if (root == NULL)
error:
sexpr_free(root);
- return(ret);
+ return ret;
}
static int
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
- return(-1);
+ return -1;
if ((names == NULL) || (maxnames < 0))
goto error;
if (maxnames == 0)
- return(0);
+ return 0;
root = sexpr_get(conn, "/xend/domain?state=halted");
if (root == NULL)
cleanup:
sexpr_free(root);
- return(ret);
+ return ret;
error:
for (i = 0; i < ret; ++i)
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
/* Support only xendConfigVersion >=4 */
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_1_0) {
virXendError(VIR_ERR_OPERATION_INVALID,
"%s", _("unsupported in xendConfigVersion < 4"));
- return (-1);
+ return -1;
}
/* look up the information by domain name */
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL)
- return (-1);
+ return -1;
/* get the scheduler type */
sched_type = xenDaemonGetSchedulerType(domain, &sched_nparam);
error:
sexpr_free(root);
VIR_FREE(sched_type);
- return (ret);
+ return ret;
}
/**
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
/* Support only xendConfigVersion >=4 and active domains */
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_1_0) {
virXendError(VIR_ERR_OPERATION_INVALID,
"%s", _("unsupported in xendConfigVersion < 4"));
- return (-1);
+ return -1;
}
/* look up the information by domain name */
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL)
- return (-1);
+ return -1;
/* get the scheduler type */
sched_type = xenDaemonGetSchedulerType(domain, &sched_nparam);
error:
sexpr_free(root);
VIR_FREE(sched_type);
- return (ret);
+ return ret;
}
/**
if (nameowner && STREQ(nameowner, key)) {
virHashRemoveEntry(args->priv->nameConfigMap, olddomname);
}
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
if (now == ((time_t)-1)) {
virReportSystemError(errno,
"%s", _("cannot get time of day"));
- return (-1);
+ return -1;
}
/* Rate limit re-scans */
if ((now - priv->lastRefresh) < XM_REFRESH_INTERVAL)
- return (0);
+ return 0;
priv->lastRefresh = now;
virReportSystemError(errno,
_("cannot read directory %s"),
priv->configDir);
- return (-1);
+ return -1;
}
while ((ent = readdir(dh))) {
closedir(dh);
- return (ret);
+ return ret;
}
priv->configCache = virHashCreate(50, xenXMConfigFree);
if (!priv->configCache)
- return (-1);
+ return -1;
priv->nameConfigMap = virHashCreate(50, NULL);
if (!priv->nameConfigMap) {
virHashFree(priv->configCache);
priv->configCache = NULL;
- return (-1);
+ return -1;
}
/* Force the cache to be reloaded next time that
* xenXMConfigCacheRefresh is called.
*/
priv->lastRefresh = 0;
- return (0);
+ return 0;
}
/*
virHashFree(priv->nameConfigMap);
virHashFree(priv->configCache);
- return (0);
+ return 0;
}
/*
xenXMConfCachePtr entry;
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id != -1)
- return (-1);
+ return -1;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
info->cpuTime = 0;
xenUnifiedUnlock(priv);
- return (0);
+ return 0;
error:
xenUnifiedUnlock(priv);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
if (domain->id != -1)
- return (NULL);
+ return NULL;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
if (domain->conn->flags & VIR_CONNECT_RO)
- return (-1);
+ return -1;
if (domain->id != -1)
- return (-1);
+ return -1;
if (memory < 1024 * MIN_XEN_GUEST_SIZE)
- return (-1);
+ return -1;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
if (domain->conn->flags & VIR_CONNECT_RO)
- return (-1);
+ return -1;
if (domain->id != -1)
- return (-1);
+ return -1;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (0);
+ return 0;
}
if (domain->id != -1)
- return (0);
+ return 0;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
VIR_FREE(mapsave);
VIR_FREE(cpuset);
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
/*
if (!VIR_IS_CONNECT(conn)) {
xenXMError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (NULL);
+ return NULL;
}
if (domname == NULL) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (NULL);
+ return NULL;
}
priv = conn->privateData;
cleanup:
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
const xenXMConfCachePtr entry = (const xenXMConfCachePtr)payload;
if (!memcmp(entry->def->uuid, wantuuid, VIR_UUID_BUFLEN))
- return (1);
+ return 1;
- return (0);
+ return 0;
}
/*
if (!VIR_IS_CONNECT(conn)) {
xenXMError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (NULL);
+ return NULL;
}
if (uuid == NULL) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (NULL);
+ return NULL;
}
priv = conn->privateData;
cleanup:
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id != -1)
- return (-1);
+ return -1;
xenUnifiedLock(priv);
goto error;
xenUnifiedUnlock(priv);
- return (0);
+ return 0;
error:
if (domain->id != -1) {
domain->id = -1;
}
xenUnifiedUnlock(priv);
- return (-1);
+ return -1;
}
/*
if (!VIR_IS_CONNECT(conn)) {
xenXMError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (NULL);
+ return NULL;
}
if (xml == NULL) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (NULL);
+ return NULL;
}
if (conn->flags & VIR_CONNECT_RO)
- return (NULL);
+ return NULL;
xenUnifiedLock(priv);
if (!xenInotifyActive(conn) && xenXMConfigCacheRefresh (conn) < 0) {
xenUnifiedUnlock(priv);
- return (NULL);
+ return NULL;
}
if (!(def = virDomainDefParseString(priv->caps, xml,
1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE))) {
xenUnifiedUnlock(priv);
- return (NULL);
+ return NULL;
}
if (!(conf = xenFormatXM(conn, def, priv->xendConfigVersion)))
ret = virGetDomain(conn, def->name, def->uuid);
xenUnifiedUnlock(priv);
VIR_FREE(filename);
- return (ret);
+ return ret;
error:
VIR_FREE(filename);
virConfFree(conf);
virDomainDefFree(def);
xenUnifiedUnlock(priv);
- return (NULL);
+ return NULL;
}
/*
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
xenXMError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return (-1);
+ return -1;
}
if (domain->id != -1)
- return (-1);
+ return -1;
if (domain->conn->flags & VIR_CONNECT_RO)
- return (-1);
+ return -1;
priv = domain->conn->privateData;
xenUnifiedLock(priv);
if (!VIR_IS_CONNECT(conn)) {
xenXMError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = conn->privateData;
if (!VIR_IS_CONNECT(conn)) {
xenXMError(VIR_ERR_INVALID_CONN, __FUNCTION__);
- return (-1);
+ return -1;
}
priv = conn->privateData;
cleanup:
virDomainDeviceDefFree(dev);
xenUnifiedUnlock(priv);
- return (ret);
+ return ret;
}
int
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL || path == NULL || nb == NULL)
- return (NULL);
+ return NULL;
return xs_directory (priv->xshandle, 0, path, nb);
}
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
snprintf(s, 255, "/local/domain/%d/%s", domid, path);
s[255] = 0;
int ret = -1;
if (!VIR_IS_CONNECTED_DOMAIN(domain))
- return (-1);
+ return -1;
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xshandle == NULL)
- return (-1);
+ return -1;
if (domain->conn->flags & VIR_CONNECT_RO)
- return (-1);
+ return -1;
snprintf(s, 255, "/local/domain/%d/%s", domain->id, path);
s[255] = 0;
if (xs_write(priv->xshandle, 0, &s[0], value, strlen(value)))
ret = 0;
- return (ret);
+ return ret;
}
/**
xenUnifiedPrivatePtr priv;
if (!VIR_IS_CONNECTED_DOMAIN(domain))
- return (NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
snprintf(query, 199, "/local/domain/%d/vm", virDomainGetID(domain));
query[199] = 0;
vm = xs_read(priv->xshandle, 0, &query[0], &len);
- return (vm);
+ return vm;
}
/**
xenUnifiedPrivatePtr priv;
if (!VIR_IS_CONNECTED_DOMAIN(domain))
- return (NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
snprintf(s, 255, "%s/%s", vm, name);
s[255] = 0;
ret = xs_read(priv->xshandle, 0, &s[0], &len);
- return (ret);
+ return ret;
}
virXenStoreError(VIR_ERR_NO_XEN,
"%s", _("failed to connect to Xen Store"));
}
- return (-1);
+ return -1;
}
/* Init activeDomainList */
if (conn == NULL) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) conn->privateData;
priv->activeDomainList = NULL;
if (priv->xshandle == NULL)
- return(-1);
+ return -1;
if (priv->xsWatch != -1)
virEventRemoveHandle(priv->xsWatch);
xs_daemon_close(priv->xshandle);
priv->xshandle = NULL;
- return (0);
+ return 0;
}
/**
xenUnifiedPrivatePtr priv;
if (!VIR_IS_CONNECTED_DOMAIN(domain))
- return (-1);
+ return -1;
if ((domain == NULL) || (domain->conn == NULL) || (info == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xshandle == NULL)
- return(-1);
+ return -1;
if (domain->id == -1)
- return(-1);
+ return -1;
tmp = virDomainDoStoreQuery(domain->conn, domain->id, "running");
if (tmp != NULL) {
info->nrVirtCpu = nb_vcpus;
VIR_FREE(tmp2);
}
- return (0);
+ return 0;
}
/**
if ((domain == NULL) || (domain->conn == NULL) ||
(memory < 1024 * MIN_XEN_GUEST_SIZE)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id == -1)
- return(-1);
+ return -1;
if ((domain->id == 0) && (memory < (2 * MIN_XEN_GUEST_SIZE * 1024)))
- return(-1);
+ return -1;
snprintf(value, 19, "%lu", memory);
value[19] = 0;
ret = virDomainDoStoreWrite(domain, "memory/target", &value[0]);
if (ret < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
/**
xenUnifiedPrivatePtr priv;
if (!VIR_IS_CONNECTED_DOMAIN(domain))
- return (ret);
+ return ret;
if (domain->id == -1)
return 0;
VIR_FREE(tmp);
}
xenUnifiedUnlock(priv);
- return(ret);
+ return ret;
}
/**
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
idlist = xs_directory(priv->xshandle, 0, "/local/domain", &num);
VIR_FREE (idlist);
ret = realnum;
}
- return(ret);
+ return ret;
}
/**
if ((conn == NULL) || (ids == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
priv = (xenUnifiedPrivatePtr) conn->privateData;
ret = xenStoreDoListDomains(conn, priv, ids, maxids);
xenUnifiedUnlock(priv);
- return(ret);
+ return ret;
}
/**
if ((conn == NULL) || (name == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return(NULL);
+ return NULL;
idlist = xs_directory(priv->xshandle, 0, "/local/domain", &num);
if (idlist == NULL)
VIR_FREE(xenddomain);
VIR_FREE(idlist);
- return(ret);
+ return ret;
}
/**
if ((domain == NULL) || (domain->conn == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id == -1 || domain->id == 0)
- return(-1);
+ return -1;
/*
* this is very hackish, the domU kernel probes for a special
* node in the xenstore and launch the shutdown command if found.
if ((domain == NULL) || (domain->conn == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(-1);
+ return -1;
}
if (domain->id == -1 || domain->id == 0)
- return(-1);
+ return -1;
/*
* this is very hackish, the domU kernel probes for a special
* node in the xenstore and launch the shutdown command if found.
if ((domain == NULL) || (domain->conn == NULL)) {
virXenStoreError(VIR_ERR_INVALID_ARG, __FUNCTION__);
- return(NULL);
+ return NULL;
}
vm = virDomainGetVM(domain);
VIR_FREE(vm);
}
- return (str);
+ return str;
}
/**
ret = -1;
VIR_FREE(tmp);
}
- return(ret);
+ return ret;
}
/**
xenUnifiedPrivatePtr priv;
if (id < 0)
- return(NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
if (mac == NULL)
- return (NULL);
+ return NULL;
snprintf(dir, sizeof(dir), "/local/domain/0/backend/vif/%d", id);
list = xs_directory(priv->xshandle, 0, dir, &num);
if (list == NULL)
- return(NULL);
+ return NULL;
for (i = 0; i < num; i++) {
snprintf(path, sizeof(path), "%s/%s/%s", dir, list[i], "mac");
if ((val = xs_read(priv->xshandle, 0, path, &len)) == NULL)
}
VIR_FREE(list);
- return(ret);
+ return ret;
}
/*
xenUnifiedPrivatePtr priv;
if (id < 0)
- return(NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
if (dev == NULL)
- return (NULL);
+ return NULL;
devlen = strlen(dev);
if (devlen <= 0)
- return (NULL);
+ return NULL;
snprintf(dir, sizeof(dir), "/local/domain/0/backend/vbd/%d", id);
list = xs_directory(priv->xshandle, 0, dir, &num);
VIR_FREE (val);
VIR_FREE (list);
- return (ret);
+ return ret;
}
}
VIR_FREE (list);
VIR_FREE (val);
VIR_FREE (list);
- return (ret);
+ return ret;
}
}
VIR_FREE (list);
}
- return (NULL);
+ return NULL;
}
/*
xenUnifiedPrivatePtr priv;
if (id < 0)
- return(NULL);
+ return NULL;
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return (NULL);
+ return NULL;
if (bdf == NULL)
- return (NULL);
+ return NULL;
snprintf(dir, sizeof(dir), "/local/domain/0/backend/pci/%d", id);
list = xs_directory(priv->xshandle, 0, dir, &num);
if (list == NULL)
- return(NULL);
+ return NULL;
for (i = 0; i < num; i++) {
snprintf(path, sizeof(path), "%s/%s/%s", dir, list[i], "dev-0");
if ((val = xs_read(priv->xshandle, 0, path, &len)) == NULL)
}
VIR_FREE(list);
- return(ret);
+ return ret;
}
/*
priv = (xenUnifiedPrivatePtr) conn->privateData;
if (priv->xshandle == NULL)
- return(NULL);
+ return NULL;
snprintf(prop, 199, "/local/domain/%d/name", id);
prop[199] = 0;
vm = vms->contents[0];
xen_vm_get_memory_static_max(session, &mem_static_max, vm);
xen_vm_set_free(vms);
- return (mem_static_max / 1024);
+ return mem_static_max / 1024;
} else {
if (vms) xen_vm_set_free(vms);
xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
if (def->os.loader == NULL) {
XENXS_ERROR(VIR_ERR_INTERNAL_ERROR,
"%s", _("domain information incomplete, missing HVM loader"));
- return(-1);
+ return -1;
}
} else {
if (sexpr_node_copy(node, "domain/image/hvm/kernel", &def->os.kernel) < 0)
VIR_FREE(cpus);
if (conf)
virConfFree(conf);
- return (NULL);
+ return NULL;
}
int fd;
if (chdir("/tmp") < 0)
- return(EXIT_FAILURE);
+ return EXIT_FAILURE;
setpgid(0, 0);
setsid();
DO_TEST(test18);
DO_TEST(test19);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
models, "Penryn", -1);
VIR_FREE(map);
- return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
int ret = 0;
if ((driver.caps = testQemuCapsInit()) == NULL)
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
# define DO_TEST(name, uuid, internal) \
do { \
virCapabilitiesFree(driver.caps);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("ipv6-static-multi");
DO_TEST("ipv6-static");
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("nat-network-dns-srv-record-minimal");
DO_TEST("nat-network-dns-hosts");
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("bandwidth-network");
DO_TEST_FULL("passthrough-pf", VIR_NETWORK_XML_INACTIVE);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("usb_device_1d6b_1_0000_00_1d_0_if0");
DO_TEST("usb_device_1d6b_1_0000_00_1d_0");
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
if (virtTestRun(nodeData[i], 1, linuxTestNodeInfo, nodeData[i]) != 0)
ret = -1;
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("iter-test2", false);
DO_TEST("iter-test3", false);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
VIR_FREE(driver.stateDir);
virCapabilitiesFree(driver.caps);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
virCapabilitiesFree(driver.caps);
VIR_FREE(map);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
int ret = 0;
if ((driver.caps = testQemuCapsInit()) == NULL)
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
# define DO_TEST_FULL(name, is_different, inactive) \
do { \
virCapabilitiesFree(driver.caps);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
virCapabilitiesFree(driver.caps);
VIR_FREE(map);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
int ret = 0;
if (!(caps = testXenCapsInit()))
- return(EXIT_FAILURE);
+ return EXIT_FAILURE;
#define DO_TEST(in, out, version) \
do { \
virCapabilitiesFree(caps);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST_NETMASK("2000::1:1", "9000::1:1",
"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", false);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("/dev/xvda1", 51713);
DO_TEST("/dev/xvda15", 51727);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("pool-iscsi-multiiqn");
DO_TEST("pool-iscsi-vendor-product");
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("pool-logical", "vol-logical");
DO_TEST("pool-logical", "vol-logical-backing");
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
virAuthConfigFree(config);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
DO_TEST("VSprintf infinite loop", testBufInfiniteLoop, 0);
DO_TEST("Auto-indentation", testBufAutoIndent, 0);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
/*
- * Copyright (C) 2011 Red Hat, Inc.
+ * Copyright (C) 2011, 2012 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
if (virtTestRun("Test parse", 1, testParse, NULL) < 0)
ret = -1;
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
if (virtTestRun("Message Payload Stream Encode", 1, testMessagePayloadStreamEncode, NULL) < 0)
ret = -1;
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
#ifdef HAVE_IFADDRS_H
if (checkProtocols(&hasIPv4, &hasIPv6, &freePort) < 0) {
fprintf(stderr, "Cannot identify IPv4/6 availability\n");
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
}
if (hasIPv4) {
#endif
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
asn1_delete_structure(&pkix_asn1);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
# undef DO_TEST
VIR_FREE(custom_uri);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
TEST_FIELDS(2147483648000ull, 2038, 1, 19, 3, 14, 8);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
TEST_PARAMS("foo=one%20two", "", params5);
TEST_PARAMS("=bogus&foo=one", "foo=one", params6);
- return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
ret = -1;
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
int ret = 0;
if (!(caps = testXenCapsInit()))
- return(EXIT_FAILURE);
+ return EXIT_FAILURE;
#define DO_TEST(name, version) \
do { \
virCapabilitiesFree(caps);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
} while (0)
if (!(caps = testXenCapsInit()))
- return(EXIT_FAILURE);
+ return EXIT_FAILURE;
DO_TEST("pv", "pv", "pvtest", 1);
DO_TEST("fv", "fv", "fvtest", 1);
virCapabilitiesFree(caps);
- return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
+ return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
VIRT_TEST_MAIN(mymain)
char *x;
if (s == NULL)
- return(NULL);
+ return NULL;
if ((x = strdup(s)))
return x;
vshError(ctl, _("%s: %d: failed to allocate %lu bytes"),
return (((double)val / 1024.0l));
} else if (val < (1024.0l * 1024.0l * 1024.0l)) {
*unit = "MB";
- return ((double)val / (1024.0l * 1024.0l));
+ return (double)val / (1024.0l * 1024.0l);
} else if (val < (1024.0l * 1024.0l * 1024.0l * 1024.0l)) {
*unit = "GB";
- return ((double)val / (1024.0l * 1024.0l * 1024.0l));
+ return (double)val / (1024.0l * 1024.0l * 1024.0l);
} else {
*unit = "TB";
- return ((double)val / (1024.0l * 1024.0l * 1024.0l * 1024.0l));
+ return (double)val / (1024.0l * 1024.0l * 1024.0l * 1024.0l);
}
}
projects / libvirt.git / commitdiff