Remove virConnectPtr from storage APIs & driver

The virConnectPtr is no longer required for error reporting since
that is recorded in a thread local. Remove use of virConnectPtr
from all APIs in storage_conf.{h,c} and storage_encryption_conf.{h,c}
and update all callers to match

src/conf/domain_conf.c

@@ -1297,7 +1297,7 @@ virDomainDiskDefParseXML(xmlNodePtr node,
                 devaddr = virXMLPropString(cur, "devaddr");
             } else if (encryption == NULL &&
                        xmlStrEqual(cur->name, BAD_CAST "encryption")) {
-                encryption = virStorageEncryptionParseNode(NULL, node->doc,
+                encryption = virStorageEncryptionParseNode(node->doc,
                                                            cur);
                 if (encryption == NULL)
                     goto error;
@@ -4581,7 +4581,7 @@ virDomainDiskDefFormat(virBufferPtr buf,
         virBufferEscapeString(buf, "      <serial>%s</serial>\n",
                               def->serial);
     if (def->encryption != NULL &&
-        virStorageEncryptionFormat(NULL, buf, def->encryption) < 0)
+        virStorageEncryptionFormat(buf, def->encryption) < 0)
         return -1;
 
     if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)

src/conf/storage_conf.h

@@ -318,12 +318,11 @@ static inline int virStoragePoolObjIsActive(virStoragePoolObjPtr pool) {
     return pool->active;
 }
 
-#define virStorageReportError(conn, code, fmt...)                            \
-        virReportErrorHelper(conn, VIR_FROM_STORAGE, code, __FILE__,       \
-                               __FUNCTION__, __LINE__, fmt)
+#define virStorageReportError(code, fmt...)                             \
+    virReportErrorHelper(NULL, VIR_FROM_STORAGE, code, __FILE__,        \
+                         __FUNCTION__, __LINE__, fmt)
 
-int virStoragePoolLoadAllConfigs(virConnectPtr conn,
-                                 virStoragePoolObjListPtr pools,
+int virStoragePoolLoadAllConfigs(virStoragePoolObjListPtr pools,
                                  const char *configDir,
                                  const char *autostartDir);
 
@@ -341,40 +340,29 @@ virStorageVolDefPtr virStorageVolDefFindByName(virStoragePoolObjPtr pool,
 
 void virStoragePoolObjClearVols(virStoragePoolObjPtr pool);
 
-virStoragePoolDefPtr virStoragePoolDefParseString(virConnectPtr conn,
-                                                  const char *xml);
-virStoragePoolDefPtr virStoragePoolDefParseFile(virConnectPtr conn,
-                                                const char *filename);
-virStoragePoolDefPtr virStoragePoolDefParseNode(virConnectPtr conn,
-                                                xmlDocPtr xml,
+virStoragePoolDefPtr virStoragePoolDefParseString(const char *xml);
+virStoragePoolDefPtr virStoragePoolDefParseFile(const char *filename);
+virStoragePoolDefPtr virStoragePoolDefParseNode(xmlDocPtr xml,
                                                 xmlNodePtr root);
-char *virStoragePoolDefFormat(virConnectPtr conn,
-                              virStoragePoolDefPtr def);
+char *virStoragePoolDefFormat(virStoragePoolDefPtr def);
 
-virStorageVolDefPtr virStorageVolDefParseString(virConnectPtr conn,
-                                                virStoragePoolDefPtr pool,
+virStorageVolDefPtr virStorageVolDefParseString(virStoragePoolDefPtr pool,
                                                 const char *xml);
-virStorageVolDefPtr virStorageVolDefParseFile(virConnectPtr conn,
-                                              virStoragePoolDefPtr pool,
+virStorageVolDefPtr virStorageVolDefParseFile(virStoragePoolDefPtr pool,
                                               const char *filename);
-virStorageVolDefPtr virStorageVolDefParseNode(virConnectPtr conn,
-                                              virStoragePoolDefPtr pool,
+virStorageVolDefPtr virStorageVolDefParseNode(virStoragePoolDefPtr pool,
                                               xmlDocPtr xml,
                                               xmlNodePtr root);
-char *virStorageVolDefFormat(virConnectPtr conn,
-                             virStoragePoolDefPtr pool,
+char *virStorageVolDefFormat(virStoragePoolDefPtr pool,
                              virStorageVolDefPtr def);
 
-virStoragePoolObjPtr virStoragePoolObjAssignDef(virConnectPtr conn,
-                                                virStoragePoolObjListPtr pools,
+virStoragePoolObjPtr virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools,
                                                 virStoragePoolDefPtr def);
 
-int virStoragePoolObjSaveDef(virConnectPtr conn,
-                             virStorageDriverStatePtr driver,
+int virStoragePoolObjSaveDef(virStorageDriverStatePtr driver,
                              virStoragePoolObjPtr pool,
                              virStoragePoolDefPtr def);
-int virStoragePoolObjDeleteDef(virConnectPtr conn,
-                               virStoragePoolObjPtr pool);
+int virStoragePoolObjDeleteDef(virStoragePoolObjPtr pool);
 
 void virStorageVolDefFree(virStorageVolDefPtr def);
 void virStoragePoolSourceFree(virStoragePoolSourcePtr source);
@@ -385,14 +373,11 @@ void virStoragePoolObjRemove(virStoragePoolObjListPtr pools,
                              virStoragePoolObjPtr pool);
 
 virStoragePoolSourcePtr
-virStoragePoolDefParseSourceString(virConnectPtr conn,
-                                   const char *srcSpec,
+virStoragePoolDefParseSourceString(const char *srcSpec,
                                    int pool_type);
 virStoragePoolSourcePtr
-virStoragePoolSourceListNewSource(virConnectPtr conn,
-                                  virStoragePoolSourceListPtr list);
-char *virStoragePoolSourceListFormat(virConnectPtr conn,
-                                     virStoragePoolSourceListPtr def);
+virStoragePoolSourceListNewSource(virStoragePoolSourceListPtr list);
+char *virStoragePoolSourceListFormat(virStoragePoolSourceListPtr def);
 
 void virStoragePoolObjLock(virStoragePoolObjPtr obj);
 void virStoragePoolObjUnlock(virStoragePoolObjPtr obj);

src/conf/storage_encryption_conf.c

@@ -70,7 +70,7 @@ virStorageEncryptionFree(virStorageEncryptionPtr enc)
 #ifndef PROXY
 
 static virStorageEncryptionSecretPtr
-virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
+virStorageEncryptionSecretParse(xmlXPathContextPtr ctxt,
                                 xmlNodePtr node)
 {
     xmlNodePtr old_node;
@@ -89,13 +89,13 @@ virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
 
     type_str = virXPathString("string(./@type)", ctxt);
     if (type_str == NULL) {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR, "%s",
+        virStorageReportError(VIR_ERR_XML_ERROR, "%s",
                               _("unknown volume encryption secret type"));
         goto cleanup;
     }
     type = virStorageEncryptionSecretTypeTypeFromString(type_str);
     if (type < 0) {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR,
+        virStorageReportError(VIR_ERR_XML_ERROR,
                               _("unknown volume encryption secret type %s"),
                               type_str);
         VIR_FREE(type_str);
@@ -107,14 +107,14 @@ virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
     uuidstr = virXPathString("string(./@uuid)", ctxt);
     if (uuidstr) {
         if (virUUIDParse(uuidstr, ret->uuid) < 0) {
-            virStorageReportError(conn, VIR_ERR_XML_ERROR,
+            virStorageReportError(VIR_ERR_XML_ERROR,
                                   _("malformed volume encryption uuid '%s'"),
                                   uuidstr);
             goto cleanup;
         }
         VIR_FREE(uuidstr);
     } else {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR, "%s",
+        virStorageReportError(VIR_ERR_XML_ERROR, "%s",
                               _("missing volume encryption uuid"));
         goto cleanup;
     }
@@ -129,7 +129,7 @@ virStorageEncryptionSecretParse(virConnectPtr conn, xmlXPathContextPtr ctxt,
 }
 
 static virStorageEncryptionPtr
-virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
+virStorageEncryptionParseXML(xmlXPathContextPtr ctxt)
 {
     xmlNodePtr *nodes = NULL;
     virStorageEncryptionPtr ret;
@@ -143,13 +143,13 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
 
     format_str = virXPathString("string(./@format)", ctxt);
     if (format_str == NULL) {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR, "%s",
+        virStorageReportError(VIR_ERR_XML_ERROR, "%s",
                               _("unknown volume encryption format"));
         goto cleanup;
     }
     format = virStorageEncryptionFormatTypeFromString(format_str);
     if (format < 0) {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR,
+        virStorageReportError(VIR_ERR_XML_ERROR,
                               _("unknown volume encryption format type %s"),
                               format_str);
         VIR_FREE(format_str);
@@ -160,7 +160,7 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
 
     n = virXPathNodeSet("./secret", ctxt, &nodes);
     if (n < 0){
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("cannot extract volume encryption secrets"));
         goto cleanup;
     }
@@ -170,7 +170,7 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
     }
     ret->nsecrets = n;
     for (i = 0; i < n; i++) {
-        ret->secrets[i] = virStorageEncryptionSecretParse(conn, ctxt, nodes[i]);
+        ret->secrets[i] = virStorageEncryptionSecretParse(ctxt, nodes[i]);
         if (ret->secrets[i] == NULL)
             goto cleanup;
     }
@@ -185,14 +185,13 @@ virStorageEncryptionParseXML(virConnectPtr conn, xmlXPathContextPtr ctxt)
 }
 
 virStorageEncryptionPtr
-virStorageEncryptionParseNode(virConnectPtr conn,
-                              xmlDocPtr xml, xmlNodePtr root)
+virStorageEncryptionParseNode(xmlDocPtr xml, xmlNodePtr root)
 {
     xmlXPathContextPtr ctxt = NULL;
     virStorageEncryptionPtr enc = NULL;
 
     if (STRNEQ((const char *) root->name, "encryption")) {
-        virStorageReportError(conn, VIR_ERR_XML_ERROR,
+        virStorageReportError(VIR_ERR_XML_ERROR,
                               "%s", _("unknown root element for volume "
                                       "encryption information"));
         goto cleanup;
@@ -205,7 +204,7 @@ virStorageEncryptionParseNode(virConnectPtr conn,
     }
 
     ctxt->node = root;
-    enc = virStorageEncryptionParseXML(conn, ctxt);
+    enc = virStorageEncryptionParseXML(ctxt);
 
   cleanup:
     xmlXPathFreeContext(ctxt);
@@ -215,8 +214,7 @@ virStorageEncryptionParseNode(virConnectPtr conn,
 
 
 static int
-virStorageEncryptionSecretFormat(virConnectPtr conn,
-                                 virBufferPtr buf,
+virStorageEncryptionSecretFormat(virBufferPtr buf,
                                  virStorageEncryptionSecretPtr secret)
 {
     const char *type;
@@ -224,7 +222,7 @@ virStorageEncryptionSecretFormat(virConnectPtr conn,
 
     type = virStorageEncryptionSecretTypeTypeToString(secret->type);
     if (!type) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("unexpected volume encryption secret type"));
         return -1;
     }
@@ -235,8 +233,7 @@ virStorageEncryptionSecretFormat(virConnectPtr conn,
 }
 
 int
-virStorageEncryptionFormat(virConnectPtr conn,
-                           virBufferPtr buf,
+virStorageEncryptionFormat(virBufferPtr buf,
                            virStorageEncryptionPtr enc)
 {
     const char *format;
@@ -244,14 +241,14 @@ virStorageEncryptionFormat(virConnectPtr conn,
 
     format = virStorageEncryptionFormatTypeToString(enc->format);
     if (!format) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("unexpected encryption format"));
         return -1;
     }
     virBufferVSprintf(buf, "    <encryption format='%s'>\n", format);
 
     for (i = 0; i < enc->nsecrets; i++) {
-        if (virStorageEncryptionSecretFormat(conn, buf, enc->secrets[i]) < 0)
+        if (virStorageEncryptionSecretFormat(buf, enc->secrets[i]) < 0)
             return -1;
     }
 
@@ -261,7 +258,7 @@ virStorageEncryptionFormat(virConnectPtr conn,
 }
 
 int
-virStorageGenerateQcowPassphrase(virConnectPtr conn, unsigned char *dest)
+virStorageGenerateQcowPassphrase(unsigned char *dest)
 {
     int fd;
     size_t i;
@@ -271,7 +268,7 @@ virStorageGenerateQcowPassphrase(virConnectPtr conn, unsigned char *dest)
        unpleasant surprises with the qemu monitor input mechanism. */
     fd = open("/dev/urandom", O_RDONLY);
     if (fd < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Cannot open /dev/urandom"));
         return -1;
     }
@@ -282,7 +279,7 @@ virStorageGenerateQcowPassphrase(virConnectPtr conn, unsigned char *dest)
         while ((r = read(fd, dest + i, 1)) == -1 && errno == EINTR)
             ;
         if (r <= 0) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("Cannot read from /dev/urandom"));
             close(fd);
             return -1;

src/conf/storage_encryption_conf.h

@@ -64,10 +64,9 @@ struct _virStorageEncryption {
 
 void virStorageEncryptionFree(virStorageEncryptionPtr enc);
 
-virStorageEncryptionPtr virStorageEncryptionParseNode(virConnectPtr conn,
-                                                      xmlDocPtr xml,
+virStorageEncryptionPtr virStorageEncryptionParseNode(xmlDocPtr xml,
                                                       xmlNodePtr root);
-int virStorageEncryptionFormat(virConnectPtr conn, virBufferPtr buf,
+int virStorageEncryptionFormat(virBufferPtr buf,
                                virStorageEncryptionPtr enc);
 
 /* A helper for VIR_STORAGE_ENCRYPTION_FORMAT_QCOW */
@@ -75,6 +74,6 @@ enum {
   VIR_STORAGE_QCOW_PASSPHRASE_SIZE = 16
 };
 
-int virStorageGenerateQcowPassphrase(virConnectPtr conn, unsigned char *dest);
+int virStorageGenerateQcowPassphrase(unsigned char *dest);
 
 #endif /* __VIR_STORAGE_ENCRYPTION_H__ */

src/storage/storage_backend.c

@@ -271,7 +271,7 @@ cleanup:
 }
 
 int
-virStorageBackendCreateRaw(virConnectPtr conn,
+virStorageBackendCreateRaw(virConnectPtr conn ATTRIBUTE_UNUSED,
                            virStoragePoolObjPtr pool,
                            virStorageVolDefPtr vol,
                            virStorageVolDefPtr inputvol,
@@ -284,7 +284,7 @@ virStorageBackendCreateRaw(virConnectPtr conn,
     char *buf = NULL;
 
     if (vol->target.encryption != NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+        virStorageReportError(VIR_ERR_NO_SUPPORT,
                               "%s", _("storage pool does not support encrypted "
                                       "volumes"));
         return -1;
@@ -419,14 +419,14 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
         conn->secretDriver->lookupByUUID == NULL ||
         conn->secretDriver->defineXML == NULL ||
         conn->secretDriver->setValue == NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT, "%s",
+        virStorageReportError(VIR_ERR_NO_SUPPORT, "%s",
                               _("secret storage not supported"));
         goto cleanup;
     }
 
     enc = vol->target.encryption;
     if (enc->nsecrets != 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("secrets already defined"));
         goto cleanup;
     }
@@ -461,7 +461,7 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
     }
     VIR_FREE(xml);
 
-    if (virStorageGenerateQcowPassphrase(conn, value) < 0)
+    if (virStorageGenerateQcowPassphrase(value) < 0)
         goto cleanup;
 
     if (conn->secretDriver->setValue(secret, value, sizeof(value), 0) < 0)
@@ -619,13 +619,13 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
     };
 
     if (type == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unknown storage vol type %d"),
                               vol->target.format);
         return -1;
     }
     if (inputvol && inputType == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unknown storage vol type %d"),
                               inputvol->target.format);
         return -1;
@@ -640,14 +640,14 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
         if (inputvol &&
             (!inputBackingPath ||
              STRNEQ(inputBackingPath, vol->backingStore.path))) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("a different backing store can not "
                                           "be specified."));
             return -1;
         }
 
         if (backingType == NULL) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unknown storage vol backing store type %d"),
                                   vol->backingStore.format);
             return -1;
@@ -665,7 +665,7 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
 
         if (vol->target.format != VIR_STORAGE_FILE_QCOW &&
             vol->target.format != VIR_STORAGE_FILE_QCOW2) {
-            virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+            virStorageReportError(VIR_ERR_NO_SUPPORT,
                                   _("qcow volume encryption unsupported with "
                                     "volume format %s"), type);
             return -1;
@@ -673,13 +673,13 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
         enc = vol->target.encryption;
         if (enc->format != VIR_STORAGE_ENCRYPTION_FORMAT_QCOW &&
             enc->format != VIR_STORAGE_ENCRYPTION_FORMAT_DEFAULT) {
-            virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+            virStorageReportError(VIR_ERR_NO_SUPPORT,
                                   _("unsupported volume encryption format %d"),
                                   vol->target.encryption->format);
             return -1;
         }
         if (enc->nsecrets > 1) {
-            virStorageReportError(conn, VIR_ERR_INVALID_STORAGE_VOL, "%s",
+            virStorageReportError(VIR_ERR_INVALID_STORAGE_VOL, "%s",
                                   _("too many secrets for qcow encryption"));
             return -1;
         }
@@ -695,7 +695,7 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
     else if ((create_tool = virFindFileInPath("qemu-img")) != NULL)
         use_kvmimg = 0;
     else {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("unable to find kvm-img or qemu-img"));
         return -1;
     }
@@ -737,7 +737,7 @@ virStorageBackendCreateQemuImg(virConnectPtr conn,
  * with a partially functional qcow-create. Go figure ??!?
  */
 static int
-virStorageBackendCreateQcowCreate(virConnectPtr conn,
+virStorageBackendCreateQcowCreate(virConnectPtr conn ATTRIBUTE_UNUSED,
                                   virStoragePoolObjPtr pool,
                                   virStorageVolDefPtr vol,
                                   virStorageVolDefPtr inputvol,
@@ -748,25 +748,25 @@ virStorageBackendCreateQcowCreate(virConnectPtr conn,
     const char *imgargv[4];
 
     if (inputvol) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("cannot copy from volume with qcow-create"));
         return -1;
     }
 
     if (vol->target.format != VIR_STORAGE_FILE_QCOW2) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unsupported storage vol type %d"),
                               vol->target.format);
         return -1;
     }
     if (vol->backingStore.path != NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT, "%s",
+        virStorageReportError(VIR_ERR_NO_SUPPORT, "%s",
                               _("copy-on-write image not supported with "
                                       "qcow-create"));
         return -1;
     }
     if (vol->target.encryption != NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+        virStorageReportError(VIR_ERR_NO_SUPPORT,
                               "%s", _("encrypted volumes not supported with "
                                       "qcow-create"));
         return -1;
@@ -787,7 +787,7 @@ virStorageBackendCreateQcowCreate(virConnectPtr conn,
 }
 
 virStorageBackendBuildVolFrom
-virStorageBackendFSImageToolTypeToFunc(virConnectPtr conn, int tool_type)
+virStorageBackendFSImageToolTypeToFunc(int tool_type)
 {
     switch (tool_type) {
     case TOOL_KVM_IMG:
@@ -796,7 +796,7 @@ virStorageBackendFSImageToolTypeToFunc(virConnectPtr conn, int tool_type)
     case TOOL_QCOW_CREATE:
         return virStorageBackendCreateQcowCreate;
     default:
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Unknown file create tool type '%d'."),
                               tool_type);
     }
@@ -827,8 +827,7 @@ virStorageBackendFindFSImageTool(char **tool)
 }
 
 virStorageBackendBuildVolFrom
-virStorageBackendGetBuildVolFromFunction(virConnectPtr conn,
-                                         virStorageVolDefPtr vol,
+virStorageBackendGetBuildVolFromFunction(virStorageVolDefPtr vol,
                                          virStorageVolDefPtr inputvol)
 {
     int tool_type;
@@ -845,13 +844,13 @@ virStorageBackendGetBuildVolFromFunction(virConnectPtr conn,
          inputvol->target.format != VIR_STORAGE_FILE_RAW)) {
 
         if ((tool_type = virStorageBackendFindFSImageTool(NULL)) < 0) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("creation of non-raw file images is "
                                           "not supported without qemu-img."));
             return NULL;
         }
 
-        return virStorageBackendFSImageToolTypeToFunc(conn, tool_type);
+        return virStorageBackendFSImageToolTypeToFunc(tool_type);
     }
 
     if (vol->type == VIR_STORAGE_VOL_BLOCK)
@@ -868,7 +867,7 @@ virStorageBackendForType(int type) {
         if (backends[i]->type == type)
             return backends[i];
 
-    virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR,
+    virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                           _("missing backend for pool type %d"), type);
     return NULL;
 }
@@ -1192,8 +1191,7 @@ virStorageBackendStablePath(virStoragePoolObjPtr pool,
  * then run a callback passing in all the matches
  */
 int
-virStorageBackendRunProgRegex(virConnectPtr conn,
-                              virStoragePoolObjPtr pool,
+virStorageBackendRunProgRegex(virStoragePoolObjPtr pool,
                               const char *const*prog,
                               int nregex,
                               const char **regex,
@@ -1223,7 +1221,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
         if (err != 0) {
             char error[100];
             regerror(err, &reg[i], error, sizeof(error));
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Failed to compile regex %s"), error);
             for (j = 0 ; j <= i ; j++)
                 regfree(&reg[j]);
@@ -1255,7 +1253,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
     }
 
     if ((list = fdopen(fd, "r")) == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("cannot read fd"));
         goto cleanup;
     }
@@ -1286,7 +1284,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
 
                 /* We're matching on the last regex, so callback time */
                 if (i == (nregex-1)) {
-                    if (((*func)(conn, pool, groups, data)) < 0)
+                    if (((*func)(pool, groups, data)) < 0)
                         goto cleanup;
 
                     /* Release matches & restart to matching the first regex */
@@ -1337,7 +1335,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
             if (outexit != NULL)
                 *outexit = WEXITSTATUS(exitstatus);
         } else {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("command did not exit cleanly"));
             return -1;
         }
@@ -1358,8 +1356,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
  * If there are no input tokens (empty input), call FUNC with N_COLUMNS == 0.
  */
 int
-virStorageBackendRunProgNul(virConnectPtr conn,
-                            virStoragePoolObjPtr pool,
+virStorageBackendRunProgNul(virStoragePoolObjPtr pool,
                             const char **prog,
                             size_t n_columns,
                             virStorageBackendListVolNulFunc func,
@@ -1391,7 +1388,7 @@ virStorageBackendRunProgNul(virConnectPtr conn,
     }
 
     if ((fp = fdopen(fd, "r")) == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("cannot read fd"));
         goto cleanup;
     }
@@ -1406,13 +1403,13 @@ virStorageBackendRunProgNul(virConnectPtr conn,
         if (tok_len < 0) {
             /* Maybe EOF, maybe an error.
                If n_tok > 0, then we know it's an error.  */
-            if (n_tok && func (conn, pool, n_tok, v, data) < 0)
+            if (n_tok && func (pool, n_tok, v, data) < 0)
                 goto cleanup;
             break;
         }
         ++n_tok;
         if (n_tok == n_columns) {
-            if (func (conn, pool, n_tok, v, data) < 0)
+            if (func (pool, n_tok, v, data) < 0)
                 goto cleanup;
             n_tok = 0;
             for (i = 0; i < n_columns; i++) {
@@ -1452,13 +1449,13 @@ virStorageBackendRunProgNul(virConnectPtr conn,
     } else {
         if (WIFEXITED(exitstatus)) {
             if (WEXITSTATUS(exitstatus) != 0) {
-                virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+                virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                       _("non-zero exit status from command %d"),
                                       WEXITSTATUS(exitstatus));
                 return -1;
             }
         } else {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("command did not exit cleanly"));
             return -1;
         }
@@ -1480,7 +1477,7 @@ virStorageBackendRunProgRegex(virConnectPtr conn,
                               void *data ATTRIBUTE_UNUSED,
                               int *outexit ATTRIBUTE_UNUSED)
 {
-    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, _("%s not implemented on Win32"), __FUNCTION__);
+    virStorageReportError(VIR_ERR_INTERNAL_ERROR, _("%s not implemented on Win32"), __FUNCTION__);
     return -1;
 }
 
@@ -1492,7 +1489,7 @@ virStorageBackendRunProgNul(virConnectPtr conn,
                             virStorageBackendListVolNulFunc func ATTRIBUTE_UNUSED,
                             void *data ATTRIBUTE_UNUSED)
 {
-    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, _("%s not implemented on Win32"), __FUNCTION__);
+    virStorageReportError(VIR_ERR_INTERNAL_ERROR, _("%s not implemented on Win32"), __FUNCTION__);
     return -1;
 }
 #endif

src/storage/storage_backend.h

@@ -51,13 +51,11 @@ int virStorageBackendCreateRaw(virConnectPtr conn,
                                virStorageVolDefPtr inputvol,
                                unsigned int flags);
 virStorageBackendBuildVolFrom
-virStorageBackendGetBuildVolFromFunction(virConnectPtr conn,
-                                         virStorageVolDefPtr vol,
+virStorageBackendGetBuildVolFromFunction(virStorageVolDefPtr vol,
                                          virStorageVolDefPtr inputvol);
 int virStorageBackendFindFSImageTool(char **tool);
 virStorageBackendBuildVolFrom
-virStorageBackendFSImageToolTypeToFunc(virConnectPtr conn,
-                                       int tool_type);
+virStorageBackendFSImageToolTypeToFunc(int tool_type);
 
 
 typedef struct _virStorageBackend virStorageBackend;
@@ -100,18 +98,15 @@ virStorageBackendUpdateVolTargetFormatFD(virStorageVolTargetPtr target,
 char *virStorageBackendStablePath(virStoragePoolObjPtr pool,
                                   const char *devpath);
 
-typedef int (*virStorageBackendListVolRegexFunc)(virConnectPtr conn,
-                                                 virStoragePoolObjPtr pool,
+typedef int (*virStorageBackendListVolRegexFunc)(virStoragePoolObjPtr pool,
                                                  char **const groups,
                                                  void *data);
-typedef int (*virStorageBackendListVolNulFunc)(virConnectPtr conn,
-                                               virStoragePoolObjPtr pool,
+typedef int (*virStorageBackendListVolNulFunc)(virStoragePoolObjPtr pool,
                                                size_t n_tokens,
                                                char **const groups,
                                                void *data);
 
-int virStorageBackendRunProgRegex(virConnectPtr conn,
-                                  virStoragePoolObjPtr pool,
+int virStorageBackendRunProgRegex(virStoragePoolObjPtr pool,
                                   const char *const*prog,
                                   int nregex,
                                   const char **regex,
@@ -120,8 +115,7 @@ int virStorageBackendRunProgRegex(virConnectPtr conn,
                                   void *data,
                                   int *exitstatus);
 
-int virStorageBackendRunProgNul(virConnectPtr conn,
-                                virStoragePoolObjPtr pool,
+int virStorageBackendRunProgNul(virStoragePoolObjPtr pool,
                                 const char **prog,
                                 size_t n_columns,
                                 virStorageBackendListVolNulFunc func,

src/storage/storage_backend_disk.c

@@ -39,8 +39,7 @@
 #define SECTOR_SIZE 512
 
 static int
-virStorageBackendDiskMakeDataVol(virConnectPtr conn,
-                                 virStoragePoolObjPtr pool,
+virStorageBackendDiskMakeDataVol(virStoragePoolObjPtr pool,
                                  char **const groups,
                                  virStorageVolDefPtr vol)
 {
@@ -105,14 +104,14 @@ virStorageBackendDiskMakeDataVol(virConnectPtr conn,
 
         if (virStrToLong_ull(groups[3], NULL, 10,
                              &vol->source.extents[0].start) < 0) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("cannot parse device start location"));
             return -1;
         }
 
         if (virStrToLong_ull(groups[4], NULL, 10,
                              &vol->source.extents[0].end) < 0) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("cannot parse device end location"));
             return -1;
         }
@@ -154,8 +153,7 @@ virStorageBackendDiskMakeDataVol(virConnectPtr conn,
 }
 
 static int
-virStorageBackendDiskMakeFreeExtent(virConnectPtr conn ATTRIBUTE_UNUSED,
-                                    virStoragePoolObjPtr pool,
+virStorageBackendDiskMakeFreeExtent(virStoragePoolObjPtr pool,
                                     char **const groups)
 {
     virStoragePoolSourceDevicePtr dev = &pool->def->source.devices[0];
@@ -202,8 +200,7 @@ virStorageBackendDiskMakeFreeExtent(virConnectPtr conn ATTRIBUTE_UNUSED,
 
 
 static int
-virStorageBackendDiskMakeVol(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
+virStorageBackendDiskMakeVol(virStoragePoolObjPtr pool,
                              size_t ntok ATTRIBUTE_UNUSED,
                              char **const groups,
                              void *data)
@@ -237,10 +234,10 @@ virStorageBackendDiskMakeVol(virConnectPtr conn,
             }
         }
 
-        return virStorageBackendDiskMakeDataVol(conn, pool, groups, vol);
+        return virStorageBackendDiskMakeDataVol(pool, groups, vol);
     } else if (STREQ(groups[2], "free")) {
         /* ....or free space extents */
-        return virStorageBackendDiskMakeFreeExtent(conn, pool, groups);
+        return virStorageBackendDiskMakeFreeExtent(pool, groups);
     } else {
         /* This code path should never happen unless someone changed
          * libvirt_parthelper forgot to change this code */
@@ -260,8 +257,7 @@ virStorageBackendDiskMakeVol(virConnectPtr conn,
  * and we can even ensure the output is friendly.
  */
 static int
-virStorageBackendDiskReadPartitions(virConnectPtr conn,
-                                    virStoragePoolObjPtr pool,
+virStorageBackendDiskReadPartitions(virStoragePoolObjPtr pool,
                                     virStorageVolDefPtr vol)
 {
 
@@ -278,8 +274,7 @@ virStorageBackendDiskReadPartitions(virConnectPtr conn,
 
     pool->def->allocation = pool->def->capacity = pool->def->available = 0;
 
-    return virStorageBackendRunProgNul(conn,
-                                       pool,
+    return virStorageBackendRunProgNul(pool,
                                        prog,
                                        6,
                                        virStorageBackendDiskMakeVol,
@@ -287,11 +282,10 @@ virStorageBackendDiskReadPartitions(virConnectPtr conn,
 }
 
 static int
-virStorageBackendDiskMakePoolGeometry(virConnectPtr conn ATTRIBUTE_UNUSED,
-                                     virStoragePoolObjPtr pool,
-                                     size_t ntok ATTRIBUTE_UNUSED,
-                                     char **const groups,
-                                     void *data ATTRIBUTE_UNUSED)
+virStorageBackendDiskMakePoolGeometry(virStoragePoolObjPtr pool,
+                                      size_t ntok ATTRIBUTE_UNUSED,
+                                      char **const groups,
+                                      void *data ATTRIBUTE_UNUSED)
 {
 
        pool->def->source.devices[0].geometry.cyliders = atoi(groups[0]);
@@ -302,14 +296,13 @@ virStorageBackendDiskMakePoolGeometry(virConnectPtr conn ATTRIBUTE_UNUSED,
 }
 
 static int
-virStorageBackendDiskReadGeometry(virConnectPtr conn, virStoragePoolObjPtr pool)
+virStorageBackendDiskReadGeometry(virStoragePoolObjPtr pool)
 {
     const char *prog[] = {
         PARTHELPER, pool->def->source.devices[0].path, "-g", NULL,
     };
 
-    return virStorageBackendRunProgNul(conn,
-                                       pool,
+    return virStorageBackendRunProgNul(pool,
                                        prog,
                                        3,
                                        virStorageBackendDiskMakePoolGeometry,
@@ -317,7 +310,7 @@ virStorageBackendDiskReadGeometry(virConnectPtr conn, virStoragePoolObjPtr pool)
 }
 
 static int
-virStorageBackendDiskRefreshPool(virConnectPtr conn,
+virStorageBackendDiskRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                  virStoragePoolObjPtr pool)
 {
     VIR_FREE(pool->def->source.devices[0].freeExtents);
@@ -325,11 +318,11 @@ virStorageBackendDiskRefreshPool(virConnectPtr conn,
 
     virFileWaitForDevices();
 
-    if (virStorageBackendDiskReadGeometry(conn, pool) != 0) {
+    if (virStorageBackendDiskReadGeometry(pool) != 0) {
         return -1;
     }
 
-    return virStorageBackendDiskReadPartitions(conn, pool, NULL);
+    return virStorageBackendDiskReadPartitions(pool, NULL);
 }
 
 
@@ -386,7 +379,7 @@ virStorageBackendDiskPartTypeToCreate(virStoragePoolObjPtr pool)
 }
 
 static int
-virStorageBackendDiskPartFormat(virConnectPtr conn, virStoragePoolObjPtr pool,
+virStorageBackendDiskPartFormat(virStoragePoolObjPtr pool,
                                 virStorageVolDefPtr vol,
                                 char* partFormat)
 {
@@ -394,7 +387,7 @@ virStorageBackendDiskPartFormat(virConnectPtr conn, virStoragePoolObjPtr pool,
     if (pool->def->source.format == VIR_STORAGE_POOL_DISK_DOS) {
         const char *partedFormat = virStoragePartedFsTypeTypeToString(vol->target.format);
         if(partedFormat == NULL) {
-           virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+           virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                  "%s", _("Invalid partition type"));
            return -1;
         }
@@ -402,7 +395,7 @@ virStorageBackendDiskPartFormat(virConnectPtr conn, virStoragePoolObjPtr pool,
             /* make sure we don't have a extended partition already */
             for (i = 0; i < pool->volumes.count; i++) {
                  if (pool->volumes.objs[i]->target.format == VIR_STORAGE_VOL_DISK_EXTENDED) {
-                     virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+                     virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                            "%s", _("extended partition already exists"));
                      return -1;
                  }
@@ -426,7 +419,7 @@ virStorageBackendDiskPartFormat(virConnectPtr conn, virStoragePoolObjPtr pool,
                               }
                          }
                          if (i == pool->volumes.count) {
-                             virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+                             virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                                    "%s", _("no extended partition found and no primary partition available"));
                              return -1;
                          }
@@ -448,8 +441,7 @@ virStorageBackendDiskPartFormat(virConnectPtr conn, virStoragePoolObjPtr pool,
  * partitions
  */
 static int
-virStorageBackendDiskPartBoundries(virConnectPtr conn,
-                                   virStoragePoolObjPtr pool,
+virStorageBackendDiskPartBoundries(virStoragePoolObjPtr pool,
                                    unsigned long long *start,
                                    unsigned long long *end,
                                    unsigned long long allocation)
@@ -511,7 +503,7 @@ virStorageBackendDiskPartBoundries(virConnectPtr conn,
     }
 
     if (smallestExtent == -1) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("no large enough free extent"));
         return -1;
     }
@@ -538,7 +530,7 @@ virStorageBackendDiskPartBoundries(virConnectPtr conn,
 
 
 static int
-virStorageBackendDiskCreateVol(virConnectPtr conn,
+virStorageBackendDiskCreateVol(virConnectPtr conn ATTRIBUTE_UNUSED,
                                virStoragePoolObjPtr pool,
                                virStorageVolDefPtr vol)
 {
@@ -556,17 +548,17 @@ virStorageBackendDiskCreateVol(virConnectPtr conn,
     };
 
     if (vol->target.encryption != NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+        virStorageReportError(VIR_ERR_NO_SUPPORT,
                               "%s", _("storage pool does not support encrypted "
                                       "volumes"));
         return -1;
     }
 
-    if (virStorageBackendDiskPartFormat(conn, pool, vol, partFormat) != 0) {
+    if (virStorageBackendDiskPartFormat(pool, vol, partFormat) != 0) {
         return -1;
     }
 
-    if (virStorageBackendDiskPartBoundries(conn, pool, &startOffset,
+    if (virStorageBackendDiskPartBoundries(pool, &startOffset,
                                            &endOffset,
                                            vol->capacity) != 0) {
        return -1;
@@ -591,7 +583,7 @@ virStorageBackendDiskCreateVol(virConnectPtr conn,
     VIR_FREE(vol->target.path);
 
     /* Fetch actual extent info, generate key */
-    if (virStorageBackendDiskReadPartitions(conn, pool, vol) < 0)
+    if (virStorageBackendDiskReadPartitions(pool, vol) < 0)
         return -1;
 
     return 0;
@@ -606,7 +598,7 @@ virStorageBackendDiskBuildVolFrom(virConnectPtr conn,
 {
     virStorageBackendBuildVolFrom build_func;
 
-    build_func = virStorageBackendGetBuildVolFromFunction(conn, vol, inputvol);
+    build_func = virStorageBackendGetBuildVolFromFunction(vol, inputvol);
     if (!build_func)
         return -1;
 
@@ -614,7 +606,7 @@ virStorageBackendDiskBuildVolFrom(virConnectPtr conn,
 }
 
 static int
-virStorageBackendDiskDeleteVol(virConnectPtr conn,
+virStorageBackendDiskDeleteVol(virConnectPtr conn ATTRIBUTE_UNUSED,
                                virStoragePoolObjPtr pool,
                                virStorageVolDefPtr vol,
                                unsigned int flags ATTRIBUTE_UNUSED)
@@ -637,7 +629,7 @@ virStorageBackendDiskDeleteVol(virConnectPtr conn,
     DEBUG("devname=%s, srcname=%s", devname, srcname);
 
     if (!STRPREFIX(devname, srcname)) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Volume path '%s' did not start with parent "
                                 "pool source device name."), devname);
         goto cleanup;
@@ -646,7 +638,7 @@ virStorageBackendDiskDeleteVol(virConnectPtr conn,
     part_num = devname + strlen(srcname);
 
     if (*part_num == 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse partition number from target "
                                 "'%s'"), devname);
         goto cleanup;

src/storage/storage_backend_fs.c

@@ -135,8 +135,7 @@ struct _virNetfsDiscoverState {
 typedef struct _virNetfsDiscoverState virNetfsDiscoverState;
 
 static int
-virStorageBackendFileSystemNetFindPoolSourcesFunc(virConnectPtr conn,
-                                                  virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
+virStorageBackendFileSystemNetFindPoolSourcesFunc(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
                                                   char **const groups,
                                                   void *data)
 {
@@ -149,18 +148,18 @@ virStorageBackendFileSystemNetFindPoolSourcesFunc(virConnectPtr conn,
 
     name = strrchr(path, '/');
     if (name == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("invalid netfs path (no /): %s"), path);
         goto cleanup;
     }
     name += 1;
     if (*name == '\0') {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("invalid netfs path (ends in /): %s"), path);
         goto cleanup;
     }
 
-    if (!(src = virStoragePoolSourceListNewSource(conn, &state->list)))
+    if (!(src = virStoragePoolSourceListNewSource(&state->list)))
         goto cleanup;
 
     if (!(src->host.name = strdup(state->host)) ||
@@ -180,7 +179,7 @@ cleanup:
 
 
 static char *
-virStorageBackendFileSystemNetFindPoolSources(virConnectPtr conn,
+virStorageBackendFileSystemNetFindPoolSources(virConnectPtr conn ATTRIBUTE_UNUSED,
                                               const char *srcSpec,
                                               unsigned int flags ATTRIBUTE_UNUSED)
 {
@@ -212,7 +211,7 @@ virStorageBackendFileSystemNetFindPoolSources(virConnectPtr conn,
     char *retval = NULL;
     unsigned int i;
 
-    source = virStoragePoolDefParseSourceString(conn, srcSpec,
+    source = virStoragePoolDefParseSourceString(srcSpec,
                                                 VIR_STORAGE_POOL_NETFS);
     if (!source)
         goto cleanup;
@@ -220,12 +219,12 @@ virStorageBackendFileSystemNetFindPoolSources(virConnectPtr conn,
     state.host = source->host.name;
     prog[3] = source->host.name;
 
-    if (virStorageBackendRunProgRegex(conn, NULL, prog, 1, regexes, vars,
+    if (virStorageBackendRunProgRegex(NULL, prog, 1, regexes, vars,
                                       virStorageBackendFileSystemNetFindPoolSourcesFunc,
                                       &state, &exitstatus) < 0)
         goto cleanup;
 
-    retval = virStoragePoolSourceListFormat(conn, &state.list);
+    retval = virStoragePoolSourceListFormat(&state.list);
     if (retval == NULL) {
         virReportOOMError();
         goto cleanup;
@@ -286,8 +285,7 @@ virStorageBackendFileSystemIsMounted(virStoragePoolObjPtr pool) {
  * Returns 0 if successfully mounted, -1 on error
  */
 static int
-virStorageBackendFileSystemMount(virConnectPtr conn,
-                                 virStoragePoolObjPtr pool) {
+virStorageBackendFileSystemMount(virStoragePoolObjPtr pool) {
     char *src;
     char *options;
     const char **mntargv;
@@ -351,18 +349,18 @@ virStorageBackendFileSystemMount(virConnectPtr conn,
 
     if (pool->def->type == VIR_STORAGE_POOL_NETFS) {
         if (pool->def->source.host.name == NULL) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source host"));
             return -1;
         }
         if (pool->def->source.dir == NULL) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source path"));
             return -1;
         }
     } else {
         if (pool->def->source.ndevice != 1) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source device"));
             return -1;
         }
@@ -420,25 +418,24 @@ virStorageBackendFileSystemMount(virConnectPtr conn,
  * Returns 0 if successfully unmounted, -1 on error
  */
 static int
-virStorageBackendFileSystemUnmount(virConnectPtr conn,
-                                   virStoragePoolObjPtr pool) {
+virStorageBackendFileSystemUnmount(virStoragePoolObjPtr pool) {
     const char *mntargv[3];
     int ret;
 
     if (pool->def->type == VIR_STORAGE_POOL_NETFS) {
         if (pool->def->source.host.name == NULL) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source host"));
             return -1;
         }
         if (pool->def->source.dir == NULL) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source dir"));
             return -1;
         }
     } else {
         if (pool->def->source.ndevice != 1) {
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("missing source device"));
             return -1;
         }
@@ -476,11 +473,11 @@ virStorageBackendFileSystemUnmount(virConnectPtr conn,
  */
 #if WITH_STORAGE_FS
 static int
-virStorageBackendFileSystemStart(virConnectPtr conn,
+virStorageBackendFileSystemStart(virConnectPtr conn ATTRIBUTE_UNUSED,
                                  virStoragePoolObjPtr pool)
 {
     if (pool->def->type != VIR_STORAGE_POOL_DIR &&
-        virStorageBackendFileSystemMount(conn, pool) < 0)
+        virStorageBackendFileSystemMount(pool) < 0)
         return -1;
 
     return 0;
@@ -499,7 +496,7 @@ virStorageBackendFileSystemStart(virConnectPtr conn,
  * Returns 0 on success, -1 on error
  */
 static int
-virStorageBackendFileSystemBuild(virConnectPtr conn,
+virStorageBackendFileSystemBuild(virConnectPtr conn ATTRIBUTE_UNUSED,
                                  virStoragePoolObjPtr pool,
                                  unsigned int flags ATTRIBUTE_UNUSED)
 {
@@ -512,7 +509,7 @@ virStorageBackendFileSystemBuild(virConnectPtr conn,
         goto error;
     }
     if (!(p = strrchr(parent, '/'))) {
-        virStorageReportError(conn, VIR_ERR_INVALID_ARG,
+        virStorageReportError(VIR_ERR_INVALID_ARG,
                               _("path '%s' is not absolute"),
                               pool->def->target.path);
         goto error;
@@ -694,11 +691,11 @@ no_memory:
  */
 #if WITH_STORAGE_FS
 static int
-virStorageBackendFileSystemStop(virConnectPtr conn,
+virStorageBackendFileSystemStop(virConnectPtr conn ATTRIBUTE_UNUSED,
                                 virStoragePoolObjPtr pool)
 {
     if (pool->def->type != VIR_STORAGE_POOL_DIR &&
-        virStorageBackendFileSystemUnmount(conn, pool) < 0)
+        virStorageBackendFileSystemUnmount(pool) < 0)
         return -1;
 
     return 0;
@@ -766,7 +763,7 @@ virStorageBackendFileSystemVolCreate(virConnectPtr conn ATTRIBUTE_UNUSED,
     return 0;
 }
 
-static int createFileDir(virConnectPtr conn,
+static int createFileDir(virConnectPtr conn ATTRIBUTE_UNUSED,
                          virStoragePoolObjPtr pool,
                          virStorageVolDefPtr vol,
                          virStorageVolDefPtr inputvol,
@@ -774,7 +771,7 @@ static int createFileDir(virConnectPtr conn,
     int err;
 
     if (inputvol) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s",
                               _("cannot copy from volume to a directory volume"));
         return -1;
@@ -803,13 +800,13 @@ _virStorageBackendFileSystemVolBuild(virConnectPtr conn,
 
     if (inputvol) {
         if (vol->target.encryption != NULL) {
-            virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+            virStorageReportError(VIR_ERR_NO_SUPPORT,
                                   "%s", _("storage pool does not support "
                                           "building encrypted volumes from "
                                           "other volumes"));
             return -1;
         }
-        create_func = virStorageBackendGetBuildVolFromFunction(conn, vol,
+        create_func = virStorageBackendGetBuildVolFromFunction(vol,
                                                                inputvol);
         if (!create_func)
             return -1;
@@ -818,12 +815,12 @@ _virStorageBackendFileSystemVolBuild(virConnectPtr conn,
     } else if (vol->target.format == VIR_STORAGE_FILE_DIR) {
         create_func = createFileDir;
     } else if ((tool_type = virStorageBackendFindFSImageTool(NULL)) != -1) {
-        create_func = virStorageBackendFSImageToolTypeToFunc(conn, tool_type);
+        create_func = virStorageBackendFSImageToolTypeToFunc(tool_type);
 
         if (!create_func)
             return -1;
     } else {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("creation of non-raw images "
                                       "is not supported without qemu-img"));
         return -1;

src/storage/storage_backend_iscsi.c

@@ -45,8 +45,7 @@
 #define VIR_FROM_THIS VIR_FROM_STORAGE
 
 static int
-virStorageBackendISCSITargetIP(virConnectPtr conn,
-                               const char *hostname,
+virStorageBackendISCSITargetIP(const char *hostname,
                                char *ipaddr,
                                size_t ipaddrlen)
 {
@@ -62,14 +61,14 @@ virStorageBackendISCSITargetIP(virConnectPtr conn,
 
     ret = getaddrinfo(hostname, NULL, &hints, &result);
     if (ret != 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("host lookup failed %s"),
                               gai_strerror(ret));
         return -1;
     }
 
     if (result == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("no IP address for target %s"),
                               hostname);
         return -1;
@@ -78,7 +77,7 @@ virStorageBackendISCSITargetIP(virConnectPtr conn,
     if (getnameinfo(result->ai_addr, result->ai_addrlen,
                     ipaddr, ipaddrlen, NULL, 0,
                     NI_NUMERICHOST) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot format ip addr for %s"),
                               hostname);
         freeaddrinfo(result);
@@ -90,8 +89,7 @@ virStorageBackendISCSITargetIP(virConnectPtr conn,
 }
 
 static int
-virStorageBackendISCSIExtractSession(virConnectPtr conn ATTRIBUTE_UNUSED,
-                                     virStoragePoolObjPtr pool,
+virStorageBackendISCSIExtractSession(virStoragePoolObjPtr pool,
                                      char **const groups,
                                      void *data)
 {
@@ -108,8 +106,7 @@ virStorageBackendISCSIExtractSession(virConnectPtr conn ATTRIBUTE_UNUSED,
 }
 
 static char *
-virStorageBackendISCSISession(virConnectPtr conn,
-                              virStoragePoolObjPtr pool,
+virStorageBackendISCSISession(virStoragePoolObjPtr pool,
                               int probe)
 {
     /*
@@ -134,7 +131,7 @@ virStorageBackendISCSISession(virConnectPtr conn,
      * returned an exit status of > 0, even if they succeeded.  We will just
      * rely on whether session got filled in properly.
      */
-    if (virStorageBackendRunProgRegex(conn, pool,
+    if (virStorageBackendRunProgRegex(pool,
                                       prog,
                                       1,
                                       regexes,
@@ -146,7 +143,7 @@ virStorageBackendISCSISession(virConnectPtr conn,
 
     if (session == NULL &&
         !probe) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("cannot find session"));
         return NULL;
     }
@@ -158,8 +155,7 @@ virStorageBackendISCSISession(virConnectPtr conn,
 #define LINE_SIZE 4096
 
 static int
-virStorageBackendIQNFound(virConnectPtr conn,
-                          virStoragePoolObjPtr pool,
+virStorageBackendIQNFound(virStoragePoolObjPtr pool,
                           char **ifacename)
 {
     int ret = IQN_MISSING, fd = -1;
@@ -174,7 +170,7 @@ virStorageBackendIQNFound(virConnectPtr conn,
 
     if (VIR_ALLOC_N(line, LINE_SIZE) != 0) {
         ret = IQN_ERROR;
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Could not allocate memory for output of '%s'"),
                               prog[0]);
         goto out;
@@ -183,7 +179,7 @@ virStorageBackendIQNFound(virConnectPtr conn,
     memset(line, 0, LINE_SIZE);
 
     if (virExec(prog, NULL, NULL, &child, -1, &fd, NULL, VIR_EXEC_NONE) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to run '%s' when looking for existing interface with IQN '%s'"),
                               prog[0], pool->def->source.initiator.iqn);
 
@@ -192,7 +188,7 @@ virStorageBackendIQNFound(virConnectPtr conn,
     }
 
     if ((fp = fdopen(fd, "r")) == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to open stream for file descriptor "
                                 "when reading output from '%s': '%s'"),
                               prog[0], virStrerror(errno, ebuf, sizeof ebuf));
@@ -204,7 +200,7 @@ virStorageBackendIQNFound(virConnectPtr conn,
         newline = strrchr(line, '\n');
         if (newline == NULL) {
             ret = IQN_ERROR;
-            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Unexpected line > %d characters "
                                     "when parsing output of '%s'"),
                                   LINE_SIZE, prog[0]);
@@ -251,15 +247,14 @@ out:
 
 
 static int
-virStorageBackendCreateIfaceIQN(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
-                             char **ifacename)
+virStorageBackendCreateIfaceIQN(virStoragePoolObjPtr pool,
+                                char **ifacename)
 {
     int ret = -1, exitstatus = -1;
     char temp_ifacename[32];
 
     if (virRandomInitialize(time(NULL) ^ getpid()) == -1) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Failed to initialize random generator "
                                 "when creating iscsi interface"));
         goto out;
@@ -280,7 +275,7 @@ virStorageBackendCreateIfaceIQN(virConnectPtr conn,
      * We will just rely on whether the interface got created
      * properly. */
     if (virRun(cmdargv1, &exitstatus) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to run command '%s' to create new iscsi interface"),
                               cmdargv1[0]);
         goto out;
@@ -296,14 +291,14 @@ virStorageBackendCreateIfaceIQN(virConnectPtr conn,
      * returned an exit status of > 0, even if they succeeded.  We will just
      * rely on whether iface file got updated properly. */
     if (virRun(cmdargv2, &exitstatus) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to run command '%s' to update iscsi interface with IQN '%s'"),
                               cmdargv1[0], pool->def->source.initiator.iqn);
         goto out;
     }
 
     /* Check again to make sure the interface was created. */
-    if (virStorageBackendIQNFound(conn, pool, ifacename) != IQN_FOUND) {
+    if (virStorageBackendIQNFound(pool, ifacename) != IQN_FOUND) {
         VIR_DEBUG("Failed to find interface '%s' with IQN '%s' "
                   "after attempting to create it",
                   &temp_ifacename[0], pool->def->source.initiator.iqn);
@@ -323,20 +318,19 @@ out:
 
 
 static int
-virStorageBackendISCSIConnectionIQN(virConnectPtr conn,
-                                    virStoragePoolObjPtr pool,
+virStorageBackendISCSIConnectionIQN(virStoragePoolObjPtr pool,
                                     const char *portal,
                                     const char *action)
 {
     int ret = -1;
     char *ifacename = NULL;
 
-    switch (virStorageBackendIQNFound(conn, pool, &ifacename)) {
+    switch (virStorageBackendIQNFound(pool, &ifacename)) {
     case IQN_FOUND:
         VIR_DEBUG("ifacename: '%s'", ifacename);
         break;
     case IQN_MISSING:
-        if (virStorageBackendCreateIfaceIQN(conn, pool, &ifacename) != 0) {
+        if (virStorageBackendCreateIfaceIQN(pool, &ifacename) != 0) {
             goto out;
         }
         break;
@@ -349,7 +343,7 @@ virStorageBackendISCSIConnectionIQN(virConnectPtr conn,
         ISCSIADM, "--mode", "discovery", "--type", "sendtargets", "--portal", portal, NULL
     };
     if (virRun(sendtargets, NULL) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to run %s to get target list"),
                               sendtargets[0]);
         goto out;
@@ -362,7 +356,7 @@ virStorageBackendISCSIConnectionIQN(virConnectPtr conn,
     };
 
     if (virRun(cmdargv, NULL) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to run command '%s' with action '%s'"),
                               cmdargv[0], action);
         goto out;
@@ -377,8 +371,7 @@ out:
 
 
 static int
-virStorageBackendISCSIConnection(virConnectPtr conn,
-                                 virStoragePoolObjPtr pool,
+virStorageBackendISCSIConnection(virStoragePoolObjPtr pool,
                                  const char *portal,
                                  const char *action)
 {
@@ -386,7 +379,7 @@ virStorageBackendISCSIConnection(virConnectPtr conn,
 
     if (pool->def->source.initiator.iqn != NULL) {
 
-        ret = virStorageBackendISCSIConnectionIQN(conn, pool, portal, action);
+        ret = virStorageBackendISCSIConnectionIQN(pool, portal, action);
 
     } else {
 
@@ -406,8 +399,7 @@ virStorageBackendISCSIConnection(virConnectPtr conn,
 
 
 static int
-virStorageBackendISCSIFindLUs(virConnectPtr conn,
-                              virStoragePoolObjPtr pool,
+virStorageBackendISCSIFindLUs(virStoragePoolObjPtr pool,
                               const char *session)
 {
     char sysfs_path[PATH_MAX];
@@ -425,7 +417,7 @@ virStorageBackendISCSIFindLUs(virConnectPtr conn,
         retval = -1;
     }
 
-    if (virStorageBackendSCSIFindLUs(conn, pool, host) < 0) {
+    if (virStorageBackendSCSIFindLUs(pool, host) < 0) {
         virReportSystemError(errno,
                              _("Failed to find LUs on host %u"), host);
         retval = -1;
@@ -435,8 +427,7 @@ virStorageBackendISCSIFindLUs(virConnectPtr conn,
 }
 
 static int
-virStorageBackendISCSIRescanLUNs(virConnectPtr conn ATTRIBUTE_UNUSED,
-                                 virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
+virStorageBackendISCSIRescanLUNs(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
                                  const char *session)
 {
     const char *const cmdargv[] = {
@@ -451,8 +442,7 @@ virStorageBackendISCSIRescanLUNs(virConnectPtr conn ATTRIBUTE_UNUSED,
 
 
 static int
-virStorageBackendISCSILogin(virConnectPtr conn,
-                            virStoragePoolObjPtr pool,
+virStorageBackendISCSILogin(virStoragePoolObjPtr pool,
                             const char *portal)
 {
     const char *const cmdsendtarget[] = {
@@ -463,26 +453,23 @@ virStorageBackendISCSILogin(virConnectPtr conn,
     if (virRun(cmdsendtarget, NULL) < 0)
         return -1;
 
-    return virStorageBackendISCSIConnection(conn, pool, portal, "--login");
+    return virStorageBackendISCSIConnection(pool, portal, "--login");
 }
 
 static int
-virStorageBackendISCSILogout(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
+virStorageBackendISCSILogout(virStoragePoolObjPtr pool,
                              const char *portal)
 {
-    return virStorageBackendISCSIConnection(conn, pool, portal, "--logout");
+    return virStorageBackendISCSIConnection(pool, portal, "--logout");
 }
 
 static char *
-virStorageBackendISCSIPortal(virConnectPtr conn,
-                             virStoragePoolObjPtr pool)
+virStorageBackendISCSIPortal(virStoragePoolObjPtr pool)
 {
     char ipaddr[NI_MAXHOST];
     char *portal;
 
-    if (virStorageBackendISCSITargetIP(conn,
-                                       pool->def->source.host.name,
+    if (virStorageBackendISCSITargetIP(pool->def->source.host.name,
                                        ipaddr, sizeof(ipaddr)) < 0)
         return NULL;
 
@@ -499,29 +486,29 @@ virStorageBackendISCSIPortal(virConnectPtr conn,
 
 
 static int
-virStorageBackendISCSIStartPool(virConnectPtr conn,
+virStorageBackendISCSIStartPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                 virStoragePoolObjPtr pool)
 {
     char *portal = NULL;
     char *session;
 
     if (pool->def->source.host.name == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("missing source host"));
         return -1;
     }
 
     if (pool->def->source.ndevice != 1 ||
         pool->def->source.devices[0].path == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("missing source device"));
         return -1;
     }
 
-    if ((session = virStorageBackendISCSISession(conn, pool, 1)) == NULL) {
-        if ((portal = virStorageBackendISCSIPortal(conn, pool)) == NULL)
+    if ((session = virStorageBackendISCSISession(pool, 1)) == NULL) {
+        if ((portal = virStorageBackendISCSIPortal(pool)) == NULL)
             return -1;
-        if (virStorageBackendISCSILogin(conn, pool, portal) < 0) {
+        if (virStorageBackendISCSILogin(pool, portal) < 0) {
             VIR_FREE(portal);
             return -1;
         }
@@ -533,18 +520,18 @@ virStorageBackendISCSIStartPool(virConnectPtr conn,
 }
 
 static int
-virStorageBackendISCSIRefreshPool(virConnectPtr conn,
+virStorageBackendISCSIRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                   virStoragePoolObjPtr pool)
 {
     char *session = NULL;
 
     pool->def->allocation = pool->def->capacity = pool->def->available = 0;
 
-    if ((session = virStorageBackendISCSISession(conn, pool, 0)) == NULL)
+    if ((session = virStorageBackendISCSISession(pool, 0)) == NULL)
         goto cleanup;
-    if (virStorageBackendISCSIRescanLUNs(conn, pool, session) < 0)
+    if (virStorageBackendISCSIRescanLUNs(pool, session) < 0)
         goto cleanup;
-    if (virStorageBackendISCSIFindLUs(conn, pool, session) < 0)
+    if (virStorageBackendISCSIFindLUs(pool, session) < 0)
         goto cleanup;
     VIR_FREE(session);
 
@@ -557,15 +544,15 @@ virStorageBackendISCSIRefreshPool(virConnectPtr conn,
 
 
 static int
-virStorageBackendISCSIStopPool(virConnectPtr conn,
+virStorageBackendISCSIStopPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                virStoragePoolObjPtr pool)
 {
     char *portal;
 
-    if ((portal = virStorageBackendISCSIPortal(conn, pool)) == NULL)
+    if ((portal = virStorageBackendISCSIPortal(pool)) == NULL)
         return -1;
 
-    if (virStorageBackendISCSILogout(conn, pool, portal) < 0) {
+    if (virStorageBackendISCSILogout(pool, portal) < 0) {
         VIR_FREE(portal);
         return -1;
     }

src/storage/storage_backend_logical.c

@@ -62,8 +62,7 @@ virStorageBackendLogicalSetActive(virStoragePoolObjPtr pool,
 
 
 static int
-virStorageBackendLogicalMakeVol(virConnectPtr conn,
-                                virStoragePoolObjPtr pool,
+virStorageBackendLogicalMakeVol(virStoragePoolObjPtr pool,
                                 char **const groups,
                                 void *data)
 {
@@ -149,17 +148,17 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
     }
 
     if (virStrToLong_ull(groups[4], NULL, 10, &offset) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("malformed volume extent offset value"));
         return -1;
     }
     if (virStrToLong_ull(groups[5], NULL, 10, &length) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("malformed volume extent length value"));
         return -1;
     }
     if (virStrToLong_ull(groups[6], NULL, 10, &size) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("malformed volume extent size value"));
         return -1;
     }
@@ -172,8 +171,7 @@ virStorageBackendLogicalMakeVol(virConnectPtr conn,
 }
 
 static int
-virStorageBackendLogicalFindLVs(virConnectPtr conn,
-                                virStoragePoolObjPtr pool,
+virStorageBackendLogicalFindLVs(virStoragePoolObjPtr pool,
                                 virStorageVolDefPtr vol)
 {
     /*
@@ -208,8 +206,7 @@ virStorageBackendLogicalFindLVs(virConnectPtr conn,
 
     int exitstatus;
 
-    if (virStorageBackendRunProgRegex(conn,
-                                      pool,
+    if (virStorageBackendRunProgRegex(pool,
                                       prog,
                                       1,
                                       regexes,
@@ -217,13 +214,13 @@ virStorageBackendLogicalFindLVs(virConnectPtr conn,
                                       virStorageBackendLogicalMakeVol,
                                       vol,
                                       &exitstatus) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("lvs command failed"));
                               return -1;
     }
 
     if (exitstatus != 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("lvs command failed with exitstatus %d"),
                               exitstatus);
         return -1;
@@ -233,8 +230,7 @@ virStorageBackendLogicalFindLVs(virConnectPtr conn,
 }
 
 static int
-virStorageBackendLogicalRefreshPoolFunc(virConnectPtr conn ATTRIBUTE_UNUSED,
-                                        virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
+virStorageBackendLogicalRefreshPoolFunc(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
                                         char **const groups,
                                         void *data ATTRIBUTE_UNUSED)
 {
@@ -249,8 +245,7 @@ virStorageBackendLogicalRefreshPoolFunc(virConnectPtr conn ATTRIBUTE_UNUSED,
 
 
 static int
-virStorageBackendLogicalFindPoolSourcesFunc(virConnectPtr conn,
-                                            virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
+virStorageBackendLogicalFindPoolSourcesFunc(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
                                             char **const groups,
                                             void *data)
 {
@@ -278,8 +273,7 @@ virStorageBackendLogicalFindPoolSourcesFunc(virConnectPtr conn,
     }
 
     if (thisSource == NULL) {
-        if (!(thisSource = virStoragePoolSourceListNewSource(conn,
-                                                             sourceList)))
+        if (!(thisSource = virStoragePoolSourceListNewSource(sourceList)))
             goto err_no_memory;
 
         thisSource->name = vgname;
@@ -309,7 +303,7 @@ virStorageBackendLogicalFindPoolSourcesFunc(virConnectPtr conn,
 }
 
 static char *
-virStorageBackendLogicalFindPoolSources(virConnectPtr conn,
+virStorageBackendLogicalFindPoolSources(virConnectPtr conn ATTRIBUTE_UNUSED,
                                         const char *srcSpec ATTRIBUTE_UNUSED,
                                         unsigned int flags ATTRIBUTE_UNUSED)
 {
@@ -343,14 +337,14 @@ virStorageBackendLogicalFindPoolSources(virConnectPtr conn,
     memset(&sourceList, 0, sizeof(sourceList));
     sourceList.type = VIR_STORAGE_POOL_LOGICAL;
 
-    if (virStorageBackendRunProgRegex(conn, NULL, prog, 1, regexes, vars,
+    if (virStorageBackendRunProgRegex(NULL, prog, 1, regexes, vars,
                                       virStorageBackendLogicalFindPoolSourcesFunc,
                                       &sourceList, &exitstatus) < 0)
         return NULL;
 
-    retval = virStoragePoolSourceListFormat(conn, &sourceList);
+    retval = virStoragePoolSourceListFormat(&sourceList);
     if (retval == NULL) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "%s",
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("failed to get source from sourceList"));
         goto cleanup;
     }
@@ -451,7 +445,7 @@ virStorageBackendLogicalBuildPool(virConnectPtr conn ATTRIBUTE_UNUSED,
 
 
 static int
-virStorageBackendLogicalRefreshPool(virConnectPtr conn,
+virStorageBackendLogicalRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                     virStoragePoolObjPtr pool)
 {
     /*
@@ -478,14 +472,13 @@ virStorageBackendLogicalRefreshPool(virConnectPtr conn,
     virFileWaitForDevices();
 
     /* Get list of all logical volumes */
-    if (virStorageBackendLogicalFindLVs(conn, pool, NULL) < 0) {
+    if (virStorageBackendLogicalFindLVs(pool, NULL) < 0) {
         virStoragePoolObjClearVols(pool);
         return -1;
     }
 
     /* Now get basic volgrp metadata */
-    if (virStorageBackendRunProgRegex(conn,
-                                      pool,
+    if (virStorageBackendRunProgRegex(pool,
                                       prog,
                                       1,
                                       regexes,
@@ -579,7 +572,7 @@ virStorageBackendLogicalCreateVol(virConnectPtr conn,
     const char **cmdargv = cmdargvnew;
 
     if (vol->target.encryption != NULL) {
-        virStorageReportError(conn, VIR_ERR_NO_SUPPORT,
+        virStorageReportError(VIR_ERR_NO_SUPPORT,
                               "%s", _("storage pool does not support encrypted "
                                       "volumes"));
         return -1;
@@ -641,7 +634,7 @@ virStorageBackendLogicalCreateVol(virConnectPtr conn,
     fd = -1;
 
     /* Fill in data about this new vol */
-    if (virStorageBackendLogicalFindLVs(conn, pool, vol) < 0) {
+    if (virStorageBackendLogicalFindLVs(pool, vol) < 0) {
         virReportSystemError(errno,
                              _("cannot find newly created volume '%s'"),
                              vol->target.path);
@@ -666,7 +659,7 @@ virStorageBackendLogicalBuildVolFrom(virConnectPtr conn,
 {
     virStorageBackendBuildVolFrom build_func;
 
-    build_func = virStorageBackendGetBuildVolFromFunction(conn, vol, inputvol);
+    build_func = virStorageBackendGetBuildVolFromFunction(vol, inputvol);
     if (!build_func)
         return -1;
 

src/storage/storage_backend_mpath.c

@@ -39,8 +39,7 @@
 #define VIR_FROM_THIS VIR_FROM_STORAGE
 
 static int
-virStorageBackendMpathUpdateVolTargetInfo(virConnectPtr conn,
-                                          virStorageVolTargetPtr target,
+virStorageBackendMpathUpdateVolTargetInfo(virStorageVolTargetPtr target,
                                           unsigned long long *allocation,
                                           unsigned long long *capacity)
 {
@@ -60,7 +59,7 @@ virStorageBackendMpathUpdateVolTargetInfo(virConnectPtr conn,
                                                allocation,
                                                capacity) < 0) {
 
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to update volume target info for '%s'"),
                           target->path);
 
@@ -69,7 +68,7 @@ virStorageBackendMpathUpdateVolTargetInfo(virConnectPtr conn,
     }
 
     if (virStorageBackendUpdateVolTargetFormatFD(target, fd) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to update volume target format for '%s'"),
                           target->path);
 
@@ -86,8 +85,7 @@ out:
 
 
 static int
-virStorageBackendMpathNewVol(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
+virStorageBackendMpathNewVol(virStoragePoolObjPtr pool,
                              const int devnum,
                              const char *dev)
 {
@@ -111,12 +109,11 @@ virStorageBackendMpathNewVol(virConnectPtr conn,
         goto cleanup;
     }
 
-    if (virStorageBackendMpathUpdateVolTargetInfo(conn,
-                                                  &vol->target,
+    if (virStorageBackendMpathUpdateVolTargetInfo(&vol->target,
                                                   &vol->allocation,
                                                   &vol->capacity) < 0) {
 
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to update volume for '%s'"),
                               vol->target.path);
         goto cleanup;
@@ -231,8 +228,7 @@ out:
 
 
 static int
-virStorageBackendCreateVols(virConnectPtr conn,
-                            virStoragePoolObjPtr pool,
+virStorageBackendCreateVols(virStoragePoolObjPtr pool,
                             struct dm_names *names)
 {
     int retval = 0, is_mpath = 0;
@@ -260,8 +256,7 @@ virStorageBackendCreateVols(virConnectPtr conn,
                 goto out;
             }
 
-            virStorageBackendMpathNewVol(conn,
-                                         pool,
+            virStorageBackendMpathNewVol(pool,
                                          minor,
                                          map_device);
 
@@ -280,8 +275,7 @@ out:
 
 
 static int
-virStorageBackendGetMaps(virConnectPtr conn,
-                         virStoragePoolObjPtr pool)
+virStorageBackendGetMaps(virStoragePoolObjPtr pool)
 {
     int retval = 0;
     struct dm_task *dmt = NULL;
@@ -309,7 +303,7 @@ virStorageBackendGetMaps(virConnectPtr conn,
         goto out;
     }
 
-    virStorageBackendCreateVols(conn, pool, names);
+    virStorageBackendCreateVols(pool, names);
 
 out:
     if (dmt != NULL) {
@@ -320,7 +314,7 @@ out:
 
 
 static int
-virStorageBackendMpathRefreshPool(virConnectPtr conn,
+virStorageBackendMpathRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                   virStoragePoolObjPtr pool)
 {
     int retval = 0;
@@ -331,7 +325,7 @@ virStorageBackendMpathRefreshPool(virConnectPtr conn,
 
     virFileWaitForDevices();
 
-    virStorageBackendGetMaps(conn, pool);
+    virStorageBackendGetMaps(pool);
 
     return retval;
 }

src/storage/storage_backend_scsi.c

@@ -40,8 +40,7 @@
  * the device otherwise.
  */
 static int
-getDeviceType(virConnectPtr conn,
-              uint32_t host,
+getDeviceType(uint32_t host,
               uint32_t bus,
               uint32_t target,
               uint32_t lun,
@@ -85,7 +84,7 @@ getDeviceType(virConnectPtr conn,
      * character is not \0, virStrToLong_i complains
      */
     if (virStrToLong_i(typestr, &p, 10, type) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Device type '%s' is not an integer"),
                               typestr);
         /* Hm, type wasn't an integer; seems strange */
@@ -191,8 +190,7 @@ virStorageBackendSCSIUpdateVolTargetInfo(virStorageVolTargetPtr target,
 }
 
 static int
-virStorageBackendSCSINewLun(virConnectPtr conn,
-                            virStoragePoolObjPtr pool,
+virStorageBackendSCSINewLun(virStoragePoolObjPtr pool,
                             uint32_t host,
                             uint32_t bus,
                             uint32_t target,
@@ -252,7 +250,7 @@ virStorageBackendSCSINewLun(virConnectPtr conn,
                                                  &vol->allocation,
                                                  &vol->capacity) < 0) {
 
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to update volume for '%s'"),
                               devpath);
         retval = -1;
@@ -289,8 +287,7 @@ out:
 
 
 static int
-getNewStyleBlockDevice(virConnectPtr conn ATTRIBUTE_UNUSED /*TEMPORARY*/,
-                       const char *lun_path,
+getNewStyleBlockDevice(const char *lun_path,
                        const char *block_name ATTRIBUTE_UNUSED,
                        char **block_device)
 {
@@ -344,8 +341,7 @@ out:
 
 
 static int
-getOldStyleBlockDevice(virConnectPtr conn,
-                       const char *lun_path ATTRIBUTE_UNUSED,
+getOldStyleBlockDevice(const char *lun_path ATTRIBUTE_UNUSED,
                        const char *block_name,
                        char **block_device)
 {
@@ -356,7 +352,7 @@ getOldStyleBlockDevice(virConnectPtr conn,
     blockp = strrchr(block_name, ':');
     if (blockp == NULL) {
         /* Hm, wasn't what we were expecting; have to give up */
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to parse block name %s"),
                               block_name);
         retval = -1;
@@ -379,8 +375,7 @@ out:
 
 
 static int
-getBlockDevice(virConnectPtr conn,
-               uint32_t host,
+getBlockDevice(uint32_t host,
                uint32_t bus,
                uint32_t target,
                uint32_t lun,
@@ -409,13 +404,11 @@ getBlockDevice(virConnectPtr conn,
     while ((lun_dirent = readdir(lun_dir))) {
         if (STREQLEN(lun_dirent->d_name, "block", 5)) {
             if (strlen(lun_dirent->d_name) == 5) {
-                retval = getNewStyleBlockDevice(conn,
-                                                lun_path,
+                retval = getNewStyleBlockDevice(lun_path,
                                                 lun_dirent->d_name,
                                                 block_device);
             } else {
-                retval = getOldStyleBlockDevice(conn,
-                                                lun_path,
+                retval = getOldStyleBlockDevice(lun_path,
                                                 lun_dirent->d_name,
                                                 block_device);
             }
@@ -432,8 +425,7 @@ out:
 
 
 static int
-processLU(virConnectPtr conn,
-          virStoragePoolObjPtr pool,
+processLU(virStoragePoolObjPtr pool,
           uint32_t host,
           uint32_t bus,
           uint32_t target,
@@ -447,8 +439,8 @@ processLU(virConnectPtr conn,
     VIR_DEBUG(_("Processing LU %u:%u:%u:%u"),
               host, bus, target, lun);
 
-    if (getDeviceType(conn, host, bus, target, lun, &device_type) < 0) {
-        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
+    if (getDeviceType(host, bus, target, lun, &device_type) < 0) {
+        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to determine if %u:%u:%u:%u is a Direct-Access LUN"),
                               host, bus, target, lun);
         retval = -1;
@@ -468,11 +460,11 @@ processLU(virConnectPtr conn,
     VIR_DEBUG(_("%u:%u:%u:%u is a Direct-Access LUN"),
               host, bus, target, lun);
 
-    if (getBlockDevice(conn, host, bus, target, lun, &block_device) < 0) {
+    if (getBlockDevice(host, bus, target, lun, &block_device) < 0) {
         goto out;
     }
 
-    if (virStorageBackendSCSINewLun(conn, pool,
+    if (virStorageBackendSCSINewLun(pool,
                                     host, bus, target, lun,
                                     block_device) < 0) {
         VIR_DEBUG(_("Failed to create new storage volume for %u:%u:%u:%u"),
@@ -492,8 +484,7 @@ out:
 
 
 int
-virStorageBackendSCSIFindLUs(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
+virStorageBackendSCSIFindLUs(virStoragePoolObjPtr pool,
                              uint32_t scanhost)
 {
     int retval = 0;
@@ -531,7 +522,7 @@ virStorageBackendSCSIFindLUs(virConnectPtr conn,
 
         VIR_DEBUG(_("Found LU '%s'"), lun_dirent->d_name);
 
-        processLU(conn, pool, scanhost, bus, target, lun);
+        processLU(pool, scanhost, bus, target, lun);
     }
 
     closedir(devicedir);
@@ -627,7 +618,7 @@ out:
 
 
 static int
-virStorageBackendSCSIRefreshPool(virConnectPtr conn,
+virStorageBackendSCSIRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                  virStoragePoolObjPtr pool)
 {
     int retval = 0;
@@ -649,7 +640,7 @@ virStorageBackendSCSIRefreshPool(virConnectPtr conn,
         goto out;
     }
 
-    virStorageBackendSCSIFindLUs(conn, pool, host);
+    virStorageBackendSCSIFindLUs(pool, host);
 
 out:
     return retval;

src/storage/storage_backend_scsi.h

@@ -36,8 +36,7 @@ int
 virStorageBackendSCSIGetHostNumber(const char *sysfs_path,
                                    uint32_t *host);
 int
-virStorageBackendSCSIFindLUs(virConnectPtr conn,
-                             virStoragePoolObjPtr pool,
+virStorageBackendSCSIFindLUs(virStoragePoolObjPtr pool,
                              uint32_t scanhost);
 
 #endif /* __VIR_STORAGE_BACKEND_SCSI_H__ */

src/test/test_driver.c

@@ -577,10 +577,10 @@ static int testOpenDefault(virConnectPtr conn) {
     interfaceobj->active = 1;
     virInterfaceObjUnlock(interfaceobj);
 
-    if (!(pooldef = virStoragePoolDefParseString(conn, defaultPoolXML)))
+    if (!(pooldef = virStoragePoolDefParseString(defaultPoolXML)))
         goto error;
 
-    if (!(poolobj = virStoragePoolObjAssignDef(conn, &privconn->pools,
+    if (!(poolobj = virStoragePoolObjAssignDef(&privconn->pools,
                                                pooldef))) {
         virStoragePoolDefFree(pooldef);
         goto error;
@@ -648,8 +648,7 @@ static char *testBuildFilename(const char *relativeTo,
     }
 }
 
-static int testOpenVolumesForPool(virConnectPtr conn,
-                                  xmlDocPtr xml,
+static int testOpenVolumesForPool(xmlDocPtr xml,
                                   xmlXPathContextPtr ctxt,
                                   const char *file,
                                   virStoragePoolObjPtr pool,
@@ -684,12 +683,12 @@ static int testOpenVolumesForPool(virConnectPtr conn,
                 goto error;
             }
 
-            def = virStorageVolDefParseFile(conn, pool->def, absFile);
+            def = virStorageVolDefParseFile(pool->def, absFile);
             VIR_FREE(absFile);
             if (!def)
                 goto error;
         } else {
-            if ((def = virStorageVolDefParseNode(conn, pool->def, xml,
+            if ((def = virStorageVolDefParseNode(pool->def, xml,
                                                  vols[i])) == NULL) {
                 goto error;
             }
@@ -1008,18 +1007,18 @@ static int testOpenFromFile(virConnectPtr conn,
                 goto error;
             }
 
-            def = virStoragePoolDefParseFile(conn, absFile);
+            def = virStoragePoolDefParseFile(absFile);
             VIR_FREE(absFile);
             if (!def)
                 goto error;
         } else {
-            if ((def = virStoragePoolDefParseNode(conn, xml,
+            if ((def = virStoragePoolDefParseNode(xml,
                                                   pools[i])) == NULL) {
                 goto error;
             }
         }
 
-        if (!(pool = virStoragePoolObjAssignDef(conn, &privconn->pools,
+        if (!(pool = virStoragePoolObjAssignDef(&privconn->pools,
                                                 def))) {
             virStoragePoolDefFree(def);
             goto error;
@@ -1032,7 +1031,7 @@ static int testOpenFromFile(virConnectPtr conn,
         pool->active = 1;
 
         /* Find storage volumes */
-        if (testOpenVolumesForPool(conn, xml, ctxt, file, pool, i+1) < 0) {
+        if (testOpenVolumesForPool(xml, ctxt, file, pool, i+1) < 0) {
             virStoragePoolObjUnlock(pool);
             goto error;
         }
@@ -3727,7 +3726,7 @@ testStorageFindPoolSources(virConnectPtr conn,
     }
 
     if (srcSpec) {
-        source = virStoragePoolDefParseSourceString(conn, srcSpec, pool_type);
+        source = virStoragePoolDefParseSourceString(srcSpec, pool_type);
         if (!source)
             goto cleanup;
     }
@@ -3773,7 +3772,7 @@ testStoragePoolCreate(virConnectPtr conn,
     virStoragePoolPtr ret = NULL;
 
     testDriverLock(privconn);
-    if (!(def = virStoragePoolDefParseString(conn, xml)))
+    if (!(def = virStoragePoolDefParseString(xml)))
         goto cleanup;
 
     pool = virStoragePoolObjFindByUUID(&privconn->pools, def->uuid);
@@ -3785,7 +3784,7 @@ testStoragePoolCreate(virConnectPtr conn,
         goto cleanup;
     }
 
-    if (!(pool = virStoragePoolObjAssignDef(conn, &privconn->pools, def)))
+    if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))
         goto cleanup;
     def = NULL;
 
@@ -3816,14 +3815,14 @@ testStoragePoolDefine(virConnectPtr conn,
     virStoragePoolPtr ret = NULL;
 
     testDriverLock(privconn);
-    if (!(def = virStoragePoolDefParseString(conn, xml)))
+    if (!(def = virStoragePoolDefParseString(xml)))
         goto cleanup;
 
     def->capacity = defaultPoolCap;
     def->allocation = defaultPoolAlloc;
     def->available = defaultPoolCap - defaultPoolAlloc;
 
-    if (!(pool = virStoragePoolObjAssignDef(conn, &privconn->pools, def)))
+    if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))
         goto cleanup;
     def = NULL;
 
@@ -4055,7 +4054,7 @@ testStoragePoolDumpXML(virStoragePoolPtr pool,
         goto cleanup;
     }
 
-    ret = virStoragePoolDefFormat(pool->conn, privpool->def);
+    ret = virStoragePoolDefFormat(privpool->def);
 
 cleanup:
     if (privpool)
@@ -4341,7 +4340,7 @@ testStorageVolumeCreateXML(virStoragePoolPtr pool,
         goto cleanup;
     }
 
-    privvol = virStorageVolDefParseString(pool->conn, privpool->def, xmldesc);
+    privvol = virStorageVolDefParseString(privpool->def, xmldesc);
     if (privvol == NULL)
         goto cleanup;
 
@@ -4422,7 +4421,7 @@ testStorageVolumeCreateXMLFrom(virStoragePoolPtr pool,
         goto cleanup;
     }
 
-    privvol = virStorageVolDefParseString(pool->conn, privpool->def, xmldesc);
+    privvol = virStorageVolDefParseString(privpool->def, xmldesc);
     if (privvol == NULL)
         goto cleanup;
 
@@ -4645,7 +4644,7 @@ testStorageVolumeGetXMLDesc(virStorageVolPtr vol,
         goto cleanup;
     }
 
-    ret = virStorageVolDefFormat(vol->conn, privpool->def, privvol);
+    ret = virStorageVolDefFormat(privpool->def, privvol);
 
 cleanup:
     if (privpool)

src/vbox/vbox_tmpl.c

@@ -6578,7 +6578,7 @@ static virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool,
     memset(&poolDef, 0, sizeof(poolDef));
     poolDef.type = VIR_STORAGE_POOL_DIR;
 
-    if ((def = virStorageVolDefParseString(pool->conn, &poolDef, xml)) == NULL)
+    if ((def = virStorageVolDefParseString(&poolDef, xml)) == NULL)
         goto cleanup;
 
     if (   !def->name
@@ -6922,7 +6922,7 @@ static char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags A
     vboxIIDUtf16Free(hddIID);
 
     if (defOk)
-        ret = virStorageVolDefFormat(vol->conn, &pool, &def);
+        ret = virStorageVolDefFormat(&pool, &def);
 
     return ret;
 }

tests/storagepoolxml2xmltest.c

@@ -33,10 +33,10 @@ static int testCompareXMLToXMLFiles(const char *inxml, const char *outxml) {
     if (virtTestLoadFile(outxml, &outXmlPtr, MAX_FILE) < 0)
         goto fail;
 
-    if (!(dev = virStoragePoolDefParseString(NULL, inXmlData)))
+    if (!(dev = virStoragePoolDefParseString(inXmlData)))
         goto fail;
 
-    if (!(actual = virStoragePoolDefFormat(NULL, dev)))
+    if (!(actual = virStoragePoolDefFormat(dev)))
         goto fail;
 
     if (STRNEQ(outXmlData, actual)) {

tests/storagevolxml2xmltest.c

@@ -40,13 +40,13 @@ static int testCompareXMLToXMLFiles(const char *poolxml,
     if (virtTestLoadFile(outxml, &outXmlPtr, MAX_FILE) < 0)
         goto fail;
 
-    if (!(pool = virStoragePoolDefParseString(NULL, poolXmlData)))
+    if (!(pool = virStoragePoolDefParseString(poolXmlData)))
         goto fail;
 
-    if (!(dev = virStorageVolDefParseString(NULL, pool, inXmlData)))
+    if (!(dev = virStorageVolDefParseString(pool, inXmlData)))
         goto fail;
 
-    if (!(actual = virStorageVolDefFormat(NULL, pool, dev)))
+    if (!(actual = virStorageVolDefFormat(pool, dev)))
         goto fail;
 
     if (STRNEQ(outXmlData, actual)) {