← Back to branch summary

~ubuntu-branches/ubuntu/maverick/libvirt/maverick

« back to all changes in this revision

Viewing changes to src/storage_driver.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2009-02-11 01:01:42 UTC
  • mto: (3.4.1 sid) (1.2.1 upstream) (0.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20090211010142-wk9mgtbw8bmp3zcb
Tags: upstream-0.6.0
Import upstream version 0.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/storage_driver.c
41
41
#include "memory.h"
42
42
#include "storage_backend.h"
43
43
 
 
44
#define VIR_FROM_THIS VIR_FROM_STORAGE
 
45
 
44
46
#define storageLog(msg...) fprintf(stderr, msg)
45
47
 
46
48
static virStorageDriverStatePtr driverState;
47
49
 
48
50
static int storageDriverShutdown(void);
49
51
 
 
52
static void storageDriverLock(virStorageDriverStatePtr driver)
 
53
{
 
54
    virMutexLock(&driver->lock);
 
55
}
 
56
static void storageDriverUnlock(virStorageDriverStatePtr driver)
 
57
{
 
58
    virMutexUnlock(&driver->lock);
 
59
}
50
60
 
51
61
static void
52
62
storageDriverAutostart(virStorageDriverStatePtr driver) {
55
65
    for (i = 0 ; i < driver->pools.count ; i++) {
56
66
        virStoragePoolObjPtr pool = driver->pools.objs[i];
57
67
 
 
68
        virStoragePoolObjLock(pool);
58
69
        if (pool->autostart &&
59
70
            !virStoragePoolObjIsActive(pool)) {
60
71
            virStorageBackendPtr backend;
61
72
            if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
62
73
                storageLog("Missing backend %d",
63
74
                           pool->def->type);
 
75
                virStoragePoolObjUnlock(pool);
64
76
                continue;
65
77
            }
66
78
 
69
81
                virErrorPtr err = virGetLastError();
70
82
                storageLog("Failed to autostart storage pool '%s': %s",
71
83
                           pool->def->name, err ? err->message : NULL);
 
84
                virStoragePoolObjUnlock(pool);
72
85
                continue;
73
86
            }
74
87
 
78
91
                    backend->stopPool(NULL, pool);
79
92
                storageLog("Failed to autostart storage pool '%s': %s",
80
93
                           pool->def->name, err ? err->message : NULL);
 
94
                virStoragePoolObjUnlock(pool);
81
95
                continue;
82
96
            }
83
97
            pool->active = 1;
84
98
        }
 
99
        virStoragePoolObjUnlock(pool);
85
100
    }
86
101
}
87
102
 
93
108
static int
94
109
storageDriverStartup(void) {
95
110
    uid_t uid = geteuid();
96
 
    struct passwd *pw;
97
111
    char *base = NULL;
98
112
    char driverConf[PATH_MAX];
99
113
 
100
114
    if (VIR_ALLOC(driverState) < 0)
101
115
        return -1;
102
116
 
 
117
    if (virMutexInit(&driverState->lock) < 0) {
 
118
        VIR_FREE(driverState);
 
119
        return -1;
 
120
    }
 
121
    storageDriverLock(driverState);
 
122
 
103
123
    if (!uid) {
104
124
        if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
105
125
            goto out_of_memory;
106
126
    } else {
107
 
        if (!(pw = getpwuid(uid))) {
108
 
            storageLog("Failed to find user record for uid '%d': %s",
109
 
                       uid, strerror(errno));
110
 
            goto out_of_memory;
111
 
        }
112
 
 
113
 
        if (asprintf (&base, "%s/.libvirt", pw->pw_dir) == -1) {
114
 
            storageLog("out of memory in asprintf");
115
 
            goto out_of_memory;
116
 
        }
 
127
        char *userdir = virGetUserDirectory(NULL, uid);
 
128
 
 
129
        if (!userdir)
 
130
            goto error;
 
131
 
 
132
        if (virAsprintf(&base, "%s/.libvirt", userdir) == -1) {
 
133
            storageLog("out of memory in virAsprintf");
 
134
            VIR_FREE(userdir);
 
135
            goto out_of_memory;
 
136
        }
 
137
        VIR_FREE(userdir);
117
138
    }
118
139
 
119
140
    /* Configuration paths are either ~/.libvirt/storage/... (session) or
124
145
        goto out_of_memory;
125
146
    driverConf[sizeof(driverConf)-1] = '\0';
126
147
 
127
 
    if (asprintf (&driverState->configDir,
128
 
                  "%s/storage", base) == -1)
129
 
        goto out_of_memory;
130
 
 
131
 
    if (asprintf (&driverState->autostartDir,
132
 
                  "%s/storage/autostart", base) == -1)
133
 
        goto out_of_memory;
134
 
 
135
 
    free(base);
136
 
    base = NULL;
 
148
    if (virAsprintf(&driverState->configDir,
 
149
                    "%s/storage", base) == -1)
 
150
        goto out_of_memory;
 
151
 
 
152
    if (virAsprintf(&driverState->autostartDir,
 
153
                    "%s/storage/autostart", base) == -1)
 
154
        goto out_of_memory;
 
155
 
 
156
    VIR_FREE(base);
137
157
 
138
158
    /*
139
159
    if (virStorageLoadDriverConfig(driver, driverConf) < 0) {
145
165
    if (virStoragePoolLoadAllConfigs(NULL,
146
166
                                     &driverState->pools,
147
167
                                     driverState->configDir,
148
 
                                     driverState->autostartDir) < 0) {
149
 
        storageDriverShutdown();
150
 
        return -1;
151
 
    }
 
168
                                     driverState->autostartDir) < 0)
 
169
        goto error;
152
170
    storageDriverAutostart(driverState);
153
171
 
 
172
    storageDriverUnlock(driverState);
154
173
    return 0;
155
174
 
156
 
 out_of_memory:
 
175
out_of_memory:
157
176
    storageLog("virStorageStartup: out of memory");
158
 
    free(base);
159
 
    free(driverState);
160
 
    driverState = NULL;
 
177
error:
 
178
    VIR_FREE(base);
 
179
    storageDriverUnlock(driverState);
 
180
    storageDriverShutdown();
161
181
    return -1;
162
182
}
163
183
 
172
192
    if (!driverState)
173
193
        return -1;
174
194
 
 
195
    storageDriverLock(driverState);
175
196
    virStoragePoolLoadAllConfigs(NULL,
176
197
                                 &driverState->pools,
177
198
                                 driverState->configDir,
178
199
                                 driverState->autostartDir);
179
200
    storageDriverAutostart(driverState);
 
201
    storageDriverUnlock(driverState);
180
202
 
181
203
    return 0;
182
204
}
191
213
static int
192
214
storageDriverActive(void) {
193
215
    unsigned int i;
 
216
    int active = 0;
194
217
 
195
218
    if (!driverState)
196
219
        return 0;
197
220
 
198
 
    /* If we've any active networks or guests, then we
199
 
     * mark this driver as active
200
 
     */
201
 
    for (i = 0 ; i < driverState->pools.count ; i++)
 
221
    storageDriverLock(driverState);
 
222
 
 
223
    for (i = 0 ; i < driverState->pools.count ; i++) {
 
224
        virStoragePoolObjLock(driverState->pools.objs[i]);
202
225
        if (virStoragePoolObjIsActive(driverState->pools.objs[i]))
203
 
            return 1;
 
226
            active = 1;
 
227
        virStoragePoolObjUnlock(driverState->pools.objs[i]);
 
228
    }
204
229
 
205
 
    /* Otherwise we're happy to deal with a shutdown */
206
 
    return 0;
 
230
    storageDriverUnlock(driverState);
 
231
    return active;
207
232
}
208
233
 
209
234
/**
213
238
 */
