Also add a space after the start in some of the cases.
Signed-off-by: Ján Tomko <jtomko@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
struct _virCapsHostMemBWNode {
unsigned int id;
- virBitmapPtr cpus; /* All CPUs that belong to this node*/
+ virBitmapPtr cpus; /* All CPUs that belong to this node */
virResctrlInfoMemBWPerNode control;
};
goto cleanup;
}
- /* ensure that the string can be passed to qemu*/
+ /* ensure that the string can be passed to qemu */
if (strchr(vendor_id, ',')) {
virReportError(VIR_ERR_XML_ERROR, "%s",
_("vendor id is invalid"));
if (numaMemory) {
/* update the sizes in XML if nothing was set in the XML or ABI update
- * is supported*/
+ * is supported */
virDomainDefSetMemoryTotal(def, numaMemory + hotplugMemory);
} else {
/* verify that the sum of memory modules doesn't exceed the total
ignore_value(virStringParseYesNo(autoAddress, &usbsrc->autoAddress));
/* Product can validly be 0, so we need some extra help to determine
- * if it is uninitialized*/
+ * if it is uninitialized */
got_product = false;
got_vendor = false;
case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
- /* No target type yet*/
+ /* No target type yet */
break;
}
case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
- /* No target type yet*/
+ /* No target type yet */
ret = 0;
break;
}
/* Vendor of the source */
char *vendor;
- /* Product name of the source*/
+ /* Product name of the source */
char *product;
/* Pool type specific format such as filesystem type,
if (esxVI_EnsureSession(priv->primary) < 0)
return -1;
- /* Lookup HostVirtualSwitch and HostPortGroup list*/
+ /* Lookup HostVirtualSwitch and HostPortGroup list */
if (esxVI_LookupHostVirtualSwitchByName(priv->primary, network->name,
&hostVirtualSwitch,
esxVI_Occurrence_RequiredItem) < 0 ||
char xlCPU[32];
/* enable nested HVM only if global nested_hvm option enable it and
- * host support it*/
+ * host support it */
if (ARCH_IS_X86(def->os.arch)) {
vmx = virCPUCheckFeature(caps->host.arch, caps->host.cpu, "vmx");
svm = virCPUCheckFeature(caps->host.arch, caps->host.cpu, "svm");
/* Immutable pointer, immutable object */
virPortAllocatorRangePtr migrationPorts;
- /* Immutable pointer, lockless APIs*/
+ /* Immutable pointer, lockless APIs */
virSysinfoDefPtr hostsysinfo;
/* Immutable pointer. lockless access */
* The DEST-DEVICE is optionally post-fixed with disk type
*/
- /* Extract the source file path*/
+ /* Extract the source file path */
if (!(offset = strchr(head, ',')))
goto error;
}
}
- /* Read the config file if it exists*/
+ /* Read the config file if it exists */
if (remote_config_file &&
virLockDaemonConfigLoadFile(config, remote_config_file, implicit_conf) < 0) {
VIR_ERROR(_("Can't load config file: %s: %s"),
}
}
- /* Read the config file if it exists*/
+ /* Read the config file if it exists */
if (remote_config_file &&
virLogDaemonConfigLoadFile(config, remote_config_file, implicit_conf) < 0) {
VIR_ERROR(_("Can't load config file: %s: %s"),
/* Immutable pointer, Immutable object */
virDomainXMLOptionPtr xmlopt;
- /* Immutable pointer, lockless APIs*/
+ /* Immutable pointer, lockless APIs */
virSysinfoDefPtr hostsysinfo;
/* Atomic inc/dec only */
/* The NBD device will be cleaned up while the cgroup will end.
* For this we need to remember the qemu-nbd pid and add it to
- * the cgroup*/
+ * the cgroup */
if (virLXCControllerAppendNBDPids(ctrl, fs->src->path) < 0)
return -1;
} else {
/* The NBD device will be cleaned up while the cgroup will end.
* For this we need to remember the qemu-nbd pid and add it to
- * the cgroup*/
+ * the cgroup */
if (virLXCControllerAppendNBDPids(ctrl, virDomainDiskGetSource(disk)) < 0)
return -1;
} else {
for (i = 0; i < VIR_LXC_DOMAIN_NAMESPACE_LAST; i++)
nsFDs[i] = -1;
- /*If there are no namespace to be opened just return success*/
+ /* If there are no namespaces to be opened just return success */
if (lxcDef == NULL)
return 0;
virNetworkObjDeleteAllPorts(obj, driver->stateDir);
- /* @def replaced in virNetworkObjUnsetDefTransient*/
+ /* @def replaced in virNetworkObjUnsetDefTransient */
def = virNetworkObjGetDef(obj);
event = virNetworkEventLifecycleNew(def->name,
iptablesAddTcpOutput(fw, VIR_FIREWALL_LAYER_IPV4, def->bridge, 53);
iptablesAddUdpOutput(fw, VIR_FIREWALL_LAYER_IPV4, def->bridge, 53);
- /* allow TFTP requests through to dnsmasq if necessary & back out*/
+ /* allow TFTP requests through to dnsmasq if necessary & back out */
if (ipv4def && ipv4def->tftproot) {
iptablesAddUdpInput(fw, VIR_FIREWALL_LAYER_IPV4, def->bridge, 69);
iptablesAddUdpOutput(fw, VIR_FIREWALL_LAYER_IPV4, def->bridge, 69);
} else if (ret > 0) {
token = strtok_r(temp, ";", &saveptr);
while (token != NULL) {
- /*add new device to list*/
+ /* add new device to list */
if (VIR_ALLOC(net) < 0)
goto error;
char cpy_temp[32];
int len;
- /*parse string*/
+ /* parse string */
do {
char *next = strchr(p, ',');
if (!next)
if ((fp = fopen("/proc/vz/vestat", "r")) == NULL)
return -1;
- /*search line with VEID=vpsid*/
+ /* search line with VEID=vpsid */
while (1) {
ret = getline(&line, &line_size, fp);
if (ret < 0) {
if (sscanf(line, "%d %llu %llu %llu",
&readvps, &usertime, &nicetime, &systime) == 4
- && readvps == vpsid) { /*found vpsid*/
+ && readvps == vpsid) { /* found vpsid */
/* convert jiffies to nanoseconds */
*cpuTime = (1000ull * 1000ull * 1000ull
* (usertime + nicetime + systime)
X_QEMU_CAPS_CHARDEV_SPICEVMC, /* newer -chardev spicevmc */
/* 55 */
- X_QEMU_CAPS_DEVICE_SPICEVMC, /* older -device spicevmc*/
+ X_QEMU_CAPS_DEVICE_SPICEVMC, /* older -device spicevmc */
QEMU_CAPS_VIRTIO_TX_ALG, /* -device virtio-net-pci,tx=string */
X_QEMU_CAPS_DEVICE_QXL_VGA, /* primary qxl device named qxl-vga? */
X_QEMU_CAPS_PCI_MULTIFUNCTION, /* -device multifunction=on|off */
X_QEMU_CAPS_DTB, /* -dtb file */
QEMU_CAPS_SCSI_MEGASAS, /* -device megasas */
X_QEMU_CAPS_IPV6_MIGRATION, /* -incoming [::] */
- X_QEMU_CAPS_MACHINE_OPT, /* -machine xxxx*/
+ X_QEMU_CAPS_MACHINE_OPT, /* -machine xxxx */
/* 135 */
X_QEMU_CAPS_MACHINE_USB_OPT, /* -machine xxx,usb=on/off */
/* Immutable pointer, immutable object */
virPortAllocatorRangePtr migrationPorts;
- /* Immutable pointer, lockless APIs*/
+ /* Immutable pointer, lockless APIs */
virSysinfoDefPtr hostsysinfo;
/* Immutable pointer. lockless access */
}
/* For all other pci-root and pcie-root controllers, though,
- * the index must be zero*/
+ * the index must be zero */
if (cont->idx != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Index for '%s' controllers must be 0"),
return 256 * 1024;
/* Align memory size. QEMU requires rounding to next 4KiB block.
- * We'll take the "traditional" path and round it to 1MiB*/
+ * We'll take the "traditional" path and round it to 1MiB */
return 1024;
}
continue;
/* First IDE controller lives on the PIIX3 at slot=1, function=1,
- dealt with earlier on*/
+ dealt with earlier on */
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
cont->idx == 0)
continue;
}
/* internal snapshot requires a disk image to store the memory image to, and
- * also disks can't be excluded from an internal snapshot*/
+ * also disks can't be excluded from an internal snapshot */
if ((def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && !found_internal) ||
(found_internal && forbid_internal)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
return -1;
} else {
- /* otherwise report possible errors from the attempt to eject the media*/
+ /* otherwise report possible errors from the attempt to eject the media */
if (rc < 0)
return -1;
}
vhostnet_path = "/dev/vhost-net";
/* If running a plain QEMU guest, or
- * if the config says explicitly to not use vhost, return now*/
+ * if the config says explicitly to not use vhost, return now */
if (def->virtType != VIR_DOMAIN_VIRT_KVM ||
net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_QEMU) {
*vhostfdSize = 0;
}
}
- /* Read the config file if it exists*/
+ /* Read the config file if it exists */
if (remote_config_file &&
daemonConfigLoadFile(config, remote_config_file, implicit_conf) < 0) {
VIR_ERROR(_("Can't load config file: %s: %s"),
return virNetClientCallDispatchMessage(client);
case VIR_NET_STREAM: /* Stream protocol */
- case VIR_NET_STREAM_HOLE: /* Sparse stream protocol*/
+ case VIR_NET_STREAM_HOLE: /* Sparse stream protocol */
return virNetClientCallDispatchStream(client);
case VIR_NET_CALL:
}
/* calculate remote key hash, using MD5 algorithm that is
- * usual in OpenSSH. The returned value should *NOT* be freed*/
+ * usual in OpenSSH. The returned value should *NOT* be freed */
if (!(keyhash = libssh2_hostkey_hash(sess->session,
LIBSSH2_HOSTKEY_HASH_MD5))) {
virReportError(VIR_ERR_SSH, "%s",
return -1;
}
- /* nonblocking mode - currently does nothing*/
+ /* nonblocking mode - currently does nothing */
libssh2_channel_set_blocking(sess->channel, 0);
/* channel open */
rc = profile_status(libvirt_daemon, 1);
if (rc < 0) {
rc = profile_status("libvirtd", 1);
- /* Error or unconfined should all result in -1*/
+ /* Error or unconfined should all result in -1 */
if (rc < 0)
rc = -1;
}
VIR_STORAGE_PARTED_DIFFERENT, /* Valid label found but not match format */
VIR_STORAGE_PARTED_UNKNOWN, /* No or unrecognized label */
VIR_STORAGE_PARTED_NOPTTYPE, /* Did not find the Partition Table type */
- VIR_STORAGE_PARTED_PTTYPE_UNK, /* Partition Table type unknown*/
+ VIR_STORAGE_PARTED_PTTYPE_UNK, /* Partition Table type unknown */
} virStorageBackendPARTEDResult;
/**
goto error;
}
- /* No significance to these numbers, just enough to mix it up*/
+ /* No significance to these numbers, just enough to mix it up */
statbase = g_get_real_time();
stats->rd_req = statbase / 10;
stats->rd_bytes = statbase / 20;
if (!(net = virDomainNetFind(privdom->def, device)))
goto error;
- /* No significance to these numbers, just enough to mix it up*/
+ /* No significance to these numbers, just enough to mix it up */
statbase = g_get_real_time();
stats->rx_bytes = statbase / 10;
stats->rx_packets = statbase / 100;
VIR_ARCH_SH4EB, /* SuperH4 32 BE http://en.wikipedia.org/wiki/SuperH */
VIR_ARCH_SPARC, /* Sparc 32 BE http://en.wikipedia.org/wiki/Sparc */
VIR_ARCH_SPARC64, /* Sparc 64 BE http://en.wikipedia.org/wiki/Sparc */
- VIR_ARCH_UNICORE32, /* UniCore 32 LE http://en.wikipedia.org/wiki/Unicore*/
+ VIR_ARCH_UNICORE32, /* UniCore 32 LE http://en.wikipedia.org/wiki/Unicore */
VIR_ARCH_X86_64, /* x86 64 LE http://en.wikipedia.org/wiki/X86 */
VIR_ARCH_XTENSA, /* XTensa 32 LE http://en.wikipedia.org/wiki/Xtensa#Processor_Cores */
{
virCommandPtr cmd = opaque;
if (virCommandProcessIO(cmd) < 0) {
- /* If something went wrong, save errno or -1*/
+ /* If something went wrong, save errno or -1 */
cmd->has_error = errno ? errno : -1;
}
}
return false;
}
- /*out*/
+ /* out */
if (a->out) {
if (!b->out)
return false;
return rc;
}
- if (setlink_only) /*for re-associations on existing links*/
+ if (setlink_only) /* for re-associations on existing links */
return 0;
if (!nltarget_kernel &&
typedef struct _virNetlinkEventSrvPrivate virNetlinkEventSrvPrivate;
typedef virNetlinkEventSrvPrivate *virNetlinkEventSrvPrivatePtr;
struct _virNetlinkEventSrvPrivate {
- /*Server*/
+ /* Server */
virMutex lock;
int eventwatch;
int netlinkfd;
virNetlinkHandle *netlinknh;
- /*Events*/
+ /* Events */
int handled;
size_t handlesCount;
size_t handlesAlloc;
VIR_PERF_EVENT_BRANCH_INSTRUCTIONS, /* Count of branch instructions
for applications */
VIR_PERF_EVENT_BRANCH_MISSES, /* Count of branch misses for applications */
- VIR_PERF_EVENT_BUS_CYCLES, /* Count of bus cycles for applications*/
+ VIR_PERF_EVENT_BUS_CYCLES, /* Count of bus cycles for applications */
VIR_PERF_EVENT_STALLED_CYCLES_FRONTEND, /* Count of stalled cpu cycles in
the frontend of the instruction
processor pipeline */
the backend of the instruction
processor pipeline */
VIR_PERF_EVENT_REF_CPU_CYCLES, /* Count of ref cpu cycles */
- VIR_PERF_EVENT_CPU_CLOCK, /* Count of cpu clock time*/
- VIR_PERF_EVENT_TASK_CLOCK, /* Count of task clock time*/
+ VIR_PERF_EVENT_CPU_CLOCK, /* Count of cpu clock time */
+ VIR_PERF_EVENT_TASK_CLOCK, /* Count of task clock time */
VIR_PERF_EVENT_PAGE_FAULTS, /* Count of total page faults */
VIR_PERF_EVENT_CONTEXT_SWITCHES, /* Count of context switches */
VIR_PERF_EVENT_CPU_MIGRATIONS, /* Count of cpu migrations */
}
-/* virResctrlAlloc and virResctrlMonitor*/
+/* virResctrlAlloc and virResctrlMonitor */
/*
* virResctrlAlloc and virResctrlMonitor are representing a resource control
static int vboxConnectIsEncrypted(virConnectPtr conn G_GNUC_UNUSED)
{
- /* No encryption is needed, or used on the local transport*/
+ /* No encryption is needed, or used on the local transport */
return 0;
}
VBOX_IID_INITIALIZE(&iid);
/* Internal vbox IDs start from 0, the public libvirt ID
- * starts from 1, so refuse id == 0, and adjust the rest*/
+ * starts from 1, so refuse id == 0, and adjust the rest */
if (id == 0) {
virReportError(VIR_ERR_NO_DOMAIN,
_("no domain with matching id %d"), id);
goto cleanup;
rc = gVBoxAPI.UIMachine.SaveSettings(machine);
- /*It may failed when the machine is not mutable.*/
+ /* It may failed when the machine is not mutable. */
rc = gVBoxAPI.UIMachine.GetSettingsFilePath(machine, &settingsFilePath);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
VBOX_UTF16_TO_UTF8(settingsFilePath, &settingsFilePath_Utf8);
- /*Getting the machine name to retrieve the machine location path.*/
+ /* Getting the machine name to retrieve the machine location path. */
rc = gVBoxAPI.UIMachine.GetName(machine, &machineNameUtf16);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
goto cleanup;
}
- /*We create the xml struct with the settings file path.*/
+ /* We create the xml struct with the settings file path. */
snapshotMachineDesc = virVBoxSnapshotConfLoadVboxFile(settingsFilePath_Utf8, machineLocationPath);
if (snapshotMachineDesc == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
&realReadWriteDisksPath);
realReadOnlyDisksPathSize = virVBoxSnapshotConfGetRODisksPathsFromLibvirtXML(currentSnapshotXmlFilePath,
&realReadOnlyDisksPath);
- /*The read-only disk number is necessarily greater or equal to the
- *read-write disk number*/
+ /* The read-only disk number is necessarily greater or equal to the
+ * read-write disk number */
if (realReadOnlyDisksPathSize < realReadWriteDisksPathSize) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("The read only disk number must be greater or equal to the "
_("Unable to know if disk is in media registry"));
goto cleanup;
}
- if (diskInMediaRegistry == 1) /*Nothing to do.*/
+ if (diskInMediaRegistry == 1) /* Nothing to do. */
continue;
- /*The read only disk is not in the media registry*/
+ /* The read only disk is not in the media registry */
VBOX_UTF8_TO_UTF16(def->parent.dom->disks[it]->src->path, &locationUtf);
rc = gVBoxAPI.UIVirtualBox.OpenMedium(data->vboxObj,
VBOX_UTF16_TO_UTF8(formatUtf, &format);
VBOX_UTF16_FREE(formatUtf);
- /*This disk is already in the media registry*/
+ /* This disk is already in the media registry */
IMedium *parentReadOnlyMedium = NULL;
rc = gVBoxAPI.UIMedium.GetParent(readOnlyMedium, &parentReadOnlyMedium);
if (NS_FAILED(rc)) {
}
}
- /*Now, we can unregister the machine*/
+ /* Now, we can unregister the machine */
rc = gVBoxAPI.UIMachine.Unregister(machine,
CleanupMode_DetachAllReturnHardDisksOnly,
&aMediaSize,
VBOX_UTF16_TO_UTF8(locationUtf16, &locationUtf8);
VBOX_UTF16_FREE(locationUtf16);
if (strstr(locationUtf8, "fake") != NULL) {
- /*we delete the fake disk because we don't need it anymore*/
+ /* we delete the fake disk because we don't need it anymore */
IProgress *progress = NULL;
resultCodeUnion resultCode;
rc = gVBoxAPI.UIMedium.DeleteStorage(medium, &progress);
VBOX_UTF8_FREE(locationUtf8);
}
}
- /*Close all disks that failed to close normally.*/
+ /* Close all disks that failed to close normally. */
for (it = 0; it < snapshotMachineDesc->mediaRegistry->ndisks; it++) {
if (vboxCloseDisksRecursively(dom, snapshotMachineDesc->mediaRegistry->disks[it]->location) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
goto cleanup;
}
}
- /*Here, all disks are closed or deleted*/
+ /* Here, all disks are closed or deleted */
- /*We are now going to create and fill the Snapshot xml struct*/
+ /* We are now going to create and fill the Snapshot xml struct */
if (VIR_ALLOC(newSnapshotPtr) < 0)
goto cleanup;
newSnapshotPtr->storageController = g_strdup(snapshotMachineDesc->storageController);
- /*We get the parent disk uuid from the parent disk location to correctly fill the storage controller.*/
+ /* We get the parent disk uuid from the parent disk location
+ * to correctly fill the storage controller. */
for (it = 0; it < def->parent.dom->ndisks; it++) {
char *location = NULL;
const char *uuidReplacing = NULL;
location = def->parent.dom->disks[it]->src->path;
if (!location)
goto cleanup;
- /*Replacing the uuid*/
+ /* Replacing the uuid */
uuidReplacing = virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc, location);
if (uuidReplacing == NULL)
goto cleanup;
}
if (needToChangeStorageController) {
- /*We need to append this disk in the storage controller*/
+ /* We need to append this disk in the storage controller */
char *tmp = NULL;
resultSize = virStringSearch(snapshotMachineDesc->storageController,
VBOX_UUID_REGEX,
VIR_FREE(tmp);
}
- /*Close disk*/
+ /* Close disk */
rc = gVBoxAPI.UIMedium.Close(medium);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
}
} else {
- /*Create a "fake" disk to avoid corrupting children snapshot disks.*/
+ /* Create a "fake" disk to avoid corrupting children snapshot disks. */
for (it = 0; it < def->parent.dom->ndisks; it++) {
IMedium *medium = NULL;
PRUnichar *locationUtf16 = NULL;
goto cleanup;
}
newHardDisk = NULL; /* Consumed by above */
- /*Adding the fake disk to the machine storage controllers*/
+ /* Adding the fake disk to the machine storage controllers */
resultSize = virStringSearch(snapshotMachineDesc->storageController,
VBOX_UUID_REGEX,
snapshotMachineDesc->storageController = g_strdup(tmp);
VIR_FREE(tmp);
- /*Closing the "fake" disk*/
+ /* Closing the "fake" disk */
rc = gVBoxAPI.UIMedium.Close(newMedium);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
}
- /*Now, we rewrite the 'machineName'.vbox file to redefine the machine.*/
+ /* Now, we rewrite the 'machineName'.vbox file to redefine the machine. */
if (virVBoxSnapshotConfSaveVboxFile(snapshotMachineDesc, settingsFilePath_Utf8) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to serialize the machine description"));
}
VBOX_UTF16_TO_UTF8(settingsFilePathUtf16, &settingsFilepath);
- /*Getting the machine name to retrieve the machine location path.*/
+ /* Getting the machine name to retrieve the machine location path. */
rc = gVBoxAPI.UIMachine.GetName(machine, &machineNameUtf16);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to add hard disk to the media registry"));
goto cleanup;
}
- /*Adding fake disks to the machine storage controllers*/
+ /* Adding fake disks to the machine storage controllers */
resultSize = virStringSearch(snapshotMachineDesc->storageController,
VBOX_UUID_REGEX,
snapshotMachineDesc->storageController = g_strdup(tmp);
VIR_FREE(tmp);
- /*Closing the "fake" disk*/
+ /* Closing the "fake" disk */
rc = gVBoxAPI.UIMedium.Close(newMedium);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
}
}
- /*We remove the read write disks from the media registry*/
+ /* We remove the read write disks from the media registry */
for (it = 0; it < def->ndisks; it++) {
const char *uuidRW =
virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc,
goto cleanup;
}
}
- /*If the parent snapshot is not NULL, we remove the-read only disks from the media registry*/
+ /* If the parent snapshot is not NULL, we remove the-read only disks from the media registry */
if (def->parent.parent_name != NULL) {
for (it = 0; it < def->parent.dom->ndisks; it++) {
const char *uuidRO =
rc = gVBoxAPI.UIMedium.GetLocation(medium, &locationUtf16);
VBOX_UTF16_TO_UTF8(locationUtf16, &locationUtf8);
if (isCurrent && strstr(locationUtf8, "fake") != NULL) {
- /*we delete the fake disk because we don't need it anymore*/
+ /* we delete the fake disk because we don't need it anymore */
IProgress *progress = NULL;
resultCodeUnion resultCode;
rc = gVBoxAPI.UIMedium.DeleteStorage(medium, &progress);
VBOX_UTF8_FREE(locationUtf8);
}
- /*removing the snapshot*/
+ /* removing the snapshot */
if (virVBoxSnapshotConfRemoveSnapshot(snapshotMachineDesc, def->parent.name) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to remove snapshot %s"), def->parent.name);
}
}
- /*Registering the machine*/
+ /* Registering the machine */
if (virVBoxSnapshotConfSaveVboxFile(snapshotMachineDesc, settingsFilepath) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to serialize the machine description"));
if (doms) {
/* safe to ignore, new size will be equal or less than
- * previous allocation*/
+ * previous allocation */
ignore_value(VIR_REALLOC_N(doms, count + 1));
*domains = doms;
doms = NULL;
hardDisk->children[i]->parent = hardDisk;
}
uuid = virXMLPropString(diskNode, "uuid");
- /*we use virStringSearch because the uuid is between brackets*/
+ /* we use virStringSearch because the uuid is between brackets */
resultSize = virStringSearch(uuid,
VBOX_UUID_REGEX,
1,
goto cleanup;
}
if (location[0] != '/') {
- /*The location is a relative path, so we must change it into an absolute one. */
+ /* The location is a relative path, so we must change it into an absolute one. */
tmp = g_strdup_printf("%s%s", machineLocation, location);
hardDisk->location = g_strdup(tmp);
} else {
goto cleanup;
uuid = virXMLPropString(snapshotNode, "uuid");
- /*we use virStringSearch because the uuid is between brackets*/
+ /* we use virStringSearch because the uuid is between brackets */
resultSize = virStringSearch(uuid,
VBOX_UUID_REGEX,
1,
goto cleanup;
/* We change the date format from "yyyy-MM-dd hh:mm:ss.msec+timeZone"
- * to "yyyy-MM-ddThh:mm:ssZ"*/
+ * to "yyyy-MM-ddThh:mm:ssZ" */
firstRegexResult = virStringSearch(snapshot->timeStamp,
"([0-9]{4}-[0-9]{2}-[0-9]{2})",
1,
if (xmlNewProp(node, BAD_CAST "timeStamp", BAD_CAST timeStamp) == NULL)
goto cleanup;
- /*node description*/
+ /* node description */
if (snapshot->description != NULL) {
descriptionNode = xmlNewNode(NULL, BAD_CAST "Description");
xmlNodeSetContent(descriptionNode, BAD_CAST snapshot->description);
xmlAddChild(node, descriptionNode);
}
- /*hardware*/
+ /* hardware */
parseError = xmlParseInNodeContext(node,
snapshot->hardware,
(int)strlen(snapshot->hardware),
}
xmlAddChild(node, hardwareNode);
- /*storageController*/
+ /* storageController */
if (xmlParseInNodeContext(node, snapshot->storageController,
(int)strlen(snapshot->storageController),
0,
goto cleanup;
}
- /*Retrieve MachineNode*/
+ /* Retrieve MachineNode */
cur = xmlDocGetRootElement(xml);
xPathContext->node = cur;
machineNode = virXPathNode("./vbox:Machine", xPathContext);
currentSnapshotAttribute = virXMLPropString(machineNode, "currentSnapshot");
if (currentSnapshotAttribute != NULL) {
- /*we use virStringSearch because the uuid is between brackets*/
+ /* we use virStringSearch because the uuid is between brackets */
searchResultSize = virStringSearch(currentSnapshotAttribute,
VBOX_UUID_REGEX,
1,
}
machineDescription->storageController = virXMLNodeToString(xml, cur);
- /*retrieve mediaRegistry*/
+ /* retrieve mediaRegistry */
cur = virXPathNode("./vbox:MediaRegistry", xPathContext);
if (cur == NULL) {
virReportError(VIR_ERR_XML_ERROR, "%s",
goto cleanup;
}
- /*retrieve snapshot*/
+ /* retrieve snapshot */
xPathContext->node = machineNode;
cur = virXPathNode("./vbox:Snapshot", xPathContext);
if (cur != NULL) {
return -1;
}
- /*If parent is NULL and the machine has no snapshot yet,
- *it means that the added snapshot is the first snapshot*/
+ /* If parent is NULL and the machine has no snapshot yet,
+ * it means that the added snapshot is the first snapshot */
if (snapshotParentName == NULL) {
if (machine->snapshot != NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to get the parent disk"));
return -1;
}
- /*Hard disk found*/
+ /* Hard disk found */
if (VIR_EXPAND_N(parentDisk->children, parentDisk->nchildren, 1) < 0)
return -1;
IMachine *machine;
nsresult rc;
PRUnichar *id = NULL;
- bool bpause = true; /*NO live snapshot*/
+ bool bpause = true; /* NO live snapshot */
rc = console->vtbl->GetMachine(console, &machine);
.stateCleanup = vzStateCleanup,
};
-/* Parallels domain type backward compatibility*/
+/* Parallels domain type backward compatibility */
static virHypervisorDriver parallelsHypervisorDriver;
static virConnectDriver parallelsConnectDriver = {
.localOnly = true,
ret = EXIT_FAILURE;
/* Network event tests */
- /* Tests requiring the test network not to be set up*/
+ /* Tests requiring the test network not to be set up */
if (virTestRun("Network createXML start event ", testNetworkCreateXML, &test) < 0)
ret = EXIT_FAILURE;
if (virTestRun("Network (un)define events", testNetworkDefine, &test) < 0)
if (qemuAgentSetVCPUs(qemuMonitorTestGetAgent(test), cpuinfo, nvcpus) < 0)
goto cleanup;
- /* try to hotplug two, second one will fail*/
+ /* try to hotplug two, second one will fail */
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
return EXIT_AM_SKIP;
}
-#endif /*WITH_VBOX*/
+#endif /* WITH_VBOX */
return ret;
}
-/* Point of this test is to see how table behaves with right to left writing*/
+/* Point of this test is to see how table behaves with right to left writing */
static int
testUnicodeArabic(const void *opaque G_GNUC_UNUSED)
{
{.name = NULL}
};
-/* compare domains, pack NULLed ones at the end*/
+/* compare domains, pack NULLed ones at the end */
static int
virshDomainSorter(const void *a, const void *b)
{
const char *vol_string = NULL; /* string containing volumes to delete */
char **vol_list = NULL; /* tokenized vol_string */
int nvol_list = 0;
- virshUndefineVolume *vols = NULL; /* info about the volumes to delete*/
+ virshUndefineVolume *vols = NULL; /* info about the volumes to delete */
size_t nvols = 0;
xmlDocPtr doc = NULL;
xmlXPathContextPtr ctxt = NULL;
goto cleanup;
}
- /* Pin mode: pinning specified vcpu to specified physical cpus*/
+ /* Pin mode: pinning specified vcpu to specified physical cpus */
if (!(cpumap = virshParseCPUList(ctl, &cpumaplen, cpulist, maxcpu)))
goto cleanup;
goto cleanup;
}
- /* Pin mode: pinning emulator threads to specified physical cpus*/
+ /* Pin mode: pinning emulator threads to specified physical cpus */
if (!(cpumap = virshParseCPUList(ctl, &cpumaplen, cpulist, maxcpu)))
goto cleanup;
if (!xmlStrEqual(n1->name, n2->name))
return false;
- /* Iterate over n2 attributes and check if n1 contains them*/
+ /* Iterate over n2 attributes and check if n1 contains them */
attr = n2->properties;
while (attr) {
if (attr->type == XML_ATTRIBUTE_NODE) {
if (!table)
goto cleanup;
- /* Insert the pool info rows into table*/
+ /* Insert the pool info rows into table */
for (i = 0; i < list->npools; i++) {
if (vshTableRowAppend(table,
virStoragePoolGetName(list->pools[i]),
projects / libvirt.git / commitdiff