storage_conf.c 65.5 KB
Newer Older
1 2 3
/*
 * storage_conf.c: config handling for storage driver
 *
E
Eric Blake 已提交
4
 * Copyright (C) 2006-2012 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006-2008 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>

36
#include "virerror.h"
37
#include "datatypes.h"
38
#include "storage_conf.h"
39
#include "virstoragefile.h"
40

41
#include "virxml.h"
42
#include "viruuid.h"
43
#include "virbuffer.h"
44
#include "viralloc.h"
E
Eric Blake 已提交
45
#include "virfile.h"
46
#include "virstring.h"
47

48 49
#define VIR_FROM_THIS VIR_FROM_STORAGE

50 51
#define DEFAULT_POOL_PERM_MODE 0755
#define DEFAULT_VOL_PERM_MODE  0600
52

53 54 55 56
VIR_ENUM_IMPL(virStoragePool,
              VIR_STORAGE_POOL_LAST,
              "dir", "fs", "netfs",
              "logical", "disk", "iscsi",
57
              "scsi", "mpath", "rbd", "sheepdog")
58 59 60 61 62

VIR_ENUM_IMPL(virStoragePoolFormatFileSystem,
              VIR_STORAGE_POOL_FS_LAST,
              "auto", "ext2", "ext3",
              "ext4", "ufs", "iso9660", "udf",
J
Jim Fehlig 已提交
63
              "gfs", "gfs2", "vfat", "hfs+", "xfs", "ocfs2")
64 65 66

VIR_ENUM_IMPL(virStoragePoolFormatFileSystemNet,
              VIR_STORAGE_POOL_NETFS_LAST,
67
              "auto", "nfs", "glusterfs", "cifs")
68 69 70 71

VIR_ENUM_IMPL(virStoragePoolFormatDisk,
              VIR_STORAGE_POOL_DISK_LAST,
              "unknown", "dos", "dvh", "gpt",
72
              "mac", "bsd", "pc98", "sun", "lvm2")
73 74 75

VIR_ENUM_IMPL(virStoragePoolFormatLogical,
              VIR_STORAGE_POOL_LOGICAL_LAST,
76
              "unknown", "lvm2")
77 78 79 80 81 82 83


VIR_ENUM_IMPL(virStorageVolFormatDisk,
              VIR_STORAGE_VOL_DISK_LAST,
              "none", "linux", "fat16",
              "fat32", "linux-swap",
              "linux-lvm", "linux-raid",
84
              "extended")
85

86 87
VIR_ENUM_IMPL(virStoragePartedFsType,
              VIR_STORAGE_PARTED_FS_TYPE_LAST,
88
              "ext2", "ext2", "fat16",
89 90 91
              "fat32", "linux-swap",
              "ext2", "ext2",
              "extended")
92

93 94 95 96
VIR_ENUM_IMPL(virStoragePoolSourceAdapterType,
              VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_LAST,
              "default", "scsi_host", "fc_host")

97 98 99 100 101 102 103 104 105
typedef const char *(*virStorageVolFormatToString)(int format);
typedef int (*virStorageVolFormatFromString)(const char *format);

typedef const char *(*virStoragePoolFormatToString)(int format);
typedef int (*virStoragePoolFormatFromString)(const char *format);

typedef struct _virStorageVolOptions virStorageVolOptions;
typedef virStorageVolOptions *virStorageVolOptionsPtr;
struct _virStorageVolOptions {
106
    int defaultFormat;
107 108 109 110 111 112
    virStorageVolFormatToString formatToString;
    virStorageVolFormatFromString formatFromString;
};

/* Flags to indicate mandatory components in the pool source */
enum {
O
Osier Yang 已提交
113 114 115 116 117 118 119
    VIR_STORAGE_POOL_SOURCE_HOST            = (1 << 0),
    VIR_STORAGE_POOL_SOURCE_DEVICE          = (1 << 1),
    VIR_STORAGE_POOL_SOURCE_DIR             = (1 << 2),
    VIR_STORAGE_POOL_SOURCE_ADAPTER         = (1 << 3),
    VIR_STORAGE_POOL_SOURCE_NAME            = (1 << 4),
    VIR_STORAGE_POOL_SOURCE_INITIATOR_IQN   = (1 << 5),
    VIR_STORAGE_POOL_SOURCE_NETWORK         = (1 << 6),
120 121 122 123 124
};

typedef struct _virStoragePoolOptions virStoragePoolOptions;
typedef virStoragePoolOptions *virStoragePoolOptionsPtr;
struct _virStoragePoolOptions {
E
Eric Blake 已提交
125
    unsigned int flags;
126 127 128 129 130 131 132 133 134 135 136 137 138
    int defaultFormat;
    virStoragePoolFormatToString formatToString;
    virStoragePoolFormatFromString formatFromString;
};

typedef struct _virStoragePoolTypeInfo virStoragePoolTypeInfo;
typedef virStoragePoolTypeInfo *virStoragePoolTypeInfoPtr;
struct _virStoragePoolTypeInfo {
    int poolType;
    virStoragePoolOptions poolOptions;
    virStorageVolOptions volOptions;
};

E
Eric Blake 已提交
139 140 141 142 143 144 145 146 147
static int
virStorageVolumeFormatFromString(const char *format)
{
    int ret = virStorageFileFormatTypeFromString(format);
    if (ret == VIR_STORAGE_FILE_NONE)
        return -1;
    return ret;
}

148
static virStoragePoolTypeInfo poolTypeInfo[] = {
149 150 151 152 153 154 155 156
    {.poolType = VIR_STORAGE_POOL_LOGICAL,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_NAME |
                   VIR_STORAGE_POOL_SOURCE_DEVICE),
         .defaultFormat = VIR_STORAGE_POOL_LOGICAL_LVM2,
         .formatFromString = virStoragePoolFormatLogicalTypeFromString,
         .formatToString = virStoragePoolFormatLogicalTypeToString,
     },
157
    },
158 159 160 161 162 163
    {.poolType = VIR_STORAGE_POOL_DIR,
     .volOptions = {
         .defaultFormat = VIR_STORAGE_FILE_RAW,
         .formatFromString = virStorageVolumeFormatFromString,
         .formatToString = virStorageFileFormatTypeToString,
     },
164
    },
165 166 167 168 169 170 171
    {.poolType = VIR_STORAGE_POOL_FS,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_DEVICE),
         .defaultFormat = VIR_STORAGE_POOL_FS_AUTO,
         .formatFromString = virStoragePoolFormatFileSystemTypeFromString,
         .formatToString = virStoragePoolFormatFileSystemTypeToString,
      },
172
      .volOptions = {
173 174 175 176
         .defaultFormat = VIR_STORAGE_FILE_RAW,
         .formatFromString = virStorageVolumeFormatFromString,
         .formatToString = virStorageFileFormatTypeToString,
      },
177
    },
178 179 180 181 182 183 184 185
    {.poolType = VIR_STORAGE_POOL_NETFS,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
                   VIR_STORAGE_POOL_SOURCE_DIR),
         .defaultFormat = VIR_STORAGE_POOL_NETFS_AUTO,
         .formatFromString = virStoragePoolFormatFileSystemNetTypeFromString,
         .formatToString = virStoragePoolFormatFileSystemNetTypeToString,
      },
186
      .volOptions = {
187 188 189 190
         .defaultFormat = VIR_STORAGE_FILE_RAW,
         .formatFromString = virStorageVolumeFormatFromString,
         .formatToString = virStorageFileFormatTypeToString,
      },
191
    },
192 193 194 195 196 197
    {.poolType = VIR_STORAGE_POOL_ISCSI,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
                   VIR_STORAGE_POOL_SOURCE_DEVICE |
                   VIR_STORAGE_POOL_SOURCE_INITIATOR_IQN),
      },
198
      .volOptions = {
199 200 201 202 203 204 205 206 207 208
         .formatToString = virStoragePoolFormatDiskTypeToString,
      }
    },
    {.poolType = VIR_STORAGE_POOL_SCSI,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_ADAPTER),
     },
     .volOptions = {
         .formatToString = virStoragePoolFormatDiskTypeToString,
     }
209
    },
210 211 212 213 214 215
    {.poolType = VIR_STORAGE_POOL_RBD,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
                   VIR_STORAGE_POOL_SOURCE_NETWORK |
                   VIR_STORAGE_POOL_SOURCE_NAME),
      },
216
      .volOptions = {
217 218 219
          .defaultFormat = VIR_STORAGE_FILE_RAW,
          .formatToString = virStoragePoolFormatDiskTypeToString,
      }
220
    },
221 222 223 224 225 226 227 228 229 230
    {.poolType = VIR_STORAGE_POOL_SHEEPDOG,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
                   VIR_STORAGE_POOL_SOURCE_NETWORK |
                   VIR_STORAGE_POOL_SOURCE_NAME),
     },
     .volOptions = {
         .defaultFormat = VIR_STORAGE_FILE_RAW,
         .formatToString = virStoragePoolFormatDiskTypeToString,
     }
231
    },
232 233 234 235
    {.poolType = VIR_STORAGE_POOL_MPATH,
     .volOptions = {
         .formatToString = virStoragePoolFormatDiskTypeToString,
     }
236
    },
237 238 239 240 241 242 243 244 245 246 247 248
    {.poolType = VIR_STORAGE_POOL_DISK,
     .poolOptions = {
         .flags = (VIR_STORAGE_POOL_SOURCE_DEVICE),
         .defaultFormat = VIR_STORAGE_POOL_DISK_UNKNOWN,
         .formatFromString = virStoragePoolFormatDiskTypeFromString,
         .formatToString = virStoragePoolFormatDiskTypeToString,
     },
     .volOptions = {
         .defaultFormat = VIR_STORAGE_VOL_DISK_NONE,
         .formatFromString = virStorageVolFormatDiskTypeFromString,
         .formatToString = virStorageVolFormatDiskTypeToString,
     },
249 250 251 252 253
    }
};