214
239
static int
215
240
storageDriverShutdown(void) {
216
 
    unsigned int i;
217
 
 
218
241
    if (!driverState)
219
242
        return -1;
220
243
 
221
 
    /* shutdown active pools */
222
 
    for (i = 0 ; i < driverState->pools.count ; i++) {
223
 
        virStoragePoolObjPtr pool = driverState->pools.objs[i];
224
 
 
225
 
        if (virStoragePoolObjIsActive(pool)) {
226
 
            virStorageBackendPtr backend;
227
 
            if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
228
 
                storageLog("Missing backend");
229
 
                continue;
230
 
            }
231
 
 
232
 
            if (backend->stopPool &&
233
 
                backend->stopPool(NULL, pool) < 0) {
234
 
                virErrorPtr err = virGetLastError();
235
 
                storageLog("Failed to stop storage pool '%s': %s",
236
 
                           pool->def->name, err ? err->message : NULL);
237
 
            }
238
 
            virStoragePoolObjClearVols(pool);
239
 
        }
240
 
    }
 
244
    storageDriverLock(driverState);
241
245
 
242
246
    /* free inactive pools */
243
247
    virStoragePoolObjListFree(&driverState->pools);
244
248
 
245
249
    VIR_FREE(driverState->configDir);
246
250
    VIR_FREE(driverState->autostartDir);
 
251
    storageDriverUnlock(driverState);
 
252
    virMutexDestroy(&driverState->lock);
247
253
    VIR_FREE(driverState);
248
254
 
249
255
    return 0;
254
260
static virStoragePoolPtr
255
261
storagePoolLookupByUUID(virConnectPtr conn,
256
262
                        const unsigned char *uuid) {
257
 
    virStorageDriverStatePtr driver =
258
 
        (virStorageDriverStatePtr)conn->storagePrivateData;
259
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, uuid);
260
 
    virStoragePoolPtr ret;
 
263
    virStorageDriverStatePtr driver = conn->storagePrivateData;
 
264
    virStoragePoolObjPtr pool;
 
265
    virStoragePoolPtr ret = NULL;
 
266
 
 
267
    storageDriverLock(driver);
 
268
    pool = virStoragePoolObjFindByUUID(&driver->pools, uuid);
 
269
    storageDriverUnlock(driver);
261
270
 
262
271
    if (!pool) {
263
272
        virStorageReportError(conn, VIR_ERR_NO_STORAGE_POOL,
264
273
                              "%s", _("no pool with matching uuid"));
265
 
        return NULL;
 
274
        goto cleanup;
266
275
    }
267
276
 
268
277
    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid);
 
278
 
 
279
cleanup:
 
280
    if (pool)
 
281
        virStoragePoolObjUnlock(pool);
269
282
    return ret;
270
283
}
271
284
 
272
285
static virStoragePoolPtr
273
286
storagePoolLookupByName(virConnectPtr conn,
274
287
                        const char *name) {
275
 
    virStorageDriverStatePtr driver =
276
 
        (virStorageDriverStatePtr)conn->storagePrivateData;
277
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByName(&driver->pools, name);
278
 
    virStoragePoolPtr ret;
 
288
    virStorageDriverStatePtr driver = conn->storagePrivateData;
 
289
    virStoragePoolObjPtr pool;
 
290
    virStoragePoolPtr ret = NULL;
 
291
 
 
292
    storageDriverLock(driver);
 
293
    pool = virStoragePoolObjFindByName(&driver->pools, name);
 
294
    storageDriverUnlock(driver);
279
295
 
280
296
    if (!pool) {
281
297
        virStorageReportError(conn, VIR_ERR_NO_STORAGE_POOL,
282
298
                              "%s", _("no pool with matching name"));
283
 
        return NULL;
 
299
        goto cleanup;
284
300
    }
285
301
 
286
302
    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid);
 
303
 
 
304
cleanup:
 
305
    if (pool)
 
306
        virStoragePoolObjUnlock(pool);
287
307
    return ret;
288
308
}
289
309
 
311
331
 
312
332
static int
313
333
storageNumPools(virConnectPtr conn) {
314
 
    virStorageDriverStatePtr driver
315
 
        = (virStorageDriverStatePtr)conn->storagePrivateData;
 
334
    virStorageDriverStatePtr driver = conn->storagePrivateData;
316
335
    unsigned int i, nactive = 0;
317
336
 
318
 
    for (i = 0 ; i < driver->pools.count ; i++)
 
337
    storageDriverLock(driver);
 
338
    for (i = 0 ; i < driver->pools.count ; i++) {
 
339
        virStoragePoolObjLock(driver->pools.objs[i]);
319
340
        if (virStoragePoolObjIsActive(driver->pools.objs[i]))
320
341
            nactive++;
 
342
        virStoragePoolObjUnlock(driver->pools.objs[i]);
 
343
    }
 
344
    storageDriverUnlock(driver);
321
345
 
322
346
    return nactive;
323
347
}
326
350
storageListPools(virConnectPtr conn,
327
351
                 char **const names,
328
352
                 int nnames) {
329
 
    virStorageDriverStatePtr driver =
330
 
        (virStorageDriverStatePtr)conn->storagePrivateData;
 
353
    virStorageDriverStatePtr driver = conn->storagePrivateData;
331
354
    int got = 0, i;
332
355
 
 
356
    storageDriverLock(driver);
333
357
    for (i = 0 ; i < driver->pools.count && got < nnames ; i++) {
 
358
        virStoragePoolObjLock(driver->pools.objs[i]);
334
359
        if (virStoragePoolObjIsActive(driver->pools.objs[i])) {
335
360
            if (!(names[got] = strdup(driver->pools.objs[i]->def->name))) {
336
 
                virStorageReportError(conn, VIR_ERR_NO_MEMORY,
337
 
                                      "%s", _("names"));
 
361
                virStoragePoolObjUnlock(driver->pools.objs[i]);
 
362
                virReportOOMError(conn);
338
363
                goto cleanup;
339
364
            }
340
365
            got++;
341
366
        }
 
367
        virStoragePoolObjUnlock(driver->pools.objs[i]);
342
368
    }
 
369
    storageDriverUnlock(driver);
343
370
    return got;
344
371
 
345
372
 cleanup:
346
 
    for (i = 0 ; i < got ; i++) {
347
 
        free(names[i]);
348
 
        names[i] = NULL;
349
 
    }
 
373
    storageDriverUnlock(driver);
 
374
    for (i = 0 ; i < got ; i++)
 
375
        VIR_FREE(names[i]);
350
376
    memset(names, 0, nnames * sizeof(*names));
351
377
    return -1;
352
378
}
353
379
 
