shaba/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-27 07:22:07 +03:00
Code Releases Activity

qemu: Refactor config parameter retrieval

Browse Source 
This patch adds macros to help retrieve configuration values from qemu
driver's configuration. Some configuration options are grouped
together in the process.
This commit is contained in:
Peter Krempa 2012-11-27 17:59:34 +01:00
parent 753ff83a50
commit 7aba113ca7
1 changed files with 82 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

315
src/qemu/qemu_conf.c
View File

@ -145,58 +145,42 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
}
#define CHECK_TYPE(name,typ) if (p && p->type != (typ)) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"%s: %s: expected type " #typ, \
filename, (name)); \
virConfFree(conf); \
return -1; \
#define CHECK_TYPE(name,typ) \
if (p && p->type != (typ)) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"%s: %s: expected type " #typ, \
filename, (name)); \
virConfFree(conf); \
return -1; \
}
p = virConfGetValue(conf, "vnc_auto_unix_socket");
CHECK_TYPE("vnc_auto_unix_socket", VIR_CONF_LONG);
if (p) driver->vncAutoUnixSocket = p->l;
#define GET_VALUE_LONG(NAME, VAR) \
p = virConfGetValue(conf, NAME); \
CHECK_TYPE(NAME, VIR_CONF_LONG); \
if (p) \
VAR = p->l;
p = virConfGetValue(conf, "vnc_tls");
CHECK_TYPE("vnc_tls", VIR_CONF_LONG);
if (p) driver->vncTLS = p->l;
p = virConfGetValue(conf, "vnc_tls_x509_verify");
CHECK_TYPE("vnc_tls_x509_verify", VIR_CONF_LONG);
if (p) driver->vncTLSx509verify = p->l;
p = virConfGetValue(conf, "vnc_tls_x509_cert_dir");
CHECK_TYPE("vnc_tls_x509_cert_dir", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->vncTLSx509certdir);
if (!(driver->vncTLSx509certdir = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
#define GET_VALUE_STR(NAME, VAR) \
p = virConfGetValue(conf, NAME); \
CHECK_TYPE(NAME, VIR_CONF_STRING); \
if (p && p->str) { \
VIR_FREE(VAR); \
if (!(VAR = strdup(p->str))) { \
virReportOOMError(); \
virConfFree(conf); \
return -1; \
} \
}
p = virConfGetValue(conf, "vnc_listen");
CHECK_TYPE("vnc_listen", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->vncListen);
if (!(driver->vncListen = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "vnc_password");
CHECK_TYPE("vnc_password", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->vncPassword);
if (!(driver->vncPassword = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
GET_VALUE_LONG("vnc_auto_unix_socket", driver->vncAutoUnixSocket);
GET_VALUE_LONG("vnc_tls", driver->vncTLS);
GET_VALUE_LONG("vnc_tls_x509_verify", driver->vncTLSx509verify);
GET_VALUE_STR("vnc_tls_x509_cert_dir", driver->vncTLSx509certdir);
GET_VALUE_STR("vnc_listen", driver->vncListen);
GET_VALUE_STR("vnc_password", driver->vncPassword);
GET_VALUE_LONG("vnc_sasl", driver->vncSASL);
GET_VALUE_STR("vnc_sasl_dir", driver->vncSASLdir);
GET_VALUE_LONG("vnc_allow_host_audio", driver->vncAllowHostAudio);
p = virConfGetValue(conf, "security_driver");
if (p && p->type == VIR_CONF_LIST) {
@ -240,104 +224,47 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
}
}
p = virConfGetValue(conf, "security_default_confined");
CHECK_TYPE("security_default_confined", VIR_CONF_LONG);
if (p) driver->securityDefaultConfined = p->l;
GET_VALUE_LONG("security_default_confined", driver->securityDefaultConfined);
GET_VALUE_LONG("security_require_confined", driver->securityRequireConfined);
p = virConfGetValue(conf, "security_require_confined");
CHECK_TYPE("security_require_confined", VIR_CONF_LONG);
if (p) driver->securityRequireConfined = p->l;
GET_VALUE_LONG("spice_tls", driver->spiceTLS);
GET_VALUE_STR("spice_tls_x509_cert_dir", driver->spiceTLSx509certdir);
GET_VALUE_STR("spice_listen", driver->spiceListen);
GET_VALUE_STR("spice_password", driver->spicePassword);
p = virConfGetValue(conf, "vnc_sasl");
CHECK_TYPE("vnc_sasl", VIR_CONF_LONG);
if (p) driver->vncSASL = p->l;
p = virConfGetValue(conf, "vnc_sasl_dir");
CHECK_TYPE("vnc_sasl_dir", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->vncSASLdir);
if (!(driver->vncSASLdir = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
GET_VALUE_LONG("remote_display_port_min", driver->remotePortMin);
if (driver->remotePortMin < QEMU_REMOTE_PORT_MIN) {
/* if the port is too low, we can't get the display name
* to tell to vnc (usually subtract 5900, e.g. localhost:1
* for port 5901) */
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: remote_display_port_min: port must be greater "
"than or equal to %d"),
filename, QEMU_REMOTE_PORT_MIN);
virConfFree(conf);
return -1;
}
p = virConfGetValue(conf, "spice_tls");
CHECK_TYPE("spice_tls", VIR_CONF_LONG);
if (p) driver->spiceTLS = p->l;
p = virConfGetValue(conf, "spice_tls_x509_cert_dir");
CHECK_TYPE("spice_tls_x509_cert_dir", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->spiceTLSx509certdir);
if (!(driver->spiceTLSx509certdir = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "spice_listen");
CHECK_TYPE("spice_listen", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->spiceListen);
if (!(driver->spiceListen = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "spice_password");
CHECK_TYPE("spice_password", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->spicePassword);
if (!(driver->spicePassword = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "remote_display_port_min");
CHECK_TYPE("remote_display_port_min", VIR_CONF_LONG);
if (p) {
if (p->l < QEMU_REMOTE_PORT_MIN) {
/* if the port is too low, we can't get the display name
* to tell to vnc (usually subtract 5900, e.g. localhost:1
* for port 5901) */
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: remote_display_port_min: port must be greater than or equal to %d"),
filename, QEMU_REMOTE_PORT_MIN);
virConfFree(conf);
return -1;
}
driver->remotePortMin = p->l;
}
p = virConfGetValue(conf, "remote_display_port_max");
CHECK_TYPE("remote_display_port_max", VIR_CONF_LONG);
if (p) {
if (p->l > QEMU_REMOTE_PORT_MAX ||
p->l < driver->remotePortMin) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: remote_display_port_max: port must be between the minimal port and %d"),
filename, QEMU_REMOTE_PORT_MAX);
virConfFree(conf);
return -1;
}
/* increasing the value by 1 makes all the loops going through
the bitmap (i = remotePortMin; i < remotePortMax; i++), work as
expected. */
driver->remotePortMax = p->l + 1;
GET_VALUE_LONG("remote_display_port_max", driver->remotePortMax);
if (driver->remotePortMax > QEMU_REMOTE_PORT_MAX ||
driver->remotePortMax < driver->remotePortMin) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: remote_display_port_max: port must be between "
"the minimal port and %d"),
filename, QEMU_REMOTE_PORT_MAX);
virConfFree(conf);
return -1;
}
/* increasing the value by 1 makes all the loops going through
the bitmap (i = remotePortMin; i < remotePortMax; i++), work as
expected. */
driver->remotePortMax++;
if (driver->remotePortMin > driver->remotePortMax) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: remote_display_port_min: min port must not be greater than max port"),
filename);
_("%s: remote_display_port_min: min port must not be "
"greater than max port"), filename);
virConfFree(conf);
return -1;
}
@ -371,11 +298,7 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
}
VIR_FREE(group);
p = virConfGetValue(conf, "dynamic_ownership");
CHECK_TYPE("dynamic_ownership", VIR_CONF_LONG);
if (p) driver->dynamicOwnership = p->l;
GET_VALUE_LONG("dynamic_ownership", driver->dynamicOwnership);
p = virConfGetValue(conf, "cgroup_controllers");
CHECK_TYPE("cgroup_controllers", VIR_CONF_LIST);
@ -441,57 +364,13 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
driver->cgroupDeviceACL[i] = NULL;
}
p = virConfGetValue(conf, "save_image_format");
CHECK_TYPE("save_image_format", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->saveImageFormat);
if (!(driver->saveImageFormat = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
GET_VALUE_STR("save_image_format", driver->saveImageFormat);
GET_VALUE_STR("dump_image_format", driver->dumpImageFormat);
GET_VALUE_STR("auto_dump_path", driver->autoDumpPath);
GET_VALUE_LONG("auto_dump_bypass_cache", driver->autoDumpBypassCache);
GET_VALUE_LONG("auto_start_bypass_cache", driver->autoStartBypassCache);
p = virConfGetValue(conf, "dump_image_format");
CHECK_TYPE("dump_image_format", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->dumpImageFormat);
if (!(driver->dumpImageFormat = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "auto_dump_path");
CHECK_TYPE("auto_dump_path", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->autoDumpPath);
if (!(driver->autoDumpPath = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
p = virConfGetValue(conf, "auto_dump_bypass_cache");
CHECK_TYPE("auto_dump_bypass_cache", VIR_CONF_LONG);
if (p) driver->autoDumpBypassCache = true;
p = virConfGetValue(conf, "auto_start_bypass_cache");
CHECK_TYPE("auto_start_bypass_cache", VIR_CONF_LONG);
if (p) driver->autoStartBypassCache = true;
p = virConfGetValue(conf, "hugetlbfs_mount");
CHECK_TYPE("hugetlbfs_mount", VIR_CONF_STRING);
if (p && p->str) {
VIR_FREE(driver->hugetlbfs_mount);
if (!(driver->hugetlbfs_mount = strdup(p->str))) {
virReportOOMError();
virConfFree(conf);
return -1;
}
}
GET_VALUE_STR("hugetlbfs_mount", driver->hugetlbfs_mount);
p = virConfGetValue(conf, "mac_filter");
CHECK_TYPE("mac_filter", VIR_CONF_LONG);
@ -515,33 +394,12 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
}
}
p = virConfGetValue(conf, "relaxed_acs_check");
CHECK_TYPE("relaxed_acs_check", VIR_CONF_LONG);
if (p) driver->relaxedACS = p->l;
p = virConfGetValue(conf, "vnc_allow_host_audio");
CHECK_TYPE("vnc_allow_host_audio", VIR_CONF_LONG);
if (p) driver->vncAllowHostAudio = p->l;
p = virConfGetValue(conf, "clear_emulator_capabilities");
CHECK_TYPE("clear_emulator_capabilities", VIR_CONF_LONG);
if (p) driver->clearEmulatorCapabilities = p->l;
p = virConfGetValue(conf, "allow_disk_format_probing");
CHECK_TYPE("allow_disk_format_probing", VIR_CONF_LONG);
if (p) driver->allowDiskFormatProbing = p->l;
p = virConfGetValue(conf, "set_process_name");
CHECK_TYPE("set_process_name", VIR_CONF_LONG);
if (p) driver->setProcessName = p->l;
p = virConfGetValue(conf, "max_processes");
CHECK_TYPE("max_processes", VIR_CONF_LONG);
if (p) driver->maxProcesses = p->l;
p = virConfGetValue(conf, "max_files");
CHECK_TYPE("max_files", VIR_CONF_LONG);
if (p) driver->maxFiles = p->l;
GET_VALUE_LONG("relaxed_acs_check", driver->relaxedACS);
GET_VALUE_LONG("clear_emulator_capabilities", driver->clearEmulatorCapabilities);
GET_VALUE_LONG("allow_disk_format_probing", driver->allowDiskFormatProbing);
GET_VALUE_LONG("set_process_name", driver->setProcessName);
GET_VALUE_LONG("max_processes", driver->maxProcesses);
GET_VALUE_LONG("max_files", driver->maxFiles);
p = virConfGetValue(conf, "lock_manager");
CHECK_TYPE("lock_manager", VIR_CONF_STRING);
@ -559,25 +417,16 @@ int qemuLoadDriverConfig(virQEMUDriverPtr driver,
VIR_FREE(lockConf);
}
p = virConfGetValue(conf, "max_queued");
CHECK_TYPE("max_queued", VIR_CONF_LONG);
if (p) driver->max_queued = p->l;
p = virConfGetValue(conf, "keepalive_interval");
CHECK_TYPE("keepalive_interval", VIR_CONF_LONG);
if (p) driver->keepAliveInterval = p->l;
p = virConfGetValue(conf, "keepalive_count");
CHECK_TYPE("keepalive_count", VIR_CONF_LONG);
if (p) driver->keepAliveCount = p->l;
p = virConfGetValue(conf, "seccomp_sandbox");
CHECK_TYPE("seccomp_sandbox", VIR_CONF_LONG);
if (p) driver->seccompSandbox = p->l;
GET_VALUE_LONG("max_queued", driver->max_queued);
GET_VALUE_LONG("keepalive_interval", driver->keepAliveInterval);
GET_VALUE_LONG("keepalive_count", driver->keepAliveCount);
GET_VALUE_LONG("seccomp_sandbox", driver->seccompSandbox);
virConfFree(conf);
return 0;
}
#undef GET_VALUE_LONG
#undef GET_VALUE_STRING
static void
qemuDriverCloseCallbackFree(void *payload,