static virStoragePoolTypeInfoPtr
254 255
virStoragePoolTypeInfoLookup(int type)
{
256
    unsigned int i;
257
    for (i = 0; i < ARRAY_CARDINALITY(poolTypeInfo); i++)
258 259 260
        if (poolTypeInfo[i].poolType == type)
            return &poolTypeInfo[i];

261 262
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("missing backend for pool type %d"), type);
263 264 265 266
    return NULL;
}

static virStoragePoolOptionsPtr
267 268
virStoragePoolOptionsForPoolType(int type)
{
269 270 271 272 273 274 275
    virStoragePoolTypeInfoPtr backend = virStoragePoolTypeInfoLookup(type);
    if (backend == NULL)
        return NULL;
    return &backend->poolOptions;
}

static virStorageVolOptionsPtr
276 277
virStorageVolOptionsForPoolType(int type)
{
278 279 280 281 282 283 284
    virStoragePoolTypeInfoPtr backend = virStoragePoolTypeInfoLookup(type);
    if (backend == NULL)
        return NULL;
    return &backend->volOptions;
}


285
void
286 287
virStorageVolDefFree(virStorageVolDefPtr def)
{
288
    int i;
289 290 291 292

    if (!def)
        return;

293 294
    VIR_FREE(def->name);
    VIR_FREE(def->key);
295

296
    for (i = 0; i < def->source.nextent; i++) {
297
        VIR_FREE(def->source.extents[i].path);
298
    }
299
    VIR_FREE(def->source.extents);
300

301 302
    VIR_FREE(def->target.path);
    VIR_FREE(def->target.perms.label);
303
    VIR_FREE(def->target.timestamps);
304
    virStorageEncryptionFree(def->target.encryption);
305 306
    VIR_FREE(def->backingStore.path);
    VIR_FREE(def->backingStore.perms.label);
307
    VIR_FREE(def->backingStore.timestamps);
308
    virStorageEncryptionFree(def->backingStore.encryption);
309
    VIR_FREE(def);
310 311
}

312 313 314 315 316 317 318 319 320 321 322 323 324
static void
virStoragePoolSourceAdapterClear(virStoragePoolSourceAdapter adapter)
{
    if (adapter.type == VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST) {
        VIR_FREE(adapter.data.fchost.wwnn);
        VIR_FREE(adapter.data.fchost.wwpn);
        VIR_FREE(adapter.data.fchost.parent);
    } else if (adapter.type ==
               VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST) {
        VIR_FREE(adapter.data.name);
    }
}

325
void
326 327
virStoragePoolSourceClear(virStoragePoolSourcePtr source)
{
328 329
    int i;

330
    if (!source)
331 332
        return;

333
    for (i = 0; i < source->nhost; i++) {
334 335 336 337
        VIR_FREE(source->hosts[i].name);
    }
    VIR_FREE(source->hosts);

338
    for (i = 0; i < source->ndevice; i++) {
339 340
        VIR_FREE(source->devices[i].freeExtents);
        VIR_FREE(source->devices[i].path);
341
    }
342 343 344
    VIR_FREE(source->devices);
    VIR_FREE(source->dir);
    VIR_FREE(source->name);
345
    virStoragePoolSourceAdapterClear(source->adapter);
D
David Allan 已提交
346
    VIR_FREE(source->initiator.iqn);
347 348
    VIR_FREE(source->vendor);
    VIR_FREE(source->product);
349

350 351 352
    if (source->authType == VIR_STORAGE_POOL_AUTH_CHAP) {
        VIR_FREE(source->auth.chap.login);
        VIR_FREE(source->auth.chap.passwd);
353
    }
354 355 356 357 358

    if (source->authType == VIR_STORAGE_POOL_AUTH_CEPHX) {
        VIR_FREE(source->auth.cephx.username);
        VIR_FREE(source->auth.cephx.secret.usage);
    }
359 360
}

361 362 363 364 365 366 367
void
virStoragePoolSourceFree(virStoragePoolSourcePtr source)
{
    virStoragePoolSourceClear(source);
    VIR_FREE(source);
}

368
void
369 370
virStoragePoolDefFree(virStoragePoolDefPtr def)
{
371 372 373 374 375
    if (!def)
        return;

    VIR_FREE(def->name);

376
    virStoragePoolSourceClear(&def->source);
377

378 379 380
    VIR_FREE(def->target.path);
    VIR_FREE(def->target.perms.label);
    VIR_FREE(def);
381 382 383 384
}


void
385 386
virStoragePoolObjFree(virStoragePoolObjPtr obj)
{
387 388 389
    if (!obj)
        return;

390 391
    virStoragePoolObjClearVols(obj);

392 393
    virStoragePoolDefFree(obj->def);
    virStoragePoolDefFree(obj->newDef);
394

395 396
    VIR_FREE(obj->configFile);
    VIR_FREE(obj->autostartLink);
397 398 399

    virMutexDestroy(&obj->lock);

400
    VIR_FREE(obj);
401 402
}

403 404
void
virStoragePoolObjListFree(virStoragePoolObjListPtr pools)
405 406
{
    unsigned int i;
407
    for (i = 0; i < pools->count; i++)
408 409 410 411 412
        virStoragePoolObjFree(pools->objs[i]);
    VIR_FREE(pools->objs);
    pools->count = 0;
}

413
void
414
virStoragePoolObjRemove(virStoragePoolObjListPtr pools,
415 416
                        virStoragePoolObjPtr pool)
{
417
    unsigned int i;
418

419 420
    virStoragePoolObjUnlock(pool);

421
    for (i = 0; i < pools->count; i++) {
422
        virStoragePoolObjLock(pools->objs[i]);
423
        if (pools->objs[i] == pool) {
424
            virStoragePoolObjUnlock(pools->objs[i]);
425
            virStoragePoolObjFree(pools->objs[i]);
426

427 428 429
            if (i < (pools->count - 1))
                memmove(pools->objs + i, pools->objs + i + 1,
                        sizeof(*(pools->objs)) * (pools->count - (i + 1)));
430

431 432 433 434
            if (VIR_REALLOC_N(pools->objs, pools->count - 1) < 0) {
                ; /* Failure to reduce memory allocation isn't fatal */
            }
            pools->count--;
435

436 437
            break;
        }
438
        virStoragePoolObjUnlock(pools->objs[i]);
439
    }
440 441 442 443
}


static int
444
virStoragePoolDefParseAuthChap(xmlXPathContextPtr ctxt,
445 446
                               virStoragePoolAuthChapPtr auth)
{
447
    auth->login = virXPathString("string(./auth/@login)", ctxt);
448
    if (auth->login == NULL) {
449 450
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing auth host attribute"));
451 452 453
        return -1;
    }

454
    auth->passwd = virXPathString("string(./auth/@passwd)", ctxt);
455
    if (auth->passwd == NULL) {
456 457
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing auth passwd attribute"));
458 459 460 461 462 463
        return -1;
    }

    return 0;
}

464 465
static int
virStoragePoolDefParseAuthCephx(xmlXPathContextPtr ctxt,
466 467
                                virStoragePoolAuthCephxPtr auth)
{
468 469 470
    char *uuid = NULL;
    auth->username = virXPathString("string(./auth/@username)", ctxt);
    if (auth->username == NULL) {
471 472
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing auth username attribute"));
473 474 475 476 477 478
        return -1;
    }

    uuid = virXPathString("string(./auth/secret/@uuid)", ctxt);
    auth->secret.usage = virXPathString("string(./auth/secret/@usage)", ctxt);
    if (uuid == NULL && auth->secret.usage == NULL) {
479 480
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing auth secret uuid or usage attribute"));
481 482 483
        return -1;
    }

484 485 486 487 488 489 490 491 492 493 494 495 496 497
    if (uuid != NULL) {
        if (auth->secret.usage != NULL) {
            virReportError(VIR_ERR_XML_ERROR, "%s",
                           _("either auth secret uuid or usage expected"));
            return -1;
        }
        if (virUUIDParse(uuid, auth->secret.uuid) < 0) {
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("invalid auth secret uuid"));
            return -1;
        }
        auth->secret.uuidUsable = true;
    } else {
        auth->secret.uuidUsable = false;
498 499 500 501 502
    }

    return 0;
}