354
380
static int
355
381
storageNumDefinedPools(virConnectPtr conn) {
356
 
    virStorageDriverStatePtr driver
357
 
        = (virStorageDriverStatePtr)conn->storagePrivateData;
 
382
    virStorageDriverStatePtr driver = conn->storagePrivateData;
358
383
    unsigned int i, nactive = 0;
359
384
 
360
 
    for (i = 0 ; i < driver->pools.count ; i++)
 
385
    storageDriverLock(driver);
 
386
    for (i = 0 ; i < driver->pools.count ; i++) {
 
387
        virStoragePoolObjLock(driver->pools.objs[i]);
361
388
        if (!virStoragePoolObjIsActive(driver->pools.objs[i]))
362
389
            nactive++;
 
390
        virStoragePoolObjUnlock(driver->pools.objs[i]);
 
391
    }
 
392
    storageDriverUnlock(driver);
363
393
 
364
394
    return nactive;
365
395
}
368
398
storageListDefinedPools(virConnectPtr conn,
369
399
                        char **const names,
370
400
                        int nnames) {
371
 
    virStorageDriverStatePtr driver
372
 
        = (virStorageDriverStatePtr)conn->storagePrivateData;
 
401
    virStorageDriverStatePtr driver = conn->storagePrivateData;
373
402
    int got = 0, i;
374
403
 
 
404
    storageDriverLock(driver);
375
405
    for (i = 0 ; i < driver->pools.count && got < nnames ; i++) {
 
406
        virStoragePoolObjLock(driver->pools.objs[i]);
376
407
        if (!virStoragePoolObjIsActive(driver->pools.objs[i])) {
377
408
            if (!(names[got] = strdup(driver->pools.objs[i]->def->name))) {
378
 
                virStorageReportError(conn, VIR_ERR_NO_MEMORY,
379
 
                                      "%s", _("names"));
 
409
                virStoragePoolObjUnlock(driver->pools.objs[i]);
 
410
                virReportOOMError(conn);
380
411
                goto cleanup;
381
412
            }
382
413
            got++;
383
414
        }
 
415
        virStoragePoolObjUnlock(driver->pools.objs[i]);
384
416
    }
 
417
    storageDriverUnlock(driver);
385
418
    return got;
386
419
 
387
420
 cleanup:
 
421
    storageDriverUnlock(driver);
388
422
    for (i = 0 ; i < got ; i++) {
389
423
        free(names[i]);
390
424
        names[i] = NULL;
393
427
    return -1;
394
428
}
395
429
 
 
430
/* This method is required to be re-entrant / thread safe, so
 
431
   uses no driver lock */
396
432
static char *
397
433
storageFindPoolSources(virConnectPtr conn,
398
434
                       const char *type,
401
437
{
402
438
    int backend_type;
403
439
    virStorageBackendPtr backend;
 
440
    char *ret = NULL;
404
441
 
405
442
    backend_type = virStoragePoolTypeFromString(type);
406
443
    if (backend_type < 0)
407
 
        return NULL;
 
444
        goto cleanup;
408
445
 
409
446
    backend = virStorageBackendForType(backend_type);
410
447
    if (backend == NULL)
411
 
        return NULL;
 
448
        goto cleanup;
412
449
 
413
450
    if (backend->findPoolSources)
414
 
        return backend->findPoolSources(conn, srcSpec, flags);
 
451
        ret = backend->findPoolSources(conn, srcSpec, flags);
415
452
 
416
 
    return NULL;
 
453
cleanup:
 
454
    return ret;
417
455
}
418
456
 
419
457
 
421
459
storagePoolCreate(virConnectPtr conn,
422
460
                  const char *xml,
423
461
                  unsigned int flags ATTRIBUTE_UNUSED) {
424
 
    virStorageDriverStatePtr driver =
425
 
        (virStorageDriverStatePtr )conn->storagePrivateData;
 
462
    virStorageDriverStatePtr driver = conn->storagePrivateData;
426
463
    virStoragePoolDefPtr def;
427
 
    virStoragePoolObjPtr pool;
428
 
    virStoragePoolPtr ret;
 
464
    virStoragePoolObjPtr pool = NULL;
 
465
    virStoragePoolPtr ret = NULL;
429
466
    virStorageBackendPtr backend;
430
467
 
 
468
    storageDriverLock(driver);
431
469
    if (!(def = virStoragePoolDefParse(conn, xml, NULL)))
432
 
        return NULL;
433
 
 
434
 
    if (virStoragePoolObjFindByUUID(&driver->pools, def->uuid) ||
435
 
        virStoragePoolObjFindByName(&driver->pools, def->name)) {
 
470
        goto cleanup;
 
471
 
 
472
    pool = virStoragePoolObjFindByUUID(&driver->pools, def->uuid);
 
473
    if (!pool)
 
474
        pool = virStoragePoolObjFindByName(&driver->pools, def->name);
 
475
 
 
476
    if (pool) {
436
477
        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
437
478
                              "%s", _("storage pool already exists"));
438
 
        virStoragePoolDefFree(def);
439
 
        return NULL;
440
 
    }
441
 
 
442
 
    if ((backend = virStorageBackendForType(def->type)) == NULL) {
443
 
        virStoragePoolDefFree(def);
444
 
        return NULL;
445
 
    }
446
 
 
447
 
    if (!(pool = virStoragePoolObjAssignDef(conn, &driver->pools, def))) {
448
 
        virStoragePoolDefFree(def);
449
 
        return NULL;
450
 
    }
 
479
        goto cleanup;
 
480
    }
 
481
 
 
482
    if ((backend = virStorageBackendForType(def->type)) == NULL)
 
483
        goto cleanup;
 
484
 
 
485
    if (!(pool = virStoragePoolObjAssignDef(conn, &driver->pools, def)))
 
486
        goto cleanup;
 
487
    def = NULL;
451
488
 
452
489
    if (backend->startPool &&
453
490
        backend->startPool(conn, pool) < 0)
454
 
        return NULL;
 
491
        goto cleanup;
 
492
 
455
493
    if (backend->refreshPool(conn, pool) < 0) {
456
494
        if (backend->stopPool)
457
495
            backend->stopPool(conn, pool);
458
 
        return NULL;
 
496
        goto cleanup;
459
497
    }
460
498
    pool->active = 1;
461
499
 
462
500
    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid);
463
501
 
 
502
cleanup:
 
503
    virStoragePoolDefFree(def);
 
504
    if (pool)
 
505
        virStoragePoolObjUnlock(pool);
 
506
    storageDriverUnlock(driver);
464
507
    return ret;
465
508
}
466
509
 
468
511
storagePoolDefine(virConnectPtr conn,
469
512
                  const char *xml,
470
513
                  unsigned int flags ATTRIBUTE_UNUSED) {
471
 
    virStorageDriverStatePtr driver
472
 
        = (virStorageDriverStatePtr )conn->storagePrivateData;
 
514
    virStorageDriverStatePtr driver = conn->storagePrivateData;
473
515
    virStoragePoolDefPtr def;
474
 
    virStoragePoolObjPtr pool;
475
 
    virStoragePoolPtr ret;
 
516
    virStoragePoolObjPtr pool = NULL;
 
517
    virStoragePoolPtr ret = NULL;
476
518
    virStorageBackendPtr backend;
477
519
 
 
520
    storageDriverLock(driver);
478
521
    if (!(def = virStoragePoolDefParse(conn, xml, NULL)))
479
 
        return NULL;
480
 
 
481
 
    if ((backend = virStorageBackendForType(def->type)) == NULL) {
482
 
        virStoragePoolDefFree(def);
483
 
        return NULL;
484
 
    }
485
 
 
486
 
    if (!(pool = virStoragePoolObjAssignDef(conn, &driver->pools, def))) {
487
 
        virStoragePoolDefFree(def);
488
 
        return NULL;
489
 
    }
 
522
        goto cleanup;
 
523
 
 
524
    if ((backend = virStorageBackendForType(def->type)) == NULL)
 
525
        goto cleanup;
 
526
 
 
527
    if (!(pool = virStoragePoolObjAssignDef(conn, &driver->pools, def)))
 
528
        goto cleanup;
490
529
 
491
530
    if (virStoragePoolObjSaveDef(conn, driver, pool, def) < 0) {
492
531
        virStoragePoolObjRemove(&driver->pools, pool);
493
 
        return NULL;
 
532
        def = NULL;
 
533
        goto cleanup;
494
534
    }
 
535
    def = NULL;
495
536
 
496
537
    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid);
 
538
 
 
539
cleanup:
 
540
    virStoragePoolDefFree(def);
 
541
    if (pool)
 
542
        virStoragePoolObjUnlock(pool);
 
543
    storageDriverUnlock(driver);
497
544
    return ret;
498
545
}
499
546
 
500
547
static int
501
548
storagePoolUndefine(virStoragePoolPtr obj) {
502
 
    virStorageDriverStatePtr driver =
503
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
504
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
549
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
550
    virStoragePoolObjPtr pool;
 
551
    int ret = -1;
505
552
 
 
553
    storageDriverLock(driver);
 
554
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
506
555
    if (!pool) {
507
556
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
508
557
                              "%s", _("no storage pool with matching uuid"));
509
 
        return -1;
 
558
        goto cleanup;
510
559
    }
