The various drivers each have vir*EnsureACL and vir*CheckACL API's which are generated on the fly by gendispatch to include the driver typed "def" name as the last argument based on the API being checked and the driver name (e.g. Node, Interface, Secrets, etc.). Rather than having that name by typed, it's possible to generate the API prototype using a "void *opaque" argument and then modify the first line of the code to make the typed def argumment based off the opaque data. This way we can generalize the ACL typedefs in object parsing code to just be an opaque type. The next step in that generalization is to remove the multiple typdef's and replace it with one general typedef in order to further generalize the various drivers object and object list handling functions. Signed-off-by: John Ferlan <jferlan@redhat.com> --- src/conf/domain_conf.h | 3 +-- src/conf/interface_conf.h | 3 +-- src/conf/network_conf.h | 3 +-- src/conf/node_device_conf.h | 3 +-- src/conf/storage_conf.h | 3 +-- src/conf/virsecretobj.h | 3 +-- src/rpc/gendispatch.pl | 5 ++++- 7 files changed, 10 insertions(+), 13 deletions(-) diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index dd79206..dd9e43e 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2400,8 +2400,7 @@ struct _virDomainObj { * restore will be required later */ }; -typedef bool (*virDomainObjListACLFilter)(virConnectPtr conn, - virDomainDefPtr def); +typedef bool (*virDomainObjListACLFilter)(virConnectPtr conn, void *opaque); typedef enum { diff --git a/src/conf/interface_conf.h b/src/conf/interface_conf.h index 2523207..1e38412 100644 --- a/src/conf/interface_conf.h +++ b/src/conf/interface_conf.h @@ -212,8 +212,7 @@ char *virInterfaceDefFormat(const virInterfaceDef *def); void virInterfaceObjLock(virInterfaceObjPtr obj); void virInterfaceObjUnlock(virInterfaceObjPtr obj); -typedef bool (*virInterfaceObjListFilter)(virConnectPtr conn, - virInterfaceDefPtr def); +typedef bool (*virInterfaceObjListFilter)(virConnectPtr conn, void *opaque); # define VIR_CONNECT_LIST_INTERFACES_FILTERS_ACTIVE \ (VIR_CONNECT_LIST_INTERFACES_ACTIVE | \ diff --git a/src/conf/network_conf.h b/src/conf/network_conf.h index 9e4ae71..217b548 100644 --- a/src/conf/network_conf.h +++ b/src/conf/network_conf.h @@ -331,8 +331,7 @@ bool virNetworkObjTaint(virNetworkObjPtr obj, void virNetworkDefFree(virNetworkDefPtr def); -typedef bool (*virNetworkObjListFilter)(virConnectPtr conn, - virNetworkDefPtr def); +typedef bool (*virNetworkObjListFilter)(virConnectPtr conn, void *opaque); enum { VIR_NETWORK_OBJ_LIST_ADD_LIVE = (1 << 0), diff --git a/src/conf/node_device_conf.h b/src/conf/node_device_conf.h index 1634483..e1cdb1d 100644 --- a/src/conf/node_device_conf.h +++ b/src/conf/node_device_conf.h @@ -315,8 +315,7 @@ void virNodeDeviceObjUnlock(virNodeDeviceObjPtr obj); VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS | \ VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC) -typedef bool (*virNodeDeviceObjListFilter)(virConnectPtr conn, - virNodeDeviceDefPtr def); +typedef bool (*virNodeDeviceObjListFilter)(virConnectPtr conn, void *opaque); int virNodeDeviceObjListExport(virConnectPtr conn, virNodeDeviceObjList devobjs, diff --git a/src/conf/storage_conf.h b/src/conf/storage_conf.h index e952f5f..5eda544 100644 --- a/src/conf/storage_conf.h +++ b/src/conf/storage_conf.h @@ -314,8 +314,7 @@ struct _virStoragePoolSourceList { virStoragePoolSourcePtr sources; }; -typedef bool (*virStoragePoolObjListFilter)(virConnectPtr conn, - virStoragePoolDefPtr def); +typedef bool (*virStoragePoolObjListFilter)(virConnectPtr conn, void *opaque); static inline int virStoragePoolObjIsActive(virStoragePoolObjPtr pool) diff --git a/src/conf/virsecretobj.h b/src/conf/virsecretobj.h index fa45b42..673a4c8 100644 --- a/src/conf/virsecretobj.h +++ b/src/conf/virsecretobj.h @@ -65,8 +65,7 @@ virSecretObjPtr virSecretObjListAdd(virSecretObjListPtr secrets, const char *configDir, virSecretDefPtr *oldDef); -typedef bool (*virSecretObjListACLFilter)(virConnectPtr conn, - virSecretDefPtr def); +typedef bool (*virSecretObjListACLFilter)(virConnectPtr conn, void *opaque); int virSecretObjListNumOfSecrets(virSecretObjListPtr secrets, virSecretObjListACLFilter filter, diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index 173189c..12b047b 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -2066,7 +2066,7 @@ elsif ($mode eq "client") { if ($object eq "StorageVol") { push @argdecls, "virStoragePoolDefPtr pool"; } - push @argdecls, "$objecttype $arg"; + push @argdecls, "void *opaque"; } if ($checkflags) { push @argdecls, "unsigned int flags"; @@ -2101,6 +2101,9 @@ elsif ($mode eq "client") { print "/* Returns: $fail on error/denied, $pass on allowed */\n"; print "$ret $apiname(" . join(", ", @argdecls) . ")\n"; print "{\n"; + if ($object ne "Connect") { + print " $objecttype $arg = opaque;\n"; + } print " virAccessManagerPtr mgr;\n"; print " int rv;\n"; print "\n"; -- 2.7.4

Introduce a new generic virPoolObj[Ptr] and virPoolObjTable[Ptr] in order to generically manage driver lists of objects rather than the current hodgepodge of some drivers using a forward linked list and other drivers using a single UUID only based hash table to look up objects. The concept is to mimic the domain objects which keep objects in a UUID hash table and a name hash table for faster lookup. There's also generic API's in order to Lock, Reference, Unreference, and Unlock the objects to remove the need for a heavy handed driver lock. Since these are Hash Table objects rather than List Objects, the structures and API's have been named thusly. These are all based upon the existing generic object/class model so allocation/freeing is using existing API's. In addition to common structures and API's, as each driver is converted the driver specific ACL filter API's can be replaced by a generic pool ACL filter API. Each of the API's is designed to have a consistency with respect to returning a locked and referenced object, so that a virPoolObjEndAPI can be called in order to dereference and unlock the object. The ultimate goal is to have a single way to think about these objects management so that the various drivers don't have to have special or different code in order to manage based on the "style" of list/table the driver needs to manage. A _virPoolObj uses a fairly generic structure: virObjectLockable parent; bool flags virPoolDefPtr pooldef; void *def; void *newDef; virFreeCallback defFreeFunc; void *privateData; void (*privateDataFreeFunc)(void *); Access to the fields of the object is handled via API's to fetch or set the various fields rather than allowing the calling driver to manage the object directly. This ensures a more consistent look and feel to the code for each driver. The "def" and "newDef" field along with the defFreeFunc will point at the driver's specific vir*DefPtr data and the FreeFunc handles the free of the data when the object is finally removed. The vir*DefPtr API's will each need to be modified to take an "void *opaque" and assign that to the specific driver definition type. Most drivers have no need for privateData; however, a few drivers will need to manage driver specific object private data. For those drivers additional object management code is generated in order to manage the Get, Set, and test of the private data. The goal being to have one set of API's to manage the data rather than drivers directly touching it. A _virPoolObjTable is another generic structure: virObjectLockable parent; virPoolObjTableType type; bool nameOnly; int hashStart; virHashTable *objsUuid; virHashTable *objsName; Not every driver supports UUID's, so the UUID table isn't required, but it is the preferred lookup mechanism. The bool 'nameOnly' will help the table code make those decisions. The various Pool Object Table API's are taken from the current object list managements and converted to use tables. Objects are added to the table allowing for a callback mechanism to handle driver specific "assignment" options when the object already appears in the table and the driver would be managing the replacement of the "existing" object "def". There are common API's to Add, Clear, Remove, Search, Iterate, Collect, List, Clone, and Prune objects. Each uses the same common methodology to lock the table list, use the virHash* APIs, and unlock the table list returning the requested data for the operation. Generally that means a locked and referenced object. The virPoolObjEndAPI will handle the dereference and unlocking. Add new error code for the new poolobj subsystem Signed-off-by: John Ferlan <jferlan@redhat.com> --- include/libvirt/virterror.h | 1 + po/POTFILES.in | 1 + src/Makefile.am | 5 + src/conf/virpoolobj.c | 1184 +++++++++++++++++++++++++++++++++++++++++++ src/conf/virpoolobj.h | 222 ++++++++ src/libvirt_private.syms | 33 ++ src/util/virerror.c | 1 + 7 files changed, 1447 insertions(+) create mode 100644 src/conf/virpoolobj.c create mode 100644 src/conf/virpoolobj.h diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h index 2efee8f..2174334 100644 --- a/include/libvirt/virterror.h +++ b/include/libvirt/virterror.h @@ -132,6 +132,7 @@ typedef enum { VIR_FROM_PERF = 65, /* Error from perf */ VIR_FROM_LIBSSH = 66, /* Error from libssh connection transport */ + VIR_FROM_POOLOBJ = 67, /* Error from the poolobj code */ # ifdef VIR_ENUM_SENTINELS VIR_ERR_DOMAIN_LAST diff --git a/po/POTFILES.in b/po/POTFILES.in index 365ea66..95fa9a6 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -42,6 +42,7 @@ src/conf/snapshot_conf.c src/conf/storage_conf.c src/conf/virchrdev.c src/conf/virdomainobjlist.c +src/conf/virpoolobj.c src/conf/virsecretobj.c src/cpu/cpu.c src/cpu/cpu_arm.c diff --git a/src/Makefile.am b/src/Makefile.am index 2f32d41..03a8cf3 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -373,6 +373,10 @@ NWFILTER_CONF_SOURCES = \ $(NWFILTER_PARAM_CONF_SOURCES) \ conf/nwfilter_conf.c conf/nwfilter_conf.h +# "Generic" poolobj sources +POOLOBJ_SOURCES = \ + conf/virpoolobj.h conf/virpoolobj.c + # Storage driver generic impl APIs STORAGE_CONF_SOURCES = \ conf/storage_conf.h conf/storage_conf.c @@ -405,6 +409,7 @@ CONF_SOURCES = \ $(NETDEV_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \ $(OBJECT_EVENT_SOURCES) \ + $(POOLOBJ_SOURCES) \ $(DOMAIN_EVENT_SOURCES) \ $(NETWORK_EVENT_SOURCES) \ $(STORAGE_EVENT_SOURCES) \ diff --git a/src/conf/virpoolobj.c b/src/conf/virpoolobj.c new file mode 100644 index 0000000..bca6524 --- /dev/null +++ b/src/conf/virpoolobj.c @@ -0,0 +1,1184 @@ +/* + * virpoolobj.c: internal pool objects handling + * + * Copyright (C) 2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include "datatypes.h" +#include "viralloc.h" +#include "virpoolobj.h" +#include "virerror.h" +#include "virlog.h" +#include "virhash.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_POOLOBJ + +VIR_LOG_INIT("conf.virpoolobj"); + +VIR_ENUM_DECL(virPoolObjTable); +VIR_ENUM_IMPL(virPoolObjTable, VIR_POOLOBJTABLE_LAST, + "nodedev", "interface", "nwfilter", "volume", "block storage", + "secret", "network", "domain snapshot", "domain") + +struct _virPoolDef { + char *uuid; + char *name; +}; + +struct _virPoolObj { + virObjectLockable parent; + + /* copy of the def->name and def->uuid (if available) used for lookups + * without needing to know the object type */ + virPoolDefPtr pooldef; + + /* Boolean states that can be managed by consumer */ + bool active; /* object is active or not */ + bool beingRemoved; /* object being prepared for removal */ + bool autostart; /* object is autostarted */ + bool persistent; /* object definition is persistent */ + bool updated; /* object config has been updated in some way */ + + /* Boolean states managed by virPoolObj */ + bool removing; /* true when object has been removed from table(s) */ + + /* 'def' is the current config definition. + * 'newDef' is the next boot configuration. + * The 'type' value will describe which _vir*Def struct describes + * The 'privateData' will be private object data for each pool obj + * and specific to the 'type' of object being managed. */ + void *def; + void *newDef; + virFreeCallback defFreeFunc; + + /* Private data to be managed by the specific object using + * vir{$OBJ}ObjPrivate{Get|Set}{$FIELD} type API's. Each of those + * calling the virPoolObjGetPrivateData in order to access this field */ + void *privateData; + void (*privateDataFreeFunc)(void *); +}; + +struct _virPoolObjTable { + virObjectLockable parent; + virPoolObjTableType type; + bool nameOnly; + int hashStart; + + /* uuid string -> virPoolObj mapping + * for O(1), lockless lookup-by-uuid */ + virHashTable *objsUuid; + + /* name -> virPoolObj mapping for O(1), + * lockless lookup-by-name */ + virHashTable *objsName; +}; + +static virClassPtr virPoolObjClass; +static void virPoolObjDispose(void *obj); + +static int +virPoolObjOnceInit(void) +{ + if (!(virPoolObjClass = virClassNew(virClassForObjectLockable(), + "virPoolObj", + sizeof(virPoolObj), + virPoolObjDispose))) + return -1; + + return 0; +} +VIR_ONCE_GLOBAL_INIT(virPoolObj) + + +/** + * @pooldef: The 'name' and possible 'uuid' of the def for lookups + * @def: The 'def' for the object + * @newDef: The 'newDef' (next) for the object + * @defFreeFunc: The vir$OBJFreeDef callback + * + * Create/return a new poolobj to be placed into the hash table + * + * Returns: Object on success, NULL on failure + */ +virPoolObjPtr +virPoolObjNew(virPoolDefPtr pooldef, + void *def, + void *newDef, + virFreeCallback defFreeFunc) +{ + virPoolObjPtr obj; + + if (virPoolObjInitialize() < 0) + return NULL; + + if (!(obj = virObjectLockableNew(virPoolObjClass))) + return NULL; + + VIR_DEBUG("obj=%p pooldef=%p def=%p newDef=%p ff=%p", + obj, pooldef, def, newDef, defFreeFunc); + obj->pooldef = pooldef; + obj->def = def; + obj->newDef = newDef; + obj->defFreeFunc = defFreeFunc; + + return obj; +} + + +static void +virPoolDefFree(virPoolDefPtr def) +{ + if (!def) + return; + + VIR_FREE(def->uuid); + VIR_FREE(def->name); + VIR_FREE(def); +} + + +static void +virPoolObjDispose(void *_obj) +{ + virPoolObjPtr obj = _obj; + + if (!obj) + return; + + VIR_DEBUG("obj=%p, pooldef=%p def=%p newDef=%p ff=%p", + obj, obj->pooldef, obj->def, obj->newDef, obj->defFreeFunc); + + virPoolDefFree(obj->pooldef); + (obj->defFreeFunc)(obj->def); + (obj->defFreeFunc)(obj->newDef); + + if (obj->privateDataFreeFunc) + (obj->privateDataFreeFunc)(obj->privateData); +} + + +/** + * @obj: A locked poolobj pointer + * @active: The "new" state + * + * Set the @active bit in the object. + */ +void +virPoolObjSetActive(virPoolObjPtr obj, + bool active) +{ + obj->active = active; +} + + +/** + * @obj: A locked poolobj pointer + * @autostart: The @autostart value sent from the driver + * + * Set the @autostart bit in the object. + */ +void +virPoolObjSetAutostart(virPoolObjPtr obj, + bool autostart) +{ + obj->autostart = autostart; +} + + +/** + * @obj: A locked poolobj pointer + * @beingRemoved: The @beingRemoved value sent from the driver + * + * Set the @beingRemoved bit in the object. + */ +void +virPoolObjSetBeingRemoved(virPoolObjPtr obj, + bool beingRemoved) +{ + obj->beingRemoved = beingRemoved; +} + + +/** + * @obj: A locked poolobj pointer + * @persistent: The @persistent value sent from the driver + * + * Set the @persistent bit in the object. + */ +void +virPoolObjSetPersistent(virPoolObjPtr obj, + bool persistent) +{ + obj->persistent = persistent; +} + + +/** + * @obj: A locked poolobj pointer + * @def: Opaque 'def' to replace in the object + * + * Set the @def in the object. This code will call the defFreeFunc + * on the existing object in obj->def before assigning. + */ +void +virPoolObjSetDef(virPoolObjPtr obj, + void *def) +{ + obj->defFreeFunc(obj->def); + obj->def = def; +} + + +/** + * @obj: A locked poolobj pointer + * @newDef: Opaque 'newDef' to replace in the object + * + * Set the @newDef in the object. This code will call the defFreeFunc + * on the existing object in obj->newDef before assigning. + */ +void +virPoolObjSetNewDef(virPoolObjPtr obj, + void *newDef) +{ + obj->defFreeFunc(obj->newDef); + obj->newDef = newDef; +} + + +/** + * @obj: A locked poolobj pointer + * @privateData: Pointer to private data + * @privateDataFreeFunc: Callback function when the object is free t + * free the privateData details + * + * Set the @privateData address and @privateDataFreeFunc addresses. + */ +void +virPoolObjSetPrivateData(virPoolObjPtr obj, + void *privateData, + virFreeCallback privateDataFreeFunc) +{ + obj->privateData = privateData; + obj->privateDataFreeFunc = privateDataFreeFunc; +} + + +/* virPoolObjIs{Active|Autostart|BeingRemoved|Persistent} + * @obj: A locked poolobj pointer + * + * Various accessor fetch functions for the bool bits in the object + */ +bool +virPoolObjIsActive(const virPoolObj *obj) +{ + return obj->active; +} + + +bool +virPoolObjIsAutostart(const virPoolObj *obj) +{ + return obj->autostart; +} + + +bool +virPoolObjIsBeingRemoved(const virPoolObj *obj) +{ + return obj->beingRemoved; +} + + +bool +virPoolObjIsPersistent(const virPoolObj *obj) +{ + return obj->persistent; +} + + +/** + * @obj: A locked poolobj pointer + * + * Return the obj->def pointer to the caller + */ +void * +virPoolObjGetDef(const virPoolObj *obj) +{ + return obj->def; +} + + +/** + * @obj: A locked poolobj pointer + * + * Return the obj->newDef pointer to the caller + */ +void * +virPoolObjGetNewDef(const virPoolObj *obj) +{ + return obj->newDef; +} + + +/** + * @obj: A locked poolobj pointer + * + * Return the obj->privateData pointer to the caller + */ +void * +virPoolObjGetPrivateData(const virPoolObj *obj) +{ + return obj->privateData; +} + + +/** + * @obj: A locked and ref'd poolobj pointer + * + * Unref and unlock the object + */ +void +virPoolObjEndAPI(virPoolObjPtr *obj) +{ + if (!*obj) + return; + + virObjectUnlock(*obj); + virObjectUnref(*obj); + *obj = NULL; +} + + +static virClassPtr virPoolObjTableClass; +static void virPoolObjTableDispose(void *obj); + +static int +virPoolObjTableOnceInit(void) +{ + if (!(virPoolObjTableClass = virClassNew(virClassForObjectLockable(), + "virPoolObjTable", + sizeof(virPoolObjTable), + virPoolObjTableDispose))) + return -1; + + return 0; +} + + +VIR_ONCE_GLOBAL_INIT(virPoolObjTable) + +/* virPoolObjTableNew: + * @type: The virPoolObjTableType type of hash table + * @hashStart: Initial size of the table + * @nameOnly: Whether the table will only have names + * + * Allocate the hash table object and initialize the hash table(s). + * At least a "Name" hash table is always allocated, but there may + * also be a "UUID" hash table as well based on the @nameOnly argument + * + * Returns: The hash table on success, NULL on failure + */ +virPoolObjTablePtr +virPoolObjTableNew(virPoolObjTableType type, + int hashStart, + bool nameOnly) +{ + virPoolObjTablePtr poolobjs; + + if (virPoolObjTableInitialize() < 0) + return NULL; + + if (!(poolobjs = virObjectLockableNew(virPoolObjTableClass))) + return NULL; + + VIR_DEBUG("objtable=%p type=%s", + poolobjs, virPoolObjTableTypeToString(type)); + poolobjs->type = type; + poolobjs->hashStart = hashStart; + poolobjs->nameOnly = nameOnly; + + if (!nameOnly && + !(poolobjs->objsUuid = virHashCreate(hashStart, virObjectFreeHashData))) + goto error; + + if (!(poolobjs->objsName = virHashCreate(hashStart, virObjectFreeHashData))) + goto error; + + return poolobjs; + + error: + virObjectUnref(poolobjs); + return NULL; +} + + +static void +virPoolObjTableDispose(void *obj) +{ + virPoolObjTablePtr poolobjs = obj; + + if (!poolobjs) + return; + + VIR_DEBUG("objtable=%p type=%s", + poolobjs, virPoolObjTableTypeToString(poolobjs->type)); + + if (!poolobjs->nameOnly) + virHashFree(poolobjs->objsUuid); + virHashFree(poolobjs->objsName); +} + + +/* virPoolObjTableAdd[Locked] + * @poolobjs: Pool object table + * @new_uuidstr: Optional uuid by formatted string (offers more uniqueness) + * @new_name: Required name for uniqueness + * @def: Pointer to a void Object definition + * @newDef: Pointer to the "next" void Object definition + * @defFreeFunc: Callback to free the def/newDef + * @assignDefFunc: Callback to assign def logic (def/newDef manipulation) + * @assignFlags: Flags to pass to @assignDefFunc + * + * Search for the @new_uuidstr/@new_name keys in @poolobjs and either + * update the definition via the @assignDefFunc or add the @def and + * @newDef to @poolobjs. + * + * The @defFreeFunc is a reference to the vir*DefFree function for + * the type of pool + * + * The optional @assignDefFunc is a callback function that will + * handle the management of @def, @newDef, and @oldDef long with + * an @assignFlags option depending on how/where it's called. + * + * Returns: A locked pool object with incremented ref or NULL + * Caller must use virPoolObjEndAPI when done. + */ +static virPoolObjPtr +virPoolObjTableAddLocked(virPoolObjTablePtr poolobjs, + const char *new_uuidstr, + const char *new_name, + void *def, + void *newDef, + void *oldDef, + virFreeCallback defFreeFunc, + virPoolObjTableAssignDefFunc assignDefFunc, + unsigned int assignFlags) +{ + virPoolDefPtr pooldef = NULL; + virPoolObjPtr obj = NULL; + + VIR_DEBUG("poolobjs=%p uuidstr=%s name=%s", + poolobjs, NULLSTR(new_uuidstr), new_name); + + /* UUID is the primary search, although if the name is sufficiently + * unique (such as for node devices and interfaces), then name will + * be the primary */ + if (poolobjs->nameOnly) + obj = virHashLookup(poolobjs->objsName, new_name); + else + obj = virHashLookup(poolobjs->objsUuid, new_uuidstr); + + if (obj) { + virObjectLock(obj); + + /* If used UUID for Lookup, ensure name matches too */ + if (new_uuidstr && STRNEQ(obj->pooldef->name, new_name)) { + virReportError(VIR_ERR_OPERATION_FAILED, + _("%s '%s' is already defined with uuid %s"), + virPoolObjTableTypeToString(poolobjs->type), + obj->pooldef->name, obj->pooldef->uuid); + virObjectUnlock(obj); + return NULL; + } + + if (assignDefFunc) { + if (assignDefFunc(obj, def, oldDef, assignFlags) < 0) { + virObjectUnlock(obj); + return NULL; + } + } else { + /* Simple replacement */ + defFreeFunc(obj->def); + obj->def = def; + } + } else { + /* Ensure that something by the same name doesn't already exist */ + if (!new_uuidstr && + (obj = virHashLookup(poolobjs->objsName, new_name))) { + virObjectLock(obj); + virReportError(VIR_ERR_OPERATION_FAILED, + _("%s '%s' already exists with uuid %s"), + virPoolObjTableTypeToString(poolobjs->type), + new_name, obj->pooldef->uuid); + virObjectUnlock(obj); + return NULL; + } + + if (VIR_ALLOC(pooldef) < 0) + return NULL; + + if (VIR_STRDUP(pooldef->uuid, new_uuidstr) < 0 || + VIR_STRDUP(pooldef->name, new_name) < 0) + goto error; + + if (!(obj = virPoolObjNew(pooldef, def, newDef, defFreeFunc))) + goto error; + + virObjectLock(obj); + + if (!poolobjs->nameOnly && + virHashAddEntry(poolobjs->objsUuid, new_uuidstr, obj) < 0) + goto error; + + if (virHashAddEntry(poolobjs->objsName, new_name, obj) < 0) { + if (!poolobjs->nameOnly) + virHashRemoveEntry(poolobjs->objsUuid, new_uuidstr); + goto error; + } + + /* If it's in two hash tables, increment ref count! */ + if (new_uuidstr) + virObjectRef(obj); + } + + virObjectRef(obj); + return obj; + + error: + VIR_DEBUG("Fail to add object to table"); + virPoolDefFree(pooldef); + virObjectUnref(obj); + virObjectUnlock(obj); + return NULL; +} + + +virPoolObjPtr +virPoolObjTableAdd(virPoolObjTablePtr poolobjs, + const char *new_uuidstr, + const char *new_name, + void *def, + void *newDef, + void *oldDef, + virFreeCallback defFreeFunc, + virPoolObjTableAssignDefFunc assignDefFunc, + unsigned int assignFlags) +{ + virPoolObjPtr ret; + + virObjectLock(poolobjs); + ret = virPoolObjTableAddLocked(poolobjs, new_uuidstr, new_name, + def, newDef, oldDef, defFreeFunc, + assignDefFunc, assignFlags); + VIR_DEBUG("poolobjs=%p, ret=%p", poolobjs, ret); + virObjectUnlock(poolobjs); + return ret; +} + + +/* + * virPoolObjTableClear + * @poolobjs: Pool object table + * + * Remove all the objects from @poolobjs, but don't free the table. + * Useful for @poolobjs tables that can repopulate themselves and don't + * want to determine the difference between two objects. + */ +void +virPoolObjTableClearAll(virPoolObjTablePtr poolobjs) +{ + ssize_t count; + virObjectLock(poolobjs); + if (!poolobjs->nameOnly) { + count = virHashRemoveAll(poolobjs->objsUuid); + VIR_DEBUG("cleared out %ld objects from objsUuid", count); + } + + count = virHashRemoveAll(poolobjs->objsName); + VIR_DEBUG("cleared out %ld objects from objsName", count); + virObjectUnlock(poolobjs); +} + + +/* + * virPoolObjTableRemove + * @poolobjs: Pool object table + * @obj: Object to remove + * + * Remove the object from the table. + * + * The caller must hold a lock on the driver owning @poolobjs and + * must have locked @obj to ensure no one else is either waiting for + * @obj or still using it. The caller can also take out an extra + * reference on @obj to ensure it doesn't disappear if it needs it + * beyond this removal. + * + * Upon exit, the lock held upon entry is removed. + */ +void +virPoolObjTableRemove(virPoolObjTablePtr poolobjs, + virPoolObjPtr *obj) +{ + virPoolDefPtr pooldef = (*obj)->pooldef; + + VIR_DEBUG("poolobjs=%p, obj=%p", poolobjs, obj); + + (*obj)->removing = true; + virObjectRef(*obj); + virObjectUnlock(*obj); + + virObjectLock(poolobjs); + virObjectLock(*obj); + if (!poolobjs->nameOnly) + virHashRemoveEntry(poolobjs->objsUuid, pooldef->uuid); + virHashRemoveEntry(poolobjs->objsName, pooldef->name); + virObjectUnlock(*obj); + virObjectUnref(*obj); + virObjectUnlock(poolobjs); +} + + +/** + * virPoolObjFindByUUIDInternal: + * @poolobjs: Pool object table + * @uuid: pool uuid to find + * + * Lock and search the pool for the UUID. Depending on 'ref' argument + * we either return with referenced count incremented on the object too + * + * Returns: pool object + */ +static virPoolObjPtr +virPoolObjTableFindByUUIDInternal(virPoolObjTablePtr poolobjs, + const unsigned char *uuid, + bool ref) +{ + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virPoolObjPtr obj; + + virObjectLock(poolobjs); + if (poolobjs->nameOnly) { + virObjectUnlock(poolobjs); + return NULL; + } + + virUUIDFormat(uuid, uuidstr); + + obj = virHashLookup(poolobjs->objsUuid, uuidstr); + if (ref) { + virObjectRef(obj); + virObjectUnlock(poolobjs); + } + if (obj) { + virObjectLock(obj); + if (obj->removing) { + virObjectUnlock(obj); + if (ref) + virObjectUnref(obj); + obj = NULL; + } + } + if (!ref) + virObjectUnlock(poolobjs); + return obj; +} + + +/** + * virPoolObjFindByUUID: + * @poolobjs: Pool object table + * @uuid: pool uuid to find + * + * Returns: Locked pool object. + */ +virPoolObjPtr +virPoolObjTableFindByUUID(virPoolObjTablePtr poolobjs, + const unsigned char *uuid) +{ + return virPoolObjTableFindByUUIDInternal(poolobjs, uuid, false); +} + + +/** + * virPoolObjFindByUUIDUnlocked: + * @poolobjs: Pool object table + * @uuid: pool uuid to find + * + * Returns: Locked and ref count incremented pool object. + */ +virPoolObjPtr +virPoolObjTableFindByUUIDRef(virPoolObjTablePtr poolobjs, + const unsigned char *uuid) +{ + return virPoolObjTableFindByUUIDInternal(poolobjs, uuid, true); +} + + +virPoolObjPtr +virPoolObjTableFindByName(virPoolObjTablePtr poolobjs, + const char *name) +{ + virPoolObjPtr obj; + + virObjectLock(poolobjs); + obj = virHashLookup(poolobjs->objsName, name); + virObjectRef(obj); + virObjectUnlock(poolobjs); + if (obj) { + virObjectLock(obj); + if (obj->removing) { + virObjectUnlock(obj); + virObjectUnref(obj); + obj = NULL; + } + } + return obj; +} + + +static int +virPoolObjTableSearchCallback(const void *payload, + const void *name ATTRIBUTE_UNUSED, + const void *opaque) +{ + virPoolObjPtr obj = (virPoolObjPtr) payload; + struct virPoolObjTableSearchIterData *data = + (struct virPoolObjTableSearchIterData *) opaque; + int found = 0; + + virObjectLock(obj); + + if (data->callback(obj, data->opaque) == 1) + found = 1; + + virObjectUnlock(obj); + return found; +} + + +/* virPoolObjTableSearchInternal + * @poolobjs: Pool object table + * @callback: Consumer specific callback function for search + * @opaque: Consumer specific data to the callback function + * @ref: Whether to place a reference on the object or not + * + * Search through the poolobj table by name, calling the consumer + * specific callback with the obj and consumer specific data structure. + * If the consumer determines there's a match, it will return true + * and the cause the search to complete + * + * Returns virPoolObjPtr if data is found, NULL if not. The returned + * object will be locked and can have it reference count incremented. + * If the reference count is incremented, use the virPoolObjEndAPI on + * the object; otherwise, use virObjectUnlock to release the object lock. + */ +static virPoolObjPtr +virPoolObjTableSearchInternal(virPoolObjTablePtr poolobjs, + virPoolObjTableSearchIterator callback, + void *opaque, + bool ref) +{ + virPoolObjPtr ret; + struct virPoolObjTableSearchIterData data = { .callback = callback, + .opaque = opaque }; + + virObjectLock(poolobjs); + if (poolobjs->nameOnly) + ret = virHashSearch(poolobjs->objsName, virPoolObjTableSearchCallback, + &data); + else + ret = virHashSearch(poolobjs->objsUuid, virPoolObjTableSearchCallback, + &data); + if (ref) { + virObjectRef(ret); + virObjectUnlock(poolobjs); + } + if (ret) { + virObjectLock(ret); + if (ret->removing) { + virObjectUnlock(ret); + if (ref) + virObjectUnref(ret); + ret = NULL; + } + } + if (!ref) + virObjectUnlock(poolobjs); + + return ret; +} + + +virPoolObjPtr +virPoolObjTableSearch(virPoolObjTablePtr poolobjs, + virPoolObjTableSearchIterator callback, + void *opaque) +{ + return virPoolObjTableSearchInternal(poolobjs, callback, opaque, false); +} + + +virPoolObjPtr +virPoolObjTableSearchRef(virPoolObjTablePtr poolobjs, + virPoolObjTableSearchIterator callback, + void *opaque) +{ + return virPoolObjTableSearchInternal(poolobjs, callback, opaque, true); +} + + +struct iterateData { + virPoolObjTableIteratorCallback callback; + void *opaque; +}; + +static int +virPoolObjTableIterator(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + virPoolObjPtr obj = payload; + struct iterateData *data = opaque; + + virObjectLock(obj); + data->callback(obj, data->opaque); + virObjectUnlock(obj); + + return 0; +} + + +/* virPoolObjTableIterate: + * @poolobjs: Source table to perform iteration + * @callback: Function to call + * @opaque: Opaque data for callback + * + * Just iterate through each entry in @poolobjs calling the + * void function with the locked pool object + * + * Returns: void + */ +void +virPoolObjTableIterate(virPoolObjTablePtr poolobjs, + virPoolObjTableIteratorCallback callback, + void *opaque) +{ + struct iterateData data = { .callback = callback, + .opaque = opaque }; + virObjectLock(poolobjs); + if (poolobjs->nameOnly) + virHashForEach(poolobjs->objsName, virPoolObjTableIterator, &data); + else + virHashForEach(poolobjs->objsUuid, virPoolObjTableIterator, &data); + virObjectUnlock(poolobjs); +} + + +struct collectData { + virPoolObjPtr *objs; + size_t nobjs; +}; + +static int +virPoolObjTableCollectIterator(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + struct collectData *data = opaque; + + data->objs[data->nobjs++] = virObjectRef(payload); + return 0; +} + + +static void +virPoolObjTableFilter(virPoolObjPtr **list, + size_t *nobjs, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + virPoolObjMatchFilter matchfilter, + unsigned int flags) +{ + size_t i = 0; + + while (i < *nobjs) { + virPoolObjPtr obj = (*list)[i]; + + virObjectLock(obj); + + /* do not list the object if: + * 1) it's being removed. + * 2) connection does not have ACL to see it + * 3) it doesn't match the filter + */ + if (obj->removing || + (aclfilter && !aclfilter(conn, obj->def)) || + (matchfilter && !matchfilter(obj, flags))) { + virObjectUnlock(obj); + virObjectUnref(obj); + VIR_DELETE_ELEMENT(*list, i, *nobjs); + continue; + } + + virObjectUnlock(obj); + i++; + } +} + + +/* virPoolObjTableCollect: + * @poolobjs: Pool object table + * @conn: Pointer to connection + * @objs: Pointer to a list of objects to return + * @nobjs: Count of objects + * @aclfilter: Filter results based on ACL + * @matchfilter: Possible consumer callback to futher "match" the data + * @flags: Consumer specific flags + * + * Create a list of poolobjs that match both the ACL filter and the consumer + * provided match filter and return them and the count to the caller. Each + * of the returned object is returned with an incremented ref count. When + * the caller is done with the list, each object in the returned @objs list + * should be run through virObjectListFreeCount to Unref the object. + * + * Returns 0 on success, -1 on failure + */ +int +virPoolObjTableCollect(virPoolObjTablePtr poolobjs, + virConnectPtr conn, + virPoolObjPtr **objs, + size_t *nobjs, + virPoolObjACLFilter aclfilter, + virPoolObjMatchFilter matchfilter, + unsigned int flags) +{ + struct collectData data = { NULL, 0 }; + + virObjectLock(poolobjs); + if (poolobjs->nameOnly) { + if (VIR_ALLOC_N(data.objs, virHashSize(poolobjs->objsName)) < 0) { + virObjectUnlock(poolobjs); + return -1; + } + virHashForEach(poolobjs->objsName, virPoolObjTableCollectIterator, + &data); + } else { + if (VIR_ALLOC_N(data.objs, virHashSize(poolobjs->objsUuid)) < 0) { + virObjectUnlock(poolobjs); + return -1; + } + virHashForEach(poolobjs->objsUuid, virPoolObjTableCollectIterator, + &data); + } + virObjectUnlock(poolobjs); + + virPoolObjTableFilter(&data.objs, &data.nobjs, conn, + aclfilter, matchfilter, flags); + + *nobjs = data.nobjs; + *objs = data.objs; + + return 0; +} + + +static int +virPoolObjTableListIterator(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + virPoolObjPtr obj = payload; + struct virPoolObjTableListIterData *data = opaque; + + virObjectLock(obj); + if (data->aclfilter && !data->aclfilter(data->conn, obj->def)) + goto cleanup; + + if (data->callback && data->callback(obj, data->opaque) < 0) + data->ret = -1; + + cleanup: + virObjectUnlock(obj); + return 0; +} + + +/* virPoolObjTableList: + * @poolobjs: Pool object table + * @conn: Pointer to connection + * @aclfilter: Filter results based on ACL + * @callback: Possible consumer callback handle @opaque data + * @opaque: Consumer opaque data + * + * Similar to Collect, except allowing the consumer to build up it's + * @opaque data based on consumer @callback defined rules. + * + * Returns 0 on success, -1 on failure + */ +int +virPoolObjTableList(virPoolObjTablePtr poolobjs, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + virPoolObjTableListCallback callback, + void *opaque) +{ + struct virPoolObjTableListIterData data = { .conn = conn, + .aclfilter = aclfilter, + .callback = callback, + .opaque = opaque, + .ret = 0 }; + + virObjectLock(poolobjs); + if (poolobjs->nameOnly) + virHashForEach(poolobjs->objsName, virPoolObjTableListIterator, &data); + else + virHashForEach(poolobjs->objsUuid, virPoolObjTableListIterator, &data); + virObjectUnlock(poolobjs); + + return data.ret; +} + + +struct cloneData { + virPoolObjTableCloneCallback callback; + int ret; + virPoolObjTablePtr dst; +}; + +static int +virPoolObjTableCloneIterator(void *payload, + const void *name ATTRIBUTE_UNUSED, + void *opaque) +{ + virPoolObjPtr src = payload; + virPoolObjPtr dst = NULL; + struct cloneData *data = opaque; + void *def; + int ret = -1; + + virObjectLock(src); + + if (!(def = data->callback(src))) + goto error; + + if (!(dst = virPoolObjTableAdd(data->dst, src->pooldef->uuid, + src->pooldef->name, def, NULL, NULL, + src->defFreeFunc, NULL, 0))) + goto error; + def = NULL; + + ret = 0; + + cleanup: + src->defFreeFunc(def); + virObjectUnlock(dst); + virObjectUnlock(src); + return ret; + + error: + data->ret = -1; + goto cleanup; +} + + +/* virPoolObjTableClone: + * @src: Source table to perform a deep copy on + * @callback: Callback to create @def to be added into the cloned table. + * + * Make a deep copy of the object table including all objects and + * all defs within each hash table. This function does not use the + * assignFlags for the virPoolObjTableAdd[Locked] since generation + * of the cloned objects would be all considered new rather than + * assigning or redefining a definition. + * + * Returns: Cloned table or NULL + */ +virPoolObjTablePtr +virPoolObjTableClone(virPoolObjTablePtr src, + virPoolObjTableCloneCallback callback) +{ + struct cloneData data = { .callback = callback, + .ret = 0 }; + + virObjectLock(src); + if (!(data.dst = virPoolObjTableNew(src->type, src->hashStart, + src->nameOnly))) + goto cleanup; + + /* Clone both the UUID and Name table in the result */ + if (!src->nameOnly) + virHashForEach(src->objsUuid, virPoolObjTableCloneIterator, &data); + + virHashForEach(src->objsName, virPoolObjTableCloneIterator, &data); + + if (data.ret < 0) { + virObjectUnref(data.dst); + data.dst = NULL; + } + + cleanup: + virObjectUnlock(src); + return data.dst; +} + + +struct pruneData { + unsigned int flags; + virPoolObjMatchFilter matchfilter; +}; + +static int +pruneList(const void *payload, + const void *name ATTRIBUTE_UNUSED, + const void *opaque) +{ + virPoolObjPtr obj = (virPoolObjPtr) payload; + const struct pruneData *data = opaque; + int want = 0; + + virObjectLock(obj); + want = data->matchfilter(obj, data->flags); + virObjectUnlock(obj); + return want; +} + + +/** + * virPoolObjTablePrune: + * @poolobjs: Pool objects table + * @flags: bitwise-OR of flags to be prunedvirConnectListAllNetworksFlags + * + * Iterate over list of objects and remove the desired ones from the + * name and uuid (if exists) table + */ +void +virPoolObjTablePrune(virPoolObjTablePtr poolobjs, + virPoolObjMatchFilter matchfilter, + unsigned int flags) +{ + struct pruneData data = { .flags = flags, + .matchfilter = matchfilter }; + + virObjectLock(poolobjs); + if (!poolobjs->nameOnly) + virHashRemoveSet(poolobjs->objsUuid, pruneList, &data); + virHashRemoveSet(poolobjs->objsName, pruneList, &data); + virObjectUnlock(poolobjs); +} diff --git a/src/conf/virpoolobj.h b/src/conf/virpoolobj.h new file mode 100644 index 0000000..fcccb1e --- /dev/null +++ b/src/conf/virpoolobj.h @@ -0,0 +1,222 @@ +/* + * virpoolobj.h: internal pool objects handling + * + * Copyright (C) 2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#ifndef __VIRPOOLOBJ_H__ +# define __VIRPOOLOBJ_H__ + +# include "internal.h" + +typedef enum { + VIR_POOLOBJTABLE_NODEDEVICE, + VIR_POOLOBJTABLE_INTERFACE, + VIR_POOLOBJTABLE_NWFILTER, + VIR_POOLOBJTABLE_VOLUME, + VIR_POOLOBJTABLE_BLOCK_STORAGE, + VIR_POOLOBJTABLE_SECRET, + VIR_POOLOBJTABLE_NETWORK, + VIR_POOLOBJTABLE_SNAPSHOT, + VIR_POOLOBJTABLE_DOMAIN, + + VIR_POOLOBJTABLE_LAST +} virPoolObjTableType; + +/* Some default hash table size start values */ +# define VIR_POOLOBJTABLE_NODEDEVICE_HASHSTART 50 +# define VIR_POOLOBJTABLE_INTERFACE_HASHSTART 10 +# define VIR_POOLOBJTABLE_NWFILTER_HASHSTART 20 +# define VIR_POOLOBJTABLE_VOLUME_HASHSTART 10 +# define VIR_POOLOBJTABLE_BLOCK_STORAGE_HASHSTART 20 +# define VIR_POOLOBJTABLE_SECRET_HASHSTART 20 +# define VIR_POOLOBJTABLE_NETWORK_HASHSTART 10 +# define VIR_POOLOBJTABLE_SNAPSHOT_HASHSTART 10 +# define VIR_POOLOBJTABLE_DOMAIN_HASHSTART 50 + +typedef struct _virPoolDef virPoolDef; +typedef virPoolDef *virPoolDefPtr; + +typedef struct _virPoolObj virPoolObj; +typedef virPoolObj *virPoolObjPtr; + +typedef struct _virPoolObjTable virPoolObjTable; +typedef virPoolObjTable *virPoolObjTablePtr; + + +/* virPoolObjTableAssignDef + */ +typedef int (*virPoolObjTableAssignDefFunc)(virPoolObjPtr obj, + void *newDef, + void *oldDef, + unsigned int flags); + +/* + * virPoolObjTableSearchIterator: + * @obj: the virPoolObj for the current table entry + * @opaque: opaque user data provided at registration + * + * The virPoolObjTableSearch[Ref] functions walk through the PoolObjTable + * hash table entries expecting the SearchIterator function to return true + * once the searched on criteria is met. + * + * It is forbidden to call any other libvirt APIs from an implementation + * of this callback, since it can be invoked from a context which is not + * re-entrant safe. Failure to abide by this requirement may lead to + * application deadlocks or crashes. + */ +typedef bool (*virPoolObjTableSearchIterator)(virPoolObjPtr obj, void *opaque); +struct virPoolObjTableSearchIterData { + virPoolObjTableSearchIterator callback; + void *opaque; +}; + +/* + * virPoolObjACLFilter: + * Used by Collect and List API's in order filter results based on object ACL + */ +typedef bool (*virPoolObjACLFilter)(virConnectPtr conn, void *objdef); + +/* + * virPoolObjMatchFilter: + * Used by Collect and List API's in order filter results based on caller + * specific criteria + */ +typedef bool (*virPoolObjMatchFilter)(virPoolObjPtr obj, unsigned int filter); + +/* + * virPoolObjTableListCallback: + * Similar to the Match filter except, passing an opaque handle allows the + * List function to alter/generate what data is collected/filtered + */ +typedef int (*virPoolObjTableListCallback)(virPoolObjPtr obj, void *opaque); +struct virPoolObjTableListIterData { + virConnectPtr conn; + virPoolObjACLFilter aclfilter; + virPoolObjTableListCallback callback; + void *opaque; + int ret; +}; + + +typedef void *(*virPoolObjTableCloneCallback)(virPoolObjPtr src); + +typedef void (*virPoolObjTableIteratorCallback)(virPoolObjPtr obj, + void *opaque); + + +virPoolObjPtr virPoolObjNew(virPoolDefPtr pooldef, + void *def, + void *newDef, + virFreeCallback defFreeFunc); + +void virPoolObjSetActive(virPoolObjPtr obj, bool active); + +void virPoolObjSetAutostart(virPoolObjPtr obj, bool autostart); + +void virPoolObjSetBeingRemoved(virPoolObjPtr obj, bool beingRemoved); + +void virPoolObjSetPersistent(virPoolObjPtr obj, bool persistent); + +void virPoolObjSetDef(virPoolObjPtr obj, void *def); + +void virPoolObjSetNewDef(virPoolObjPtr obj, void *newDef); + +void virPoolObjSetPrivateData(virPoolObjPtr obj, + void *privateData, + virFreeCallback privateDataFreeFunc); + +bool virPoolObjIsActive(const virPoolObj *obj); + +bool virPoolObjIsAutostart(const virPoolObj *obj); + +bool virPoolObjIsBeingRemoved(const virPoolObj *obj); + +bool virPoolObjIsPersistent(const virPoolObj *obj); + +void *virPoolObjGetDef(const virPoolObj *obj); + +void *virPoolObjGetNewDef(const virPoolObj *obj); + +void *virPoolObjGetPrivateData(const virPoolObj *obj); + +void virPoolObjEndAPI(virPoolObjPtr *obj); + +virPoolObjTablePtr virPoolObjTableNew(virPoolObjTableType type, + int hashStart, + bool nameOnly); + +virPoolObjPtr virPoolObjTableAdd(virPoolObjTablePtr poolobjs, + const char *new_uuidstr, + const char *new_name, + void *def, + void *newDef, + void *oldDef, + virFreeCallback defFreeFunc, + virPoolObjTableAssignDefFunc assignDefFunc, + unsigned int assignFlags) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4) + ATTRIBUTE_NONNULL(7); + +void virPoolObjTableClearAll(virPoolObjTablePtr poolobjs); + +void virPoolObjTableRemove(virPoolObjTablePtr poolobjs, + virPoolObjPtr *obj); + +virPoolObjPtr virPoolObjTableFindByUUID(virPoolObjTablePtr poolobjs, + const unsigned char *uuid); + +virPoolObjPtr virPoolObjTableFindByUUIDRef(virPoolObjTablePtr poolobjs, + const unsigned char *uuid); + +virPoolObjPtr virPoolObjTableFindByName(virPoolObjTablePtr poolobjs, + const char *name); + +virPoolObjPtr virPoolObjTableSearch(virPoolObjTablePtr poolobjs, + virPoolObjTableSearchIterator callback, + void *opaque); + +virPoolObjPtr virPoolObjTableSearchRef(virPoolObjTablePtr poolobjs, + virPoolObjTableSearchIterator callback, + void *opaque); + +void virPoolObjTableIterate(virPoolObjTablePtr src, + virPoolObjTableIteratorCallback callback, + void *opaque); + +int virPoolObjTableCollect(virPoolObjTablePtr poolobjs, + virConnectPtr conn, + virPoolObjPtr **objs, + size_t *nobjs, + virPoolObjACLFilter aclfilter, + virPoolObjMatchFilter matchfilter, + unsigned int flags); + +int virPoolObjTableList(virPoolObjTablePtr poolobjs, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + virPoolObjTableListCallback callback, + void *opaque); + +virPoolObjTablePtr virPoolObjTableClone(virPoolObjTablePtr src, + virPoolObjTableCloneCallback callback); + +void virPoolObjTablePrune(virPoolObjTablePtr poolobjs, + virPoolObjMatchFilter matchfilter, + unsigned int flags); + +#endif /* __VIRPOOLOBJ_H__ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 6bbb36b..1f2157d 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -961,6 +961,39 @@ virDomainObjListRemoveLocked; virDomainObjListRename; +# conf/virpoolobj.h +virPoolObjEndAPI; +virPoolObjGetDef; +virPoolObjGetNewDef; +virPoolObjGetPrivateData; +virPoolObjIsActive; +virPoolObjIsAutostart; +virPoolObjIsBeingRemoved; +virPoolObjIsPersistent; +virPoolObjNew; +virPoolObjSetActive; +virPoolObjSetAutostart; +virPoolObjSetBeingRemoved; +virPoolObjSetDef; +virPoolObjSetNewDef; +virPoolObjSetPersistent; +virPoolObjSetPrivateData; +virPoolObjTableAdd; +virPoolObjTableClearAll; +virPoolObjTableClone; +virPoolObjTableCollect; +virPoolObjTableFindByName; +virPoolObjTableFindByUUID; +virPoolObjTableFindByUUIDRef; +virPoolObjTableIterate; +virPoolObjTableList; +virPoolObjTableNew; +virPoolObjTablePrune; +virPoolObjTableRemove; +virPoolObjTableSearch; +virPoolObjTableSearchRef; + + # conf/virsecretobj.h virSecretLoadAllConfigs; virSecretObjDeleteConfig; diff --git a/src/util/virerror.c b/src/util/virerror.c index ef17fb5..5330fb2 100644 --- a/src/util/virerror.c +++ b/src/util/virerror.c @@ -139,6 +139,7 @@ VIR_ENUM_IMPL(virErrorDomain, VIR_ERR_DOMAIN_LAST, "Perf", /* 65 */ "Libssh transport layer", + "Pool Object", ) -- 2.7.4

Use the virPoolObj[Table] object management model in order to manage the Node Device objects. While making the adjustments to use the new model, there are some code formatting adjustments that were also made with the goal to follow more recent code flow and layout. For API's that were static, rather than use "virNode*", some names were converted to be "node*" - makes it easier to determine while reading code what is local and what is "outside" the perveyance of the module. For the node_device_hal.c - removed the usage of privateData - it wasn't actually used anyway other than alloc()/free(). The NODE_DEV_UDI was never referenced. Signed-off-by: John Ferlan <jferlan@redhat.com> --- po/POTFILES.in | 1 + src/Makefile.am | 3 +- src/conf/node_device_conf.c | 497 +----------------------------- src/conf/node_device_conf.h | 85 +----- src/conf/virnodedeviceobj.c | 570 +++++++++++++++++++++++++++++++++++ src/conf/virnodedeviceobj.h | 86 ++++++ src/libvirt_private.syms | 25 +- src/node_device/node_device_driver.c | 388 ++++++++++-------------- src/node_device/node_device_driver.h | 2 +- src/node_device/node_device_hal.c | 82 ++--- src/node_device/node_device_udev.c | 76 +++-- src/test/test_driver.c | 294 +++++++----------- 12 files changed, 1032 insertions(+), 1077 deletions(-) create mode 100644 src/conf/virnodedeviceobj.c create mode 100644 src/conf/virnodedeviceobj.h diff --git a/po/POTFILES.in b/po/POTFILES.in index 95fa9a6..37379b5 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -42,6 +42,7 @@ src/conf/snapshot_conf.c src/conf/storage_conf.c src/conf/virchrdev.c src/conf/virdomainobjlist.c +src/conf/virnodedeviceobj.c src/conf/virpoolobj.c src/conf/virsecretobj.c src/cpu/cpu.c diff --git a/src/Makefile.am b/src/Makefile.am index 03a8cf3..20ee73a 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -392,7 +392,8 @@ SECRET_CONF_SOURCES = \ # Network driver generic impl APIs NODE_DEVICE_CONF_SOURCES = \ - conf/node_device_conf.c conf/node_device_conf.h + conf/node_device_conf.c conf/node_device_conf.h \ + conf/virnodedeviceobj.c conf/virnodedeviceobj.h CPU_CONF_SOURCES = \ conf/cpu_conf.c conf/cpu_conf.h diff --git a/src/conf/node_device_conf.c b/src/conf/node_device_conf.c index 4d3268f..cfd576d 100644 --- a/src/conf/node_device_conf.c +++ b/src/conf/node_device_conf.c @@ -59,7 +59,7 @@ VIR_ENUM_IMPL(virNodeDevNetCap, VIR_NODE_DEV_CAP_NET_LAST, "80211") static int -virNodeDevCapsDefParseString(const char *xpath, +nodeDeviceCapsDefParseString(const char *xpath, xmlXPathContextPtr ctxt, char **string) { @@ -72,173 +72,11 @@ virNodeDevCapsDefParseString(const char *xpath, return 0; } -int virNodeDeviceHasCap(const virNodeDeviceObj *dev, const char *cap) -{ - virNodeDevCapsDefPtr caps = dev->def->caps; - const char *fc_host_cap = - virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_FC_HOST); - const char *vports_cap = - virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS); - - while (caps) { - if (STREQ(cap, virNodeDevCapTypeToString(caps->data.type))) - return 1; - else if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) - if ((STREQ(cap, fc_host_cap) && - (caps->data.scsi_host.flags & - VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) || - (STREQ(cap, vports_cap) && - (caps->data.scsi_host.flags & - VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS))) - return 1; - caps = caps->next; - } - return 0; -} - - -/* virNodeDeviceFindFCCapDef: - * @dev: Pointer to current device - * - * Search the device object 'caps' array for fc_host capability. - * - * Returns: - * Pointer to the caps or NULL if not found - */ -static virNodeDevCapsDefPtr -virNodeDeviceFindFCCapDef(const virNodeDeviceObj *dev) -{ - virNodeDevCapsDefPtr caps = dev->def->caps; - - while (caps) { - if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST && - (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) - break; - - caps = caps->next; - } - return caps; -} - - -/* virNodeDeviceFindVPORTCapDef: - * @dev: Pointer to current device - * - * Search the device object 'caps' array for vport_ops capability. - * - * Returns: - * Pointer to the caps or NULL if not found - */ -static virNodeDevCapsDefPtr -virNodeDeviceFindVPORTCapDef(const virNodeDeviceObj *dev) -{ - virNodeDevCapsDefPtr caps = dev->def->caps; - - while (caps) { - if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST && - (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS)) - break; - - caps = caps->next; - } - return caps; -} - - -virNodeDeviceObjPtr -virNodeDeviceFindBySysfsPath(virNodeDeviceObjListPtr devs, - const char *sysfs_path) -{ - size_t i; - - for (i = 0; i < devs->count; i++) { - virNodeDeviceObjLock(devs->objs[i]); - if ((devs->objs[i]->def->sysfs_path != NULL) && - (STREQ(devs->objs[i]->def->sysfs_path, sysfs_path))) { - return devs->objs[i]; - } - virNodeDeviceObjUnlock(devs->objs[i]); - } - - return NULL; -} - - -virNodeDeviceObjPtr virNodeDeviceFindByName(virNodeDeviceObjListPtr devs, - const char *name) -{ - size_t i; - - for (i = 0; i < devs->count; i++) { - virNodeDeviceObjLock(devs->objs[i]); - if (STREQ(devs->objs[i]->def->name, name)) - return devs->objs[i]; - virNodeDeviceObjUnlock(devs->objs[i]); - } - - return NULL; -} - - -static virNodeDeviceObjPtr -virNodeDeviceFindByWWNs(virNodeDeviceObjListPtr devs, - const char *parent_wwnn, - const char *parent_wwpn) -{ - size_t i; - - for (i = 0; i < devs->count; i++) { - virNodeDevCapsDefPtr cap; - virNodeDeviceObjLock(devs->objs[i]); - if ((cap = virNodeDeviceFindFCCapDef(devs->objs[i])) && - STREQ_NULLABLE(cap->data.scsi_host.wwnn, parent_wwnn) && - STREQ_NULLABLE(cap->data.scsi_host.wwpn, parent_wwpn)) - return devs->objs[i]; - virNodeDeviceObjUnlock(devs->objs[i]); - } - - return NULL; -} - -static virNodeDeviceObjPtr -virNodeDeviceFindByFabricWWN(virNodeDeviceObjListPtr devs, - const char *parent_fabric_wwn) -{ - size_t i; - - for (i = 0; i < devs->count; i++) { - virNodeDevCapsDefPtr cap; - virNodeDeviceObjLock(devs->objs[i]); - if ((cap = virNodeDeviceFindFCCapDef(devs->objs[i])) && - STREQ_NULLABLE(cap->data.scsi_host.fabric_wwn, parent_fabric_wwn)) - return devs->objs[i]; - virNodeDeviceObjUnlock(devs->objs[i]); - } - - return NULL; -} - - -static virNodeDeviceObjPtr -virNodeDeviceFindByCap(virNodeDeviceObjListPtr devs, - const char *cap) -{ - size_t i; - - for (i = 0; i < devs->count; i++) { - virNodeDeviceObjLock(devs->objs[i]); - if (virNodeDeviceHasCap(devs->objs[i], cap)) - return devs->objs[i]; - virNodeDeviceObjUnlock(devs->objs[i]); - } - - return NULL; -} - - -void virNodeDeviceDefFree(virNodeDeviceDefPtr def) +void +virNodeDeviceDefFree(void *opaque) { + virNodeDeviceDefPtr def = opaque; virNodeDevCapsDefPtr caps; if (!def) @@ -263,82 +101,6 @@ void virNodeDeviceDefFree(virNodeDeviceDefPtr def) VIR_FREE(def); } -void virNodeDeviceObjFree(virNodeDeviceObjPtr dev) -{ - if (!dev) - return; - - virNodeDeviceDefFree(dev->def); - if (dev->privateFree) - (*dev->privateFree)(dev->privateData); - - virMutexDestroy(&dev->lock); - - VIR_FREE(dev); -} - -void virNodeDeviceObjListFree(virNodeDeviceObjListPtr devs) -{ - size_t i; - for (i = 0; i < devs->count; i++) - virNodeDeviceObjFree(devs->objs[i]); - VIR_FREE(devs->objs); - devs->count = 0; -} - -virNodeDeviceObjPtr virNodeDeviceAssignDef(virNodeDeviceObjListPtr devs, - virNodeDeviceDefPtr def) -{ - virNodeDeviceObjPtr device; - - if ((device = virNodeDeviceFindByName(devs, def->name))) { - virNodeDeviceDefFree(device->def); - device->def = def; - return device; - } - - if (VIR_ALLOC(device) < 0) - return NULL; - - if (virMutexInit(&device->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("cannot initialize mutex")); - VIR_FREE(device); - return NULL; - } - virNodeDeviceObjLock(device); - - if (VIR_APPEND_ELEMENT_COPY(devs->objs, devs->count, device) < 0) { - virNodeDeviceObjUnlock(device); - virNodeDeviceObjFree(device); - return NULL; - } - device->def = def; - - return device; - -} - -void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs, - virNodeDeviceObjPtr *dev) -{ - size_t i; - - virNodeDeviceObjUnlock(*dev); - - for (i = 0; i < devs->count; i++) { - virNodeDeviceObjLock(*dev); - if (devs->objs[i] == *dev) { - virNodeDeviceObjUnlock(*dev); - virNodeDeviceObjFree(devs->objs[i]); - *dev = NULL; - - VIR_DELETE_ELEMENT(devs->objs, i, devs->count); - break; - } - virNodeDeviceObjUnlock(*dev); - } -} static void virPCIELinkFormat(virBufferPtr buf, @@ -377,7 +139,9 @@ virPCIEDeviceInfoFormat(virBufferPtr buf, virBufferAddLit(buf, "</pci-express>\n"); } -char *virNodeDeviceDefFormat(const virNodeDeviceDef *def) + +char * +virNodeDeviceDefFormat(const virNodeDeviceDef *def) { virBuffer buf = VIR_BUFFER_INITIALIZER; virNodeDevCapsDefPtr caps; @@ -1009,7 +773,7 @@ virNodeDevCapSCSIHostParseXML(xmlXPathContextPtr ctxt, orignode2 = ctxt->node; ctxt->node = nodes[i]; - if (virNodeDevCapsDefParseString("string(./wwnn[1])", + if (nodeDeviceCapsDefParseString("string(./wwnn[1])", ctxt, &data->scsi_host.wwnn) < 0) { if (virRandomGenerateWWN(&data->scsi_host.wwnn, virt_type) < 0) { @@ -1021,7 +785,7 @@ virNodeDevCapSCSIHostParseXML(xmlXPathContextPtr ctxt, } } - if (virNodeDevCapsDefParseString("string(./wwpn[1])", + if (nodeDeviceCapsDefParseString("string(./wwpn[1])", ctxt, &data->scsi_host.wwpn) < 0) { if (virRandomGenerateWWN(&data->scsi_host.wwpn, virt_type) < 0) { @@ -1872,132 +1636,6 @@ virNodeDeviceGetWWNs(virNodeDeviceDefPtr def, return ret; } -/* - * Return the NPIV dev's parent device name - */ -/* virNodeDeviceFindFCParentHost: - * @parent: Pointer to node device object - * @parent_host: Pointer to return parent host number - * - * Search the capabilities for the device to find the FC capabilities - * in order to set the parent_host value. - * - * Returns: - * 0 on success with parent_host set, -1 otherwise; - */ -static int -virNodeDeviceFindFCParentHost(virNodeDeviceObjPtr parent, - int *parent_host) -{ - virNodeDevCapsDefPtr cap = virNodeDeviceFindVPORTCapDef(parent); - - if (!cap) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Parent device %s is not capable " - "of vport operations"), - parent->def->name); - return -1; - } - - *parent_host = cap->data.scsi_host.host; - return 0; -} - - -int -virNodeDeviceGetParentHost(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_name, - int *parent_host) -{ - virNodeDeviceObjPtr parent = NULL; - int ret; - - if (!(parent = virNodeDeviceFindByName(devs, parent_name))) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Could not find parent device for '%s'"), - dev_name); - return -1; - } - - ret = virNodeDeviceFindFCParentHost(parent, parent_host); - - virNodeDeviceObjUnlock(parent); - - return ret; -} - - -int -virNodeDeviceGetParentHostByWWNs(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_wwnn, - const char *parent_wwpn, - int *parent_host) -{ - virNodeDeviceObjPtr parent = NULL; - int ret; - - if (!(parent = virNodeDeviceFindByWWNs(devs, parent_wwnn, parent_wwpn))) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Could not find parent device for '%s'"), - dev_name); - return -1; - } - - ret = virNodeDeviceFindFCParentHost(parent, parent_host); - - virNodeDeviceObjUnlock(parent); - - return ret; -} - - -int -virNodeDeviceGetParentHostByFabricWWN(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_fabric_wwn, - int *parent_host) -{ - virNodeDeviceObjPtr parent = NULL; - int ret; - - if (!(parent = virNodeDeviceFindByFabricWWN(devs, parent_fabric_wwn))) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Could not find parent device for '%s'"), - dev_name); - return -1; - } - - ret = virNodeDeviceFindFCParentHost(parent, parent_host); - - virNodeDeviceObjUnlock(parent); - - return ret; -} - - -int -virNodeDeviceFindVportParentHost(virNodeDeviceObjListPtr devs, - int *parent_host) -{ - virNodeDeviceObjPtr parent = NULL; - const char *cap = virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS); - int ret; - - if (!(parent = virNodeDeviceFindByCap(devs, cap))) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Could not find any vport capable device")); - return -1; - } - - ret = virNodeDeviceFindFCParentHost(parent, parent_host); - - virNodeDeviceObjUnlock(parent); - - return ret; -} - void virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps) { @@ -2071,120 +1709,3 @@ void virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps) VIR_FREE(caps); } - - -void virNodeDeviceObjLock(virNodeDeviceObjPtr obj) -{ - virMutexLock(&obj->lock); -} - -void virNodeDeviceObjUnlock(virNodeDeviceObjPtr obj) -{ - virMutexUnlock(&obj->lock); -} - -static bool -virNodeDeviceCapMatch(virNodeDeviceObjPtr devobj, - int type) -{ - virNodeDevCapsDefPtr cap = NULL; - - for (cap = devobj->def->caps; cap; cap = cap->next) { - if (type == cap->data.type) - return true; - - if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { - if (type == VIR_NODE_DEV_CAP_FC_HOST && - (cap->data.scsi_host.flags & - VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) - return true; - - if (type == VIR_NODE_DEV_CAP_VPORTS && - (cap->data.scsi_host.flags & - VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS)) - return true; - } - } - - return false; -} - -#define MATCH(FLAG) ((flags & (VIR_CONNECT_LIST_NODE_DEVICES_CAP_ ## FLAG)) && \ - virNodeDeviceCapMatch(devobj, VIR_NODE_DEV_CAP_ ## FLAG)) -static bool -virNodeDeviceMatch(virNodeDeviceObjPtr devobj, - unsigned int flags) -{ - /* filter by cap type */ - if (flags & VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP) { - if (!(MATCH(SYSTEM) || - MATCH(PCI_DEV) || - MATCH(USB_DEV) || - MATCH(USB_INTERFACE) || - MATCH(NET) || - MATCH(SCSI_HOST) || - MATCH(SCSI_TARGET) || - MATCH(SCSI) || - MATCH(STORAGE) || - MATCH(FC_HOST) || - MATCH(VPORTS) || - MATCH(SCSI_GENERIC))) - return false; - } - - return true; -} -#undef MATCH - -int -virNodeDeviceObjListExport(virConnectPtr conn, - virNodeDeviceObjList devobjs, - virNodeDevicePtr **devices, - virNodeDeviceObjListFilter filter, - unsigned int flags) -{ - virNodeDevicePtr *tmp_devices = NULL; - virNodeDevicePtr device = NULL; - int ndevices = 0; - int ret = -1; - size_t i; - - if (devices && VIR_ALLOC_N(tmp_devices, devobjs.count + 1) < 0) - goto cleanup; - - for (i = 0; i < devobjs.count; i++) { - virNodeDeviceObjPtr devobj = devobjs.objs[i]; - virNodeDeviceObjLock(devobj); - if ((!filter || filter(conn, devobj->def)) && - virNodeDeviceMatch(devobj, flags)) { - if (devices) { - if (!(device = virGetNodeDevice(conn, - devobj->def->name))) { - virNodeDeviceObjUnlock(devobj); - goto cleanup; - } - tmp_devices[ndevices] = device; - } - ndevices++; - } - virNodeDeviceObjUnlock(devobj); - } - - if (tmp_devices) { - /* trim the array to the final size */ - ignore_value(VIR_REALLOC_N(tmp_devices, ndevices + 1)); - *devices = tmp_devices; - tmp_devices = NULL; - } - - ret = ndevices; - - cleanup: - if (tmp_devices) { - for (i = 0; i < ndevices; i++) - virObjectUnref(tmp_devices[i]); - } - - VIR_FREE(tmp_devices); - return ret; -} diff --git a/src/conf/node_device_conf.h b/src/conf/node_device_conf.h index e1cdb1d..ec7f079 100644 --- a/src/conf/node_device_conf.h +++ b/src/conf/node_device_conf.h @@ -28,10 +28,8 @@ # include "internal.h" # include "virbitmap.h" # include "virutil.h" -# include "virthread.h" # include "virpci.h" # include "device_conf.h" -# include "object_event.h" # include <libxml/tree.h> @@ -207,53 +205,6 @@ struct _virNodeDeviceDef { virNodeDevCapsDefPtr caps; /* optional device capabilities */ }; - -typedef struct _virNodeDeviceObj virNodeDeviceObj; -typedef virNodeDeviceObj *virNodeDeviceObjPtr; -struct _virNodeDeviceObj { - virMutex lock; - - virNodeDeviceDefPtr def; /* device definition */ - void *privateData; /* driver-specific private data */ - void (*privateFree)(void *data); /* destructor for private data */ - -}; - -typedef struct _virNodeDeviceObjList virNodeDeviceObjList; -typedef virNodeDeviceObjList *virNodeDeviceObjListPtr; -struct _virNodeDeviceObjList { - size_t count; - virNodeDeviceObjPtr *objs; -}; - -typedef struct _virNodeDeviceDriverState virNodeDeviceDriverState; -typedef virNodeDeviceDriverState *virNodeDeviceDriverStatePtr; -struct _virNodeDeviceDriverState { - virMutex lock; - - virNodeDeviceObjList devs; /* currently-known devices */ - void *privateData; /* driver-specific private data */ - - /* Immutable pointer, self-locking APIs */ - virObjectEventStatePtr nodeDeviceEventState; -}; - - -int virNodeDeviceHasCap(const virNodeDeviceObj *dev, const char *cap); - -virNodeDeviceObjPtr virNodeDeviceFindByName(virNodeDeviceObjListPtr devs, - const char *name); -virNodeDeviceObjPtr -virNodeDeviceFindBySysfsPath(virNodeDeviceObjListPtr devs, - const char *sysfs_path) - ATTRIBUTE_NONNULL(2); - -virNodeDeviceObjPtr virNodeDeviceAssignDef(virNodeDeviceObjListPtr devs, - virNodeDeviceDefPtr def); - -void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs, - virNodeDeviceObjPtr *dev); - char *virNodeDeviceDefFormat(const virNodeDeviceDef *def); virNodeDeviceDefPtr virNodeDeviceDefParseString(const char *str, @@ -271,36 +222,10 @@ int virNodeDeviceGetWWNs(virNodeDeviceDefPtr def, char **wwnn, char **wwpn); -int virNodeDeviceGetParentHost(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_name, - int *parent_host); - -int virNodeDeviceGetParentHostByWWNs(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_wwnn, - const char *parent_wwpn, - int *parent_host); - -int virNodeDeviceGetParentHostByFabricWWN(virNodeDeviceObjListPtr devs, - const char *dev_name, - const char *parent_fabric_wwn, - int *parent_host); - -int virNodeDeviceFindVportParentHost(virNodeDeviceObjListPtr devs, - int *parent_host); - -void virNodeDeviceDefFree(virNodeDeviceDefPtr def); - -void virNodeDeviceObjFree(virNodeDeviceObjPtr dev); - -void virNodeDeviceObjListFree(virNodeDeviceObjListPtr devs); +void virNodeDeviceDefFree(void *opaque); void virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps); -void virNodeDeviceObjLock(virNodeDeviceObjPtr obj); -void virNodeDeviceObjUnlock(virNodeDeviceObjPtr obj); - # define VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP \ (VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM | \ VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV | \ @@ -315,12 +240,4 @@ void virNodeDeviceObjUnlock(virNodeDeviceObjPtr obj); VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS | \ VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC) -typedef bool (*virNodeDeviceObjListFilter)(virConnectPtr conn, void *opaque); - -int virNodeDeviceObjListExport(virConnectPtr conn, - virNodeDeviceObjList devobjs, - virNodeDevicePtr **devices, - virNodeDeviceObjListFilter filter, - unsigned int flags); - #endif /* __VIR_NODE_DEVICE_CONF_H__ */ diff --git a/src/conf/virnodedeviceobj.c b/src/conf/virnodedeviceobj.c new file mode 100644 index 0000000..73a43ac --- /dev/null +++ b/src/conf/virnodedeviceobj.c @@ -0,0 +1,570 @@ +/* + * virnodedeviceobj.c: node device object handling + * (derived from node_device_conf.c) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include "datatypes.h" +#include "node_device_conf.h" + +#include "viralloc.h" +#include "virnodedeviceobj.h" +#include "virerror.h" +#include "virlog.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NODEDEV + +VIR_LOG_INIT("conf.virnodedeviceobj"); + +static int +nodeDeviceHasCap(const virNodeDeviceDef *def, + const char *cap) +{ + virNodeDevCapsDefPtr caps = def->caps; + const char *fc_host_cap = + virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_FC_HOST); + const char *vports_cap = + virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS); + + while (caps) { + if (STREQ(cap, virNodeDevCapTypeToString(caps->data.type))) + return 1; + else if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) + if ((STREQ(cap, fc_host_cap) && + (caps->data.scsi_host.flags & + VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) || + (STREQ(cap, vports_cap) && + (caps->data.scsi_host.flags & + VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS))) + return 1; + caps = caps->next; + } + return 0; +} + + +/* nodeDeviceFindFCCapDef: + * @def: Node device definition + * + * Search the device object 'caps' array for fc_host capability. + * + * Returns: + * Pointer to the caps or NULL if not found + */ +static virNodeDevCapsDefPtr +nodeDeviceFindFCCapDef(const virNodeDeviceDef *def) +{ + virNodeDevCapsDefPtr caps = def->caps; + + while (caps) { + if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST && + (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) + break; + + caps = caps->next; + } + return caps; +} + + +/* nodeDeviceFindVPORTCapDef: + * @def: Node device definition + * + * Search the device object 'caps' array for vport_ops capability. + * + * Returns: + * Pointer to the caps or NULL if not found + */ +static virNodeDevCapsDefPtr +nodeDeviceFindVPORTCapDef(const virNodeDeviceDef *def) +{ + virNodeDevCapsDefPtr caps = def->caps; + + while (caps) { + if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST && + (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS)) + break; + + caps = caps->next; + } + return caps; +} + + +struct searchData { + const char *sysfs_path; + const char *cap; + const char *parent_wwnn; + const char *parent_wwpn; + const char *parent_fabric_wwn; +}; + + +static bool +searchBySysfsPath(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct searchData *data = opaque; + + if (STREQ_NULLABLE(def->sysfs_path, data->sysfs_path)) + return true; + + return false; +} + + +static bool +searchByCap(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct searchData *data = opaque; + + if (nodeDeviceHasCap(def, data->cap)) + return true; + + return false; +} + + +static bool +searchByWWNs(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct searchData *data = opaque; + virNodeDevCapsDefPtr cap; + + if ((cap = nodeDeviceFindFCCapDef(def)) && + STREQ_NULLABLE(cap->data.scsi_host.wwnn, data->parent_wwnn) && + STREQ_NULLABLE(cap->data.scsi_host.wwpn, data->parent_wwpn)) + return true; + + return false; +} + + +static bool +searchByFabricWWN(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct searchData *data = opaque; + virNodeDevCapsDefPtr cap; + + if ((cap = nodeDeviceFindFCCapDef(def)) && + STREQ_NULLABLE(cap->data.scsi_host.fabric_wwn, data->parent_fabric_wwn)) + return true; + + return false; +} + + +/* virNodeDeviceObjFindBy{SysfsPath|Cap|WWNs|FabricWWN} + * @devs: Pointer to pool object table + * + * API specific: + * @sysfs_path: Sysfs path to search + * @cap: Capability name to search + * @wwnn & @wwpn: WWNN & WWPN name to search + * @fabric_wwn: Fabric_WWN to search + * + * Search by API specific argument in the table to return a pool object + * matching the argument specifics + * + * Returns: NULL if not found, a locked and ref'd object reference that + * needs a virPoolObjEndAPI to clear + */ +virPoolObjPtr +virNodeDeviceObjFindBySysfsPath(virPoolObjTablePtr devs, + const char *sysfs_path) +{ + struct searchData data = { .sysfs_path = sysfs_path }; + + return virPoolObjTableSearchRef(devs, searchBySysfsPath, &data); +} + + +static virPoolObjPtr +nodeDeviceFindByCap(virPoolObjTablePtr devs, + const char *cap) +{ + struct searchData data = { .cap = cap }; + + return virPoolObjTableSearchRef(devs, searchByCap, &data); +} + + +static virPoolObjPtr +nodeDeviceFindByWWNs(virPoolObjTablePtr devs, + const char *parent_wwnn, + const char *parent_wwpn) +{ + struct searchData data = { .parent_wwnn = parent_wwnn, + .parent_wwpn = parent_wwpn }; + + return virPoolObjTableSearchRef(devs, searchByWWNs, &data); +} + + +static virPoolObjPtr +nodeDeviceFindByFabricWWN(virPoolObjTablePtr devs, + const char *parent_fabric_wwn) +{ + struct searchData data = { .parent_fabric_wwn = parent_fabric_wwn }; + + return virPoolObjTableSearchRef(devs, searchByFabricWWN, &data); +} + + +/* + * Return the NPIV dev's parent device name + */ +/* nodeDeviceFindFCParentHost: + * @def: Pointer to node device def + * @parent_host: Pointer to return parent host number + * + * Search the capabilities for the device to find the FC capabilities + * in order to set the parent_host value. + * + * Returns: + * 0 on success with parent_host set, -1 otherwise; + */ +static int +nodeDeviceFindFCParentHost(const virNodeDeviceDef *def, + int *parent_host) +{ + virNodeDevCapsDefPtr cap = nodeDeviceFindVPORTCapDef(def); + + if (!cap) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Parent device %s is not capable " + "of vport operations"), + def->name); + return -1; + } + + *parent_host = cap->data.scsi_host.host; + return 0; +} + + +int +virNodeDeviceObjGetParentHost(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_name, + int *parent_host) +{ + virPoolObjPtr obj; + virNodeDeviceDefPtr def; + int ret; + + if (!(obj = virPoolObjTableFindByName(devs, parent_name))) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not find parent device for '%s'"), + dev_name); + return -1; + } + def = virPoolObjGetDef(obj); + + ret = nodeDeviceFindFCParentHost(def, parent_host); + + virPoolObjEndAPI(&obj); + return ret; +} + + +int +virNodeDeviceObjGetParentHostByWWNs(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_wwnn, + const char *parent_wwpn, + int *parent_host) +{ + virPoolObjPtr obj = NULL; + virNodeDeviceDefPtr def; + int ret; + + if (!(obj = nodeDeviceFindByWWNs(devs, parent_wwnn, parent_wwpn))) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not find parent device for '%s'"), + dev_name); + return -1; + } + def = virPoolObjGetDef(obj); + + ret = nodeDeviceFindFCParentHost(def, parent_host); + + virPoolObjEndAPI(&obj); + + return ret; +} + + +int +virNodeDeviceObjGetParentHostByFabricWWN(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_fabric_wwn, + int *parent_host) +{ + virPoolObjPtr obj; + virNodeDeviceDefPtr def; + int ret; + + if (!(obj = nodeDeviceFindByFabricWWN(devs, parent_fabric_wwn))) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not find parent device for '%s'"), + dev_name); + return -1; + } + def = virPoolObjGetDef(obj); + + ret = nodeDeviceFindFCParentHost(def, parent_host); + + virPoolObjEndAPI(&obj); + + return ret; +} + + +int +virNodeDeviceObjFindVportParentHost(virPoolObjTablePtr devs, + int *parent_host) +{ + virPoolObjPtr obj; + virNodeDeviceDefPtr def; + const char *cap = virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS); + int ret; + + if (!(obj = nodeDeviceFindByCap(devs, cap))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Could not find any vport capable device")); + return -1; + } + def = virPoolObjGetDef(obj); + + ret = nodeDeviceFindFCParentHost(def, parent_host); + + virPoolObjEndAPI(&obj); + return ret; +} + + +static bool +nodeDeviceCapMatch(virPoolObjPtr obj, + int type) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + virNodeDevCapsDefPtr cap = NULL; + + for (cap = def->caps; cap; cap = cap->next) { + if (type == cap->data.type) + return true; + + if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { + if (type == VIR_NODE_DEV_CAP_FC_HOST && + (cap->data.scsi_host.flags & + VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST)) + return true; + + if (type == VIR_NODE_DEV_CAP_VPORTS && + (cap->data.scsi_host.flags & + VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS)) + return true; + } + } + + return false; +} + + +virPoolObjPtr +virNodeDeviceObjFindByName(virPoolObjTablePtr devobjs, + const char *name) +{ + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByName(devobjs, name))) + virReportError(VIR_ERR_NO_NODE_DEVICE, + _("no node device with matching name '%s'"), + name); + + return obj; +} + + +struct nodeCountData { + const char *cap; + int count; +}; + +static int +nodeCount(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct nodeCountData *data = opaque; + + if (!data->cap || nodeDeviceHasCap(def, data->cap)) + data->count++; + + return 0; +} + + +int +virNodeDeviceObjNumOfDevices(virPoolObjTablePtr devobjs, + virConnectPtr conn, + const char *cap, + virPoolObjACLFilter aclfilter) +{ + struct nodeCountData data = { .cap = cap, + .count = 0 }; + + if (virPoolObjTableList(devobjs, conn, aclfilter, nodeCount, &data) < 0) + return 0; + + return data.count; +} + + +struct nodedevNameData { + const char *cap; + int nnames; + char **const names; + int maxnames; +}; + +static int +nodedevGetNames(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct nodedevNameData *data = opaque; + + if (data->nnames < data->maxnames) { + if (!data->cap || nodeDeviceHasCap(def, data->cap)) { + if (VIR_STRDUP(data->names[data->nnames++], def->name) < 0) + return -1; + } + } + return 0; +} + + +int +virNodeDeviceObjGetNames(virPoolObjTablePtr devobjs, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + const char *cap, + char **const names, + int maxnames) +{ + struct nodedevNameData data = { .cap = cap, + .nnames = 0, + .names = names, + .maxnames = maxnames }; + + if (virPoolObjTableList(devobjs, conn, aclfilter, + nodedevGetNames, &data) < 0) + goto failure; + + return data.nnames; + + failure: + while (--data.nnames >= 0) + VIR_FREE(names[data.nnames]); + return -1; +} + + +#define MATCH(FLAG) ((flags & (VIR_CONNECT_LIST_NODE_DEVICES_CAP_ ## FLAG)) && \ + nodeDeviceCapMatch(obj, VIR_NODE_DEV_CAP_ ## FLAG)) +static bool +nodeDeviceMatchFilter(virPoolObjPtr obj, + unsigned int flags) +{ + /* filter by cap type */ + if (flags & VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP) { + if (!(MATCH(SYSTEM) || + MATCH(PCI_DEV) || + MATCH(USB_DEV) || + MATCH(USB_INTERFACE) || + MATCH(NET) || + MATCH(SCSI_HOST) || + MATCH(SCSI_TARGET) || + MATCH(SCSI) || + MATCH(STORAGE) || + MATCH(FC_HOST) || + MATCH(VPORTS) || + MATCH(SCSI_GENERIC))) + return false; + } + + return true; +} +#undef MATCH + + +int +virNodeDeviceObjExportList(virConnectPtr conn, + virPoolObjTablePtr devobjs, + virNodeDevicePtr **devices, + virPoolObjACLFilter aclfilter, + unsigned int flags) +{ + virPoolObjPtr *objs = NULL; + virNodeDevicePtr *devs = NULL; + size_t nobjs = 0; + int ret = -1; + size_t i; + + if (virPoolObjTableCollect(devobjs, conn, &objs, &nobjs, aclfilter, + nodeDeviceMatchFilter, flags) < 0) + return -1; + + if (devices) { + if (VIR_ALLOC_N(devs, nobjs + 1) < 0) + goto cleanup; + + for (i = 0; i < nobjs; i++) { + virPoolObjPtr obj = objs[i]; + virNodeDeviceDefPtr def; + + virObjectLock(obj); + def = virPoolObjGetDef(obj); + devs[i] = virGetNodeDevice(conn, def->name); + virObjectUnlock(obj); + + if (!devs[i]) + goto cleanup; + } + + *devices = devs; + devs = NULL; + } + + ret = nobjs; + + cleanup: + virObjectListFree(devs); + virObjectListFreeCount(objs, nobjs); + return ret; +} diff --git a/src/conf/virnodedeviceobj.h b/src/conf/virnodedeviceobj.h new file mode 100644 index 0000000..3359211 --- /dev/null +++ b/src/conf/virnodedeviceobj.h @@ -0,0 +1,86 @@ +/* + * virnodedeviceobj.h: node device object handling for node devices + * (derived from node_device_conf.h) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#ifndef __VIRNODEDEVICEOBJ_H__ +# define __VIRNODEDEVICEOBJ_H__ + +# include "internal.h" +# include "virpoolobj.h" +# include "virthread.h" + +# include "object_event.h" + + +typedef struct _virNodeDeviceDriverState virNodeDeviceDriverState; +typedef virNodeDeviceDriverState *virNodeDeviceDriverStatePtr; +struct _virNodeDeviceDriverState { + virMutex lock; + + virPoolObjTablePtr devs; /* currently-known devices */ + void *privateData; /* driver-specific private data */ + + /* Immutable pointer, self-locking APIs */ + virObjectEventStatePtr nodeDeviceEventState; +}; + +virPoolObjPtr virNodeDeviceObjFindBySysfsPath(virPoolObjTablePtr devs, + const char *sysfs_path) + ATTRIBUTE_NONNULL(2); + +int virNodeDeviceObjGetParentHost(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_name, + int *parent_host); + +int virNodeDeviceObjGetParentHostByWWNs(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_wwnn, + const char *parent_wwpn, + int *parent_host); + +int virNodeDeviceObjGetParentHostByFabricWWN(virPoolObjTablePtr devs, + const char *dev_name, + const char *parent_fabric_wwn, + int *parent_host); + +int virNodeDeviceObjFindVportParentHost(virPoolObjTablePtr devs, + int *parent_host); + +virPoolObjPtr virNodeDeviceObjFindByName(virPoolObjTablePtr devobjs, + const char *name); + +int virNodeDeviceObjNumOfDevices(virPoolObjTablePtr devobjs, + virConnectPtr conn, + const char *cap, + virPoolObjACLFilter aclfilter); + +int virNodeDeviceObjGetNames(virPoolObjTablePtr devobjs, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + const char *cap, + char **const names, + int maxnames); + +int virNodeDeviceObjExportList(virConnectPtr conn, + virPoolObjTablePtr devobjs, + virNodeDevicePtr **devices, + virPoolObjACLFilter aclfilter, + unsigned int flags); + +#endif /* __VIRNODEDEVICEOBJ_H__ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 1f2157d..98b3840 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -694,25 +694,12 @@ virNetDevIPRouteParseXML; virNodeDevCapsDefFree; virNodeDevCapTypeFromString; virNodeDevCapTypeToString; -virNodeDeviceAssignDef; virNodeDeviceDefFormat; virNodeDeviceDefFree; virNodeDeviceDefParseFile; virNodeDeviceDefParseNode; virNodeDeviceDefParseString; -virNodeDeviceFindByName; -virNodeDeviceFindBySysfsPath; -virNodeDeviceFindVportParentHost; -virNodeDeviceGetParentHost; -virNodeDeviceGetParentHostByFabricWWN; -virNodeDeviceGetParentHostByWWNs; virNodeDeviceGetWWNs; -virNodeDeviceHasCap; -virNodeDeviceObjListExport; -virNodeDeviceObjListFree; -virNodeDeviceObjLock; -virNodeDeviceObjRemove; -virNodeDeviceObjUnlock; # conf/node_device_event.h @@ -961,6 +948,18 @@ virDomainObjListRemoveLocked; virDomainObjListRename; +# conf/virnodedeviceobj.h +virNodeDeviceObjExportList; +virNodeDeviceObjFindByName; +virNodeDeviceObjFindBySysfsPath; +virNodeDeviceObjFindVportParentHost; +virNodeDeviceObjGetNames; +virNodeDeviceObjGetParentHost; +virNodeDeviceObjGetParentHostByFabricWWN; +virNodeDeviceObjGetParentHostByWWNs; +virNodeDeviceObjNumOfDevices; + + # conf/virpoolobj.h virPoolObjEndAPI; virPoolObjGetDef; diff --git a/src/node_device/node_device_driver.c b/src/node_device/node_device_driver.c index 5238e23..f7e460c 100644 --- a/src/node_device/node_device_driver.c +++ b/src/node_device/node_device_driver.c @@ -42,19 +42,22 @@ #include "virutil.h" #include "viraccessapicheck.h" #include "virnetdev.h" +#include "virpoolobj.h" #define VIR_FROM_THIS VIR_FROM_NODEDEV virNodeDeviceDriverStatePtr driver; -static int update_caps(virNodeDeviceObjPtr dev) +static int +update_caps(virPoolObjPtr obj) { - virNodeDevCapsDefPtr cap = dev->def->caps; + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + virNodeDevCapsDefPtr cap = def->caps; while (cap) { switch (cap->data.type) { case VIR_NODE_DEV_CAP_SCSI_HOST: - nodeDeviceSysfsGetSCSIHostCaps(&dev->def->caps->data); + nodeDeviceSysfsGetSCSIHostCaps(&def->caps->data); break; case VIR_NODE_DEV_CAP_NET: if (virNetDevGetLinkInfo(cap->data.net.ifname, &cap->data.net.lnk) < 0) @@ -64,8 +67,8 @@ static int update_caps(virNodeDeviceObjPtr dev) return -1; break; case VIR_NODE_DEV_CAP_PCI_DEV: - if (nodeDeviceSysfsGetPCIRelatedDevCaps(dev->def->sysfs_path, - &dev->def->caps->data) < 0) + if (nodeDeviceSysfsGetPCIRelatedDevCaps(def->sysfs_path, + &def->caps->data) < 0) return -1; break; @@ -100,16 +103,18 @@ static int update_caps(virNodeDeviceObjPtr dev) * the driver name for a device each time its entry is used, both for * udev *and* HAL backends. */ -static int update_driver_name(virNodeDeviceObjPtr dev) +static int +update_driver_name(virPoolObjPtr obj) { + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); char *driver_link = NULL; char *devpath = NULL; char *p; int ret = -1; - VIR_FREE(dev->def->driver); + VIR_FREE(def->driver); - if (virAsprintf(&driver_link, "%s/driver", dev->def->sysfs_path) < 0) + if (virAsprintf(&driver_link, "%s/driver", def->sysfs_path) < 0) goto cleanup; /* Some devices don't have an explicit driver, so just return @@ -126,7 +131,7 @@ static int update_driver_name(virNodeDeviceObjPtr dev) } p = strrchr(devpath, '/'); - if (p && VIR_STRDUP(dev->def->driver, p + 1) < 0) + if (p && VIR_STRDUP(def->driver, p + 1) < 0) goto cleanup; ret = 0; @@ -137,7 +142,7 @@ static int update_driver_name(virNodeDeviceObjPtr dev) } #else /* XXX: Implement me for non-linux */ -static int update_driver_name(virNodeDeviceObjPtr dev ATTRIBUTE_UNUSED) +static int update_driver_name(virPoolObjPtr obj ATTRIBUTE_UNUSED) { return 0; } @@ -153,74 +158,41 @@ void nodeDeviceUnlock(void) virMutexUnlock(&driver->lock); } +/* Node device implementations */ + int nodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags) { - int ndevs = 0; - size_t i; + virCheckFlags(0, -1); if (virNodeNumOfDevicesEnsureACL(conn) < 0) return -1; - virCheckFlags(0, -1); - - nodeDeviceLock(); - for (i = 0; i < driver->devs.count; i++) { - virNodeDeviceObjPtr obj = driver->devs.objs[i]; - virNodeDeviceObjLock(obj); - if (virNodeNumOfDevicesCheckACL(conn, obj->def) && - ((cap == NULL) || - virNodeDeviceHasCap(obj, cap))) - ++ndevs; - virNodeDeviceObjUnlock(obj); - } - nodeDeviceUnlock(); - - return ndevs; + return virNodeDeviceObjNumOfDevices(driver->devs, conn, cap, + virNodeNumOfDevicesCheckACL); } + int nodeListDevices(virConnectPtr conn, const char *cap, - char **const names, int maxnames, + char **const names, + int maxnames, unsigned int flags) { - int ndevs = 0; - size_t i; + virCheckFlags(0, -1); if (virNodeListDevicesEnsureACL(conn) < 0) return -1; - virCheckFlags(0, -1); - - nodeDeviceLock(); - for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) { - virNodeDeviceObjPtr obj = driver->devs.objs[i]; - virNodeDeviceObjLock(obj); - if (virNodeListDevicesCheckACL(conn, obj->def) && - (cap == NULL || - virNodeDeviceHasCap(obj, cap))) { - if (VIR_STRDUP(names[ndevs++], obj->def->name) < 0) { - virNodeDeviceObjUnlock(obj); - goto failure; - } - } - virNodeDeviceObjUnlock(obj); - } - nodeDeviceUnlock(); - - return ndevs; - - failure: - nodeDeviceUnlock(); - --ndevs; - while (--ndevs >= 0) - VIR_FREE(names[ndevs]); - return -1; + return virNodeDeviceObjGetNames(driver->devs, conn, + virNodeListDevicesCheckACL, + cap, names, maxnames); } + int nodeConnectListAllNodeDevices(virConnectPtr conn, virNodeDevicePtr **devices, @@ -233,89 +205,92 @@ nodeConnectListAllNodeDevices(virConnectPtr conn, if (virConnectListAllNodeDevicesEnsureACL(conn) < 0) return -1; - nodeDeviceLock(); - ret = virNodeDeviceObjListExport(conn, driver->devs, devices, + ret = virNodeDeviceObjExportList(conn, driver->devs, devices, virConnectListAllNodeDevicesCheckACL, flags); - nodeDeviceUnlock(); return ret; } + virNodeDevicePtr nodeDeviceLookupByName(virConnectPtr conn, const char *name) { - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevicePtr ret = NULL; - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - name); - goto cleanup; - } + if (!(obj = virNodeDeviceObjFindByName(driver->devs, name))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNodeDeviceLookupByNameEnsureACL(conn, obj->def) < 0) + if (virNodeDeviceLookupByNameEnsureACL(conn, def) < 0) goto cleanup; ret = virGetNodeDevice(conn, name); cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } +struct nodeDeviceSearchData { + const char *wwnn; + const char *wwpn; +}; + +static bool +nodeLookupSCSIHostByWWN(virPoolObjPtr obj, + void *opaque) +{ + virNodeDeviceDefPtr def = virPoolObjGetDef(obj); + struct nodeDeviceSearchData *data = opaque; + virNodeDevCapsDefPtr cap; + + for (cap = def->caps; cap; cap = cap->next) { + if (cap->data.type != VIR_NODE_DEV_CAP_SCSI_HOST) + continue; + + nodeDeviceSysfsGetSCSIHostCaps(&cap->data); + if (cap->data.scsi_host.flags & + VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { + if (STREQ(cap->data.scsi_host.wwnn, data->wwnn) && + STREQ(cap->data.scsi_host.wwpn, data->wwpn)) { + return true; + } + } + } + + return false; +} + + virNodeDevicePtr nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn, const char *wwnn, const char *wwpn, unsigned int flags) { - size_t i; - virNodeDeviceObjListPtr devs = &driver->devs; - virNodeDevCapsDefPtr cap = NULL; - virNodeDeviceObjPtr obj = NULL; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevicePtr dev = NULL; + struct nodeDeviceSearchData data = { .wwnn = wwnn, + .wwpn = wwpn }; virCheckFlags(0, NULL); - nodeDeviceLock(); + if (!(obj = virPoolObjTableSearchRef(driver->devs, nodeLookupSCSIHostByWWN, + &data))) + return NULL; + def = virPoolObjGetDef(obj); - for (i = 0; i < devs->count; i++) { - obj = devs->objs[i]; - virNodeDeviceObjLock(obj); - cap = obj->def->caps; - - while (cap) { - if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { - nodeDeviceSysfsGetSCSIHostCaps(&cap->data); - if (cap->data.scsi_host.flags & - VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { - if (STREQ(cap->data.scsi_host.wwnn, wwnn) && - STREQ(cap->data.scsi_host.wwpn, wwpn)) { - - if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, obj->def) < 0) - goto out; - - dev = virGetNodeDevice(conn, obj->def->name); - virNodeDeviceObjUnlock(obj); - goto out; - } - } - } - cap = cap->next; - } + if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, def) < 0) + goto cleanup; - virNodeDeviceObjUnlock(obj); - } + dev = virGetNodeDevice(conn, def->name); - out: - nodeDeviceUnlock(); + cleanup: + virPoolObjEndAPI(&obj); return dev; } @@ -324,34 +299,27 @@ char * nodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags) { - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; char *ret = NULL; virCheckFlags(0, NULL); - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = virNodeDeviceObjFindByName(driver->devs, dev->name))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNodeDeviceGetXMLDescEnsureACL(dev->conn, obj->def) < 0) + if (virNodeDeviceGetXMLDescEnsureACL(dev->conn, def) < 0) goto cleanup; update_driver_name(obj); if (update_caps(obj) < 0) goto cleanup; - ret = virNodeDeviceDefFormat(obj->def); + ret = virNodeDeviceDefFormat(def); cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } @@ -359,25 +327,19 @@ nodeDeviceGetXMLDesc(virNodeDevicePtr dev, char * nodeDeviceGetParent(virNodeDevicePtr dev) { - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; char *ret = NULL; - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = virNodeDeviceObjFindByName(driver->devs, dev->name))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNodeDeviceGetParentEnsureACL(dev->conn, obj->def) < 0) + if (virNodeDeviceGetParentEnsureACL(dev->conn, def) < 0) goto cleanup; - if (obj->def->parent) { - if (VIR_STRDUP(ret, obj->def->parent) < 0) + if (def->parent) { + if (VIR_STRDUP(ret, def->parent) < 0) goto cleanup; } else { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -385,8 +347,7 @@ nodeDeviceGetParent(virNodeDevicePtr dev) } cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } @@ -394,26 +355,20 @@ nodeDeviceGetParent(virNodeDevicePtr dev) int nodeDeviceNumOfCaps(virNodeDevicePtr dev) { - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = virNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - if (virNodeDeviceNumOfCapsEnsureACL(dev->conn, obj->def) < 0) + if (virNodeDeviceNumOfCapsEnsureACL(dev->conn, def) < 0) goto cleanup; - for (caps = obj->def->caps; caps; caps = caps->next) { + for (caps = def->caps; caps; caps = caps->next) { ++ncaps; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { @@ -430,36 +385,32 @@ nodeDeviceNumOfCaps(virNodeDevicePtr dev) ret = ncaps; cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } int -nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) +nodeDeviceListCaps(virNodeDevicePtr dev, + char **const names, + int maxnames) { - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = virNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - if (virNodeDeviceListCapsEnsureACL(dev->conn, obj->def) < 0) + if (virNodeDeviceListCapsEnsureACL(dev->conn, def) < 0) goto cleanup; - for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) { - if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(caps->data.type)) < 0) + for (caps = def->caps; caps && ncaps < maxnames; caps = caps->next) { + if (VIR_STRDUP(names[ncaps++], + virNodeDevCapTypeToString(caps->data.type)) < 0) goto cleanup; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { @@ -483,8 +434,7 @@ nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) ret = ncaps; cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) @@ -573,9 +523,7 @@ nodeDeviceCreateXML(virConnectPtr conn, virt_type = virConnectGetType(conn); nodeDeviceLock(); - - def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type); - if (def == NULL) + if (!(def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type))) goto cleanup; if (virNodeDeviceCreateXMLEnsureACL(conn, def) < 0) @@ -585,36 +533,35 @@ nodeDeviceCreateXML(virConnectPtr conn, goto cleanup; if (def->parent) { - if (virNodeDeviceGetParentHost(&driver->devs, - def->name, - def->parent, - &parent_host) < 0) + if (virNodeDeviceObjGetParentHost(driver->devs, + def->name, + def->parent, + &parent_host) < 0) goto cleanup; } else if (def->parent_wwnn && def->parent_wwpn) { - if (virNodeDeviceGetParentHostByWWNs(&driver->devs, - def->name, - def->parent_wwnn, - def->parent_wwpn, - &parent_host) < 0) + if (virNodeDeviceObjGetParentHostByWWNs(driver->devs, + def->name, + def->parent_wwnn, + def->parent_wwpn, + &parent_host) < 0) goto cleanup; } else if (def->parent_fabric_wwn) { - if (virNodeDeviceGetParentHostByFabricWWN(&driver->devs, - def->name, - def->parent_fabric_wwn, - &parent_host) < 0) + if (virNodeDeviceObjGetParentHostByFabricWWN(driver->devs, + def->name, + def->parent_fabric_wwn, + &parent_host) < 0) goto cleanup; } else { /* Try to find a vport capable scsi_host when no parent supplied */ - if (virNodeDeviceFindVportParentHost(&driver->devs, &parent_host) < 0) + if (virNodeDeviceObjFindVportParentHost(driver->devs, &parent_host) < 0) goto cleanup; } if (virManageVport(parent_host, wwpn, wwnn, - VPORT_CREATE) == -1) { + VPORT_CREATE) == -1) goto cleanup; - } dev = find_new_device(conn, wwnn, wwpn); /* We don't check the return value, because one way or another, @@ -638,64 +585,45 @@ int nodeDeviceDestroy(virNodeDevicePtr dev) { int ret = -1; - virNodeDeviceObjPtr obj = NULL; - char *parent_name = NULL, *wwnn = NULL, *wwpn = NULL; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; + char *wwnn = NULL; + char *wwpn = NULL; int parent_host = -1; - nodeDeviceLock(); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - nodeDeviceUnlock(); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto out; - } - - if (virNodeDeviceDestroyEnsureACL(dev->conn, obj->def) < 0) - goto out; + if (!(obj = virNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - if (virNodeDeviceGetWWNs(obj->def, &wwnn, &wwpn) == -1) - goto out; + if (virNodeDeviceDestroyEnsureACL(dev->conn, def) < 0) + goto cleanup; + if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) == -1) + goto cleanup; - /* virNodeDeviceGetParentHost will cause the device object's lock to be - * taken, so we have to dup the parent's name and drop the lock - * before calling it. We don't need the reference to the object - * any more once we have the parent's name. */ - if (VIR_STRDUP(parent_name, obj->def->parent) < 0) { - virNodeDeviceObjUnlock(obj); - obj = NULL; - goto out; - } - virNodeDeviceObjUnlock(obj); - obj = NULL; - - if (virNodeDeviceGetParentHost(&driver->devs, - dev->name, - parent_name, - &parent_host) == -1) { - goto out; - } + if (virNodeDeviceObjGetParentHost(driver->devs, + dev->name, + def->parent, + &parent_host) == -1) + goto cleanup; if (virManageVport(parent_host, wwpn, wwnn, - VPORT_DELETE) == -1) { - goto out; - } + VPORT_DELETE) == -1) + goto cleanup; + + virPoolObjTableRemove(driver->devs, &obj); ret = 0; - out: - if (obj) - virNodeDeviceObjUnlock(obj); - VIR_FREE(parent_name); + cleanup: + virPoolObjEndAPI(&obj); VIR_FREE(wwnn); VIR_FREE(wwpn); return ret; } + int nodeConnectNodeDeviceEventRegisterAny(virConnectPtr conn, virNodeDevicePtr dev, diff --git a/src/node_device/node_device_driver.h b/src/node_device/node_device_driver.h index 56f89ab..bc8af8a 100644 --- a/src/node_device/node_device_driver.h +++ b/src/node_device/node_device_driver.h @@ -26,7 +26,7 @@ # include "internal.h" # include "driver.h" -# include "node_device_conf.h" +# include "virnodedeviceobj.h" # define LINUX_NEW_DEVICE_WAIT_TIME 60 diff --git a/src/node_device/node_device_hal.c b/src/node_device/node_device_hal.c index fb7bf25..70c37c9 100644 --- a/src/node_device/node_device_hal.c +++ b/src/node_device/node_device_hal.c @@ -52,9 +52,6 @@ VIR_LOG_INIT("node_device.node_device_hal"); #define DRV_STATE_HAL_CTX(ds) ((LibHalContext *)((ds)->privateData)) -#define NODE_DEV_UDI(obj) ((const char *)((obj)->privateData) - - static const char * hal_name(const char *udi) { @@ -446,27 +443,18 @@ gather_capabilities(LibHalContext *ctx, const char *udi, return rv; } -static void -free_udi(void *udi) -{ - VIR_FREE(udi); -} static void dev_create(const char *udi) { LibHalContext *ctx; char *parent_key = NULL; - virNodeDeviceObjPtr dev = NULL; + virPoolObjPtr obj = NULL; virNodeDeviceDefPtr def = NULL; const char *name = hal_name(udi); int rv; - char *privData; char *devicePath = NULL; - if (VIR_STRDUP(privData, udi) < 0) - return; - nodeDeviceLock(); ctx = DRV_STATE_HAL_CTX(driver); @@ -492,29 +480,23 @@ dev_create(const char *udi) /* Some devices don't have a path in sysfs, so ignore failure */ (void)get_str_prop(ctx, udi, "linux.sysfs_path", &devicePath); + VIR_STEAL_PTR(def->sysfs_path, devicePath); - dev = virNodeDeviceAssignDef(&driver->devs, - def); - - if (!dev) { - VIR_FREE(devicePath); + if (!(obj = virPoolObjTableAdd(driver->devs, NULL, def->name, + def, NULL, NULL, virNodeDeviceDefFree, + NULL, 0))) goto failure; - } - - dev->privateData = privData; - dev->privateFree = free_udi; - dev->def->sysfs_path = devicePath; - - virNodeDeviceObjUnlock(dev); + def = NULL; + virPoolObjEndAPI(&obj); nodeDeviceUnlock(); return; failure: VIR_DEBUG("FAILED TO ADD dev %s", name); cleanup: - VIR_FREE(privData); virNodeDeviceDefFree(def); + virPoolObjEndAPI(&obj); nodeDeviceUnlock(); } @@ -522,19 +504,17 @@ static void dev_refresh(const char *udi) { const char *name = hal_name(udi); - virNodeDeviceObjPtr dev; + virPoolObjPtr obj; - nodeDeviceLock(); - dev = virNodeDeviceFindByName(&driver->devs, name); - if (dev) { + if ((obj = virPoolObjTableFindByName(driver->devs, name))) { /* Simply "rediscover" device -- incrementally handling changes * to sub-capabilities (like net.80203) is nasty ... so avoid it. */ - virNodeDeviceObjRemove(&driver->devs, &dev); + virPoolObjTableObjRemove(driver->devs, &obj); } else { VIR_DEBUG("no device named %s", name); } - nodeDeviceUnlock(); + virPoolObjEndAPI(&obj); if (dev) dev_create(udi); @@ -554,16 +534,14 @@ device_removed(LibHalContext *ctx ATTRIBUTE_UNUSED, const char *udi) { const char *name = hal_name(udi); - virNodeDeviceObjPtr dev; + virPoolObjPtr obj; - nodeDeviceLock(); - dev = virNodeDeviceFindByName(&driver->devs, name); VIR_DEBUG("%s", name); - if (dev) - virNodeDeviceObjRemove(&driver->devs, &dev); + if ((obj = virPoolObjTableFindByName(driver->devs, name))) + virPoolObjTableRemove(driver->devs, &obj); else VIR_DEBUG("no device named %s", name); - nodeDeviceUnlock(); + virPoolObjEndAPI(&obj); } @@ -572,18 +550,18 @@ device_cap_added(LibHalContext *ctx, const char *udi, const char *cap) { const char *name = hal_name(udi); - virNodeDeviceObjPtr dev; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; - nodeDeviceLock(); - dev = virNodeDeviceFindByName(&driver->devs, name); - nodeDeviceUnlock(); VIR_DEBUG("%s %s", cap, name); - if (dev) { - (void)gather_capability(ctx, udi, cap, &dev->def->caps); - virNodeDeviceObjUnlock(dev); + + if ((obj = virPoolObjTableFindByName(driver->devs, name))) { + def = virPoolObjGetDef(obj); + (void)gather_capability(ctx, udi, cap, &def->caps); } else { VIR_DEBUG("no device named %s", name); } + virPoolObjEndAPI(&obj); } @@ -639,6 +617,11 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED, } nodeDeviceLock(); + if (!(driver->devs = + virPoolObjTableNew(VIR_POOLOBJTABLE_NODEDEVICE, + VIR_POOLOBJTABLE_NODEDEVICE_HASHSTART, true))) + goto cleanup; + dbus_error_init(&err); if (!(sysbus = virDBusGetSystemBus())) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -713,9 +696,9 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED, _("%s: %s"), err.name, err.message); dbus_error_free(&err); } - virNodeDeviceObjListFree(&driver->devs); if (hal_ctx) (void)libhal_ctx_free(hal_ctx); + virObjectUnref(driver->devs); nodeDeviceUnlock(); VIR_FREE(driver); @@ -729,7 +712,7 @@ nodeStateCleanup(void) if (driver) { nodeDeviceLock(); LibHalContext *hal_ctx = DRV_STATE_HAL_CTX(driver); - virNodeDeviceObjListFree(&driver->devs); + virObjectUnref(driver->devs); (void)libhal_ctx_shutdown(hal_ctx, NULL); (void)libhal_ctx_free(hal_ctx); nodeDeviceUnlock(); @@ -751,10 +734,9 @@ nodeStateReload(void) LibHalContext *hal_ctx; VIR_INFO("Reloading HAL device state"); - nodeDeviceLock(); + VIR_INFO("Removing existing objects"); - virNodeDeviceObjListFree(&driver->devs); - nodeDeviceUnlock(); + virPoolObjTableClearAll(driver->devs); hal_ctx = DRV_STATE_HAL_CTX(driver); VIR_INFO("Creating new objects"); diff --git a/src/node_device/node_device_udev.c b/src/node_device/node_device_udev.c index 4b81312..33e8cc7 100644 --- a/src/node_device/node_device_udev.c +++ b/src/node_device/node_device_udev.c @@ -43,6 +43,7 @@ #include "virpci.h" #include "virstring.h" #include "virnetdev.h" +#include "virpoolobj.h" #define VIR_FROM_THIS VIR_FROM_NODEDEV @@ -1024,32 +1025,34 @@ static int udevGetDeviceDetails(struct udev_device *device, static int udevRemoveOneDevice(struct udev_device *device) { - virNodeDeviceObjPtr dev = NULL; + virPoolObjPtr obj = NULL; + virNodeDeviceDefPtr def; virObjectEventPtr event = NULL; const char *name = NULL; int ret = -1; name = udev_device_get_syspath(device); - dev = virNodeDeviceFindBySysfsPath(&driver->devs, name); - if (!dev) { + if (!(obj = virNodeDeviceObjFindBySysfsPath(driver->devs, name))) { VIR_DEBUG("Failed to find device to remove that has udev name '%s'", name); goto cleanup; } - event = virNodeDeviceEventLifecycleNew(dev->def->name, + def = virPoolObjGetDef(obj); + event = virNodeDeviceEventLifecycleNew(def->name, VIR_NODE_DEVICE_EVENT_DELETED, 0); VIR_DEBUG("Removing device '%s' with sysfs path '%s'", - dev->def->name, name); - virNodeDeviceObjRemove(&driver->devs, &dev); + def->name, name); + virPoolObjTableRemove(driver->devs, &obj); ret = 0; cleanup: if (event) virObjectEventStateQueue(driver->nodeDeviceEventState, event); + virPoolObjEndAPI(&obj); return ret; } @@ -1059,7 +1062,7 @@ static int udevSetParent(struct udev_device *device, { struct udev_device *parent_device = NULL; const char *parent_sysfs_path = NULL; - virNodeDeviceObjPtr dev = NULL; + virPoolObjPtr obj = NULL; int ret = -1; parent_device = device; @@ -1077,14 +1080,11 @@ static int udevSetParent(struct udev_device *device, goto cleanup; } - dev = virNodeDeviceFindBySysfsPath(&driver->devs, - parent_sysfs_path); - if (dev != NULL) { - if (VIR_STRDUP(def->parent, dev->def->name) < 0) { - virNodeDeviceObjUnlock(dev); + if ((obj = virNodeDeviceObjFindBySysfsPath(driver->devs, + parent_sysfs_path))) { + virNodeDeviceDefPtr objdef = virPoolObjGetDef(obj); + if (VIR_STRDUP(def->parent, objdef->name) < 0) goto cleanup; - } - virNodeDeviceObjUnlock(dev); if (VIR_STRDUP(def->parent_sysfs_path, parent_sysfs_path) < 0) goto cleanup; @@ -1098,6 +1098,7 @@ static int udevSetParent(struct udev_device *device, ret = 0; cleanup: + virPoolObjEndAPI(&obj); return ret; } @@ -1105,7 +1106,8 @@ static int udevSetParent(struct udev_device *device, static int udevAddOneDevice(struct udev_device *device) { virNodeDeviceDefPtr def = NULL; - virNodeDeviceObjPtr dev = NULL; + virPoolObjPtr obj = NULL; + virNodeDeviceDefPtr newdef; virObjectEventPtr event = NULL; bool new_device = true; int ret = -1; @@ -1128,29 +1130,37 @@ static int udevAddOneDevice(struct udev_device *device) if (udevGetDeviceDetails(device, def) != 0) goto cleanup; + if (!def->name) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Did not generate def->name for '%s'"), + udev_device_get_syspath(device)); + goto cleanup; + } + if (udevSetParent(device, def) != 0) goto cleanup; - dev = virNodeDeviceFindByName(&driver->devs, def->name); - if (dev) { - virNodeDeviceObjUnlock(dev); + if ((obj = virPoolObjTableFindByName(driver->devs, def->name))) { + virPoolObjEndAPI(&obj); new_device = false; } /* If this is a device change, the old definition will be freed * and the current definition will take its place. */ - dev = virNodeDeviceAssignDef(&driver->devs, def); - if (dev == NULL) + if (!(obj = virPoolObjTableAdd(driver->devs, NULL, def->name, + def, NULL, NULL, virNodeDeviceDefFree, + NULL, 0))) goto cleanup; + VIR_STEAL_PTR(newdef, def); if (new_device) - event = virNodeDeviceEventLifecycleNew(dev->def->name, + event = virNodeDeviceEventLifecycleNew(newdef->name, VIR_NODE_DEVICE_EVENT_CREATED, 0); else - event = virNodeDeviceEventUpdateNew(dev->def->name); + event = virNodeDeviceEventUpdateNew(newdef->name); - virNodeDeviceObjUnlock(dev); + virPoolObjEndAPI(&obj); ret = 0; @@ -1288,7 +1298,7 @@ static int nodeStateCleanup(void) if (udev != NULL) udev_unref(udev); - virNodeDeviceObjListFree(&driver->devs); + virObjectUnref(driver->devs); nodeDeviceUnlock(); virMutexDestroy(&driver->lock); VIR_FREE(driver); @@ -1404,7 +1414,7 @@ udevGetDMIData(virNodeDevCapDataPtr data) static int udevSetupSystemDev(void) { virNodeDeviceDefPtr def = NULL; - virNodeDeviceObjPtr dev = NULL; + virPoolObjPtr obj = NULL; int ret = -1; if (VIR_ALLOC(def) < 0) @@ -1420,17 +1430,18 @@ static int udevSetupSystemDev(void) udevGetDMIData(&def->caps->data); #endif - dev = virNodeDeviceAssignDef(&driver->devs, def); - if (dev == NULL) + if (!(obj = virPoolObjTableAdd(driver->devs, NULL, def->name, + def, NULL, NULL, virNodeDeviceDefFree, + NULL, 0))) goto cleanup; + def = NULL; - virNodeDeviceObjUnlock(dev); + virPoolObjEndAPI(&obj); ret = 0; cleanup: - if (ret == -1) - virNodeDeviceDefFree(def); + virNodeDeviceDefFree(def); return ret; } @@ -1488,6 +1499,11 @@ static int nodeStateInitialize(bool privileged, nodeDeviceLock(); driver->nodeDeviceEventState = virObjectEventStateNew(); + if (!(driver->devs = + virPoolObjTableNew(VIR_POOLOBJTABLE_NODEDEVICE, + VIR_POOLOBJTABLE_NODEDEVICE_HASHSTART, true))) + goto cleanup; + if (udevPCITranslateInit(privileged) < 0) goto cleanup; diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 6820298..ce44728 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -36,6 +36,7 @@ #include "virerror.h" #include "datatypes.h" #include "test_driver.h" +#include "virpoolobj.h" #include "virbuffer.h" #include "viruuid.h" #include "capabilities.h" @@ -51,6 +52,7 @@ #include "storage_conf.h" #include "storage_event.h" #include "node_device_conf.h" +#include "virnodedeviceobj.h" #include "node_device_event.h" #include "virxml.h" #include "virthread.h" @@ -98,7 +100,7 @@ struct _testDriver { bool transaction_running; virInterfaceObjList backupIfaces; virStoragePoolObjList pools; - virNodeDeviceObjList devs; + virPoolObjTablePtr devs; int numCells; testCell cells[MAX_CELLS]; size_t numAuths; @@ -149,7 +151,7 @@ testDriverFree(testDriverPtr driver) virObjectUnref(driver->caps); virObjectUnref(driver->xmlopt); virObjectUnref(driver->domains); - virNodeDeviceObjListFree(&driver->devs); + virObjectUnref(driver->devs); virObjectUnref(driver->networks); virInterfaceObjListFree(&driver->ifaces); virStoragePoolObjListFree(&driver->pools); @@ -413,6 +415,9 @@ testDriverNew(void) if (!(ret->xmlopt = virDomainXMLOptionNew(NULL, NULL, &ns)) || !(ret->eventState = virObjectEventStateNew()) || + !(ret->devs = virPoolObjTableNew(VIR_POOLOBJTABLE_NODEDEVICE, + VIR_POOLOBJTABLE_NODEDEVICE_HASHSTART, + true)) || !(ret->domains = virDomainObjListNew()) || !(ret->networks = virNetworkObjListNew())) goto error; @@ -1113,33 +1118,32 @@ testParseNodedevs(testDriverPtr privconn, int num, ret = -1; size_t i; xmlNodePtr *nodes = NULL; - virNodeDeviceObjPtr obj; + virNodeDeviceDefPtr def = NULL; + xmlNodePtr node; + virPoolObjPtr obj = NULL; - num = virXPathNodeSet("/node/device", ctxt, &nodes); - if (num < 0) + if ((num = virXPathNodeSet("/node/device", ctxt, &nodes)) < 0) goto error; for (i = 0; i < num; i++) { - virNodeDeviceDefPtr def; - xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file, - "nodedev"); - if (!node) + if (!(node = testParseXMLDocFromFile(nodes[i], file, "nodedev"))) goto error; - def = virNodeDeviceDefParseNode(ctxt->doc, node, 0, NULL); - if (!def) + if (!(def = virNodeDeviceDefParseNode(ctxt->doc, node, 0, NULL))) goto error; - if (!(obj = virNodeDeviceAssignDef(&privconn->devs, def))) { - virNodeDeviceDefFree(def); + if (!(obj = virPoolObjTableAdd(privconn->devs, NULL, def->name, + def, NULL, NULL, virNodeDeviceDefFree, + NULL, 0))) goto error; - } + def = NULL; - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); } ret = 0; error: + virNodeDeviceDefFree(def); VIR_FREE(nodes); return ret; } @@ -5374,27 +5378,34 @@ testStorageVolGetPath(virStorageVolPtr vol) /* Node device implementations */ +static virPoolObjPtr +testNodeDeviceObjFindByName(virPoolObjTablePtr devobjs, + const char *name) +{ + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByName(devobjs, name))) + virReportError(VIR_ERR_NO_NODE_DEVICE, + _("no node device with matching name '%s'"), + name); + + return obj; +} + + static int testNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags) { testDriverPtr driver = conn->privateData; - int ndevs = 0; - size_t i; virCheckFlags(0, -1); - testDriverLock(driver); - for (i = 0; i < driver->devs.count; i++) - if ((cap == NULL) || - virNodeDeviceHasCap(driver->devs.objs[i], cap)) - ++ndevs; - testDriverUnlock(driver); - - return ndevs; + return virNodeDeviceObjNumOfDevices(driver->devs, conn, cap, NULL); } + static int testNodeListDevices(virConnectPtr conn, const char *cap, @@ -5403,118 +5414,73 @@ testNodeListDevices(virConnectPtr conn, unsigned int flags) { testDriverPtr driver = conn->privateData; - int ndevs = 0; - size_t i; virCheckFlags(0, -1); - testDriverLock(driver); - for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) { - virNodeDeviceObjLock(driver->devs.objs[i]); - if (cap == NULL || - virNodeDeviceHasCap(driver->devs.objs[i], cap)) { - if (VIR_STRDUP(names[ndevs++], driver->devs.objs[i]->def->name) < 0) { - virNodeDeviceObjUnlock(driver->devs.objs[i]); - goto failure; - } - } - virNodeDeviceObjUnlock(driver->devs.objs[i]); - } - testDriverUnlock(driver); - - return ndevs; - - failure: - testDriverUnlock(driver); - --ndevs; - while (--ndevs >= 0) - VIR_FREE(names[ndevs]); - return -1; + return virNodeDeviceObjGetNames(driver->devs, conn, NULL, + cap, names, maxnames); } + static virNodeDevicePtr testNodeDeviceLookupByName(virConnectPtr conn, const char *name) { testDriverPtr driver = conn->privateData; - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; virNodeDevicePtr ret = NULL; - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, name); - testDriverUnlock(driver); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - name); - goto cleanup; - } + if (!(obj = testNodeDeviceObjFindByName(driver->devs, name))) + return NULL; ret = virGetNodeDevice(conn, name); - cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } + static char * testNodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags) { testDriverPtr driver = dev->conn->privateData; - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; char *ret = NULL; virCheckFlags(0, NULL); - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - testDriverUnlock(driver); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = testNodeDeviceObjFindByName(driver->devs, dev->name))) + return NULL; + def = virPoolObjGetDef(obj); - ret = virNodeDeviceDefFormat(obj->def); + ret = virNodeDeviceDefFormat(def); - cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } + static char * testNodeDeviceGetParent(virNodeDevicePtr dev) { testDriverPtr driver = dev->conn->privateData; - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; char *ret = NULL; - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - testDriverUnlock(driver); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = testNodeDeviceObjFindByName(driver->devs, dev->name))) + return NULL; + def = virPoolObjGetDef(obj); - if (obj->def->parent) { - ignore_value(VIR_STRDUP(ret, obj->def->parent)); + if (def->parent) { + ignore_value(VIR_STRDUP(ret, def->parent)); } else { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no parent for this device")); } - cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } @@ -5523,30 +5489,20 @@ static int testNodeDeviceNumOfCaps(virNodeDevicePtr dev) { testDriverPtr driver = dev->conn->privateData; - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; - int ret = -1; - - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - testDriverUnlock(driver); - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = testNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - for (caps = obj->def->caps; caps; caps = caps->next) + for (caps = def->caps; caps; caps = caps->next) ++ncaps; - ret = ncaps; - cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); - return ret; + virPoolObjEndAPI(&obj); + return ncaps; } @@ -5554,31 +5510,25 @@ static int testNodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) { testDriverPtr driver = dev->conn->privateData; - virNodeDeviceObjPtr obj; + virPoolObjPtr obj; + virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - testDriverUnlock(driver); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto cleanup; - } + if (!(obj = testNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) { - if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(caps->data.type)) < 0) + for (caps = def->caps; caps && ncaps < maxnames; caps = caps->next) { + if (VIR_STRDUP(names[ncaps++], + virNodeDevCapTypeToString(caps->data.type)) < 0) goto cleanup; } ret = ncaps; cleanup: - if (obj) - virNodeDeviceObjUnlock(obj); + virPoolObjEndAPI(&obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) @@ -5587,6 +5537,7 @@ testNodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) return ret; } + static virNodeDevicePtr testNodeDeviceCreateXML(virConnectPtr conn, const char *xmlDesc, @@ -5594,7 +5545,8 @@ testNodeDeviceCreateXML(virConnectPtr conn, { testDriverPtr driver = conn->privateData; virNodeDeviceDefPtr def = NULL; - virNodeDeviceObjPtr obj = NULL; + virPoolObjPtr obj = NULL; + virNodeDeviceDefPtr objdef; char *wwnn = NULL, *wwpn = NULL; int parent_host = -1; virNodeDevicePtr dev = NULL; @@ -5603,20 +5555,17 @@ testNodeDeviceCreateXML(virConnectPtr conn, virCheckFlags(0, NULL); - testDriverLock(driver); - - def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, NULL); - if (def == NULL) + if (!(def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, NULL))) goto cleanup; /* We run these next two simply for validation */ if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) == -1) goto cleanup; - if (virNodeDeviceGetParentHost(&driver->devs, - def->name, - def->parent, - &parent_host) == -1) { + if (virNodeDeviceObjGetParentHost(driver->devs, + def->name, + def->parent, + &parent_host) == -1) { goto cleanup; } @@ -5638,19 +5587,20 @@ testNodeDeviceCreateXML(virConnectPtr conn, caps = caps->next; } - - if (!(obj = virNodeDeviceAssignDef(&driver->devs, def))) + if (!(obj = virPoolObjTableAdd(driver->devs, NULL, def->name, + def, NULL, NULL, virNodeDeviceDefFree, + NULL, 0))) goto cleanup; - virNodeDeviceObjUnlock(obj); + VIR_STEAL_PTR(objdef, def); - event = virNodeDeviceEventLifecycleNew(def->name, + event = virNodeDeviceEventLifecycleNew(objdef->name, VIR_NODE_DEVICE_EVENT_CREATED, 0); - dev = virGetNodeDevice(conn, def->name); - def = NULL; + dev = virGetNodeDevice(conn, objdef->name); + cleanup: - testDriverUnlock(driver); + virPoolObjEndAPI(&obj); virNodeDeviceDefFree(def); testObjectEventQueue(driver, event); VIR_FREE(wwnn); @@ -5658,60 +5608,44 @@ testNodeDeviceCreateXML(virConnectPtr conn, return dev; } + static int testNodeDeviceDestroy(virNodeDevicePtr dev) { - int ret = 0; + int ret = -1; testDriverPtr driver = dev->conn->privateData; - virNodeDeviceObjPtr obj = NULL; - char *parent_name = NULL, *wwnn = NULL, *wwpn = NULL; + virPoolObjPtr obj = NULL; + virNodeDeviceDefPtr def; + char *wwnn = NULL; + char *wwpn = NULL; int parent_host = -1; virObjectEventPtr event = NULL; - testDriverLock(driver); - obj = virNodeDeviceFindByName(&driver->devs, dev->name); - testDriverUnlock(driver); - - if (!obj) { - virReportError(VIR_ERR_NO_NODE_DEVICE, - _("no node device with matching name '%s'"), - dev->name); - goto out; - } - - if (virNodeDeviceGetWWNs(obj->def, &wwnn, &wwpn) == -1) - goto out; - - if (VIR_STRDUP(parent_name, obj->def->parent) < 0) - goto out; + if (!(obj = testNodeDeviceObjFindByName(driver->devs, dev->name))) + return -1; + def = virPoolObjGetDef(obj); - /* virNodeDeviceGetParentHost will cause the device object's lock to be - * taken, so we have to dup the parent's name and drop the lock - * before calling it. We don't need the reference to the object - * any more once we have the parent's name. */ - virNodeDeviceObjUnlock(obj); + if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) == -1) + goto cleanup; /* We do this just for basic validation */ - if (virNodeDeviceGetParentHost(&driver->devs, - dev->name, - parent_name, - &parent_host) == -1) { - obj = NULL; - goto out; - } + if (virNodeDeviceObjGetParentHost(driver->devs, + dev->name, + def->parent, + &parent_host) == -1) + goto cleanup; event = virNodeDeviceEventLifecycleNew(dev->name, VIR_NODE_DEVICE_EVENT_DELETED, 0); - virNodeDeviceObjLock(obj); - virNodeDeviceObjRemove(&driver->devs, &obj); + virPoolObjTableRemove(driver->devs, &obj); - out: - if (obj) - virNodeDeviceObjUnlock(obj); + ret = 0; + + cleanup: + virPoolObjEndAPI(&obj); testObjectEventQueue(driver, event); - VIR_FREE(parent_name); VIR_FREE(wwnn); VIR_FREE(wwpn); return ret; -- 2.7.4

Use the virPoolObj[Table] object management model in order to manage the NWFilter objects. While making the adjustments to use the new model, there are some code formatting adjustments that were also made with the goal to follow more recent code flow and layout. All nwfilter object management API's have their own virnwfilterobj entry points now instead of being mashed in with nwfilter_conf Signed-off-by: John Ferlan <jferlan@redhat.com> --- po/POTFILES.in | 1 + src/Makefile.am | 3 +- src/conf/nwfilter_conf.c | 381 ++------------------------------- src/conf/nwfilter_conf.h | 69 +----- src/conf/virnwfilterobj.c | 373 ++++++++++++++++++++++++++++++++ src/conf/virnwfilterobj.h | 64 ++++++ src/libvirt_private.syms | 23 +- src/nwfilter/nwfilter_driver.c | 225 +++++++------------ src/nwfilter/nwfilter_gentech_driver.c | 111 +++++----- src/nwfilter/nwfilter_gentech_driver.h | 2 +- src/nwfilter/nwfilter_tech_driver.h | 2 +- 11 files changed, 612 insertions(+), 642 deletions(-) create mode 100644 src/conf/virnwfilterobj.c create mode 100644 src/conf/virnwfilterobj.h diff --git a/po/POTFILES.in b/po/POTFILES.in index 37379b5..0435265 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -43,6 +43,7 @@ src/conf/storage_conf.c src/conf/virchrdev.c src/conf/virdomainobjlist.c src/conf/virnodedeviceobj.c +src/conf/virnwfilterobj.c src/conf/virpoolobj.c src/conf/virsecretobj.c src/cpu/cpu.c diff --git a/src/Makefile.am b/src/Makefile.am index d864e6c..73f3dd0 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -371,7 +371,8 @@ NWFILTER_PARAM_CONF_SOURCES = \ NWFILTER_CONF_SOURCES = \ $(NWFILTER_PARAM_CONF_SOURCES) \ - conf/nwfilter_conf.c conf/nwfilter_conf.h + conf/nwfilter_conf.c conf/nwfilter_conf.h \ + conf/virnwfilterobj.c conf/virnwfilterobj.h # "Generic" poolobj sources POOLOBJ_SOURCES = \ diff --git a/src/conf/nwfilter_conf.c b/src/conf/nwfilter_conf.c index 2cdcfa7..2d55667 100644 --- a/src/conf/nwfilter_conf.c +++ b/src/conf/nwfilter_conf.c @@ -30,7 +30,6 @@ #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> -#include <dirent.h> #if HAVE_NET_ETHERNET_H # include <net/ethernet.h> #endif @@ -326,8 +325,9 @@ virNWFilterEntryFree(virNWFilterEntryPtr entry) void -virNWFilterDefFree(virNWFilterDefPtr def) +virNWFilterDefFree(void *opaque) { + virNWFilterDefPtr def = opaque; size_t i; if (!def) return; @@ -344,32 +344,6 @@ virNWFilterDefFree(virNWFilterDefPtr def) } -void -virNWFilterObjFree(virNWFilterObjPtr obj) -{ - if (!obj) - return; - - virNWFilterDefFree(obj->def); - virNWFilterDefFree(obj->newDef); - - virMutexDestroy(&obj->lock); - - VIR_FREE(obj); -} - - -void -virNWFilterObjListFree(virNWFilterObjListPtr nwfilters) -{ - size_t i; - for (i = 0; i < nwfilters->count; i++) - virNWFilterObjFree(nwfilters->objs[i]); - VIR_FREE(nwfilters->objs); - nwfilters->count = 0; -} - - static int virNWFilterRuleDefAddVar(virNWFilterRuleDefPtr nwf, nwItemDesc *item, @@ -418,27 +392,6 @@ virNWFilterRuleDefAddString(virNWFilterRuleDefPtr nwf, } -void -virNWFilterObjRemove(virNWFilterObjListPtr nwfilters, - virNWFilterObjPtr nwfilter) -{ - size_t i; - - virNWFilterObjUnlock(nwfilter); - - for (i = 0; i < nwfilters->count; i++) { - virNWFilterObjLock(nwfilters->objs[i]); - if (nwfilters->objs[i] == nwfilter) { - virNWFilterObjUnlock(nwfilters->objs[i]); - virNWFilterObjFree(nwfilters->objs[i]); - - VIR_DELETE_ELEMENT(nwfilters->objs, i, nwfilters->count); - break; - } - virNWFilterObjUnlock(nwfilters->objs[i]); - } -} - union data { void *v; char *c; @@ -2779,39 +2732,6 @@ virNWFilterDefParseFile(const char *filename) } -virNWFilterObjPtr -virNWFilterObjFindByUUID(virNWFilterObjListPtr nwfilters, - const unsigned char *uuid) -{ - size_t i; - - for (i = 0; i < nwfilters->count; i++) { - virNWFilterObjLock(nwfilters->objs[i]); - if (!memcmp(nwfilters->objs[i]->def->uuid, uuid, VIR_UUID_BUFLEN)) - return nwfilters->objs[i]; - virNWFilterObjUnlock(nwfilters->objs[i]); - } - - return NULL; -} - - -virNWFilterObjPtr -virNWFilterObjFindByName(virNWFilterObjListPtr nwfilters, const char *name) -{ - size_t i; - - for (i = 0; i < nwfilters->count; i++) { - virNWFilterObjLock(nwfilters->objs[i]); - if (STREQ_NULLABLE(nwfilters->objs[i]->def->name, name)) - return nwfilters->objs[i]; - virNWFilterObjUnlock(nwfilters->objs[i]); - } - - return NULL; -} - - int virNWFilterSaveXML(const char *configDir, virNWFilterDefPtr def, const char *xml) @@ -2860,62 +2780,6 @@ int virNWFilterSaveConfig(const char *configDir, } -static int -_virNWFilterDefLoopDetect(virNWFilterObjListPtr nwfilters, - virNWFilterDefPtr def, - const char *filtername) -{ - int rc = 0; - size_t i; - virNWFilterEntryPtr entry; - virNWFilterObjPtr obj; - - if (!def) - return 0; - - for (i = 0; i < def->nentries; i++) { - entry = def->filterEntries[i]; - if (entry->include) { - - if (STREQ(filtername, entry->include->filterref)) { - rc = -1; - break; - } - - obj = virNWFilterObjFindByName(nwfilters, - entry->include->filterref); - if (obj) { - rc = _virNWFilterDefLoopDetect(nwfilters, - obj->def, filtername); - - virNWFilterObjUnlock(obj); - if (rc < 0) - break; - } - } - } - - return rc; -} - - -/* - * virNWFilterDefLoopDetect: - * @nwfilters : the nwfilters to search - * @def : the filter definition that may add a loop and is to be tested - * - * Detect a loop introduced through the filters being able to - * reference each other. - * - * Returns 0 in case no loop was detected, -1 otherwise. - */ -static int -virNWFilterDefLoopDetect(virNWFilterObjListPtr nwfilters, - virNWFilterDefPtr def) -{ - return _virNWFilterDefLoopDetect(nwfilters, def, def->name); -} - int nCallbackDriver; #define MAX_CALLBACK_DRIVER 10 static virNWFilterCallbackDriverPtr callbackDrvArray[MAX_CALLBACK_DRIVER]; @@ -2987,7 +2851,7 @@ virNWFilterInstFiltersOnAllVMs(void) return 0; } -static int +int virNWFilterTriggerVMFilterRebuild(void) { size_t i; @@ -3028,223 +2892,23 @@ virNWFilterTriggerVMFilterRebuild(void) int -virNWFilterTestUnassignDef(virNWFilterObjPtr nwfilter) -{ - int rc = 0; - - nwfilter->wantRemoved = 1; - /* trigger the update on VMs referencing the filter */ - if (virNWFilterTriggerVMFilterRebuild()) - rc = -1; - - nwfilter->wantRemoved = 0; - - return rc; -} - -static bool -virNWFilterDefEqual(const virNWFilterDef *def1, virNWFilterDefPtr def2, - bool cmpUUIDs) -{ - bool ret = false; - unsigned char rem_uuid[VIR_UUID_BUFLEN]; - char *xml1, *xml2 = NULL; - - if (!cmpUUIDs) { - /* make sure the UUIDs are equal */ - memcpy(rem_uuid, def2->uuid, sizeof(rem_uuid)); - memcpy(def2->uuid, def1->uuid, sizeof(def2->uuid)); - } - - if (!(xml1 = virNWFilterDefFormat(def1)) || - !(xml2 = virNWFilterDefFormat(def2))) - goto cleanup; - - ret = STREQ(xml1, xml2); - - cleanup: - if (!cmpUUIDs) - memcpy(def2->uuid, rem_uuid, sizeof(rem_uuid)); - - VIR_FREE(xml1); - VIR_FREE(xml2); - - return ret; -} - -virNWFilterObjPtr -virNWFilterObjAssignDef(virNWFilterObjListPtr nwfilters, - virNWFilterDefPtr def) -{ - virNWFilterObjPtr nwfilter; - - nwfilter = virNWFilterObjFindByUUID(nwfilters, def->uuid); - - if (nwfilter) { - if (STRNEQ(def->name, nwfilter->def->name)) { - virReportError(VIR_ERR_OPERATION_FAILED, - _("filter with same UUID but different name " - "('%s') already exists"), - nwfilter->def->name); - virNWFilterObjUnlock(nwfilter); - return NULL; - } - virNWFilterObjUnlock(nwfilter); - } else { - nwfilter = virNWFilterObjFindByName(nwfilters, def->name); - if (nwfilter) { - char uuidstr[VIR_UUID_STRING_BUFLEN]; - virUUIDFormat(nwfilter->def->uuid, uuidstr); - virReportError(VIR_ERR_OPERATION_FAILED, - _("filter '%s' already exists with uuid %s"), - def->name, uuidstr); - virNWFilterObjUnlock(nwfilter); - return NULL; - } - } - - if (virNWFilterDefLoopDetect(nwfilters, def) < 0) { - virReportError(VIR_ERR_OPERATION_FAILED, - "%s", _("filter would introduce a loop")); - return NULL; - } - - - if ((nwfilter = virNWFilterObjFindByName(nwfilters, def->name))) { - - if (virNWFilterDefEqual(def, nwfilter->def, false)) { - virNWFilterDefFree(nwfilter->def); - nwfilter->def = def; - return nwfilter; - } - - nwfilter->newDef = def; - /* trigger the update on VMs referencing the filter */ - if (virNWFilterTriggerVMFilterRebuild()) { - nwfilter->newDef = NULL; - virNWFilterObjUnlock(nwfilter); - return NULL; - } - - virNWFilterDefFree(nwfilter->def); - nwfilter->def = def; - nwfilter->newDef = NULL; - return nwfilter; - } - - if (VIR_ALLOC(nwfilter) < 0) - return NULL; - - if (virMutexInitRecursive(&nwfilter->lock) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("cannot initialize mutex")); - VIR_FREE(nwfilter); - return NULL; - } - virNWFilterObjLock(nwfilter); - nwfilter->active = 0; - - if (VIR_APPEND_ELEMENT_COPY(nwfilters->objs, - nwfilters->count, nwfilter) < 0) { - virNWFilterObjUnlock(nwfilter); - virNWFilterObjFree(nwfilter); - return NULL; - } - nwfilter->def = def; - - return nwfilter; -} - - -static virNWFilterObjPtr -virNWFilterLoadConfig(virNWFilterObjListPtr nwfilters, - const char *configDir, - const char *name) -{ - virNWFilterDefPtr def = NULL; - virNWFilterObjPtr nwfilter; - char *configFile = NULL; - - if (!(configFile = virFileBuildPath(configDir, name, ".xml"))) - goto error; - - if (!(def = virNWFilterDefParseFile(configFile))) - goto error; - - if (STRNEQ(name, def->name)) { - virReportError(VIR_ERR_XML_ERROR, - _("network filter config filename '%s' " - "does not match name '%s'"), - configFile, def->name); - goto error; - } - - /* We generated a UUID, make it permanent by saving the config to disk */ - if (!def->uuid_specified && - virNWFilterSaveConfig(configDir, def) < 0) - goto error; - - if (!(nwfilter = virNWFilterObjAssignDef(nwfilters, def))) - goto error; - - VIR_FREE(configFile); - return nwfilter; - - error: - VIR_FREE(configFile); - virNWFilterDefFree(def); - return NULL; -} - - -int -virNWFilterLoadAllConfigs(virNWFilterObjListPtr nwfilters, - const char *configDir) -{ - DIR *dir; - struct dirent *entry; - int ret = -1; - int rc; - - if ((rc = virDirOpenIfExists(&dir, configDir)) <= 0) - return rc; - - while ((ret = virDirRead(dir, &entry, configDir)) > 0) { - virNWFilterObjPtr nwfilter; - - if (!virFileStripSuffix(entry->d_name, ".xml")) - continue; - - nwfilter = virNWFilterLoadConfig(nwfilters, configDir, entry->d_name); - if (nwfilter) - virNWFilterObjUnlock(nwfilter); - } - - VIR_DIR_CLOSE(dir); - return ret; -} - - -int -virNWFilterObjSaveDef(virNWFilterDriverStatePtr driver, - virNWFilterDefPtr def) +virNWFilterSaveDef(const char *configDir, + virNWFilterDefPtr def) { char uuidstr[VIR_UUID_STRING_BUFLEN]; char *xml; int ret = -1; char *configFile = NULL; - if (virFileMakePath(driver->configDir) < 0) { + if (virFileMakePath(configDir) < 0) { virReportSystemError(errno, _("cannot create config directory %s"), - driver->configDir); + configDir); goto error; } - if (!(configFile = virFileBuildPath(driver->configDir, - def->name, ".xml"))) { + if (!(configFile = virFileBuildPath(configDir, def->name, ".xml"))) goto error; - } if (!(xml = virNWFilterDefFormat(def))) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -3265,26 +2929,24 @@ virNWFilterObjSaveDef(virNWFilterDriverStatePtr driver, int -virNWFilterObjDeleteDef(const char *configDir, - virNWFilterObjPtr nwfilter) +virNWFilterDeleteDef(const char *configDir, + virNWFilterDefPtr def) { int ret = -1; char *configFile = NULL; - if (!(configFile = virFileBuildPath(configDir, - nwfilter->def->name, ".xml"))) { - goto error; - } + if (!(configFile = virFileBuildPath(configDir, def->name, ".xml"))) + return -1; if (unlink(configFile) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, - _("cannot remove config for %s"), - nwfilter->def->name); - goto error; + _("cannot remove config for %s"), def->name); + goto cleanup; } ret = 0; - error: + + cleanup: VIR_FREE(configFile); return ret; } @@ -3572,17 +3234,6 @@ void virNWFilterConfLayerShutdown(void) } -void virNWFilterObjLock(virNWFilterObjPtr obj) -{ - virMutexLock(&obj->lock); -} - -void virNWFilterObjUnlock(virNWFilterObjPtr obj) -{ - virMutexUnlock(&obj->lock); -} - - bool virNWFilterRuleIsProtocolIPv4(virNWFilterRuleDefPtr rule) { if (rule->prtclType >= VIR_NWFILTER_RULE_PROTOCOL_TCP && diff --git a/src/conf/nwfilter_conf.h b/src/conf/nwfilter_conf.h index ea3cd5c..7f997a4 100644 --- a/src/conf/nwfilter_conf.h +++ b/src/conf/nwfilter_conf.h @@ -546,41 +546,6 @@ struct _virNWFilterDef { }; -typedef struct _virNWFilterObj virNWFilterObj; -typedef virNWFilterObj *virNWFilterObjPtr; - -struct _virNWFilterObj { - virMutex lock; - - int active; - int wantRemoved; - - virNWFilterDefPtr def; - virNWFilterDefPtr newDef; -}; - - -typedef struct _virNWFilterObjList virNWFilterObjList; -typedef virNWFilterObjList *virNWFilterObjListPtr; -struct _virNWFilterObjList { - size_t count; - virNWFilterObjPtr *objs; -}; - - -typedef struct _virNWFilterDriverState virNWFilterDriverState; -typedef virNWFilterDriverState *virNWFilterDriverStatePtr; -struct _virNWFilterDriverState { - virMutex lock; - bool privileged; - - virNWFilterObjList nwfilters; - - char *configDir; - bool watchingFirewallD; -}; - - typedef enum { STEP_APPLY_NEW, STEP_TEAR_NEW, @@ -597,30 +562,15 @@ struct domUpdateCBStruct { void virNWFilterRuleDefFree(virNWFilterRuleDefPtr def); -void virNWFilterDefFree(virNWFilterDefPtr def); -void virNWFilterObjListFree(virNWFilterObjListPtr nwfilters); -void virNWFilterObjRemove(virNWFilterObjListPtr nwfilters, - virNWFilterObjPtr nwfilter); - -void virNWFilterObjFree(virNWFilterObjPtr obj); +void virNWFilterDefFree(void *opaque); -virNWFilterObjPtr virNWFilterObjFindByUUID(virNWFilterObjListPtr nwfilters, - const unsigned char *uuid); +int virNWFilterTriggerVMFilterRebuild(void); -virNWFilterObjPtr virNWFilterObjFindByName(virNWFilterObjListPtr nwfilters, - const char *name); - - -int virNWFilterObjSaveDef(virNWFilterDriverStatePtr driver, - virNWFilterDefPtr def); +int virNWFilterSaveDef(const char *configDir, + virNWFilterDefPtr def); -int virNWFilterObjDeleteDef(const char *configDir, - virNWFilterObjPtr nwfilter); - -virNWFilterObjPtr virNWFilterObjAssignDef(virNWFilterObjListPtr nwfilters, - virNWFilterDefPtr def); - -int virNWFilterTestUnassignDef(virNWFilterObjPtr nwfilter); +int virNWFilterDeleteDef(const char *configDir, + virNWFilterDefPtr def); virNWFilterDefPtr virNWFilterDefParseNode(xmlDocPtr xml, xmlNodePtr root); @@ -634,18 +584,12 @@ int virNWFilterSaveXML(const char *configDir, int virNWFilterSaveConfig(const char *configDir, virNWFilterDefPtr def); -int virNWFilterLoadAllConfigs(virNWFilterObjListPtr nwfilters, - const char *configDir); - char *virNWFilterConfigFile(const char *dir, const char *name); virNWFilterDefPtr virNWFilterDefParseString(const char *xml); virNWFilterDefPtr virNWFilterDefParseFile(const char *filename); -void virNWFilterObjLock(virNWFilterObjPtr obj); -void virNWFilterObjUnlock(virNWFilterObjPtr obj); - void virNWFilterWriteLockFilterUpdates(void); void virNWFilterReadLockFilterUpdates(void); void virNWFilterUnlockFilterUpdates(void); @@ -655,7 +599,6 @@ void virNWFilterConfLayerShutdown(void); int virNWFilterInstFiltersOnAllVMs(void); - typedef int (*virNWFilterRebuild)(virDomainObjListIterator domUpdateCB, void *data); typedef void (*virNWFilterVoidCall)(void); diff --git a/src/conf/virnwfilterobj.c b/src/conf/virnwfilterobj.c new file mode 100644 index 0000000..44c171f --- /dev/null +++ b/src/conf/virnwfilterobj.c @@ -0,0 +1,373 @@ +/* + * virnwfilterobj.c: network filter object processing + * (derived from nwfilter_conf.c) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#include <config.h> +#include <dirent.h> + +#include "datatypes.h" + +#include "viralloc.h" +#include "virerror.h" +#include "virfile.h" +#include "virlog.h" +#include "virnwfilterobj.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NWFILTER + +VIR_LOG_INIT("conf.virnwfilterobj"); + +struct nwfilterLoopSearchData { + const char *filtername; +}; + +static bool +nwfilterLoopSearch(virPoolObjPtr obj, + void *opaque) +{ + virNWFilterDefPtr def = virPoolObjGetDef(obj); + struct nwfilterLoopSearchData *data = opaque; + virNWFilterEntryPtr entry; + size_t i; + + for (i = 0; i < def->nentries; i++) { + entry = def->filterEntries[i]; + if (entry->include && + STREQ(data->filtername, entry->include->filterref)) + return true; + } + + return false; +} + + +/* + * nwfilterLoopDetect: + * @nwfilters : the nwfilters to search + * @filtername: the filter name that may add a loop and is to be tested + * + * Detect a loop introduced through the filters being able to + * reference each other. + * + * Returns 0 in case no loop was detected, -1 otherwise. + */ +static int +nwfilterLoopDetect(virPoolObjTablePtr nwfilters, + const char *filtername) +{ + struct nwfilterLoopSearchData data = { .filtername = filtername }; + virPoolObjPtr obj; + + if ((obj = virPoolObjTableSearch(nwfilters, nwfilterLoopSearch, &data))) { + virObjectUnlock(obj); + return -1; + } + + return 0; +} + + +static bool +nwfilterDefEqual(const virNWFilterDef *def1, + virNWFilterDefPtr def2, + bool cmpUUIDs) +{ + bool ret = false; + unsigned char rem_uuid[VIR_UUID_BUFLEN]; + char *xml1, *xml2 = NULL; + + if (!cmpUUIDs) { + /* make sure the UUIDs are equal */ + memcpy(rem_uuid, def2->uuid, sizeof(rem_uuid)); + memcpy(def2->uuid, def1->uuid, sizeof(def2->uuid)); + } + + if (!(xml1 = virNWFilterDefFormat(def1)) || + !(xml2 = virNWFilterDefFormat(def2))) + goto cleanup; + + ret = STREQ(xml1, xml2); + + cleanup: + if (!cmpUUIDs) + memcpy(def2->uuid, rem_uuid, sizeof(rem_uuid)); + + VIR_FREE(xml1); + VIR_FREE(xml2); + + return ret; +} + + +static int +nwfilterAssignDef(virPoolObjPtr obj, + void *newDef, + void *oldDef ATTRIBUTE_UNUSED, + unsigned int assignFlags ATTRIBUTE_UNUSED) +{ + virNWFilterDefPtr newdef = newDef; + + + if (nwfilterDefEqual(newdef, virPoolObjGetDef(obj), false)) { + virPoolObjSetDef(obj, newdef); + } else { + virPoolObjSetNewDef(obj, newdef); + + /* trigger the update on VMs referencing the filter */ + if (virNWFilterTriggerVMFilterRebuild()) { + virPoolObjSetNewDef(obj, NULL); + return -1; + } + + virPoolObjSetDef(obj, newdef); + virPoolObjSetNewDef(obj, NULL); + } + return 0; +} + + +virPoolObjPtr +virNWFilterObjAdd(virPoolObjTablePtr nwfilters, + virNWFilterDefPtr def) +{ + virPoolObjPtr obj; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + /* Check if this filter def's name is referenced already by + * some other filter's include path */ + if (nwfilterLoopDetect(nwfilters, def->name) < 0) { + virReportError(VIR_ERR_OPERATION_FAILED, + _("filter '%s' would introduce a loop"), def->name); + return NULL; + } + + virUUIDFormat(def->uuid, uuidstr); + if (!(obj = virPoolObjTableAdd(nwfilters, uuidstr, def->name, + def, NULL, NULL, virNWFilterDefFree, + nwfilterAssignDef, 0))) + return NULL; + + return obj; +} + + +int +virNWFilterObjTestUnassignDef(virPoolObjPtr obj) +{ + int rc = 0; + + virPoolObjSetBeingRemoved(obj, true); + /* trigger the update on VMs referencing the filter */ + if (virNWFilterTriggerVMFilterRebuild()) + rc = -1; + virPoolObjSetBeingRemoved(obj, false); + + return rc; +} + + +struct nwfilterCountData { + int count; +}; + +static int +nwfilterCount(virPoolObjPtr obj ATTRIBUTE_UNUSED, + void *opaque) +{ + struct nwfilterCountData *data = opaque; + + data->count++; + return 0; +} + + +int +virNWFilterObjNumOfNWFilters(virPoolObjTablePtr nwfilters, + virConnectPtr conn, + virPoolObjACLFilter aclfilter) +{ + struct nwfilterCountData data = { .count = 0 }; + + if (virPoolObjTableList(nwfilters, conn, aclfilter, + nwfilterCount, &data) < 0) + return 0; + + return data.count; +} + + +struct nwfilterNameData { + int nnames; + char **const names; + int maxnames; +}; + +static int nwfilterGetNames(virPoolObjPtr obj, + void *opaque) +{ + virNWFilterDefPtr def = virPoolObjGetDef(obj); + struct nwfilterNameData *data = opaque; + + if (data->nnames < data->maxnames) { + if (VIR_STRDUP(data->names[data->nnames++], def->name) < 0) + return -1; + } + + return 0; +} + + +int +virNWFilterObjGetFilters(virPoolObjTablePtr nwfilters, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + char **names, + int maxnames) +{ + struct nwfilterNameData data = { .nnames = 0, + .names = names, + .maxnames = maxnames }; + + if (virPoolObjTableList(nwfilters, conn, aclfilter, + nwfilterGetNames, &data) < 0) + goto failure; + + return data.nnames; + + failure: + while (data.nnames >= 0) + VIR_FREE(data.names[--data.nnames]); + + return -1; +} + + +int +virNWFilterObjExportList(virConnectPtr conn, + virPoolObjTablePtr nwfilters, + virNWFilterPtr **filters, + virPoolObjACLFilter aclfilter, + unsigned int flags) +{ + virPoolObjPtr *objs = NULL; + size_t nobjs = 0; + virNWFilterPtr *filts = NULL; + int ret = -1; + size_t i; + + if (virPoolObjTableCollect(nwfilters, conn, &objs, &nobjs, aclfilter, + NULL, flags) < 0) + return -1; + + if (filters) { + if (VIR_ALLOC_N(filts, nobjs + 1) < 0) + goto cleanup; + + for (i = 0; i < nobjs; i++) { + virPoolObjPtr obj = objs[i]; + virNWFilterDefPtr def; + + virObjectLock(obj); + def = virPoolObjGetDef(obj); + filts[i] = virGetNWFilter(conn, def->name, def->uuid); + virObjectUnlock(obj); + + if (!filts[i]) + goto cleanup; + } + + *filters = filts; + filts = NULL; + } + + ret = nobjs; + + cleanup: + virObjectListFree(filts); + virObjectListFreeCount(objs, nobjs); + return ret; +} + + +static virPoolObjPtr +virNWFilterLoadConfig(virPoolObjTablePtr nwfilters, + const char *configDir, + const char *name) +{ + virNWFilterDefPtr def = NULL; + virPoolObjPtr obj; + char *configFile = NULL; + + if (!(configFile = virFileBuildPath(configDir, name, ".xml"))) + goto error; + + if (!(def = virNWFilterDefParseFile(configFile))) + goto error; + + if (STRNEQ(name, def->name)) { + virReportError(VIR_ERR_XML_ERROR, + _("network filter config filename '%s' " + "does not match name '%s'"), + configFile, def->name); + goto error; + } + + /* We generated a UUID, make it permanent by saving the config to disk */ + if (!def->uuid_specified && + virNWFilterSaveConfig(configDir, def) < 0) + goto error; + + if (!(obj = virNWFilterObjAdd(nwfilters, def))) + goto error; + + VIR_FREE(configFile); + return obj; + + error: + VIR_FREE(configFile); + virNWFilterDefFree(def); + return NULL; +} + + +int +virNWFilterObjLoadAllConfigs(virPoolObjTablePtr nwfilters, + const char *configDir) +{ + DIR *dir; + struct dirent *entry; + int ret = -1; + int rc; + + if ((rc = virDirOpenIfExists(&dir, configDir)) <= 0) + return rc; + + while ((ret = virDirRead(dir, &entry, configDir)) > 0) { + virPoolObjPtr obj; + + if (!virFileStripSuffix(entry->d_name, ".xml")) + continue; + + if ((obj = virNWFilterLoadConfig(nwfilters, configDir, entry->d_name))) + virPoolObjEndAPI(&obj); + } + + VIR_DIR_CLOSE(dir); + return ret; +} diff --git a/src/conf/virnwfilterobj.h b/src/conf/virnwfilterobj.h new file mode 100644 index 0000000..29eaf10 --- /dev/null +++ b/src/conf/virnwfilterobj.h @@ -0,0 +1,64 @@ +/* + * virnwfilterobj.h: network filter object processing + * (derived from nwfilter_conf.h) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ +#ifndef VIRNWFILTEROBJ_H +# define VIRNWFILTEROBJ_H + +# include "internal.h" + +# include "nwfilter_conf.h" +# include "virpoolobj.h" + +typedef struct _virNWFilterDriverState virNWFilterDriverState; +typedef virNWFilterDriverState *virNWFilterDriverStatePtr; +struct _virNWFilterDriverState { + virMutex lock; + bool privileged; + + virPoolObjTablePtr nwfilters; + + char *configDir; + bool watchingFirewallD; +}; + + +virPoolObjPtr virNWFilterObjAdd(virPoolObjTablePtr nwfilters, + virNWFilterDefPtr def); + +int virNWFilterObjTestUnassignDef(virPoolObjPtr obj); + +int virNWFilterObjNumOfNWFilters(virPoolObjTablePtr nwfilters, + virConnectPtr conn, + virPoolObjACLFilter aclfilter); + +int virNWFilterObjGetFilters(virPoolObjTablePtr nwfilters, + virConnectPtr conn, + virPoolObjACLFilter aclfilter, + char **names, + int maxnames); + +int virNWFilterObjExportList(virConnectPtr conn, + virPoolObjTablePtr nwfilters, + virNWFilterPtr **filters, + virPoolObjACLFilter aclfilter, + unsigned int flags); + +int virNWFilterObjLoadAllConfigs(virPoolObjTablePtr nwfilters, + const char *configDir); + +#endif /* VIRNWFILTEROBJ_H */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 5f95814..2e9f0c2 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -742,18 +742,9 @@ virNWFilterDefFormat; virNWFilterDefFree; virNWFilterDefParseFile; virNWFilterDefParseString; +virNWFilterDeleteDef; virNWFilterInstFiltersOnAllVMs; virNWFilterJumpTargetTypeToString; -virNWFilterLoadAllConfigs; -virNWFilterObjAssignDef; -virNWFilterObjDeleteDef; -virNWFilterObjFindByName; -virNWFilterObjFindByUUID; -virNWFilterObjListFree; -virNWFilterObjLock; -virNWFilterObjRemove; -virNWFilterObjSaveDef; -virNWFilterObjUnlock; virNWFilterPrintStateMatchFlags; virNWFilterPrintTCPFlags; virNWFilterReadLockFilterUpdates; @@ -764,7 +755,8 @@ virNWFilterRuleIsProtocolEthernet; virNWFilterRuleIsProtocolIPv4; virNWFilterRuleIsProtocolIPv6; virNWFilterRuleProtocolTypeToString; -virNWFilterTestUnassignDef; +virNWFilterSaveDef; +virNWFilterTriggerVMFilterRebuild; virNWFilterUnlockFilterUpdates; virNWFilterUnRegisterCallbackDriver; virNWFilterWriteLockFilterUpdates; @@ -959,6 +951,15 @@ virNodeDeviceObjGetParentHostByWWNs; virNodeDeviceObjNumOfDevices; +# conf/virnwfilterobj.h +virNWFilterObjAdd; +virNWFilterObjExportList; +virNWFilterObjGetFilters; +virNWFilterObjLoadAllConfigs; +virNWFilterObjNumOfNWFilters; +virNWFilterObjTestUnassignDef; + + # conf/virpoolobj.h virPoolObjEndAPI; virPoolObjGetDef; diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c index 186830c..4d69072 100644 --- a/src/nwfilter/nwfilter_driver.c +++ b/src/nwfilter/nwfilter_driver.c @@ -37,7 +37,6 @@ #include "viralloc.h" #include "domain_conf.h" #include "domain_nwfilter.h" -#include "nwfilter_conf.h" #include "nwfilter_driver.h" #include "nwfilter_gentech_driver.h" #include "configmake.h" @@ -238,8 +237,12 @@ nwfilterStateInitialize(bool privileged, VIR_FREE(base); - if (virNWFilterLoadAllConfigs(&driver->nwfilters, - driver->configDir) < 0) + if (!(driver->nwfilters = + virPoolObjTableNew(VIR_POOLOBJTABLE_NWFILTER, + VIR_POOLOBJTABLE_NWFILTER_HASHSTART, false))) + goto error; + + if (virNWFilterObjLoadAllConfigs(driver->nwfilters, driver->configDir) < 0) goto error; nwfilterDriverUnlock(); @@ -291,8 +294,7 @@ nwfilterStateReload(void) virNWFilterWriteLockFilterUpdates(); virNWFilterCallbackDriversLock(); - virNWFilterLoadAllConfigs(&driver->nwfilters, - driver->configDir); + virNWFilterObjLoadAllConfigs(driver->nwfilters, driver->configDir); virNWFilterCallbackDriversUnlock(); virNWFilterUnlockFilterUpdates(); @@ -343,7 +345,7 @@ nwfilterStateCleanup(void) nwfilterDriverRemoveDBusMatches(); /* free inactive nwfilters */ - virNWFilterObjListFree(&driver->nwfilters); + virObjectUnref(driver->nwfilters); VIR_FREE(driver->configDir); nwfilterDriverUnlock(); @@ -356,31 +358,45 @@ nwfilterStateCleanup(void) } +static virPoolObjPtr +nwfilterObjFromNWFilter(virNWFilterPtr nwfilter) +{ + virPoolObjPtr obj; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + if (!(obj = virPoolObjTableFindByUUIDRef(driver->nwfilters, + nwfilter->uuid))) { + virReportError(VIR_ERR_NO_NWFILTER, + _("no nwfilter with matching uuid '%s'"), + uuidstr); + return NULL; + } + return obj; +} + + static virNWFilterPtr nwfilterLookupByUUID(virConnectPtr conn, const unsigned char *uuid) { - virNWFilterObjPtr nwfilter; + virPoolObjPtr obj; + virNWFilterDefPtr def; virNWFilterPtr ret = NULL; - nwfilterDriverLock(); - nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, uuid); - nwfilterDriverUnlock(); - - if (!nwfilter) { + if (!(obj = virPoolObjTableFindByUUIDRef(driver->nwfilters, uuid))) { virReportError(VIR_ERR_NO_NWFILTER, "%s", _("no nwfilter with matching uuid")); goto cleanup; } - if (virNWFilterLookupByUUIDEnsureACL(conn, nwfilter->def) < 0) + def = virPoolObjGetDef(obj); + if (virNWFilterLookupByUUIDEnsureACL(conn, def) < 0) goto cleanup; - ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid); + ret = virGetNWFilter(conn, def->name, def->uuid); cleanup: - if (nwfilter) - virNWFilterObjUnlock(nwfilter); + virPoolObjEndAPI(&obj); return ret; } @@ -389,27 +405,24 @@ static virNWFilterPtr nwfilterLookupByName(virConnectPtr conn, const char *name) { - virNWFilterObjPtr nwfilter; + virPoolObjPtr obj; + virNWFilterDefPtr def; virNWFilterPtr ret = NULL; - nwfilterDriverLock(); - nwfilter = virNWFilterObjFindByName(&driver->nwfilters, name); - nwfilterDriverUnlock(); - - if (!nwfilter) { + if (!(obj = virPoolObjTableFindByName(driver->nwfilters, name))) { virReportError(VIR_ERR_NO_NWFILTER, _("no nwfilter with matching name '%s'"), name); goto cleanup; } - if (virNWFilterLookupByNameEnsureACL(conn, nwfilter->def) < 0) + def = virPoolObjGetDef(obj); + if (virNWFilterLookupByNameEnsureACL(conn, def) < 0) goto cleanup; - ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid); + ret = virGetNWFilter(conn, def->name, def->uuid); cleanup: - if (nwfilter) - virNWFilterObjUnlock(nwfilter); + virPoolObjEndAPI(&obj); return ret; } @@ -417,58 +430,27 @@ nwfilterLookupByName(virConnectPtr conn, static int nwfilterConnectNumOfNWFilters(virConnectPtr conn) { - size_t i; - int n; - if (virConnectNumOfNWFiltersEnsureACL(conn) < 0) return -1; - n = 0; - for (i = 0; i < driver->nwfilters.count; i++) { - virNWFilterObjPtr obj = driver->nwfilters.objs[i]; - virNWFilterObjLock(obj); - if (virConnectNumOfNWFiltersCheckACL(conn, obj->def)) - n++; - virNWFilterObjUnlock(obj); - } - - return n; + return virNWFilterObjNumOfNWFilters(driver->nwfilters, conn, + virConnectNumOfNWFiltersCheckACL); } static int nwfilterConnectListNWFilters(virConnectPtr conn, - char **const names, - int nnames) + char **names, + int maxnames) { - int got = 0; - size_t i; + memset(names, 0, maxnames * sizeof(*names)); if (virConnectListNWFiltersEnsureACL(conn) < 0) return -1; - nwfilterDriverLock(); - for (i = 0; i < driver->nwfilters.count && got < nnames; i++) { - virNWFilterObjPtr obj = driver->nwfilters.objs[i]; - virNWFilterObjLock(obj); - if (virConnectListNWFiltersCheckACL(conn, obj->def)) { - if (VIR_STRDUP(names[got], obj->def->name) < 0) { - virNWFilterObjUnlock(obj); - goto cleanup; - } - got++; - } - virNWFilterObjUnlock(obj); - } - nwfilterDriverUnlock(); - return got; - - cleanup: - nwfilterDriverUnlock(); - for (i = 0; i < got; i++) - VIR_FREE(names[i]); - memset(names, 0, nnames * sizeof(*names)); - return -1; + return virNWFilterObjGetFilters(driver->nwfilters, conn, + virConnectListNWFiltersCheckACL, + names, maxnames); } @@ -477,63 +459,23 @@ nwfilterConnectListAllNWFilters(virConnectPtr conn, virNWFilterPtr **filters, unsigned int flags) { - virNWFilterPtr *tmp_filters = NULL; - int nfilters = 0; - virNWFilterPtr filter = NULL; - virNWFilterObjPtr obj = NULL; - size_t i; - int ret = -1; - virCheckFlags(0, -1); if (virConnectListAllNWFiltersEnsureACL(conn) < 0) return -1; - nwfilterDriverLock(); - - if (!filters) { - ret = driver->nwfilters.count; - goto cleanup; - } - - if (VIR_ALLOC_N(tmp_filters, driver->nwfilters.count + 1) < 0) - goto cleanup; - - for (i = 0; i < driver->nwfilters.count; i++) { - obj = driver->nwfilters.objs[i]; - virNWFilterObjLock(obj); - if (virConnectListAllNWFiltersCheckACL(conn, obj->def)) { - if (!(filter = virGetNWFilter(conn, obj->def->name, - obj->def->uuid))) { - virNWFilterObjUnlock(obj); - goto cleanup; - } - tmp_filters[nfilters++] = filter; - } - virNWFilterObjUnlock(obj); - } - - *filters = tmp_filters; - tmp_filters = NULL; - ret = nfilters; - - cleanup: - nwfilterDriverUnlock(); - if (tmp_filters) { - for (i = 0; i < nfilters; i ++) - virObjectUnref(tmp_filters[i]); - } - VIR_FREE(tmp_filters); - - return ret; + return virNWFilterObjExportList(conn, driver->nwfilters, filters, + virConnectListAllNWFiltersCheckACL, flags); } + static virNWFilterPtr nwfilterDefineXML(virConnectPtr conn, const char *xml) { virNWFilterDefPtr def; - virNWFilterObjPtr nwfilter = NULL; + virNWFilterDefPtr objdef; + virPoolObjPtr obj = NULL; virNWFilterPtr ret = NULL; if (!driver->privileged) { @@ -552,22 +494,20 @@ nwfilterDefineXML(virConnectPtr conn, if (virNWFilterDefineXMLEnsureACL(conn, def) < 0) goto cleanup; - if (!(nwfilter = virNWFilterObjAssignDef(&driver->nwfilters, def))) + if (!(obj = virNWFilterObjAdd(driver->nwfilters, def))) goto cleanup; + VIR_STEAL_PTR(objdef, def); - if (virNWFilterObjSaveDef(driver, def) < 0) { - virNWFilterObjRemove(&driver->nwfilters, nwfilter); - def = NULL; + if (virNWFilterSaveDef(driver->configDir, objdef) < 0) { + virPoolObjTableRemove(driver->nwfilters, &obj); goto cleanup; } - def = NULL; - ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid); + ret = virGetNWFilter(conn, objdef->name, objdef->uuid); cleanup: virNWFilterDefFree(def); - if (nwfilter) - virNWFilterObjUnlock(nwfilter); + virPoolObjEndAPI(&obj); virNWFilterCallbackDriversUnlock(); virNWFilterUnlockFilterUpdates(); @@ -577,42 +517,37 @@ nwfilterDefineXML(virConnectPtr conn, static int -nwfilterUndefine(virNWFilterPtr obj) +nwfilterUndefine(virNWFilterPtr nwfilter) { - virNWFilterObjPtr nwfilter; + virPoolObjPtr obj; + virNWFilterDefPtr def; int ret = -1; nwfilterDriverLock(); virNWFilterWriteLockFilterUpdates(); virNWFilterCallbackDriversLock(); - nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, obj->uuid); - if (!nwfilter) { - virReportError(VIR_ERR_NO_NWFILTER, - "%s", _("no nwfilter with matching uuid")); + if (!(obj = nwfilterObjFromNWFilter(nwfilter))) goto cleanup; - } + def = virPoolObjGetDef(obj); - if (virNWFilterUndefineEnsureACL(obj->conn, nwfilter->def) < 0) + if (virNWFilterUndefineEnsureACL(nwfilter->conn, def) < 0) goto cleanup; - if (virNWFilterTestUnassignDef(nwfilter) < 0) { - virReportError(VIR_ERR_OPERATION_INVALID, - "%s", + if (virNWFilterObjTestUnassignDef(obj) < 0) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("nwfilter is in use")); goto cleanup; } - if (virNWFilterObjDeleteDef(driver->configDir, nwfilter) < 0) + if (virNWFilterDeleteDef(driver->configDir, def) < 0) goto cleanup; - virNWFilterObjRemove(&driver->nwfilters, nwfilter); - nwfilter = NULL; + virPoolObjTableRemove(driver->nwfilters, &obj); ret = 0; cleanup: - if (nwfilter) - virNWFilterObjUnlock(nwfilter); + virPoolObjEndAPI(&obj); virNWFilterCallbackDriversUnlock(); virNWFilterUnlockFilterUpdates(); @@ -622,32 +557,26 @@ nwfilterUndefine(virNWFilterPtr obj) static char * -nwfilterGetXMLDesc(virNWFilterPtr obj, +nwfilterGetXMLDesc(virNWFilterPtr nwfilter, unsigned int flags) { - virNWFilterObjPtr nwfilter; + virPoolObjPtr obj; + virNWFilterDefPtr def; char *ret = NULL; virCheckFlags(0, NULL); - nwfilterDriverLock(); - nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, obj->uuid); - nwfilterDriverUnlock(); - - if (!nwfilter) { - virReportError(VIR_ERR_NO_NWFILTER, - "%s", _("no nwfilter with matching uuid")); + if (!(obj = nwfilterObjFromNWFilter(nwfilter))) goto cleanup; - } - if (virNWFilterGetXMLDescEnsureACL(obj->conn, nwfilter->def) < 0) + def = virPoolObjGetDef(obj); + if (virNWFilterGetXMLDescEnsureACL(nwfilter->conn, def) < 0) goto cleanup; - ret = virNWFilterDefFormat(nwfilter->def); + ret = virNWFilterDefFormat(def); cleanup: - if (nwfilter) - virNWFilterObjUnlock(nwfilter); + virPoolObjEndAPI(&obj); return ret; } diff --git a/src/nwfilter/nwfilter_gentech_driver.c b/src/nwfilter/nwfilter_gentech_driver.c index 761a01b..3c2697d 100644 --- a/src/nwfilter/nwfilter_gentech_driver.c +++ b/src/nwfilter/nwfilter_gentech_driver.c @@ -302,7 +302,7 @@ virNWFilterCreateVarsFrom(virNWFilterHashTablePtr vars1, typedef struct _virNWFilterInst virNWFilterInst; typedef virNWFilterInst *virNWFilterInstPtr; struct _virNWFilterInst { - virNWFilterObjPtr *filters; + virPoolObjPtr *filters; size_t nfilters; virNWFilterRuleInstPtr *rules; size_t nrules; @@ -315,7 +315,7 @@ virNWFilterInstReset(virNWFilterInstPtr inst) size_t i; for (i = 0; i < inst->nfilters; i++) - virNWFilterObjUnlock(inst->filters[i]); + virObjectUnref(inst->filters[i]); VIR_FREE(inst->filters); inst->nfilters = 0; @@ -368,6 +368,21 @@ virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def, } +static virPoolObjPtr +nwfilterObjFromFiltername(virNWFilterDriverStatePtr driver, + const char *name) +{ + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByName(driver->nwfilters, name))) { + virReportError(VIR_ERR_NO_NWFILTER, + _("Could not find filter '%s'"), name); + } + + return obj; +} + + static int virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver, virNWFilterIncludeDefPtr inc, @@ -376,21 +391,20 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver, bool *foundNewFilter, virNWFilterInstPtr inst) { - virNWFilterObjPtr obj; + virPoolObjPtr obj; + virNWFilterDefPtr def; + virNWFilterDefPtr newdef; virNWFilterHashTablePtr tmpvars = NULL; virNWFilterDefPtr childdef; int ret = -1; VIR_DEBUG("Instantiating filter %s", inc->filterref); - obj = virNWFilterObjFindByName(&driver->nwfilters, - inc->filterref); - if (!obj) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("referenced filter '%s' is missing"), - inc->filterref); - goto cleanup; - } - if (obj->wantRemoved) { + if (!(obj = nwfilterObjFromFiltername(driver, inc->filterref))) + return -1; + def = virPoolObjGetDef(obj); + newdef = virPoolObjGetNewDef(obj); + + if (virPoolObjIsBeingRemoved(obj)) { virReportError(VIR_ERR_NO_NWFILTER, _("Filter '%s' is in use."), inc->filterref); @@ -398,16 +412,15 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver, } /* create a temporary hashmap for depth-first tree traversal */ - if (!(tmpvars = virNWFilterCreateVarsFrom(inc->params, - vars))) + if (!(tmpvars = virNWFilterCreateVarsFrom(inc->params, vars))) goto cleanup; - childdef = obj->def; + childdef = def; switch (useNewFilter) { case INSTANTIATE_FOLLOW_NEWFILTER: - if (obj->newDef) { - childdef = obj->newDef; + if (newdef) { + childdef = newdef; *foundNewFilter = true; } break; @@ -419,7 +432,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver, inst->nfilters, obj) < 0) goto cleanup; - obj = NULL; + virObjectRef(obj); if (virNWFilterDefToInst(driver, childdef, @@ -434,8 +447,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver, if (ret < 0) virNWFilterInstReset(inst); virNWFilterHashTableFree(tmpvars); - if (obj) - virNWFilterObjUnlock(obj); + virPoolObjEndAPI(&obj); return ret; } @@ -501,7 +513,7 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter, int useNewFilter, virNWFilterDriverStatePtr driver) { - virNWFilterObjPtr obj; + virPoolObjPtr obj = NULL; int rc = 0; size_t i, j; virNWFilterDefPtr next_filter; @@ -542,34 +554,34 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter, break; } else if (inc) { VIR_DEBUG("Following filter %s", inc->filterref); - obj = virNWFilterObjFindByName(&driver->nwfilters, inc->filterref); - if (obj) { + if (!(obj = nwfilterObjFromFiltername(driver, inc->filterref))) { + rc = -1; + break; + } else { + virNWFilterDefPtr def = virPoolObjGetDef(obj); + virNWFilterDefPtr newdef = virPoolObjGetNewDef(obj); + virNWFilterHashTablePtr tmpvars; - if (obj->wantRemoved) { + if (virPoolObjIsBeingRemoved(obj)) { virReportError(VIR_ERR_NO_NWFILTER, _("Filter '%s' is in use."), inc->filterref); rc = -1; - virNWFilterObjUnlock(obj); break; } /* create a temporary hashmap for depth-first tree traversal */ - virNWFilterHashTablePtr tmpvars = - virNWFilterCreateVarsFrom(inc->params, - vars); - if (!tmpvars) { + if (!(tmpvars = virNWFilterCreateVarsFrom(inc->params, vars))) { rc = -1; - virNWFilterObjUnlock(obj); break; } - next_filter = obj->def; + next_filter = def; switch (useNewFilter) { case INSTANTIATE_FOLLOW_NEWFILTER: - if (obj->newDef) - next_filter = obj->newDef; + if (newdef) + next_filter = newdef; break; case INSTANTIATE_ALWAYS: break; @@ -583,18 +595,14 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter, virNWFilterHashTableFree(tmpvars); - virNWFilterObjUnlock(obj); + virPoolObjEndAPI(&obj); if (rc < 0) break; - } else { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("referenced filter '%s' is missing"), - inc->filterref); - rc = -1; - break; } } } + + virPoolObjEndAPI(&obj); return rc; } @@ -787,7 +795,9 @@ __virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver, int rc; const char *drvname = EBIPTABLES_DRIVER_ID; virNWFilterTechDriverPtr techdriver; - virNWFilterObjPtr obj; + virPoolObjPtr obj; + virNWFilterDefPtr def; + virNWFilterDefPtr newdef; virNWFilterHashTablePtr vars, vars1; virNWFilterDefPtr filter; char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0}; @@ -807,15 +817,12 @@ __virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver, VIR_DEBUG("filter name: %s", filtername); - obj = virNWFilterObjFindByName(&driver->nwfilters, filtername); - if (!obj) { - virReportError(VIR_ERR_NO_NWFILTER, - _("Could not find filter '%s'"), - filtername); + if (!(obj = nwfilterObjFromFiltername(driver, filtername))) return -1; - } + def = virPoolObjGetDef(obj); + newdef = virPoolObjGetNewDef(obj); - if (obj->wantRemoved) { + if (virPoolObjIsBeingRemoved(obj)) { virReportError(VIR_ERR_NO_NWFILTER, _("Filter '%s' is in use."), filtername); @@ -847,12 +854,12 @@ __virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver, goto err_exit_vars1; } - filter = obj->def; + filter = def; switch (useNewFilter) { case INSTANTIATE_FOLLOW_NEWFILTER: - if (obj->newDef) { - filter = obj->newDef; + if (newdef) { + filter = newdef; *foundNewFilter = true; } break; @@ -880,7 +887,7 @@ __virNWFilterInstantiateFilter(virNWFilterDriverStatePtr driver, virNWFilterHashTableFree(vars1); err_exit: - virNWFilterObjUnlock(obj); + virPoolObjEndAPI(&obj); VIR_FREE(str_ipaddr); VIR_FREE(str_macaddr); diff --git a/src/nwfilter/nwfilter_gentech_driver.h b/src/nwfilter/nwfilter_gentech_driver.h index 8349ab4..7192487 100644 --- a/src/nwfilter/nwfilter_gentech_driver.h +++ b/src/nwfilter/nwfilter_gentech_driver.h @@ -24,7 +24,7 @@ #ifndef __NWFILTER_GENTECH_DRIVER_H # define __NWFILTER_GENTECH_DRIVER_H -# include "nwfilter_conf.h" +# include "virnwfilterobj.h" # include "nwfilter_tech_driver.h" virNWFilterTechDriverPtr virNWFilterTechDriverForName(const char *name); diff --git a/src/nwfilter/nwfilter_tech_driver.h b/src/nwfilter/nwfilter_tech_driver.h index 7b6f56f..bc30496 100644 --- a/src/nwfilter/nwfilter_tech_driver.h +++ b/src/nwfilter/nwfilter_tech_driver.h @@ -26,7 +26,7 @@ #ifndef __NWFILTER_TECH_DRIVER_H__ # define __NWFILTER_TECH_DRIVER_H__ -# include "nwfilter_conf.h" +# include "virnwfilterobj.h" typedef struct _virNWFilterTechDriver virNWFilterTechDriver; typedef virNWFilterTechDriver *virNWFilterTechDriverPtr; -- 2.7.4

Use the virPoolObj[Table] object management model in order to manage the storage volume objects. While making the adjustments to use the new model, there are some code formatting adjustments that were also made with the goal to follow more recent code flow and layout. Signed-off-by: John Ferlan <jferlan@redhat.com> --- src/conf/storage_conf.c | 205 +++++++++++-- src/conf/storage_conf.h | 45 ++- src/libvirt_private.syms | 10 +- src/storage/storage_backend_disk.c | 143 ++++++--- src/storage/storage_backend_gluster.c | 17 +- src/storage/storage_backend_logical.c | 58 ++-- src/storage/storage_backend_mpath.c | 10 +- src/storage/storage_backend_rbd.c | 10 +- src/storage/storage_backend_sheepdog.c | 7 +- src/storage/storage_backend_zfs.c | 51 ++-- src/storage/storage_driver.c | 539 ++++++++++++++++++--------------- src/storage/storage_util.c | 10 +- src/test/test_driver.c | 371 ++++++++++++----------- 13 files changed, 875 insertions(+), 601 deletions(-) diff --git a/src/conf/storage_conf.c b/src/conf/storage_conf.c index c9b93aa..8012b6f 100644 --- a/src/conf/storage_conf.c +++ b/src/conf/storage_conf.c @@ -321,8 +321,9 @@ virStorageVolOptionsForPoolType(int type) void -virStorageVolDefFree(virStorageVolDefPtr def) +virStorageVolDefFree(void *opaque) { + virStorageVolDefPtr def = opaque; size_t i; if (!def) @@ -415,7 +416,7 @@ virStoragePoolObjFree(virStoragePoolObjPtr obj) if (!obj) return; - virStoragePoolObjClearVols(obj); + virObjectUnref(obj->volumes); virStoragePoolDefFree(obj->def); virStoragePoolDefFree(obj->newDef); @@ -1776,56 +1777,74 @@ virStoragePoolSourceFindDuplicateDevices(virStoragePoolObjPtr pool, return NULL; } + void virStoragePoolObjClearVols(virStoragePoolObjPtr pool) { - size_t i; - for (i = 0; i < pool->volumes.count; i++) - virStorageVolDefFree(pool->volumes.objs[i]); + virPoolObjTableClearAll(pool->volumes); +} + + +struct volSearchData { + const char *compare; +}; - VIR_FREE(pool->volumes.objs); - pool->volumes.count = 0; +static bool +volFindByKey(virPoolObjPtr obj, + void *opaque) +{ + virStorageVolDefPtr def = virPoolObjGetDef(obj); + struct volSearchData *data = opaque; + + if (STREQ(def->key, data->compare)) + return true; + + return false; } -virStorageVolDefPtr -virStorageVolDefFindByKey(virStoragePoolObjPtr pool, + +virPoolObjPtr +virStorageVolObjFindByKey(virStoragePoolObjPtr pool, const char *key) { - size_t i; + struct volSearchData data = { .compare = key }; - for (i = 0; i < pool->volumes.count; i++) - if (STREQ(pool->volumes.objs[i]->key, key)) - return pool->volumes.objs[i]; - - return NULL; + return virPoolObjTableSearchRef(pool->volumes, volFindByKey, &data); } -virStorageVolDefPtr -virStorageVolDefFindByPath(virStoragePoolObjPtr pool, - const char *path) + +static bool +volFindByPath(virPoolObjPtr obj, + void *opaque) { - size_t i; + virStorageVolDefPtr def = virPoolObjGetDef(obj); + struct volSearchData *data = opaque; - for (i = 0; i < pool->volumes.count; i++) - if (STREQ(pool->volumes.objs[i]->target.path, path)) - return pool->volumes.objs[i]; + if (STREQ(def->target.path, data->compare)) + return true; - return NULL; + return false; } -virStorageVolDefPtr -virStorageVolDefFindByName(virStoragePoolObjPtr pool, - const char *name) + +virPoolObjPtr +virStorageVolObjFindByPath(virStoragePoolObjPtr pool, + const char *path) { - size_t i; + struct volSearchData data = { .compare = path }; - for (i = 0; i < pool->volumes.count; i++) - if (STREQ(pool->volumes.objs[i]->name, name)) - return pool->volumes.objs[i]; + return virPoolObjTableSearchRef(pool->volumes, volFindByPath, &data); +} - return NULL; + +virPoolObjPtr +virStorageVolObjFindByName(virStoragePoolObjPtr pool, + const char *name) +{ + return virPoolObjTableFindByName(pool->volumes, name); } + virStoragePoolObjPtr virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools, virStoragePoolDefPtr def) @@ -1855,6 +1874,14 @@ virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools, virStoragePoolObjLock(pool); pool->active = 0; + if (!(pool->volumes = + virPoolObjTableNew(VIR_POOLOBJTABLE_VOLUME, + VIR_POOLOBJTABLE_VOLUME_HASHSTART, true))) { + virStoragePoolObjUnlock(pool); + virStoragePoolObjFree(pool); + return NULL; + } + if (VIR_APPEND_ELEMENT_COPY(pools->objs, pools->count, pool) < 0) { virStoragePoolObjUnlock(pool); virStoragePoolObjFree(pool); @@ -1865,6 +1892,122 @@ virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools, return pool; } + +virPoolObjPtr +virStoragePoolObjAddVolume(virStoragePoolObjPtr pool, + virStorageVolDefPtr voldef) +{ + return virPoolObjTableAdd(pool->volumes, NULL, voldef->name, voldef, + NULL, NULL, virStorageVolDefFree, NULL, 0); +} + + +void +virStoragePoolObjRemoveVolume(virStoragePoolObjPtr pool, + virPoolObjPtr *volobj) +{ + virPoolObjTableRemove(pool->volumes, volobj); +} + + +struct volCountData { + virConnectPtr conn; + virStoragePoolDefPtr pooldef; + virStoragePoolVolumeACLFilter aclfilter; + int count; +}; + +static int +volCount(virPoolObjPtr obj, + void *opaque) +{ + struct volCountData *data = opaque; + + /* Similar to virPoolObjTableListIterator */ + if (data->aclfilter && !data->aclfilter(data->conn, data->pooldef, obj)) + return 0; + + data->count++; + return 0; +} + + +int +virStoragePoolObjNumOfVolumes(virPoolObjTablePtr volumes, + virConnectPtr conn, + virStoragePoolDefPtr pooldef, + virStoragePoolVolumeACLFilter aclfilter) +{ + struct volCountData data = { .conn = conn, + .count = 0, + .pooldef = pooldef, + .aclfilter = aclfilter }; + + if (virPoolObjTableList(volumes, conn, NULL, volCount, &data) < 0) + return 0; + + return data.count; +} + + +struct volListData { + virConnectPtr conn; + virStoragePoolDefPtr pooldef; + virStoragePoolVolumeACLFilter aclfilter; + int nnames; + char **const names; + int maxnames; +}; + +static int +volListVolumes(virPoolObjPtr obj, + void *opaque) +{ + virStorageVolDefPtr def = virPoolObjGetDef(obj); + struct volListData *data = opaque; + + /* Similar to virPoolObjTableListIterator */ + if (data->aclfilter && !data->aclfilter(data->conn, data->pooldef, obj)) + return 0; + + if (data->nnames < data->maxnames) { + if (VIR_STRDUP(data->names[data->nnames++], def->name) < 0) + return -1; + } + + return 0; +} + + +int +virStoragePoolObjListVolumes(virPoolObjTablePtr volumes, + virConnectPtr conn, + virStoragePoolDefPtr pooldef, + virStoragePoolVolumeACLFilter aclfilter, + char **const names, + int maxnames) +{ + struct volListData data = { .conn = conn, + .nnames = 0, + .pooldef = pooldef, + .aclfilter = aclfilter, + .names = names, + .maxnames = maxnames }; + + memset(names, 0, maxnames * sizeof(*names)); + + if (virPoolObjTableList(volumes, conn, NULL, volListVolumes, &data) < 0) + goto error; + + return data.nnames; + + error: + while (--data.nnames >= 0) + VIR_FREE(names[data.nnames]); + return -1; +} + + static virStoragePoolObjPtr virStoragePoolObjLoad(virStoragePoolObjListPtr pools, const char *file, diff --git a/src/conf/storage_conf.h b/src/conf/storage_conf.h index 5eda544..cfc8281 100644 --- a/src/conf/storage_conf.h +++ b/src/conf/storage_conf.h @@ -28,6 +28,7 @@ # include "virstorageencryption.h" # include "virstoragefile.h" # include "virbitmap.h" +# include "virpoolobj.h" # include "virthread.h" # include "device_conf.h" # include "node_device_conf.h" @@ -73,13 +74,6 @@ struct _virStorageVolDef { virStorageSource target; }; -typedef struct _virStorageVolDefList virStorageVolDefList; -typedef virStorageVolDefList *virStorageVolDefListPtr; -struct _virStorageVolDefList { - size_t count; - virStorageVolDefPtr *objs; -}; - VIR_ENUM_DECL(virStorageVol) typedef enum { @@ -279,7 +273,7 @@ struct _virStoragePoolObj { virStoragePoolDefPtr def; virStoragePoolDefPtr newDef; - virStorageVolDefList volumes; + virPoolObjTablePtr volumes; }; typedef struct _virStoragePoolObjList virStoragePoolObjList; @@ -343,14 +337,14 @@ virStoragePoolObjPtr virStoragePoolSourceFindDuplicateDevices(virStoragePoolObjPtr pool, virStoragePoolDefPtr def); -virStorageVolDefPtr -virStorageVolDefFindByKey(virStoragePoolObjPtr pool, +virPoolObjPtr +virStorageVolObjFindByKey(virStoragePoolObjPtr pool, const char *key); -virStorageVolDefPtr -virStorageVolDefFindByPath(virStoragePoolObjPtr pool, +virPoolObjPtr +virStorageVolObjFindByPath(virStoragePoolObjPtr pool, const char *path); -virStorageVolDefPtr -virStorageVolDefFindByName(virStoragePoolObjPtr pool, +virPoolObjPtr +virStorageVolObjFindByName(virStoragePoolObjPtr pool, const char *name); void virStoragePoolObjClearVols(virStoragePoolObjPtr pool); @@ -387,6 +381,27 @@ virStoragePoolObjPtr virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools, virStoragePoolDefPtr def); +virPoolObjPtr virStoragePoolObjAddVolume(virStoragePoolObjPtr pool, + virStorageVolDefPtr voldef); + +void virStoragePoolObjRemoveVolume(virStoragePoolObjPtr pool, + virPoolObjPtr *volobj); + +typedef bool (*virStoragePoolVolumeACLFilter) + (virConnectPtr conn, virStoragePoolDefPtr pool, void *objdef); + +int virStoragePoolObjNumOfVolumes(virPoolObjTablePtr volumes, + virConnectPtr conn, + virStoragePoolDefPtr pooldef, + virStoragePoolVolumeACLFilter aclfilter); + +int virStoragePoolObjListVolumes(virPoolObjTablePtr volumes, + virConnectPtr conn, + virStoragePoolDefPtr pooldef, + virStoragePoolVolumeACLFilter aclfilter, + char **const names, + int maxnames); + int virStoragePoolSaveState(const char *stateFile, virStoragePoolDefPtr def); int virStoragePoolSaveConfig(const char *configFile, @@ -396,7 +411,7 @@ int virStoragePoolObjSaveDef(virStorageDriverStatePtr driver, virStoragePoolDefPtr def); int virStoragePoolObjDeleteDef(virStoragePoolObjPtr pool); -void virStorageVolDefFree(virStorageVolDefPtr def); +void virStorageVolDefFree(void *opaque); void virStoragePoolSourceClear(virStoragePoolSourcePtr source); void virStoragePoolSourceDeviceClear(virStoragePoolSourceDevicePtr dev); void virStoragePoolSourceFree(virStoragePoolSourcePtr source); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 17de708..14c3682 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -862,6 +862,7 @@ virStoragePoolFormatLogicalTypeToString; virStoragePoolGetVhbaSCSIHostParent; virStoragePoolLoadAllConfigs; virStoragePoolLoadAllState; +virStoragePoolObjAddVolume; virStoragePoolObjAssignDef; virStoragePoolObjClearVols; virStoragePoolObjDeleteDef; @@ -870,8 +871,11 @@ virStoragePoolObjFindByUUID; virStoragePoolObjIsDuplicate; virStoragePoolObjListExport; virStoragePoolObjListFree; +virStoragePoolObjListVolumes; virStoragePoolObjLock; +virStoragePoolObjNumOfVolumes; virStoragePoolObjRemove; +virStoragePoolObjRemoveVolume; virStoragePoolObjSaveDef; virStoragePoolObjUnlock; virStoragePoolSaveConfig; @@ -887,14 +891,14 @@ virStoragePoolSourceListFormat; virStoragePoolSourceListNewSource; virStoragePoolTypeFromString; virStoragePoolTypeToString; -virStorageVolDefFindByKey; -virStorageVolDefFindByName; -virStorageVolDefFindByPath; virStorageVolDefFormat; virStorageVolDefFree; virStorageVolDefParseFile; virStorageVolDefParseNode; virStorageVolDefParseString; +virStorageVolObjFindByKey; +virStorageVolObjFindByName; +virStorageVolObjFindByPath; virStorageVolTypeFromString; virStorageVolTypeToString; diff --git a/src/storage/storage_backend_disk.c b/src/storage/storage_backend_disk.c index 819f1e5..dcf4e3e 100644 --- a/src/storage/storage_backend_disk.c +++ b/src/storage/storage_backend_disk.c @@ -43,6 +43,20 @@ VIR_LOG_INIT("storage.storage_backend_disk"); #define SECTOR_SIZE 512 + +static bool +volPartFindExtended(virPoolObjPtr volobj, + void *opaque ATTRIBUTE_UNUSED) +{ + virStorageVolDefPtr def = virPoolObjGetDef(volobj); + + if (def->source.partType == VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) + return true; + + return false; +} + + static int virStorageBackendDiskMakeDataVol(virStoragePoolObjPtr pool, char **const groups, @@ -59,17 +73,21 @@ virStorageBackendDiskMakeDataVol(virStoragePoolObjPtr pool, partname = groups[0]; if (vol == NULL) { + virPoolObjPtr volobj; /* This is typically a reload/restart/refresh path where * we're discovering the existing partitions for the pool */ - if (VIR_ALLOC(vol) < 0) + if (VIR_ALLOC(vol) < 0 || + VIR_STRDUP(vol->name, partname) < 0) { + VIR_FREE(vol); return -1; - if (VIR_STRDUP(vol->name, partname) < 0 || - VIR_APPEND_ELEMENT_COPY(pool->volumes.objs, - pool->volumes.count, vol) < 0) { + } + + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) { virStorageVolDefFree(vol); return -1; } + virPoolObjEndAPI(&volobj); } if (vol->target.path == NULL) { @@ -192,15 +210,13 @@ virStorageBackendDiskMakeDataVol(virStoragePoolObjPtr pool, /* Find the extended partition and increase the allocation value */ if (vol->source.partType == VIR_STORAGE_VOL_DISK_TYPE_LOGICAL) { - size_t i; + virPoolObjPtr volobj; - for (i = 0; i < pool->volumes.count; i++) { - if (pool->volumes.objs[i]->source.partType == - VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) { - pool->volumes.objs[i]->target.allocation += - vol->target.allocation; - break; - } + if ((volobj = virPoolObjTableSearch(pool->volumes, volPartFindExtended, + NULL))) { + virStorageVolDefPtr voldef = virPoolObjGetDef(volobj); + voldef->target.allocation += vol->target.allocation; + virPoolObjEndAPI(&volobj); } } @@ -285,21 +301,26 @@ virStorageBackendDiskMakeVol(size_t ntok ATTRIBUTE_UNUSED, /* Remaining data / metadata parts get turn into volumes... */ if (STREQ(groups[2], "metadata") || STREQ(groups[2], "data")) { - virStorageVolDefPtr vol = data->vol; + virStorageVolDefPtr voldef = data->vol; - if (vol) { + if (voldef) { /* We're searching for a specific vol only */ - if (vol->key) { - if (STRNEQ(vol->key, groups[0])) + if (voldef->key) { + if (STRNEQ(voldef->key, groups[0])) + return 0; + } else { + virPoolObjPtr volobj; + + if ((volobj = virStorageVolObjFindByKey(pool, groups[0]))) { + /* If no key, the volume must be newly created. If groups[0] + * isn't already a volume, assume it's the path we want */ + virPoolObjEndAPI(&volobj); return 0; - } else if (virStorageVolDefFindByKey(pool, groups[0]) != NULL) { - /* If no key, the volume must be newly created. If groups[0] - * isn't already a volume, assume it's the path we want */ - return 0; + } } } - return virStorageBackendDiskMakeDataVol(pool, groups, vol); + return virStorageBackendDiskMakeDataVol(pool, groups, voldef); } else if (STREQ(groups[2], "free")) { /* ....or free space extents */ return virStorageBackendDiskMakeFreeExtent(pool, groups); @@ -518,6 +539,28 @@ virStorageBackendDiskBuildPool(virConnectPtr conn ATTRIBUTE_UNUSED, return ret; } + +struct volPartListData { + int count; +}; + + +static int +volNumOfPartTypes(virPoolObjPtr volobj, + void *opaque) +{ + virStorageVolDefPtr def = virPoolObjGetDef(volobj); + struct volPartListData *data = opaque; + int partType = def->source.partType; + + if (partType == VIR_STORAGE_VOL_DISK_TYPE_PRIMARY || + partType == VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) + data->count++; + + return 0; +} + + /** * Decides what kind of partition type that should be created. * Important when the partition table is of msdos type @@ -525,19 +568,17 @@ virStorageBackendDiskBuildPool(virConnectPtr conn ATTRIBUTE_UNUSED, static int virStorageBackendDiskPartTypeToCreate(virStoragePoolObjPtr pool) { + struct volPartListData data = { .count = 0 }; + if (pool->def->source.format == VIR_STORAGE_POOL_DISK_DOS) { + /* count primary and extended partitions, - can't be more than 3 to create a new primary partition */ - size_t i; - int count = 0; - for (i = 0; i < pool->volumes.count; i++) { - int partType = pool->volumes.objs[i]->source.partType; - if (partType == VIR_STORAGE_VOL_DISK_TYPE_PRIMARY || - partType == VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) - count++; + * can't be more than 3 to create a new primary partition */ + if (virPoolObjTableList(pool->volumes, NULL, NULL, + volNumOfPartTypes, &data) == 0) { + if (data.count >= 4) + return VIR_STORAGE_VOL_DISK_TYPE_LOGICAL; } - if (count >= 4) - return VIR_STORAGE_VOL_DISK_TYPE_LOGICAL; } /* for all other cases, all partitions are primary */ @@ -549,7 +590,8 @@ virStorageBackendDiskPartFormat(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, char** partFormat) { - size_t i; + virPoolObjPtr volobj; + if (pool->def->source.format == VIR_STORAGE_POOL_DISK_DOS) { const char *partedFormat; partedFormat = virStoragePartedFsTypeToString(vol->target.format); @@ -560,14 +602,14 @@ virStorageBackendDiskPartFormat(virStoragePoolObjPtr pool, } if (vol->target.format == VIR_STORAGE_VOL_DISK_EXTENDED) { /* make sure we don't have an extended partition already */ - for (i = 0; i < pool->volumes.count; i++) { - if (pool->volumes.objs[i]->source.partType == - VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("extended partition already exists")); - return -1; - } + if ((volobj == virPoolObjTableSearch(pool->volumes, + volPartFindExtended, NULL))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("extended partition already exists")); + virPoolObjEndAPI(&volobj); + return -1; } + if (VIR_STRDUP(*partFormat, partedFormat) < 0) return -1; } else { @@ -582,18 +624,19 @@ virStorageBackendDiskPartFormat(virStoragePoolObjPtr pool, break; case VIR_STORAGE_VOL_DISK_TYPE_LOGICAL: /* make sure we have an extended partition */ - for (i = 0; i < pool->volumes.count; i++) { - if (pool->volumes.objs[i]->source.partType == - VIR_STORAGE_VOL_DISK_TYPE_EXTENDED) { - if (virAsprintf(partFormat, "logical %s", - partedFormat) < 0) - return -1; - break; + if ((volobj == virPoolObjTableSearch(pool->volumes, + volPartFindExtended, + NULL))) { + if (virAsprintf(partFormat, "logical %s", + partedFormat) < 0) { + virPoolObjEndAPI(&volobj); + return -1; } - } - if (i == pool->volumes.count) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("no extended partition found and no primary partition available")); + virPoolObjEndAPI(&volobj); + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("no extended partition found and no " + "primary partition available")); return -1; } break; diff --git a/src/storage/storage_backend_gluster.c b/src/storage/storage_backend_gluster.c index 7be2d9e..aa9d7be 100644 --- a/src/storage/storage_backend_gluster.c +++ b/src/storage/storage_backend_gluster.c @@ -379,15 +379,20 @@ virStorageBackendGlusterRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED, } while (!(errno = glfs_readdirplus_r(dir, &st, &de.ent, &ent)) && ent) { virStorageVolDefPtr vol; - int okay = virStorageBackendGlusterRefreshVol(state, - ent->d_name, &st, - &vol); + virPoolObjPtr volobj; - if (okay < 0) + if (virStorageBackendGlusterRefreshVol(state, ent->d_name, + &st, &vol) < 0) goto cleanup; - if (vol && VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, - vol) < 0) + + if (!vol) + continue; + + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) { + virStorageVolDefFree(vol); goto cleanup; + } + virPoolObjEndAPI(&volobj); } if (errno) { virReportSystemError(errno, _("failed to read directory '%s' in '%s'"), diff --git a/src/storage/storage_backend_logical.c b/src/storage/storage_backend_logical.c index b0191aa..ad66656 100644 --- a/src/storage/storage_backend_logical.c +++ b/src/storage/storage_backend_logical.c @@ -288,7 +288,8 @@ virStorageBackendLogicalMakeVol(char **const groups, { struct virStorageBackendLogicalPoolVolData *data = opaque; virStoragePoolObjPtr pool = data->pool; - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef = data->vol; bool is_new_vol = false; int ret = -1; const char *attrs = groups[9]; @@ -306,32 +307,30 @@ virStorageBackendLogicalMakeVol(char **const groups, return 0; /* See if we're only looking for a specific volume */ - if (data->vol != NULL) { - vol = data->vol; - if (STRNEQ(vol->name, groups[0])) - return 0; - } + if (voldef && STRNEQ(voldef->name, groups[0])) + return 0; /* Or filling in more data on an existing volume */ - if (vol == NULL) - vol = virStorageVolDefFindByName(pool, groups[0]); + if (!voldef) { + if ((volobj = virStorageVolObjFindByName(pool, groups[0]))) + voldef = virPoolObjGetDef(volobj); + } /* Or a completely new volume */ - if (vol == NULL) { - if (VIR_ALLOC(vol) < 0) + if (!voldef) { + if (VIR_ALLOC(voldef) < 0) return -1; is_new_vol = true; - vol->type = VIR_STORAGE_VOL_BLOCK; + voldef->type = VIR_STORAGE_VOL_BLOCK; - if (VIR_STRDUP(vol->name, groups[0]) < 0) + if (VIR_STRDUP(voldef->name, groups[0]) < 0) goto cleanup; - } - if (vol->target.path == NULL) { - if (virAsprintf(&vol->target.path, "%s/%s", - pool->def->target.path, vol->name) < 0) + if (!voldef->target.path) { + if (virAsprintf(&voldef->target.path, "%s/%s", + pool->def->target.path, voldef->name) < 0) goto cleanup; } @@ -342,7 +341,7 @@ virStorageBackendLogicalMakeVol(char **const groups, * in brackets [] described for the groups[1] (backingStore). */ if (attrs[0] == 's') - vol->target.sparse = true; + voldef->target.sparse = true; /* Skips the backingStore of lv created with "--virtualsize", * its original device "/dev/$vgname/$lvname_vorigin" is @@ -352,41 +351,44 @@ virStorageBackendLogicalMakeVol(char **const groups, * lv is created with "--virtualsize"). */ if (groups[1] && STRNEQ(groups[1], "") && (groups[1][0] != '[')) { - if (VIR_ALLOC(vol->target.backingStore) < 0) + if (VIR_ALLOC(voldef->target.backingStore) < 0) goto cleanup; - if (virAsprintf(&vol->target.backingStore->path, "%s/%s", + if (virAsprintf(&voldef->target.backingStore->path, "%s/%s", pool->def->target.path, groups[1]) < 0) goto cleanup; - vol->target.backingStore->format = VIR_STORAGE_POOL_LOGICAL_LVM2; + voldef->target.backingStore->format = VIR_STORAGE_POOL_LOGICAL_LVM2; } - if (!vol->key && VIR_STRDUP(vol->key, groups[2]) < 0) + if (!voldef->key && VIR_STRDUP(voldef->key, groups[2]) < 0) goto cleanup; - if (virStorageBackendUpdateVolInfo(vol, false, + if (virStorageBackendUpdateVolInfo(voldef, false, VIR_STORAGE_VOL_OPEN_DEFAULT, 0) < 0) goto cleanup; - if (virStrToLong_ull(groups[8], NULL, 10, &vol->target.allocation) < 0) { + if (virStrToLong_ull(groups[8], NULL, 10, &voldef->target.allocation) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("malformed volume allocation value")); goto cleanup; } - if (virStorageBackendLogicalParseVolExtents(vol, groups) < 0) + if (virStorageBackendLogicalParseVolExtents(voldef, groups) < 0) goto cleanup; - if (is_new_vol && - VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, vol) < 0) - goto cleanup; + if (is_new_vol) { + if (!(volobj = virStoragePoolObjAddVolume(pool, voldef))) + goto cleanup; + voldef = NULL; + virPoolObjEndAPI(&volobj); + } ret = 0; cleanup: if (is_new_vol) - virStorageVolDefFree(vol); + virStorageVolDefFree(voldef); return ret; } diff --git a/src/storage/storage_backend_mpath.c b/src/storage/storage_backend_mpath.c index a5d692a..514b59b 100644 --- a/src/storage/storage_backend_mpath.c +++ b/src/storage/storage_backend_mpath.c @@ -48,6 +48,7 @@ virStorageBackendMpathNewVol(virStoragePoolObjPtr pool, const char *dev) { virStorageVolDefPtr vol; + virPoolObjPtr volobj; int ret = -1; if (VIR_ALLOC(vol) < 0) @@ -70,16 +71,19 @@ virStorageBackendMpathNewVol(virStoragePoolObjPtr pool, if (VIR_STRDUP(vol->key, vol->target.path) < 0) goto cleanup; - if (VIR_APPEND_ELEMENT_COPY(pool->volumes.objs, pool->volumes.count, vol) < 0) + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) goto cleanup; + + vol = NULL; + virPoolObjEndAPI(&volobj); + pool->def->capacity += vol->target.capacity; pool->def->allocation += vol->target.allocation; ret = 0; cleanup: - if (ret != 0) - virStorageVolDefFree(vol); + virStorageVolDefFree(vol); return ret; } diff --git a/src/storage/storage_backend_rbd.c b/src/storage/storage_backend_rbd.c index 45beb10..5a46664 100644 --- a/src/storage/storage_backend_rbd.c +++ b/src/storage/storage_backend_rbd.c @@ -429,6 +429,7 @@ virStorageBackendRBDRefreshPool(virConnectPtr conn, int ret = -1; int len = -1; int r = 0; + int count = 0; char *name, *names = NULL; virStorageBackendRBDStatePtr ptr = NULL; struct rados_cluster_stat_t clusterstat; @@ -473,6 +474,7 @@ virStorageBackendRBDRefreshPool(virConnectPtr conn, for (name = names; name < names + max_size;) { virStorageVolDefPtr vol; + virPoolObjPtr volobj; if (STREQ(name, "")) break; @@ -506,15 +508,17 @@ virStorageBackendRBDRefreshPool(virConnectPtr conn, goto cleanup; } - if (VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, vol) < 0) { + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) { virStorageVolDefFree(vol); virStoragePoolObjClearVols(pool); goto cleanup; } + count++; + virPoolObjEndAPI(&volobj); } - VIR_DEBUG("Found %zu images in RBD pool %s", - pool->volumes.count, pool->def->source.name); + VIR_DEBUG("Found %d images in RBD pool %s", + count, pool->def->source.name); ret = 0; diff --git a/src/storage/storage_backend_sheepdog.c b/src/storage/storage_backend_sheepdog.c index 36458a5..04734c8 100644 --- a/src/storage/storage_backend_sheepdog.c +++ b/src/storage/storage_backend_sheepdog.c @@ -115,6 +115,7 @@ virStorageBackendSheepdogAddVolume(virConnectPtr conn ATTRIBUTE_UNUSED, virStoragePoolObjPtr pool, const char *diskInfo) { virStorageVolDefPtr vol = NULL; + virPoolObjPtr obj; if (diskInfo == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -130,11 +131,11 @@ virStorageBackendSheepdogAddVolume(virConnectPtr conn ATTRIBUTE_UNUSED, if (virStorageBackendSheepdogRefreshVol(conn, pool, vol) < 0) goto error; - if (VIR_EXPAND_N(pool->volumes.objs, pool->volumes.count, 1) < 0) + if (!(obj = virStoragePoolObjAddVolume(pool, vol))) goto error; + vol = NULL; - pool->volumes.objs[pool->volumes.count - 1] = vol; - + virPoolObjEndAPI(&obj); return 0; error: diff --git a/src/storage/storage_backend_zfs.c b/src/storage/storage_backend_zfs.c index 70c533a..fab29fb 100644 --- a/src/storage/storage_backend_zfs.c +++ b/src/storage/storage_backend_zfs.c @@ -99,16 +99,17 @@ virStorageBackendZFSCheckPool(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED, static int virStorageBackendZFSParseVol(virStoragePoolObjPtr pool, - virStorageVolDefPtr vol, + virStorageVolDefPtr volume, const char *volume_string) { + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef = volume; int ret = -1; char **tokens; size_t count; char **name_tokens = NULL; char *vol_name; bool is_new_vol = false; - virStorageVolDefPtr volume = NULL; if (!(tokens = virStringSplitCount(volume_string, "\t", 0, &count))) return -1; @@ -121,58 +122,60 @@ virStorageBackendZFSParseVol(virStoragePoolObjPtr pool, vol_name = name_tokens[1]; - if (vol == NULL) - volume = virStorageVolDefFindByName(pool, vol_name); - else - volume = vol; + if (!voldef) { + if ((volobj = virStorageVolObjFindByName(pool, vol_name))) + voldef = virPoolObjGetDef(volobj); + } - if (volume == NULL) { - if (VIR_ALLOC(volume) < 0) + if (!voldef) { + if (VIR_ALLOC(voldef) < 0) goto cleanup; is_new_vol = true; - volume->type = VIR_STORAGE_VOL_BLOCK; + voldef->type = VIR_STORAGE_VOL_BLOCK; - if (VIR_STRDUP(volume->name, vol_name) < 0) + if (VIR_STRDUP(voldef->name, vol_name) < 0) goto cleanup; } - if (!volume->key && VIR_STRDUP(volume->key, tokens[0]) < 0) + if (!voldef->key && VIR_STRDUP(voldef->key, tokens[0]) < 0) goto cleanup; - if (volume->target.path == NULL) { - if (virAsprintf(&volume->target.path, "%s/%s", - pool->def->target.path, volume->name) < 0) + if (voldef->target.path == NULL) { + if (virAsprintf(&voldef->target.path, "%s/%s", + pool->def->target.path, voldef->name) < 0) goto cleanup; } - if (virStrToLong_ull(tokens[1], NULL, 10, &volume->target.capacity) < 0) { + if (virStrToLong_ull(tokens[1], NULL, 10, &voldef->target.capacity) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("malformed volsize reported")); goto cleanup; } - if (virStrToLong_ull(tokens[2], NULL, 10, &volume->target.allocation) < 0) { + if (virStrToLong_ull(tokens[2], NULL, 10, &voldef->target.allocation) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("malformed refreservation reported")); goto cleanup; } - if (volume->target.allocation < volume->target.capacity) - volume->target.sparse = true; + if (voldef->target.allocation < voldef->target.capacity) + voldef->target.sparse = true; - if (is_new_vol && - VIR_APPEND_ELEMENT(pool->volumes.objs, - pool->volumes.count, - volume) < 0) - goto cleanup; + if (is_new_vol) { + if (!(volobj = virStoragePoolObjAddVolume(pool, voldef))) + goto cleanup; + + voldef = NULL; + } ret = 0; cleanup: virStringListFree(tokens); virStringListFree(name_tokens); + virPoolObjEndAPI(&volobj); if (is_new_vol) - virStorageVolDefFree(volume); + virStorageVolDefFree(voldef); return ret; } diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c index ed4772a..19f7a88 100644 --- a/src/storage/storage_driver.c +++ b/src/storage/storage_driver.c @@ -1370,13 +1370,11 @@ storagePoolSetAutostart(virStoragePoolPtr obj, return ret; } - static int storagePoolNumOfVolumes(virStoragePoolPtr obj) { virStoragePoolObjPtr pool; int ret = -1; - size_t i; if (!(pool = virStoragePoolObjFromStoragePool(obj))) return -1; @@ -1389,26 +1387,27 @@ storagePoolNumOfVolumes(virStoragePoolPtr obj) _("storage pool '%s' is not active"), pool->def->name); goto cleanup; } - ret = 0; - for (i = 0; i < pool->volumes.count; i++) { - if (virStoragePoolNumOfVolumesCheckACL(obj->conn, pool->def, - pool->volumes.objs[i])) - ret++; - } + + /* NB: Cannot call filter in List function since the volume ACL filter + * function requires 3 instead of 2 params for virPoolObjACLFilter. + * Setting up this way fulfills check-aclrules.pl's check that the + * driver function calls the CheckACL API */ + ret = virStoragePoolObjNumOfVolumes(pool->volumes, obj->conn, pool->def, + virStoragePoolNumOfVolumesCheckACL); cleanup: virStoragePoolObjUnlock(pool); return ret; } + static int storagePoolListVolumes(virStoragePoolPtr obj, char **const names, int maxnames) { + int ret = -1; virStoragePoolObjPtr pool; - size_t i; - int n = 0; memset(names, 0, maxnames * sizeof(*names)); @@ -1424,35 +1423,30 @@ storagePoolListVolumes(virStoragePoolPtr obj, goto cleanup; } - for (i = 0; i < pool->volumes.count && n < maxnames; i++) { - if (!virStoragePoolListVolumesCheckACL(obj->conn, pool->def, - pool->volumes.objs[i])) - continue; - if (VIR_STRDUP(names[n++], pool->volumes.objs[i]->name) < 0) - goto cleanup; - } - - virStoragePoolObjUnlock(pool); - return n; + /* NB: Cannot call filter in List function since the volume ACL filter + * function requires 3 instead of 2 params for virPoolObjACLFilter. + * Setting up this way fulfills check-aclrules.pl's check that the + * driver function calls the CheckACL API */ + ret = virStoragePoolObjListVolumes(pool->volumes, obj->conn, pool->def, + virStoragePoolListVolumesCheckACL, + names, maxnames); cleanup: virStoragePoolObjUnlock(pool); - for (n = 0; n < maxnames; n++) - VIR_FREE(names[n]); - - memset(names, 0, maxnames * sizeof(*names)); - return -1; + return ret; } + static int storagePoolListAllVolumes(virStoragePoolPtr pool, - virStorageVolPtr **vols, + virStorageVolPtr **volumes, unsigned int flags) { virStoragePoolObjPtr obj; + virPoolObjPtr *volobjs = NULL; + size_t nvolobjs = 0; size_t i; - virStorageVolPtr *tmp_vols = NULL; - virStorageVolPtr vol = NULL; + virStorageVolPtr *vols = NULL; int nvols = 0; int ret = -1; @@ -1470,40 +1464,45 @@ storagePoolListAllVolumes(virStoragePoolPtr pool, goto cleanup; } - /* Just returns the volumes count */ - if (!vols) { - ret = obj->volumes.count; + if (virPoolObjTableCollect(obj->volumes, pool->conn, &volobjs, &nvolobjs, + NULL, NULL, flags) < 0) goto cleanup; - } - if (VIR_ALLOC_N(tmp_vols, obj->volumes.count + 1) < 0) - goto cleanup; - - for (i = 0; i < obj->volumes.count; i++) { - if (!virStoragePoolListAllVolumesCheckACL(pool->conn, obj->def, - obj->volumes.objs[i])) - continue; - if (!(vol = virGetStorageVol(pool->conn, obj->def->name, - obj->volumes.objs[i]->name, - obj->volumes.objs[i]->key, - NULL, NULL))) + if (volumes) { + if (VIR_ALLOC_N(vols, nvolobjs + 1) < 0) goto cleanup; - tmp_vols[nvols++] = vol; - } - *vols = tmp_vols; - tmp_vols = NULL; - ret = nvols; + for (i = 0; i < nvolobjs; i++) { + bool passacl = false; + virPoolObjPtr volobj = volobjs[i]; + virStorageVolDefPtr def; + + virObjectLock(volobj); + def = virPoolObjGetDef(volobj); + /* NB: Cannot call ACL filter in Collect function since it + * takes 3 params and the volume ACL filter requires 3 */ + if (virStoragePoolListAllVolumesCheckACL(pool->conn, obj->def, + obj)) { + vols[nvols++] = virGetStorageVol(pool->conn, obj->def->name, + def->name, def->key, + NULL, NULL); + passacl = true; + } + virObjectUnlock(volobj); - cleanup: - if (tmp_vols) { - for (i = 0; i < nvols; i++) - virObjectUnref(tmp_vols[i]); - VIR_FREE(tmp_vols); + if (passacl && !vols[i]) + goto cleanup; + } + + *volumes = vols; + vols = NULL; } - virStoragePoolObjUnlock(obj); + ret = nvols; + cleanup: + virObjectListFree(vols); + virObjectListFreeCount(volobjs, nvolobjs); return ret; } @@ -1512,7 +1511,8 @@ storageVolLookupByName(virStoragePoolPtr obj, const char *name) { virStoragePoolObjPtr pool; - virStorageVolDefPtr vol; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; virStorageVolPtr ret = NULL; if (!(pool = virStoragePoolObjFromStoragePool(obj))) @@ -1524,22 +1524,22 @@ storageVolLookupByName(virStoragePoolPtr obj, goto cleanup; } - vol = virStorageVolDefFindByName(pool, name); - - if (!vol) { + if (!(volobj = virStorageVolObjFindByName(pool, name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), name); goto cleanup; } + voldef = virPoolObjGetDef(volobj); - if (virStorageVolLookupByNameEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolLookupByNameEnsureACL(obj->conn, pool->def, voldef) < 0) goto cleanup; - ret = virGetStorageVol(obj->conn, pool->def->name, vol->name, vol->key, - NULL, NULL); + ret = virGetStorageVol(obj->conn, pool->def->name, voldef->name, + voldef->key, NULL, NULL); cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; } @@ -1556,21 +1556,25 @@ storageVolLookupByKey(virConnectPtr conn, for (i = 0; i < driver->pools.count && !ret; i++) { virStoragePoolObjLock(driver->pools.objs[i]); if (virStoragePoolObjIsActive(driver->pools.objs[i])) { - virStorageVolDefPtr vol = - virStorageVolDefFindByKey(driver->pools.objs[i], key); + virPoolObjPtr volobj; - if (vol) { + if ((volobj = virStorageVolObjFindByKey(driver->pools.objs[i], + key))) { virStoragePoolDefPtr def = driver->pools.objs[i]->def; - if (virStorageVolLookupByKeyEnsureACL(conn, def, vol) < 0) { + virStorageVolDefPtr voldef = virPoolObjGetDef(volobj); + + if (virStorageVolLookupByKeyEnsureACL(conn, def, voldef) < 0) { + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(driver->pools.objs[i]); goto cleanup; } ret = virGetStorageVol(conn, def->name, - vol->name, - vol->key, + voldef->name, + voldef->key, NULL, NULL); + virPoolObjEndAPI(&volobj); } } virStoragePoolObjUnlock(driver->pools.objs[i]); @@ -1600,7 +1604,7 @@ storageVolLookupByPath(virConnectPtr conn, storageDriverLock(); for (i = 0; i < driver->pools.count && !ret; i++) { virStoragePoolObjPtr pool = driver->pools.objs[i]; - virStorageVolDefPtr vol; + virPoolObjPtr volobj = NULL; char *stable_path = NULL; virStoragePoolObjLock(pool); @@ -1646,18 +1650,22 @@ storageVolLookupByPath(virConnectPtr conn, break; } - vol = virStorageVolDefFindByPath(pool, stable_path); + volobj = virStorageVolObjFindByPath(pool, stable_path); VIR_FREE(stable_path); - if (vol) { - if (virStorageVolLookupByPathEnsureACL(conn, pool->def, vol) < 0) { + if (volobj) { + virStorageVolDefPtr voldef = virPoolObjGetDef(volobj); + if (virStorageVolLookupByPathEnsureACL(conn, pool->def, + voldef) < 0) { + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); goto cleanup; } ret = virGetStorageVol(conn, pool->def->name, - vol->name, vol->key, + voldef->name, voldef->key, NULL, NULL); + virPoolObjEndAPI(&volobj); } virStoragePoolObjUnlock(pool); @@ -1727,18 +1735,21 @@ static void storageVolRemoveFromPool(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) { - size_t i; + virPoolObjPtr obj; - for (i = 0; i < pool->volumes.count; i++) { - if (pool->volumes.objs[i] == vol) { - VIR_INFO("Deleting volume '%s' from storage pool '%s'", - vol->name, pool->def->name); - virStorageVolDefFree(vol); - - VIR_DELETE_ELEMENT(pool->volumes.objs, i, pool->volumes.count); - break; - } + if (!(obj = virPoolObjTableFindByName(pool->volumes, vol->name))) { + virReportError(VIR_ERR_NO_STORAGE_VOL, + _("no storage vol with matching name '%s'"), + vol->name); + return; } + + VIR_INFO("Deleting volume '%s' from storage pool '%s'", + vol->name, pool->def->name); + + virStoragePoolObjRemoveVolume(pool, &obj); + + virPoolObjEndAPI(&obj); } @@ -1781,23 +1792,23 @@ storageVolDeleteInternal(virStorageVolPtr obj, } -static virStorageVolDefPtr -virStorageVolDefFromVol(virStorageVolPtr obj, +static virPoolObjPtr +virStorageVolObjFromVol(virStorageVolPtr volume, virStoragePoolObjPtr *pool, virStorageBackendPtr *backend) { - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj = NULL; *pool = NULL; storageDriverLock(); - *pool = virStoragePoolObjFindByName(&driver->pools, obj->pool); + *pool = virStoragePoolObjFindByName(&driver->pools, volume->pool); storageDriverUnlock(); if (!*pool) { virReportError(VIR_ERR_NO_STORAGE_POOL, _("no storage pool with matching name '%s'"), - obj->pool); + volume->pool); return NULL; } @@ -1808,10 +1819,10 @@ virStorageVolDefFromVol(virStorageVolPtr obj, goto error; } - if (!(vol = virStorageVolDefFindByName(*pool, obj->name))) { + if (!(volobj = virStorageVolObjFindByName(*pool, volume->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), - obj->name); + volume->name); goto error; } @@ -1820,7 +1831,7 @@ virStorageVolDefFromVol(virStorageVolPtr obj, goto error; } - return vol; + return volobj; error: virStoragePoolObjUnlock(*pool); @@ -1831,40 +1842,44 @@ virStorageVolDefFromVol(virStorageVolPtr obj, static int -storageVolDelete(virStorageVolPtr obj, +storageVolDelete(virStorageVolPtr volume, unsigned int flags) { virStoragePoolObjPtr pool; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; virStorageBackendPtr backend; - virStorageVolDefPtr vol = NULL; int ret = -1; - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolDeleteEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolDeleteEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - if (vol->in_use) { + if (voldef->in_use) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still in use."), - vol->name); + voldef->name); goto cleanup; } - if (vol->building) { + if (voldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - vol->name); + voldef->name); goto cleanup; } - if (storageVolDeleteInternal(obj, backend, pool, vol, flags, true) < 0) + if (storageVolDeleteInternal(volume, backend, pool, voldef, + flags, true) < 0) goto cleanup; ret = 0; cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; } @@ -1878,7 +1893,10 @@ storageVolCreateXML(virStoragePoolPtr obj, virStoragePoolObjPtr pool; virStorageBackendPtr backend; virStorageVolDefPtr voldef = NULL; - virStorageVolPtr ret = NULL, volobj = NULL; + virStorageVolDefPtr objvoldef; + virPoolObjPtr volobj = NULL; + virStorageVolPtr vol = NULL; + virStorageVolPtr ret = NULL; virCheckFlags(VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA, NULL); @@ -1894,9 +1912,8 @@ storageVolCreateXML(virStoragePoolPtr obj, if ((backend = virStorageBackendForType(pool->def->type)) == NULL) goto cleanup; - voldef = virStorageVolDefParseString(pool->def, xmldesc, - VIR_VOL_XML_PARSE_OPT_CAPACITY); - if (voldef == NULL) + if (!(voldef = virStorageVolDefParseString(pool->def, xmldesc, + VIR_VOL_XML_PARSE_OPT_CAPACITY))) goto cleanup; if (!voldef->target.capacity && !backend->buildVol) { @@ -1909,7 +1926,7 @@ storageVolCreateXML(virStoragePoolPtr obj, if (virStorageVolCreateXMLEnsureACL(obj->conn, pool->def, voldef) < 0) goto cleanup; - if (virStorageVolDefFindByName(pool, voldef->name)) { + if ((volobj = virStorageVolObjFindByName(pool, voldef->name))) { virReportError(VIR_ERR_STORAGE_VOL_EXIST, _("'%s'"), voldef->name); goto cleanup; @@ -1922,43 +1939,38 @@ storageVolCreateXML(virStoragePoolPtr obj, goto cleanup; } - if (VIR_REALLOC_N(pool->volumes.objs, - pool->volumes.count+1) < 0) - goto cleanup; - /* Wipe any key the user may have suggested, as volume creation * will generate the canonical key. */ VIR_FREE(voldef->key); if (backend->createVol(obj->conn, pool, voldef) < 0) goto cleanup; - pool->volumes.objs[pool->volumes.count++] = voldef; - volobj = virGetStorageVol(obj->conn, pool->def->name, voldef->name, - voldef->key, NULL, NULL); - if (!volobj) { - pool->volumes.count--; + if (!(volobj = virStoragePoolObjAddVolume(pool, voldef))) goto cleanup; - } + VIR_STEAL_PTR(objvoldef, voldef); + if (!(vol = virGetStorageVol(obj->conn, pool->def->name, objvoldef->name, + objvoldef->key, NULL, NULL))) { + virStoragePoolObjRemoveVolume(pool, &volobj); + goto cleanup; + } if (backend->buildVol) { int buildret; virStorageVolDefPtr buildvoldef = NULL; - if (VIR_ALLOC(buildvoldef) < 0) { - voldef = NULL; + if (VIR_ALLOC(buildvoldef) < 0) goto cleanup; - } /* Make a shallow copy of the 'defined' volume definition, since the * original allocation value will change as the user polls 'info', * but we only need the initial requested values */ - memcpy(buildvoldef, voldef, sizeof(*voldef)); + memcpy(buildvoldef, objvoldef, sizeof(*objvoldef)); /* Drop the pool lock during volume allocation */ pool->asyncjobs++; - voldef->building = true; + objvoldef->building = true; virStoragePoolObjUnlock(pool); buildret = backend->buildVol(obj->conn, pool, buildvoldef, flags); @@ -1969,23 +1981,21 @@ storageVolCreateXML(virStoragePoolPtr obj, virStoragePoolObjLock(pool); storageDriverUnlock(); - voldef->building = false; + objvoldef->building = false; pool->asyncjobs--; if (buildret < 0) { /* buildVol handles deleting volume on failure */ - storageVolRemoveFromPool(pool, voldef); - voldef = NULL; + storageVolRemoveFromPool(pool, objvoldef); goto cleanup; } } if (backend->refreshVol && - backend->refreshVol(obj->conn, pool, voldef) < 0) { - storageVolDeleteInternal(volobj, backend, pool, voldef, + backend->refreshVol(obj->conn, pool, objvoldef) < 0) { + storageVolDeleteInternal(vol, backend, pool, objvoldef, 0, false); - voldef = NULL; goto cleanup; } @@ -1993,18 +2003,18 @@ storageVolCreateXML(virStoragePoolPtr obj, * it updates the pool values. */ if (pool->def->type != VIR_STORAGE_POOL_DISK) { - pool->def->allocation += voldef->target.allocation; - pool->def->available -= voldef->target.allocation; + pool->def->allocation += objvoldef->target.allocation; + pool->def->available -= objvoldef->target.allocation; } VIR_INFO("Creating volume '%s' in storage pool '%s'", - volobj->name, pool->def->name); - ret = volobj; - volobj = NULL; - voldef = NULL; + vol->name, pool->def->name); + ret = vol; + vol = NULL; cleanup: - virObjectUnref(volobj); + virPoolObjEndAPI(&volobj); + virObjectUnref(vol); virStorageVolDefFree(voldef); if (pool) virStoragePoolObjUnlock(pool); @@ -2014,13 +2024,19 @@ storageVolCreateXML(virStoragePoolPtr obj, static virStorageVolPtr storageVolCreateXMLFrom(virStoragePoolPtr obj, const char *xmldesc, - virStorageVolPtr vobj, + virStorageVolPtr volume, unsigned int flags) { virStoragePoolObjPtr pool, origpool = NULL; virStorageBackendPtr backend; - virStorageVolDefPtr origvol = NULL, newvol = NULL, shadowvol = NULL; - virStorageVolPtr ret = NULL, volobj = NULL; + virPoolObjPtr newvolobj = NULL; + virPoolObjPtr origvolobj = NULL; + virStorageVolDefPtr origvoldef; + virStorageVolDefPtr newvoldef = NULL; + virStorageVolDefPtr objnewvoldef; + virStorageVolDefPtr shadowvoldef = NULL; + virStorageVolPtr vol = NULL; + virStorageVolPtr ret = NULL; int buildret; virCheckFlags(VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA | @@ -2029,9 +2045,9 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, storageDriverLock(); pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid); - if (pool && STRNEQ(obj->name, vobj->pool)) { + if (pool && STRNEQ(obj->name, volume->pool)) { virStoragePoolObjUnlock(pool); - origpool = virStoragePoolObjFindByName(&driver->pools, vobj->pool); + origpool = virStoragePoolObjFindByName(&driver->pools, volume->pool); virStoragePoolObjLock(pool); } storageDriverUnlock(); @@ -2044,10 +2060,10 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, goto cleanup; } - if (STRNEQ(obj->name, vobj->pool) && !origpool) { + if (STRNEQ(obj->name, volume->pool) && !origpool) { virReportError(VIR_ERR_NO_STORAGE_POOL, _("no storage pool with matching name '%s'"), - vobj->pool); + volume->pool); goto cleanup; } @@ -2067,41 +2083,42 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, if ((backend = virStorageBackendForType(pool->def->type)) == NULL) goto cleanup; - origvol = virStorageVolDefFindByName(origpool ? - origpool : pool, vobj->name); - if (!origvol) { + if (!(origvolobj = virStorageVolObjFindByName(origpool ? origpool : + pool, volume->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), - vobj->name); + volume->name); goto cleanup; } + origvoldef = virPoolObjGetDef(origvolobj); - newvol = virStorageVolDefParseString(pool->def, xmldesc, - VIR_VOL_XML_PARSE_NO_CAPACITY); - if (newvol == NULL) + if (!(newvoldef = + virStorageVolDefParseString(pool->def, xmldesc, + VIR_VOL_XML_PARSE_NO_CAPACITY))) goto cleanup; - if (virStorageVolCreateXMLFromEnsureACL(obj->conn, pool->def, newvol) < 0) + if (virStorageVolCreateXMLFromEnsureACL(obj->conn, pool->def, + newvoldef) < 0) goto cleanup; - if (virStorageVolDefFindByName(pool, newvol->name)) { + if ((newvolobj = virStorageVolObjFindByName(pool, newvoldef->name))) { virReportError(VIR_ERR_INTERNAL_ERROR, _("storage volume name '%s' already in use."), - newvol->name); + newvoldef->name); goto cleanup; } /* Use the original volume's capacity in case the new capacity * is less than that, or it was omitted */ - if (newvol->target.capacity < origvol->target.capacity) - newvol->target.capacity = origvol->target.capacity; + if (newvoldef->target.capacity < origvoldef->target.capacity) + newvoldef->target.capacity = origvoldef->target.capacity; /* If the allocation was not provided in the XML, then use capacity * as it's specifically documented "If omitted when creating a volume, * the volume will be fully allocated at time of creation.". This * is especially important for logical volume creation. */ - if (!newvol->target.has_allocation) - newvol->target.allocation = newvol->target.capacity; + if (!newvoldef->target.has_allocation) + newvoldef->target.allocation = newvoldef->target.capacity; if (!backend->buildVolFrom) { virReportError(VIR_ERR_NO_SUPPORT, @@ -2110,49 +2127,47 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, goto cleanup; } - if (origvol->building) { + if (origvoldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - origvol->name); + origvoldef->name); goto cleanup; } if (backend->refreshVol && - backend->refreshVol(obj->conn, pool, origvol) < 0) - goto cleanup; - - if (VIR_REALLOC_N(pool->volumes.objs, - pool->volumes.count+1) < 0) + backend->refreshVol(obj->conn, pool, origvoldef) < 0) goto cleanup; /* 'Define' the new volume so we get async progress reporting. * Wipe any key the user may have suggested, as volume creation * will generate the canonical key. */ - VIR_FREE(newvol->key); - if (backend->createVol(obj->conn, pool, newvol) < 0) + VIR_FREE(newvoldef->key); + if (backend->createVol(obj->conn, pool, newvoldef) < 0) goto cleanup; /* Make a shallow copy of the 'defined' volume definition, since the * original allocation value will change as the user polls 'info', * but we only need the initial requested values */ - if (VIR_ALLOC(shadowvol) < 0) + if (VIR_ALLOC(shadowvoldef) < 0) goto cleanup; - memcpy(shadowvol, newvol, sizeof(*newvol)); + memcpy(shadowvoldef, newvoldef, sizeof(*newvoldef)); + + if (!(newvolobj = virStoragePoolObjAddVolume(pool, newvoldef))) + goto cleanup; + VIR_STEAL_PTR(objnewvoldef, newvoldef); - pool->volumes.objs[pool->volumes.count++] = newvol; - volobj = virGetStorageVol(obj->conn, pool->def->name, newvol->name, - newvol->key, NULL, NULL); - if (!volobj) { - pool->volumes.count--; + if (!(vol = virGetStorageVol(obj->conn, pool->def->name, objnewvoldef->name, + objnewvoldef->key, NULL, NULL))) { + virStoragePoolObjRemoveVolume(pool, &newvolobj); goto cleanup; } /* Drop the pool lock during volume allocation */ pool->asyncjobs++; - newvol->building = true; - origvol->in_use++; + objnewvoldef->building = true; + origvoldef->in_use++; virStoragePoolObjUnlock(pool); if (origpool) { @@ -2160,7 +2175,8 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, virStoragePoolObjUnlock(origpool); } - buildret = backend->buildVolFrom(obj->conn, pool, shadowvol, origvol, flags); + buildret = backend->buildVolFrom(obj->conn, pool, shadowvoldef, + origvoldef, flags); storageDriverLock(); virStoragePoolObjLock(pool); @@ -2168,8 +2184,8 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, virStoragePoolObjLock(origpool); storageDriverUnlock(); - origvol->in_use--; - newvol->building = false; + origvoldef->in_use--; + objnewvoldef->building = false; pool->asyncjobs--; if (origpool) { @@ -2180,9 +2196,8 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, if (buildret < 0 || (backend->refreshVol && - backend->refreshVol(obj->conn, pool, newvol) < 0)) { - storageVolDeleteInternal(volobj, backend, pool, newvol, 0, false); - newvol = NULL; + backend->refreshVol(obj->conn, pool, objnewvoldef) < 0)) { + storageVolDeleteInternal(vol, backend, pool, objnewvoldef, 0, false); goto cleanup; } @@ -2190,20 +2205,21 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, * it updates the pool values */ if (pool->def->type != VIR_STORAGE_POOL_DISK) { - pool->def->allocation += newvol->target.allocation; - pool->def->available -= newvol->target.allocation; + pool->def->allocation += objnewvoldef->target.allocation; + pool->def->available -= objnewvoldef->target.allocation; } VIR_INFO("Creating volume '%s' in storage pool '%s'", - volobj->name, pool->def->name); - ret = volobj; - volobj = NULL; - newvol = NULL; + vol->name, pool->def->name); + ret = vol; + vol = NULL; cleanup: - virObjectUnref(volobj); - virStorageVolDefFree(newvol); - VIR_FREE(shadowvol); + virPoolObjEndAPI(&origvolobj); + virPoolObjEndAPI(&newvolobj); + virObjectUnref(vol); + virStorageVolDefFree(newvoldef); + VIR_FREE(shadowvoldef); if (pool) virStoragePoolObjUnlock(pool); if (origpool) @@ -2213,7 +2229,7 @@ storageVolCreateXMLFrom(virStoragePoolPtr obj, static int -storageVolDownload(virStorageVolPtr obj, +storageVolDownload(virStorageVolPtr volume, virStreamPtr stream, unsigned long long offset, unsigned long long length, @@ -2221,21 +2237,23 @@ storageVolDownload(virStorageVolPtr obj, { virStorageBackendPtr backend; virStoragePoolObjPtr pool = NULL; - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; int ret = -1; virCheckFlags(0, -1); - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolDownloadEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolDownloadEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - if (vol->building) { + if (voldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - vol->name); + voldef->name); goto cleanup; } @@ -2245,10 +2263,11 @@ storageVolDownload(virStorageVolPtr obj, goto cleanup; } - ret = backend->downloadVol(obj->conn, pool, vol, stream, + ret = backend->downloadVol(volume->conn, pool, voldef, stream, offset, length, flags); cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; @@ -2380,7 +2399,7 @@ virStorageVolFDStreamCloseCb(virStreamPtr st ATTRIBUTE_UNUSED, } static int -storageVolUpload(virStorageVolPtr obj, +storageVolUpload(virStorageVolPtr volume, virStreamPtr stream, unsigned long long offset, unsigned long long length, @@ -2388,29 +2407,31 @@ storageVolUpload(virStorageVolPtr obj, { virStorageBackendPtr backend; virStoragePoolObjPtr pool = NULL; - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; virStorageVolStreamInfoPtr cbdata = NULL; int ret = -1; virCheckFlags(0, -1); - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolUploadEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolUploadEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - if (vol->in_use) { + if (voldef->in_use) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still in use."), - vol->name); + voldef->name); goto cleanup; } - if (vol->building) { + if (voldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - vol->name); + voldef->name); goto cleanup; } @@ -2429,11 +2450,11 @@ storageVolUpload(virStorageVolPtr obj, if (VIR_ALLOC(cbdata) < 0 || VIR_STRDUP(cbdata->pool_name, pool->def->name) < 0) goto cleanup; - if (vol->type == VIR_STORAGE_VOL_PLOOP && - VIR_STRDUP(cbdata->vol_path, vol->target.path) < 0) + if (voldef->type == VIR_STORAGE_VOL_PLOOP && + VIR_STRDUP(cbdata->vol_path, voldef->target.path) < 0) goto cleanup; - if ((ret = backend->uploadVol(obj->conn, pool, vol, stream, + if ((ret = backend->uploadVol(volume->conn, pool, voldef, stream, offset, length, flags)) < 0) goto cleanup; @@ -2446,6 +2467,7 @@ storageVolUpload(virStorageVolPtr obj, cbdata = NULL; cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); if (cbdata) virStorageVolPoolRefreshDataFree(cbdata); @@ -2454,13 +2476,14 @@ storageVolUpload(virStorageVolPtr obj, } static int -storageVolResize(virStorageVolPtr obj, +storageVolResize(virStorageVolPtr volume, unsigned long long capacity, unsigned int flags) { virStorageBackendPtr backend; virStoragePoolObjPtr pool = NULL; - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; unsigned long long abs_capacity, delta = 0; int ret = -1; @@ -2468,44 +2491,46 @@ storageVolResize(virStorageVolPtr obj, VIR_STORAGE_VOL_RESIZE_DELTA | VIR_STORAGE_VOL_RESIZE_SHRINK, -1); - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolResizeEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolResizeEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - if (vol->in_use) { + if (voldef->in_use) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still in use."), - vol->name); + voldef->name); goto cleanup; } - if (vol->building) { + if (voldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - vol->name); + voldef->name); goto cleanup; } if (flags & VIR_STORAGE_VOL_RESIZE_DELTA) { if (flags & VIR_STORAGE_VOL_RESIZE_SHRINK) - abs_capacity = vol->target.capacity - MIN(capacity, vol->target.capacity); + abs_capacity = voldef->target.capacity - + MIN(capacity, voldef->target.capacity); else - abs_capacity = vol->target.capacity + capacity; + abs_capacity = voldef->target.capacity + capacity; flags &= ~VIR_STORAGE_VOL_RESIZE_DELTA; } else { abs_capacity = capacity; } - if (abs_capacity < vol->target.allocation) { + if (abs_capacity < voldef->target.allocation) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("can't shrink capacity below " "existing allocation")); goto cleanup; } - if (abs_capacity < vol->target.capacity && + if (abs_capacity < voldef->target.capacity && !(flags & VIR_STORAGE_VOL_RESIZE_SHRINK)) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("Can't shrink capacity below current " @@ -2514,7 +2539,7 @@ storageVolResize(virStorageVolPtr obj, } if (flags & VIR_STORAGE_VOL_RESIZE_ALLOCATE) - delta = abs_capacity - vol->target.allocation; + delta = abs_capacity - voldef->target.allocation; if (delta > pool->def->available) { virReportError(VIR_ERR_OPERATION_FAILED, "%s", @@ -2529,16 +2554,16 @@ storageVolResize(virStorageVolPtr obj, goto cleanup; } - if (backend->resizeVol(obj->conn, pool, vol, abs_capacity, flags) < 0) + if (backend->resizeVol(volume->conn, pool, voldef, abs_capacity, flags) < 0) goto cleanup; - vol->target.capacity = abs_capacity; + voldef->target.capacity = abs_capacity; /* Only update the allocation and pool values if we actually did the * allocation; otherwise, this is akin to a create operation with a * capacity value different and potentially much larger than available */ if (flags & VIR_STORAGE_VOL_RESIZE_ALLOCATE) { - vol->target.allocation = abs_capacity; + voldef->target.allocation = abs_capacity; pool->def->allocation += delta; pool->def->available -= delta; } @@ -2546,6 +2571,7 @@ storageVolResize(virStorageVolPtr obj, ret = 0; cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; @@ -2553,13 +2579,14 @@ storageVolResize(virStorageVolPtr obj, static int -storageVolWipePattern(virStorageVolPtr obj, +storageVolWipePattern(virStorageVolPtr volume, unsigned int algorithm, unsigned int flags) { virStorageBackendPtr backend; virStoragePoolObjPtr pool = NULL; - virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; int ret = -1; virCheckFlags(0, -1); @@ -2571,24 +2598,24 @@ storageVolWipePattern(virStorageVolPtr obj, return -1; } - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - - if (virStorageVolWipePatternEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolWipePatternEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - if (vol->in_use) { + if (voldef->in_use) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still in use."), - vol->name); + voldef->name); goto cleanup; } - if (vol->building) { + if (voldef->building) { virReportError(VIR_ERR_OPERATION_INVALID, _("volume '%s' is still being allocated."), - vol->name); + voldef->name); goto cleanup; } @@ -2598,16 +2625,17 @@ storageVolWipePattern(virStorageVolPtr obj, goto cleanup; } - if (backend->wipeVol(obj->conn, pool, vol, algorithm, flags) < 0) + if (backend->wipeVol(volume->conn, pool, voldef, algorithm, flags) < 0) goto cleanup; if (backend->refreshVol && - backend->refreshVol(obj->conn, pool, vol) < 0) + backend->refreshVol(volume->conn, pool, voldef) < 0) goto cleanup; ret = 0; cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; @@ -2622,37 +2650,40 @@ storageVolWipe(virStorageVolPtr obj, static int -storageVolGetInfoFlags(virStorageVolPtr obj, +storageVolGetInfoFlags(virStorageVolPtr volume, virStorageVolInfoPtr info, unsigned int flags) { virStoragePoolObjPtr pool; virStorageBackendPtr backend; - virStorageVolDefPtr vol; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; int ret = -1; virCheckFlags(VIR_STORAGE_VOL_GET_PHYSICAL, -1); - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return -1; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolGetInfoFlagsEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolGetInfoFlagsEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; if (backend->refreshVol && - backend->refreshVol(obj->conn, pool, vol) < 0) + backend->refreshVol(volume->conn, pool, voldef) < 0) goto cleanup; memset(info, 0, sizeof(*info)); - info->type = vol->type; - info->capacity = vol->target.capacity; + info->type = voldef->type; + info->capacity = voldef->target.capacity; if (flags & VIR_STORAGE_VOL_GET_PHYSICAL) - info->allocation = vol->target.physical; + info->allocation = voldef->target.physical; else - info->allocation = vol->target.allocation; + info->allocation = voldef->target.allocation; ret = 0; cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; } @@ -2667,50 +2698,56 @@ storageVolGetInfo(virStorageVolPtr obj, static char * -storageVolGetXMLDesc(virStorageVolPtr obj, +storageVolGetXMLDesc(virStorageVolPtr volume, unsigned int flags) { virStoragePoolObjPtr pool; virStorageBackendPtr backend; - virStorageVolDefPtr vol; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; char *ret = NULL; virCheckFlags(0, NULL); - if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, &backend))) return NULL; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolGetXMLDescEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolGetXMLDescEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; if (backend->refreshVol && - backend->refreshVol(obj->conn, pool, vol) < 0) + backend->refreshVol(volume->conn, pool, voldef) < 0) goto cleanup; - ret = virStorageVolDefFormat(pool->def, vol); + ret = virStorageVolDefFormat(pool->def, voldef); cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; } static char * -storageVolGetPath(virStorageVolPtr obj) +storageVolGetPath(virStorageVolPtr volume) { virStoragePoolObjPtr pool; - virStorageVolDefPtr vol; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; char *ret = NULL; - if (!(vol = virStorageVolDefFromVol(obj, &pool, NULL))) + if (!(volobj = virStorageVolObjFromVol(volume, &pool, NULL))) return NULL; + voldef = virPoolObjGetDef(volobj); - if (virStorageVolGetPathEnsureACL(obj->conn, pool->def, vol) < 0) + if (virStorageVolGetPathEnsureACL(volume->conn, pool->def, voldef) < 0) goto cleanup; - ignore_value(VIR_STRDUP(ret, vol->target.path)); + ignore_value(VIR_STRDUP(ret, voldef->target.path)); cleanup: + virPoolObjEndAPI(&volobj); virStoragePoolObjUnlock(pool); return ret; } diff --git a/src/storage/storage_util.c b/src/storage/storage_util.c index a665bac..644c3e7 100644 --- a/src/storage/storage_util.c +++ b/src/storage/storage_util.c @@ -3471,6 +3471,7 @@ virStorageBackendRefreshLocal(virConnectPtr conn ATTRIBUTE_UNUSED, struct statvfs sb; struct stat statbuf; virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; virStorageSourcePtr target = NULL; int direrr; int fd = -1, ret = -1; @@ -3539,8 +3540,11 @@ virStorageBackendRefreshLocal(virConnectPtr conn ATTRIBUTE_UNUSED, * An error message was raised, but we just continue. */ } - if (VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, vol) < 0) + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) goto cleanup; + + vol = NULL; + virPoolObjEndAPI(&volobj); } if (direrr < 0) goto cleanup; @@ -3656,6 +3660,7 @@ virStorageBackendSCSINewLun(virStoragePoolObjPtr pool, const char *dev) { virStorageVolDefPtr vol = NULL; + virPoolObjPtr volobj; char *devpath = NULL; int retval = -1; @@ -3727,10 +3732,11 @@ virStorageBackendSCSINewLun(virStoragePoolObjPtr pool, pool->def->capacity += vol->target.capacity; pool->def->allocation += vol->target.allocation; - if (VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, vol) < 0) + if (!(volobj = virStoragePoolObjAddVolume(pool, vol))) goto cleanup; vol = NULL; + virPoolObjEndAPI(&volobj); retval = 0; cleanup: diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 51605f3..fedf415 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -1016,7 +1016,9 @@ testOpenVolumesForPool(const char *file, size_t i; int num, ret = -1; xmlNodePtr *nodes = NULL; + xmlNodePtr node; virStorageVolDefPtr def = NULL; + virPoolObjPtr volobj = NULL; /* Find storage volumes */ if (virAsprintf(&vol_xpath, "/node/pool[%d]/volume", poolidx) < 0) @@ -1028,25 +1030,22 @@ testOpenVolumesForPool(const char *file, goto error; for (i = 0; i < num; i++) { - xmlNodePtr node = testParseXMLDocFromFile(nodes[i], file, - "volume"); - if (!node) + if (!(node = testParseXMLDocFromFile(nodes[i], file, "volume"))) goto error; - def = virStorageVolDefParseNode(pool->def, ctxt->doc, node, 0); - if (!def) + if (!(def = virStorageVolDefParseNode(pool->def, ctxt->doc, node, 0))) goto error; if (def->target.path == NULL) { if (virAsprintf(&def->target.path, "%s/%s", - pool->def->target.path, - def->name) == -1) + pool->def->target.path, def->name) < 0) goto error; } if (!def->key && VIR_STRDUP(def->key, def->target.path) < 0) goto error; - if (VIR_APPEND_ELEMENT_COPY(pool->volumes.objs, pool->volumes.count, def) < 0) + + if (!(volobj = virStoragePoolObjAddVolume(pool, def))) goto error; pool->def->allocation += def->target.allocation; @@ -1057,6 +1056,7 @@ testOpenVolumesForPool(const char *file, ret = 0; error: + virPoolObjEndAPI(&volobj); virStorageVolDefFree(def); VIR_FREE(nodes); return ret; @@ -4702,9 +4702,9 @@ testStoragePoolNumOfVolumes(virStoragePoolPtr pool) pool->name); testDriverUnlock(privconn); - if (privpool == NULL) { + if (!privpool) { virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; + return -1; } if (!virStoragePoolObjIsActive(privpool)) { @@ -4713,23 +4713,26 @@ testStoragePoolNumOfVolumes(virStoragePoolPtr pool) goto cleanup; } - ret = privpool->volumes.count; + /* NB: Neither pool->def nor aclfilter is being used for test purposes + * so last two args can be NULL */ + ret = virStoragePoolObjNumOfVolumes(privpool->volumes, pool->conn, + NULL, NULL); cleanup: - if (privpool) - virStoragePoolObjUnlock(privpool); + virStoragePoolObjUnlock(privpool); return ret; } + + static int testStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int maxnames) { + int ret = -1; testDriverPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; - size_t i = 0; - int n = 0; memset(names, 0, maxnames * sizeof(*names)); @@ -4738,47 +4741,39 @@ testStoragePoolListVolumes(virStoragePoolPtr pool, pool->name); testDriverUnlock(privconn); - if (privpool == NULL) { + if (!privpool) { virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; + return -1; } - if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), pool->name); goto cleanup; } - for (i = 0; i < privpool->volumes.count && n < maxnames; i++) { - if (VIR_STRDUP(names[n++], privpool->volumes.objs[i]->name) < 0) - goto cleanup; - } - - virStoragePoolObjUnlock(privpool); - return n; + /* NB: Neither pool->def nor aclfilter is being used for test purposes + * so those two args can be NULL */ + ret = virStoragePoolObjListVolumes(privpool->volumes, pool->conn, + NULL, NULL, names, maxnames); cleanup: - for (n = 0; n < maxnames; n++) - VIR_FREE(names[i]); - - memset(names, 0, maxnames * sizeof(*names)); - if (privpool) - virStoragePoolObjUnlock(privpool); - return -1; + virStoragePoolObjUnlock(privpool); + return ret; } + static int testStoragePoolListAllVolumes(virStoragePoolPtr obj, - virStorageVolPtr **vols, + virStorageVolPtr **volumes, unsigned int flags) { testDriverPtr privconn = obj->conn->privateData; virStoragePoolObjPtr pool; + virPoolObjPtr *volobjs = NULL; + size_t nvolobjs = 0; size_t i; - virStorageVolPtr *tmp_vols = NULL; - virStorageVolPtr vol = NULL; - int nvols = 0; + virStorageVolPtr *vols = NULL; int ret = -1; virCheckFlags(0, -1); @@ -4790,7 +4785,7 @@ testStoragePoolListAllVolumes(virStoragePoolPtr obj, if (!pool) { virReportError(VIR_ERR_NO_STORAGE_POOL, "%s", _("no storage pool with matching uuid")); - goto cleanup; + return -1; } if (!virStoragePoolObjIsActive(pool)) { @@ -4799,40 +4794,39 @@ testStoragePoolListAllVolumes(virStoragePoolPtr obj, goto cleanup; } - /* Just returns the volumes count */ - if (!vols) { - ret = pool->volumes.count; + if (virPoolObjTableCollect(pool->volumes, obj->conn, &volobjs, &nvolobjs, + NULL, NULL, flags) < 0) goto cleanup; - } - if (VIR_ALLOC_N(tmp_vols, pool->volumes.count + 1) < 0) - goto cleanup; - - for (i = 0; i < pool->volumes.count; i++) { - if (!(vol = virGetStorageVol(obj->conn, pool->def->name, - pool->volumes.objs[i]->name, - pool->volumes.objs[i]->key, - NULL, NULL))) + if (volumes) { + if (VIR_ALLOC_N(vols, nvolobjs + 1) < 0) goto cleanup; - tmp_vols[nvols++] = vol; - } - *vols = tmp_vols; - tmp_vols = NULL; - ret = nvols; + for (i = 0; i < nvolobjs; i++) { + virPoolObjPtr volobj = volobjs[i]; + virStorageVolDefPtr def; - cleanup: - if (tmp_vols) { - for (i = 0; i < nvols; i++) { - if (tmp_vols[i]) - virStorageVolFree(tmp_vols[i]); + virObjectLock(volobj); + def = virPoolObjGetDef(volobj); + vols[i] = virGetStorageVol(obj->conn, pool->def->name, + def->name, def->key, NULL, NULL); + virObjectUnlock(volobj); + + if (!vols[i]) + goto cleanup; } - VIR_FREE(tmp_vols); + + *volumes = vols; + vols = NULL; } - if (pool) - virStoragePoolObjUnlock(pool); + ret = nvolobjs; + cleanup: + virObjectListFree(vols); + virObjectListFreeCount(volobjs, nvolobjs); + + virStoragePoolObjUnlock(pool); return ret; } @@ -4842,7 +4836,8 @@ testStorageVolLookupByName(virStoragePoolPtr pool, { testDriverPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; virStorageVolPtr ret = NULL; testDriverLock(privconn); @@ -4862,19 +4857,19 @@ testStorageVolLookupByName(virStoragePoolPtr pool, goto cleanup; } - privvol = virStorageVolDefFindByName(privpool, name); - - if (!privvol) { + if (!(volobj = virStorageVolObjFindByName(privpool, name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), name); goto cleanup; } + voldef = virPoolObjGetDef(volobj); ret = virGetStorageVol(pool->conn, privpool->def->name, - privvol->name, privvol->key, + voldef->name, voldef->key, NULL, NULL); cleanup: + virPoolObjEndAPI(&volobj); if (privpool) virStoragePoolObjUnlock(privpool); return ret; @@ -4886,6 +4881,8 @@ testStorageVolLookupByKey(virConnectPtr conn, const char *key) { testDriverPtr privconn = conn->privateData; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; size_t i; virStorageVolPtr ret = NULL; @@ -4893,18 +4890,19 @@ testStorageVolLookupByKey(virConnectPtr conn, for (i = 0; i < privconn->pools.count; i++) { virStoragePoolObjLock(privconn->pools.objs[i]); if (virStoragePoolObjIsActive(privconn->pools.objs[i])) { - virStorageVolDefPtr privvol = - virStorageVolDefFindByKey(privconn->pools.objs[i], key); - - if (privvol) { - ret = virGetStorageVol(conn, - privconn->pools.objs[i]->def->name, - privvol->name, - privvol->key, - NULL, NULL); - virStoragePoolObjUnlock(privconn->pools.objs[i]); - break; - } + if (!(volobj = virStorageVolObjFindByKey(privconn->pools.objs[i], + key))) + continue; + voldef = virPoolObjGetDef(volobj); + + ret = virGetStorageVol(conn, + privconn->pools.objs[i]->def->name, + voldef->name, + voldef->key, + NULL, NULL); + virPoolObjEndAPI(&volobj); + virStoragePoolObjUnlock(privconn->pools.objs[i]); + break; } virStoragePoolObjUnlock(privconn->pools.objs[i]); } @@ -4922,6 +4920,8 @@ testStorageVolLookupByPath(virConnectPtr conn, const char *path) { testDriverPtr privconn = conn->privateData; + virPoolObjPtr volobj; + virStorageVolDefPtr voldef; size_t i; virStorageVolPtr ret = NULL; @@ -4929,18 +4929,19 @@ testStorageVolLookupByPath(virConnectPtr conn, for (i = 0; i < privconn->pools.count; i++) { virStoragePoolObjLock(privconn->pools.objs[i]); if (virStoragePoolObjIsActive(privconn->pools.objs[i])) { - virStorageVolDefPtr privvol = - virStorageVolDefFindByPath(privconn->pools.objs[i], path); - - if (privvol) { - ret = virGetStorageVol(conn, - privconn->pools.objs[i]->def->name, - privvol->name, - privvol->key, - NULL, NULL); - virStoragePoolObjUnlock(privconn->pools.objs[i]); - break; - } + if (!(volobj = virStorageVolObjFindByPath(privconn->pools.objs[i], + path))) + continue; + voldef = virPoolObjGetDef(volobj); + + ret = virGetStorageVol(conn, + privconn->pools.objs[i]->def->name, + voldef->name, + voldef->key, + NULL, NULL); + virPoolObjEndAPI(&volobj); + virStoragePoolObjUnlock(privconn->pools.objs[i]); + break; } virStoragePoolObjUnlock(privconn->pools.objs[i]); } @@ -4960,7 +4961,9 @@ testStorageVolCreateXML(virStoragePoolPtr pool, { testDriverPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol = NULL; + virStorageVolDefPtr voldef = NULL; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr objvoldef; virStorageVolPtr ret = NULL; virCheckFlags(0, NULL); @@ -4981,46 +4984,48 @@ testStorageVolCreateXML(virStoragePoolPtr pool, goto cleanup; } - privvol = virStorageVolDefParseString(privpool->def, xmldesc, 0); - if (privvol == NULL) + if (!(voldef = virStorageVolDefParseString(privpool->def, xmldesc, 0))) goto cleanup; - if (virStorageVolDefFindByName(privpool, privvol->name)) { + if ((volobj = virStorageVolObjFindByName(privpool, voldef->name))) { virReportError(VIR_ERR_OPERATION_FAILED, "%s", _("storage vol already exists")); goto cleanup; } /* Make sure enough space */ - if ((privpool->def->allocation + privvol->target.allocation) > + if ((privpool->def->allocation + voldef->target.allocation) > privpool->def->capacity) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not enough free space in pool for volume '%s'"), - privvol->name); + voldef->name); goto cleanup; } - if (virAsprintf(&privvol->target.path, "%s/%s", + if (virAsprintf(&voldef->target.path, "%s/%s", privpool->def->target.path, - privvol->name) == -1) + voldef->name) == -1) + goto cleanup; + + if (VIR_STRDUP(voldef->key, voldef->target.path) < 0) goto cleanup; - if (VIR_STRDUP(privvol->key, privvol->target.path) < 0 || - VIR_APPEND_ELEMENT_COPY(privpool->volumes.objs, - privpool->volumes.count, privvol) < 0) + if (!(volobj = virStoragePoolObjAddVolume(privpool, voldef))) goto cleanup; + VIR_STEAL_PTR(objvoldef, voldef); - privpool->def->allocation += privvol->target.allocation; + privpool->def->allocation += objvoldef->target.allocation; privpool->def->available = (privpool->def->capacity - privpool->def->allocation); - ret = virGetStorageVol(pool->conn, privpool->def->name, - privvol->name, privvol->key, - NULL, NULL); - privvol = NULL; + if (!(ret = virGetStorageVol(pool->conn, privpool->def->name, + objvoldef->name, objvoldef->key, + NULL, NULL))) + virStoragePoolObjRemoveVolume(privpool, &volobj); cleanup: - virStorageVolDefFree(privvol); + virPoolObjEndAPI(&volobj); + virStorageVolDefFree(voldef); if (privpool) virStoragePoolObjUnlock(privpool); return ret; @@ -5034,7 +5039,10 @@ testStorageVolCreateXMLFrom(virStoragePoolPtr pool, { testDriverPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol = NULL, origvol = NULL; + virStorageVolDefPtr voldef = NULL; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr objvoldef; + virPoolObjPtr origvolobj = NULL; virStorageVolPtr ret = NULL; virCheckFlags(0, NULL); @@ -5055,18 +5063,16 @@ testStorageVolCreateXMLFrom(virStoragePoolPtr pool, goto cleanup; } - privvol = virStorageVolDefParseString(privpool->def, xmldesc, 0); - if (privvol == NULL) + if (!(voldef = virStorageVolDefParseString(privpool->def, xmldesc, 0))) goto cleanup; - if (virStorageVolDefFindByName(privpool, privvol->name)) { + if ((volobj = virStorageVolObjFindByName(privpool, voldef->name))) { virReportError(VIR_ERR_OPERATION_FAILED, "%s", _("storage vol already exists")); goto cleanup; } - origvol = virStorageVolDefFindByName(privpool, clonevol->name); - if (!origvol) { + if (!(origvolobj = virStorageVolObjFindByName(privpool, clonevol->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), clonevol->name); @@ -5074,57 +5080,61 @@ testStorageVolCreateXMLFrom(virStoragePoolPtr pool, } /* Make sure enough space */ - if ((privpool->def->allocation + privvol->target.allocation) > + if ((privpool->def->allocation + voldef->target.allocation) > privpool->def->capacity) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not enough free space in pool for volume '%s'"), - privvol->name); + voldef->name); goto cleanup; } privpool->def->available = (privpool->def->capacity - privpool->def->allocation); - if (virAsprintf(&privvol->target.path, "%s/%s", + if (virAsprintf(&voldef->target.path, "%s/%s", privpool->def->target.path, - privvol->name) == -1) + voldef->name) == -1) goto cleanup; - if (VIR_STRDUP(privvol->key, privvol->target.path) < 0 || - VIR_APPEND_ELEMENT_COPY(privpool->volumes.objs, - privpool->volumes.count, privvol) < 0) + if (VIR_STRDUP(voldef->key, voldef->target.path) < 0) goto cleanup; - privpool->def->allocation += privvol->target.allocation; + if (!(volobj = virStoragePoolObjAddVolume(privpool, voldef))) + goto cleanup; + VIR_STEAL_PTR(objvoldef, voldef); + + privpool->def->allocation += objvoldef->target.allocation; privpool->def->available = (privpool->def->capacity - privpool->def->allocation); - ret = virGetStorageVol(pool->conn, privpool->def->name, - privvol->name, privvol->key, - NULL, NULL); - privvol = NULL; + if (!(ret = virGetStorageVol(pool->conn, privpool->def->name, + objvoldef->name, objvoldef->key, + NULL, NULL))) + virStoragePoolObjRemoveVolume(privpool, &volobj); cleanup: - virStorageVolDefFree(privvol); + virPoolObjEndAPI(&origvolobj); + virPoolObjEndAPI(&volobj); + virStorageVolDefFree(voldef); if (privpool) virStoragePoolObjUnlock(privpool); return ret; } static int -testStorageVolDelete(virStorageVolPtr vol, +testStorageVolDelete(virStorageVolPtr volume, unsigned int flags) { - testDriverPtr privconn = vol->conn->privateData; + testDriverPtr privconn = volume->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol; - size_t i; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; int ret = -1; virCheckFlags(0, -1); testDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, - vol->pool); + volume->pool); testDriverUnlock(privconn); if (privpool == NULL) { @@ -5132,38 +5142,32 @@ testStorageVolDelete(virStorageVolPtr vol, goto cleanup; } - - privvol = virStorageVolDefFindByName(privpool, vol->name); - - if (privvol == NULL) { - virReportError(VIR_ERR_NO_STORAGE_VOL, - _("no storage vol with matching name '%s'"), - vol->name); - goto cleanup; - } - if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("storage pool '%s' is not active"), vol->pool); + _("storage pool '%s' is not active"), volume->pool); goto cleanup; } + if (!(volobj = virPoolObjTableFindByName(privpool->volumes, + volume->name))) { + virReportError(VIR_ERR_NO_STORAGE_VOL, + _("no storage vol with matching name '%s'"), + volume->name); + goto cleanup; + } + voldef = virPoolObjGetDef(volobj); - privpool->def->allocation -= privvol->target.allocation; + privpool->def->allocation -= voldef->target.allocation; privpool->def->available = (privpool->def->capacity - privpool->def->allocation); - for (i = 0; i < privpool->volumes.count; i++) { - if (privpool->volumes.objs[i] == privvol) { - virStorageVolDefFree(privvol); - VIR_DELETE_ELEMENT(privpool->volumes.objs, i, privpool->volumes.count); - break; - } - } + virStoragePoolObjRemoveVolume(privpool, &volobj); + ret = 0; cleanup: + virPoolObjEndAPI(&volobj); if (privpool) virStoragePoolObjUnlock(privpool); return ret; @@ -5184,17 +5188,18 @@ static int testStorageVolumeTypeForPool(int pooltype) } static int -testStorageVolGetInfo(virStorageVolPtr vol, +testStorageVolGetInfo(virStorageVolPtr volume, virStorageVolInfoPtr info) { - testDriverPtr privconn = vol->conn->privateData; + testDriverPtr privconn = volume->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; int ret = -1; testDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, - vol->pool); + volume->pool); testDriverUnlock(privconn); if (privpool == NULL) { @@ -5202,47 +5207,48 @@ testStorageVolGetInfo(virStorageVolPtr vol, goto cleanup; } - privvol = virStorageVolDefFindByName(privpool, vol->name); - - if (privvol == NULL) { + if (!(volobj = virStorageVolObjFindByName(privpool, volume->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), - vol->name); + volume->name); goto cleanup; } + voldef = virPoolObjGetDef(volobj); if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("storage pool '%s' is not active"), vol->pool); + _("storage pool '%s' is not active"), volume->pool); goto cleanup; } memset(info, 0, sizeof(*info)); info->type = testStorageVolumeTypeForPool(privpool->def->type); - info->capacity = privvol->target.capacity; - info->allocation = privvol->target.allocation; + info->capacity = voldef->target.capacity; + info->allocation = voldef->target.allocation; ret = 0; cleanup: + virPoolObjEndAPI(&volobj); if (privpool) virStoragePoolObjUnlock(privpool); return ret; } static char * -testStorageVolGetXMLDesc(virStorageVolPtr vol, +testStorageVolGetXMLDesc(virStorageVolPtr volume, unsigned int flags) { - testDriverPtr privconn = vol->conn->privateData; + testDriverPtr privconn = volume->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; char *ret = NULL; virCheckFlags(0, NULL); testDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, - vol->pool); + volume->pool); testDriverUnlock(privconn); if (privpool == NULL) { @@ -5250,40 +5256,41 @@ testStorageVolGetXMLDesc(virStorageVolPtr vol, goto cleanup; } - privvol = virStorageVolDefFindByName(privpool, vol->name); - - if (privvol == NULL) { + if (!(volobj = virStorageVolObjFindByName(privpool, volume->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), - vol->name); + volume->name); goto cleanup; } + voldef = virPoolObjGetDef(volobj); if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("storage pool '%s' is not active"), vol->pool); + _("storage pool '%s' is not active"), volume->pool); goto cleanup; } - ret = virStorageVolDefFormat(privpool->def, privvol); + ret = virStorageVolDefFormat(privpool->def, voldef); cleanup: + virPoolObjEndAPI(&volobj); if (privpool) virStoragePoolObjUnlock(privpool); return ret; } static char * -testStorageVolGetPath(virStorageVolPtr vol) +testStorageVolGetPath(virStorageVolPtr volume) { - testDriverPtr privconn = vol->conn->privateData; + testDriverPtr privconn = volume->conn->privateData; virStoragePoolObjPtr privpool; - virStorageVolDefPtr privvol; + virPoolObjPtr volobj = NULL; + virStorageVolDefPtr voldef; char *ret = NULL; testDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, - vol->pool); + volume->pool); testDriverUnlock(privconn); if (privpool == NULL) { @@ -5291,24 +5298,24 @@ testStorageVolGetPath(virStorageVolPtr vol) goto cleanup; } - privvol = virStorageVolDefFindByName(privpool, vol->name); - - if (privvol == NULL) { + if (!(volobj = virStorageVolObjFindByName(privpool, volume->name))) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), - vol->name); + volume->name); goto cleanup; } + voldef = virPoolObjGetDef(volobj); if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("storage pool '%s' is not active"), vol->pool); + _("storage pool '%s' is not active"), volume->pool); goto cleanup; } - ignore_value(VIR_STRDUP(ret, privvol->target.path)); + ignore_value(VIR_STRDUP(ret, voldef->target.path)); cleanup: + virPoolObjEndAPI(&volobj); if (privpool) virStoragePoolObjUnlock(privpool); return ret; -- 2.7.4

Use the virPoolObj[Table] object management model in order to manage the Network objects. While making the adjustments to use the new model, there are some code formatting adjustments that were also made with the goal to follow more recent code flow and layout. For API's that were static, rather than use "virNetwork*", the names were converted to be "network*" - makes it easier to determine while reading code what is local and what is "outside" the perveyance of the module. All network object management API's have their own virnetworkobj entry points now instead of being mashed in with network_conf Signed-off-by: John Ferlan <jferlan@redhat.com> --- po/POTFILES.in | 1 + src/Makefile.am | 1 + src/conf/network_conf.c | 1308 +----------------------- src/conf/network_conf.h | 132 +-- src/conf/virnetworkobj.c | 1166 ++++++++++++++++++++++ src/conf/virnetworkobj.h | 121 +++ src/libvirt_private.syms | 60 +- src/network/bridge_driver.c | 1812 ++++++++++++++++++---------------- src/network/bridge_driver.h | 11 +- src/network/bridge_driver_platform.h | 3 +- src/test/test_driver.c | 399 ++++---- tests/networkxml2conftest.c | 18 +- 12 files changed, 2521 insertions(+), 2511 deletions(-) create mode 100644 src/conf/virnetworkobj.c create mode 100644 src/conf/virnetworkobj.h diff --git a/po/POTFILES.in b/po/POTFILES.in index a2e961f..98fc000 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -42,6 +42,7 @@ src/conf/snapshot_conf.c src/conf/storage_conf.c src/conf/virchrdev.c src/conf/virdomainobjlist.c +src/conf/virnetworkobj.c src/conf/virnodedeviceobj.c src/conf/virnwfilterobj.c src/conf/virpoolobj.c diff --git a/src/Makefile.am b/src/Makefile.am index 2d95020..41e384d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -360,6 +360,7 @@ SECRET_EVENT_SOURCES = \ # Network driver generic impl APIs NETWORK_CONF_SOURCES = \ conf/network_conf.c conf/network_conf.h \ + conf/virnetworkobj.h conf/virnetworkobj.c \ conf/networkcommon_conf.c conf/networkcommon_conf.h # Network filter driver generic impl APIs diff --git a/src/conf/network_conf.c b/src/conf/network_conf.c index 0e20dac..9c98eea 100644 --- a/src/conf/network_conf.c +++ b/src/conf/network_conf.c @@ -29,7 +29,6 @@ #include <sys/stat.h> #include <fcntl.h> #include <string.h> -#include <dirent.h> #include "virerror.h" #include "datatypes.h" @@ -46,14 +45,6 @@ #include "virstring.h" #define VIR_FROM_THIS VIR_FROM_NETWORK -/* currently, /sbin/tc implementation allows up to 16 bits for minor class size */ -#define CLASS_ID_BITMAP_SIZE (1<<16) - -struct _virNetworkObjList { - virObjectLockable parent; - - virHashTablePtr objs; -}; VIR_ENUM_IMPL(virNetworkForward, VIR_NETWORK_FORWARD_LAST, @@ -79,206 +70,6 @@ VIR_ENUM_IMPL(virNetworkForwardDriverName, VIR_ENUM_IMPL(virNetworkTaint, VIR_NETWORK_TAINT_LAST, "hook-script"); -static virClassPtr virNetworkObjClass; -static virClassPtr virNetworkObjListClass; -static void virNetworkObjDispose(void *obj); -static void virNetworkObjListDispose(void *obj); - -static int virNetworkObjOnceInit(void) -{ - if (!(virNetworkObjClass = virClassNew(virClassForObjectLockable(), - "virNetworkObj", - sizeof(virNetworkObj), - virNetworkObjDispose))) - return -1; - - if (!(virNetworkObjListClass = virClassNew(virClassForObjectLockable(), - "virNetworkObjList", - sizeof(virNetworkObjList), - virNetworkObjListDispose))) - return -1; - return 0; -} - - -VIR_ONCE_GLOBAL_INIT(virNetworkObj) - -virNetworkObjPtr -virNetworkObjNew(void) -{ - virNetworkObjPtr net; - - if (virNetworkObjInitialize() < 0) - return NULL; - - if (!(net = virObjectLockableNew(virNetworkObjClass))) - return NULL; - - if (!(net->class_id = virBitmapNew(CLASS_ID_BITMAP_SIZE))) - goto error; - - /* The first three class IDs are already taken */ - ignore_value(virBitmapSetBit(net->class_id, 0)); - ignore_value(virBitmapSetBit(net->class_id, 1)); - ignore_value(virBitmapSetBit(net->class_id, 2)); - - return net; - - error: - virObjectUnref(net); - return NULL; -} - -void -virNetworkObjEndAPI(virNetworkObjPtr *net) -{ - if (!*net) - return; - - virObjectUnlock(*net); - virObjectUnref(*net); - *net = NULL; -} - -virNetworkObjListPtr virNetworkObjListNew(void) -{ - virNetworkObjListPtr nets; - - if (virNetworkObjInitialize() < 0) - return NULL; - - if (!(nets = virObjectLockableNew(virNetworkObjListClass))) - return NULL; - - if (!(nets->objs = virHashCreate(50, virObjectFreeHashData))) { - virObjectUnref(nets); - return NULL; - } - - return nets; -} - -/** - * virNetworkObjFindByUUIDLocked: - * @nets: list of network objects - * @uuid: network uuid to find - * - * This functions requires @nets to be locked already! - * - * Returns: not locked, but ref'd network object. - */ -virNetworkObjPtr -virNetworkObjFindByUUIDLocked(virNetworkObjListPtr nets, - const unsigned char *uuid) -{ - virNetworkObjPtr ret = NULL; - char uuidstr[VIR_UUID_STRING_BUFLEN]; - - virUUIDFormat(uuid, uuidstr); - - ret = virHashLookup(nets->objs, uuidstr); - if (ret) - virObjectRef(ret); - return ret; -} - -/** - * virNetworkObjFindByUUID: - * @nets: list of network objects - * @uuid: network uuid to find - * - * This functions locks @nets and find network object which - * corresponds to @uuid. - * - * Returns: locked and ref'd network object. - */ -virNetworkObjPtr -virNetworkObjFindByUUID(virNetworkObjListPtr nets, - const unsigned char *uuid) -{ - virNetworkObjPtr ret; - - virObjectLock(nets); - ret = virNetworkObjFindByUUIDLocked(nets, uuid); - virObjectUnlock(nets); - if (ret) - virObjectLock(ret); - return ret; -} - -static int -virNetworkObjSearchName(const void *payload, - const void *name ATTRIBUTE_UNUSED, - const void *data) -{ - virNetworkObjPtr net = (virNetworkObjPtr) payload; - int want = 0; - - virObjectLock(net); - if (STREQ(net->def->name, (const char *)data)) - want = 1; - virObjectUnlock(net); - return want; -} - -/* - * virNetworkObjFindByNameLocked: - * @nets: list of network objects - * @name: network name to find - * - * This functions requires @nets to be locked already! - * - * Returns: not locked, but ref'd network object. - */ -virNetworkObjPtr -virNetworkObjFindByNameLocked(virNetworkObjListPtr nets, - const char *name) -{ - virNetworkObjPtr ret = NULL; - - ret = virHashSearch(nets->objs, virNetworkObjSearchName, name); - if (ret) - virObjectRef(ret); - return ret; -} - -/** - * virNetworkObjFindByName: - * @nets: list of network objects - * @name: network name to find - * - * This functions locks @nets and find network object which - * corresponds to @name. - * - * Returns: locked and ref'd network object. - */ -virNetworkObjPtr -virNetworkObjFindByName(virNetworkObjListPtr nets, - const char *name) -{ - virNetworkObjPtr ret; - - virObjectLock(nets); - ret = virNetworkObjFindByNameLocked(nets, name); - virObjectUnlock(nets); - if (ret) - virObjectLock(ret); - return ret; -} - -bool -virNetworkObjTaint(virNetworkObjPtr obj, - virNetworkTaintFlags taint) -{ - unsigned int flag = (1 << taint); - - if (obj->taint & flag) - return false; - - obj->taint |= flag; - return true; -} - static void virPortGroupDefClear(virPortGroupDefPtr def) @@ -398,8 +189,9 @@ virNetworkForwardDefClear(virNetworkForwardDefPtr def) } void -virNetworkDefFree(virNetworkDefPtr def) +virNetworkDefFree(void *opaque) { + virNetworkDefPtr def = opaque; size_t i; if (!def) @@ -435,273 +227,6 @@ virNetworkDefFree(virNetworkDefPtr def) VIR_FREE(def); } -static void -virNetworkObjDispose(void *obj) -{ - virNetworkObjPtr net = obj; - - virNetworkDefFree(net->def); - virNetworkDefFree(net->newDef); - virBitmapFree(net->class_id); -} - -static void -virNetworkObjListDispose(void *obj) -{ - virNetworkObjListPtr nets = obj; - - virHashFree(nets->objs); -} - -/* - * virNetworkObjAssignDef: - * @network: the network object to update - * @def: the new NetworkDef (will be consumed by this function) - * @live: is this new def the "live" version, or the "persistent" version - * - * Replace the appropriate copy of the given network's def or newDef - * with def. Use "live" and current state of the network to determine - * which to replace and what to do with the old defs. When a non-live - * def is set, indicate that the network is now persistent. - * - * NB: a persistent network can be made transient by calling with: - * virNetworkObjAssignDef(network, NULL, false) (i.e. set the - * persistent def to NULL) - * - */ -void -virNetworkObjAssignDef(virNetworkObjPtr network, - virNetworkDefPtr def, - bool live) -{ - if (live) { - /* before setting new live def, save (into newDef) any - * existing persistent (!live) def to be restored when the - * network is destroyed, unless there is one already saved. - */ - if (network->persistent && !network->newDef) - network->newDef = network->def; - else - virNetworkDefFree(network->def); - network->def = def; - } else { /* !live */ - virNetworkDefFree(network->newDef); - if (virNetworkObjIsActive(network)) { - /* save new configuration to be restored on network - * shutdown, leaving current live def alone - */ - network->newDef = def; - } else { /* !live and !active */ - if (network->def && !network->persistent) { - /* network isn't (yet) marked active or persistent, - * but already has a "live" def set. This means we are - * currently setting the persistent def as a part of - * the process of starting the network, so we need to - * preserve the "not yet live" def in network->def. - */ - network->newDef = def; - } else { - /* either there is no live def set, or this network - * was already set as persistent, so the proper thing - * is to overwrite network->def. - */ - network->newDef = NULL; - virNetworkDefFree(network->def); - network->def = def; - } - } - network->persistent = !!def; - } -} - -/* - * If flags & VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE then this will - * refuse updating an existing def if the current def is live - * - * If flags & VIR_NETWORK_OBJ_LIST_ADD_LIVE then the @def being - * added is assumed to represent a live config, not a future - * inactive config - * - * If flags is zero, network is considered as inactive and persistent. - */ -static virNetworkObjPtr -virNetworkAssignDefLocked(virNetworkObjListPtr nets, - virNetworkDefPtr def, - unsigned int flags) -{ - virNetworkObjPtr network; - virNetworkObjPtr ret = NULL; - char uuidstr[VIR_UUID_STRING_BUFLEN]; - - /* See if a network with matching UUID already exists */ - if ((network = virNetworkObjFindByUUIDLocked(nets, def->uuid))) { - virObjectLock(network); - /* UUID matches, but if names don't match, refuse it */ - if (STRNEQ(network->def->name, def->name)) { - virUUIDFormat(network->def->uuid, uuidstr); - virReportError(VIR_ERR_OPERATION_FAILED, - _("network '%s' is already defined with uuid %s"), - network->def->name, uuidstr); - goto cleanup; - } - - if (flags & VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE) { - /* UUID & name match, but if network is already active, refuse it */ - if (virNetworkObjIsActive(network)) { - virReportError(VIR_ERR_OPERATION_INVALID, - _("network is already active as '%s'"), - network->def->name); - goto cleanup; - } - } - - virNetworkObjAssignDef(network, - def, - !!(flags & VIR_NETWORK_OBJ_LIST_ADD_LIVE)); - } else { - /* UUID does not match, but if a name matches, refuse it */ - if ((network = virNetworkObjFindByNameLocked(nets, def->name))) { - virObjectLock(network); - virUUIDFormat(network->def->uuid, uuidstr); - virReportError(VIR_ERR_OPERATION_FAILED, - _("network '%s' already exists with uuid %s"), - def->name, uuidstr); - goto cleanup; - } - - if (!(network = virNetworkObjNew())) - goto cleanup; - - virObjectLock(network); - - virUUIDFormat(def->uuid, uuidstr); - if (virHashAddEntry(nets->objs, uuidstr, network) < 0) - goto cleanup; - - network->def = def; - network->persistent = !(flags & VIR_NETWORK_OBJ_LIST_ADD_LIVE); - virObjectRef(network); - } - - ret = network; - network = NULL; - - cleanup: - virNetworkObjEndAPI(&network); - return ret; -} - -/* - * virNetworkAssignDef: - * @nets: list of all networks - * @def: the new NetworkDef (will be consumed by this function iff successful) - * @flags: bitwise-OR of VIR_NETWORK_OBJ_LIST_ADD_* flags - * - * Either replace the appropriate copy of the NetworkDef with name - * matching def->name or, if not found, create a new NetworkObj with - * def. For an existing network, use "live" and current state of the - * network to determine which to replace. - * - * Look at virNetworkAssignDefLocked() for @flags description. - * - * Returns NULL on error, virNetworkObjPtr on success. - */ -virNetworkObjPtr -virNetworkAssignDef(virNetworkObjListPtr nets, - virNetworkDefPtr def, - unsigned int flags) -{ - virNetworkObjPtr network; - - virObjectLock(nets); - network = virNetworkAssignDefLocked(nets, def, flags); - virObjectUnlock(nets); - return network; -} - -/* - * virNetworkObjSetDefTransient: - * @network: network object pointer - * @live: if true, run this operation even for an inactive network. - * this allows freely updated network->def with runtime defaults - * before starting the network, which will be discarded on network - * shutdown. Any cleanup paths need to be sure to handle newDef if - * the network is never started. - * - * Mark the active network config as transient. Ensures live-only update - * operations do not persist past network destroy. - * - * Returns 0 on success, -1 on failure - */ -int -virNetworkObjSetDefTransient(virNetworkObjPtr network, bool live) -{ - if (!virNetworkObjIsActive(network) && !live) - return 0; - - if (!network->persistent || network->newDef) - return 0; - - network->newDef = virNetworkDefCopy(network->def, VIR_NETWORK_XML_INACTIVE); - return network->newDef ? 0 : -1; -} - -/* virNetworkObjUnsetDefTransient: - * - * This *undoes* what virNetworkObjSetDefTransient did. - */ -void -virNetworkObjUnsetDefTransient(virNetworkObjPtr network) -{ - if (network->newDef) { - virNetworkDefFree(network->def); - network->def = network->newDef; - network->newDef = NULL; - } -} - -/* - * virNetworkObjGetPersistentDef: - * @network: network object pointer - * - * Return the persistent network configuration. If network is transient, - * return the running config. - * - * Returns NULL on error, virNetworkDefPtr on success. - */ -virNetworkDefPtr -virNetworkObjGetPersistentDef(virNetworkObjPtr network) -{ - if (network->newDef) - return network->newDef; - else - return network->def; -} - -/* - * virNetworkObjReplacePersistentDef: - * @network: network object pointer - * @def: new virNetworkDef to replace current persistent config - * - * Replace the "persistent" network configuration with the given new - * virNetworkDef. This pays attention to whether or not the network - * is active. - * - * Returns -1 on error, 0 on success - */ -int -virNetworkObjReplacePersistentDef(virNetworkObjPtr network, - virNetworkDefPtr def) -{ - if (virNetworkObjIsActive(network)) { - virNetworkDefFree(network->newDef); - network->newDef = def; - } else { - virNetworkDefFree(network->def); - network->def = def; - } - return 0; -} /* * virNetworkDefCopy: @@ -733,64 +258,6 @@ virNetworkDefCopy(virNetworkDefPtr def, unsigned int flags) return newDef; } -/* - * virNetworkConfigChangeSetup: - * - * 1) checks whether network state is consistent with the requested - * type of modification. - * - * 3) make sure there are separate "def" and "newDef" copies of - * networkDef if appropriate. - * - * Returns 0 on success, -1 on error. - */ -int -virNetworkConfigChangeSetup(virNetworkObjPtr network, unsigned int flags) -{ - bool isActive; - int ret = -1; - - isActive = virNetworkObjIsActive(network); - - if (!isActive && (flags & VIR_NETWORK_UPDATE_AFFECT_LIVE)) { - virReportError(VIR_ERR_OPERATION_INVALID, "%s", - _("network is not running")); - goto cleanup; - } - - if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) { - if (!network->persistent) { - virReportError(VIR_ERR_OPERATION_INVALID, "%s", - _("cannot change persistent config of a " - "transient network")); - goto cleanup; - } - /* this should already have been done by the driver, but do it - * anyway just in case. - */ - if (isActive && (virNetworkObjSetDefTransient(network, false) < 0)) - goto cleanup; - } - - ret = 0; - cleanup: - return ret; -} - -void virNetworkRemoveInactive(virNetworkObjListPtr nets, - virNetworkObjPtr net) -{ - char uuidstr[VIR_UUID_STRING_BUFLEN]; - - virUUIDFormat(net->def->uuid, uuidstr); - virObjectRef(net); - virObjectUnlock(net); - virObjectLock(nets); - virObjectLock(net); - virHashRemoveEntry(nets->objs, uuidstr); - virObjectUnlock(nets); - virObjectUnref(net); -} /* return ips[index], or NULL if there aren't enough ips */ virNetworkIPDefPtr @@ -2092,7 +1559,7 @@ virNetworkForwardDefParseXML(const char *networkName, return ret; } -static virNetworkDefPtr +virNetworkDefPtr virNetworkDefParseXML(xmlXPathContextPtr ctxt) { virNetworkDefPtr def; @@ -3071,45 +2538,6 @@ virNetworkDefFormat(const virNetworkDef *def, return NULL; } -static char * -virNetworkObjFormat(virNetworkObjPtr net, - unsigned int flags) -{ - virBuffer buf = VIR_BUFFER_INITIALIZER; - char *class_id = virBitmapFormat(net->class_id); - size_t i; - - if (!class_id) - goto error; - - virBufferAddLit(&buf, "<networkstatus>\n"); - virBufferAdjustIndent(&buf, 2); - virBufferAsprintf(&buf, "<class_id bitmap='%s'/>\n", class_id); - virBufferAsprintf(&buf, "<floor sum='%llu'/>\n", net->floor_sum); - VIR_FREE(class_id); - - for (i = 0; i < VIR_NETWORK_TAINT_LAST; i++) { - if (net->taint & (1 << i)) - virBufferAsprintf(&buf, "<taint flag='%s'/>\n", - virNetworkTaintTypeToString(i)); - } - - if (virNetworkDefFormatBuf(&buf, net->def, flags) < 0) - goto error; - - virBufferAdjustIndent(&buf, -2); - virBufferAddLit(&buf, "</networkstatus>"); - - if (virBufferCheckError(&buf) < 0) - goto error; - - return virBufferContentAndReset(&buf); - - error: - virBufferFreeAndReset(&buf); - return NULL; -} - const char * virNetworkDefForwardIf(const virNetworkDef *def, size_t n) { @@ -3181,356 +2609,20 @@ int virNetworkSaveConfig(const char *configDir, } -int virNetworkSaveStatus(const char *statusDir, - virNetworkObjPtr network) + +char * +virNetworkConfigFile(const char *dir, + const char *name) { - int ret = -1; - int flags = 0; - char *xml; + char *ret = NULL; - if (!(xml = virNetworkObjFormat(network, flags))) - goto cleanup; + ignore_value(virAsprintf(&ret, "%s/%s.xml", dir, name)); + return ret; +} - if (virNetworkSaveXML(statusDir, network->def, xml)) - goto cleanup; - ret = 0; - cleanup: - VIR_FREE(xml); - return ret; -} - -virNetworkObjPtr -virNetworkLoadState(virNetworkObjListPtr nets, - const char *stateDir, - const char *name) -{ - char *configFile = NULL; - virNetworkDefPtr def = NULL; - virNetworkObjPtr net = NULL; - xmlDocPtr xml = NULL; - xmlNodePtr node = NULL, *nodes = NULL; - xmlXPathContextPtr ctxt = NULL; - virBitmapPtr class_id_map = NULL; - unsigned long long floor_sum_val = 0; - unsigned int taint = 0; - int n; - size_t i; - - - if ((configFile = virNetworkConfigFile(stateDir, name)) == NULL) - goto error; - - if (!(xml = virXMLParseCtxt(configFile, NULL, _("(network status)"), &ctxt))) - goto error; - - if (!(node = virXPathNode("//network", ctxt))) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Could not find any 'network' element in status file")); - goto error; - } - - /* parse the definition first */ - ctxt->node = node; - if (!(def = virNetworkDefParseXML(ctxt))) - goto error; - - if (STRNEQ(name, def->name)) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Network config filename '%s'" - " does not match network name '%s'"), - configFile, def->name); - goto error; - } - - /* now parse possible status data */ - node = xmlDocGetRootElement(xml); - if (xmlStrEqual(node->name, BAD_CAST "networkstatus")) { - /* Newer network status file. Contains useful - * info which are not to be found in bare config XML */ - char *class_id = NULL; - char *floor_sum = NULL; - - ctxt->node = node; - if ((class_id = virXPathString("string(./class_id[1]/@bitmap)", ctxt))) { - if (virBitmapParse(class_id, &class_id_map, - CLASS_ID_BITMAP_SIZE) < 0) { - VIR_FREE(class_id); - goto error; - } - } - VIR_FREE(class_id); - - floor_sum = virXPathString("string(./floor[1]/@sum)", ctxt); - if (floor_sum && - virStrToLong_ull(floor_sum, NULL, 10, &floor_sum_val) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Malformed 'floor_sum' attribute: %s"), - floor_sum); - VIR_FREE(floor_sum); - goto error; - } - VIR_FREE(floor_sum); - - if ((n = virXPathNodeSet("./taint", ctxt, &nodes)) < 0) - goto error; - - for (i = 0; i < n; i++) { - char *str = virXMLPropString(nodes[i], "flag"); - if (str) { - int flag = virNetworkTaintTypeFromString(str); - if (flag < 0) { - virReportError(VIR_ERR_CONFIG_UNSUPPORTED, - _("Unknown taint flag %s"), str); - VIR_FREE(str); - goto error; - } - VIR_FREE(str); - /* Compute taint mask here. The network object does not - * exist yet, so we can't use virNetworkObjtTaint. */ - taint |= (1 << flag); - } - } - VIR_FREE(nodes); - } - - /* create the object */ - if (!(net = virNetworkAssignDef(nets, def, VIR_NETWORK_OBJ_LIST_ADD_LIVE))) - goto error; - /* do not put any "goto error" below this comment */ - - /* assign status data stored in the network object */ - if (class_id_map) { - virBitmapFree(net->class_id); - net->class_id = class_id_map; - } - - if (floor_sum_val > 0) - net->floor_sum = floor_sum_val; - - net->taint = taint; - net->active = 1; /* any network with a state file is by definition active */ - - cleanup: - VIR_FREE(configFile); - xmlFreeDoc(xml); - xmlXPathFreeContext(ctxt); - return net; - - error: - VIR_FREE(nodes); - virBitmapFree(class_id_map); - virNetworkDefFree(def); - goto cleanup; -} - -virNetworkObjPtr virNetworkLoadConfig(virNetworkObjListPtr nets, - const char *configDir, - const char *autostartDir, - const char *name) -{ - char *configFile = NULL, *autostartLink = NULL; - virNetworkDefPtr def = NULL; - virNetworkObjPtr net; - int autostart; - - if ((configFile = virNetworkConfigFile(configDir, name)) == NULL) - goto error; - if ((autostartLink = virNetworkConfigFile(autostartDir, name)) == NULL) - goto error; - - if ((autostart = virFileLinkPointsTo(autostartLink, configFile)) < 0) - goto error; - - if (!(def = virNetworkDefParseFile(configFile))) - goto error; - - if (STRNEQ(name, def->name)) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Network config filename '%s'" - " does not match network name '%s'"), - configFile, def->name); - goto error; - } - - if (def->forward.type == VIR_NETWORK_FORWARD_NONE || - def->forward.type == VIR_NETWORK_FORWARD_NAT || - def->forward.type == VIR_NETWORK_FORWARD_ROUTE || - def->forward.type == VIR_NETWORK_FORWARD_OPEN) { - - if (!def->mac_specified) { - virNetworkSetBridgeMacAddr(def); - virNetworkSaveConfig(configDir, def); - } - } else { - /* Throw away MAC address for other forward types, - * which could have been generated by older libvirt RPMs */ - def->mac_specified = false; - } - - if (!(net = virNetworkAssignDef(nets, def, 0))) - goto error; - - net->autostart = autostart; - - VIR_FREE(configFile); - VIR_FREE(autostartLink); - - return net; - - error: - VIR_FREE(configFile); - VIR_FREE(autostartLink); - virNetworkDefFree(def); - return NULL; -} - - -int -virNetworkLoadAllState(virNetworkObjListPtr nets, - const char *stateDir) -{ - DIR *dir; - struct dirent *entry; - int ret = -1; - int rc; - - if ((rc = virDirOpenIfExists(&dir, stateDir)) <= 0) - return rc; - - while ((ret = virDirRead(dir, &entry, stateDir)) > 0) { - virNetworkObjPtr net; - - if (!virFileStripSuffix(entry->d_name, ".xml")) - continue; - - net = virNetworkLoadState(nets, stateDir, entry->d_name); - virNetworkObjEndAPI(&net); - } - - VIR_DIR_CLOSE(dir); - return ret; -} - - -int virNetworkLoadAllConfigs(virNetworkObjListPtr nets, - const char *configDir, - const char *autostartDir) -{ - DIR *dir; - struct dirent *entry; - int ret = -1; - int rc; - - if ((rc = virDirOpenIfExists(&dir, configDir)) <= 0) - return rc; - - while ((ret = virDirRead(dir, &entry, configDir)) > 0) { - virNetworkObjPtr net; - - if (!virFileStripSuffix(entry->d_name, ".xml")) - continue; - - /* NB: ignoring errors, so one malformed config doesn't - kill the whole process */ - net = virNetworkLoadConfig(nets, - configDir, - autostartDir, - entry->d_name); - virNetworkObjEndAPI(&net); - } - - VIR_DIR_CLOSE(dir); - return ret; -} - -int virNetworkDeleteConfig(const char *configDir, - const char *autostartDir, - virNetworkObjPtr net) -{ - char *configFile = NULL; - char *autostartLink = NULL; - int ret = -1; - - if ((configFile = virNetworkConfigFile(configDir, net->def->name)) == NULL) - goto error; - if ((autostartLink = virNetworkConfigFile(autostartDir, net->def->name)) == NULL) - goto error; - - /* Not fatal if this doesn't work */ - unlink(autostartLink); - net->autostart = 0; - - if (unlink(configFile) < 0) { - virReportSystemError(errno, - _("cannot remove config file '%s'"), - configFile); - goto error; - } - - ret = 0; - - error: - VIR_FREE(configFile); - VIR_FREE(autostartLink); - return ret; -} - -char *virNetworkConfigFile(const char *dir, - const char *name) -{ - char *ret = NULL; - - ignore_value(virAsprintf(&ret, "%s/%s.xml", dir, name)); - return ret; -} - -struct virNetworkBridgeInUseHelperData { - const char *bridge; - const char *skipname; -}; - -static int -virNetworkBridgeInUseHelper(const void *payload, - const void *name ATTRIBUTE_UNUSED, - const void *opaque) -{ - int ret; - virNetworkObjPtr net = (virNetworkObjPtr) payload; - const struct virNetworkBridgeInUseHelperData *data = opaque; - - virObjectLock(net); - if (data->skipname && - ((net->def && STREQ(net->def->name, data->skipname)) || - (net->newDef && STREQ(net->newDef->name, data->skipname)))) - ret = 0; - else if ((net->def && net->def->bridge && - STREQ(net->def->bridge, data->bridge)) || - (net->newDef && net->newDef->bridge && - STREQ(net->newDef->bridge, data->bridge))) - ret = 1; - else - ret = 0; - virObjectUnlock(net); - return ret; -} - -int virNetworkBridgeInUse(virNetworkObjListPtr nets, - const char *bridge, - const char *skipname) -{ - virNetworkObjPtr obj; - struct virNetworkBridgeInUseHelperData data = {bridge, skipname}; - - virObjectLock(nets); - obj = virHashSearch(nets->objs, virNetworkBridgeInUseHelper, &data); - virObjectUnlock(nets); - - return obj != NULL; -} - - -void virNetworkSetBridgeMacAddr(virNetworkDefPtr def) +void +virNetworkSetBridgeMacAddr(virNetworkDefPtr def) { if (!def->mac_specified) { /* if the bridge doesn't have a mac address explicitly defined, @@ -4449,377 +3541,3 @@ virNetworkDefUpdateSection(virNetworkDefPtr def, xmlXPathFreeContext(ctxt); return ret; } - -/* - * virNetworkObjUpdate: - * - * Apply the supplied update to the given virNetworkObj. Except for - * @network pointing to an actual network object rather than the - * opaque virNetworkPtr, parameters are identical to the public API - * virNetworkUpdate. - * - * The original virNetworkDefs are copied, and all modifications made - * to these copies. The originals are replaced with the copies only - * after success has been guaranteed. - * - * Returns: -1 on error, 0 on success. - */ -int -virNetworkObjUpdate(virNetworkObjPtr network, - unsigned int command, /* virNetworkUpdateCommand */ - unsigned int section, /* virNetworkUpdateSection */ - int parentIndex, - const char *xml, - unsigned int flags) /* virNetworkUpdateFlags */ -{ - int ret = -1; - virNetworkDefPtr livedef = NULL, configdef = NULL; - - /* normalize config data, and check for common invalid requests. */ - if (virNetworkConfigChangeSetup(network, flags) < 0) - goto cleanup; - - if (flags & VIR_NETWORK_UPDATE_AFFECT_LIVE) { - virNetworkDefPtr checkdef; - - /* work on a copy of the def */ - if (!(livedef = virNetworkDefCopy(network->def, 0))) - goto cleanup; - if (virNetworkDefUpdateSection(livedef, command, section, - parentIndex, xml, flags) < 0) { - goto cleanup; - } - /* run a final format/parse cycle to make sure we didn't - * add anything illegal to the def - */ - if (!(checkdef = virNetworkDefCopy(livedef, 0))) - goto cleanup; - virNetworkDefFree(checkdef); - } - - if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) { - virNetworkDefPtr checkdef; - - /* work on a copy of the def */ - if (!(configdef = virNetworkDefCopy(virNetworkObjGetPersistentDef(network), - VIR_NETWORK_XML_INACTIVE))) { - goto cleanup; - } - if (virNetworkDefUpdateSection(configdef, command, section, - parentIndex, xml, flags) < 0) { - goto cleanup; - } - if (!(checkdef = virNetworkDefCopy(configdef, - VIR_NETWORK_XML_INACTIVE))) { - goto cleanup; - } - virNetworkDefFree(checkdef); - } - - if (configdef) { - /* successfully modified copy, now replace original */ - if (virNetworkObjReplacePersistentDef(network, configdef) < 0) - goto cleanup; - configdef = NULL; - } - if (livedef) { - /* successfully modified copy, now replace original */ - virNetworkDefFree(network->def); - network->def = livedef; - livedef = NULL; - } - - ret = 0; - cleanup: - virNetworkDefFree(livedef); - virNetworkDefFree(configdef); - return ret; -} - -#define MATCH(FLAG) (flags & (FLAG)) -static bool -virNetworkMatch(virNetworkObjPtr netobj, - unsigned int flags) -{ - /* filter by active state */ - if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) && - !((MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE) && - virNetworkObjIsActive(netobj)) || - (MATCH(VIR_CONNECT_LIST_NETWORKS_INACTIVE) && - !virNetworkObjIsActive(netobj)))) - return false; - - /* filter by persistence */ - if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_PERSISTENT) && - !((MATCH(VIR_CONNECT_LIST_NETWORKS_PERSISTENT) && - netobj->persistent) || - (MATCH(VIR_CONNECT_LIST_NETWORKS_TRANSIENT) && - !netobj->persistent))) - return false; - - /* filter by autostart option */ - if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_AUTOSTART) && - !((MATCH(VIR_CONNECT_LIST_NETWORKS_AUTOSTART) && - netobj->autostart) || - (MATCH(VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART) && - !netobj->autostart))) - return false; - - return true; -} -#undef MATCH - -struct virNetworkObjListData { - virConnectPtr conn; - virNetworkPtr *nets; - virNetworkObjListFilter filter; - unsigned int flags; - int nnets; - bool error; -}; - -static int -virNetworkObjListPopulate(void *payload, - const void *name ATTRIBUTE_UNUSED, - void *opaque) -{ - struct virNetworkObjListData *data = opaque; - virNetworkObjPtr obj = payload; - virNetworkPtr net = NULL; - - if (data->error) - return 0; - - virObjectLock(obj); - - if (data->filter && - !data->filter(data->conn, obj->def)) - goto cleanup; - - if (!virNetworkMatch(obj, data->flags)) - goto cleanup; - - if (!data->nets) { - data->nnets++; - goto cleanup; - } - - if (!(net = virGetNetwork(data->conn, obj->def->name, obj->def->uuid))) { - data->error = true; - goto cleanup; - } - - data->nets[data->nnets++] = net; - - cleanup: - virObjectUnlock(obj); - return 0; -} - -int -virNetworkObjListExport(virConnectPtr conn, - virNetworkObjListPtr netobjs, - virNetworkPtr **nets, - virNetworkObjListFilter filter, - unsigned int flags) -{ - int ret = -1; - struct virNetworkObjListData data = { conn, NULL, filter, flags, 0, false}; - - virObjectLock(netobjs); - if (nets && VIR_ALLOC_N(data.nets, virHashSize(netobjs->objs) + 1) < 0) - goto cleanup; - - virHashForEach(netobjs->objs, virNetworkObjListPopulate, &data); - - if (data.error) - goto cleanup; - - if (data.nets) { - /* trim the array to the final size */ - ignore_value(VIR_REALLOC_N(data.nets, data.nnets + 1)); - *nets = data.nets; - data.nets = NULL; - } - - ret = data.nnets; - cleanup: - virObjectUnlock(netobjs); - while (data.nets && data.nnets) - virObjectUnref(data.nets[--data.nnets]); - - VIR_FREE(data.nets); - return ret; -} - -struct virNetworkObjListForEachHelperData { - virNetworkObjListIterator callback; - void *opaque; - int ret; -}; - -static int -virNetworkObjListForEachHelper(void *payload, - const void *name ATTRIBUTE_UNUSED, - void *opaque) -{ - struct virNetworkObjListForEachHelperData *data = opaque; - - if (data->callback(payload, data->opaque) < 0) - data->ret = -1; - return 0; -} - -/** - * virNetworkObjListForEach: - * @nets: a list of network objects - * @callback: function to call over each of object in the list - * @opaque: pointer to pass to the @callback - * - * Function iterates over the list of network objects and calls - * passed callback over each one of them. You should avoid - * calling those virNetworkObjList APIs, which lock the list - * again in favor of their virNetworkObj*Locked variants. - * - * Returns: 0 on success, -1 otherwise. - */ -int -virNetworkObjListForEach(virNetworkObjListPtr nets, - virNetworkObjListIterator callback, - void *opaque) -{ - struct virNetworkObjListForEachHelperData data = {callback, opaque, 0}; - virObjectLock(nets); - virHashForEach(nets->objs, virNetworkObjListForEachHelper, &data); - virObjectUnlock(nets); - return data.ret; -} - -struct virNetworkObjListGetHelperData { - virConnectPtr conn; - virNetworkObjListFilter filter; - char **names; - int nnames; - bool active; - int got; - bool error; -}; - -static int -virNetworkObjListGetHelper(void *payload, - const void *name ATTRIBUTE_UNUSED, - void *opaque) -{ - struct virNetworkObjListGetHelperData *data = opaque; - virNetworkObjPtr obj = payload; - - if (data->error) - return 0; - - if (data->nnames >= 0 && - data->got == data->nnames) - return 0; - - virObjectLock(obj); - - if (data->filter && - !data->filter(data->conn, obj->def)) - goto cleanup; - - if ((data->active && virNetworkObjIsActive(obj)) || - (!data->active && !virNetworkObjIsActive(obj))) { - if (data->names && - VIR_STRDUP(data->names[data->got], obj->def->name) < 0) { - data->error = true; - goto cleanup; - } - data->got++; - } - - cleanup: - virObjectUnlock(obj); - return 0; -} - -int -virNetworkObjListGetNames(virNetworkObjListPtr nets, - bool active, - char **names, - int nnames, - virNetworkObjListFilter filter, - virConnectPtr conn) -{ - int ret = -1; - - struct virNetworkObjListGetHelperData data = { - conn, filter, names, nnames, active, 0, false}; - - virObjectLock(nets); - virHashForEach(nets->objs, virNetworkObjListGetHelper, &data); - virObjectUnlock(nets); - - if (data.error) - goto cleanup; - - ret = data.got; - cleanup: - if (ret < 0) { - while (data.got) - VIR_FREE(data.names[--data.got]); - } - return ret; -} - -int -virNetworkObjListNumOfNetworks(virNetworkObjListPtr nets, - bool active, - virNetworkObjListFilter filter, - virConnectPtr conn) -{ - struct virNetworkObjListGetHelperData data = { - conn, filter, NULL, -1, active, 0, false}; - - virObjectLock(nets); - virHashForEach(nets->objs, virNetworkObjListGetHelper, &data); - virObjectUnlock(nets); - - return data.got; -} - -struct virNetworkObjListPruneHelperData { - unsigned int flags; -}; - -static int -virNetworkObjListPruneHelper(const void *payload, - const void *name ATTRIBUTE_UNUSED, - const void *opaque) -{ - const struct virNetworkObjListPruneHelperData *data = opaque; - virNetworkObjPtr obj = (virNetworkObjPtr) payload; - int want = 0; - - virObjectLock(obj); - want = virNetworkMatch(obj, data->flags); - virObjectUnlock(obj); - return want; -} - -/** - * virNetworkObjListPrune: - * @nets: a list of network objects - * @flags: bitwise-OR of virConnectListAllNetworksFlags - * - * Iterate over list of network objects and remove the desired - * ones from it. - */ -void -virNetworkObjListPrune(virNetworkObjListPtr nets, - unsigned int flags) -{ - struct virNetworkObjListPruneHelperData data = {flags}; - - virObjectLock(nets); - virHashRemoveSet(nets->objs, virNetworkObjListPruneHelper, &data); - virObjectUnlock(nets); -} diff --git a/src/conf/network_conf.h b/src/conf/network_conf.h index 217b548..ae936a6 100644 --- a/src/conf/network_conf.h +++ b/src/conf/network_conf.h @@ -270,35 +270,6 @@ struct _virNetworkDef { xmlNodePtr metadata; }; -typedef struct _virNetworkObj virNetworkObj; -typedef virNetworkObj *virNetworkObjPtr; -struct _virNetworkObj { - virObjectLockable parent; - - pid_t dnsmasqPid; - pid_t radvdPid; - unsigned int active : 1; - unsigned int autostart : 1; - unsigned int persistent : 1; - - virNetworkDefPtr def; /* The current definition */ - virNetworkDefPtr newDef; /* New definition to activate at shutdown */ - - virBitmapPtr class_id; /* bitmap of class IDs for QoS */ - unsigned long long floor_sum; /* sum of all 'floor'-s of attached NICs */ - - unsigned int taint; - - /* Immutable pointer, self locking APIs */ - virMacMapPtr macmap; -}; - -virNetworkObjPtr virNetworkObjNew(void); -void virNetworkObjEndAPI(virNetworkObjPtr *net); - -typedef struct _virNetworkObjList virNetworkObjList; -typedef virNetworkObjList *virNetworkObjListPtr; - typedef enum { VIR_NETWORK_TAINT_HOOK, /* Hook script was executed over network. We can't guarantee @@ -310,50 +281,16 @@ typedef enum { VIR_NETWORK_TAINT_LAST } virNetworkTaintFlags; -static inline int -virNetworkObjIsActive(const virNetworkObj *net) -{ - return net->active; -} - -virNetworkObjListPtr virNetworkObjListNew(void); - -virNetworkObjPtr virNetworkObjFindByUUIDLocked(virNetworkObjListPtr nets, - const unsigned char *uuid); -virNetworkObjPtr virNetworkObjFindByUUID(virNetworkObjListPtr nets, - const unsigned char *uuid); -virNetworkObjPtr virNetworkObjFindByNameLocked(virNetworkObjListPtr nets, - const char *name); -virNetworkObjPtr virNetworkObjFindByName(virNetworkObjListPtr nets, - const char *name); -bool virNetworkObjTaint(virNetworkObjPtr obj, - virNetworkTaintFlags taint); - -void virNetworkDefFree(virNetworkDefPtr def); - -typedef bool (*virNetworkObjListFilter)(virConnectPtr conn, void *opaque); +void virNetworkDefFree(void *opaque); enum { VIR_NETWORK_OBJ_LIST_ADD_LIVE = (1 << 0), VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1), }; -virNetworkObjPtr virNetworkAssignDef(virNetworkObjListPtr nets, - virNetworkDefPtr def, - unsigned int flags); -void virNetworkObjAssignDef(virNetworkObjPtr network, - virNetworkDefPtr def, - bool live); -int virNetworkObjSetDefTransient(virNetworkObjPtr network, bool live); -void virNetworkObjUnsetDefTransient(virNetworkObjPtr network); -virNetworkDefPtr virNetworkObjGetPersistentDef(virNetworkObjPtr network); -int virNetworkObjReplacePersistentDef(virNetworkObjPtr network, - virNetworkDefPtr def); -virNetworkDefPtr virNetworkDefCopy(virNetworkDefPtr def, unsigned int flags); -int virNetworkConfigChangeSetup(virNetworkObjPtr dom, unsigned int flags); -void virNetworkRemoveInactive(virNetworkObjListPtr nets, - virNetworkObjPtr net); +virNetworkDefPtr virNetworkDefCopy(virNetworkDefPtr def, unsigned int flags); +virNetworkDefPtr virNetworkDefParseXML(xmlXPathContextPtr ctxt); virNetworkDefPtr virNetworkDefParseString(const char *xmlStr); virNetworkDefPtr virNetworkDefParseFile(const char *filename); virNetworkDefPtr virNetworkDefParseNode(xmlDocPtr xml, @@ -385,46 +322,11 @@ int virNetworkSaveXML(const char *configDir, int virNetworkSaveConfig(const char *configDir, virNetworkDefPtr def); -int virNetworkSaveStatus(const char *statusDir, - virNetworkObjPtr net) ATTRIBUTE_RETURN_CHECK; - -virNetworkObjPtr virNetworkLoadConfig(virNetworkObjListPtr nets, - const char *configDir, - const char *autostartDir, - const char *file); - -virNetworkObjPtr virNetworkLoadState(virNetworkObjListPtr nets, - const char *stateDir, - const char *name); - -int virNetworkLoadAllConfigs(virNetworkObjListPtr nets, - const char *configDir, - const char *autostartDir); - -int virNetworkLoadAllState(virNetworkObjListPtr nets, - const char *stateDir); - -int virNetworkDeleteConfig(const char *configDir, - const char *autostartDir, - virNetworkObjPtr net); - char *virNetworkConfigFile(const char *dir, const char *name); -int virNetworkBridgeInUse(virNetworkObjListPtr nets, - const char *bridge, - const char *skipname); - void virNetworkSetBridgeMacAddr(virNetworkDefPtr def); -int -virNetworkObjUpdate(virNetworkObjPtr obj, - unsigned int command, /* virNetworkUpdateCommand */ - unsigned int section, /* virNetworkUpdateSection */ - int parentIndex, - const char *xml, - unsigned int flags); /* virNetworkUpdateFlags */ - VIR_ENUM_DECL(virNetworkForward) # define VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE \ @@ -444,34 +346,6 @@ VIR_ENUM_DECL(virNetworkForward) VIR_CONNECT_LIST_NETWORKS_FILTERS_PERSISTENT | \ VIR_CONNECT_LIST_NETWORKS_FILTERS_AUTOSTART) -int virNetworkObjListExport(virConnectPtr conn, - virNetworkObjListPtr netobjs, - virNetworkPtr **nets, - virNetworkObjListFilter filter, - unsigned int flags); - -typedef int (*virNetworkObjListIterator)(virNetworkObjPtr net, - void *opaque); - -int virNetworkObjListForEach(virNetworkObjListPtr nets, - virNetworkObjListIterator callback, - void *opaque); - -int virNetworkObjListGetNames(virNetworkObjListPtr nets, - bool active, - char **names, - int nnames, - virNetworkObjListFilter filter, - virConnectPtr conn); - -int virNetworkObjListNumOfNetworks(virNetworkObjListPtr nets, - bool active, - virNetworkObjListFilter filter, - virConnectPtr conn); - -void virNetworkObjListPrune(virNetworkObjListPtr nets, - unsigned int flags); - /* for testing */ int virNetworkDefUpdateSection(virNetworkDefPtr def, diff --git a/src/conf/virnetworkobj.c b/src/conf/virnetworkobj.c new file mode 100644 index 0000000..f85b8a1 --- /dev/null +++ b/src/conf/virnetworkobj.c @@ -0,0 +1,1166 @@ +/* + * virnetworkobj.c: handle network objects + * (derived from network_conf.c) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#include <config.h> +#include <dirent.h> + +#include "datatypes.h" +#include "virnetworkobj.h" + +#include "viralloc.h" +#include "virerror.h" +#include "virfile.h" +#include "virlog.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NETWORK + +VIR_LOG_INIT("conf.virnetworkobj"); + +/* currently, /sbin/tc implementation allows up to 16 bits for minor class size */ +#define CLASS_ID_BITMAP_SIZE (1<<16) + +struct _virNetworkObjPrivate { + pid_t dnsmasqPid; + pid_t radvdPid; + + virBitmapPtr class_id; /* bitmap of class IDs for QoS */ + unsigned long long floor_sum; /* sum of all 'floor'-s of attached NICs */ + + unsigned int taint; + + /* Immutable pointer, self locking APIs */ + virMacMapPtr macmap; +}; + + +static void +virNetworkObjPrivateFree(void *obj) +{ + virNetworkObjPrivatePtr objpriv = obj; + if (!objpriv) + return; + + virBitmapFree(objpriv->class_id); + virObjectUnref(objpriv->macmap); + + VIR_FREE(objpriv); +} + + +static virNetworkObjPrivatePtr +virNetworkObjPrivateAlloc(void) +{ + virNetworkObjPrivatePtr objpriv = NULL; + + if (VIR_ALLOC(objpriv) < 0) + return NULL; + + if (!(objpriv->class_id = virBitmapNew(CLASS_ID_BITMAP_SIZE))) + goto error; + + /* The first three class IDs are already taken */ + ignore_value(virBitmapSetBit(objpriv->class_id, 0)); + ignore_value(virBitmapSetBit(objpriv->class_id, 1)); + ignore_value(virBitmapSetBit(objpriv->class_id, 2)); + + return objpriv; + + error: + virNetworkObjPrivateFree(objpriv); + return NULL; +} + + +pid_t +virNetworkObjPrivateGetDnsmasqPid(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->dnsmasqPid; +} + + +void +virNetworkObjPrivateSetDnsmasqPid(virPoolObjPtr obj, + pid_t dnsmasqPid) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + objpriv->dnsmasqPid = dnsmasqPid; +} + + +pid_t +virNetworkObjPrivateGetRadvdPid(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->radvdPid; +} + + +void +virNetworkObjPrivateSetRadvdPid(virPoolObjPtr obj, + pid_t radvdPid) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + objpriv->radvdPid = radvdPid; +} + + +virBitmapPtr +virNetworkObjPrivateGetClassId(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->class_id; +} + + +void +virNetworkObjPrivateSetClassId(virPoolObjPtr obj, + virBitmapPtr class_id) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + virBitmapFree(objpriv->class_id); + objpriv->class_id = class_id; +} + + +unsigned long long +virNetworkObjPrivateGetFloorSum(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->floor_sum; +} + + +void +virNetworkObjPrivateSetFloorSum(virPoolObjPtr obj, + unsigned long long floor_sum) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + objpriv->floor_sum = floor_sum; +} + + +virMacMapPtr +virNetworkObjPrivateGetMacMap(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->macmap; +} + + +void +virNetworkObjPrivateSetMacMap(virPoolObjPtr obj, + virMacMapPtr macmap) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + virObjectUnref(objpriv->macmap); + objpriv->macmap = macmap; +} + + +unsigned int +virNetworkObjPrivateGetTaint(virPoolObjPtr obj) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + return objpriv->taint; +} + + +bool +virNetworkObjPrivateIsTaint(virPoolObjPtr obj, + virNetworkTaintFlags taint) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + unsigned int flag = (1 << taint); + + if (objpriv->taint & flag) + return false; + + objpriv->taint |= flag; + return true; +} + + +void +virNetworkObjPrivateSetTaint(virPoolObjPtr obj, + unsigned int taint) +{ + virNetworkObjPrivatePtr objpriv = virPoolObjGetPrivateData(obj); + + objpriv->taint = taint; +} + + +/* + * If flags & VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE then this will + * refuse updating an existing def if the current def is live + * + * If flags & VIR_NETWORK_OBJ_LIST_ADD_LIVE then the @def being + * added is assumed to represent a live config, not a future + * inactive config + * + * If flags is zero, network is considered as inactive and persistent. + */ +static int +networkAssignDef(virPoolObjPtr obj, + void *newDef, + void *oldDef ATTRIBUTE_UNUSED, + unsigned int assignFlags) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + virNetworkDefPtr newdef = newDef; + + if (assignFlags & VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE) { + /* UUID & name match, but if network is already active, refuse it */ + if (virPoolObjIsActive(obj)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("network is already active as '%s'"), + def->name); + return -1; + } + } + + if (assignFlags & VIR_NETWORK_OBJ_LIST_ADD_LIVE) { + /* before setting new live def, save (into newDef) any + * existing persistent (!live) def to be restored when the + * network is destroyed, unless there is one already saved. + */ + if (virPoolObjIsPersistent(obj) && !virPoolObjGetNewDef(obj)) { + virPoolObjSetNewDef(obj, def); + virPoolObjSetDef(obj, NULL); /* Don't want SetDef to free def! */ + } + virPoolObjSetDef(obj, newdef); + } else { /* !live */ + virNetworkDefFree(virPoolObjGetNewDef(obj)); + if (virPoolObjIsActive(obj)) { + /* save new configuration to be restored on network + * shutdown, leaving current live def alone + */ + virPoolObjSetNewDef(obj, newdef); + } else { /* !live and !active */ + if (def && !virPoolObjIsPersistent(obj)) { + /* network isn't (yet) marked active or persistent, + * but already has a "live" def set. This means we are + * currently setting the persistent def as a part of + * the process of starting the network, so we need to + * preserve the "not yet live" def in network->def. + */ + virPoolObjSetNewDef(obj, newdef); + } else { + /* either there is no live def set, or this network + * was already set as persistent, so the proper thing + * is to overwrite network->def. + */ + virPoolObjSetNewDef(obj, NULL); + virPoolObjSetDef(obj, newdef); + } + } + virPoolObjSetPersistent(obj, !!newdef); + } + + return 0; +} + + +/* + * virNetworkObjAdd: + * @netobjs: the network object to update + * @def: the new NetworkDef (will be consumed by this function) + * @assignFlags: assignment flags + * + * Replace the appropriate copy of the given network's def or newDef + * with def. Use "live" and current state of the network to determine + * which to replace and what to do with the old defs. When a non-live + * def is set, indicate that the network is now persistent. + * + * NB: a persistent network can be made transient by calling with: + * virNetworkObjAssignDef(network, NULL, false) (i.e. set the + * persistent def to NULL) + * + */ +virPoolObjPtr +virNetworkObjAdd(virPoolObjTablePtr netobjs, + virNetworkDefPtr def, + unsigned int assignFlags) +{ + virPoolObjPtr obj = NULL; + virNetworkObjPrivatePtr objpriv = NULL; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + virUUIDFormat(def->uuid, uuidstr); + + if (!(obj = virPoolObjTableAdd(netobjs, uuidstr, def->name, + def, NULL, NULL, virNetworkDefFree, + networkAssignDef, assignFlags))) + return NULL; + + if (!(assignFlags & VIR_NETWORK_OBJ_LIST_ADD_LIVE)) + virPoolObjSetPersistent(obj, true); + + if (!(objpriv = virPoolObjGetPrivateData(obj))) { + if (!(objpriv = virNetworkObjPrivateAlloc())) + goto error; + + virPoolObjSetPrivateData(obj, objpriv, virNetworkObjPrivateFree); + } + + return obj; + + error: + virPoolObjTableRemove(netobjs, &obj); + virPoolObjEndAPI(&obj); + return NULL; +} + + +void +virNetworkObjAssignDef(virPoolObjPtr obj, + virNetworkDefPtr def) +{ + networkAssignDef(obj, def, NULL, false); +} + + +static char * +networkObjFormat(virPoolObjPtr obj, + unsigned int flags) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + virNetworkDefPtr def = virPoolObjGetDef(obj); + char *class_id = virBitmapFormat(virNetworkObjPrivateGetClassId(obj)); + unsigned int taint = virNetworkObjPrivateGetTaint(obj); + size_t i; + + if (!class_id) + goto error; + + virBufferAddLit(&buf, "<networkstatus>\n"); + virBufferAdjustIndent(&buf, 2); + virBufferAsprintf(&buf, "<class_id bitmap='%s'/>\n", class_id); + virBufferAsprintf(&buf, "<floor sum='%llu'/>\n", + virNetworkObjPrivateGetFloorSum(obj)); + VIR_FREE(class_id); + + for (i = 0; i < VIR_NETWORK_TAINT_LAST; i++) { + if (taint & (1 << i)) + virBufferAsprintf(&buf, "<taint flag='%s'/>\n", + virNetworkTaintTypeToString(i)); + } + + if (virNetworkDefFormatBuf(&buf, def, flags) < 0) + goto error; + + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</networkstatus>"); + + if (virBufferCheckError(&buf) < 0) + goto error; + + return virBufferContentAndReset(&buf); + + error: + virBufferFreeAndReset(&buf); + return NULL; +} + + +int +virNetworkObjSaveStatus(const char *statusDir, + virPoolObjPtr obj) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + int ret = -1; + int flags = 0; + char *xml; + + if (!(xml = networkObjFormat(obj, flags))) + goto cleanup; + + if (virNetworkSaveXML(statusDir, def, xml)) + goto cleanup; + + ret = 0; + cleanup: + VIR_FREE(xml); + return ret; +} + + +int +virNetworkObjDeleteConfig(const char *configDir, + const char *autostartDir, + virPoolObjPtr obj) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + char *configFile = NULL; + char *autostartLink = NULL; + int ret = -1; + + if (!(configFile = virNetworkConfigFile(configDir, def->name))) + goto error; + + if (!(autostartLink = virNetworkConfigFile(autostartDir, def->name))) + goto error; + + /* Not fatal if this doesn't work */ + unlink(autostartLink); + virPoolObjSetAutostart(obj, false); + + if (unlink(configFile) < 0) { + virReportSystemError(errno, + _("cannot remove config file '%s'"), + configFile); + goto error; + } + + ret = 0; + + error: + VIR_FREE(configFile); + VIR_FREE(autostartLink); + return ret; +} + + +static virPoolObjPtr +networkLoadConfig(virPoolObjTablePtr netobjs, + const char *configDir, + const char *autostartDir, + const char *name) +{ + char *configFile = NULL; + char *autostartLink = NULL; + virNetworkDefPtr def = NULL; + virPoolObjPtr obj; + int autostart; + + if (!(configFile = virNetworkConfigFile(configDir, name))) + goto error; + + if (!(autostartLink = virNetworkConfigFile(autostartDir, name))) + goto error; + + if ((autostart = virFileLinkPointsTo(autostartLink, configFile)) < 0) + goto error; + + if (!(def = virNetworkDefParseFile(configFile))) + goto error; + + if (STRNEQ(name, def->name)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Network config filename '%s' does not match " + "network name '%s'"), + configFile, def->name); + goto error; + } + + if (def->forward.type == VIR_NETWORK_FORWARD_NONE || + def->forward.type == VIR_NETWORK_FORWARD_NAT || + def->forward.type == VIR_NETWORK_FORWARD_ROUTE || + def->forward.type == VIR_NETWORK_FORWARD_OPEN) { + + if (!def->mac_specified) { + virNetworkSetBridgeMacAddr(def); + virNetworkSaveConfig(configDir, def); + } + } else { + /* Throw away MAC address for other forward types, + * which could have been generated by older libvirt RPMs */ + def->mac_specified = false; + } + + if (!(obj = virNetworkObjAdd(netobjs, def, 0))) + goto error; + def = NULL; + + virPoolObjSetAutostart(obj, autostart); + + VIR_FREE(configFile); + VIR_FREE(autostartLink); + + return obj; + + error: + VIR_FREE(configFile); + VIR_FREE(autostartLink); + virNetworkDefFree(def); + return NULL; +} + + +int +virNetworkObjLoadAllConfigs(virPoolObjTablePtr netobjs, + const char *configDir, + const char *autostartDir) +{ + DIR *dir; + struct dirent *entry; + int ret = -1; + int rc; + + if ((rc = virDirOpenIfExists(&dir, configDir)) <= 0) + return rc; + + while ((ret = virDirRead(dir, &entry, configDir)) > 0) { + virPoolObjPtr obj; + + if (!virFileStripSuffix(entry->d_name, ".xml")) + continue; + + /* NB: ignoring errors, so one malformed config doesn't + kill the whole process */ + obj = networkLoadConfig(netobjs, configDir, autostartDir, + entry->d_name); + virPoolObjEndAPI(&obj); + } + + VIR_DIR_CLOSE(dir); + return ret; +} + + +static virPoolObjPtr +networkObjLoadState(virPoolObjTablePtr netobjs, + const char *stateDir, + const char *name) +{ + char *configFile = NULL; + virNetworkDefPtr def = NULL; + virPoolObjPtr obj = NULL; + xmlDocPtr xml = NULL; + xmlNodePtr node = NULL; + xmlNodePtr *nodes = NULL; + xmlXPathContextPtr ctxt = NULL; + virBitmapPtr class_id_map = NULL; + unsigned long long floor_sum_val = 0; + unsigned int taint = 0; + int n; + size_t i; + + + if ((configFile = virNetworkConfigFile(stateDir, name)) == NULL) + goto error; + + if (!(xml = virXMLParseCtxt(configFile, NULL, _("(network status)"), + &ctxt))) + goto error; + + if (!(node = virXPathNode("//network", ctxt))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Could not find any 'network' element " + "in status file")); + goto error; + } + + /* parse the definition first */ + ctxt->node = node; + if (!(def = virNetworkDefParseXML(ctxt))) + goto error; + + if (STRNEQ(name, def->name)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Network config filename '%s' does not match " + "network name '%s'"), + configFile, def->name); + goto error; + } + + /* now parse possible status data */ + node = xmlDocGetRootElement(xml); + if (xmlStrEqual(node->name, BAD_CAST "networkstatus")) { + /* Newer network status file. Contains useful + * info which are not to be found in bare config XML */ + char *class_id = NULL; + char *floor_sum = NULL; + + ctxt->node = node; + if ((class_id = + virXPathString("string(./class_id[1]/@bitmap)", ctxt))) { + if (virBitmapParse(class_id, &class_id_map, + CLASS_ID_BITMAP_SIZE) < 0) { + VIR_FREE(class_id); + goto error; + } + } + VIR_FREE(class_id); + + floor_sum = virXPathString("string(./floor[1]/@sum)", ctxt); + if (floor_sum && + virStrToLong_ull(floor_sum, NULL, 10, &floor_sum_val) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Malformed 'floor_sum' attribute: %s"), + floor_sum); + VIR_FREE(floor_sum); + goto error; + } + VIR_FREE(floor_sum); + + if ((n = virXPathNodeSet("./taint", ctxt, &nodes)) < 0) + goto error; + + for (i = 0; i < n; i++) { + char *str = virXMLPropString(nodes[i], "flag"); + if (str) { + int flag = virNetworkTaintTypeFromString(str); + if (flag < 0) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("Unknown taint flag %s"), str); + VIR_FREE(str); + goto error; + } + VIR_FREE(str); + /* Compute taint mask here. The network object does not + * exist yet, so we can't use virNetworkObjtTaint. */ + taint |= (1 << flag); + } + } + VIR_FREE(nodes); + } + + /* create the object */ + if (!(obj = virNetworkObjAdd(netobjs, def, VIR_NETWORK_OBJ_LIST_ADD_LIVE))) + goto error; + def = NULL; + + /* assign status data stored in the network object */ + if (class_id_map) + virNetworkObjPrivateSetClassId(obj, class_id_map); + + if (floor_sum_val > 0) + virNetworkObjPrivateSetFloorSum(obj, floor_sum_val); + + virNetworkObjPrivateSetTaint(obj, taint); + + /* any network with a state file is by definition active */ + virPoolObjSetActive(obj, true); + + cleanup: + VIR_FREE(configFile); + xmlFreeDoc(xml); + xmlXPathFreeContext(ctxt); + return obj; + + error: + VIR_FREE(nodes); + virBitmapFree(class_id_map); + virNetworkDefFree(def); + goto cleanup; +} + + +int +virNetworkObjLoadAllState(virPoolObjTablePtr netobjs, + const char *stateDir) +{ + DIR *dir; + struct dirent *entry; + int ret = -1; + int rc; + + if ((rc = virDirOpenIfExists(&dir, stateDir)) <= 0) + return rc; + + while ((ret = virDirRead(dir, &entry, stateDir)) > 0) { + virPoolObjPtr obj; + + if (!virFileStripSuffix(entry->d_name, ".xml")) + continue; + + obj = networkObjLoadState(netobjs, stateDir, entry->d_name); + virPoolObjEndAPI(&obj); + } + + VIR_DIR_CLOSE(dir); + return ret; +} + + +/* + * virNetworkObjSetDefTransient: + * @obj: pool object pointer + * @live: if true, run this operation even for an inactive network. + * this allows freely updated network->def with runtime defaults + * before starting the network, which will be discarded on network + * shutdown. Any cleanup paths need to be sure to handle newDef if + * the network is never started. + * + * Mark the active network config as transient. Ensures live-only update + * operations do not persist past network destroy. + * + * Returns 0 on success, -1 on failure + */ +int +virNetworkObjSetDefTransient(virPoolObjPtr obj, + bool live) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + virNetworkDefPtr newDef; + + if (!virPoolObjIsActive(obj) && !live) + return 0; + + if (!virPoolObjIsPersistent(obj) || virPoolObjGetNewDef(obj)) + return 0; + + newDef = virNetworkDefCopy(def, VIR_NETWORK_XML_INACTIVE); + virPoolObjSetNewDef(obj, newDef); + return newDef ? 0 : -1; +} + + +/* virNetworkObjUnsetDefTransient: + * + * This *undoes* what virNetworkObjSetDefTransient did. + */ +void +virNetworkObjUnsetDefTransient(virPoolObjPtr obj) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + virNetworkDefPtr newDef = virPoolObjGetNewDef(obj); + if (newDef) { + virNetworkDefFree(def); + virPoolObjSetDef(obj, newDef); + virPoolObjSetNewDef(obj, NULL); + } +} + + +/* + * virNetworkObjGetPersistentDef: + * @obj: pool object pointer + * + * Return the persistent network configuration. If network is transient, + * return the running config. + * + * Returns NULL on error, virNetworkDefPtr on success. + */ +virNetworkDefPtr +virNetworkObjGetPersistentDef(virPoolObjPtr obj) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + virNetworkDefPtr newDef = virPoolObjGetNewDef(obj); + if (newDef) + return newDef; + else + return def; +} + + +/* + * virNetworkObjReplacePersistentDef: + * @obj: pool object pointer + * @def: new virNetworkDef to replace current persistent config + * + * Replace the "persistent" network configuration with the given new + * virNetworkDef. This pays attention to whether or not the network + * is active. + * + * Returns -1 on error, 0 on success + */ +int +virNetworkObjReplacePersistentDef(virPoolObjPtr obj, + virNetworkDefPtr def) +{ + virNetworkDefPtr curDef = virPoolObjGetDef(obj); + virNetworkDefPtr newDef = virPoolObjGetNewDef(obj); + + if (virPoolObjIsActive(obj)) { + virNetworkDefFree(newDef); + virPoolObjSetNewDef(obj, def); + } else { + virNetworkDefFree(curDef); + virPoolObjSetDef(obj, def); + } + return 0; +} + + +/* + * networkObjConfigChangeSetup: + * + * 1) checks whether network state is consistent with the requested + * type of modification. + * + * 3) make sure there are separate "def" and "newDef" copies of + * networkDef if appropriate. + * + * Returns 0 on success, -1 on error. + */ +static int +networkObjConfigChangeSetup(virPoolObjPtr obj, + unsigned int flags) +{ + bool isActive; + int ret = -1; + + isActive = virPoolObjIsActive(obj); + + if (!isActive && (flags & VIR_NETWORK_UPDATE_AFFECT_LIVE)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("network is not running")); + goto cleanup; + } + + if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) { + if (!virPoolObjIsPersistent(obj)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("cannot change persistent config of a " + "transient network")); + goto cleanup; + } + /* this should already have been done by the driver, but do it + * anyway just in case. + */ + if (isActive && (virNetworkObjSetDefTransient(obj, false) < 0)) + goto cleanup; + } + + ret = 0; + + cleanup: + return ret; +} + + +/* + * virNetworkObjUpdate: + * + * Apply the supplied update to the given pool object. Except for + * @obj pointing to an actual network object rather than the + * opaque virNetworkPtr, parameters are identical to the public API + * virNetworkUpdate. + * + * The original virNetworkDefs are copied, and all modifications made + * to these copies. The originals are replaced with the copies only + * after success has been guaranteed. + * + * Returns: -1 on error, 0 on success. + */ +int +virNetworkObjUpdate(virPoolObjPtr obj, + unsigned int command, /* virNetworkUpdateCommand */ + unsigned int section, /* virNetworkUpdateSection */ + int parentIndex, + const char *xml, + unsigned int flags) /* virNetworkUpdateFlags */ +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + int ret = -1; + virNetworkDefPtr livedef = NULL, configdef = NULL; + + /* normalize config data, and check for common invalid requests. */ + if (networkObjConfigChangeSetup(obj, flags) < 0) + goto cleanup; + + if (flags & VIR_NETWORK_UPDATE_AFFECT_LIVE) { + virNetworkDefPtr checkdef; + + /* work on a copy of the def */ + if (!(livedef = virNetworkDefCopy(def, 0))) + goto cleanup; + if (virNetworkDefUpdateSection(livedef, command, section, + parentIndex, xml, flags) < 0) + goto cleanup; + + /* run a final format/parse cycle to make sure we didn't + * add anything illegal to the def + */ + if (!(checkdef = virNetworkDefCopy(livedef, 0))) + goto cleanup; + virNetworkDefFree(checkdef); + } + + if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) { + virNetworkDefPtr checkdef; + + /* work on a copy of the def */ + if (!(configdef = virNetworkDefCopy(virNetworkObjGetPersistentDef(obj), + VIR_NETWORK_XML_INACTIVE))) { + goto cleanup; + } + if (virNetworkDefUpdateSection(configdef, command, section, + parentIndex, xml, flags) < 0) { + goto cleanup; + } + if (!(checkdef = virNetworkDefCopy(configdef, + VIR_NETWORK_XML_INACTIVE))) { + goto cleanup; + } + virNetworkDefFree(checkdef); + } + + if (configdef) { + /* successfully modified copy, now replace original */ + if (virNetworkObjReplacePersistentDef(obj, configdef) < 0) + goto cleanup; + configdef = NULL; + } + if (livedef) { + /* successfully modified copy, now replace original */ + virNetworkDefFree(def); + virPoolObjSetDef(obj, livedef); + livedef = NULL; + } + + ret = 0; + cleanup: + virNetworkDefFree(livedef); + virNetworkDefFree(configdef); + return ret; +} + + +struct networkCountData { + bool wantActive; + int count; +}; + +static int +networkCount(virPoolObjPtr obj, + void *opaque) +{ + struct networkCountData *data = opaque; + + if ((data->wantActive && virPoolObjIsActive(obj)) || + (!data->wantActive && !virPoolObjIsActive(obj))) + data->count++; + + return 0; +} + + +int +virNetworkObjNumOfNetworks(virPoolObjTablePtr netobjs, + virConnectPtr conn, + bool wantActive, + virPoolObjACLFilter aclfilter) +{ + struct networkCountData data = { .count = 0, + .wantActive = wantActive }; + + if (virPoolObjTableList(netobjs, conn, aclfilter, networkCount, &data) < 0) + return 0; + + return data.count; +} + + +struct networkNameData { + bool wantActive; + int nnames; + char **const names; + int maxnames; +}; + +static int +networkListNames(virPoolObjPtr obj, + void *opaque) +{ + struct networkNameData *data = opaque; + + if (data->nnames < data->maxnames) { + if (data->wantActive && virPoolObjIsActive(obj)) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + + if (VIR_STRDUP(data->names[data->nnames++], def->name) < 0) + return -1; + } else if (!data->wantActive && !virPoolObjIsActive(obj)) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + + if (VIR_STRDUP(data->names[data->nnames++], def->name) < 0) + return -1; + } + } + return 0; +} + + +int +virNetworkObjGetNames(virPoolObjTablePtr netobjs, + virConnectPtr conn, + bool wantActive, + virPoolObjACLFilter aclfilter, + char **const names, + int maxnames) +{ + struct networkNameData data = { .wantActive = wantActive, + .nnames = 0, + .names = names, + .maxnames = maxnames }; + + memset(names, 0, sizeof(*names) * maxnames); + if (virPoolObjTableList(netobjs, conn, aclfilter, + networkListNames, &data) < 0) + goto error; + + return data.nnames; + + error: + while (--data.nnames >= 0) + VIR_FREE(names[data.nnames]); + return -1; +} + + +#define MATCH(FLAG) (flags & (FLAG)) +static bool +networkMatch(virPoolObjPtr obj, + unsigned int flags) +{ + /* filter by active state */ + if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) && + !((MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE) && + virPoolObjIsActive(obj)) || + (MATCH(VIR_CONNECT_LIST_NETWORKS_INACTIVE) && + !virPoolObjIsActive(obj)))) + return false; + + /* filter by persistence */ + if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_PERSISTENT) && + !((MATCH(VIR_CONNECT_LIST_NETWORKS_PERSISTENT) && + virPoolObjIsPersistent(obj)) || + (MATCH(VIR_CONNECT_LIST_NETWORKS_TRANSIENT) && + !virPoolObjIsPersistent(obj)))) + return false; + + /* filter by autostart option */ + if (MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_AUTOSTART) && + !((MATCH(VIR_CONNECT_LIST_NETWORKS_AUTOSTART) && + virPoolObjIsAutostart(obj)) || + (MATCH(VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART) && + !virPoolObjIsAutostart(obj)))) + return false; + + return true; +} +#undef MATCH + +int +virNetworkObjExportList(virConnectPtr conn, + virPoolObjTablePtr netobjs, + virNetworkPtr **nets, + virPoolObjACLFilter aclfilter, + unsigned int flags) +{ + virPoolObjPtr *objs = NULL; + size_t nobjs; + virNetworkPtr *tmp_nets = NULL; + size_t i; + + if (virPoolObjTableCollect(netobjs, conn, &objs, &nobjs, aclfilter, + networkMatch, flags) < 0) + return -1; + + if (nets) { + if (VIR_ALLOC_N(tmp_nets, nobjs + 1) < 0) + goto cleanup; + + for (i = 0; i < nobjs; i++) { + virNetworkDefPtr def; + + virObjectLock(objs[i]); + def = virPoolObjGetDef(objs[i]); + tmp_nets[i] = virGetNetwork(conn, def->name, def->uuid); + virObjectUnlock(objs[i]); + if (!tmp_nets[i]) + goto cleanup; + } + + VIR_STEAL_PTR(*nets, tmp_nets); + } + + cleanup: + virObjectListFree(tmp_nets); + virObjectListFreeCount(objs, nobjs); + + return nobjs; +} + + +/** + * virNetworkObjListPrune: + * @netobjs: network objects table + * @flags: bitwise-OR of virConnectListAllNetworksFlags + * + * Iterate over list of network objects and remove the desired + * ones from it. + */ +void +virNetworkObjPrune(virPoolObjTablePtr netobjs, + unsigned int flags) +{ + virPoolObjTablePrune(netobjs, networkMatch, flags); +} + + +struct bridgeInUseData { + const char *bridge; + const char *skipname; +}; + +static bool +bridgeInUse(virPoolObjPtr obj, + void *opaque) +{ + virNetworkDefPtr def = virPoolObjGetDef(obj); + virNetworkDefPtr newDef = virPoolObjGetNewDef(obj); + const struct bridgeInUseData *data = opaque; + + if (data->skipname && + ((STREQ(def->name, data->skipname)) || + (newDef && STREQ(newDef->name, data->skipname)))) + return false; + else if ((def->bridge && STREQ(def->bridge, data->bridge)) || + (newDef && newDef->bridge && + STREQ(newDef->bridge, data->bridge))) + return true; + + return false; +} + + +bool +virNetworkObjBridgeInUse(virPoolObjTablePtr netobjs, + const char *bridge, + const char *skipname) +{ + virPoolObjPtr obj; + struct bridgeInUseData data = { .bridge = bridge, + .skipname = skipname }; + + if ((obj = virPoolObjTableSearch(netobjs, bridgeInUse, &data))) { + virObjectUnlock(obj); + return true; + } + + return false; +} diff --git a/src/conf/virnetworkobj.h b/src/conf/virnetworkobj.h new file mode 100644 index 0000000..0154b56 --- /dev/null +++ b/src/conf/virnetworkobj.h @@ -0,0 +1,121 @@ +/* + * virnetworkobj.h: handle network objects + * (derived from network_conf.h) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#ifndef __NETWORKOBJ_H__ +# define __NETWORKOBJ_H__ + +# include "internal.h" + +# include "network_conf.h" +# include "virpoolobj.h" + +typedef struct _virNetworkObjPrivate virNetworkObjPrivate; +typedef virNetworkObjPrivate *virNetworkObjPrivatePtr; + +pid_t virNetworkObjPrivateGetDnsmasqPid(virPoolObjPtr obj); + +void virNetworkObjPrivateSetDnsmasqPid(virPoolObjPtr obj, pid_t dnsmasqPid); + +pid_t virNetworkObjPrivateGetRadvdPid(virPoolObjPtr obj); + +void virNetworkObjPrivateSetRadvdPid(virPoolObjPtr obj, pid_t radvdPid); + +virBitmapPtr virNetworkObjPrivateGetClassId(virPoolObjPtr obj); + +void virNetworkObjPrivateSetClassId(virPoolObjPtr obj, virBitmapPtr class_id); + +unsigned long long virNetworkObjPrivateGetFloorSum(virPoolObjPtr obj); + +void virNetworkObjPrivateSetFloorSum(virPoolObjPtr obj, + unsigned long long floor_sum); + +virMacMapPtr virNetworkObjPrivateGetMacMap(virPoolObjPtr obj); + +void virNetworkObjPrivateSetMacMap(virPoolObjPtr obj, virMacMapPtr macmap); + +unsigned int virNetworkObjPrivateGetTaint(virPoolObjPtr obj); + +bool virNetworkObjPrivateIsTaint(virPoolObjPtr obj, + virNetworkTaintFlags taint); + +void virNetworkObjPrivateSetTaint(virPoolObjPtr obj, unsigned int taint); + +virPoolObjPtr virNetworkObjAdd(virPoolObjTablePtr netobjs, + virNetworkDefPtr def, + unsigned int flags); + +void virNetworkObjAssignDef(virPoolObjPtr obj, + virNetworkDefPtr def); + +int virNetworkObjSaveStatus(const char *statusDir, + virPoolObjPtr obj) ATTRIBUTE_RETURN_CHECK; + +int virNetworkObjDeleteConfig(const char *configDir, + const char *autostartDir, + virPoolObjPtr obj); + +int virNetworkObjLoadAllConfigs(virPoolObjTablePtr netobjs, + const char *configDir, + const char *autostartDir); + +int virNetworkObjLoadAllState(virPoolObjTablePtr netobjs, + const char *stateDir); + +int virNetworkObjSetDefTransient(virPoolObjPtr obj, bool live); + +void virNetworkObjUnsetDefTransient(virPoolObjPtr obj); + +virNetworkDefPtr virNetworkObjGetPersistentDef(virPoolObjPtr obj); + +int virNetworkObjReplacePersistentDef(virPoolObjPtr obj, + virNetworkDefPtr def); + +int virNetworkObjUpdate(virPoolObjPtr obj, + unsigned int command, /* virNetworkUpdateCommand */ + unsigned int section, /* virNetworkUpdateSection */ + int parentIndex, + const char *xml, + unsigned int flags); /* virNetworkUpdateFlags */ + +int virNetworkObjNumOfNetworks(virPoolObjTablePtr netobjs, + virConnectPtr conn, + bool wantActive, + virPoolObjACLFilter aclfilter); + +int virNetworkObjGetNames(virPoolObjTablePtr netobjs, + virConnectPtr conn, + bool wantActive, + virPoolObjACLFilter aclfilter, + char **const names, + int maxnames); + +int virNetworkObjExportList(virConnectPtr conn, + virPoolObjTablePtr netobjs, + virNetworkPtr **nets, + virPoolObjACLFilter aclfilter, + unsigned int flags); + +void virNetworkObjPrune(virPoolObjTablePtr netobjs, + unsigned int flags); + +bool virNetworkObjBridgeInUse(virPoolObjTablePtr netobjs, + const char *bridge, + const char *skipname); + +#endif /* __NETWORKOBJ_H__ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 5c91988..59209df 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -620,11 +620,8 @@ virNetDevVPortTypeToString; # conf/network_conf.h -virNetworkAssignDef; -virNetworkBridgeInUse; virNetworkBridgeMACTableManagerTypeFromString; virNetworkBridgeMACTableManagerTypeToString; -virNetworkConfigChangeSetup; virNetworkConfigFile; virNetworkDefCopy; virNetworkDefFormat; @@ -636,35 +633,12 @@ virNetworkDefGetRouteByIndex; virNetworkDefParseFile; virNetworkDefParseNode; virNetworkDefParseString; +virNetworkDefParseXML; virNetworkDefUpdateSection; -virNetworkDeleteConfig; virNetworkForwardTypeToString; virNetworkIPDefNetmask; virNetworkIPDefPrefix; -virNetworkLoadAllConfigs; -virNetworkLoadAllState; -virNetworkObjAssignDef; -virNetworkObjEndAPI; -virNetworkObjFindByName; -virNetworkObjFindByNameLocked; -virNetworkObjFindByUUID; -virNetworkObjFindByUUIDLocked; -virNetworkObjGetPersistentDef; -virNetworkObjListExport; -virNetworkObjListForEach; -virNetworkObjListGetNames; -virNetworkObjListNew; -virNetworkObjListNumOfNetworks; -virNetworkObjListPrune; -virNetworkObjNew; -virNetworkObjReplacePersistentDef; -virNetworkObjSetDefTransient; -virNetworkObjTaint; -virNetworkObjUnsetDefTransient; -virNetworkObjUpdate; -virNetworkRemoveInactive; virNetworkSaveConfig; -virNetworkSaveStatus; virNetworkSetBridgeMacAddr; virNetworkTaintTypeFromString; virNetworkTaintTypeToString; @@ -920,6 +894,38 @@ virInterfaceObjGetNames; virInterfaceObjNumOfInterfaces; +# conf/virnetworkobj.h +virNetworkObjAdd; +virNetworkObjAssignDef; +virNetworkObjBridgeInUse; +virNetworkObjDeleteConfig; +virNetworkObjExportList; +virNetworkObjGetNames; +virNetworkObjGetPersistentDef; +virNetworkObjLoadAllConfigs; +virNetworkObjLoadAllState; +virNetworkObjNumOfNetworks; +virNetworkObjPrivateGetClassId; +virNetworkObjPrivateGetDnsmasqPid; +virNetworkObjPrivateGetFloorSum; +virNetworkObjPrivateGetMacMap; +virNetworkObjPrivateGetRadvdPid; +virNetworkObjPrivateGetTaint; +virNetworkObjPrivateIsTaint; +virNetworkObjPrivateSetClassId; +virNetworkObjPrivateSetDnsmasqPid; +virNetworkObjPrivateSetFloorSum; +virNetworkObjPrivateSetMacMap; +virNetworkObjPrivateSetRadvdPid; +virNetworkObjPrivateSetTaint; +virNetworkObjPrune; +virNetworkObjReplacePersistentDef; +virNetworkObjSaveStatus; +virNetworkObjSetDefTransient; +virNetworkObjUnsetDefTransient; +virNetworkObjUpdate; + + # conf/virnodedeviceobj.h virNodeDeviceObjExportList; virNodeDeviceObjFindByName; diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c index 06759c6..926fe71 100644 --- a/src/network/bridge_driver.c +++ b/src/network/bridge_driver.c @@ -49,7 +49,6 @@ #include "datatypes.h" #include "bridge_driver.h" #include "bridge_driver_platform.h" -#include "network_conf.h" #include "device_conf.h" #include "driver.h" #include "virbuffer.h" @@ -66,6 +65,7 @@ #include "virnetdevbridge.h" #include "virnetdevtap.h" #include "virnetdevvportprofile.h" +#include "virnetworkobj.h" #include "virpci.h" #include "virdbus.h" #include "virfile.h" @@ -135,64 +135,92 @@ networkDnsmasqCapsRefresh(virNetworkDriverStatePtr driver) static int networkStateCleanup(void); static int networkStartNetwork(virNetworkDriverStatePtr driver, - virNetworkObjPtr network); + virPoolObjPtr obj); static int networkShutdownNetwork(virNetworkDriverStatePtr driver, - virNetworkObjPtr network); + virPoolObjPtr obj); static int networkStartNetworkVirtual(virNetworkDriverStatePtr driver, - virNetworkObjPtr network); + virPoolObjPtr obj); static int networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver, - virNetworkObjPtr network); + virPoolObjPtr obj); -static int networkStartNetworkExternal(virNetworkObjPtr network); +static int networkStartNetworkExternal(virPoolObjPtr obj); -static int networkShutdownNetworkExternal(virNetworkObjPtr network); +static int networkShutdownNetworkExternal(virPoolObjPtr obj); static void networkReloadFirewallRules(virNetworkDriverStatePtr driver); static void networkRefreshDaemons(virNetworkDriverStatePtr driver); -static int networkPlugBandwidth(virNetworkObjPtr net, +static int networkPlugBandwidth(virPoolObjPtr obj, virDomainNetDefPtr iface); -static int networkUnplugBandwidth(virNetworkObjPtr net, +static int networkUnplugBandwidth(virPoolObjPtr obj, virDomainNetDefPtr iface); -static void networkNetworkObjTaint(virNetworkObjPtr net, +static void networkNetworkObjTaint(virPoolObjPtr obj, virNetworkTaintFlags taint); -static virNetworkObjPtr -networkObjFromNetwork(virNetworkPtr net) +static virPoolObjPtr +networkObjFindByUUID(const unsigned char *uuid, + const char *name) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; char uuidstr[VIR_UUID_STRING_BUFLEN]; - network = virNetworkObjFindByUUID(driver->networks, net->uuid); - if (!network) { - virUUIDFormat(net->uuid, uuidstr); + if (!(obj = virPoolObjTableFindByUUIDRef(driver->networks, uuid))) { + virUUIDFormat(uuid, uuidstr); + if (name) + virReportError(VIR_ERR_NO_NETWORK, + _("no network with matching uuid '%s' (%s)"), + uuidstr, name); + else + virReportError(VIR_ERR_NO_NETWORK, + _("no network with matching uuid '%s'"), + uuidstr); + } + + return obj; +} + +static virPoolObjPtr +networkObjFromNetwork(virNetworkPtr net) +{ + return networkObjFindByUUID(net->uuid, net->name); +} + + +static virPoolObjPtr +networkObjFindByName(const char *name) +{ + virNetworkDriverStatePtr driver = networkGetDriver(); + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByName(driver->networks, name))) { virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching uuid '%s' (%s)"), - uuidstr, net->name); + _("no network with matching name '%s'"), name); } - return network; + return obj; } + static int -networkRunHook(virNetworkObjPtr network, +networkRunHook(virPoolObjPtr obj, virDomainDefPtr dom, virDomainNetDefPtr iface, int op, int sub_op) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virBuffer buf = VIR_BUFFER_INITIALIZER; char *xml = NULL, *net_xml = NULL, *dom_xml = NULL; int hookret; int ret = -1; if (virHookPresent(VIR_HOOK_DRIVER_NETWORK)) { - if (!network) { + if (!obj) { VIR_DEBUG("Not running hook as @network is NULL"); ret = 0; goto cleanup; @@ -202,7 +230,7 @@ networkRunHook(virNetworkObjPtr network, virBufferAdjustIndent(&buf, 2); if (iface && virDomainNetDefFormat(&buf, iface, NULL, 0) < 0) goto cleanup; - if (virNetworkDefFormatBuf(&buf, network->def, 0) < 0) + if (virNetworkDefFormatBuf(&buf, def, 0) < 0) goto cleanup; if (dom && virDomainDefFormatInternal(dom, NULL, 0, &buf) < 0) goto cleanup; @@ -214,7 +242,7 @@ networkRunHook(virNetworkObjPtr network, goto cleanup; xml = virBufferContentAndReset(&buf); - hookret = virHookCall(VIR_HOOK_DRIVER_NETWORK, network->def->name, + hookret = virHookCall(VIR_HOOK_DRIVER_NETWORK, def->name, op, sub_op, NULL, xml, NULL); /* @@ -223,7 +251,7 @@ networkRunHook(virNetworkObjPtr network, if (hookret < 0) goto cleanup; - networkNetworkObjTaint(network, VIR_NETWORK_TAINT_HOOK); + networkNetworkObjTaint(obj, VIR_NETWORK_TAINT_HOOK); } ret = 0; @@ -235,6 +263,7 @@ networkRunHook(virNetworkObjPtr network, return ret; } + static char * networkDnsmasqLeaseFileNameDefault(virNetworkDriverStatePtr driver, const char *netname) @@ -246,6 +275,7 @@ networkDnsmasqLeaseFileNameDefault(virNetworkDriverStatePtr driver, return leasefile; } + static char * networkDnsmasqLeaseFileNameCustom(virNetworkDriverStatePtr driver, const char *bridge) @@ -257,6 +287,7 @@ networkDnsmasqLeaseFileNameCustom(virNetworkDriverStatePtr driver, return leasefile; } + static char * networkDnsmasqConfigFileName(virNetworkDriverStatePtr driver, const char *netname) @@ -268,6 +299,7 @@ networkDnsmasqConfigFileName(virNetworkDriverStatePtr driver, return conffile; } + static char * networkRadvdPidfileBasename(const char *netname) { @@ -278,6 +310,7 @@ networkRadvdPidfileBasename(const char *netname) return pidfilebase; } + static char * networkRadvdConfigFileName(virNetworkDriverStatePtr driver, const char *netname) @@ -289,6 +322,7 @@ networkRadvdConfigFileName(virNetworkDriverStatePtr driver, return configfile; } + static char * networkMacMgrFileName(virNetworkDriverStatePtr driver, const char *bridge) @@ -300,10 +334,11 @@ networkMacMgrFileName(virNetworkDriverStatePtr driver, return filename; } + /* do needed cleanup steps and remove the network from the list */ static int networkRemoveInactive(virNetworkDriverStatePtr driver, - virNetworkObjPtr net) + virPoolObjPtr *obj) { char *leasefile = NULL; char *customleasefile = NULL; @@ -313,7 +348,7 @@ networkRemoveInactive(virNetworkDriverStatePtr driver, char *statusfile = NULL; char *macMapFile = NULL; dnsmasqContext *dctx = NULL; - virNetworkDefPtr def = virNetworkObjGetPersistentDef(net); + virNetworkDefPtr def = virNetworkObjGetPersistentDef(*obj); int ret = -1; @@ -326,7 +361,8 @@ networkRemoveInactive(virNetworkDriverStatePtr driver, if (!(leasefile = networkDnsmasqLeaseFileNameDefault(driver, def->name))) goto cleanup; - if (!(customleasefile = networkDnsmasqLeaseFileNameCustom(driver, def->bridge))) + if (!(customleasefile = networkDnsmasqLeaseFileNameCustom(driver, + def->bridge))) goto cleanup; if (!(radvdconfigfile = networkRadvdConfigFileName(driver, def->name))) @@ -361,7 +397,7 @@ networkRemoveInactive(virNetworkDriverStatePtr driver, unlink(statusfile); /* remove the network definition */ - virNetworkRemoveInactive(driver->networks, net); + virPoolObjTableRemove(driver->networks, obj); ret = 0; @@ -377,28 +413,31 @@ networkRemoveInactive(virNetworkDriverStatePtr driver, return ret; } + static int networkMacMgrAdd(virNetworkDriverStatePtr driver, - virNetworkObjPtr network, + virPoolObjPtr obj, const char *domain, const virMacAddr *mac) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + virMacMapPtr macmap = virNetworkObjPrivateGetMacMap(obj); char macStr[VIR_MAC_STRING_BUFLEN]; char *file = NULL; int ret = -1; - if (!network->macmap) + if (!macmap) return 0; virMacAddrFormat(mac, macStr); - if (!(file = networkMacMgrFileName(driver, network->def->bridge))) + if (!(file = networkMacMgrFileName(driver, def->bridge))) goto cleanup; - if (virMacMapAdd(network->macmap, domain, macStr) < 0) + if (virMacMapAdd(macmap, domain, macStr) < 0) goto cleanup; - if (virMacMapWriteFile(network->macmap, file) < 0) + if (virMacMapWriteFile(macmap, file) < 0) goto cleanup; ret = 0; @@ -407,28 +446,31 @@ networkMacMgrAdd(virNetworkDriverStatePtr driver, return ret; } + static int networkMacMgrDel(virNetworkDriverStatePtr driver, - virNetworkObjPtr network, + virPoolObjPtr obj, const char *domain, const virMacAddr *mac) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + virMacMapPtr macmap = virNetworkObjPrivateGetMacMap(obj); char macStr[VIR_MAC_STRING_BUFLEN]; char *file = NULL; int ret = -1; - if (!network->macmap) + if (!macmap) return 0; virMacAddrFormat(mac, macStr); - if (!(file = networkMacMgrFileName(driver, network->def->bridge))) + if (!(file = networkMacMgrFileName(driver, def->bridge))) goto cleanup; - if (virMacMapRemove(network->macmap, domain, macStr) < 0) + if (virMacMapRemove(macmap, domain, macStr) < 0) goto cleanup; - if (virMacMapWriteFile(network->macmap, file) < 0) + if (virMacMapWriteFile(macmap, file) < 0) goto cleanup; ret = 0; @@ -437,6 +479,7 @@ networkMacMgrDel(virNetworkDriverStatePtr driver, return ret; } + static char * networkBridgeDummyNicName(const char *brname) { @@ -461,34 +504,33 @@ networkBridgeDummyNicName(const char *brname) return nicname; } -static int -networkUpdateState(virNetworkObjPtr obj, + +/* Enter with locked virPoolObjPtr */ +static void +networkUpdateState(virPoolObjPtr obj, void *opaque) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virNetworkDriverStatePtr driver = opaque; dnsmasqCapsPtr dnsmasq_caps = networkGetDnsmasqCaps(driver); - int ret = -1; - virObjectLock(obj); - if (!virNetworkObjIsActive(obj)) { - ret = 0; + if (!virPoolObjIsActive(obj)) goto cleanup; - } - switch (obj->def->forward.type) { + switch (def->forward.type) { case VIR_NETWORK_FORWARD_NONE: case VIR_NETWORK_FORWARD_NAT: case VIR_NETWORK_FORWARD_ROUTE: case VIR_NETWORK_FORWARD_OPEN: /* If bridge doesn't exist, then mark it inactive */ - if (!(obj->def->bridge && virNetDevExists(obj->def->bridge) == 1)) - obj->active = 0; + if (!(def->bridge && virNetDevExists(def->bridge) == 1)) + virPoolObjSetActive(obj, false); break; case VIR_NETWORK_FORWARD_BRIDGE: - if (obj->def->bridge) { - if (virNetDevExists(obj->def->bridge) != 1) - obj->active = 0; + if (def->bridge) { + if (virNetDevExists(def->bridge) != 1) + virPoolObjSetActive(obj, false); break; } /* intentionally drop through to common case for all @@ -507,63 +549,58 @@ networkUpdateState(virNetworkObjPtr obj, } /* Try and read dnsmasq/radvd pids of active networks */ - if (obj->active && obj->def->ips && (obj->def->nips > 0)) { + if (virPoolObjIsActive(obj) && def->ips && (def->nips > 0)) { char *radvdpidbase; char *macMapFile; + pid_t dnsmasqPid; + pid_t radvdPid; + virMacMapPtr macmap = NULL; ignore_value(virPidFileReadIfAlive(driver->pidDir, - obj->def->name, - &obj->dnsmasqPid, + def->name, + &dnsmasqPid, dnsmasqCapsGetBinaryPath(dnsmasq_caps))); + virNetworkObjPrivateSetDnsmasqPid(obj, dnsmasqPid); - radvdpidbase = networkRadvdPidfileBasename(obj->def->name); - if (!radvdpidbase) + if (!(radvdpidbase = networkRadvdPidfileBasename(def->name))) goto cleanup; ignore_value(virPidFileReadIfAlive(driver->pidDir, radvdpidbase, - &obj->radvdPid, RADVD)); + &radvdPid, RADVD)); + virNetworkObjPrivateSetRadvdPid(obj, radvdPid); VIR_FREE(radvdpidbase); - if (!(macMapFile = networkMacMgrFileName(driver, obj->def->bridge))) + if (!(macMapFile = networkMacMgrFileName(driver, def->bridge))) goto cleanup; if (virFileExists(macMapFile) && - !(obj->macmap = virMacMapNew(macMapFile))) { + !(macmap = virMacMapNew(macMapFile))) { VIR_FREE(macMapFile); goto cleanup; } + virNetworkObjPrivateSetMacMap(obj, macmap); VIR_FREE(macMapFile); } - ret = 0; cleanup: - virObjectUnlock(obj); virObjectUnref(dnsmasq_caps); - return ret; } -static int -networkAutostartConfig(virNetworkObjPtr net, +/* Enter with locked virPoolObjPtr */ +static void +networkAutostartConfig(virPoolObjPtr obj, void *opaque) { virNetworkDriverStatePtr driver = opaque; - int ret = -1; - - virObjectLock(net); - if (net->autostart && - !virNetworkObjIsActive(net) && - networkStartNetwork(driver, net) < 0) - goto cleanup; - ret = 0; - cleanup: - virObjectUnlock(net); - return ret; + if (virPoolObjIsAutostart(obj) && !virPoolObjIsActive(obj)) + ignore_value(networkStartNetwork(driver, obj)); } + #if HAVE_FIREWALLD static DBusHandlerResult firewalld_dbus_filter_bridge(DBusConnection *connection ATTRIBUTE_UNUSED, @@ -584,6 +621,7 @@ firewalld_dbus_filter_bridge(DBusConnection *connection ATTRIBUTE_UNUSED, } #endif + static int networkMigrateStateFiles(virNetworkDriverStatePtr driver) { @@ -669,6 +707,7 @@ networkMigrateStateFiles(virNetworkDriverStatePtr driver) return ret; } + /** * networkStateInitialize: * @@ -751,28 +790,30 @@ networkStateInitialize(bool privileged, /* if this fails now, it will be retried later with dnsmasqCapsRefresh() */ network_driver->dnsmasqCaps = dnsmasqCapsNewFromBinary(DNSMASQ); - if (!(network_driver->networks = virNetworkObjListNew())) + if (!(network_driver->networks = + virPoolObjTableNew(VIR_POOLOBJTABLE_NETWORK, + VIR_POOLOBJTABLE_NETWORK_HASHSTART, false))) goto error; - if (virNetworkLoadAllState(network_driver->networks, - network_driver->stateDir) < 0) + if (virNetworkObjLoadAllState(network_driver->networks, + network_driver->stateDir) < 0) goto error; - if (virNetworkLoadAllConfigs(network_driver->networks, - network_driver->networkConfigDir, - network_driver->networkAutostartDir) < 0) + if (virNetworkObjLoadAllConfigs(network_driver->networks, + network_driver->networkConfigDir, + network_driver->networkAutostartDir) < 0) goto error; /* Update the internal status of all allegedly active * networks according to external conditions on the host * (i.e. anything that isn't stored directly in each * network's state file). */ - virNetworkObjListForEach(network_driver->networks, - networkUpdateState, - network_driver); - virNetworkObjListPrune(network_driver->networks, - VIR_CONNECT_LIST_NETWORKS_INACTIVE | - VIR_CONNECT_LIST_NETWORKS_TRANSIENT); + virPoolObjTableIterate(network_driver->networks, + networkUpdateState, + network_driver); + virNetworkObjPrune(network_driver->networks, + VIR_CONNECT_LIST_NETWORKS_INACTIVE | + VIR_CONNECT_LIST_NETWORKS_TRANSIENT); networkReloadFirewallRules(network_driver); networkRefreshDaemons(network_driver); @@ -814,6 +855,7 @@ networkStateInitialize(bool privileged, goto cleanup; } + /** * networkStateAutoStart: * @@ -825,11 +867,12 @@ networkStateAutoStart(void) if (!network_driver) return; - virNetworkObjListForEach(network_driver->networks, - networkAutostartConfig, - network_driver); + virPoolObjTableIterate(network_driver->networks, + networkAutostartConfig, + network_driver); } + /** * networkStateReload: * @@ -842,16 +885,16 @@ networkStateReload(void) if (!network_driver) return 0; - virNetworkLoadAllState(network_driver->networks, - network_driver->stateDir); - virNetworkLoadAllConfigs(network_driver->networks, - network_driver->networkConfigDir, - network_driver->networkAutostartDir); + virNetworkObjLoadAllState(network_driver->networks, + network_driver->stateDir); + virNetworkObjLoadAllConfigs(network_driver->networks, + network_driver->networkConfigDir, + network_driver->networkAutostartDir); networkReloadFirewallRules(network_driver); networkRefreshDaemons(network_driver); - virNetworkObjListForEach(network_driver->networks, - networkAutostartConfig, - network_driver); + virPoolObjTableIterate(network_driver->networks, + networkAutostartConfig, + network_driver); return 0; } @@ -1032,17 +1075,18 @@ networkDnsmasqConfLocalPTRs(virBufferPtr buf, int -networkDnsmasqConfContents(virNetworkObjPtr network, +networkDnsmasqConfContents(virPoolObjPtr obj, const char *pidfile, char **configstr, dnsmasqContext *dctx, dnsmasqCapsPtr caps ATTRIBUTE_UNUSED) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virBuffer configbuf = VIR_BUFFER_INITIALIZER; int r, ret = -1; int nbleases = 0; size_t i; - virNetworkDNSDefPtr dns = &network->def->dns; + virNetworkDNSDefPtr dns = &def->dns; bool wantDNS = dns->enable != VIR_TRISTATE_BOOL_NO; virNetworkIPDefPtr tmpipdef, ipdef, ipv4def, ipv6def; bool ipv6SLAAC; @@ -1076,7 +1120,7 @@ networkDnsmasqConfContents(virNetworkObjPtr network, "## or other application using the libvirt API.\n" "##\n## dnsmasq conf file created by libvirt\n" "strict-order\n", - network->def->name); + def->name); /* if dns is disabled, set its listening port to 0, which * tells dnsmasq to not listen @@ -1084,10 +1128,10 @@ networkDnsmasqConfContents(virNetworkObjPtr network, if (!wantDNS) virBufferAddLit(&configbuf, "port=0\n"); - if (wantDNS && network->def->dns.forwarders) { + if (wantDNS && def->dns.forwarders) { virBufferAddLit(&configbuf, "no-resolv\n"); - for (i = 0; i < network->def->dns.nfwds; i++) { - virNetworkDNSForwarderPtr fwd = &network->def->dns.forwarders[i]; + for (i = 0; i < def->dns.nfwds; i++) { + virNetworkDNSForwarderPtr fwd = &def->dns.forwarders[i]; virBufferAddLit(&configbuf, "server="); if (fwd->domain) @@ -1106,23 +1150,23 @@ networkDnsmasqConfContents(virNetworkObjPtr network, } } - if (network->def->domain) { - if (network->def->domainLocalOnly == VIR_TRISTATE_BOOL_YES) { + if (def->domain) { + if (def->domainLocalOnly == VIR_TRISTATE_BOOL_YES) { virBufferAsprintf(&configbuf, "local=/%s/\n", - network->def->domain); + def->domain); } virBufferAsprintf(&configbuf, "domain=%s\n" "expand-hosts\n", - network->def->domain); + def->domain); } if (wantDNS && - networkDnsmasqConfLocalPTRs(&configbuf, network->def) < 0) + networkDnsmasqConfLocalPTRs(&configbuf, def) < 0) goto cleanup; - if (wantDNS && network->def->dns.forwardPlainNames == VIR_TRISTATE_BOOL_NO) { + if (wantDNS && def->dns.forwardPlainNames == VIR_TRISTATE_BOOL_NO) { virBufferAddLit(&configbuf, "domain-needed\n"); /* need to specify local=// whether or not a domain is * specified, unless the config says we should forward "plain" @@ -1153,19 +1197,19 @@ networkDnsmasqConfContents(virNetworkObjPtr network, virBufferAsprintf(&configbuf, "bind-dynamic\n" "interface=%s\n", - network->def->bridge); + def->bridge); } else { virBufferAddLit(&configbuf, "bind-interfaces\n"); /* * --interface does not actually work with dnsmasq < 2.47, * due to DAD for ipv6 addresses on the interface. * - * virCommandAddArgList(cmd, "--interface", network->def->bridge, NULL); + * virCommandAddArgList(cmd, "--interface", def->bridge, NULL); * * So listen on all defined IPv[46] addresses */ for (i = 0; - (tmpipdef = virNetworkDefGetIPByIndex(network->def, AF_UNSPEC, i)); + (tmpipdef = virNetworkDefGetIPByIndex(def, AF_UNSPEC, i)); i++) { char *ipaddr = virSocketAddrFormat(&tmpipdef->address); @@ -1211,7 +1255,7 @@ networkDnsmasqConfContents(virNetworkObjPtr network, * via the sender's link-local address. The only thing we can do * is set the lifetime of this route to 0, i.e. disable it. */ - if (network->def->forward.type == VIR_NETWORK_FORWARD_NONE) { + if (def->forward.type == VIR_NETWORK_FORWARD_NONE) { virBufferAddLit(&configbuf, "dhcp-option=3\n" "no-resolv\n"); if (dnsmasqCapsGet(caps, DNSMASQ_CAPS_RA_PARAM)) { @@ -1235,14 +1279,14 @@ networkDnsmasqConfContents(virNetworkObjPtr network, virReportError(VIR_ERR_INTERNAL_ERROR, _("Missing required 'service' " "attribute in SRV record of network '%s'"), - network->def->name); + def->name); goto cleanup; } if (!dns->srvs[i].protocol) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Missing required 'service' " "attribute in SRV record of network '%s'"), - network->def->name); + def->name); goto cleanup; } /* RFC2782 requires that service and protocol be preceded by @@ -1284,7 +1328,7 @@ networkDnsmasqConfContents(virNetworkObjPtr network, /* Find the first dhcp for both IPv4 and IPv6 */ for (i = 0, ipv4def = NULL, ipv6def = NULL, ipv6SLAAC = false; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_UNSPEC, i)); + (ipdef = virNetworkDefGetIPByIndex(def, AF_UNSPEC, i)); i++) { if (VIR_SOCKET_ADDR_IS_FAMILY(&ipdef->address, AF_INET)) { if (ipdef->nranges || ipdef->nhosts) { @@ -1346,7 +1390,7 @@ networkDnsmasqConfContents(virNetworkObjPtr network, if (prefix < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("bridge '%s' has an invalid prefix"), - network->def->bridge); + def->bridge); goto cleanup; } for (r = 0; r < ipdef->nranges; r++) { @@ -1452,7 +1496,7 @@ networkDnsmasqConfContents(virNetworkObjPtr network, virBufferAddLit(&configbuf, "enable-ra\n"); } else { for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET6, i)); + (ipdef = virNetworkDefGetIPByIndex(def, AF_INET6, i)); i++) { if (!(ipdef->nranges || ipdef->nhosts)) { char *bridgeaddr = virSocketAddrFormat(&ipdef->address); @@ -1481,11 +1525,12 @@ networkDnsmasqConfContents(virNetworkObjPtr network, /* build the dnsmasq command line */ static int ATTRIBUTE_NONNULL(3) networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver, - virNetworkObjPtr network, + virPoolObjPtr obj, virCommandPtr *cmdout, char *pidfile, dnsmasqContext *dctx) { + virNetworkDefPtr def = virPoolObjGetDef(obj); dnsmasqCapsPtr dnsmasq_caps = networkGetDnsmasqCaps(driver); virCommandPtr cmd = NULL; int ret = -1; @@ -1493,16 +1538,16 @@ networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver, char *configstr = NULL; char *leaseshelper_path = NULL; - network->dnsmasqPid = -1; + virNetworkObjPrivateSetDnsmasqPid(obj, -1); - if (networkDnsmasqConfContents(network, pidfile, &configstr, + if (networkDnsmasqConfContents(obj, pidfile, &configstr, dctx, dnsmasq_caps) < 0) goto cleanup; if (!configstr) goto cleanup; /* construct the filename */ - if (!(configfile = networkDnsmasqConfigFileName(driver, network->def->name))) + if (!(configfile = networkDnsmasqConfigFileName(driver, def->name))) goto cleanup; /* Write the file */ @@ -1524,7 +1569,7 @@ networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver, /* Libvirt gains full control of leases database */ virCommandAddArgFormat(cmd, "--leasefile-ro"); virCommandAddArgFormat(cmd, "--dhcp-script=%s", leaseshelper_path); - virCommandAddEnvPair(cmd, "VIR_BRIDGE_NAME", network->def->bridge); + virCommandAddEnvPair(cmd, "VIR_BRIDGE_NAME", def->bridge); *cmdout = cmd; ret = 0; @@ -1536,21 +1581,24 @@ networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver, return ret; } + static int networkStartDhcpDaemon(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virNetworkIPDefPtr ipdef; size_t i; bool needDnsmasq = false; virCommandPtr cmd = NULL; char *pidfile = NULL; + pid_t dnsmasqPid = -1; int ret = -1; dnsmasqContext *dctx = NULL; /* see if there are any IP addresses that need a dhcp server */ i = 0; - while ((ipdef = virNetworkDefGetIPByIndex(network->def, AF_UNSPEC, i))) { + while ((ipdef = virNetworkDefGetIPByIndex(def, AF_UNSPEC, i))) { i++; if (ipdef->nranges || ipdef->nhosts) needDnsmasq = true; @@ -1562,7 +1610,7 @@ networkStartDhcpDaemon(virNetworkDriverStatePtr driver, goto cleanup; } - if (!needDnsmasq && network->def->dns.enable == VIR_TRISTATE_BOOL_NO) { + if (!needDnsmasq && def->dns.enable == VIR_TRISTATE_BOOL_NO) { /* no DHCP services needed, and user disabled DNS service */ ret = 0; goto cleanup; @@ -1575,8 +1623,7 @@ networkStartDhcpDaemon(virNetworkDriverStatePtr driver, goto cleanup; } - if (!(pidfile = virPidFileBuildPath(driver->pidDir, - network->def->name))) + if (!(pidfile = virPidFileBuildPath(driver->pidDir, def->name))) goto cleanup; if (virFileMakePath(driver->dnsmasqStateDir) < 0) { @@ -1586,14 +1633,13 @@ networkStartDhcpDaemon(virNetworkDriverStatePtr driver, goto cleanup; } - dctx = dnsmasqContextNew(network->def->name, driver->dnsmasqStateDir); - if (dctx == NULL) + if (!(dctx = dnsmasqContextNew(def->name, driver->dnsmasqStateDir))) goto cleanup; if (networkDnsmasqCapsRefresh(driver) < 0) goto cleanup; - ret = networkBuildDhcpDaemonCommandLine(driver, network, &cmd, pidfile, dctx); + ret = networkBuildDhcpDaemonCommandLine(driver, obj, &cmd, pidfile, dctx); if (ret < 0) goto cleanup; @@ -1613,10 +1659,9 @@ networkStartDhcpDaemon(virNetworkDriverStatePtr driver, * pid */ - ret = virPidFileRead(driver->pidDir, network->def->name, - &network->dnsmasqPid); - if (ret < 0) + if ((ret = virPidFileRead(driver->pidDir, def->name, &dnsmasqPid)) < 0) goto cleanup; + virNetworkObjPrivateSetDnsmasqPid(obj, dnsmasqPid); ret = 0; cleanup: @@ -1635,43 +1680,39 @@ networkStartDhcpDaemon(virNetworkDriverStatePtr driver, */ static int networkRefreshDhcpDaemon(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + pid_t dnsmasqPid = virNetworkObjPrivateGetDnsmasqPid(obj); int ret = -1; size_t i; virNetworkIPDefPtr ipdef, ipv4def, ipv6def; dnsmasqContext *dctx = NULL; /* if no IP addresses specified, nothing to do */ - if (!virNetworkDefGetIPByIndex(network->def, AF_UNSPEC, 0)) + if (!virNetworkDefGetIPByIndex(def, AF_UNSPEC, 0)) return 0; /* if there's no running dnsmasq, just start it */ - if (network->dnsmasqPid <= 0 || (kill(network->dnsmasqPid, 0) < 0)) - return networkStartDhcpDaemon(driver, network); + if (dnsmasqPid <= 0 || (kill(dnsmasqPid, 0) < 0)) + return networkStartDhcpDaemon(driver, obj); - VIR_INFO("Refreshing dnsmasq for network %s", network->def->bridge); - if (!(dctx = dnsmasqContextNew(network->def->name, - driver->dnsmasqStateDir))) { + VIR_INFO("Refreshing dnsmasq for network %s", def->bridge); + if (!(dctx = dnsmasqContextNew(def->name, driver->dnsmasqStateDir))) goto cleanup; - } /* Look for first IPv4 address that has dhcp defined. * We only support dhcp-host config on one IPv4 subnetwork * and on one IPv6 subnetwork. */ ipv4def = NULL; - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET, i)); i++) { if (!ipv4def && (ipdef->nranges || ipdef->nhosts)) ipv4def = ipdef; } ipv6def = NULL; - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET6, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET6, i)); i++) { if (!ipv6def && (ipdef->nranges || ipdef->nhosts)) ipv6def = ipdef; } @@ -1682,18 +1723,19 @@ networkRefreshDhcpDaemon(virNetworkDriverStatePtr driver, if (ipv6def && (networkBuildDnsmasqDhcpHostsList(dctx, ipv6def) < 0)) goto cleanup; - if (networkBuildDnsmasqHostsList(dctx, &network->def->dns) < 0) + if (networkBuildDnsmasqHostsList(dctx, &def->dns) < 0) goto cleanup; if ((ret = dnsmasqSave(dctx)) < 0) goto cleanup; - ret = kill(network->dnsmasqPid, SIGHUP); + ret = kill(dnsmasqPid, SIGHUP); cleanup: dnsmasqContextFree(dctx); return ret; } + /* networkRestartDhcpDaemon: * * kill and restart dnsmasq, in order to update any config that is on @@ -1703,16 +1745,18 @@ networkRefreshDhcpDaemon(virNetworkDriverStatePtr driver, */ static int networkRestartDhcpDaemon(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + pid_t dnsmasqPid = virNetworkObjPrivateGetDnsmasqPid(obj); + /* if there is a running dnsmasq, kill it */ - if (network->dnsmasqPid > 0) { - networkKillDaemon(network->dnsmasqPid, "dnsmasq", - network->def->name); - network->dnsmasqPid = -1; + if (dnsmasqPid > 0) { + networkKillDaemon(dnsmasqPid, "dnsmasq", def->name); + virNetworkObjPrivateSetDnsmasqPid(obj, -1); } /* now start dnsmasq if it should be started */ - return networkStartDhcpDaemon(driver, network); + return networkStartDhcpDaemon(driver, obj); } static char radvd1[] = " AdvOtherConfigFlag off;\n\n"; @@ -1722,8 +1766,9 @@ static char radvd3[] = " AdvOnLink on;\n" " AdvRouterAddr off;\n"; static int -networkRadvdConfContents(virNetworkObjPtr network, char **configstr) +networkRadvdConfContents(virPoolObjPtr obj, char **configstr) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virBuffer configbuf = VIR_BUFFER_INITIALIZER; int ret = -1; size_t i; @@ -1733,9 +1778,7 @@ networkRadvdConfContents(virNetworkObjPtr network, char **configstr) *configstr = NULL; /* Check if DHCPv6 is needed */ - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET6, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET6, i)); i++) { v6present = true; if (ipdef->nranges || ipdef->nhosts) { dhcp6 = true; @@ -1758,22 +1801,19 @@ networkRadvdConfContents(virNetworkObjPtr network, char **configstr) " IgnoreIfMissing on;\n" " AdvManagedFlag %s;\n" "%s", - network->def->bridge, + def->bridge, dhcp6 ? "on" : "off", dhcp6 ? "\n" : radvd1); /* add a section for each IPv6 address in the config */ - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET6, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET6, i)); i++) { int prefix; char *netaddr; - prefix = virNetworkIPDefPrefix(ipdef); - if (prefix < 0) { + if ((prefix = virNetworkIPDefPrefix(ipdef)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("bridge '%s' has an invalid prefix"), - network->def->bridge); + def->bridge); goto cleanup; } if (!(netaddr = virSocketAddrFormat(&ipdef->address))) @@ -1799,12 +1839,14 @@ networkRadvdConfContents(virNetworkObjPtr network, char **configstr) return ret; } + /* write file and return its name (which must be freed by caller) */ static int networkRadvdConfWrite(virNetworkDriverStatePtr driver, - virNetworkObjPtr network, + virPoolObjPtr obj, char **configFile) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int ret = -1; char *configStr = NULL; char *myConfigFile = NULL; @@ -1814,7 +1856,7 @@ networkRadvdConfWrite(virNetworkDriverStatePtr driver, *configFile = NULL; - if (networkRadvdConfContents(network, &configStr) < 0) + if (networkRadvdConfContents(obj, &configStr) < 0) goto cleanup; if (!configStr) { @@ -1823,8 +1865,9 @@ networkRadvdConfWrite(virNetworkDriverStatePtr driver, } /* construct the filename */ - if (!(*configFile = networkRadvdConfigFileName(driver, network->def->name))) + if (!(*configFile = networkRadvdConfigFileName(driver, def->name))) goto cleanup; + /* write the file */ if (virFileWriteStr(*configFile, configStr, 0600) < 0) { virReportSystemError(errno, @@ -1840,18 +1883,21 @@ networkRadvdConfWrite(virNetworkDriverStatePtr driver, return ret; } + static int networkStartRadvd(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); dnsmasqCapsPtr dnsmasq_caps = networkGetDnsmasqCaps(driver); char *pidfile = NULL; char *radvdpidbase = NULL; char *configfile = NULL; virCommandPtr cmd = NULL; + pid_t radvdPid = -1; int ret = -1; - network->radvdPid = -1; + virNetworkObjPrivateSetRadvdPid(obj, -1); /* Is dnsmasq handling RA? */ if (DNSMASQ_RA_SUPPORT(dnsmasq_caps)) { @@ -1859,7 +1905,7 @@ networkStartRadvd(virNetworkDriverStatePtr driver, goto cleanup; } - if (!virNetworkDefGetIPByIndex(network->def, AF_INET6, 0)) { + if (!virNetworkDefGetIPByIndex(def, AF_INET6, 0)) { /* no IPv6 addresses, so we don't need to run radvd */ ret = 0; goto cleanup; @@ -1887,12 +1933,13 @@ networkStartRadvd(virNetworkDriverStatePtr driver, } /* construct pidfile name */ - if (!(radvdpidbase = networkRadvdPidfileBasename(network->def->name))) + if (!(radvdpidbase = networkRadvdPidfileBasename(def->name))) goto cleanup; + if (!(pidfile = virPidFileBuildPath(driver->pidDir, radvdpidbase))) goto cleanup; - if (networkRadvdConfWrite(driver, network, &configfile) < 0) + if (networkRadvdConfWrite(driver, obj, &configfile) < 0) goto cleanup; /* prevent radvd from daemonizing itself with "--debug 1", and use @@ -1915,8 +1962,9 @@ networkStartRadvd(virNetworkDriverStatePtr driver, if (virCommandRun(cmd, NULL) < 0) goto cleanup; - if (virPidFileRead(driver->pidDir, radvdpidbase, &network->radvdPid) < 0) + if (virPidFileRead(driver->pidDir, radvdpidbase, &radvdPid) < 0) goto cleanup; + virNetworkObjPrivateSetRadvdPid(obj, radvdPid); ret = 0; cleanup: @@ -1928,96 +1976,97 @@ networkStartRadvd(virNetworkDriverStatePtr driver, return ret; } + static int networkRefreshRadvd(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + pid_t radvdPid = virNetworkObjPrivateGetRadvdPid(obj); dnsmasqCapsPtr dnsmasq_caps = networkGetDnsmasqCaps(driver); char *radvdpidbase; /* Is dnsmasq handling RA? */ if (DNSMASQ_RA_SUPPORT(dnsmasq_caps)) { virObjectUnref(dnsmasq_caps); - if (network->radvdPid <= 0) + if (radvdPid <= 0) return 0; /* radvd should not be running but in case it is */ - if ((networkKillDaemon(network->radvdPid, "radvd", - network->def->name) >= 0) && - ((radvdpidbase = networkRadvdPidfileBasename(network->def->name)) - != NULL)) { + if ((networkKillDaemon(radvdPid, "radvd", def->name) >= 0) && + ((radvdpidbase = networkRadvdPidfileBasename(def->name)))) { virPidFileDelete(driver->pidDir, radvdpidbase); VIR_FREE(radvdpidbase); } - network->radvdPid = -1; + virNetworkObjPrivateSetRadvdPid(obj, -1); return 0; } virObjectUnref(dnsmasq_caps); /* if there's no running radvd, just start it */ - if (network->radvdPid <= 0 || (kill(network->radvdPid, 0) < 0)) - return networkStartRadvd(driver, network); + if (radvdPid <= 0 || (kill(radvdPid, 0) < 0)) + return networkStartRadvd(driver, obj); - if (!virNetworkDefGetIPByIndex(network->def, AF_INET6, 0)) { + if (!virNetworkDefGetIPByIndex(def, AF_INET6, 0)) { /* no IPv6 addresses, so we don't need to run radvd */ return 0; } - if (networkRadvdConfWrite(driver, network, NULL) < 0) + if (networkRadvdConfWrite(driver, obj, NULL) < 0) return -1; - return kill(network->radvdPid, SIGHUP); + return kill(radvdPid, SIGHUP); } #if 0 /* currently unused, so it causes a build error unless we #if it out */ static int -networkRestartRadvd(virNetworkObjPtr network) +networkRestartRadvd(virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + radvdPid = virNetworkObjPrivateGetRadvdPid(obj); char *radvdpidbase; /* if there is a running radvd, kill it */ - if (network->radvdPid > 0) { + if (radvdPid > 0) { /* essentially ignore errors from the following two functions, * since there's really no better recovery to be done than to * just push ahead (and that may be exactly what's needed). */ - if ((networkKillDaemon(network->radvdPid, "radvd", - network->def->name) >= 0) && - ((radvdpidbase = networkRadvdPidfileBasename(network->def->name)) - != NULL)) { + if ((networkKillDaemon(radvdPid, "radvd", def->name) >= 0) && + ((radvdpidbase = networkRadvdPidfileBasename(def->name)))) { virPidFileDelete(driver->pidDir, radvdpidbase); VIR_FREE(radvdpidbase); } - network->radvdPid = -1; + virNetworkObjPrivateSetRadvdPid(obj, -1); } /* now start radvd if it should be started */ - return networkStartRadvd(network); + return networkStartRadvd(obj); } #endif /* #if 0 */ -static int -networkRefreshDaemonsHelper(virNetworkObjPtr net, + +/* Enter with locked virPoolObjPtr */ +static void +networkRefreshDaemonsHelper(virPoolObjPtr obj, void *opaque) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virNetworkDriverStatePtr driver = opaque; - virObjectLock(net); - if (virNetworkObjIsActive(net) && - ((net->def->forward.type == VIR_NETWORK_FORWARD_NONE) || - (net->def->forward.type == VIR_NETWORK_FORWARD_NAT) || - (net->def->forward.type == VIR_NETWORK_FORWARD_ROUTE) || - (net->def->forward.type == VIR_NETWORK_FORWARD_OPEN))) { + if (virPoolObjIsActive(obj) && + ((def->forward.type == VIR_NETWORK_FORWARD_NONE) || + (def->forward.type == VIR_NETWORK_FORWARD_NAT) || + (def->forward.type == VIR_NETWORK_FORWARD_ROUTE) || + (def->forward.type == VIR_NETWORK_FORWARD_OPEN))) { /* Only the three L3 network types that are configured by * libvirt will have a dnsmasq or radvd daemon associated * with them. Here we send a SIGHUP to an existing * dnsmasq and/or radvd, or restart them if they've * disappeared. */ - networkRefreshDhcpDaemon(driver, net); - networkRefreshRadvd(driver, net); + networkRefreshDhcpDaemon(driver, obj); + networkRefreshRadvd(driver, obj); } - virObjectUnlock(net); - return 0; } /* SIGHUP/restart any dnsmasq or radvd daemons. @@ -2027,44 +2076,46 @@ static void networkRefreshDaemons(virNetworkDriverStatePtr driver) { VIR_INFO("Refreshing network daemons"); - virNetworkObjListForEach(driver->networks, - networkRefreshDaemonsHelper, - driver); + virPoolObjTableIterate(driver->networks, + networkRefreshDaemonsHelper, + driver); } -static int -networkReloadFirewallRulesHelper(virNetworkObjPtr net, + +/* Enter with locked virPoolObjPtr */ +static void +networkReloadFirewallRulesHelper(virPoolObjPtr obj, void *opaque ATTRIBUTE_UNUSED) { + virNetworkDefPtr def = virPoolObjGetDef(obj); - virObjectLock(net); - if (virNetworkObjIsActive(net) && - ((net->def->forward.type == VIR_NETWORK_FORWARD_NONE) || - (net->def->forward.type == VIR_NETWORK_FORWARD_NAT) || - (net->def->forward.type == VIR_NETWORK_FORWARD_ROUTE))) { + if (virPoolObjIsActive(obj) && + ((def->forward.type == VIR_NETWORK_FORWARD_NONE) || + (def->forward.type == VIR_NETWORK_FORWARD_NAT) || + (def->forward.type == VIR_NETWORK_FORWARD_ROUTE))) { /* Only three of the L3 network types that are configured by * libvirt need to have iptables rules reloaded. The 4th L3 * network type, forward='open', doesn't need this because it * has no iptables rules. */ - networkRemoveFirewallRules(net->def); - if (networkAddFirewallRules(net->def) < 0) { + networkRemoveFirewallRules(def); + if (networkAddFirewallRules(def) < 0) { /* failed to add but already logged */ } } - virObjectUnlock(net); - return 0; } + static void networkReloadFirewallRules(virNetworkDriverStatePtr driver) { VIR_INFO("Reloading iptables rules"); - virNetworkObjListForEach(driver->networks, - networkReloadFirewallRulesHelper, - NULL); + virPoolObjTableIterate(driver->networks, + networkReloadFirewallRulesHelper, + NULL); } + /* Enable IP Forwarding. Return 0 for success, -1 for failure. */ static int networkEnableIPForwarding(bool enableIPv4, bool enableIPv6) @@ -2089,25 +2140,27 @@ networkEnableIPForwarding(bool enableIPv4, bool enableIPv6) #define SYSCTL_PATH "/proc/sys" + static int -networkSetIPv6Sysctls(virNetworkObjPtr network) +networkSetIPv6Sysctls(virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); char *field = NULL; int ret = -1; - bool enableIPv6 = !!virNetworkDefGetIPByIndex(network->def, AF_INET6, 0); + bool enableIPv6 = !!virNetworkDefGetIPByIndex(def, AF_INET6, 0); /* set disable_ipv6 if there are no ipv6 addresses defined for the * network. But also unset it if there *are* ipv6 addresses, as we * can't be sure of its default value. */ if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/disable_ipv6", - network->def->bridge) < 0) + def->bridge) < 0) goto cleanup; if (access(field, W_OK) < 0 && errno == ENOENT) { if (!enableIPv6) VIR_DEBUG("ipv6 appears to already be disabled on %s", - network->def->bridge); + def->bridge); ret = 0; goto cleanup; } @@ -2115,7 +2168,7 @@ networkSetIPv6Sysctls(virNetworkObjPtr network) if (virFileWriteStr(field, enableIPv6 ? "0" : "1", 0) < 0) { virReportSystemError(errno, _("cannot write to %s to enable/disable IPv6 " - "on bridge %s"), field, network->def->bridge); + "on bridge %s"), field, def->bridge); goto cleanup; } VIR_FREE(field); @@ -2128,7 +2181,7 @@ networkSetIPv6Sysctls(virNetworkObjPtr network) * their own router advertisements. */ if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/accept_ra", - network->def->bridge) < 0) + def->bridge) < 0) goto cleanup; if (virFileWriteStr(field, "0", 0) < 0) { @@ -2142,7 +2195,7 @@ networkSetIPv6Sysctls(virNetworkObjPtr network) * definition), must always have autoconf=0. */ if (virAsprintf(&field, SYSCTL_PATH "/net/ipv6/conf/%s/autoconf", - network->def->bridge) < 0) + def->bridge) < 0) goto cleanup; if (virFileWriteStr(field, "0", 0) < 0) { @@ -2157,22 +2210,23 @@ networkSetIPv6Sysctls(virNetworkObjPtr network) return ret; } + /* add an IP address to a bridge */ static int -networkAddAddrToBridge(virNetworkObjPtr network, +networkAddAddrToBridge(virPoolObjPtr obj, virNetworkIPDefPtr ipdef) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int prefix = virNetworkIPDefPrefix(ipdef); if (prefix < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("bridge '%s' has an invalid netmask or IP address"), - network->def->bridge); + def->bridge); return -1; } - if (virNetDevIPAddrAdd(network->def->bridge, - &ipdef->address, NULL, prefix) < 0) + if (virNetDevIPAddrAdd(def->bridge, &ipdef->address, NULL, prefix) < 0) return -1; return 0; @@ -2180,14 +2234,14 @@ networkAddAddrToBridge(virNetworkObjPtr network, static int -networkStartHandleMACTableManagerMode(virNetworkObjPtr network, +networkStartHandleMACTableManagerMode(virPoolObjPtr obj, const char *macTapIfName) { - const char *brname = network->def->bridge; + virNetworkDefPtr def = virPoolObjGetDef(obj); + const char *brname = def->bridge; if (brname && - network->def->macTableManager - == VIR_NETWORK_BRIDGE_MAC_TABLE_MANAGER_LIBVIRT) { + def->macTableManager == VIR_NETWORK_BRIDGE_MAC_TABLE_MANAGER_LIBVIRT) { if (virNetDevBridgeSetVlanFiltering(brname, true) < 0) return -1; if (macTapIfName) { @@ -2203,9 +2257,10 @@ networkStartHandleMACTableManagerMode(virNetworkObjPtr network, /* add an IP (static) route to a bridge */ static int -networkAddRouteToBridge(virNetworkObjPtr network, +networkAddRouteToBridge(virPoolObjPtr obj, virNetDevIPRoutePtr routedef) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int prefix = virNetDevIPRouteGetPrefix(routedef); unsigned int metric = virNetDevIPRouteGetMetric(routedef); virSocketAddrPtr addr = virNetDevIPRouteGetAddress(routedef); @@ -2215,29 +2270,25 @@ networkAddRouteToBridge(virNetworkObjPtr network, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' has an invalid netmask " "or IP address in route definition"), - network->def->name); + def->name); return -1; } - if (virNetDevIPRouteAdd(network->def->bridge, addr, - prefix, gateway, metric) < 0) { - return -1; - } - return 0; + return virNetDevIPRouteAdd(def->bridge, addr, prefix, gateway, metric); } static int -networkWaitDadFinish(virNetworkObjPtr network) +networkWaitDadFinish(virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virNetworkIPDefPtr ipdef; virSocketAddrPtr *addrs = NULL, addr = NULL; size_t naddrs = 0; int ret = -1; - VIR_DEBUG("Begin waiting for IPv6 DAD on network %s", network->def->name); + VIR_DEBUG("Begin waiting for IPv6 DAD on network %s", def->name); - while ((ipdef = virNetworkDefGetIPByIndex(network->def, - AF_INET6, naddrs))) { + while ((ipdef = virNetworkDefGetIPByIndex(def, AF_INET6, naddrs))) { addr = &ipdef->address; if (VIR_APPEND_ELEMENT_COPY(addrs, naddrs, addr) < 0) goto cleanup; @@ -2248,14 +2299,18 @@ networkWaitDadFinish(virNetworkObjPtr network) cleanup: VIR_FREE(addrs); VIR_DEBUG("Finished waiting for IPv6 DAD on network %s with status %d", - network->def->name, ret); + def->name, ret); return ret; } + static int networkStartNetworkVirtual(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + pid_t dnsmasqPid; + virMacMapPtr macmap; size_t i; bool v4present = false, v6present = false; virErrorPtr save_err = NULL; @@ -2266,11 +2321,11 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, int tapfd = -1; /* Check to see if any network IP collides with an existing route */ - if (networkCheckRouteCollision(network->def) < 0) + if (networkCheckRouteCollision(def) < 0) return -1; /* Create and configure the bridge device */ - if (!network->def->bridge) { + if (!def->bridge) { /* bridge name can only be empty if the config files were * edited directly. Otherwise networkValidate() (called after * parsing the XML from networkCreateXML() and @@ -2281,27 +2336,26 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, */ virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' has no bridge name defined"), - network->def->name); + def->name); return -1; } - if (virNetDevBridgeCreate(network->def->bridge) < 0) + if (virNetDevBridgeCreate(def->bridge) < 0) return -1; - if (network->def->mac_specified) { + if (def->mac_specified) { /* To set a mac for the bridge, we need to define a dummy tap * device, set its mac, then attach it to the bridge. As long * as its mac address is lower than any other interface that * gets attached, the bridge will always maintain this mac * address. */ - macTapIfName = networkBridgeDummyNicName(network->def->bridge); - if (!macTapIfName) + if (!(macTapIfName = networkBridgeDummyNicName(def->bridge))) goto err0; /* Keep tun fd open and interface up to allow for IPv6 DAD to happen */ - if (virNetDevTapCreateInBridgePort(network->def->bridge, - &macTapIfName, &network->def->mac, + if (virNetDevTapCreateInBridgePort(def->bridge, + &macTapIfName, &def->mac, NULL, NULL, &tapfd, 1, NULL, NULL, - network->def->mtu, NULL, + def->mtu, NULL, VIR_NETDEV_TAP_CREATE_USE_MAC_FOR_BRIDGE | VIR_NETDEV_TAP_CREATE_IFUP | VIR_NETDEV_TAP_CREATE_PERSIST) < 0) { @@ -2310,65 +2364,62 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, } } - if (!(macMapFile = networkMacMgrFileName(driver, network->def->bridge)) || - !(network->macmap = virMacMapNew(macMapFile))) + if (!(macMapFile = networkMacMgrFileName(driver, def->bridge)) || + !(macmap = virMacMapNew(macMapFile))) goto err1; + virNetworkObjPrivateSetMacMap(obj, macmap); /* Set bridge options */ /* delay is configured in seconds, but virNetDevBridgeSetSTPDelay * expects milliseconds */ - if (virNetDevBridgeSetSTPDelay(network->def->bridge, - network->def->delay * 1000) < 0) + if (virNetDevBridgeSetSTPDelay(def->bridge, def->delay * 1000) < 0) goto err1; - if (virNetDevBridgeSetSTP(network->def->bridge, - network->def->stp ? true : false) < 0) + if (virNetDevBridgeSetSTP(def->bridge, def->stp ? true : false) < 0) goto err1; /* Disable IPv6 on the bridge if there are no IPv6 addresses * defined, and set other IPv6 sysctl tunables appropriately. */ - if (networkSetIPv6Sysctls(network) < 0) + if (networkSetIPv6Sysctls(obj) < 0) goto err1; /* Add "once per network" rules */ - if (network->def->forward.type != VIR_NETWORK_FORWARD_OPEN && - networkAddFirewallRules(network->def) < 0) + if (def->forward.type != VIR_NETWORK_FORWARD_OPEN && + networkAddFirewallRules(def) < 0) goto err1; - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_UNSPEC, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_UNSPEC, i)); i++) { if (VIR_SOCKET_ADDR_IS_FAMILY(&ipdef->address, AF_INET)) v4present = true; if (VIR_SOCKET_ADDR_IS_FAMILY(&ipdef->address, AF_INET6)) v6present = true; /* Add the IP address/netmask to the bridge */ - if (networkAddAddrToBridge(network, ipdef) < 0) + if (networkAddAddrToBridge(obj, ipdef) < 0) goto err2; } - if (networkStartHandleMACTableManagerMode(network, macTapIfName) < 0) + if (networkStartHandleMACTableManagerMode(obj, macTapIfName) < 0) goto err2; /* Bring up the bridge interface */ - if (virNetDevSetOnline(network->def->bridge, 1) < 0) + if (virNetDevSetOnline(def->bridge, 1) < 0) goto err2; - for (i = 0; i < network->def->nroutes; i++) { + for (i = 0; i < def->nroutes; i++) { virSocketAddrPtr gateway = NULL; - routedef = network->def->routes[i]; + routedef = def->routes[i]; gateway = virNetDevIPRouteGetGateway(routedef); /* Add the IP route to the bridge */ /* ignore errors, error msg will be generated */ /* but libvirt will not know and net-destroy will work. */ if (VIR_SOCKET_ADDR_VALID(gateway)) { - if (networkAddRouteToBridge(network, routedef) < 0) { + if (networkAddRouteToBridge(obj, routedef) < 0) { /* an error occurred adding the static route */ continue; /* for now, do nothing */ } @@ -2376,7 +2427,7 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, } /* If forward.type != NONE, turn on global IP forwarding */ - if (network->def->forward.type != VIR_NETWORK_FORWARD_NONE && + if (def->forward.type != VIR_NETWORK_FORWARD_NONE && networkEnableIPForwarding(v4present, v6present) < 0) { virReportSystemError(errno, "%s", _("failed to enable IP forwarding")); @@ -2386,17 +2437,17 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, /* start dnsmasq if there are any IP addresses (v4 or v6) */ if ((v4present || v6present) && - networkStartDhcpDaemon(driver, network) < 0) + networkStartDhcpDaemon(driver, obj) < 0) goto err3; /* start radvd if there are any ipv6 addresses */ - if (v6present && networkStartRadvd(driver, network) < 0) + if (v6present && networkStartRadvd(driver, obj) < 0) goto err4; /* dnsmasq does not wait for DAD to complete before daemonizing, * so we need to wait for it ourselves. */ - if (v6present && networkWaitDadFinish(network) < 0) + if (v6present && networkWaitDadFinish(obj) < 0) goto err4; /* DAD has finished, dnsmasq is now bound to the @@ -2408,8 +2459,7 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, VIR_FORCE_CLOSE(tapfd); } - if (virNetDevBandwidthSet(network->def->bridge, - network->def->bandwidth, true) < 0) + if (virNetDevBandwidthSet(def->bridge, def->bandwidth, true) < 0) goto err5; VIR_FREE(macTapIfName); @@ -2418,28 +2468,28 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, return 0; err5: - if (network->def->bandwidth) - virNetDevBandwidthClear(network->def->bridge); + if (def->bandwidth) + virNetDevBandwidthClear(def->bridge); err4: if (!save_err) save_err = virSaveLastError(); - if (network->dnsmasqPid > 0) { - kill(network->dnsmasqPid, SIGTERM); - network->dnsmasqPid = -1; + if ((dnsmasqPid = virNetworkObjPrivateGetDnsmasqPid(obj)) > 0) { + kill(dnsmasqPid, SIGTERM); + virNetworkObjPrivateSetDnsmasqPid(obj, -1); } err3: if (!save_err) save_err = virSaveLastError(); - ignore_value(virNetDevSetOnline(network->def->bridge, 0)); + ignore_value(virNetDevSetOnline(def->bridge, 0)); err2: if (!save_err) save_err = virSaveLastError(); - if (network->def->forward.type != VIR_NETWORK_FORWARD_OPEN) - networkRemoveFirewallRules(network->def); + if (def->forward.type != VIR_NETWORK_FORWARD_OPEN) + networkRemoveFirewallRules(def); err1: if (!save_err) @@ -2455,7 +2505,7 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, err0: if (!save_err) save_err = virSaveLastError(); - ignore_value(virNetDevBridgeDelete(network->def->bridge)); + ignore_value(virNetDevBridgeDelete(def->bridge)); if (save_err) { virSetError(save_err); @@ -2465,71 +2515,77 @@ networkStartNetworkVirtual(virNetworkDriverStatePtr driver, return -1; } + static int networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { - if (network->def->bandwidth) - virNetDevBandwidthClear(network->def->bridge); + virNetworkDefPtr def = virPoolObjGetDef(obj); + pid_t radvdPid = virNetworkObjPrivateGetRadvdPid(obj); + pid_t dnsmasqPid = virNetworkObjPrivateGetDnsmasqPid(obj); + virMacMapPtr macmap = virNetworkObjPrivateGetMacMap(obj); + + if (def->bandwidth) + virNetDevBandwidthClear(def->bridge); - virObjectUnref(network->macmap); + virObjectUnref(macmap); + virNetworkObjPrivateSetMacMap(obj, NULL); - if (network->radvdPid > 0) { + if (radvdPid > 0) { char *radvdpidbase; - kill(network->radvdPid, SIGTERM); + kill(radvdPid, SIGTERM); /* attempt to delete the pidfile we created */ - if ((radvdpidbase = networkRadvdPidfileBasename(network->def->name))) { + if ((radvdpidbase = networkRadvdPidfileBasename(def->name))) { virPidFileDelete(driver->pidDir, radvdpidbase); VIR_FREE(radvdpidbase); } } - if (network->dnsmasqPid > 0) - kill(network->dnsmasqPid, SIGTERM); + if (dnsmasqPid > 0) + kill(dnsmasqPid, SIGTERM); - if (network->def->mac_specified) { - char *macTapIfName = networkBridgeDummyNicName(network->def->bridge); + if (def->mac_specified) { + char *macTapIfName = networkBridgeDummyNicName(def->bridge); if (macTapIfName) { ignore_value(virNetDevTapDelete(macTapIfName, NULL)); VIR_FREE(macTapIfName); } } - ignore_value(virNetDevSetOnline(network->def->bridge, 0)); + ignore_value(virNetDevSetOnline(def->bridge, 0)); - if (network->def->forward.type != VIR_NETWORK_FORWARD_OPEN) - networkRemoveFirewallRules(network->def); + if (def->forward.type != VIR_NETWORK_FORWARD_OPEN) + networkRemoveFirewallRules(def); - ignore_value(virNetDevBridgeDelete(network->def->bridge)); + ignore_value(virNetDevBridgeDelete(def->bridge)); /* See if its still alive and really really kill it */ - if (network->dnsmasqPid > 0 && - (kill(network->dnsmasqPid, 0) == 0)) - kill(network->dnsmasqPid, SIGKILL); - network->dnsmasqPid = -1; + if (dnsmasqPid > 0 && (kill(dnsmasqPid, 0) == 0)) + kill(dnsmasqPid, SIGKILL); + virNetworkObjPrivateSetDnsmasqPid(obj, -1); - if (network->radvdPid > 0 && - (kill(network->radvdPid, 0) == 0)) - kill(network->radvdPid, SIGKILL); - network->radvdPid = -1; + if (radvdPid > 0 && (kill(radvdPid, 0) == 0)) + kill(radvdPid, SIGKILL); + virNetworkObjPrivateSetRadvdPid(obj, -1); return 0; } static int -networkStartNetworkBridge(virNetworkObjPtr network) +networkStartNetworkBridge(virPoolObjPtr obj) { /* put anything here that needs to be done each time a network of * type BRIDGE, is started. On failure, undo anything you've done, * and return -1. On success return 0. */ - return networkStartHandleMACTableManagerMode(network, NULL); + return networkStartHandleMACTableManagerMode(obj, NULL); } + static int -networkShutdownNetworkBridge(virNetworkObjPtr network ATTRIBUTE_UNUSED) +networkShutdownNetworkBridge(virPoolObjPtr obj ATTRIBUTE_UNUSED) { /* put anything here that needs to be done each time a network of * type BRIDGE is shutdown. On failure, undo anything you've done, @@ -2648,17 +2704,21 @@ networkCreateInterfacePool(virNetworkDefPtr netdef) static int -networkStartNetworkExternal(virNetworkObjPtr network) +networkStartNetworkExternal(virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); + /* put anything here that needs to be done each time a network of * type BRIDGE, PRIVATE, VEPA, HOSTDEV or PASSTHROUGH is started. On * failure, undo anything you've done, and return -1. On success * return 0. */ - return networkCreateInterfacePool(network->def); + return networkCreateInterfacePool(def); } -static int networkShutdownNetworkExternal(virNetworkObjPtr network ATTRIBUTE_UNUSED) + +static int +networkShutdownNetworkExternal(virPoolObjPtr obj ATTRIBUTE_UNUSED) { /* put anything here that needs to be done each time a network of * type BRIDGE, PRIVATE, VEPA, HOSTDEV or PASSTHROUGH is shutdown. On @@ -2668,15 +2728,17 @@ static int networkShutdownNetworkExternal(virNetworkObjPtr network ATTRIBUTE_UNU return 0; } + static int networkStartNetwork(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int ret = -1; - VIR_DEBUG("driver=%p, network=%p", driver, network); + VIR_DEBUG("driver=%p, network=%p", driver, obj); - if (virNetworkObjIsActive(network)) { + if (virPoolObjIsActive(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("network is already active")); return ret; @@ -2685,29 +2747,29 @@ networkStartNetwork(virNetworkDriverStatePtr driver, VIR_DEBUG("Beginning network startup process"); VIR_DEBUG("Setting current network def as transient"); - if (virNetworkObjSetDefTransient(network, true) < 0) + if (virNetworkObjSetDefTransient(obj, true) < 0) goto cleanup; /* Run an early hook to set-up missing devices. * If the script raised an error abort the launch. */ - if (networkRunHook(network, NULL, NULL, + if (networkRunHook(obj, NULL, NULL, VIR_HOOK_NETWORK_OP_START, VIR_HOOK_SUBOP_BEGIN) < 0) goto cleanup; - switch (network->def->forward.type) { + switch (def->forward.type) { case VIR_NETWORK_FORWARD_NONE: case VIR_NETWORK_FORWARD_NAT: case VIR_NETWORK_FORWARD_ROUTE: case VIR_NETWORK_FORWARD_OPEN: - if (networkStartNetworkVirtual(driver, network) < 0) + if (networkStartNetworkVirtual(driver, obj) < 0) goto cleanup; break; case VIR_NETWORK_FORWARD_BRIDGE: - if (network->def->bridge) { - if (networkStartNetworkBridge(network) < 0) + if (def->bridge) { + if (networkStartNetworkBridge(obj) < 0) goto cleanup; break; } @@ -2719,13 +2781,13 @@ networkStartNetwork(virNetworkDriverStatePtr driver, case VIR_NETWORK_FORWARD_VEPA: case VIR_NETWORK_FORWARD_PASSTHROUGH: case VIR_NETWORK_FORWARD_HOSTDEV: - if (networkStartNetworkExternal(network) < 0) + if (networkStartNetworkExternal(obj) < 0) goto cleanup; break; } /* finally we can call the 'started' hook script if any */ - if (networkRunHook(network, NULL, NULL, + if (networkRunHook(obj, NULL, NULL, VIR_HOOK_NETWORK_OP_STARTED, VIR_HOOK_SUBOP_BEGIN) < 0) goto cleanup; @@ -2734,19 +2796,19 @@ networkStartNetwork(virNetworkDriverStatePtr driver, * is setup. */ VIR_DEBUG("Writing network status to disk"); - if (virNetworkSaveStatus(driver->stateDir, network) < 0) + if (virNetworkObjSaveStatus(driver->stateDir, obj) < 0) goto cleanup; - network->active = 1; - VIR_INFO("Network '%s' started up", network->def->name); + virPoolObjSetActive(obj, true); + VIR_INFO("Network '%s' started up", def->name); ret = 0; cleanup: if (ret < 0) { - virNetworkObjUnsetDefTransient(network); + virNetworkObjUnsetDefTransient(obj); virErrorPtr save_err = virSaveLastError(); int save_errno = errno; - networkShutdownNetwork(driver, network); + networkShutdownNetwork(driver, obj); virSetError(save_err); virFreeError(save_err); errno = save_errno; @@ -2754,38 +2816,38 @@ networkStartNetwork(virNetworkDriverStatePtr driver, return ret; } + static int networkShutdownNetwork(virNetworkDriverStatePtr driver, - virNetworkObjPtr network) + virPoolObjPtr obj) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int ret = 0; char *stateFile; - VIR_INFO("Shutting down network '%s'", network->def->name); + VIR_INFO("Shutting down network '%s'", def->name); - if (!virNetworkObjIsActive(network)) + if (!virPoolObjIsActive(obj)) return 0; - stateFile = virNetworkConfigFile(driver->stateDir, - network->def->name); - if (!stateFile) + if (!(stateFile = virNetworkConfigFile(driver->stateDir, def->name))) return -1; unlink(stateFile); VIR_FREE(stateFile); - switch (network->def->forward.type) { + switch (def->forward.type) { case VIR_NETWORK_FORWARD_NONE: case VIR_NETWORK_FORWARD_NAT: case VIR_NETWORK_FORWARD_ROUTE: case VIR_NETWORK_FORWARD_OPEN: - ret = networkShutdownNetworkVirtual(driver, network); + ret = networkShutdownNetworkVirtual(driver, obj); break; case VIR_NETWORK_FORWARD_BRIDGE: - if (network->def->bridge) { - ret = networkShutdownNetworkBridge(network); + if (def->bridge) { + ret = networkShutdownNetworkBridge(obj); break; } /* intentionally fall through to the macvtap/direct case for @@ -2796,157 +2858,141 @@ networkShutdownNetwork(virNetworkDriverStatePtr driver, case VIR_NETWORK_FORWARD_VEPA: case VIR_NETWORK_FORWARD_PASSTHROUGH: case VIR_NETWORK_FORWARD_HOSTDEV: - ret = networkShutdownNetworkExternal(network); + ret = networkShutdownNetworkExternal(obj); break; } /* now that we know it's stopped call the hook if present */ - networkRunHook(network, NULL, NULL, VIR_HOOK_NETWORK_OP_STOPPED, + networkRunHook(obj, NULL, NULL, VIR_HOOK_NETWORK_OP_STOPPED, VIR_HOOK_SUBOP_END); - network->active = 0; - virNetworkObjUnsetDefTransient(network); + virPoolObjSetActive(obj, false); + virNetworkObjUnsetDefTransient(obj); return ret; } -static virNetworkPtr networkLookupByUUID(virConnectPtr conn, - const unsigned char *uuid) +static virNetworkPtr +networkLookupByUUID(virConnectPtr conn, + const unsigned char *uuid) { - virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkPtr ret = NULL; - network = virNetworkObjFindByUUID(driver->networks, uuid); - if (!network) { - char uuidstr[VIR_UUID_STRING_BUFLEN]; - virUUIDFormat(uuid, uuidstr); - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching uuid '%s'"), - uuidstr); - goto cleanup; - } + if (!(obj = networkObjFindByUUID(uuid, NULL))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNetworkLookupByUUIDEnsureACL(conn, network->def) < 0) + if (virNetworkLookupByUUIDEnsureACL(conn, def) < 0) goto cleanup; - ret = virGetNetwork(conn, network->def->name, network->def->uuid); + ret = virGetNetwork(conn, def->name, def->uuid); cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static virNetworkPtr networkLookupByName(virConnectPtr conn, - const char *name) + +static virNetworkPtr +networkLookupByName(virConnectPtr conn, + const char *name) { - virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkPtr ret = NULL; - network = virNetworkObjFindByName(driver->networks, name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), name); - goto cleanup; - } + if (!(obj = networkObjFindByName(name))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNetworkLookupByNameEnsureACL(conn, network->def) < 0) + if (virNetworkLookupByNameEnsureACL(conn, def) < 0) goto cleanup; - ret = virGetNetwork(conn, network->def->name, network->def->uuid); + ret = virGetNetwork(conn, def->name, def->uuid); cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static int networkConnectNumOfNetworks(virConnectPtr conn) + +static int +networkConnectNumOfNetworks(virConnectPtr conn) { virNetworkDriverStatePtr driver = networkGetDriver(); - int nactive; if (virConnectNumOfNetworksEnsureACL(conn) < 0) return -1; - nactive = virNetworkObjListNumOfNetworks(driver->networks, - true, - virConnectNumOfNetworksCheckACL, - conn); - - return nactive; + return virNetworkObjNumOfNetworks(driver->networks, conn, true, + virConnectNumOfNetworksCheckACL); } -static int networkConnectListNetworks(virConnectPtr conn, - char **const names, - int nnames) + +static int +networkConnectListNetworks(virConnectPtr conn, + char **const names, + int maxnames) { virNetworkDriverStatePtr driver = networkGetDriver(); - int got = 0; if (virConnectListNetworksEnsureACL(conn) < 0) return -1; - got = virNetworkObjListGetNames(driver->networks, - true, names, nnames, - virConnectListNetworksCheckACL, - conn); - - return got; + return virNetworkObjGetNames(driver->networks, conn, true, + virConnectListNetworksCheckACL, + names, maxnames); } -static int networkConnectNumOfDefinedNetworks(virConnectPtr conn) + +static int +networkConnectNumOfDefinedNetworks(virConnectPtr conn) { virNetworkDriverStatePtr driver = networkGetDriver(); - int ninactive = 0; if (virConnectNumOfDefinedNetworksEnsureACL(conn) < 0) return -1; - ninactive = virNetworkObjListNumOfNetworks(driver->networks, - false, - virConnectNumOfDefinedNetworksCheckACL, - conn); - - return ninactive; + return virNetworkObjNumOfNetworks(driver->networks, conn, false, + virConnectNumOfDefinedNetworksCheckACL); } -static int networkConnectListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) + +static int +networkConnectListDefinedNetworks(virConnectPtr conn, + char **const names, + int maxnames) { virNetworkDriverStatePtr driver = networkGetDriver(); - int got = 0; if (virConnectListDefinedNetworksEnsureACL(conn) < 0) return -1; - got = virNetworkObjListGetNames(driver->networks, - false, names, nnames, - virConnectListDefinedNetworksCheckACL, - conn); - return got; + return virNetworkObjGetNames(driver->networks, conn, false, + virConnectListDefinedNetworksCheckACL, + names, maxnames); } + static int networkConnectListAllNetworks(virConnectPtr conn, virNetworkPtr **nets, unsigned int flags) { virNetworkDriverStatePtr driver = networkGetDriver(); - int ret = -1; virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1); if (virConnectListAllNetworksEnsureACL(conn) < 0) - goto cleanup; - - ret = virNetworkObjListExport(conn, driver->networks, nets, - virConnectListAllNetworksCheckACL, - flags); + return -1; - cleanup: - return ret; + return virNetworkObjExportList(conn, driver->networks, nets, + virConnectListAllNetworksCheckACL, flags); } + static int networkConnectNetworkEventRegisterAny(virConnectPtr conn, virNetworkPtr net, @@ -2991,39 +3037,46 @@ networkConnectNetworkEventDeregisterAny(virConnectPtr conn, return ret; } -static int networkIsActive(virNetworkPtr net) +static int +networkIsActive(virNetworkPtr net) { - virNetworkObjPtr obj; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; if (!(obj = networkObjFromNetwork(net))) - return ret; + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkIsActiveEnsureACL(net->conn, obj->def) < 0) + if (virNetworkIsActiveEnsureACL(net->conn, def) < 0) goto cleanup; - ret = virNetworkObjIsActive(obj); + ret = virPoolObjIsActive(obj); cleanup: - virNetworkObjEndAPI(&obj); + virPoolObjEndAPI(&obj); return ret; } -static int networkIsPersistent(virNetworkPtr net) + +static int +networkIsPersistent(virNetworkPtr net) { - virNetworkObjPtr obj; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; if (!(obj = networkObjFromNetwork(net))) - return ret; + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkIsPersistentEnsureACL(net->conn, obj->def) < 0) + if (virNetworkIsPersistentEnsureACL(net->conn, def) < 0) goto cleanup; - ret = obj->persistent; + ret = virPoolObjIsPersistent(obj); cleanup: - virNetworkObjEndAPI(&obj); + virPoolObjEndAPI(&obj); return ret; } @@ -3035,7 +3088,7 @@ static int networkIsPersistent(virNetworkPtr net) * than libvirt). Set this network's name to that new name. */ static int -networkFindUnusedBridgeName(virNetworkObjListPtr nets, +networkFindUnusedBridgeName(virPoolObjTablePtr netobjs, virNetworkDefPtr def) { @@ -3057,9 +3110,9 @@ networkFindUnusedBridgeName(virNetworkObjListPtr nets, * from virNetDevExists(), just in case it isn't implemented * on this platform (probably impossible). */ - if (!(virNetworkBridgeInUse(nets, newname, def->name) || + if (!(virNetworkObjBridgeInUse(netobjs, newname, def->name) || virNetDevExists(newname) == 1)) { - VIR_FREE(def->bridge); /*could contain template */ + VIR_FREE(def->bridge); /* could contain template */ def->bridge = newname; ret = 0; goto cleanup; @@ -3087,13 +3140,13 @@ networkFindUnusedBridgeName(virNetworkObjListPtr nets, * network's bridge name. */ static int -networkBridgeNameValidate(virNetworkObjListPtr nets, +networkBridgeNameValidate(virPoolObjTablePtr netobjs, virNetworkDefPtr def) { int ret = -1; if (def->bridge && !strstr(def->bridge, "%d")) { - if (virNetworkBridgeInUse(nets, def->bridge, def->name)) { + if (virNetworkObjBridgeInUse(netobjs, def->bridge, def->name)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("bridge name '%s' already in use."), def->bridge); @@ -3101,7 +3154,7 @@ networkBridgeNameValidate(virNetworkObjListPtr nets, } } else { /* Allocate a bridge name */ - if (networkFindUnusedBridgeName(nets, def) < 0) + if (networkFindUnusedBridgeName(netobjs, def) < 0) goto cleanup; } @@ -3348,11 +3401,14 @@ networkValidate(virNetworkDriverStatePtr driver, return 0; } -static virNetworkPtr networkCreateXML(virConnectPtr conn, const char *xml) +static virNetworkPtr +networkCreateXML(virConnectPtr conn, + const char *xml) { virNetworkDriverStatePtr driver = networkGetDriver(); virNetworkDefPtr def; - virNetworkObjPtr network = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr objdef; virNetworkPtr ret = NULL; virObjectEventPtr event = NULL; @@ -3369,40 +3425,42 @@ static virNetworkPtr networkCreateXML(virConnectPtr conn, const char *xml) * we assign the def with live = true in anticipation that it will * be started momentarily. */ - if (!(network = virNetworkAssignDef(driver->networks, def, - VIR_NETWORK_OBJ_LIST_ADD_LIVE | - VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE))) + if (!(obj = virNetworkObjAdd(driver->networks, def, + VIR_NETWORK_OBJ_LIST_ADD_LIVE | + VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE))) goto cleanup; - def = NULL; + VIR_STEAL_PTR(objdef, def); - if (networkStartNetwork(driver, network) < 0) { - virNetworkRemoveInactive(driver->networks, - network); + if (networkStartNetwork(driver, obj) < 0) { + virPoolObjTableRemove(driver->networks, &obj); goto cleanup; } - event = virNetworkEventLifecycleNew(network->def->name, - network->def->uuid, + event = virNetworkEventLifecycleNew(objdef->name, + objdef->uuid, VIR_NETWORK_EVENT_STARTED, 0); - VIR_INFO("Creating network '%s'", network->def->name); - ret = virGetNetwork(conn, network->def->name, network->def->uuid); + VIR_INFO("Creating network '%s'", objdef->name); + ret = virGetNetwork(conn, objdef->name, objdef->uuid); cleanup: virNetworkDefFree(def); if (event) virObjectEventStateQueue(driver->networkEventState, event); - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static virNetworkPtr networkDefineXML(virConnectPtr conn, const char *xml) + +static virNetworkPtr +networkDefineXML(virConnectPtr conn, + const char *xml) { virNetworkDriverStatePtr driver = networkGetDriver(); virNetworkDefPtr def = NULL; - bool freeDef = true; - virNetworkObjPtr network = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr objdef; virNetworkPtr ret = NULL; virObjectEventPtr event = NULL; @@ -3415,86 +3473,86 @@ static virNetworkPtr networkDefineXML(virConnectPtr conn, const char *xml) if (networkValidate(driver, def) < 0) goto cleanup; - if (!(network = virNetworkAssignDef(driver->networks, def, 0))) + if (!(obj = virNetworkObjAdd(driver->networks, def, 0))) goto cleanup; + VIR_STEAL_PTR(objdef, def); - /* def was assigned to network object */ - freeDef = false; - - if (virNetworkSaveConfig(driver->networkConfigDir, def) < 0) { - if (!virNetworkObjIsActive(network)) { - virNetworkRemoveInactive(driver->networks, network); + if (virNetworkSaveConfig(driver->networkConfigDir, objdef) < 0) { + if (!virPoolObjIsActive(obj)) { + virPoolObjTableRemove(driver->networks, &obj); goto cleanup; } /* if network was active already, just undo new persistent * definition by making it transient. * XXX - this isn't necessarily the correct thing to do. */ - virNetworkObjAssignDef(network, NULL, false); + virNetworkObjAssignDef(obj, NULL); goto cleanup; } - event = virNetworkEventLifecycleNew(def->name, def->uuid, + event = virNetworkEventLifecycleNew(objdef->name, objdef->uuid, VIR_NETWORK_EVENT_DEFINED, 0); - VIR_INFO("Defining network '%s'", def->name); - ret = virGetNetwork(conn, def->name, def->uuid); + VIR_INFO("Defining network '%s'", objdef->name); + ret = virGetNetwork(conn, objdef->name, objdef->uuid); cleanup: if (event) virObjectEventStateQueue(driver->networkEventState, event); - if (freeDef) - virNetworkDefFree(def); - virNetworkObjEndAPI(&network); + virNetworkDefFree(def); + virPoolObjEndAPI(&obj); return ret; } + static int networkUndefine(virNetworkPtr net) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; bool active = false; virObjectEventPtr event = NULL; - if (!(network = networkObjFromNetwork(net))) - goto cleanup; + if (!(obj = networkObjFromNetwork(net))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkUndefineEnsureACL(net->conn, network->def) < 0) + if (virNetworkUndefineEnsureACL(net->conn, def) < 0) goto cleanup; - if (virNetworkObjIsActive(network)) + if (virPoolObjIsActive(obj)) active = true; - if (!network->persistent) { + if (!virPoolObjIsPersistent(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("can't undefine transient network")); goto cleanup; } /* remove autostart link */ - if (virNetworkDeleteConfig(driver->networkConfigDir, - driver->networkAutostartDir, - network) < 0) + if (virNetworkObjDeleteConfig(driver->networkConfigDir, + driver->networkAutostartDir, + obj) < 0) goto cleanup; - event = virNetworkEventLifecycleNew(network->def->name, - network->def->uuid, + event = virNetworkEventLifecycleNew(def->name, + def->uuid, VIR_NETWORK_EVENT_UNDEFINED, 0); - VIR_INFO("Undefining network '%s'", network->def->name); + VIR_INFO("Undefining network '%s'", def->name); if (!active) { - if (networkRemoveInactive(driver, network) < 0) + if (networkRemoveInactive(driver, &obj) < 0) goto cleanup; } else { /* if the network still exists, it was active, and we need to make * it transient (by deleting the persistent def) */ - virNetworkObjAssignDef(network, NULL, false); + virNetworkObjAssignDef(obj, NULL); } ret = 0; @@ -3502,10 +3560,11 @@ networkUndefine(virNetworkPtr net) cleanup: if (event) virObjectEventStateQueue(driver->networkEventState, event); - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } + static int networkUpdate(virNetworkPtr net, unsigned int command, @@ -3515,7 +3574,8 @@ networkUpdate(virNetworkPtr net, unsigned int flags) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr def = virPoolObjGetDef(obj); int isActive, ret = -1; size_t i; virNetworkIPDefPtr ipdef; @@ -3527,16 +3587,14 @@ networkUpdate(virNetworkPtr net, VIR_NETWORK_UPDATE_AFFECT_CONFIG, -1); - if (!(network = networkObjFromNetwork(net))) - goto cleanup; + if (!(obj = networkObjFromNetwork(net))) + return -1; - if (virNetworkUpdateEnsureACL(net->conn, network->def, flags) < 0) + if (virNetworkUpdateEnsureACL(net->conn, def, flags) < 0) goto cleanup; /* see if we are listening for dhcp pre-modification */ - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET, i)); - i++) { + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET, i)); i++) { if (ipdef->nranges || ipdef->nhosts) { oldDhcpActive = true; break; @@ -3546,7 +3604,7 @@ networkUpdate(virNetworkPtr net, /* VIR_NETWORK_UPDATE_AFFECT_CURRENT means "change LIVE if network * is active, else change CONFIG */ - isActive = virNetworkObjIsActive(network); + isActive = virPoolObjIsActive(obj); if ((flags & (VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG)) == VIR_NETWORK_UPDATE_AFFECT_CURRENT) { @@ -3560,9 +3618,9 @@ networkUpdate(virNetworkPtr net, /* Take care of anything that must be done before updating the * live NetworkDef. */ - if (network->def->forward.type == VIR_NETWORK_FORWARD_NONE || - network->def->forward.type == VIR_NETWORK_FORWARD_NAT || - network->def->forward.type == VIR_NETWORK_FORWARD_ROUTE) { + if (def->forward.type == VIR_NETWORK_FORWARD_NONE || + def->forward.type == VIR_NETWORK_FORWARD_NAT || + def->forward.type == VIR_NETWORK_FORWARD_ROUTE) { switch (section) { case VIR_NETWORK_SECTION_FORWARD: case VIR_NETWORK_SECTION_FORWARD_INTERFACE: @@ -3573,8 +3631,8 @@ networkUpdate(virNetworkPtr net, * old rules (and remember to load new ones after the * update). */ - if (network->def->forward.type != VIR_NETWORK_FORWARD_OPEN) { - networkRemoveFirewallRules(network->def); + if (def->forward.type != VIR_NETWORK_FORWARD_OPEN) { + networkRemoveFirewallRules(def); needFirewallRefresh = true; } break; @@ -3585,19 +3643,20 @@ networkUpdate(virNetworkPtr net, } /* update the network config in memory/on disk */ - if (virNetworkObjUpdate(network, command, section, parentIndex, xml, flags) < 0) { + if (virNetworkObjUpdate(obj, command, section, parentIndex, + xml, flags) < 0) { if (needFirewallRefresh) - ignore_value(networkAddFirewallRules(network->def)); + ignore_value(networkAddFirewallRules(def)); goto cleanup; } - if (needFirewallRefresh && networkAddFirewallRules(network->def) < 0) + if (needFirewallRefresh && networkAddFirewallRules(def) < 0) goto cleanup; if (flags & VIR_NETWORK_UPDATE_AFFECT_CONFIG) { /* save updated persistent config to disk */ if (virNetworkSaveConfig(driver->networkConfigDir, - virNetworkObjGetPersistentDef(network)) < 0) { + virNetworkObjGetPersistentDef(obj)) < 0) { goto cleanup; } } @@ -3620,7 +3679,7 @@ networkUpdate(virNetworkPtr net, * to "nobody" after it starts, and is unable to re-read * the conf file (owned by root, mode 600) */ - if (networkRestartDhcpDaemon(driver, network) < 0) + if (networkRestartDhcpDaemon(driver, obj) < 0) goto cleanup; } else if (section == VIR_NETWORK_SECTION_IP_DHCP_HOST) { @@ -3631,8 +3690,7 @@ networkUpdate(virNetworkPtr net, */ bool newDhcpActive = false; - for (i = 0; - (ipdef = virNetworkDefGetIPByIndex(network->def, AF_INET, i)); + for (i = 0; (ipdef = virNetworkDefGetIPByIndex(def, AF_INET, i)); i++) { if (ipdef->nranges || ipdef->nhosts) { newDhcpActive = true; @@ -3641,8 +3699,8 @@ networkUpdate(virNetworkPtr net, } if ((newDhcpActive != oldDhcpActive && - networkRestartDhcpDaemon(driver, network) < 0) || - networkRefreshDhcpDaemon(driver, network) < 0) { + networkRestartDhcpDaemon(driver, obj) < 0) || + networkRefreshDhcpDaemon(driver, obj) < 0) { goto cleanup; } @@ -3651,95 +3709,102 @@ networkUpdate(virNetworkPtr net, * (not the .conf file) so we can just update the config * files and send SIGHUP to dnsmasq. */ - if (networkRefreshDhcpDaemon(driver, network) < 0) + if (networkRefreshDhcpDaemon(driver, obj) < 0) goto cleanup; } if (section == VIR_NETWORK_SECTION_IP) { - /* only a change in IP addresses will affect radvd, and all of radvd's - * config is stored in the conf file which will be re-read with a SIGHUP. - */ - if (networkRefreshRadvd(driver, network) < 0) + /* only a change in IP addresses will affect radvd, and all + * of radvd's config is stored in the conf file which will + * be re-read with a SIGHUP. */ + if (networkRefreshRadvd(driver, obj) < 0) goto cleanup; } /* save current network state to disk */ - if ((ret = virNetworkSaveStatus(driver->stateDir, - network)) < 0) { + if ((ret = virNetworkObjSaveStatus(driver->stateDir, obj)) < 0) goto cleanup; - } } /* call the 'updated' network hook script */ - if (networkRunHook(network, NULL, NULL, VIR_HOOK_NETWORK_OP_UPDATED, + if (networkRunHook(obj, NULL, NULL, VIR_HOOK_NETWORK_OP_UPDATED, VIR_HOOK_SUBOP_BEGIN) < 0) goto cleanup; ret = 0; + cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static int networkCreate(virNetworkPtr net) + +static int +networkCreate(virNetworkPtr net) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; virObjectEventPtr event = NULL; - if (!(network = networkObjFromNetwork(net))) - goto cleanup; + if (!(obj = networkObjFromNetwork(net))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkCreateEnsureACL(net->conn, network->def) < 0) + if (virNetworkCreateEnsureACL(net->conn, def) < 0) goto cleanup; - if ((ret = networkStartNetwork(driver, network)) < 0) + if ((ret = networkStartNetwork(driver, obj)) < 0) goto cleanup; - event = virNetworkEventLifecycleNew(network->def->name, - network->def->uuid, + event = virNetworkEventLifecycleNew(def->name, + def->uuid, VIR_NETWORK_EVENT_STARTED, 0); cleanup: if (event) virObjectEventStateQueue(driver->networkEventState, event); - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static int networkDestroy(virNetworkPtr net) + +static int +networkDestroy(virNetworkPtr net) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; virObjectEventPtr event = NULL; - if (!(network = networkObjFromNetwork(net))) - goto cleanup; + if (!(obj = networkObjFromNetwork(net))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkDestroyEnsureACL(net->conn, network->def) < 0) + if (virNetworkDestroyEnsureACL(net->conn, def) < 0) goto cleanup; - if (!virNetworkObjIsActive(network)) { + if (!virPoolObjIsActive(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, _("network '%s' is not active"), - network->def->name); + def->name); goto cleanup; } - if ((ret = networkShutdownNetwork(driver, network)) < 0) + if ((ret = networkShutdownNetwork(driver, obj)) < 0) goto cleanup; - event = virNetworkEventLifecycleNew(network->def->name, - network->def->uuid, + event = virNetworkEventLifecycleNew(def->name, + def->uuid, VIR_NETWORK_EVENT_STOPPED, 0); - if (!network->persistent && - networkRemoveInactive(driver, network) < 0) { + if (!virPoolObjIsPersistent(obj) && + networkRemoveInactive(driver, &obj) < 0) { ret = -1; goto cleanup; } @@ -3747,108 +3812,130 @@ static int networkDestroy(virNetworkPtr net) cleanup: if (event) virObjectEventStateQueue(driver->networkEventState, event); - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static char *networkGetXMLDesc(virNetworkPtr net, - unsigned int flags) + +static char +*networkGetXMLDesc(virNetworkPtr net, + unsigned int flags) { - virNetworkObjPtr network; + virPoolObjPtr obj; virNetworkDefPtr def; + virNetworkDefPtr newDef; char *ret = NULL; virCheckFlags(VIR_NETWORK_XML_INACTIVE, NULL); - if (!(network = networkObjFromNetwork(net))) - return ret; + if (!(obj = networkObjFromNetwork(net))) + return NULL; + def = virPoolObjGetDef(obj); + newDef = virPoolObjGetNewDef(obj); - if (virNetworkGetXMLDescEnsureACL(net->conn, network->def) < 0) + if (virNetworkGetXMLDescEnsureACL(net->conn, def) < 0) goto cleanup; - if ((flags & VIR_NETWORK_XML_INACTIVE) && network->newDef) - def = network->newDef; - else - def = network->def; + if ((flags & VIR_NETWORK_XML_INACTIVE) && newDef) + def = newDef; ret = virNetworkDefFormat(def, flags); cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static char *networkGetBridgeName(virNetworkPtr net) { - virNetworkObjPtr network; + +static char * +networkGetBridgeName(virNetworkPtr net) +{ + virPoolObjPtr obj; + virNetworkDefPtr def; char *bridge = NULL; - if (!(network = networkObjFromNetwork(net))) - return bridge; + if (!(obj = networkObjFromNetwork(net))) + return NULL; + def = virPoolObjGetDef(obj); - if (virNetworkGetBridgeNameEnsureACL(net->conn, network->def) < 0) + if (virNetworkGetBridgeNameEnsureACL(net->conn, def) < 0) goto cleanup; - if (!(network->def->bridge)) { + if (!def->bridge) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' does not have a bridge name."), - network->def->name); + def->name); goto cleanup; } - ignore_value(VIR_STRDUP(bridge, network->def->bridge)); + ignore_value(VIR_STRDUP(bridge, def->bridge)); cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return bridge; } -static int networkGetAutostart(virNetworkPtr net, - int *autostart) + +static int +networkGetAutostart(virNetworkPtr net, + int *autostart) { - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; - if (!(network = networkObjFromNetwork(net))) - return ret; + if (!(obj = networkObjFromNetwork(net))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkGetAutostartEnsureACL(net->conn, network->def) < 0) + if (virNetworkGetAutostartEnsureACL(net->conn, def) < 0) goto cleanup; - *autostart = network->autostart; + *autostart = 0; + if (virPoolObjIsAutostart(obj)) + *autostart = 1; + ret = 0; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static int networkSetAutostart(virNetworkPtr net, - int autostart) + +static int +networkSetAutostart(virNetworkPtr net, + int new_autostart) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network; + virPoolObjPtr obj; + virNetworkDefPtr def; + bool autostart; char *configFile = NULL, *autostartLink = NULL; int ret = -1; + if (!(obj = networkObjFromNetwork(net))) + return -1; + def = virPoolObjGetDef(obj); - if (!(network = networkObjFromNetwork(net))) - goto cleanup; - - if (virNetworkSetAutostartEnsureACL(net->conn, network->def) < 0) + if (virNetworkSetAutostartEnsureACL(net->conn, def) < 0) goto cleanup; - if (!network->persistent) { + if (!virPoolObjIsPersistent(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("cannot set autostart for transient network")); goto cleanup; } - autostart = (autostart != 0); + autostart = (new_autostart != 0); - if (network->autostart != autostart) { - if ((configFile = virNetworkConfigFile(driver->networkConfigDir, network->def->name)) == NULL) + if (virPoolObjIsAutostart(obj) != autostart) { + if (!(configFile = virNetworkConfigFile(driver->networkConfigDir, + def->name))) goto cleanup; - if ((autostartLink = virNetworkConfigFile(driver->networkAutostartDir, network->def->name)) == NULL) + + if (!(autostartLink = virNetworkConfigFile(driver->networkAutostartDir, + def->name))) goto cleanup; if (autostart) { @@ -3866,7 +3953,8 @@ static int networkSetAutostart(virNetworkPtr net, goto cleanup; } } else { - if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) { + if (unlink(autostartLink) < 0 && + errno != ENOENT && errno != ENOTDIR) { virReportSystemError(errno, _("Failed to delete symlink '%s'"), autostartLink); @@ -3874,17 +3962,18 @@ static int networkSetAutostart(virNetworkPtr net, } } - network->autostart = autostart; + virPoolObjSetAutostart(obj, autostart); } ret = 0; cleanup: VIR_FREE(configFile); VIR_FREE(autostartLink); - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } + static int networkGetDHCPLeases(virNetworkPtr network, const char *mac, @@ -3910,7 +3999,8 @@ networkGetDHCPLeases(virNetworkPtr network, virNetworkIPDefPtr ipdef_tmp = NULL; virNetworkDHCPLeasePtr lease = NULL; virNetworkDHCPLeasePtr *leases_ret = NULL; - virNetworkObjPtr obj; + virPoolObjPtr obj; + virNetworkDefPtr def; virMacAddr mac_addr; virCheckFlags(0, -1); @@ -3923,12 +4013,13 @@ networkGetDHCPLeases(virNetworkPtr network, if (!(obj = networkObjFromNetwork(network))) return -1; + def = virPoolObjGetDef(obj); - if (virNetworkGetDHCPLeasesEnsureACL(network->conn, obj->def) < 0) + if (virNetworkGetDHCPLeasesEnsureACL(network->conn, def) < 0) goto cleanup; /* Retrieve custom leases file location */ - custom_lease_file = networkDnsmasqLeaseFileNameCustom(driver, obj->def->bridge); + custom_lease_file = networkDnsmasqLeaseFileNameCustom(driver, def->bridge); /* Read entire contents */ if ((custom_lease_file_len = virFileReadAll(custom_lease_file, @@ -3964,7 +4055,8 @@ networkGetDHCPLeases(virNetworkPtr network, goto error; } - if (!(mac_tmp = virJSONValueObjectGetString(lease_tmp, "mac-address"))) { + if (!(mac_tmp = virJSONValueObjectGetString(lease_tmp, + "mac-address"))) { /* leaseshelper program guarantees that lease will be stored only if * mac-address is known otherwise not */ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -3975,7 +4067,8 @@ networkGetDHCPLeases(virNetworkPtr network, if (mac && virMacAddrCompare(mac, mac_tmp)) continue; - if (virJSONValueObjectGetNumberLong(lease_tmp, "expiry-time", &expirytime_tmp) < 0) { + if (virJSONValueObjectGetNumberLong(lease_tmp, "expiry-time", + &expirytime_tmp) < 0) { /* A lease cannot be present without expiry-time */ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("found lease without expiry-time")); @@ -3992,7 +4085,8 @@ networkGetDHCPLeases(virNetworkPtr network, lease->expirytime = expirytime_tmp; - if (!(ip_tmp = virJSONValueObjectGetString(lease_tmp, "ip-address"))) { + if (!(ip_tmp = virJSONValueObjectGetString(lease_tmp, + "ip-address"))) { /* A lease without ip-address makes no sense */ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("found lease without ip-address")); @@ -4004,8 +4098,8 @@ networkGetDHCPLeases(virNetworkPtr network, lease->type = ipv6 ? VIR_IP_ADDR_TYPE_IPV6 : VIR_IP_ADDR_TYPE_IPV4; /* Obtain prefix */ - for (j = 0; j < obj->def->nips; j++) { - ipdef_tmp = &obj->def->ips[j]; + for (j = 0; j < def->nips; j++) { + ipdef_tmp = &def->ips[j]; if (ipv6 && VIR_SOCKET_ADDR_IS_FAMILY(&ipdef_tmp->address, AF_INET6)) { @@ -4023,7 +4117,7 @@ networkGetDHCPLeases(virNetworkPtr network, if ((VIR_STRDUP(lease->mac, mac_tmp) < 0) || (VIR_STRDUP(lease->ipaddr, ip_tmp) < 0) || - (VIR_STRDUP(lease->iface, obj->def->bridge) < 0)) + (VIR_STRDUP(lease->iface, def->bridge) < 0)) goto error; /* Fields that can be NULL */ @@ -4060,7 +4154,7 @@ networkGetDHCPLeases(virNetworkPtr network, VIR_FREE(custom_lease_file); virJSONValueFree(leases_array); - virNetworkObjEndAPI(&obj); + virPoolObjEndAPI(&obj); return rv; @@ -4180,8 +4274,8 @@ networkAllocateActualDevice(virDomainDefPtr dom, { virNetworkDriverStatePtr driver = networkGetDriver(); virDomainNetType actualType = iface->type; - virNetworkObjPtr network = NULL; - virNetworkDefPtr netdef = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr def = NULL; virNetDevBandwidthPtr bandwidth = NULL; virPortGroupDefPtr portgroup = NULL; virNetDevVPortProfilePtr virtport = iface->virtPortProfile; @@ -4196,19 +4290,14 @@ networkAllocateActualDevice(virDomainDefPtr dom, virDomainActualNetDefFree(iface->data.network.actual); iface->data.network.actual = NULL; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); + if (!(obj = networkObjFindByName(iface->data.network.name))) goto error; - } - netdef = network->def; + def = virPoolObjGetDef(obj); - if (!virNetworkObjIsActive(network)) { + if (!virPoolObjIsActive(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, _("network '%s' is not active"), - netdef->name); + def->name); goto error; } @@ -4219,7 +4308,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, * for bandwidth information, so we need to check for that and * fill it in appropriately for all forward types. */ - portgroup = virPortGroupFindByName(netdef, iface->data.network.portgroup); + portgroup = virPortGroupFindByName(def, iface->data.network.portgroup); /* If there is already interface-specific bandwidth, just use that * (already in NetDef). Otherwise, if there is bandwidth info in @@ -4240,8 +4329,8 @@ networkAllocateActualDevice(virDomainDefPtr dom, vlan = &iface->vlan; else if (portgroup && portgroup->vlan.nTags > 0) vlan = &portgroup->vlan; - else if (netdef->vlan.nTags > 0) - vlan = &netdef->vlan; + else if (def->vlan.nTags > 0) + vlan = &def->vlan; if (vlan && virNetDevVlanCopy(&iface->data.network.actual->vlan, vlan) < 0) goto error; @@ -4252,14 +4341,14 @@ networkAllocateActualDevice(virDomainDefPtr dom, else if (portgroup && portgroup->trustGuestRxFilters) iface->data.network.actual->trustGuestRxFilters = portgroup->trustGuestRxFilters; - else if (netdef->trustGuestRxFilters) + else if (def->trustGuestRxFilters) iface->data.network.actual->trustGuestRxFilters - = netdef->trustGuestRxFilters; + = def->trustGuestRxFilters; - if ((netdef->forward.type == VIR_NETWORK_FORWARD_NONE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_NAT) || - (netdef->forward.type == VIR_NETWORK_FORWARD_ROUTE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_OPEN)) { + if ((def->forward.type == VIR_NETWORK_FORWARD_NONE) || + (def->forward.type == VIR_NETWORK_FORWARD_NAT) || + (def->forward.type == VIR_NETWORK_FORWARD_ROUTE) || + (def->forward.type == VIR_NETWORK_FORWARD_OPEN)) { /* for these forward types, the actual net type really *is* * NETWORK; we just keep the info from the portgroup in * iface->data.network.actual @@ -4272,16 +4361,16 @@ networkAllocateActualDevice(virDomainDefPtr dom, * bridge and set flood/learning mode on the tap device) */ if (VIR_STRDUP(iface->data.network.actual->data.bridge.brname, - netdef->bridge) < 0) + def->bridge) < 0) goto error; iface->data.network.actual->data.bridge.macTableManager - = netdef->macTableManager; + = def->macTableManager; - if (networkPlugBandwidth(network, iface) < 0) + if (networkPlugBandwidth(obj, iface) < 0) goto error; - } else if ((netdef->forward.type == VIR_NETWORK_FORWARD_BRIDGE) && - netdef->bridge) { + } else if ((def->forward.type == VIR_NETWORK_FORWARD_BRIDGE) && + def->bridge) { /* <forward type='bridge'/> <bridge name='xxx'/> * is VIR_DOMAIN_NET_TYPE_BRIDGE @@ -4289,17 +4378,17 @@ networkAllocateActualDevice(virDomainDefPtr dom, iface->data.network.actual->type = actualType = VIR_DOMAIN_NET_TYPE_BRIDGE; if (VIR_STRDUP(iface->data.network.actual->data.bridge.brname, - netdef->bridge) < 0) + def->bridge) < 0) goto error; iface->data.network.actual->data.bridge.macTableManager - = netdef->macTableManager; + = def->macTableManager; /* merge virtualports from interface, network, and portgroup to * arrive at actual virtualport to use */ if (virNetDevVPortProfileMerge3(&iface->data.network.actual->virtPortProfile, iface->virtPortProfile, - netdef->virtPortProfile, + def->virtPortProfile, portgroup ? portgroup->virtPortProfile : NULL) < 0) { goto error; @@ -4312,23 +4401,23 @@ networkAllocateActualDevice(virDomainDefPtr dom, _("<virtualport type='%s'> not supported for network " "'%s' which uses a bridge device"), virNetDevVPortTypeToString(virtport->virtPortType), - netdef->name); + def->name); goto error; } } - } else if (netdef->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { + } else if (def->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { virDomainHostdevSubsysPCIBackendType backend; iface->data.network.actual->type = actualType = VIR_DOMAIN_NET_TYPE_HOSTDEV; - if (networkCreateInterfacePool(netdef) < 0) + if (networkCreateInterfacePool(def) < 0) goto error; /* pick first dev with 0 connections */ - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].connections == 0) { - dev = &netdef->forward.ifs[i]; + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].connections == 0) { + dev = &def->forward.ifs[i]; break; } } @@ -4336,18 +4425,18 @@ networkAllocateActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' requires exclusive access " "to interfaces, but none are available"), - netdef->name); + def->name); goto error; } iface->data.network.actual->data.hostdev.def.parent.type = VIR_DOMAIN_DEVICE_NET; iface->data.network.actual->data.hostdev.def.parent.data.net = iface; iface->data.network.actual->data.hostdev.def.info = &iface->info; iface->data.network.actual->data.hostdev.def.mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS; - iface->data.network.actual->data.hostdev.def.managed = netdef->forward.managed ? 1 : 0; + iface->data.network.actual->data.hostdev.def.managed = def->forward.managed ? 1 : 0; iface->data.network.actual->data.hostdev.def.source.subsys.type = dev->type; iface->data.network.actual->data.hostdev.def.source.subsys.u.pci.addr = dev->device.pci; - switch (netdef->forward.driverName) { + switch (def->forward.driverName) { case VIR_NETWORK_FORWARD_DRIVER_NAME_DEFAULT: backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT; break; @@ -4361,7 +4450,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("unrecognized driver name value %d " " in network '%s'"), - netdef->forward.driverName, netdef->name); + def->forward.driverName, def->name); goto error; } iface->data.network.actual->data.hostdev.def.source.subsys.u.pci.backend @@ -4372,7 +4461,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, */ if (virNetDevVPortProfileMerge3(&iface->data.network.actual->virtPortProfile, iface->virtPortProfile, - netdef->virtPortProfile, + def->virtPortProfile, portgroup ? portgroup->virtPortProfile : NULL) < 0) { goto error; @@ -4387,15 +4476,15 @@ networkAllocateActualDevice(virDomainDefPtr dom, "'%s' which uses an SR-IOV Virtual Function " "via PCI passthrough"), virNetDevVPortTypeToString(virtport->virtPortType), - netdef->name); + def->name); goto error; } } - } else if ((netdef->forward.type == VIR_NETWORK_FORWARD_BRIDGE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_PRIVATE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_VEPA) || - (netdef->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH)) { + } else if ((def->forward.type == VIR_NETWORK_FORWARD_BRIDGE) || + (def->forward.type == VIR_NETWORK_FORWARD_PRIVATE) || + (def->forward.type == VIR_NETWORK_FORWARD_VEPA) || + (def->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH)) { /* <forward type='bridge|private|vepa|passthrough'> are all * VIR_DOMAIN_NET_TYPE_DIRECT. @@ -4403,7 +4492,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, /* Set type=direct and appropriate <source mode='xxx'/> */ iface->data.network.actual->type = actualType = VIR_DOMAIN_NET_TYPE_DIRECT; - switch (netdef->forward.type) { + switch (def->forward.type) { case VIR_NETWORK_FORWARD_BRIDGE: iface->data.network.actual->data.direct.mode = VIR_NETDEV_MACVLAN_MODE_BRIDGE; break; @@ -4423,7 +4512,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, */ if (virNetDevVPortProfileMerge3(&iface->data.network.actual->virtPortProfile, iface->virtPortProfile, - netdef->virtPortProfile, + def->virtPortProfile, portgroup ? portgroup->virtPortProfile : NULL) < 0) { goto error; @@ -4437,7 +4526,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, _("<virtualport type='%s'> not supported for network " "'%s' which uses a macvtap device"), virNetDevVPortTypeToString(virtport->virtPortType), - netdef->name); + def->name); goto error; } } @@ -4445,16 +4534,16 @@ networkAllocateActualDevice(virDomainDefPtr dom, /* If there is only a single device, just return it (caller will detect * any error if exclusive use is required but could not be acquired). */ - if ((netdef->forward.nifs <= 0) && (netdef->forward.npfs <= 0)) { + if ((def->forward.nifs <= 0) && (def->forward.npfs <= 0)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' uses a direct mode, but " "has no forward dev and no interface pool"), - netdef->name); + def->name); goto error; } else { /* pick an interface from the pool */ - if (networkCreateInterfacePool(netdef) < 0) + if (networkCreateInterfacePool(def) < 0) goto error; /* PASSTHROUGH mode, and PRIVATE Mode + 802.1Qbh both @@ -4463,25 +4552,25 @@ networkAllocateActualDevice(virDomainDefPtr dom, * just search for the one with the lowest number of * connections. */ - if ((netdef->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH) || - ((netdef->forward.type == VIR_NETWORK_FORWARD_PRIVATE) && + if ((def->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH) || + ((def->forward.type == VIR_NETWORK_FORWARD_PRIVATE) && iface->data.network.actual->virtPortProfile && (iface->data.network.actual->virtPortProfile->virtPortType == VIR_NETDEV_VPORT_PROFILE_8021QBH))) { /* pick first dev with 0 connections */ - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].connections == 0) { - dev = &netdef->forward.ifs[i]; + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].connections == 0) { + dev = &def->forward.ifs[i]; break; } } } else { /* pick least used dev */ - dev = &netdef->forward.ifs[0]; - for (i = 1; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].connections < dev->connections) - dev = &netdef->forward.ifs[i]; + dev = &def->forward.ifs[0]; + for (i = 1; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].connections < dev->connections) + dev = &def->forward.ifs[i]; } } /* dev points at the physical device we want to use */ @@ -4489,7 +4578,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' requires exclusive access " "to interfaces, but none are available"), - netdef->name); + def->name); goto error; } if (VIR_STRDUP(iface->data.network.actual->data.direct.linkdev, @@ -4498,7 +4587,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, } } - if (networkMacMgrAdd(driver, network, dom->name, &iface->mac) < 0) + if (networkMacMgrAdd(driver, obj, dom->name, &iface->mac) < 0) goto error; if (virNetDevVPortProfileCheckComplete(virtport, true) < 0) @@ -4523,12 +4612,12 @@ networkAllocateActualDevice(virDomainDefPtr dom, (actualType == VIR_DOMAIN_NET_TYPE_BRIDGE && virtport && virtport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH))) { - if (netdef) { + if (def) { virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("an interface connecting to network '%s' " "is requesting a vlan tag, but that is not " "supported for this type of network"), - netdef->name); + def->name); } else { virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("an interface of type '%s' " @@ -4551,27 +4640,27 @@ networkAllocateActualDevice(virDomainDefPtr dom, } } - if (netdef) { - netdef->connections++; + if (def) { + def->connections++; if (dev) dev->connections++; /* finally we can call the 'plugged' hook script if any */ - if (networkRunHook(network, dom, iface, + if (networkRunHook(obj, dom, iface, VIR_HOOK_NETWORK_OP_IFACE_PLUGGED, VIR_HOOK_SUBOP_BEGIN) < 0) { /* adjust for failure */ - netdef->connections--; + def->connections--; if (dev) dev->connections--; goto error; } - networkLogAllocation(netdef, actualType, dev, iface, true); + networkLogAllocation(def, actualType, dev, iface, true); } ret = 0; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; error: @@ -4582,6 +4671,7 @@ networkAllocateActualDevice(virDomainDefPtr dom, goto cleanup; } + /* networkNotifyActualDevice: * @dom: domain definition that @iface belongs to * @iface: the domain's NetDef with an "actual" device already filled in. @@ -4597,10 +4687,9 @@ int networkNotifyActualDevice(virDomainDefPtr dom, virDomainNetDefPtr iface) { - virNetworkDriverStatePtr driver = networkGetDriver(); virDomainNetType actualType = virDomainNetGetActualType(iface); - virNetworkObjPtr network; - virNetworkDefPtr netdef; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkForwardIfDefPtr dev = NULL; size_t i; int ret = -1; @@ -4608,14 +4697,9 @@ networkNotifyActualDevice(virDomainDefPtr dom, if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) return 0; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); - goto error; - } - netdef = network->def; + if (!(obj = networkObjFindByName(iface->data.network.name))) + return -1; + def = virPoolObjGetDef(obj); /* if we're restarting libvirtd after an upgrade from a version * that didn't save bridge name in actualNetDef for @@ -4625,7 +4709,7 @@ networkNotifyActualDevice(virDomainDefPtr dom, if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK && !iface->data.network.actual->data.bridge.brname && (VIR_STRDUP(iface->data.network.actual->data.bridge.brname, - netdef->bridge) < 0)) + def->bridge) < 0)) goto error; if (!iface->data.network.actual || @@ -4635,14 +4719,14 @@ networkNotifyActualDevice(virDomainDefPtr dom, goto success; } - if (networkCreateInterfacePool(netdef) < 0) + if (networkCreateInterfacePool(def) < 0) goto error; - if (netdef->forward.nifs == 0) { + if (def->forward.nifs == 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' uses a direct or hostdev mode, " "but has no forward dev and no interface pool"), - netdef->name); + def->name); goto error; } @@ -4658,11 +4742,11 @@ networkNotifyActualDevice(virDomainDefPtr dom, } /* find the matching interface and increment its connections */ - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].type + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV && - STREQ(actualDev, netdef->forward.ifs[i].device.dev)) { - dev = &netdef->forward.ifs[i]; + STREQ(actualDev, def->forward.ifs[i].device.dev)) { + dev = &def->forward.ifs[i]; break; } } @@ -4671,7 +4755,7 @@ networkNotifyActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' doesn't have dev='%s' " "in use by domain"), - netdef->name, actualDev); + def->name, actualDev); goto error; } @@ -4680,15 +4764,15 @@ networkNotifyActualDevice(virDomainDefPtr dom, * must be 0 in those cases. */ if ((dev->connections > 0) && - ((netdef->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH) || - ((netdef->forward.type == VIR_NETWORK_FORWARD_PRIVATE) && + ((def->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH) || + ((def->forward.type == VIR_NETWORK_FORWARD_PRIVATE) && iface->data.network.actual->virtPortProfile && (iface->data.network.actual->virtPortProfile->virtPortType == VIR_NETDEV_VPORT_PROFILE_8021QBH)))) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' claims dev='%s' is already in " "use by a different domain"), - netdef->name, actualDev); + def->name, actualDev); goto error; } } else /* if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) */ { @@ -4703,12 +4787,12 @@ networkNotifyActualDevice(virDomainDefPtr dom, } /* find the matching interface and increment its connections */ - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].type + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI && virPCIDeviceAddressEqual(&hostdev->source.subsys.u.pci.addr, - &netdef->forward.ifs[i].device.pci)) { - dev = &netdef->forward.ifs[i]; + &def->forward.ifs[i].device.pci)) { + dev = &def->forward.ifs[i]; break; } } @@ -4717,7 +4801,7 @@ networkNotifyActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' doesn't have " "PCI device %04x:%02x:%02x.%x in use by domain"), - netdef->name, + def->name, hostdev->source.subsys.u.pci.addr.domain, hostdev->source.subsys.u.pci.addr.bus, hostdev->source.subsys.u.pci.addr.slot, @@ -4730,12 +4814,12 @@ networkNotifyActualDevice(virDomainDefPtr dom, * current connections count must be 0 in those cases. */ if ((dev->connections > 0) && - netdef->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { + def->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' claims the PCI device at " "domain=%d bus=%d slot=%d function=%d " "is already in use by a different domain"), - netdef->name, + def->name, dev->device.pci.domain, dev->device.pci.bus, dev->device.pci.slot, dev->device.pci.function); goto error; @@ -4743,23 +4827,23 @@ networkNotifyActualDevice(virDomainDefPtr dom, } success: - netdef->connections++; + def->connections++; if (dev) dev->connections++; /* finally we can call the 'plugged' hook script if any */ - if (networkRunHook(network, dom, iface, VIR_HOOK_NETWORK_OP_IFACE_PLUGGED, + if (networkRunHook(obj, dom, iface, VIR_HOOK_NETWORK_OP_IFACE_PLUGGED, VIR_HOOK_SUBOP_BEGIN) < 0) { /* adjust for failure */ if (dev) dev->connections--; - netdef->connections--; + def->connections--; goto error; } - networkLogAllocation(netdef, actualType, dev, iface, true); + networkLogAllocation(def, actualType, dev, iface, true); ret = 0; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; error: @@ -4785,8 +4869,8 @@ networkReleaseActualDevice(virDomainDefPtr dom, { virNetworkDriverStatePtr driver = networkGetDriver(); virDomainNetType actualType = virDomainNetGetActualType(iface); - virNetworkObjPtr network; - virNetworkDefPtr netdef; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkForwardIfDefPtr dev = NULL; size_t i; int ret = -1; @@ -4794,21 +4878,16 @@ networkReleaseActualDevice(virDomainDefPtr dom, if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) return 0; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); - goto error; - } - netdef = network->def; + if (!(obj = networkObjFindByName(iface->data.network.name))) + return -1; + def = virPoolObjGetDef(obj); if (iface->data.network.actual && - (netdef->forward.type == VIR_NETWORK_FORWARD_NONE || - netdef->forward.type == VIR_NETWORK_FORWARD_NAT || - netdef->forward.type == VIR_NETWORK_FORWARD_ROUTE || - netdef->forward.type == VIR_NETWORK_FORWARD_OPEN) && - networkUnplugBandwidth(network, iface) < 0) + (def->forward.type == VIR_NETWORK_FORWARD_NONE || + def->forward.type == VIR_NETWORK_FORWARD_NAT || + def->forward.type == VIR_NETWORK_FORWARD_ROUTE || + def->forward.type == VIR_NETWORK_FORWARD_OPEN) && + networkUnplugBandwidth(obj, iface) < 0) goto error; if ((!iface->data.network.actual) || @@ -4818,11 +4897,11 @@ networkReleaseActualDevice(virDomainDefPtr dom, goto success; } - if (netdef->forward.nifs == 0) { + if (def->forward.nifs == 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' uses a direct/hostdev mode, but " "has no forward dev and no interface pool"), - netdef->name); + def->name); goto error; } @@ -4837,11 +4916,11 @@ networkReleaseActualDevice(virDomainDefPtr dom, goto error; } - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].type + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV && - STREQ(actualDev, netdef->forward.ifs[i].device.dev)) { - dev = &netdef->forward.ifs[i]; + STREQ(actualDev, def->forward.ifs[i].device.dev)) { + dev = &def->forward.ifs[i]; break; } } @@ -4850,25 +4929,25 @@ networkReleaseActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' doesn't have dev='%s' " "in use by domain"), - netdef->name, actualDev); + def->name, actualDev); goto error; } } else /* if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) */ { virDomainHostdevDefPtr hostdev; - hostdev = virDomainNetGetActualHostdev(iface); - if (!hostdev) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("the interface uses a hostdev mode, but has no hostdev")); + if (!(hostdev = virDomainNetGetActualHostdev(iface))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("the interface uses a hostdev mode, " + "but has no hostdev")); goto error; } - for (i = 0; i < netdef->forward.nifs; i++) { - if (netdef->forward.ifs[i].type + for (i = 0; i < def->forward.nifs; i++) { + if (def->forward.ifs[i].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI && virPCIDeviceAddressEqual(&hostdev->source.subsys.u.pci.addr, - &netdef->forward.ifs[i].device.pci)) { - dev = &netdef->forward.ifs[i]; + &def->forward.ifs[i].device.pci)) { + dev = &def->forward.ifs[i]; break; } } @@ -4877,7 +4956,7 @@ networkReleaseActualDevice(virDomainDefPtr dom, virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' doesn't have " "PCI device %04x:%02x:%02x.%x in use by domain"), - netdef->name, + def->name, hostdev->source.subsys.u.pci.addr.domain, hostdev->source.subsys.u.pci.addr.bus, hostdev->source.subsys.u.pci.addr.slot, @@ -4887,20 +4966,20 @@ networkReleaseActualDevice(virDomainDefPtr dom, } success: - networkMacMgrDel(driver, network, dom->name, &iface->mac); + networkMacMgrDel(driver, obj, dom->name, &iface->mac); if (iface->data.network.actual) { - netdef->connections--; + def->connections--; if (dev) dev->connections--; /* finally we can call the 'unplugged' hook script if any */ - networkRunHook(network, dom, iface, VIR_HOOK_NETWORK_OP_IFACE_UNPLUGGED, + networkRunHook(obj, dom, iface, VIR_HOOK_NETWORK_OP_IFACE_UNPLUGGED, VIR_HOOK_SUBOP_BEGIN); - networkLogAllocation(netdef, actualType, dev, iface, false); + networkLogAllocation(def, actualType, dev, iface, false); } ret = 0; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); if (iface->type == VIR_DOMAIN_NET_TYPE_NETWORK) { virDomainActualNetDefFree(iface->data.network.actual); iface->data.network.actual = NULL; @@ -4911,6 +4990,7 @@ networkReleaseActualDevice(virDomainDefPtr dom, goto cleanup; } + /* * networkGetNetworkAddress: * @netname: the name of a network @@ -4931,44 +5011,38 @@ networkReleaseActualDevice(virDomainDefPtr dom, * completely unsupported. */ int -networkGetNetworkAddress(const char *netname, char **netaddr) +networkGetNetworkAddress(const char *netname, + char **netaddr) { - virNetworkDriverStatePtr driver = networkGetDriver(); int ret = -1; - virNetworkObjPtr network; - virNetworkDefPtr netdef; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkIPDefPtr ipdef; virSocketAddr addr; virSocketAddrPtr addrptr = NULL; char *dev_name = NULL; *netaddr = NULL; - network = virNetworkObjFindByName(driver->networks, netname); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - netname); - goto cleanup; - } - netdef = network->def; + if (!(obj = networkObjFindByName(netname))) + return -1; + def = virPoolObjGetDef(obj); - switch (netdef->forward.type) { + switch (def->forward.type) { case VIR_NETWORK_FORWARD_NONE: case VIR_NETWORK_FORWARD_NAT: case VIR_NETWORK_FORWARD_ROUTE: case VIR_NETWORK_FORWARD_OPEN: - ipdef = virNetworkDefGetIPByIndex(netdef, AF_UNSPEC, 0); - if (!ipdef) { + if (!(ipdef = virNetworkDefGetIPByIndex(def, AF_UNSPEC, 0))) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' doesn't have an IP address"), - netdef->name); + def->name); goto cleanup; } addrptr = &ipdef->address; break; case VIR_NETWORK_FORWARD_BRIDGE: - if ((dev_name = netdef->bridge)) + if ((dev_name = def->bridge)) break; /* * fall through if netdef->bridge wasn't set, since that is @@ -4977,13 +5051,13 @@ networkGetNetworkAddress(const char *netname, char **netaddr) case VIR_NETWORK_FORWARD_PRIVATE: case VIR_NETWORK_FORWARD_VEPA: case VIR_NETWORK_FORWARD_PASSTHROUGH: - if ((netdef->forward.nifs > 0) && netdef->forward.ifs) - dev_name = netdef->forward.ifs[0].device.dev; + if ((def->forward.nifs > 0) && def->forward.ifs) + dev_name = def->forward.ifs[0].device.dev; if (!dev_name) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' has no associated interface or bridge"), - netdef->name); + def->name); goto cleanup; } break; @@ -5001,11 +5075,13 @@ networkGetNetworkAddress(const char *netname, char **netaddr) } ret = 0; + cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } + /* networkGetActualType: * @dom: domain definition that @iface belongs to * @iface: the original NetDef from the domain @@ -5019,8 +5095,8 @@ int networkGetActualType(virDomainNetDefPtr iface) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network = NULL; - virNetworkDefPtr netdef = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr def; int ret = -1; if (!driver || iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) @@ -5029,27 +5105,22 @@ networkGetActualType(virDomainNetDefPtr iface) if (iface->data.network.actual) return iface->data.network.actual->type; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); + if (!(obj = networkObjFindByName(iface->data.network.name))) return -1; - } - netdef = network->def; + def = virPoolObjGetDef(obj); - if ((netdef->forward.type == VIR_NETWORK_FORWARD_NONE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_NAT) || - (netdef->forward.type == VIR_NETWORK_FORWARD_ROUTE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_OPEN)) { + if ((def->forward.type == VIR_NETWORK_FORWARD_NONE) || + (def->forward.type == VIR_NETWORK_FORWARD_NAT) || + (def->forward.type == VIR_NETWORK_FORWARD_ROUTE) || + (def->forward.type == VIR_NETWORK_FORWARD_OPEN)) { /* for these forward types, the actual net type really *is* * NETWORK; we just keep the info from the portgroup in * iface->data.network.actual */ ret = VIR_DOMAIN_NET_TYPE_NETWORK; - } else if ((netdef->forward.type == VIR_NETWORK_FORWARD_BRIDGE) && - netdef->bridge) { + } else if ((def->forward.type == VIR_NETWORK_FORWARD_BRIDGE) && + def->bridge) { /* <forward type='bridge'/> <bridge name='xxx'/> * is VIR_DOMAIN_NET_TYPE_BRIDGE @@ -5057,14 +5128,14 @@ networkGetActualType(virDomainNetDefPtr iface) ret = VIR_DOMAIN_NET_TYPE_BRIDGE; - } else if (netdef->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { + } else if (def->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) { ret = VIR_DOMAIN_NET_TYPE_HOSTDEV; - } else if ((netdef->forward.type == VIR_NETWORK_FORWARD_BRIDGE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_PRIVATE) || - (netdef->forward.type == VIR_NETWORK_FORWARD_VEPA) || - (netdef->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH)) { + } else if ((def->forward.type == VIR_NETWORK_FORWARD_BRIDGE) || + (def->forward.type == VIR_NETWORK_FORWARD_PRIVATE) || + (def->forward.type == VIR_NETWORK_FORWARD_VEPA) || + (def->forward.type == VIR_NETWORK_FORWARD_PASSTHROUGH)) { /* <forward type='bridge|private|vepa|passthrough'> are all * VIR_DOMAIN_NET_TYPE_DIRECT. @@ -5074,7 +5145,7 @@ networkGetActualType(virDomainNetDefPtr iface) } - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } @@ -5100,15 +5171,16 @@ networkGetActualType(virDomainNetDefPtr iface) * 1 if no QoS is set (@new_rate untouched) */ static int -networkCheckBandwidth(virNetworkObjPtr net, +networkCheckBandwidth(virPoolObjPtr obj, virNetDevBandwidthPtr ifaceBand, virNetDevBandwidthPtr oldBandwidth, virMacAddr ifaceMac, unsigned long long *new_rate) { + virNetworkDefPtr def = virPoolObjGetDef(obj); int ret = -1; - virNetDevBandwidthPtr netBand = net->def->bandwidth; - unsigned long long tmp_floor_sum = net->floor_sum; + virNetDevBandwidthPtr netBand = def->bandwidth; + unsigned long long tmp_floor_sum = virNetworkObjPrivateGetFloorSum(obj); unsigned long long tmp_new_rate = 0; char ifmac[VIR_MAC_STRING_BUFLEN]; @@ -5119,7 +5191,7 @@ networkCheckBandwidth(virNetworkObjPtr net, virReportError(VIR_ERR_OPERATION_UNSUPPORTED, _("Invalid use of 'floor' on interface with MAC " "address %s - network '%s' has no inbound QoS set"), - ifmac, net->def->name); + ifmac, def->name); return -1; } @@ -5144,8 +5216,8 @@ networkCheckBandwidth(virNetworkObjPtr net, _("Cannot plug '%s' interface into '%s' because it " "would overcommit 'peak' on network '%s'"), ifmac, - net->def->bridge, - net->def->name); + def->bridge, + def->name); goto cleanup; } } else if (tmp_floor_sum > netBand->in->average) { @@ -5155,8 +5227,8 @@ networkCheckBandwidth(virNetworkObjPtr net, _("Cannot plug '%s' interface into '%s' because it " "would overcommit 'average' on network '%s'"), ifmac, - net->def->bridge, - net->def->name); + def->bridge, + def->name); goto cleanup; } @@ -5168,6 +5240,7 @@ networkCheckBandwidth(virNetworkObjPtr net, return ret; } + /** * networkNextClassID: * @net: network object @@ -5179,13 +5252,14 @@ networkCheckBandwidth(virNetworkObjPtr net, * Returns next free class ID or -1 if none is available. */ static ssize_t -networkNextClassID(virNetworkObjPtr net) +networkNextClassID(virPoolObjPtr obj) { ssize_t ret = 0; + virBitmapPtr class_id = virNetworkObjPrivateGetClassId(obj); - ret = virBitmapNextClearBit(net->class_id, -1); + ret = virBitmapNextClearBit(class_id, -1); - if (ret < 0 || virBitmapSetBit(net->class_id, ret) < 0) + if (ret < 0 || virBitmapSetBit(class_id, ret) < 0) return -1; return ret; @@ -5193,48 +5267,56 @@ networkNextClassID(virNetworkObjPtr net) static int -networkPlugBandwidthImpl(virNetworkObjPtr net, +networkPlugBandwidthImpl(virPoolObjPtr obj, virDomainNetDefPtr iface, virNetDevBandwidthPtr ifaceBand, unsigned long long new_rate) { virNetworkDriverStatePtr driver = networkGetDriver(); + virNetworkDefPtr def = virPoolObjGetDef(obj); ssize_t class_id = 0; + unsigned long long tmp_floor_sum; int plug_ret; int ret = -1; /* generate new class_id */ - if ((class_id = networkNextClassID(net)) < 0) { + if ((class_id = networkNextClassID(obj)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not generate next class ID")); goto cleanup; } - plug_ret = virNetDevBandwidthPlug(net->def->bridge, net->def->bandwidth, + plug_ret = virNetDevBandwidthPlug(def->bridge, def->bandwidth, &iface->mac, ifaceBand, class_id); if (plug_ret < 0) { - ignore_value(virNetDevBandwidthUnplug(net->def->bridge, class_id)); + ignore_value(virNetDevBandwidthUnplug(def->bridge, class_id)); goto cleanup; } /* QoS was set, generate new class ID */ iface->data.network.actual->class_id = class_id; /* update sum of 'floor'-s of attached NICs */ - net->floor_sum += ifaceBand->in->floor; + tmp_floor_sum = virNetworkObjPrivateGetFloorSum(obj); + tmp_floor_sum += ifaceBand->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); + /* update status file */ - if (virNetworkSaveStatus(driver->stateDir, net) < 0) { - ignore_value(virBitmapClearBit(net->class_id, class_id)); - net->floor_sum -= ifaceBand->in->floor; + if (virNetworkObjSaveStatus(driver->stateDir, obj) < 0) { + virBitmapPtr obj_class_id = virNetworkObjPrivateGetClassId(obj); + + ignore_value(virBitmapClearBit(obj_class_id, class_id)); + tmp_floor_sum -= ifaceBand->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); iface->data.network.actual->class_id = 0; - ignore_value(virNetDevBandwidthUnplug(net->def->bridge, class_id)); + ignore_value(virNetDevBandwidthUnplug(def->bridge, class_id)); goto cleanup; } /* update rate for non guaranteed NICs */ - new_rate -= net->floor_sum; - if (virNetDevBandwidthUpdateRate(net->def->bridge, 2, - net->def->bandwidth, new_rate) < 0) + new_rate -= virNetworkObjPrivateGetFloorSum(obj); + if (virNetDevBandwidthUpdateRate(def->bridge, 2, + def->bandwidth, new_rate) < 0) VIR_WARN("Unable to update rate for 1:2 class on %s bridge", - net->def->bridge); + def->bridge); ret = 0; cleanup: @@ -5243,7 +5325,7 @@ networkPlugBandwidthImpl(virNetworkObjPtr net, static int -networkPlugBandwidth(virNetworkObjPtr net, +networkPlugBandwidth(virPoolObjPtr obj, virDomainNetDefPtr iface) { int ret = -1; @@ -5252,7 +5334,7 @@ networkPlugBandwidth(virNetworkObjPtr net, char ifmac[VIR_MAC_STRING_BUFLEN]; virNetDevBandwidthPtr ifaceBand = virDomainNetGetActualBandwidth(iface); - if ((plug_ret = networkCheckBandwidth(net, ifaceBand, NULL, + if ((plug_ret = networkCheckBandwidth(obj, ifaceBand, NULL, iface->mac, &new_rate)) < 0) { /* helper reported error */ goto cleanup; @@ -5273,7 +5355,7 @@ networkPlugBandwidth(virNetworkObjPtr net, goto cleanup; } - if (networkPlugBandwidthImpl(net, iface, ifaceBand, new_rate) < 0) + if (networkPlugBandwidthImpl(obj, iface, ifaceBand, new_rate) < 0) goto cleanup; ret = 0; @@ -5282,50 +5364,60 @@ networkPlugBandwidth(virNetworkObjPtr net, return ret; } + static int -networkUnplugBandwidth(virNetworkObjPtr net, +networkUnplugBandwidth(virPoolObjPtr obj, virDomainNetDefPtr iface) { + virNetworkDefPtr def = virPoolObjGetDef(obj); virNetworkDriverStatePtr driver = networkGetDriver(); int ret = 0; unsigned long long new_rate; + unsigned long long tmp_floor_sum; + virBitmapPtr obj_class_id; virNetDevBandwidthPtr ifaceBand = virDomainNetGetActualBandwidth(iface); if (iface->data.network.actual && iface->data.network.actual->class_id) { - if (!net->def->bandwidth || !net->def->bandwidth->in) { + if (!def->bandwidth || !def->bandwidth->in) { VIR_WARN("Network %s has no bandwidth but unplug requested", - net->def->name); + def->name); goto cleanup; } /* we must remove class from bridge */ - new_rate = net->def->bandwidth->in->average; + new_rate = def->bandwidth->in->average; - if (net->def->bandwidth->in->peak > 0) - new_rate = net->def->bandwidth->in->peak; + if (def->bandwidth->in->peak > 0) + new_rate = def->bandwidth->in->peak; - ret = virNetDevBandwidthUnplug(net->def->bridge, + ret = virNetDevBandwidthUnplug(def->bridge, iface->data.network.actual->class_id); if (ret < 0) goto cleanup; /* update sum of 'floor'-s of attached NICs */ - net->floor_sum -= ifaceBand->in->floor; + tmp_floor_sum = virNetworkObjPrivateGetFloorSum(obj); + tmp_floor_sum -= ifaceBand->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); + /* return class ID */ - ignore_value(virBitmapClearBit(net->class_id, + obj_class_id = virNetworkObjPrivateGetClassId(obj); + ignore_value(virBitmapClearBit(obj_class_id, iface->data.network.actual->class_id)); + /* update status file */ - if (virNetworkSaveStatus(driver->stateDir, net) < 0) { - net->floor_sum += ifaceBand->in->floor; - ignore_value(virBitmapSetBit(net->class_id, + if (virNetworkObjSaveStatus(driver->stateDir, obj) < 0) { + tmp_floor_sum += ifaceBand->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); + ignore_value(virBitmapSetBit(obj_class_id, iface->data.network.actual->class_id)); goto cleanup; } /* update rate for non guaranteed NICs */ - new_rate -= net->floor_sum; - if (virNetDevBandwidthUpdateRate(net->def->bridge, 2, - net->def->bandwidth, new_rate) < 0) + new_rate -= tmp_floor_sum; + if (virNetDevBandwidthUpdateRate(def->bridge, 2, + def->bandwidth, new_rate) < 0) VIR_WARN("Unable to update rate for 1:2 class on %s bridge", - net->def->bridge); + def->bridge); /* no class is associated any longer */ iface->data.network.actual->class_id = 0; } @@ -5334,17 +5426,18 @@ networkUnplugBandwidth(virNetworkObjPtr net, return ret; } + static void -networkNetworkObjTaint(virNetworkObjPtr net, +networkNetworkObjTaint(virPoolObjPtr obj, virNetworkTaintFlags taint) { - if (virNetworkObjTaint(net, taint)) { + if (virNetworkObjPrivateIsTaint(obj, taint)) { + virNetworkDefPtr def = virPoolObjGetDef(obj); char uuidstr[VIR_UUID_STRING_BUFLEN]; - virUUIDFormat(net->def->uuid, uuidstr); + virUUIDFormat(def->uuid, uuidstr); VIR_WARN("Network name='%s' uuid=%s is tainted: %s", - net->def->name, - uuidstr, + def->name, uuidstr, virNetworkTaintTypeToString(taint)); } } @@ -5379,29 +5472,24 @@ bool networkBandwidthChangeAllowed(virDomainNetDefPtr iface, virNetDevBandwidthPtr newBandwidth) { - virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network = NULL; + virPoolObjPtr obj = NULL; virNetDevBandwidthPtr ifaceBand = virDomainNetGetActualBandwidth(iface); bool ret = false; if (!networkBandwidthGenericChecks(iface, newBandwidth)) return true; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); + if (!(obj = networkObjFindByName(iface->data.network.name))) return false; - } - if (networkCheckBandwidth(network, newBandwidth, ifaceBand, iface->mac, NULL) < 0) + if (networkCheckBandwidth(obj, newBandwidth, ifaceBand, + iface->mac, NULL) < 0) goto cleanup; ret = true; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } @@ -5411,24 +5499,22 @@ networkBandwidthUpdate(virDomainNetDefPtr iface, virNetDevBandwidthPtr newBandwidth) { virNetworkDriverStatePtr driver = networkGetDriver(); - virNetworkObjPtr network = NULL; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetDevBandwidthPtr ifaceBand = virDomainNetGetActualBandwidth(iface); unsigned long long new_rate = 0; + unsigned long long tmp_floor_sum; int plug_ret; int ret = -1; if (!networkBandwidthGenericChecks(iface, newBandwidth)) return 0; - network = virNetworkObjFindByName(driver->networks, iface->data.network.name); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - _("no network with matching name '%s'"), - iface->data.network.name); - return ret; - } + if (!(obj = networkObjFindByName(iface->data.network.name))) + return -1; + def = virPoolObjGetDef(obj); - if ((plug_ret = networkCheckBandwidth(network, newBandwidth, ifaceBand, + if ((plug_ret = networkCheckBandwidth(obj, newBandwidth, ifaceBand, iface->mac, &new_rate)) < 0) { /* helper reported error */ goto cleanup; @@ -5446,43 +5532,47 @@ networkBandwidthUpdate(virDomainNetDefPtr iface, newBandwidth && newBandwidth->in && newBandwidth->in->floor) { /* Either we just need to update @floor .. */ - if (virNetDevBandwidthUpdateRate(network->def->bridge, + if (virNetDevBandwidthUpdateRate(def->bridge, iface->data.network.actual->class_id, - network->def->bandwidth, + def->bandwidth, newBandwidth->in->floor) < 0) goto cleanup; - network->floor_sum -= ifaceBand->in->floor; - network->floor_sum += newBandwidth->in->floor; - new_rate -= network->floor_sum; + tmp_floor_sum = virNetworkObjPrivateGetFloorSum(obj); + tmp_floor_sum -= ifaceBand->in->floor; + tmp_floor_sum += newBandwidth->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); + new_rate -= tmp_floor_sum; - if (virNetDevBandwidthUpdateRate(network->def->bridge, 2, - network->def->bandwidth, new_rate) < 0 || - virNetworkSaveStatus(driver->stateDir, network) < 0) { + if (virNetDevBandwidthUpdateRate(def->bridge, 2, + def->bandwidth, new_rate) < 0 || + virNetworkObjSaveStatus(driver->stateDir, obj) < 0) { /* Ouch, rollback */ - network->floor_sum -= newBandwidth->in->floor; - network->floor_sum += ifaceBand->in->floor; + tmp_floor_sum -= newBandwidth->in->floor; + tmp_floor_sum += ifaceBand->in->floor; + virNetworkObjPrivateSetFloorSum(obj, tmp_floor_sum); - ignore_value(virNetDevBandwidthUpdateRate(network->def->bridge, + ignore_value(virNetDevBandwidthUpdateRate(def->bridge, iface->data.network.actual->class_id, - network->def->bandwidth, + def->bandwidth, ifaceBand->in->floor)); goto cleanup; } } else if (newBandwidth->in && newBandwidth->in->floor) { /* .. or we need to plug in new .. */ - if (networkPlugBandwidthImpl(network, iface, newBandwidth, new_rate) < 0) + if (networkPlugBandwidthImpl(obj, iface, newBandwidth, new_rate) < 0) goto cleanup; } else { /* .. or unplug old. */ - if (networkUnplugBandwidth(network, iface) < 0) + if (networkUnplugBandwidth(obj, iface) < 0) goto cleanup; } ret = 0; + cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } diff --git a/src/network/bridge_driver.h b/src/network/bridge_driver.h index ff7f921..8962732 100644 --- a/src/network/bridge_driver.h +++ b/src/network/bridge_driver.h @@ -30,6 +30,7 @@ # include "domain_conf.h" # include "vircommand.h" # include "virdnsmasq.h" +# include "virpoolobj.h" int networkRegister(void); @@ -50,11 +51,11 @@ int networkGetNetworkAddress(const char *netname, char **netaddr) int networkGetActualType(virDomainNetDefPtr iface) ATTRIBUTE_NONNULL(1); -int networkDnsmasqConfContents(virNetworkObjPtr network, - const char *pidfile, - char **configstr, - dnsmasqContext *dctx, - dnsmasqCapsPtr caps); +int networkDnsmasqConfContents(virPoolObjPtr obj, + const char *pidfile, + char **configstr, + dnsmasqContext *dctx, + dnsmasqCapsPtr caps); bool networkBandwidthChangeAllowed(virDomainNetDefPtr iface, virNetDevBandwidthPtr newBandwidth) diff --git a/src/network/bridge_driver_platform.h b/src/network/bridge_driver_platform.h index 904e731..3ab24cd 100644 --- a/src/network/bridge_driver_platform.h +++ b/src/network/bridge_driver_platform.h @@ -29,13 +29,14 @@ # include "virdnsmasq.h" # include "network_conf.h" # include "object_event.h" +# include "virpoolobj.h" /* Main driver state */ struct _virNetworkDriverState { virMutex lock; /* Immutable pointer, self-locking APIs */ - virNetworkObjListPtr networks; + virPoolObjTablePtr networks; /* Immutable pointers, Immutable objects */ char *networkConfigDir; diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 26924b5..cbffcbb 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -42,7 +42,7 @@ #include "capabilities.h" #include "configmake.h" #include "viralloc.h" -#include "network_conf.h" +#include "virnetworkobj.h" #include "interface_conf.h" #include "domain_conf.h" #include "domain_event.h" @@ -120,7 +120,7 @@ struct _testDriver { /* immutable pointer, self-locking APIs */ virDomainObjListPtr domains; - virNetworkObjListPtr networks; + virPoolObjTablePtr networks; virObjectEventStatePtr eventState; }; typedef struct _testDriver testDriver; @@ -429,7 +429,9 @@ testDriverNew(void) VIR_POOLOBJTABLE_BLOCK_STORAGE_HASHSTART, false)) || !(ret->domains = virDomainObjListNew()) || - !(ret->networks = virNetworkObjListNew())) + !(ret->networks = + virPoolObjTableNew(VIR_POOLOBJTABLE_NETWORK, + VIR_POOLOBJTABLE_NETWORK_HASHSTART, false))) goto error; virAtomicIntSet(&ret->nextDomID, 1); @@ -941,7 +943,7 @@ testParseNetworks(testDriverPtr privconn, int num, ret = -1; size_t i; xmlNodePtr *nodes = NULL; - virNetworkObjPtr obj; + virPoolObjPtr obj; num = virXPathNodeSet("/node/network", ctxt, &nodes); if (num < 0) @@ -957,13 +959,13 @@ testParseNetworks(testDriverPtr privconn, if (!def) goto error; - if (!(obj = virNetworkAssignDef(privconn->networks, def, 0))) { + if (!(obj = virNetworkObjAdd(privconn->networks, def, 0))) { virNetworkDefFree(def); goto error; } - obj->active = 1; - virNetworkObjEndAPI(&obj); + virPoolObjSetActive(obj, true); + virPoolObjEndAPI(&obj); } ret = 0; @@ -3187,85 +3189,114 @@ static int testDomainInterfaceStats(virDomainPtr domain, } -static virNetworkPtr testNetworkLookupByUUID(virConnectPtr conn, - const unsigned char *uuid) +static virPoolObjPtr +testNetworkObjFindByUUID(virPoolObjTablePtr networks, + const unsigned char *uuid) +{ + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByUUIDRef(networks, uuid))) + virReportError(VIR_ERR_NO_NETWORK, NULL); + + return obj; +} + + +static virPoolObjPtr +testNetworkObjFindByName(virPoolObjTablePtr networks, + const char *name) +{ + virPoolObjPtr obj; + + if (!(obj = virPoolObjTableFindByName(networks, name))) + virReportError(VIR_ERR_NO_NETWORK, NULL); + + return obj; +} + + +static virNetworkPtr +testNetworkLookupByUUID(virConnectPtr conn, + const unsigned char *uuid) { testDriverPtr privconn = conn->privateData; - virNetworkObjPtr net; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkPtr ret = NULL; - net = virNetworkObjFindByUUID(privconn->networks, uuid); - if (net == NULL) { - virReportError(VIR_ERR_NO_NETWORK, NULL); - goto cleanup; - } + if (!(obj = testNetworkObjFindByUUID(privconn->networks, uuid))) + return NULL; + def = virPoolObjGetDef(obj); - ret = virGetNetwork(conn, net->def->name, net->def->uuid); + ret = virGetNetwork(conn, def->name, def->uuid); - cleanup: - virNetworkObjEndAPI(&net); + virPoolObjEndAPI(&obj); return ret; } -static virNetworkPtr testNetworkLookupByName(virConnectPtr conn, - const char *name) + +static virNetworkPtr +testNetworkLookupByName(virConnectPtr conn, + const char *name) { testDriverPtr privconn = conn->privateData; - virNetworkObjPtr net; + virPoolObjPtr obj; + virNetworkDefPtr def; virNetworkPtr ret = NULL; - net = virNetworkObjFindByName(privconn->networks, name); - if (net == NULL) { - virReportError(VIR_ERR_NO_NETWORK, NULL); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, name))) + return NULL; + def = virPoolObjGetDef(obj); - ret = virGetNetwork(conn, net->def->name, net->def->uuid); + ret = virGetNetwork(conn, def->name, def->uuid); - cleanup: - virNetworkObjEndAPI(&net); + virPoolObjEndAPI(&obj); return ret; } -static int testConnectNumOfNetworks(virConnectPtr conn) +static int +testConnectNumOfNetworks(virConnectPtr conn) { testDriverPtr privconn = conn->privateData; - int numActive; - numActive = virNetworkObjListNumOfNetworks(privconn->networks, - true, NULL, conn); - return numActive; + return virNetworkObjNumOfNetworks(privconn->networks, conn, true, NULL); } -static int testConnectListNetworks(virConnectPtr conn, char **const names, int nnames) { + +static int +testConnectListNetworks(virConnectPtr conn, + char **const names, + int maxnames) +{ testDriverPtr privconn = conn->privateData; - int n; - n = virNetworkObjListGetNames(privconn->networks, - true, names, nnames, NULL, conn); - return n; + return virNetworkObjGetNames(privconn->networks, conn, true, NULL, + names, maxnames); } -static int testConnectNumOfDefinedNetworks(virConnectPtr conn) + +static int +testConnectNumOfDefinedNetworks(virConnectPtr conn) { testDriverPtr privconn = conn->privateData; - int numInactive; - numInactive = virNetworkObjListNumOfNetworks(privconn->networks, - false, NULL, conn); - return numInactive; + return virNetworkObjNumOfNetworks(privconn->networks, conn, false, NULL); } -static int testConnectListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) { + +static int +testConnectListDefinedNetworks(virConnectPtr conn, + char **const names, + int maxnames) +{ testDriverPtr privconn = conn->privateData; - int n; - n = virNetworkObjListGetNames(privconn->networks, - false, names, nnames, NULL, conn); - return n; + return virNetworkObjGetNames(privconn->networks, conn, false, NULL, + names, maxnames); } + static int testConnectListAllNetworks(virConnectPtr conn, virNetworkPtr **nets, @@ -3275,139 +3306,144 @@ testConnectListAllNetworks(virConnectPtr conn, virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1); - return virNetworkObjListExport(conn, privconn->networks, nets, NULL, flags); + return virNetworkObjExportList(conn, privconn->networks, nets, NULL, flags); } -static int testNetworkIsActive(virNetworkPtr net) + +static int +testNetworkIsActive(virNetworkPtr net) { testDriverPtr privconn = net->conn->privateData; - virNetworkObjPtr obj; + virPoolObjPtr obj; int ret = -1; - obj = virNetworkObjFindByUUID(privconn->networks, net->uuid); - if (!obj) { - virReportError(VIR_ERR_NO_NETWORK, NULL); - goto cleanup; - } - ret = virNetworkObjIsActive(obj); + if (!(obj = testNetworkObjFindByUUID(privconn->networks, net->uuid))) + return -1; - cleanup: - virNetworkObjEndAPI(&obj); + ret = virPoolObjIsActive(obj); + + virPoolObjEndAPI(&obj); return ret; } -static int testNetworkIsPersistent(virNetworkPtr net) + +static int +testNetworkIsPersistent(virNetworkPtr net) { testDriverPtr privconn = net->conn->privateData; - virNetworkObjPtr obj; + virPoolObjPtr obj; int ret = -1; - obj = virNetworkObjFindByUUID(privconn->networks, net->uuid); - if (!obj) { - virReportError(VIR_ERR_NO_NETWORK, NULL); - goto cleanup; - } - ret = obj->persistent; + if (!(obj = testNetworkObjFindByUUID(privconn->networks, net->uuid))) + return -1; - cleanup: - virNetworkObjEndAPI(&obj); + ret = virPoolObjIsPersistent(obj); + + virPoolObjEndAPI(&obj); return ret; } -static virNetworkPtr testNetworkCreateXML(virConnectPtr conn, const char *xml) +static virNetworkPtr +testNetworkCreateXML(virConnectPtr conn, + const char *xml) { testDriverPtr privconn = conn->privateData; virNetworkDefPtr def; - virNetworkObjPtr net = NULL; + virPoolObjPtr obj; + virNetworkDefPtr objdef; virNetworkPtr ret = NULL; virObjectEventPtr event = NULL; - if ((def = virNetworkDefParseString(xml)) == NULL) - goto cleanup; + if (!(def = virNetworkDefParseString(xml))) + return NULL; - if (!(net = virNetworkAssignDef(privconn->networks, def, - VIR_NETWORK_OBJ_LIST_ADD_LIVE | - VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE))) + if (!(obj = virNetworkObjAdd(privconn->networks, def, + VIR_NETWORK_OBJ_LIST_ADD_LIVE | + VIR_NETWORK_OBJ_LIST_ADD_CHECK_LIVE))) goto cleanup; - def = NULL; - net->active = 1; + VIR_STEAL_PTR(objdef, def); + virPoolObjSetActive(obj, true); - event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + event = virNetworkEventLifecycleNew(objdef->name, objdef->uuid, VIR_NETWORK_EVENT_STARTED, 0); - ret = virGetNetwork(conn, net->def->name, net->def->uuid); + ret = virGetNetwork(conn, objdef->name, objdef->uuid); cleanup: virNetworkDefFree(def); testObjectEventQueue(privconn, event); - virNetworkObjEndAPI(&net); + virPoolObjEndAPI(&obj); return ret; } -static -virNetworkPtr testNetworkDefineXML(virConnectPtr conn, const char *xml) + +static virNetworkPtr +testNetworkDefineXML(virConnectPtr conn, + const char *xml) { testDriverPtr privconn = conn->privateData; virNetworkDefPtr def; - virNetworkObjPtr net = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr objdef; virNetworkPtr ret = NULL; virObjectEventPtr event = NULL; - if ((def = virNetworkDefParseString(xml)) == NULL) - goto cleanup; + if (!(def = virNetworkDefParseString(xml))) + return NULL; - if (!(net = virNetworkAssignDef(privconn->networks, def, 0))) + if (!(obj = virNetworkObjAdd(privconn->networks, def, 0))) goto cleanup; - def = NULL; + VIR_STEAL_PTR(objdef, def); - event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + event = virNetworkEventLifecycleNew(objdef->name, objdef->uuid, VIR_NETWORK_EVENT_DEFINED, 0); - ret = virGetNetwork(conn, net->def->name, net->def->uuid); + ret = virGetNetwork(conn, objdef->name, objdef->uuid); cleanup: virNetworkDefFree(def); testObjectEventQueue(privconn, event); - virNetworkObjEndAPI(&net); + virPoolObjEndAPI(&obj); return ret; } -static int testNetworkUndefine(virNetworkPtr network) + +static int +testNetworkUndefine(virNetworkPtr network) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; virObjectEventPtr event = NULL; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkObjIsActive(privnet)) { + if (virPoolObjIsActive(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("Network '%s' is still running"), network->name); + _("Network '%s' is still running"), def->name); goto cleanup; } - event = virNetworkEventLifecycleNew(network->name, network->uuid, + event = virNetworkEventLifecycleNew(def->name, def->uuid, VIR_NETWORK_EVENT_UNDEFINED, 0); - virNetworkRemoveInactive(privconn->networks, privnet); + virPoolObjTableRemove(privconn->networks, &obj); ret = 0; cleanup: testObjectEventQueue(privconn, event); - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } + static int testNetworkUpdate(virNetworkPtr net, unsigned int command, @@ -3417,24 +3453,20 @@ testNetworkUpdate(virNetworkPtr net, unsigned int flags) { testDriverPtr privconn = net->conn->privateData; - virNetworkObjPtr network = NULL; + virPoolObjPtr obj = NULL; int isActive, ret = -1; virCheckFlags(VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG, -1); - network = virNetworkObjFindByUUID(privconn->networks, net->uuid); - if (!network) { - virReportError(VIR_ERR_NO_NETWORK, - "%s", _("no network with matching uuid")); - goto cleanup; - } + if (!(obj = testNetworkObjFindByUUID(privconn->networks, net->uuid))) + return -1; /* VIR_NETWORK_UPDATE_AFFECT_CURRENT means "change LIVE if network * is active, else change CONFIG */ - isActive = virNetworkObjIsActive(network); + isActive = virPoolObjIsActive(obj); if ((flags & (VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG)) == VIR_NETWORK_UPDATE_AFFECT_CURRENT) { @@ -3445,160 +3477,159 @@ testNetworkUpdate(virNetworkPtr net, } /* update the network config in memory/on disk */ - if (virNetworkObjUpdate(network, command, section, parentIndex, xml, flags) < 0) + if (virNetworkObjUpdate(obj, command, section, parentIndex, xml, flags) < 0) goto cleanup; ret = 0; cleanup: - virNetworkObjEndAPI(&network); + virPoolObjEndAPI(&obj); return ret; } -static int testNetworkCreate(virNetworkPtr network) + +static int +testNetworkCreate(virNetworkPtr network) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; virObjectEventPtr event = NULL; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return -1; + def = virPoolObjGetDef(obj); - if (virNetworkObjIsActive(privnet)) { + if (virPoolObjIsActive(obj)) { virReportError(VIR_ERR_OPERATION_INVALID, - _("Network '%s' is already running"), network->name); + _("Network '%s' is already running"), def->name); goto cleanup; } - privnet->active = 1; - event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + virPoolObjSetActive(obj, true); + event = virNetworkEventLifecycleNew(def->name, def->uuid, VIR_NETWORK_EVENT_STARTED, 0); ret = 0; cleanup: testObjectEventQueue(privconn, event); - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } -static int testNetworkDestroy(virNetworkPtr network) + +static int +testNetworkDestroy(virNetworkPtr network) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; + virNetworkDefPtr def; int ret = -1; virObjectEventPtr event = NULL; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return -1; + def = virPoolObjGetDef(obj); - privnet->active = 0; - event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + virPoolObjSetActive(obj, false); + event = virNetworkEventLifecycleNew(def->name, def->uuid, VIR_NETWORK_EVENT_STOPPED, 0); - if (!privnet->persistent) - virNetworkRemoveInactive(privconn->networks, privnet); + if (!virPoolObjIsPersistent(obj)) + virPoolObjTableRemove(privconn->networks, &obj); ret = 0; - cleanup: testObjectEventQueue(privconn, event); - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } -static char *testNetworkGetXMLDesc(virNetworkPtr network, - unsigned int flags) + +static char * +testNetworkGetXMLDesc(virNetworkPtr network, + unsigned int flags) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; + virNetworkDefPtr def; char *ret = NULL; virCheckFlags(0, NULL); - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return NULL; + def = virPoolObjGetDef(obj); - ret = virNetworkDefFormat(privnet->def, flags); + ret = virNetworkDefFormat(def, flags); - cleanup: - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } -static char *testNetworkGetBridgeName(virNetworkPtr network) { + +static char * +testNetworkGetBridgeName(virNetworkPtr network) +{ testDriverPtr privconn = network->conn->privateData; char *bridge = NULL; - virNetworkObjPtr privnet; + virPoolObjPtr obj; + virNetworkDefPtr def; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return NULL; + def = virPoolObjGetDef(obj); - if (!(privnet->def->bridge)) { + if (!def->bridge) { virReportError(VIR_ERR_INTERNAL_ERROR, _("network '%s' does not have a bridge name."), - privnet->def->name); + def->name); goto cleanup; } - ignore_value(VIR_STRDUP(bridge, privnet->def->bridge)); + ignore_value(VIR_STRDUP(bridge, def->bridge)); cleanup: - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return bridge; } -static int testNetworkGetAutostart(virNetworkPtr network, - int *autostart) + +static int +testNetworkGetAutostart(virNetworkPtr network, + int *autostart) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; int ret = -1; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return -1; - *autostart = privnet->autostart; + *autostart = virPoolObjIsAutostart(obj); ret = 0; - cleanup: - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } -static int testNetworkSetAutostart(virNetworkPtr network, - int autostart) + +static int +testNetworkSetAutostart(virNetworkPtr network, + int autostart) { testDriverPtr privconn = network->conn->privateData; - virNetworkObjPtr privnet; + virPoolObjPtr obj; int ret = -1; - privnet = virNetworkObjFindByName(privconn->networks, network->name); - if (privnet == NULL) { - virReportError(VIR_ERR_INVALID_ARG, __FUNCTION__); - goto cleanup; - } + if (!(obj = testNetworkObjFindByName(privconn->networks, network->name))) + return -1; - privnet->autostart = autostart ? 1 : 0; + virPoolObjSetAutostart(obj, autostart ? true : false); ret = 0; - cleanup: - virNetworkObjEndAPI(&privnet); + virPoolObjEndAPI(&obj); return ret; } diff --git a/tests/networkxml2conftest.c b/tests/networkxml2conftest.c index 9b61077..73603bb 100644 --- a/tests/networkxml2conftest.c +++ b/tests/networkxml2conftest.c @@ -23,22 +23,21 @@ testCompareXMLToConfFiles(const char *inxml, const char *outconf, dnsmasqCapsPtr { char *actual = NULL; int ret = -1; - virNetworkDefPtr dev = NULL; - virNetworkObjPtr obj = NULL; + virNetworkDefPtr def = NULL; + virPoolObjPtr obj = NULL; + virNetworkDefPtr objdef; virCommandPtr cmd = NULL; char *pidfile = NULL; dnsmasqContext *dctx = NULL; - if (!(dev = virNetworkDefParseFile(inxml))) + if (!(def = virNetworkDefParseFile(inxml))) goto fail; - if (!(obj = virNetworkObjNew())) + if (!(obj = virPoolObjNew(NULL, def, NULL, virNetworkDefFree))) goto fail; + VIR_STEAL_PTR(objdef, def); - obj->def = dev; - dctx = dnsmasqContextNew(dev->name, "/var/lib/libvirt/dnsmasq"); - - if (dctx == NULL) + if (!(dctx = dnsmasqContextNew(objdef->name, "/var/lib/libvirt/dnsmasq"))) goto fail; if (networkDnsmasqConfContents(obj, pidfile, &actual, dctx, caps) < 0) @@ -66,8 +65,9 @@ testCompareXMLToConfFiles(const char *inxml, const char *outconf, dnsmasqCapsPtr VIR_FREE(actual); VIR_FREE(pidfile); virCommandFree(cmd); - virObjectUnref(obj); dnsmasqContextFree(dctx); + virObjectUnref(obj); + virNetworkDefFree(def); return ret; } -- 2.7.4