503
static int
504
virStoragePoolDefParseSource(xmlXPathContextPtr ctxt,
505 506
                             virStoragePoolSourcePtr source,
                             int pool_type,
507 508
                             xmlNodePtr node)
{
509 510 511 512 513
    int ret = -1;
    xmlNodePtr relnode, *nodeset = NULL;
    char *authType = NULL;
    int nsource, i;
    virStoragePoolOptionsPtr options;
514
    char *name = NULL;
515
    char *port = NULL;
516
    char *adapter_type = NULL;
517
    int n;
518 519 520 521 522 523 524 525

    relnode = ctxt->node;
    ctxt->node = node;

    if ((options = virStoragePoolOptionsForPoolType(pool_type)) == NULL) {
        goto cleanup;
    }

526
    source->name = virXPathString("string(./name)", ctxt);
527
    if (pool_type == VIR_STORAGE_POOL_RBD && source->name == NULL) {
528 529
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing mandatory 'name' field for RBD pool name"));
530 531
        goto cleanup;
    }
532 533

    if (options->formatFromString) {
534
        char *format = virXPathString("string(./format/@type)", ctxt);
535 536 537 538 539 540
        if (format == NULL)
            source->format = options->defaultFormat;
        else
            source->format = options->formatFromString(format);

        if (source->format < 0) {
541 542
            virReportError(VIR_ERR_XML_ERROR,
                           _("unknown pool format type %s"), format);
543 544 545 546 547 548
            VIR_FREE(format);
            goto cleanup;
        }
        VIR_FREE(format);
    }

549 550 551
    if ((n = virXPathNodeSet("./host", ctxt, &nodeset)) < 0)
        goto cleanup;
    source->nhost = n;
552 553 554 555

    if (source->nhost) {
        if (VIR_ALLOC_N(source->hosts, source->nhost) < 0) {
            virReportOOMError();
556 557 558
            goto cleanup;
        }

559
        for (i = 0; i < source->nhost; i++) {
560 561
            name = virXMLPropString(nodeset[i], "name");
            if (name == NULL) {
562 563
                virReportError(VIR_ERR_XML_ERROR,
                               "%s", _("missing storage pool host name"));
564 565 566 567 568 569 570
                goto cleanup;
            }
            source->hosts[i].name = name;

            port = virXMLPropString(nodeset[i], "port");
            if (port) {
                if (virStrToLong_i(port, NULL, 10, &source->hosts[i].port) < 0) {
571 572 573
                    virReportError(VIR_ERR_XML_ERROR,
                                   _("Invalid port number: %s"),
                                   port);
574 575 576 577 578
                    goto cleanup;
                }
            }
        }
    }
579

580
    VIR_FREE(nodeset);
581
    source->initiator.iqn = virXPathString("string(./initiator/iqn/@name)", ctxt);
582

583
    nsource = virXPathNodeSet("./device", ctxt, &nodeset);
584 585 586
    if (nsource < 0)
        goto cleanup;

587 588 589
    if (nsource > 0) {
        if (VIR_ALLOC_N(source->devices, nsource) < 0) {
            VIR_FREE(nodeset);
590
            virReportOOMError();
591 592 593
            goto cleanup;
        }

594
        for (i = 0; i < nsource; i++) {
595
            char *path = virXMLPropString(nodeset[i], "path");
596 597
            if (path == NULL) {
                VIR_FREE(nodeset);
598 599
                virReportError(VIR_ERR_XML_ERROR,
                               "%s", _("missing storage pool source device path"));
600 601
                goto cleanup;
            }
602
            source->devices[i].path = path;
603 604 605 606
        }
        source->ndevice = nsource;
    }

607
    source->dir = virXPathString("string(./dir/@path)", ctxt);
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657

    if ((adapter_type = virXPathString("string(./adapter/@type)", ctxt))) {
        if ((source->adapter.type =
             virStoragePoolSourceAdapterTypeTypeFromString(adapter_type)) <= 0) {
            virReportError(VIR_ERR_XML_ERROR,
                           _("Unknown pool adapter type '%s'"),
                           adapter_type);
            goto cleanup;
        }

        if (source->adapter.type ==
            VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST) {
            source->adapter.data.fchost.parent =
                virXPathString("string(./adapter/@parent)", ctxt);
            source->adapter.data.fchost.wwnn =
                virXPathString("string(./adapter/@wwnn)", ctxt);
            source->adapter.data.fchost.wwpn =
                virXPathString("string(./adapter/@wwpn)", ctxt);
        } else if (source->adapter.type ==
                   VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST) {
            source->adapter.data.name =
                virXPathString("string(./adapter/@name)", ctxt);
        }
    } else {
        char *wwnn = NULL;
        char *wwpn = NULL;
        char *parent = NULL;

        wwnn = virXPathString("string(./adapter/@wwnn)", ctxt);
        wwpn = virXPathString("string(./adapter/@wwpn)", ctxt);
        parent = virXPathString("string(./adapter/@parent)", ctxt);

        if (wwnn || wwpn || parent) {
            VIR_FREE(wwnn);
            VIR_FREE(wwpn);
            VIR_FREE(parent);
            virReportError(VIR_ERR_XML_ERROR, "%s",
                           _("Use of 'wwnn', 'wwpn', and 'parent' attributes "
                             "requires the 'fc_host' adapter 'type'"));
            goto cleanup;
        }

        /* To keep back-compat, 'type' is not required to specify
         * for scsi_host adapter.
         */
        if ((source->adapter.data.name =
             virXPathString("string(./adapter/@name)", ctxt)))
            source->adapter.type =
                VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST;
    }
658

659
    authType = virXPathString("string(./auth/@type)", ctxt);
660 661 662 663 664
    if (authType == NULL) {
        source->authType = VIR_STORAGE_POOL_AUTH_NONE;
    } else {
        if (STREQ(authType, "chap")) {
            source->authType = VIR_STORAGE_POOL_AUTH_CHAP;
665 666
        } else if (STREQ(authType, "ceph")) {
            source->authType = VIR_STORAGE_POOL_AUTH_CEPHX;
667
        } else {
668 669 670
            virReportError(VIR_ERR_XML_ERROR,
                           _("unknown auth type '%s'"),
                           (const char *)authType);
671 672 673 674 675
            goto cleanup;
        }
    }

    if (source->authType == VIR_STORAGE_POOL_AUTH_CHAP) {
676
        if (virStoragePoolDefParseAuthChap(ctxt, &source->auth.chap) < 0)
677 678 679
            goto cleanup;
    }

680 681 682 683 684
    if (source->authType == VIR_STORAGE_POOL_AUTH_CEPHX) {
        if (virStoragePoolDefParseAuthCephx(ctxt, &source->auth.cephx) < 0)
            goto cleanup;
    }

685 686 687
    source->vendor = virXPathString("string(./vendor/@name)", ctxt);
    source->product = virXPathString("string(./product/@name)", ctxt);

688 689 690 691
    ret = 0;
cleanup:
    ctxt->node = relnode;

692
    VIR_FREE(port);
693 694
    VIR_FREE(authType);
    VIR_FREE(nodeset);
695
    VIR_FREE(adapter_type);
696 697
    return ret;
}
698

699
virStoragePoolSourcePtr
700
virStoragePoolDefParseSourceString(const char *srcSpec,
701 702 703 704 705 706 707
                                   int pool_type)
{
    xmlDocPtr doc = NULL;
    xmlNodePtr node = NULL;
    xmlXPathContextPtr xpath_ctxt = NULL;
    virStoragePoolSourcePtr def = NULL, ret = NULL;

708 709 710
    if (!(doc = virXMLParseStringCtxt(srcSpec,
                                      _("(storage_source_specification)"),
                                      &xpath_ctxt)))
711 712 713
        goto cleanup;

    if (VIR_ALLOC(def) < 0) {
714
        virReportOOMError();
715 716 717
        goto cleanup;
    }

718
    if (!(node = virXPathNode("/source", xpath_ctxt))) {
719 720
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("root element was not source"));
721 722 723
        goto cleanup;
    }

724
    if (virStoragePoolDefParseSource(xpath_ctxt, def, pool_type,
725 726 727 728 729 730
                                     node) < 0)
        goto cleanup;

    ret = def;
    def = NULL;
cleanup:
731
    virStoragePoolSourceFree(def);
732 733 734 735 736
    xmlFreeDoc(doc);
    xmlXPathFreeContext(xpath_ctxt);

    return ret;
}
737

738
static int
739
virStorageDefParsePerms(xmlXPathContextPtr ctxt,
740 741
                        virStoragePermsPtr perms,
                        const char *permxpath,
742 743
                        int defaultmode)
{
744 745
    char *mode;
    long v;
746 747 748
    int ret = -1;
    xmlNodePtr relnode;
    xmlNodePtr node;
749

750
    node = virXPathNode(permxpath, ctxt);
751 752 753
    if (node == NULL) {
        /* Set default values if there is not <permissions> element */
        perms->mode = defaultmode;
P
Philipp Hahn 已提交
754 755
        perms->uid = (uid_t) -1;
        perms->gid = (gid_t) -1;
756 757 758 759 760 761 762
        perms->label = NULL;
        return 0;
    }

    relnode = ctxt->node;
    ctxt->node = node;

763
    mode = virXPathString("string(./mode)", ctxt);
764
    if (!mode) {
765
        perms->mode = defaultmode;
766
    } else {
767 768 769
        int tmp;

        if (virStrToLong_i(mode, NULL, 8, &tmp) < 0 || (tmp & ~0777)) {
770
            VIR_FREE(mode);
771 772
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("malformed octal mode"));
773
            goto error;
774
        }
775
        perms->mode = tmp;
776
        VIR_FREE(mode);
777 778
    }

779
    if (virXPathNode("./owner", ctxt) == NULL) {
P
Philipp Hahn 已提交
780
        perms->uid = (uid_t) -1;
781
    } else {
782
        if (virXPathLong("number(./owner)", ctxt, &v) < 0) {
783 784
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("malformed owner element"));
785
            goto error;
786 787 788 789
        }
        perms->uid = (int)v;
    }

790
    if (virXPathNode("./group", ctxt) == NULL) {
P
Philipp Hahn 已提交
791
        perms->gid = (gid_t) -1;
792
    } else {
793
        if (virXPathLong("number(./group)", ctxt, &v) < 0) {
794 795
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("malformed group element"));
796
            goto error;
797 798 799 800 801
        }
        perms->gid = (int)v;
    }

    /* NB, we're ignoring missing labels here - they'll simply inherit */
802
    perms->label = virXPathString("string(./label)", ctxt);
803

804 805 806 807
    ret = 0;
error:
    ctxt->node = relnode;
    return ret;
808 809 810
}