511
560
 
512
561
    if (virStoragePoolObjIsActive(pool)) {
513
562
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
514
563
                              "%s", _("pool is still active"));
515
 
        return -1;
 
564
        goto cleanup;
516
565
    }
517
566
 
518
567
    if (virStoragePoolObjDeleteDef(obj->conn, pool) < 0)
519
 
        return -1;
 
568
        goto cleanup;
520
569
 
521
570
    if (unlink(pool->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR)
522
571
        storageLog("Failed to delete autostart link '%s': %s",
526
575
    VIR_FREE(pool->autostartLink);
527
576
 
528
577
    virStoragePoolObjRemove(&driver->pools, pool);
 
578
    pool = NULL;
 
579
    ret = 0;
529
580
 
530
 
    return 0;
 
581
cleanup:
 
582
    if (pool)
 
583
        virStoragePoolObjUnlock(pool);
 
584
    storageDriverUnlock(driver);
 
585
    return ret;
531
586
}
532
587
 
533
588
static int
534
589
storagePoolStart(virStoragePoolPtr obj,
535
590
                 unsigned int flags ATTRIBUTE_UNUSED) {
536
 
    virStorageDriverStatePtr driver =
537
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
538
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
591
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
592
    virStoragePoolObjPtr pool;
539
593
    virStorageBackendPtr backend;
 
594
    int ret = -1;
 
595
 
 
596
    storageDriverLock(driver);
 
597
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
598
    storageDriverUnlock(driver);
540
599
 
541
600
    if (!pool) {
542
601
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
543
602
                              "%s", _("no storage pool with matching uuid"));
544
 
        return -1;
 
603
        goto cleanup;
545
604
    }
546
605
 
547
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
548
 
        return -1;
549
 
    }
 
606
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
607
        goto cleanup;
550
608
 
551
609
    if (virStoragePoolObjIsActive(pool)) {
552
610
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
553
611
                              "%s", _("pool already active"));
554
 
        return -1;
 
612
        goto cleanup;
555
613
    }
556
614
    if (backend->startPool &&
557
615
        backend->startPool(obj->conn, pool) < 0)
558
 
        return -1;
 
616
        goto cleanup;
 
617
 
559
618
    if (backend->refreshPool(obj->conn, pool) < 0) {
560
619
        if (backend->stopPool)
561
620
            backend->stopPool(obj->conn, pool);
562
 
        return -1;
 
621
        goto cleanup;
563
622
    }
564
623
 
565
624
    pool->active = 1;
 
625
    ret = 0;
566
626
 
567
 
    return 0;
 
627
cleanup:
 
628
    if (pool)
 
629
        virStoragePoolObjUnlock(pool);
 
630
    return ret;
568
631
}
569
632
 
570
633
static int
571
634
storagePoolBuild(virStoragePoolPtr obj,
572
635
                 unsigned int flags) {
573
 
    virStorageDriverStatePtr driver
574
 
        = (virStorageDriverStatePtr)obj->conn->storagePrivateData;
575
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
636
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
637
    virStoragePoolObjPtr pool;
576
638
    virStorageBackendPtr backend;
 
639
    int ret = -1;
 
640
 
 
641
    storageDriverLock(driver);
 
642
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
643
    storageDriverUnlock(driver);
577
644
 
578
645
    if (!pool) {
579
646
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
580
647
                              "%s", _("no storage pool with matching uuid"));
581
 
        return -1;
 
648
        goto cleanup;
582
649
    }
583
650
 
584
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
585
 
        return -1;
586
 
    }
 
651
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
652
        goto cleanup;
587
653
 
588
654
    if (virStoragePoolObjIsActive(pool)) {
589
655
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
590
656
                              "%s", _("storage pool is already active"));
591
 
        return -1;
 
657
        goto cleanup;
592
658
    }
593
659
 
594
660
    if (backend->buildPool &&
595
661
        backend->buildPool(obj->conn, pool, flags) < 0)
596
 
        return -1;
 
662
        goto cleanup;
 
663
    ret = 0;
597
664
 
598
 
    return 0;
 
665
cleanup:
 
666
    if (pool)
 
667
        virStoragePoolObjUnlock(pool);
 
668
    return ret;
599
669
}
600
670
 
601
671
 
602
672
static int
603
673
storagePoolDestroy(virStoragePoolPtr obj) {
604
 
    virStorageDriverStatePtr driver =
605
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
606
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
674
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
675
    virStoragePoolObjPtr pool;
607
676
    virStorageBackendPtr backend;
 
677
    int ret = -1;
 
678
 
 
679
    storageDriverLock(driver);
 
680
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
608
681
 
609
682
    if (!pool) {
610
683
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
611
684
                              "%s", _("no storage pool with matching uuid"));
612
 
        return -1;
 
685
        goto cleanup;
613
686
    }
614
687
 
615
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
616
 
        return -1;
617
 
    }
 
688
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
689
        goto cleanup;
618
690
 
619
691
    if (!virStoragePoolObjIsActive(pool)) {
620
692
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
621
693
                              "%s", _("storage pool is not active"));
622
 
        return -1;
 
694
        goto cleanup;
623
695
    }
624
696
 
625
697
    if (backend->stopPool &&
626
698
        backend->stopPool(obj->conn, pool) < 0)
627
 
        return -1;
 
699
        goto cleanup;
628
700
 
629
701
    virStoragePoolObjClearVols(pool);
630
702
 
631
703
    pool->active = 0;
632
704
 
633
 
    if (pool->configFile == NULL)
 
705
    if (pool->configFile == NULL) {
634
706
        virStoragePoolObjRemove(&driver->pools, pool);
 
707
        pool = NULL;
 
708
    }
 
709
    ret = 0;
635
710
 
636
 
    return 0;
 
711
cleanup:
 
712
    if (pool)
 
713
        virStoragePoolObjUnlock(pool);
 
714
    storageDriverUnlock(driver);
 
715
    return ret;
637
716
}
638
717
 
639
718
 
640
719
static int
641
720
storagePoolDelete(virStoragePoolPtr obj,
642
721
                  unsigned int flags) {
643
 
    virStorageDriverStatePtr driver =
644
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
645
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
722
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
723
    virStoragePoolObjPtr pool;
646
724
    virStorageBackendPtr backend;
 
725
    int ret = -1;
 
726
 
 
727
    storageDriverLock(driver);
 
728
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
729
    storageDriverUnlock(driver);
647
730
 
648
731
    if (!pool) {
649
732
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
650
733
                              "%s", _("no storage pool with matching uuid"));
651
 
        return -1;
 
734
        goto cleanup;
652
735
    }
653
736
 
654
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
655
 
        return -1;
656
 
    }
 
737
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
738
        goto cleanup;
657
739
 
658
740
    if (virStoragePoolObjIsActive(pool)) {
659
741
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
660
742
                              "%s", _("storage pool is still active"));
661
 
        return -1;
 
743
        goto cleanup;
662
744
    }
663
745
 
664
746
    if (!backend->deletePool) {
665
747
        virStorageReportError(obj->conn, VIR_ERR_NO_SUPPORT,
666
748
                              "%s", _("pool does not support volume delete"));
667
 
        return -1;
 
749
        goto cleanup;
668
750
    }
669
751
    if (backend->deletePool(obj->conn, pool, flags) < 0)
670
 
        return -1;
 
752
        goto cleanup;
 
753
    ret = 0;
671
754
 
672
 
    return 0;
 
755
cleanup:
 
756
    if (pool)
 
757
        virStoragePoolObjUnlock(pool);
 
758
    return ret;
673
759
}
674
760
 
675
761
 