static virStoragePoolDefPtr
811 812
virStoragePoolDefParseXML(xmlXPathContextPtr ctxt)
{
813
    virStoragePoolOptionsPtr options;
814
    virStoragePoolDefPtr ret;
815
    xmlNodePtr source_node;
816
    char *type = NULL;
817
    char *uuid = NULL;
818
    char *tmppath;
819

820
    if (VIR_ALLOC(ret) < 0) {
821
        virReportOOMError();
822
        return NULL;
823
    }
824

825
    type = virXPathString("string(./@type)", ctxt);
826
    if ((ret->type = virStoragePoolTypeFromString((const char *)type)) < 0) {
827 828
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown storage pool type %s"), (const char*)type);
829
        goto cleanup;
830 831
    }

832 833 834
    xmlFree(type);
    type = NULL;

835
    if ((options = virStoragePoolOptionsForPoolType(ret->type)) == NULL) {
836 837 838
        goto cleanup;
    }

839
    source_node = virXPathNode("./source", ctxt);
840
    if (source_node) {
841
        if (virStoragePoolDefParseSource(ctxt, &ret->source, ret->type,
842 843 844 845
                                         source_node) < 0)
            goto cleanup;
    }

846
    ret->name = virXPathString("string(./name)", ctxt);
847
    if (ret->name == NULL &&
848
        options->flags & VIR_STORAGE_POOL_SOURCE_NAME)
849
        ret->name = ret->source.name;
850
    if (ret->name == NULL) {
851 852
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing pool source name element"));
853 854 855
        goto cleanup;
    }

856
    uuid = virXPathString("string(./uuid)", ctxt);
857 858
    if (uuid == NULL) {
        if (virUUIDGenerate(ret->uuid) < 0) {
859 860
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("unable to generate uuid"));
861 862 863 864
            goto cleanup;
        }
    } else {
        if (virUUIDParse(uuid, ret->uuid) < 0) {
865 866
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("malformed uuid element"));
867 868
            goto cleanup;
        }
869
        VIR_FREE(uuid);
870 871
    }

872
    if (options->flags & VIR_STORAGE_POOL_SOURCE_HOST) {
873
        if (!ret->source.nhost) {
874 875 876
            virReportError(VIR_ERR_XML_ERROR,
                           "%s",
                           _("missing storage pool source host name"));
877 878 879 880
            goto cleanup;
        }
    }

881
    if (options->flags & VIR_STORAGE_POOL_SOURCE_DIR) {
882
        if (!ret->source.dir) {
883 884
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("missing storage pool source path"));
885 886 887
            goto cleanup;
        }
    }
888
    if (options->flags & VIR_STORAGE_POOL_SOURCE_NAME) {
889 890
        if (ret->source.name == NULL) {
            /* source name defaults to pool name */
891
            if (VIR_STRDUP(ret->source.name, ret->name) < 0)
892
                goto cleanup;
893 894
        }
    }
895

896
    if (options->flags & VIR_STORAGE_POOL_SOURCE_ADAPTER) {
897 898 899
        if (!ret->source.adapter.type) {
            virReportError(VIR_ERR_XML_ERROR, "%s",
                           _("missing storage pool source adapter"));
900 901
            goto cleanup;
        }
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923

        if (ret->source.adapter.type ==
            VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST) {
            if (!ret->source.adapter.data.fchost.wwnn ||
                !ret->source.adapter.data.fchost.wwpn) {
                virReportError(VIR_ERR_XML_ERROR, "%s",
                               _("'wwnn' and 'wwpn' must be specified for adapter "
                                 "type 'fchost'"));
                goto cleanup;
            }

            if (!virValidateWWN(ret->source.adapter.data.fchost.wwnn) ||
                !virValidateWWN(ret->source.adapter.data.fchost.wwpn))
                goto cleanup;
        } else if (ret->source.adapter.type ==
                   VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST) {
            if (!ret->source.adapter.data.name) {
                virReportError(VIR_ERR_XML_ERROR,
                               "%s", _("missing storage pool source adapter name"));
                goto cleanup;
            }
        }
924
    }
925

926 927 928
    /* If DEVICE is the only source type, then its required */
    if (options->flags == VIR_STORAGE_POOL_SOURCE_DEVICE) {
        if (!ret->source.ndevice) {
929 930
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("missing storage pool source device name"));
931 932 933 934
            goto cleanup;
        }
    }

935 936 937 938
    /* When we are working with a virtual disk we can skip the target
     * path and permissions */
    if (!(options->flags & VIR_STORAGE_POOL_SOURCE_NETWORK)) {
        if ((tmppath = virXPathString("string(./target/path)", ctxt)) == NULL) {
939 940
            virReportError(VIR_ERR_XML_ERROR,
                           "%s", _("missing storage pool target path"));
941 942 943 944 945 946
            goto cleanup;
        }
        ret->target.path = virFileSanitizePath(tmppath);
        VIR_FREE(tmppath);
        if (!ret->target.path)
            goto cleanup;
947

948
        if (virStorageDefParsePerms(ctxt, &ret->target.perms,
949 950
                                    "./target/permissions",
                                    DEFAULT_POOL_PERM_MODE) < 0)
951 952
            goto cleanup;
    }
953 954 955

    return ret;

956
cleanup:
957
    VIR_FREE(uuid);
958
    xmlFree(type);
959 960 961 962 963
    virStoragePoolDefFree(ret);
    return NULL;
}

virStoragePoolDefPtr
964
virStoragePoolDefParseNode(xmlDocPtr xml,
965 966
                           xmlNodePtr root)
{
967 968 969 970
    xmlXPathContextPtr ctxt = NULL;
    virStoragePoolDefPtr def = NULL;

    if (STRNEQ((const char *)root->name, "pool")) {
971 972
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("unknown root element for storage pool"));
973 974 975 976 977
        goto cleanup;
    }

    ctxt = xmlXPathNewContext(xml);
    if (ctxt == NULL) {
978
        virReportOOMError();
979 980 981 982
        goto cleanup;
    }

    ctxt->node = root;
983
    def = virStoragePoolDefParseXML(ctxt);
984 985 986 987 988 989
cleanup:
    xmlXPathFreeContext(ctxt);
    return def;
}

static virStoragePoolDefPtr
990
virStoragePoolDefParse(const char *xmlStr,
991 992
                       const char *filename)
{
993
    virStoragePoolDefPtr ret = NULL;
J
Jiri Denemark 已提交
994
    xmlDocPtr xml;
995

996
    if ((xml = virXMLParse(filename, xmlStr, _("(storage_pool_definition)")))) {
J
Jiri Denemark 已提交
997 998
        ret = virStoragePoolDefParseNode(xml, xmlDocGetRootElement(xml));
        xmlFreeDoc(xml);
999 1000
    }

1001 1002 1003
    return ret;
}

1004
virStoragePoolDefPtr
1005
virStoragePoolDefParseString(const char *xmlStr)
1006
{
1007
    return virStoragePoolDefParse(xmlStr, NULL);
1008 1009 1010
}

virStoragePoolDefPtr
1011
virStoragePoolDefParseFile(const char *filename)
1012
{
1013
    return virStoragePoolDefParse(NULL, filename);
1014 1015
}

1016
static int
1017
virStoragePoolSourceFormat(virBufferPtr buf,
1018
                           virStoragePoolOptionsPtr options,
1019 1020 1021
                           virStoragePoolSourcePtr src)
{
    int i, j;
1022
    char uuid[VIR_UUID_STRING_BUFLEN];
1023 1024

    virBufferAddLit(buf,"  <source>\n");
1025 1026
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_HOST) && src->nhost) {
        for (i = 0; i < src->nhost; i++) {
E
Eric Blake 已提交
1027
            virBufferAsprintf(buf, "    <host name='%s'", src->hosts[i].name);
1028 1029 1030 1031
            if (src->hosts[i].port)
                virBufferAsprintf(buf, " port='%d'", src->hosts[i].port);
            virBufferAddLit(buf, "/>\n");
        }
1032
    }
1033

1034
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_DEVICE) &&
1035
        src->ndevice) {
1036
        for (i = 0; i < src->ndevice; i++) {
1037
            if (src->devices[i].nfreeExtent) {
1038
                virBufferAsprintf(buf,"    <device path='%s'>\n",
1039
                                  src->devices[i].path);
1040
                for (j = 0; j < src->devices[i].nfreeExtent; j++) {
1041
                    virBufferAsprintf(buf, "    <freeExtent start='%llu' end='%llu'/>\n",
1042 1043 1044 1045
                                      src->devices[i].freeExtents[j].start,
                                      src->devices[i].freeExtents[j].end);
                }
                virBufferAddLit(buf,"    </device>\n");
1046
            } else {
1047
                virBufferAsprintf(buf, "    <device path='%s'/>\n",
1048
                                  src->devices[i].path);
1049
            }
1050 1051
        }
    }
1052

1053
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_DIR) &&
1054
        src->dir)
1055
        virBufferAsprintf(buf,"    <dir path='%s'/>\n", src->dir);
1056

1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_ADAPTER)) {
        if (src->adapter.type == VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST ||
            src->adapter.type == VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST)
            virBufferAsprintf(buf, "    <adapter type='%s'",
                              virStoragePoolSourceAdapterTypeTypeToString(src->adapter.type));

        if (src->adapter.type == VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST) {
            virBufferEscapeString(buf, " parent='%s'",
                                  src->adapter.data.fchost.parent);
            virBufferAsprintf(buf," wwnn='%s' wwpn='%s'/>\n",
                              src->adapter.data.fchost.wwnn,
                              src->adapter.data.fchost.wwpn);
        } else if (src->adapter.type ==
                 VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST) {
            virBufferAsprintf(buf," name='%s'/>\n", src->adapter.data.name);
        }
    }
1074

1075
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_NAME) &&
1076
        src->name)
1077
        virBufferAsprintf(buf,"    <name>%s</name>\n", src->name);
1078

D
David Allan 已提交
1079 1080 1081 1082 1083 1084 1085
    if ((options->flags & VIR_STORAGE_POOL_SOURCE_INITIATOR_IQN) &&
        src->initiator.iqn) {
        virBufferAddLit(buf,"    <initiator>\n");
        virBufferEscapeString(buf,"      <iqn name='%s'/>\n", src->initiator.iqn);
        virBufferAddLit(buf,"    </initiator>\n");
    }