676
762
static int
677
763
storagePoolRefresh(virStoragePoolPtr obj,
678
764
                   unsigned int flags ATTRIBUTE_UNUSED) {
679
 
    virStorageDriverStatePtr driver =
680
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
681
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
765
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
766
    virStoragePoolObjPtr pool;
682
767
    virStorageBackendPtr backend;
683
 
    int ret = 0;
 
768
    int ret = -1;
 
769
 
 
770
    storageDriverLock(driver);
 
771
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
772
    storageDriverUnlock(driver);
684
773
 
685
774
    if (!pool) {
686
775
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
687
776
                              "%s", _("no storage pool with matching uuid"));
688
 
        return -1;
 
777
        goto cleanup;
689
778
    }
690
779
 
691
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
692
 
        return -1;
693
 
    }
 
780
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
781
        goto cleanup;
694
782
 
695
783
    if (!virStoragePoolObjIsActive(pool)) {
696
784
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
697
785
                              "%s", _("storage pool is not active"));
698
 
        return -1;
 
786
        goto cleanup;
699
787
    }
700
788
 
701
789
    virStoragePoolObjClearVols(pool);
702
 
    if ((ret = backend->refreshPool(obj->conn, pool)) < 0) {
 
790
    if (backend->refreshPool(obj->conn, pool) < 0) {
703
791
        if (backend->stopPool)
704
792
            backend->stopPool(obj->conn, pool);
705
793
 
706
794
        pool->active = 0;
707
795
 
708
 
        if (pool->configFile == NULL)
 
796
        if (pool->configFile == NULL) {
709
797
            virStoragePoolObjRemove(&driver->pools, pool);
 
798
            pool = NULL;
 
799
        }
 
800
        goto cleanup;
710
801
    }
 
802
    ret = 0;
711
803
 
 
804
cleanup:
 
805
    if (pool)
 
806
        virStoragePoolObjUnlock(pool);
712
807
    return ret;
713
808
}
714
809
 
716
811
static int
717
812
storagePoolGetInfo(virStoragePoolPtr obj,
718
813
                   virStoragePoolInfoPtr info) {
719
 
    virStorageDriverStatePtr driver =
720
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
721
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
814
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
815
    virStoragePoolObjPtr pool;
722
816
    virStorageBackendPtr backend;
 
817
    int ret = -1;
 
818
 
 
819
    storageDriverLock(driver);
 
820
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
821
    storageDriverUnlock(driver);
723
822
 
724
823
    if (!pool) {
725
824
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
726
825
                              "%s", _("no storage pool with matching uuid"));
727
 
        return -1;
 
826
        goto cleanup;
728
827
    }
729
828
 
730
 
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
731
 
        return -1;
732
 
    }
 
829
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
 
830
        goto cleanup;
733
831
 
734
832
    memset(info, 0, sizeof(virStoragePoolInfo));
735
833
    if (pool->active)
739
837
    info->capacity = pool->def->capacity;
740
838
    info->allocation = pool->def->allocation;
741
839
    info->available = pool->def->available;
 
840
    ret = 0;
742
841
 
743
 
    return 0;
 
842
cleanup:
 
843
    if (pool)
 
844
        virStoragePoolObjUnlock(pool);
 
845
    return ret;
744
846
}
745
847
 
746
848
static char *
747
849
storagePoolDumpXML(virStoragePoolPtr obj,
748
850
                   unsigned int flags ATTRIBUTE_UNUSED) {
749
 
    virStorageDriverStatePtr driver =
750
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
751
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
851
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
852
    virStoragePoolObjPtr pool;
 
853
    char *ret = NULL;
 
854
 
 
855
    storageDriverLock(driver);
 
856
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
857
    storageDriverUnlock(driver);
752
858
 
753
859
    if (!pool) {
754
860
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
755
861
                              "%s", _("no storage pool with matching uuid"));
756
 
        return NULL;
 
862
        goto cleanup;
757
863
    }
758
864
 
759
 
    return virStoragePoolDefFormat(obj->conn, pool->def);
 
865
    ret = virStoragePoolDefFormat(obj->conn, pool->def);
 
866
 
 
867
cleanup:
 
868
    if (pool)
 
869
        virStoragePoolObjUnlock(pool);
 
870
    return ret;
760
871
}
761
872
 
762
873
static int
763
874
storagePoolGetAutostart(virStoragePoolPtr obj,
764
875
                        int *autostart) {
765
 
    virStorageDriverStatePtr driver =
766
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
767
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
876
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
877
    virStoragePoolObjPtr pool;
 
878
    int ret = -1;
 
879
 
 
880
    storageDriverLock(driver);
 
881
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
882
    storageDriverUnlock(driver);
768
883
 
769
884
    if (!pool) {
770
885
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
771
886
                              "%s", _("no pool with matching uuid"));
772
 
        return -1;
 
887
        goto cleanup;
773
888
    }
774
889
 
775
890
    if (!pool->configFile) {
777
892
    } else {
778
893
        *autostart = pool->autostart;
779
894
    }
 
895
    ret = 0;
780
896
 
781
 
    return 0;
 
897
cleanup:
 
898
    if (pool)
 
899
        virStoragePoolObjUnlock(pool);
 
900
    return ret;
782
901
}
783
902
 
784
903
static int
785
904
storagePoolSetAutostart(virStoragePoolPtr obj,
786
905
                        int autostart) {
787
 
    virStorageDriverStatePtr driver =
788
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
789
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
906
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
907
    virStoragePoolObjPtr pool;
 
908
    int ret = -1;
 
909
 
 
910
    storageDriverLock(driver);
 
911
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
912
    storageDriverUnlock(driver);
790
913
 
791
914
    if (!pool) {
792
915
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
793
916
                              "%s", _("no pool with matching uuid"));
794
 
        return -1;
 
917
        goto cleanup;
795
918
    }
796
919
 
797
920
    if (!pool->configFile) {
798
921
        virStorageReportError(obj->conn, VIR_ERR_INVALID_ARG,
799
922
                              "%s", _("pool has no config file"));
800
 
        return -1;
 
923
        goto cleanup;
801
924
    }
802
925
 
803
926
    autostart = (autostart != 0);
804
927
 
805
 
    if (pool->autostart == autostart)
806
 
        return 0;
807
 
 
808
 
    if (autostart) {
809
 
        int err;
810
 
 
811
 
        if ((err = virFileMakePath(driver->autostartDir))) {
812
 
            virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
813
 
                                  _("cannot create autostart directory %s: %s"),
814
 
                                  driver->autostartDir, strerror(err));
815
 
            return -1;
816
 
        }
817
 
 
818
 
        if (symlink(pool->configFile, pool->autostartLink) < 0) {
819
 
            virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
820
 
                                  _("Failed to create symlink '%s' to '%s': %s"),
821
 
                                  pool->autostartLink, pool->configFile,
822
 
                                  strerror(errno));
823
 
            return -1;
824
 
        }
825
 
    } else {
826
 
        if (unlink(pool->autostartLink) < 0 &&
827
 
            errno != ENOENT && errno != ENOTDIR) {
828
 
            virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
829
 
                                  _("Failed to delete symlink '%s': %s"),
830
 
                                  pool->autostartLink, strerror(errno));
831
 
            return -1;
832
 
        }
 