1086 1087 1088
    if (options->formatToString) {
        const char *format = (options->formatToString)(src->format);
        if (!format) {
1089 1090 1091
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown pool format number %d"),
                           src->format);
1092 1093
            return -1;
        }
1094
        virBufferAsprintf(buf,"    <format type='%s'/>\n", format);
1095 1096 1097
    }

    if (src->authType == VIR_STORAGE_POOL_AUTH_CHAP)
1098
        virBufferAsprintf(buf,"    <auth type='chap' login='%s' passwd='%s'/>\n",
1099 1100
                          src->auth.chap.login,
                          src->auth.chap.passwd);
1101

1102 1103 1104 1105
    if (src->authType == VIR_STORAGE_POOL_AUTH_CEPHX) {
        virBufferAsprintf(buf,"    <auth username='%s' type='ceph'>\n",
                          src->auth.cephx.username);

1106
        virBufferAddLit(buf,"      <secret");
1107
        if (src->auth.cephx.secret.uuidUsable) {
1108 1109 1110 1111 1112 1113 1114
            virUUIDFormat(src->auth.cephx.secret.uuid, uuid);
            virBufferAsprintf(buf," uuid='%s'", uuid);
        }

        if (src->auth.cephx.secret.usage != NULL) {
            virBufferAsprintf(buf," usage='%s'", src->auth.cephx.secret.usage);
        }
1115
        virBufferAddLit(buf,"/>\n");
1116

1117
        virBufferAddLit(buf,"    </auth>\n");
1118 1119
    }

1120 1121 1122 1123 1124 1125 1126 1127
    if (src->vendor != NULL) {
        virBufferEscapeString(buf,"    <vendor name='%s'/>\n", src->vendor);
    }

    if (src->product != NULL) {
        virBufferEscapeString(buf,"    <product name='%s'/>\n", src->product);
    }

1128 1129 1130 1131 1132
    virBufferAddLit(buf,"  </source>\n");

    return 0;
}

1133 1134

char *
1135 1136
virStoragePoolDefFormat(virStoragePoolDefPtr def)
{
1137
    virStoragePoolOptionsPtr options;
1138
    virBuffer buf = VIR_BUFFER_INITIALIZER;
1139 1140 1141
    const char *type;
    char uuid[VIR_UUID_STRING_BUFLEN];

1142
    options = virStoragePoolOptionsForPoolType(def->type);
1143 1144 1145
    if (options == NULL)
        return NULL;

1146
    type = virStoragePoolTypeToString(def->type);
1147
    if (!type) {
1148 1149
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("unexpected pool type"));
1150 1151
        goto cleanup;
    }
1152 1153
    virBufferAsprintf(&buf, "<pool type='%s'>\n", type);
    virBufferAsprintf(&buf,"  <name>%s</name>\n", def->name);
1154 1155

    virUUIDFormat(def->uuid, uuid);
1156
    virBufferAsprintf(&buf,"  <uuid>%s</uuid>\n", uuid);
1157

E
Eric Blake 已提交
1158
    virBufferAsprintf(&buf,"  <capacity unit='bytes'>%llu</capacity>\n",
1159
                      def->capacity);
E
Eric Blake 已提交
1160
    virBufferAsprintf(&buf,"  <allocation unit='bytes'>%llu</allocation>\n",
1161
                      def->allocation);
E
Eric Blake 已提交
1162
    virBufferAsprintf(&buf,"  <available unit='bytes'>%llu</available>\n",
1163
                      def->available);
1164

1165
    if (virStoragePoolSourceFormat(&buf, options, &def->source) < 0)
1166
        goto cleanup;
1167

1168 1169 1170 1171
    /* RBD and Sheepdog devices are not local block devs nor files, so it
     * doesn't have a target */
    if (def->type != VIR_STORAGE_POOL_RBD &&
        def->type != VIR_STORAGE_POOL_SHEEPDOG) {
1172
        virBufferAddLit(&buf,"  <target>\n");
1173

1174 1175
        if (def->target.path)
            virBufferAsprintf(&buf,"    <path>%s</path>\n", def->target.path);
1176

1177 1178 1179
        virBufferAddLit(&buf,"    <permissions>\n");
        virBufferAsprintf(&buf,"      <mode>0%o</mode>\n",
                          def->target.perms.mode);
1180 1181 1182 1183
        virBufferAsprintf(&buf,"      <owner>%d</owner>\n",
                          (int) def->target.perms.uid);
        virBufferAsprintf(&buf,"      <group>%d</group>\n",
                          (int) def->target.perms.gid);
1184

1185 1186 1187
        if (def->target.perms.label)
            virBufferAsprintf(&buf,"      <label>%s</label>\n",
                            def->target.perms.label);
1188

1189 1190 1191
        virBufferAddLit(&buf,"    </permissions>\n");
        virBufferAddLit(&buf,"  </target>\n");
    }
1192
    virBufferAddLit(&buf,"</pool>\n");
1193

1194
    if (virBufferError(&buf))
1195 1196
        goto no_memory;

1197
    return virBufferContentAndReset(&buf);
1198

1199
no_memory:
1200
    virReportOOMError();
1201
cleanup:
1202
    virBufferFreeAndReset(&buf);
1203 1204 1205 1206 1207
    return NULL;
}


static int
1208
virStorageSize(const char *unit,
1209
               const char *val,
1210 1211 1212
               unsigned long long *ret)
{
    if (virStrToLong_ull(val, NULL, 10, ret) < 0) {
1213 1214
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("malformed capacity element"));
1215 1216
        return -1;
    }
1217 1218 1219 1220
    /* off_t is signed, so you cannot create a file larger than 2**63
     * bytes in the first place.  */
    if (virScaleInteger(ret, unit, 1, LLONG_MAX) < 0)
        return -1;
1221 1222 1223 1224 1225

    return 0;
}

static virStorageVolDefPtr
1226
virStorageVolDefParseXML(virStoragePoolDefPtr pool,
1227 1228
                         xmlXPathContextPtr ctxt)
{
1229
    virStorageVolDefPtr ret;
1230
    virStorageVolOptionsPtr options;
1231 1232 1233
    char *allocation = NULL;
    char *capacity = NULL;
    char *unit = NULL;
1234
    xmlNodePtr node;
1235

1236
    options = virStorageVolOptionsForPoolType(pool->type);
1237 1238 1239
    if (options == NULL)
        return NULL;

1240
    if (VIR_ALLOC(ret) < 0) {
1241
        virReportOOMError();
1242
        return NULL;
1243
    }
1244

1245
    ret->name = virXPathString("string(./name)", ctxt);
1246
    if (ret->name == NULL) {
1247 1248
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing volume name element"));
1249 1250 1251
        goto cleanup;
    }

R
Richard W.M. Jones 已提交
1252
    /* Auto-generated so deliberately ignore */
1253
    /* ret->key = virXPathString("string(./key)", ctxt); */
1254

1255 1256
    capacity = virXPathString("string(./capacity)", ctxt);
    unit = virXPathString("string(./capacity/@unit)", ctxt);
1257
    if (capacity == NULL) {
1258 1259
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("missing capacity element"));
1260 1261
        goto cleanup;
    }
1262
    if (virStorageSize(unit, capacity, &ret->capacity) < 0)
1263
        goto cleanup;
1264 1265
    VIR_FREE(capacity);
    VIR_FREE(unit);
1266

1267
    allocation = virXPathString("string(./allocation)", ctxt);
1268
    if (allocation) {
1269
        unit = virXPathString("string(./allocation/@unit)", ctxt);
1270
        if (virStorageSize(unit, allocation, &ret->allocation) < 0)
1271
            goto cleanup;
1272 1273
        VIR_FREE(allocation);
        VIR_FREE(unit);
1274 1275 1276 1277
    } else {
        ret->allocation = ret->capacity;
    }

1278
    ret->target.path = virXPathString("string(./target/path)", ctxt);
1279
    if (options->formatFromString) {
1280
        char *format = virXPathString("string(./target/format/@type)", ctxt);
1281 1282 1283 1284 1285 1286
        if (format == NULL)
            ret->target.format = options->defaultFormat;
        else
            ret->target.format = (options->formatFromString)(format);

        if (ret->target.format < 0) {
1287 1288
            virReportError(VIR_ERR_XML_ERROR,
                           _("unknown volume format type %s"), format);
1289
            VIR_FREE(format);
1290 1291
            goto cleanup;
        }
1292
        VIR_FREE(format);
1293 1294
    }

1295
    if (virStorageDefParsePerms(ctxt, &ret->target.perms,
1296 1297
                                "./target/permissions",
                                DEFAULT_VOL_PERM_MODE) < 0)
1298 1299
        goto cleanup;

1300
    node = virXPathNode("./target/encryption", ctxt);
1301
    if (node != NULL) {
1302
        ret->target.encryption = virStorageEncryptionParseNode(ctxt->doc,
1303 1304 1305 1306 1307
                                                               node);
        if (ret->target.encryption == NULL)
            goto cleanup;
    }

1308
    ret->backingStore.path = virXPathString("string(./backingStore/path)", ctxt);
1309
    if (options->formatFromString) {
1310
        char *format = virXPathString("string(./backingStore/format/@type)", ctxt);
1311 1312 1313 1314 1315 1316
        if (format == NULL)
            ret->backingStore.format = options->defaultFormat;
        else
            ret->backingStore.format = (options->formatFromString)(format);

        if (ret->backingStore.format < 0) {
1317 1318
            virReportError(VIR_ERR_XML_ERROR,
                           _("unknown volume format type %s"), format);
1319 1320 1321 1322 1323 1324
            VIR_FREE(format);
            goto cleanup;
        }
        VIR_FREE(format);
    }

1325
    if (virStorageDefParsePerms(ctxt, &ret->backingStore.perms,
1326 1327
                                "./backingStore/permissions",
                                DEFAULT_VOL_PERM_MODE) < 0)
1328 1329
        goto cleanup;

1330 1331
    return ret;

1332
cleanup:
1333 1334 1335
    VIR_FREE(allocation);
    VIR_FREE(capacity);
    VIR_FREE(unit);
1336 1337 1338 1339 1340
    virStorageVolDefFree(ret);
    return NULL;
}

virStorageVolDefPtr
1341
virStorageVolDefParseNode(virStoragePoolDefPtr pool,
1342
                          xmlDocPtr xml,
1343 1344
                          xmlNodePtr root)
{
1345 1346 1347 1348
    xmlXPathContextPtr ctxt = NULL;
    virStorageVolDefPtr def = NULL;

    if (STRNEQ((const char *)root->name, "volume")) {
1349 1350
        virReportError(VIR_ERR_XML_ERROR,
                       "%s", _("unknown root element for storage vol"));
1351 1352 1353 1354 1355
        goto cleanup;
    }

    ctxt = xmlXPathNewContext(xml);
    if (ctxt == NULL) {
1356
        virReportOOMError();
1357 1358 1359 1360
        goto cleanup;
    }

    ctxt->node = root;
1361
    def = virStorageVolDefParseXML(pool, ctxt);
1362 1363 1364 1365 1366 1367
cleanup:
    xmlXPathFreeContext(ctxt);
    return def;
}

static virStorageVolDefPtr
1368
virStorageVolDefParse(virStoragePoolDefPtr pool,
1369
                      const char *xmlStr,
1370 1371
                      const char *filename)
{
1372
    virStorageVolDefPtr ret = NULL;
J
Jiri Denemark 已提交
1373
    xmlDocPtr xml;
1374

1375
    if ((xml = virXMLParse(filename, xmlStr, _("(storage_volume_definition)")))) {
J
Jiri Denemark 已提交
1376 1377
        ret = virStorageVolDefParseNode(pool, xml, xmlDocGetRootElement(xml));
        xmlFreeDoc(xml);
1378 1379 1380 1381 1382
    }

    return ret;
}

1383
virStorageVolDefPtr
1384
virStorageVolDefParseString(virStoragePoolDefPtr pool,
1385 1386
                            const char *xmlStr)
{
1387
    return virStorageVolDefParse(pool, xmlStr, NULL);
1388 1389 1390
}

virStorageVolDefPtr
1391
virStorageVolDefParseFile(virStoragePoolDefPtr pool,
1392 1393
                          const char *filename)
{
1394
    return virStorageVolDefParse(pool, NULL, filename);
1395
}
1396

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
static void
virStorageVolTimestampFormat(virBufferPtr buf, const char *name,
                             struct timespec *ts)
{
    if (ts->tv_nsec < 0)
        return;
    virBufferAsprintf(buf, "      <%s>%llu", name,
                      (unsigned long long) ts->tv_sec);
    if (ts->tv_nsec)
       virBufferAsprintf(buf, ".%09ld", ts->tv_nsec);
    virBufferAsprintf(buf, "</%s>\n", name);
}

1410
static int
1411
virStorageVolTargetDefFormat(virStorageVolOptionsPtr options,
1412 1413 1414
                             virBufferPtr buf,
                             virStorageVolTargetPtr def,
                             const char *type) {
1415
    virBufferAsprintf(buf, "  <%s>\n", type);
1416 1417

    if (def->path)
1418
        virBufferAsprintf(buf,"    <path>%s</path>\n", def->path);
1419 1420 1421 1422

    if (options->formatToString) {
        const char *format = (options->formatToString)(def->format);
        if (!format) {
1423 1424 1425
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown volume format number %d"),
                           def->format);
1426 1427
            return -1;
        }
1428
        virBufferAsprintf(buf,"    <format type='%s'/>\n", format);
1429 1430 1431
    }

    virBufferAddLit(buf,"    <permissions>\n");
1432
    virBufferAsprintf(buf,"      <mode>0%o</mode>\n",
1433
                      def->perms.mode);
E
Eric Blake 已提交
1434 1435 1436 1437
    virBufferAsprintf(buf,"      <owner>%u</owner>\n",
                      (unsigned int) def->perms.uid);
    virBufferAsprintf(buf,"      <group>%u</group>\n",
                      (unsigned int) def->perms.gid);
1438 1439 1440


    if (def->perms.label)
1441
        virBufferAsprintf(buf,"      <label>%s</label>\n",
1442 1443 1444 1445
                          def->perms.label);

    virBufferAddLit(buf,"    </permissions>\n");

1446 1447 1448 1449 1450 1451 1452 1453 1454
    if (def->timestamps) {
        virBufferAddLit(buf, "    <timestamps>\n");
        virStorageVolTimestampFormat(buf, "atime", &def->timestamps->atime);
        virStorageVolTimestampFormat(buf, "mtime", &def->timestamps->mtime);
        virStorageVolTimestampFormat(buf, "ctime", &def->timestamps->ctime);
        virStorageVolTimestampFormat(buf, "btime", &def->timestamps->btime);
        virBufferAddLit(buf, "    </timestamps>\n");
    }

1455 1456 1457 1458 1459 1460
    if (def->encryption) {
        virBufferAdjustIndent(buf, 4);
        if (virStorageEncryptionFormat(buf, def->encryption) < 0)
            return -1;
        virBufferAdjustIndent(buf, -4);
    }
1461

1462
    virBufferAsprintf(buf, "  </%s>\n", type);
1463 1464 1465

    return 0;
}
1466 1467

char *
1468
virStorageVolDefFormat(virStoragePoolDefPtr pool,
1469 1470
                       virStorageVolDefPtr def)
{
1471
    virStorageVolOptionsPtr options;
1472
    virBuffer buf = VIR_BUFFER_INITIALIZER;
1473

1474
    options = virStorageVolOptionsForPoolType(pool->type);
1475 1476 1477
    if (options == NULL)
        return NULL;

1478
    virBufferAddLit(&buf, "<volume>\n");
1479
    virBufferAsprintf(&buf,"  <name>%s</name>\n", def->name);
1480
    virBufferAsprintf(&buf,"  <key>%s</key>\n", def->key ? def->key : "(null)");
1481
    virBufferAddLit(&buf, "  <source>\n");
1482 1483 1484 1485

    if (def->source.nextent) {
        int i;
        const char *thispath = NULL;
1486
        for (i = 0; i < def->source.nextent; i++) {
1487 1488 1489
            if (thispath == NULL ||
                STRNEQ(thispath, def->source.extents[i].path)) {
                if (thispath != NULL)
1490 1491
                    virBufferAddLit(&buf, "    </device>\n");

1492
                virBufferAsprintf(&buf, "    <device path='%s'>\n",
1493
                                  def->source.extents[i].path);
1494 1495
            }

1496
            virBufferAsprintf(&buf,
1497 1498 1499
                              "      <extent start='%llu' end='%llu'/>\n",
                              def->source.extents[i].start,
                              def->source.extents[i].end);
1500 1501 1502
            thispath = def->source.extents[i].path;
        }
        if (thispath != NULL)
1503
            virBufferAddLit(&buf, "    </device>\n");
1504
    }
1505
    virBufferAddLit(&buf, "  </source>\n");
1506

E
Eric Blake 已提交
1507
    virBufferAsprintf(&buf,"  <capacity unit='bytes'>%llu</capacity>\n",
1508
                      def->capacity);
E
Eric Blake 已提交
1509
    virBufferAsprintf(&buf,"  <allocation unit='bytes'>%llu</allocation>\n",
1510
                      def->allocation);
1511

1512
    if (virStorageVolTargetDefFormat(options, &buf,
1513 1514
                                     &def->target, "target") < 0)
        goto cleanup;
1515

1516
    if (def->backingStore.path &&
1517
        virStorageVolTargetDefFormat(options, &buf,
1518 1519
                                     &def->backingStore, "backingStore") < 0)
        goto cleanup;
1520 1521

    virBufferAddLit(&buf,"</volume>\n");
1522

1523
    if (virBufferError(&buf))
1524 1525
        goto no_memory;

1526
    return virBufferContentAndReset(&buf);
1527

1528
no_memory:
1529
    virReportOOMError();
1530
cleanup:
1531
    virBufferFreeAndReset(&buf);
1532 1533 1534 1535 1536
    return NULL;
}


virStoragePoolObjPtr
1537
virStoragePoolObjFindByUUID(virStoragePoolObjListPtr pools,
1538 1539
                            const unsigned char *uuid)
{
1540
    unsigned int i;
1541

1542
    for (i = 0; i < pools->count; i++) {
1543
        virStoragePoolObjLock(pools->objs[i]);
1544 1545
        if (!memcmp(pools->objs[i]->def->uuid, uuid, VIR_UUID_BUFLEN))
            return pools->objs[i];
1546 1547
        virStoragePoolObjUnlock(pools->objs[i]);
    }
1548 1549 1550 1551 1552

    return NULL;
}

virStoragePoolObjPtr
1553
virStoragePoolObjFindByName(virStoragePoolObjListPtr pools,
1554 1555
                            const char *name)
{
1556
    unsigned int i;
1557

1558
    for (i = 0; i < pools->count; i++) {
1559
        virStoragePoolObjLock(pools->objs[i]);
1560 1561
        if (STREQ(pools->objs[i]->def->name, name))
            return pools->objs[i];
1562 1563
        virStoragePoolObjUnlock(pools->objs[i]);
    }
1564 1565 1566 1567

    return NULL;
}

1568 1569
virStoragePoolObjPtr
virStoragePoolSourceFindDuplicateDevices(virStoragePoolObjPtr pool,
1570 1571
                                         virStoragePoolDefPtr def)
{
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
    unsigned int i, j;

    for (i = 0; i < pool->def->source.ndevice; i++) {
        for (j = 0; j < def->source.ndevice; j++) {
            if (STREQ(pool->def->source.devices[i].path, def->source.devices[j].path))
                return pool;
        }
    }

    return NULL;
}