928
    if (pool->autostart != autostart) {
 
929
        if (autostart) {
 
930
            int err;
 
931
 
 
932
            if ((err = virFileMakePath(driver->autostartDir))) {
 
933
                virReportSystemError(obj->conn, err,
 
934
                                     _("cannot create autostart directory %s"),
 
935
                                     driver->autostartDir);
 
936
                goto cleanup;
 
937
            }
 
938
 
 
939
            if (symlink(pool->configFile, pool->autostartLink) < 0) {
 
940
                virReportSystemError(obj->conn, errno,
 
941
                                     _("Failed to create symlink '%s' to '%s'"),
 
942
                                     pool->autostartLink, pool->configFile);
 
943
                goto cleanup;
 
944
            }
 
945
        } else {
 
946
            if (unlink(pool->autostartLink) < 0 &&
 
947
                errno != ENOENT && errno != ENOTDIR) {
 
948
                virReportSystemError(obj->conn, errno,
 
949
                                     _("Failed to delete symlink '%s'"),
 
950
                                     pool->autostartLink);
 
951
                goto cleanup;
 
952
            }
 
953
        }
 
954
        pool->autostart = autostart;
833
955
    }
834
 
 
835
 
    pool->autostart = autostart;
836
 
 
837
 
    return 0;
 
956
    ret = 0;
 
957
 
 
958
cleanup:
 
959
    if (pool)
 
960
        virStoragePoolObjUnlock(pool);
 
961
    return ret;
838
962
}
839
963
 
840
964
 
841
965
static int
842
966
storagePoolNumVolumes(virStoragePoolPtr obj) {
843
 
    virStorageDriverStatePtr driver =
844
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
845
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
967
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
968
    virStoragePoolObjPtr pool;
 
969
    int ret = -1;
 
970
 
 
971
    storageDriverLock(driver);
 
972
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
973
    storageDriverUnlock(driver);
846
974
 
847
975
    if (!pool) {
848
976
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
849
977
                              "%s", _("no storage pool with matching uuid"));
850
 
        return -1;
 
978
        goto cleanup;
851
979
    }
852
980
 
853
981
    if (!virStoragePoolObjIsActive(pool)) {
854
982
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
855
983
                              "%s", _("storage pool is not active"));
856
 
        return -1;
 
984
        goto cleanup;
857
985
    }
 
986
    ret = pool->volumes.count;
858
987
 
859
 
    return pool->volumes.count;
 
988
cleanup:
 
989
    if (pool)
 
990
        virStoragePoolObjUnlock(pool);
 
991
    return ret;
860
992
}
861
993
 
862
994
static int
863
995
storagePoolListVolumes(virStoragePoolPtr obj,
864
996
                       char **const names,
865
997
                       int maxnames) {
866
 
    virStorageDriverStatePtr driver =
867
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
868
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
998
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
999
    virStoragePoolObjPtr pool;
869
1000
    int i, n = 0;
870
1001
 
 
1002
    memset(names, 0, maxnames * sizeof(*names));
 
1003
 
 
1004
    storageDriverLock(driver);
 
1005
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
1006
    storageDriverUnlock(driver);
 
1007
 
871
1008
    if (!pool) {
872
1009
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
873
1010
                              "%s", _("no storage pool with matching uuid"));
874
 
        return -1;
 
1011
        goto cleanup;
875
1012
    }
876
1013
 
877
1014
    if (!virStoragePoolObjIsActive(pool)) {
878
1015
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
879
1016
                              "%s", _("storage pool is not active"));
880
 
        return -1;
 
1017
        goto cleanup;
881
1018
    }
882
1019
 
883
 
    memset(names, 0, maxnames * sizeof(*names));
884
1020
    for (i = 0 ; i < pool->volumes.count && n < maxnames ; i++) {
885
1021
        if ((names[n++] = strdup(pool->volumes.objs[i]->name)) == NULL) {
886
 
            virStorageReportError(obj->conn, VIR_ERR_NO_MEMORY,
887
 
                                  "%s", _("name"));
 
1022
            virReportOOMError(obj->conn);
888
1023
            goto cleanup;
889
1024
        }
890
1025
    }
891
1026
 
 
1027
    virStoragePoolObjUnlock(pool);
892
1028
    return n;
893
1029
 
894
1030
 cleanup:
 
1031
    if (pool)
 
1032
        virStoragePoolObjUnlock(pool);
895
1033
    for (n = 0 ; n < maxnames ; n++)
896
 
        VIR_FREE(names[i]);
 
1034
        VIR_FREE(names[n]);
897
1035
 
898
1036
    memset(names, 0, maxnames * sizeof(*names));
899
1037
    return -1;
903
1041
static virStorageVolPtr
904
1042
storageVolumeLookupByName(virStoragePoolPtr obj,
905
1043
                          const char *name) {
906
 
    virStorageDriverStatePtr driver =
907
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
908
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
1044
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1045
    virStoragePoolObjPtr pool;
909
1046
    virStorageVolDefPtr vol;
 
1047
    virStorageVolPtr ret = NULL;
 
1048
 
 
1049
    storageDriverLock(driver);
 
1050
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
1051
    storageDriverUnlock(driver);
910
1052
 
911
1053
    if (!pool) {
912
1054
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
913
1055
                              "%s", _("no storage pool with matching uuid"));
914
 
        return NULL;
 
1056
        goto cleanup;
915
1057
    }
916
1058
 
917
1059
    if (!virStoragePoolObjIsActive(pool)) {
918
1060
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
919
1061
                              "%s", _("storage pool is not active"));
920
 
        return NULL;
 
1062
        goto cleanup;
921
1063
    }
922
1064
 
923
1065
    vol = virStorageVolDefFindByName(pool, name);
925
1067
    if (!vol) {
926
1068
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
927
1069
                              "%s", _("no storage vol with matching name"));
928
 
        return NULL;
 
1070
        goto cleanup;
929
1071
    }
930
1072
 
931
 
    return virGetStorageVol(obj->conn, pool->def->name, vol->name, vol->key);
 
1073
    ret = virGetStorageVol(obj->conn, pool->def->name, vol->name, vol->key);
 
1074
 
 
1075
cleanup:
 
1076
    if (pool)
 
1077
        virStoragePoolObjUnlock(pool);
 
1078
    return ret;
932
1079
}
933
1080
 
934
1081
 