1584 1585 1586
void
virStoragePoolObjClearVols(virStoragePoolObjPtr pool)
{
1587
    unsigned int i;
1588
    for (i = 0; i < pool->volumes.count; i++)
1589 1590 1591 1592
        virStorageVolDefFree(pool->volumes.objs[i]);

    VIR_FREE(pool->volumes.objs);
    pool->volumes.count = 0;
1593 1594 1595 1596
}

virStorageVolDefPtr
virStorageVolDefFindByKey(virStoragePoolObjPtr pool,
1597 1598
                          const char *key)
{
1599
    unsigned int i;
1600

1601
    for (i = 0; i < pool->volumes.count; i++)
1602 1603
        if (STREQ(pool->volumes.objs[i]->key, key))
            return pool->volumes.objs[i];
1604 1605 1606 1607 1608 1609

    return NULL;
}

virStorageVolDefPtr
virStorageVolDefFindByPath(virStoragePoolObjPtr pool,
1610 1611
                           const char *path)
{
1612
    unsigned int i;
1613

1614
    for (i = 0; i < pool->volumes.count; i++)
1615 1616
        if (STREQ(pool->volumes.objs[i]->target.path, path))
            return pool->volumes.objs[i];
1617 1618 1619 1620 1621 1622

    return NULL;
}

virStorageVolDefPtr
virStorageVolDefFindByName(virStoragePoolObjPtr pool,
1623 1624
                           const char *name)
{
1625
    unsigned int i;
1626

1627
    for (i = 0; i < pool->volumes.count; i++)
1628 1629
        if (STREQ(pool->volumes.objs[i]->name, name))
            return pool->volumes.objs[i];
1630 1631 1632 1633 1634

    return NULL;
}

virStoragePoolObjPtr
1635
virStoragePoolObjAssignDef(virStoragePoolObjListPtr pools,
1636 1637
                           virStoragePoolDefPtr def)
{
1638 1639
    virStoragePoolObjPtr pool;

1640
    if ((pool = virStoragePoolObjFindByName(pools, def->name))) {
1641 1642 1643 1644
        if (!virStoragePoolObjIsActive(pool)) {
            virStoragePoolDefFree(pool->def);
            pool->def = def;
        } else {
1645
            virStoragePoolDefFree(pool->newDef);
1646 1647 1648 1649 1650
            pool->newDef = def;
        }
        return pool;
    }

1651
    if (VIR_ALLOC(pool) < 0) {
1652
        virReportOOMError();
1653 1654 1655
        return NULL;
    }

1656
    if (virMutexInit(&pool->lock) < 0) {
1657 1658
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("cannot initialize mutex"));
1659 1660 1661
        VIR_FREE(pool);
        return NULL;
    }
1662
    virStoragePoolObjLock(pool);
1663 1664 1665
    pool->active = 0;
    pool->def = def;

1666 1667
    if (VIR_REALLOC_N(pools->objs, pools->count+1) < 0) {
        pool->def = NULL;
1668
        virStoragePoolObjUnlock(pool);
1669
        virStoragePoolObjFree(pool);
1670
        virReportOOMError();
1671 1672 1673
        return NULL;
    }
    pools->objs[pools->count++] = pool;
1674 1675 1676 1677 1678

    return pool;
}

static virStoragePoolObjPtr
1679
virStoragePoolObjLoad(virStoragePoolObjListPtr pools,
1680 1681
                      const char *file,
                      const char *path,
1682 1683
                      const char *autostartLink)
{
1684 1685 1686
    virStoragePoolDefPtr def;
    virStoragePoolObjPtr pool;

1687
    if (!(def = virStoragePoolDefParseFile(path))) {
1688 1689 1690 1691
        return NULL;
    }

    if (!virFileMatchesNameSuffix(file, def->name, ".xml")) {
1692 1693 1694
        virReportError(VIR_ERR_XML_ERROR,
                       _("Storage pool config filename '%s' does not match pool name '%s'"),
                       path, def->name);
1695 1696 1697 1698
        virStoragePoolDefFree(def);
        return NULL;
    }

1699
    if (!(pool = virStoragePoolObjAssignDef(pools, def))) {
1700 1701 1702 1703
        virStoragePoolDefFree(def);
        return NULL;
    }

1704
    VIR_FREE(pool->configFile);  /* for driver reload */
1705
    if (VIR_STRDUP(pool->configFile, path) < 0) {
1706 1707 1708
        virStoragePoolDefFree(def);
        return NULL;
    }
1709
    VIR_FREE(pool->autostartLink); /* for driver reload */
1710
    if (VIR_STRDUP(pool->autostartLink, autostartLink) < 0) {
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
        virStoragePoolDefFree(def);
        return NULL;
    }

    pool->autostart = virFileLinkPointsTo(pool->autostartLink,
                                          pool->configFile);

    return pool;
}


int
1723
virStoragePoolLoadAllConfigs(virStoragePoolObjListPtr pools,
1724
                             const char *configDir,
1725 1726
                             const char *autostartDir)
{
1727 1728 1729
    DIR *dir;
    struct dirent *entry;

1730
    if (!(dir = opendir(configDir))) {
1731 1732
        if (errno == ENOENT)
            return 0;
1733
        virReportSystemError(errno, _("Failed to open dir '%s'"),
1734
                             configDir);
1735 1736 1737 1738
        return -1;
    }

    while ((entry = readdir(dir))) {
1739 1740
        char *path;
        char *autostartLink;
1741
        virStoragePoolObjPtr pool;
1742 1743 1744 1745 1746 1747 1748

        if (entry->d_name[0] == '.')
            continue;

        if (!virFileHasSuffix(entry->d_name, ".xml"))
            continue;

1749
        if (!(path = virFileBuildPath(configDir, entry->d_name, NULL)))
1750 1751
            continue;

1752 1753 1754
        if (!(autostartLink = virFileBuildPath(autostartDir, entry->d_name,
                                               NULL))) {
            VIR_FREE(path);
1755 1756 1757
            continue;
        }

1758
        pool = virStoragePoolObjLoad(pools, entry->d_name, path,
1759
                                     autostartLink);
1760 1761
        if (pool)
            virStoragePoolObjUnlock(pool);
1762 1763 1764

        VIR_FREE(path);
        VIR_FREE(autostartLink);
1765 1766 1767 1768 1769 1770 1771 1772
    }

    closedir(dir);

    return 0;
}

int
1773
virStoragePoolObjSaveDef(virStorageDriverStatePtr driver,
1774
                         virStoragePoolObjPtr pool,
1775 1776
                         virStoragePoolDefPtr def)
{
J
Ján Tomko 已提交
1777
    char uuidstr[VIR_UUID_STRING_BUFLEN];
1778
    char *xml;
1779
    int ret = -1;
1780 1781

    if (!pool->configFile) {
1782 1783
        if (virFileMakePath(driver->configDir) < 0) {
            virReportSystemError(errno,
C
Cole Robinson 已提交
1784 1785
                                 _("cannot create config directory %s"),
                                 driver->configDir);
1786 1787 1788
            return -1;
        }

1789 1790
        if (!(pool->configFile = virFileBuildPath(driver->configDir,
                                                  def->name, ".xml"))) {
1791 1792 1793
            return -1;
        }

1794 1795
        if (!(pool->autostartLink = virFileBuildPath(driver->autostartDir,
                                                     def->name, ".xml"))) {
1796
            VIR_FREE(pool->configFile);
1797 1798 1799 1800
            return -1;
        }
    }

1801
    if (!(xml = virStoragePoolDefFormat(def))) {
1802 1803
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("failed to generate XML"));
1804 1805 1806
        return -1;
    }

J
Ján Tomko 已提交
1807 1808 1809 1810
    virUUIDFormat(def->uuid, uuidstr);
    ret = virXMLSaveFile(pool->configFile,
                         virXMLPickShellSafeComment(def->name, uuidstr),
                         "pool-edit", xml);
1811
    VIR_FREE(xml);
1812 1813 1814 1815 1816

    return ret;
}

int
1817 1818
virStoragePoolObjDeleteDef(virStoragePoolObjPtr pool)
{
1819
    if (!pool->configFile) {
1820 1821
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("no config file for %s"), pool->def->name);
1822 1823 1824 1825
        return -1;
    }

    if (unlink(pool->configFile) < 0) {
1826 1827 1828
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot remove config for %s"),
                       pool->def->name);
1829 1830 1831 1832 1833
        return -1;
    }

    return 0;
}
1834

1835
virStoragePoolSourcePtr
1836
virStoragePoolSourceListNewSource(virStoragePoolSourceListPtr list)
1837 1838 1839
{
    virStoragePoolSourcePtr source;

1840
    if (VIR_REALLOC_N(list->sources, list->nsources + 1) < 0) {
1841
        virReportOOMError();
1842 1843 1844 1845 1846 1847 1848 1849 1850
        return NULL;
    }

    source = &list->sources[list->nsources++];
    memset(source, 0, sizeof(*source));

    return source;
}

1851 1852
char *
virStoragePoolSourceListFormat(virStoragePoolSourceListPtr def)
1853
{
1854
    virStoragePoolOptionsPtr options;
1855
    virBuffer buf = VIR_BUFFER_INITIALIZER;
1856 1857
    const char *type;
    int i;
1858

1859
    options = virStoragePoolOptionsForPoolType(def->type);
1860 1861 1862
    if (options == NULL)
        return NULL;

1863
    type = virStoragePoolTypeToString(def->type);
1864
    if (!type) {
1865 1866
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("unexpected pool type"));
1867 1868 1869 1870
        goto cleanup;
    }

    virBufferAddLit(&buf, "<sources>\n");