935
1082
static virStorageVolPtr
936
1083
storageVolumeLookupByKey(virConnectPtr conn,
937
1084
                         const char *key) {
938
 
    virStorageDriverStatePtr driver =
939
 
        (virStorageDriverStatePtr)conn->storagePrivateData;
 
1085
    virStorageDriverStatePtr driver = conn->storagePrivateData;
940
1086
    unsigned int i;
 
1087
    virStorageVolPtr ret = NULL;
941
1088
 
942
 
    for (i = 0 ; i < driver->pools.count ; i++) {
 
1089
    storageDriverLock(driver);
 
1090
    for (i = 0 ; i < driver->pools.count && !ret ; i++) {
 
1091
        virStoragePoolObjLock(driver->pools.objs[i]);
943
1092
        if (virStoragePoolObjIsActive(driver->pools.objs[i])) {
944
1093
            virStorageVolDefPtr vol =
945
1094
                virStorageVolDefFindByKey(driver->pools.objs[i], key);
946
1095
 
947
1096
            if (vol)
948
 
                return virGetStorageVol(conn,
949
 
                                        driver->pools.objs[i]->def->name,
950
 
                                        vol->name,
951
 
                                        vol->key);
 
1097
                ret = virGetStorageVol(conn,
 
1098
                                       driver->pools.objs[i]->def->name,
 
1099
                                       vol->name,
 
1100
                                       vol->key);
952
1101
        }
 
1102
        virStoragePoolObjUnlock(driver->pools.objs[i]);
953
1103
    }
954
 
 
955
 
    virStorageReportError(conn, VIR_ERR_INVALID_STORAGE_VOL,
956
 
                          "%s", _("no storage vol with matching key"));
957
 
    return NULL;
 
1104
    storageDriverUnlock(driver);
 
1105
 
 
1106
    if (!ret)
 
1107
        virStorageReportError(conn, VIR_ERR_INVALID_STORAGE_VOL,
 
1108
                              "%s", _("no storage vol with matching key"));
 
1109
 
 
1110
    return ret;
958
1111
}
959
1112
 
960
1113
static virStorageVolPtr
961
1114
storageVolumeLookupByPath(virConnectPtr conn,
962
1115
                          const char *path) {
963
 
    virStorageDriverStatePtr driver =
964
 
        (virStorageDriverStatePtr)conn->storagePrivateData;
 
1116
    virStorageDriverStatePtr driver = conn->storagePrivateData;
965
1117
    unsigned int i;
 
1118
    virStorageVolPtr ret = NULL;
966
1119
 
967
 
    for (i = 0 ; i < driver->pools.count ; i++) {
 
1120
    storageDriverLock(driver);
 
1121
    for (i = 0 ; i < driver->pools.count && !ret ; i++) {
 
1122
        virStoragePoolObjLock(driver->pools.objs[i]);
968
1123
        if (virStoragePoolObjIsActive(driver->pools.objs[i])) {
969
1124
            virStorageVolDefPtr vol;
970
1125
            const char *stable_path;
977
1132
             * virStorageReportError if it fails; we just need to keep
978
1133
             * propagating the return code
979
1134
             */
980
 
            if (stable_path == NULL)
981
 
                return NULL;
 
1135
            if (stable_path == NULL) {
 
1136
                virStoragePoolObjUnlock(driver->pools.objs[i]);
 
1137
                goto cleanup;
 
1138
            }
982
1139
 
983
1140
            vol = virStorageVolDefFindByPath(driver->pools.objs[i],
984
1141
                                             stable_path);
985
1142
            VIR_FREE(stable_path);
986
1143
 
987
1144
            if (vol)
988
 
                return virGetStorageVol(conn,
989
 
                                        driver->pools.objs[i]->def->name,
990
 
                                        vol->name,
991
 
                                        vol->key);
 
1145
                ret = virGetStorageVol(conn,
 
1146
                                       driver->pools.objs[i]->def->name,
 
1147
                                       vol->name,
 
1148
                                       vol->key);
992
1149
        }
 
1150
        virStoragePoolObjUnlock(driver->pools.objs[i]);
993
1151
    }
994
1152
 
995
 
    virStorageReportError(conn, VIR_ERR_INVALID_STORAGE_VOL,
996
 
                          "%s", _("no storage vol with matching path"));
997
 
    return NULL;
 
1153
    if (!ret)
 
1154
        virStorageReportError(conn, VIR_ERR_INVALID_STORAGE_VOL,
 
1155
                              "%s", _("no storage vol with matching path"));
 
1156
 
 
1157
cleanup:
 
1158
    storageDriverUnlock(driver);
 
1159
    return ret;
998
1160
}
999
1161
 
1000
1162
static virStorageVolPtr
1001
1163
storageVolumeCreateXML(virStoragePoolPtr obj,
1002
1164
                       const char *xmldesc,
1003
1165
                       unsigned int flags ATTRIBUTE_UNUSED) {
1004
 
    virStorageDriverStatePtr driver =
1005
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
1006
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
1166
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1167
    virStoragePoolObjPtr pool;
1007
1168
    virStorageBackendPtr backend;
1008
 
    virStorageVolDefPtr vol;
 
1169
    virStorageVolDefPtr vol = NULL;
 
1170
    virStorageVolPtr ret = NULL;
 
1171
 
 
1172
    storageDriverLock(driver);
 
1173
    pool = virStoragePoolObjFindByUUID(&driver->pools, obj->uuid);
 
1174
    storageDriverUnlock(driver);
1009
1175
 
1010
1176
    if (!pool) {
1011
1177
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1012
1178
                              "%s", _("no storage pool with matching uuid"));
1013
 
        return NULL;
 
1179
        goto cleanup;
1014
1180
    }
1015
1181
 
1016
1182
    if (!virStoragePoolObjIsActive(pool)) {
1017
1183
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
1018
1184
                              "%s", _("storage pool is not active"));
1019
 
        return NULL;
 
1185
        goto cleanup;
1020
1186
    }
1021
1187
 
1022
1188
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
1023
 
        return NULL;
 
1189
        goto cleanup;
1024
1190
 
1025
1191
    vol = virStorageVolDefParse(obj->conn, pool->def, xmldesc, NULL);
1026
1192
    if (vol == NULL)
1027
 
        return NULL;
 
1193
        goto cleanup;
1028
1194
 
1029
1195
    if (virStorageVolDefFindByName(pool, vol->name)) {
1030
1196
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1031
1197
                              "%s", _("storage vol already exists"));
1032
 
        virStorageVolDefFree(vol);
1033
 
        return NULL;
 
1198
        goto cleanup;
1034
1199
    }
1035
1200
 
1036
1201
    if (VIR_REALLOC_N(pool->volumes.objs,
1037
1202
                      pool->volumes.count+1) < 0) {
1038
 
        virStorageReportError(obj->conn, VIR_ERR_NO_MEMORY, NULL);
1039
 
        virStorageVolDefFree(vol);
1040
 
        return NULL;
 
1203
        virReportOOMError(obj->conn);
 
1204
        goto cleanup;
1041
1205
    }
1042
1206
 
1043
1207
    if (!backend->createVol) {
1044
1208
        virStorageReportError(obj->conn, VIR_ERR_NO_SUPPORT,
1045
1209
                              "%s", _("storage pool does not support volume creation"));
1046
 
        virStorageVolDefFree(vol);
1047
 
        return NULL;
 
1210
        goto cleanup;
1048
1211
    }
1049
1212
 
 
1213
    /* XXX ought to drop pool lock while creating instance */
1050
1214
    if (backend->createVol(obj->conn, pool, vol) < 0) {
1051
 
        virStorageVolDefFree(vol);
1052
 
        return NULL;
 
1215
        goto cleanup;
1053
1216
    }
1054
1217
 
1055
1218
    pool->volumes.objs[pool->volumes.count++] = vol;
1056
1219
 
1057
 
    return virGetStorageVol(obj->conn, pool->def->name, vol->name, vol->key);
 
1220
    ret = virGetStorageVol(obj->conn, pool->def->name, vol->name, vol->key);
 
1221
    vol = NULL;
 
1222
 
 
1223
cleanup:
 
1224
    virStorageVolDefFree(vol);
 
1225
    if (pool)
 
1226
        virStoragePoolObjUnlock(pool);
 
1227
    return ret;
1058
1228
}
1059
1229
 
1060
1230
static int
1061
1231
storageVolumeDelete(virStorageVolPtr obj,
1062
1232
                    unsigned int flags) {
1063
 
    virStorageDriverStatePtr driver =
1064
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
1065
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1233
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1234
    virStoragePoolObjPtr pool;
1066
1235
    virStorageBackendPtr backend;
1067
 
    virStorageVolDefPtr vol;
 
1236
    virStorageVolDefPtr vol = NULL;
1068
1237
    unsigned int i;
 
1238
    int ret = -1;
 
1239
 
 
1240
    storageDriverLock(driver);
 
1241
    pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1242
    storageDriverUnlock(driver);
1069
1243
 
1070
1244
    if (!pool) {
1071
1245
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1072
1246
                              "%s", _("no storage pool with matching uuid"));
1073
 
        return -1;
 
1247
        goto cleanup;
1074
1248
    }
1075
1249
 
1076
1250
    if (!virStoragePoolObjIsActive(pool)) {
1077
1251
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
1078
1252
                              "%s", _("storage pool is not active"));
1079
 
        return -1;
 
1253
        goto cleanup;
1080
1254
    }
1081
1255
 
1082
1256
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
1083
 
        return -1;
 
1257
        goto cleanup;
1084
1258
 
1085
1259
    vol = virStorageVolDefFindByName(pool, obj->name);
1086
1260
 
1087
1261
    if (!vol) {
1088
1262
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1089
1263
                              "%s", _("no storage vol with matching name"));
1090
 
        return -1;
 
1264
        goto cleanup;