1871 1872

    for (i = 0; i < def->nsources; i++) {
1873
        virStoragePoolSourceFormat(&buf, options, &def->sources[i]);
1874 1875
    }

1876 1877 1878 1879
    virBufferAddLit(&buf, "</sources>\n");

    if (virBufferError(&buf))
        goto no_memory;
1880 1881

    return virBufferContentAndReset(&buf);
1882

1883
no_memory:
1884
    virReportOOMError();
1885
cleanup:
1886
    virBufferFreeAndReset(&buf);
1887
    return NULL;
1888
}
D
Daniel P. Berrange 已提交
1889 1890


1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
/*
 * virStoragePoolObjIsDuplicate:
 * @doms : virStoragePoolObjListPtr to search
 * @def  : virStoragePoolDefPtr definition of pool to lookup
 * @check_active: If true, ensure that pool is not active
 *
 * Returns: -1 on error
 *          0 if pool is new
 *          1 if pool is a duplicate
 */
1901 1902 1903 1904
int
virStoragePoolObjIsDuplicate(virStoragePoolObjListPtr pools,
                             virStoragePoolDefPtr def,
                             unsigned int check_active)
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
{
    int ret = -1;
    int dupPool = 0;
    virStoragePoolObjPtr pool = NULL;

    /* See if a Pool with matching UUID already exists */
    pool = virStoragePoolObjFindByUUID(pools, def->uuid);
    if (pool) {
        /* UUID matches, but if names don't match, refuse it */
        if (STRNEQ(pool->def->name, def->name)) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(pool->def->uuid, uuidstr);
1917 1918 1919
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("pool '%s' is already defined with uuid %s"),
                           pool->def->name, uuidstr);
1920 1921 1922 1923 1924 1925
            goto cleanup;
        }

        if (check_active) {
            /* UUID & name match, but if Pool is already active, refuse it */
            if (virStoragePoolObjIsActive(pool)) {
1926 1927 1928
                virReportError(VIR_ERR_OPERATION_INVALID,
                               _("pool is already active as '%s'"),
                               pool->def->name);
1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
                goto cleanup;
            }
        }

        dupPool = 1;
    } else {
        /* UUID does not match, but if a name matches, refuse it */
        pool = virStoragePoolObjFindByName(pools, def->name);
        if (pool) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(pool->def->uuid, uuidstr);
1940 1941 1942
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("pool '%s' already exists with uuid %s"),
                           def->name, uuidstr);
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
            goto cleanup;
        }
    }

    ret = dupPool;
cleanup:
    if (pool)
        virStoragePoolObjUnlock(pool);
    return ret;
}

1954 1955 1956
int
virStoragePoolSourceFindDuplicate(virStoragePoolObjListPtr pools,
                                  virStoragePoolDefPtr def)
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
{
    int i;
    int ret = 1;
    virStoragePoolObjPtr pool = NULL;
    virStoragePoolObjPtr matchpool = NULL;

    /* Check the pool list for duplicate underlying storage */
    for (i = 0; i < pools->count; i++) {
        pool = pools->objs[i];
        if (def->type != pool->def->type)
            continue;

1969 1970 1971 1972
        /* Don't mach against ourself if re-defining existing pool ! */
        if (STREQ(pool->def->name, def->name))
            continue;

1973 1974 1975 1976 1977 1978 1979 1980 1981
        virStoragePoolObjLock(pool);

        switch (pool->def->type) {
        case VIR_STORAGE_POOL_DIR:
            if (STREQ(pool->def->target.path, def->target.path))
                matchpool = pool;
            break;
        case VIR_STORAGE_POOL_NETFS:
            if ((STREQ(pool->def->source.dir, def->source.dir)) \
1982 1983
                && (pool->def->source.nhost == 1 && def->source.nhost == 1) \
                && (STREQ(pool->def->source.hosts[0].name, def->source.hosts[0].name)))
1984 1985 1986
                matchpool = pool;
            break;
        case VIR_STORAGE_POOL_SCSI:
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
            if (pool->def->source.adapter.type ==
                VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_FC_HOST) {
                if (STREQ(pool->def->source.adapter.data.fchost.wwnn,
                          def->source.adapter.data.fchost.wwnn) &&
                    STREQ(pool->def->source.adapter.data.fchost.wwpn,
                          def->source.adapter.data.fchost.wwpn))
                    matchpool = pool;
            } else if (pool->def->source.adapter.type ==
                       VIR_STORAGE_POOL_SOURCE_ADAPTER_TYPE_SCSI_HOST){
                if (STREQ(pool->def->source.adapter.data.name,
                          def->source.adapter.data.name))
                    matchpool = pool;
            }
2000 2001 2002 2003
            break;
        case VIR_STORAGE_POOL_ISCSI:
            matchpool = virStoragePoolSourceFindDuplicateDevices(pool, def);
            if (matchpool) {
2004 2005 2006 2007 2008 2009 2010 2011
                if (matchpool->def->source.nhost == 1 && def->source.nhost == 1) {
                    if (STREQ(matchpool->def->source.hosts[0].name, def->source.hosts[0].name)) {
                        if ((matchpool->def->source.initiator.iqn) && (def->source.initiator.iqn)) {
                            if (STREQ(matchpool->def->source.initiator.iqn, def->source.initiator.iqn))
                                break;
                            matchpool = NULL;
                        }
                        break;
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
                    }
                }
                matchpool = NULL;
            }
            break;
        case VIR_STORAGE_POOL_FS:
        case VIR_STORAGE_POOL_LOGICAL:
        case VIR_STORAGE_POOL_DISK:
            matchpool = virStoragePoolSourceFindDuplicateDevices(pool, def);
            break;
        default:
            break;
        }
        virStoragePoolObjUnlock(pool);
2026 2027 2028

        if (matchpool)
            break;
2029 2030 2031
    }

    if (matchpool) {
2032 2033 2034
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("Storage source conflict with pool: '%s'"),
                       matchpool->def->name);
2035 2036 2037 2038
        ret = -1;
    }
    return ret;
}
2039

2040 2041
void
virStoragePoolObjLock(virStoragePoolObjPtr obj)
2042
{
2043
    virMutexLock(&obj->lock);
2044 2045
}

2046 2047
void
virStoragePoolObjUnlock(virStoragePoolObjPtr obj)
2048
{
2049
    virMutexUnlock(&obj->lock);
2050
}
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135

#define MATCH(FLAG) (flags & (FLAG))
static bool
virStoragePoolMatch(virStoragePoolObjPtr poolobj,
                    unsigned int flags)
{
    /* filter by active state */
    if (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE) &&
        !((MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE) &&
           virStoragePoolObjIsActive(poolobj)) ||
          (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE) &&
           !virStoragePoolObjIsActive(poolobj))))
        return false;

    /* filter by persistence */
    if (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_PERSISTENT) &&
        !((MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT) &&
           poolobj->configFile) ||
          (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT) &&
           !poolobj->configFile)))
        return false;

    /* filter by autostart option */
    if (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_AUTOSTART) &&
        !((MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART) &&
           poolobj->autostart) ||
          (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART) &&
           !poolobj->autostart)))
        return false;

    /* filter by pool type */
    if (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_POOL_TYPE)) {
        if (!((MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_DIR) &&
               (poolobj->def->type == VIR_STORAGE_POOL_DIR))     ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FS) &&
               (poolobj->def->type == VIR_STORAGE_POOL_FS))      ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_NETFS) &&
               (poolobj->def->type == VIR_STORAGE_POOL_NETFS))   ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL) &&
               (poolobj->def->type == VIR_STORAGE_POOL_LOGICAL)) ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_DISK) &&
               (poolobj->def->type == VIR_STORAGE_POOL_DISK))    ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI) &&
               (poolobj->def->type == VIR_STORAGE_POOL_ISCSI))   ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_SCSI) &&
               (poolobj->def->type == VIR_STORAGE_POOL_SCSI))    ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_MPATH) &&
               (poolobj->def->type == VIR_STORAGE_POOL_MPATH))   ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_RBD) &&
               (poolobj->def->type == VIR_STORAGE_POOL_RBD))     ||
              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG) &&
               (poolobj->def->type == VIR_STORAGE_POOL_SHEEPDOG))))
            return false;
    }

    return true;
}
#undef MATCH

int
virStoragePoolList(virConnectPtr conn,
                   virStoragePoolObjList poolobjs,
                   virStoragePoolPtr **pools,
                   unsigned int flags)
{
    virStoragePoolPtr *tmp_pools = NULL;
    virStoragePoolPtr pool = NULL;
    int npools = 0;
    int ret = -1;
    int i;

    if (pools) {
        if (VIR_ALLOC_N(tmp_pools, poolobjs.count + 1) < 0) {
            virReportOOMError();
            goto cleanup;
        }
    }

    for (i = 0; i < poolobjs.count; i++) {
        virStoragePoolObjPtr poolobj = poolobjs.objs[i];
        virStoragePoolObjLock(poolobj);
        if (virStoragePoolMatch(poolobj, flags)) {
            if (pools) {
                if (!(pool = virGetStoragePool(conn,
                                               poolobj->def->name,
2136 2137
                                               poolobj->def->uuid,
                                               NULL, NULL))) {
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
                    virStoragePoolObjUnlock(poolobj);
                    goto cleanup;
                }
                tmp_pools[npools] = pool;
            }
            npools++;
        }
        virStoragePoolObjUnlock(poolobj);
    }

    if (tmp_pools) {
        /* trim the array to the final size */
        ignore_value(VIR_REALLOC_N(tmp_pools, npools + 1));
        *pools = tmp_pools;
        tmp_pools = NULL;
    }

    ret = npools;

cleanup:
    if (tmp_pools) {
        for (i = 0; i < npools; i++) {
            if (tmp_pools[i])
                virStoragePoolFree(tmp_pools[i]);
        }
    }

    VIR_FREE(tmp_pools);
    return ret;
}