1091
1265
    }
1092
1266
 
1093
1267
    if (!backend->deleteVol) {
1094
1268
        virStorageReportError(obj->conn, VIR_ERR_NO_SUPPORT,
1095
1269
                              "%s", _("storage pool does not support vol deletion"));
1096
 
        virStorageVolDefFree(vol);
1097
 
        return -1;
1098
 
    }
1099
 
 
1100
 
    if (backend->deleteVol(obj->conn, pool, vol, flags) < 0) {
1101
 
        return -1;
1102
 
    }
 
1270
 
 
1271
        goto cleanup;
 
1272
    }
 
1273
 
 
1274
    if (backend->deleteVol(obj->conn, pool, vol, flags) < 0)
 
1275
        goto cleanup;
1103
1276
 
1104
1277
    for (i = 0 ; i < pool->volumes.count ; i++) {
1105
1278
        if (pool->volumes.objs[i] == vol) {
1106
1279
            virStorageVolDefFree(vol);
 
1280
            vol = NULL;
1107
1281
 
1108
1282
            if (i < (pool->volumes.count - 1))
1109
1283
                memmove(pool->volumes.objs + i, pool->volumes.objs + i + 1,
1117
1291
            break;
1118
1292
        }
1119
1293
    }
 
1294
    ret = 0;
1120
1295
 
1121
 
    return 0;
 
1296
cleanup:
 
1297
    virStorageVolDefFree(vol);
 
1298
    if (pool)
 
1299
        virStoragePoolObjUnlock(pool);
 
1300
    return ret;
1122
1301
}
1123
1302
 
1124
1303
static int
1125
1304
storageVolumeGetInfo(virStorageVolPtr obj,
1126
1305
                     virStorageVolInfoPtr info) {
1127
 
    virStorageDriverStatePtr driver =
1128
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
1129
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1306
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1307
    virStoragePoolObjPtr pool;
1130
1308
    virStorageBackendPtr backend;
1131
1309
    virStorageVolDefPtr vol;
 
1310
    int ret = -1;
 
1311
 
 
1312
    storageDriverLock(driver);
 
1313
    pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1314
    storageDriverUnlock(driver);
1132
1315
 
1133
1316
    if (!pool) {
1134
1317
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1135
1318
                              "%s", _("no storage pool with matching uuid"));
1136
 
        return -1;
 
1319
        goto cleanup;
1137
1320
    }
1138
1321
 
1139
1322
    if (!virStoragePoolObjIsActive(pool)) {
1140
1323
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
1141
1324
                              "%s", _("storage pool is not active"));
1142
 
        return -1;
 
1325
        goto cleanup;
1143
1326
    }
1144
1327
 
1145
1328
    vol = virStorageVolDefFindByName(pool, obj->name);
1147
1330
    if (!vol) {
1148
1331
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1149
1332
                              "%s", _("no storage vol with matching name"));
1150
 
        return -1;
 
1333
        goto cleanup;
1151
1334
    }
1152
1335
 
1153
1336
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
1154
 
        return -1;
 
1337
        goto cleanup;
1155
1338
 
1156
1339
    if (backend->refreshVol &&
1157
1340
        backend->refreshVol(obj->conn, pool, vol) < 0)
1158
 
        return -1;
 
1341
        goto cleanup;
1159
1342
 
1160
1343
    memset(info, 0, sizeof(*info));
1161
1344
    info->type = vol->type;
1162
1345
    info->capacity = vol->capacity;
1163
1346
    info->allocation = vol->allocation;
 
1347
    ret = 0;
1164
1348
 
1165
 
    return 0;
 
1349
cleanup:
 
1350
    if (pool)
 
1351
        virStoragePoolObjUnlock(pool);
 
1352
    return ret;
1166
1353
}
1167
1354
 
1168
1355
static char *
1169
1356
storageVolumeGetXMLDesc(virStorageVolPtr obj,
1170
1357
                        unsigned int flags ATTRIBUTE_UNUSED) {
1171
 
    virStorageDriverStatePtr driver =
1172
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
1173
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1358
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1359
    virStoragePoolObjPtr pool;
1174
1360
    virStorageBackendPtr backend;
1175
1361
    virStorageVolDefPtr vol;
 
1362
    char *ret = NULL;
 
1363
 
 
1364
    storageDriverLock(driver);
 
1365
    pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1366
    storageDriverUnlock(driver);
1176
1367
 
1177
1368
    if (!pool) {
1178
1369
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1179
1370
                              "%s", _("no storage pool with matching uuid"));
1180
 
        return NULL;
 
1371
        goto cleanup;
1181
1372
    }
1182
1373
 
1183
1374
    if (!virStoragePoolObjIsActive(pool)) {
1184
1375
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
1185
1376
                              "%s", _("storage pool is not active"));
1186
 
        return NULL;
 
1377
        goto cleanup;
1187
1378
    }
1188
1379
 
1189
1380
    vol = virStorageVolDefFindByName(pool, obj->name);
1191
1382
    if (!vol) {
1192
1383
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1193
1384
                              "%s", _("no storage vol with matching name"));
1194
 
        return NULL;
 
1385
        goto cleanup;
1195
1386
    }
1196
1387
 
1197
1388
    if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
1198
 
        return NULL;
1199
 
 
1200
 
    return virStorageVolDefFormat(obj->conn, pool->def, vol);
 
1389
        goto cleanup;
 
1390
 
 
1391
    ret = virStorageVolDefFormat(obj->conn, pool->def, vol);
 
1392
 
 
1393
cleanup:
 
1394
    if (pool)
 
1395
        virStoragePoolObjUnlock(pool);
 
1396
 
 
1397
    return ret;
1201
1398
}
1202
1399
 
1203
1400
static char *
1204
1401
storageVolumeGetPath(virStorageVolPtr obj) {
1205
 
    virStorageDriverStatePtr driver =
1206
 
        (virStorageDriverStatePtr)obj->conn->storagePrivateData;
1207
 
    virStoragePoolObjPtr pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1402
    virStorageDriverStatePtr driver = obj->conn->storagePrivateData;
 
1403
    virStoragePoolObjPtr pool;
1208
1404
    virStorageVolDefPtr vol;
1209
 
    char *ret;
 
1405
    char *ret = NULL;
1210
1406
 
 
1407
    storageDriverLock(driver);
 
1408
    pool = virStoragePoolObjFindByName(&driver->pools, obj->pool);
 
1409
    storageDriverUnlock(driver);
1211
1410
    if (!pool) {
1212
1411
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1213
1412
                              "%s", _("no storage pool with matching uuid"));
1214
 
        return NULL;
 
1413
        goto cleanup;
1215
1414
    }
1216
1415
 
1217
1416
    if (!virStoragePoolObjIsActive(pool)) {
1218
1417
        virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR,
1219
1418
                              "%s", _("storage pool is not active"));
1220
 
        return NULL;
 
1419
        goto cleanup;
1221
1420
    }
1222
1421
 
1223
1422
    vol = virStorageVolDefFindByName(pool, obj->name);
1225
1424
    if (!vol) {
1226
1425
        virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL,
1227
1426
                              "%s", _("no storage vol with matching name"));
1228
 
        return NULL;
 
1427
        goto cleanup;
1229
1428
    }
1230
1429
 
1231
1430
    ret = strdup(vol->target.path);
1232
 
    if (ret == NULL) {
1233
 
        virStorageReportError(obj->conn, VIR_ERR_NO_MEMORY, "%s", _("path"));
1234
 
        return NULL;
1235
 
    }
 
1431
    if (ret == NULL)
 
1432
        virReportOOMError(obj->conn);
 
1433
 
 
1434
cleanup:
 
1435
    if (pool)
 
1436
        virStoragePoolObjUnlock(pool);
1236
1437
    return ret;
1237
1438
}
1238
1439