virstoragefile.c 49.7 KB
Newer Older
1
/*
2
 * virstoragefile.c: file utility functions for FS storage backend
3
 *
4
 * Copyright (C) 2007-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2007-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
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>
25
#include "virstoragefile.h"
26

27
#include <sys/stat.h>
28
#include <unistd.h>
29
#include <fcntl.h>
30
#include <stdlib.h>
31
#include "dirname.h"
32
#include "viralloc.h"
33
#include "virerror.h"
34
#include "virlog.h"
E
Eric Blake 已提交
35
#include "virfile.h"
36
#include "c-ctype.h"
37
#include "vircommand.h"
38
#include "virhash.h"
E
Eric Blake 已提交
39
#include "virendian.h"
40 41
#include "virstring.h"
#include "virutil.h"
42 43 44
#if HAVE_SYS_SYSCALL_H
# include <sys/syscall.h>
#endif
45 46 47

#define VIR_FROM_THIS VIR_FROM_STORAGE

48 49
VIR_LOG_INIT("util.storagefile");

E
Eric Blake 已提交
50
VIR_ENUM_IMPL(virStorage, VIR_STORAGE_TYPE_LAST,
51
              "none",
E
Eric Blake 已提交
52
              "file",
53
              "block",
E
Eric Blake 已提交
54 55 56 57
              "dir",
              "network",
              "volume")

58 59
VIR_ENUM_IMPL(virStorageFileFormat,
              VIR_STORAGE_FILE_LAST,
E
Eric Blake 已提交
60
              "none",
61
              "raw", "dir", "bochs",
62 63 64 65 66 67
              "cloop", "dmg", "iso",
              "vpc", "vdi",
              /* Not direct file formats, but used for various drivers */
              "fat", "vhd",
              /* Formats with backing file below here */
              "cow", "qcow", "qcow2", "qed", "vmdk")
68

69 70 71 72 73
VIR_ENUM_IMPL(virStorageFileFeature,
              VIR_STORAGE_FILE_FEATURE_LAST,
              "lazy_refcounts",
              )

74 75 76 77 78 79 80 81 82 83 84
VIR_ENUM_IMPL(virStorageNetProtocol, VIR_STORAGE_NET_PROTOCOL_LAST,
              "nbd",
              "rbd",
              "sheepdog",
              "gluster",
              "iscsi",
              "http",
              "https",
              "ftp",
              "ftps",
              "tftp")
85 86 87 88 89 90

VIR_ENUM_IMPL(virStorageNetHostTransport, VIR_STORAGE_NET_HOST_TRANS_LAST,
              "tcp",
              "unix",
              "rdma")

91 92 93 94 95
VIR_ENUM_IMPL(virStorageSourcePoolMode,
              VIR_STORAGE_SOURCE_POOL_MODE_LAST,
              "default",
              "host",
              "direct")
96

97 98 99 100 101 102 103 104 105 106 107
enum lv_endian {
    LV_LITTLE_ENDIAN = 1, /* 1234 */
    LV_BIG_ENDIAN         /* 4321 */
};

enum {
    BACKING_STORE_OK,
    BACKING_STORE_INVALID,
    BACKING_STORE_ERROR,
};

108 109
#define FILE_TYPE_VERSIONS_LAST 2

110 111
/* Either 'magic' or 'extension' *must* be provided */
struct FileTypeInfo {
112
    int magicOffset;    /* Byte offset of the magic */
113 114 115 116 117 118
    const char *magic;  /* Optional string of file magic
                         * to check at head of file */
    const char *extension; /* Optional file extension to check */
    enum lv_endian endian; /* Endianness of file format */
    int versionOffset;    /* Byte offset from start of file
                           * where we find version number,
119 120
                           * -1 to always fail the version test,
                           * -2 to always pass the version test */
121 122
    int versionNumbers[FILE_TYPE_VERSIONS_LAST];
                          /* Version numbers to validate. Zeroes are ignored. */
123 124 125 126 127 128 129 130 131 132 133
    int sizeOffset;       /* Byte offset from start of file
                           * where we find capacity info,
                           * -1 to use st_size as capacity */
    int sizeBytes;        /* Number of bytes for size field */
    int sizeMultiplier;   /* A scaling factor if size is not in bytes */
                          /* Store a COW base image path (possibly relative),
                           * or NULL if there is no COW base image, to RES;
                           * return BACKING_STORE_* */
    int qcowCryptOffset;  /* Byte offset from start of file
                           * where to find encryption mode,
                           * -1 if encryption is not used */
134
    int (*getBackingStore)(char **res, int *format,
E
Eric Blake 已提交
135
                           const char *buf, size_t buf_size);
136
    int (*getFeatures)(virBitmapPtr *features, int format,
E
Eric Blake 已提交
137
                       char *buf, ssize_t len);
138 139
};

140
static int cowGetBackingStore(char **, int *,
E
Eric Blake 已提交
141
                              const char *, size_t);
142
static int qcow1GetBackingStore(char **, int *,
E
Eric Blake 已提交
143
                                const char *, size_t);
144
static int qcow2GetBackingStore(char **, int *,
E
Eric Blake 已提交
145
                                const char *, size_t);
146
static int qcow2GetFeatures(virBitmapPtr *features, int format,
E
Eric Blake 已提交
147
                            char *buf, ssize_t len);
148
static int vmdk4GetBackingStore(char **, int *,
E
Eric Blake 已提交
149
                                const char *, size_t);
150
static int
E
Eric Blake 已提交
151
qedGetBackingStore(char **, int *, const char *, size_t);
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166

#define QCOWX_HDR_VERSION (4)
#define QCOWX_HDR_BACKING_FILE_OFFSET (QCOWX_HDR_VERSION+4)
#define QCOWX_HDR_BACKING_FILE_SIZE (QCOWX_HDR_BACKING_FILE_OFFSET+8)
#define QCOWX_HDR_IMAGE_SIZE (QCOWX_HDR_BACKING_FILE_SIZE+4+4)

#define QCOW1_HDR_CRYPT (QCOWX_HDR_IMAGE_SIZE+8+1+1)
#define QCOW2_HDR_CRYPT (QCOWX_HDR_IMAGE_SIZE+8)

#define QCOW1_HDR_TOTAL_SIZE (QCOW1_HDR_CRYPT+4+8)
#define QCOW2_HDR_TOTAL_SIZE (QCOW2_HDR_CRYPT+4+4+8+8+4+4+8)

#define QCOW2_HDR_EXTENSION_END 0
#define QCOW2_HDR_EXTENSION_BACKING_FORMAT 0xE2792ACA

167 168 169 170 171 172 173
#define QCOW2v3_HDR_FEATURES_INCOMPATIBLE (QCOW2_HDR_TOTAL_SIZE)
#define QCOW2v3_HDR_FEATURES_COMPATIBLE (QCOW2v3_HDR_FEATURES_INCOMPATIBLE+8)
#define QCOW2v3_HDR_FEATURES_AUTOCLEAR (QCOW2v3_HDR_FEATURES_COMPATIBLE+8)

/* The location of the header size [4 bytes] */
#define QCOW2v3_HDR_SIZE       (QCOW2_HDR_TOTAL_SIZE+8+8+8+4)

174
#define QED_HDR_FEATURES_OFFSET (4+4+4+4)
175 176
#define QED_HDR_IMAGE_SIZE (QED_HDR_FEATURES_OFFSET+8+8+8+8)
#define QED_HDR_BACKING_FILE_OFFSET (QED_HDR_IMAGE_SIZE+8)
177 178 179
#define QED_HDR_BACKING_FILE_SIZE (QED_HDR_BACKING_FILE_OFFSET+4)
#define QED_F_BACKING_FILE 0x01
#define QED_F_BACKING_FORMAT_NO_PROBE 0x04
A
Adam Litke 已提交
180

181 182

static struct FileTypeInfo const fileTypeInfo[] = {
183
    [VIR_STORAGE_FILE_NONE] = { 0, NULL, NULL, LV_LITTLE_ENDIAN,
184
                                -1, {0}, 0, 0, 0, 0, NULL, NULL },
185
    [VIR_STORAGE_FILE_RAW] = { 0, NULL, NULL, LV_LITTLE_ENDIAN,
186
                               -1, {0}, 0, 0, 0, 0, NULL, NULL },
187
    [VIR_STORAGE_FILE_DIR] = { 0, NULL, NULL, LV_LITTLE_ENDIAN,
188
                               -1, {0}, 0, 0, 0, 0, NULL, NULL },
189
    [VIR_STORAGE_FILE_BOCHS] = {
190 191
        /*"Bochs Virtual HD Image", */ /* Untested */
        0, NULL, NULL,
192 193
        LV_LITTLE_ENDIAN, 64, {0x20000},
        32+16+16+4+4+4+4+4, 8, 1, -1, NULL, NULL
194 195
    },
    [VIR_STORAGE_FILE_CLOOP] = {
196 197 198 199 200
        /* #!/bin/sh
           #V2.0 Format
           modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1
        */ /* Untested */
        0, NULL, NULL,
201 202
        LV_LITTLE_ENDIAN, -1, {0},
        -1, 0, 0, -1, NULL, NULL
203 204
    },
    [VIR_STORAGE_FILE_DMG] = {
205 206 207 208
        /* XXX QEMU says there's no magic for dmg,
         * /usr/share/misc/magic lists double magic (both offsets
         * would have to match) but then disables that check. */
        0, NULL, ".dmg",
209 210
        0, -1, {0},
        -1, 0, 0, -1, NULL, NULL
211 212
    },
    [VIR_STORAGE_FILE_ISO] = {
213
        32769, "CD001", ".iso",
214 215
        LV_LITTLE_ENDIAN, -2, {0},
        -1, 0, 0, -1, NULL, NULL
216
    },
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
    [VIR_STORAGE_FILE_VPC] = {
        0, "conectix", NULL,
        LV_BIG_ENDIAN, 12, {0x10000},
        8 + 4 + 4 + 8 + 4 + 4 + 2 + 2 + 4, 8, 1, -1, NULL, NULL
    },
    /* TODO: add getBackingStore function */
    [VIR_STORAGE_FILE_VDI] = {
        64, "\x7f\x10\xda\xbe", ".vdi",
        LV_LITTLE_ENDIAN, 68, {0x00010001},
        64 + 5 * 4 + 256 + 7 * 4, 8, 1, -1, NULL, NULL},

    /* Not direct file formats, but used for various drivers */
    [VIR_STORAGE_FILE_FAT] = { 0, NULL, NULL, LV_LITTLE_ENDIAN,
                               -1, {0}, 0, 0, 0, 0, NULL, NULL },
    [VIR_STORAGE_FILE_VHD] = { 0, NULL, NULL, LV_LITTLE_ENDIAN,
                               -1, {0}, 0, 0, 0, 0, NULL, NULL },

    /* All formats with a backing store probe below here */
    [VIR_STORAGE_FILE_COW] = {
        0, "OOOM", NULL,
        LV_BIG_ENDIAN, 4, {2},
        4+4+1024+4, 8, 1, -1, cowGetBackingStore, NULL
    },
240
    [VIR_STORAGE_FILE_QCOW] = {
241
        0, "QFI", NULL,
242 243
        LV_BIG_ENDIAN, 4, {1},
        QCOWX_HDR_IMAGE_SIZE, 8, 1, QCOW1_HDR_CRYPT, qcow1GetBackingStore, NULL
244 245
    },
    [VIR_STORAGE_FILE_QCOW2] = {
246
        0, "QFI", NULL,
247
        LV_BIG_ENDIAN, 4, {2, 3},
248
        QCOWX_HDR_IMAGE_SIZE, 8, 1, QCOW2_HDR_CRYPT, qcow2GetBackingStore,
249
        qcow2GetFeatures
250
    },
A
Adam Litke 已提交
251 252
    [VIR_STORAGE_FILE_QED] = {
        /* http://wiki.qemu.org/Features/QED */
253
        0, "QED", NULL,
254 255
        LV_LITTLE_ENDIAN, -2, {0},
        QED_HDR_IMAGE_SIZE, 8, 1, -1, qedGetBackingStore, NULL
A
Adam Litke 已提交
256
    },
257
    [VIR_STORAGE_FILE_VMDK] = {
258
        0, "KDMV", NULL,
259
        LV_LITTLE_ENDIAN, 4, {1, 2},
260
        4+4+4, 8, 512, -1, vmdk4GetBackingStore, NULL
261
    },
262
};
263
verify(ARRAY_CARDINALITY(fileTypeInfo) == VIR_STORAGE_FILE_LAST);
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278
/* qcow2 compatible features in the order they appear on-disk */
enum qcow2CompatibleFeature {
    QCOW2_COMPATIBLE_FEATURE_LAZY_REFCOUNTS = 0,

    QCOW2_COMPATIBLE_FEATURE_LAST
};

/* conversion to virStorageFileFeature */
static const int qcow2CompatibleFeatureArray[] = {
    VIR_STORAGE_FILE_FEATURE_LAZY_REFCOUNTS,
};
verify(ARRAY_CARDINALITY(qcow2CompatibleFeatureArray) ==
       QCOW2_COMPATIBLE_FEATURE_LAST);

279
static int
280
cowGetBackingStore(char **res,
281
                   int *format,
E
Eric Blake 已提交
282
                   const char *buf,
283 284 285 286
                   size_t buf_size)
{
#define COW_FILENAME_MAXLEN 1024
    *res = NULL;
287 288
    *format = VIR_STORAGE_FILE_AUTO;

289 290
    if (buf_size < 4+4+ COW_FILENAME_MAXLEN)
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
291 292
    if (buf[4+4] == '\0') { /* cow_header_v2.backing_file[0] */
        *format = VIR_STORAGE_FILE_NONE;
293
        return BACKING_STORE_OK;
E
Eric Blake 已提交
294
    }
295

296
    if (VIR_STRNDUP(*res, (const char*)buf + 4 + 4, COW_FILENAME_MAXLEN) < 0)
297 298 299 300
        return BACKING_STORE_ERROR;
    return BACKING_STORE_OK;
}

301 302 303

static int
qcow2GetBackingStoreFormat(int *format,
E
Eric Blake 已提交
304
                           const char *buf,
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
                           size_t buf_size,
                           size_t extension_start,
                           size_t extension_end)
{
    size_t offset = extension_start;

    /*
     * The extensions take format of
     *
     * int32: magic
     * int32: length
     * byte[length]: payload
     *
     * Unknown extensions can be ignored by skipping
     * over "length" bytes in the data stream.
     */
    while (offset < (buf_size-8) &&
           offset < (extension_end-8)) {
E
Eric Blake 已提交
323 324
        unsigned int magic = virReadBufInt32BE(buf + offset);
        unsigned int len = virReadBufInt32BE(buf + offset + 4);
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342

        offset += 8;

        if ((offset + len) < offset)
            break;

        if ((offset + len) > buf_size)
            break;

        switch (magic) {
        case QCOW2_HDR_EXTENSION_END:
            goto done;

        case QCOW2_HDR_EXTENSION_BACKING_FORMAT:
            if (buf[offset+len] != '\0')
                break;
            *format = virStorageFileFormatTypeFromString(
                ((const char *)buf)+offset);
E
Eric Blake 已提交
343 344
            if (*format <= VIR_STORAGE_FILE_NONE)
                return -1;
345 346 347 348 349
        }

        offset += len;
    }

350
 done:
351 352 353 354 355

    return 0;
}


356
static int
357
qcowXGetBackingStore(char **res,
358
                     int *format,
E
Eric Blake 已提交
359
                     const char *buf,
360 361
                     size_t buf_size,
                     bool isQCow2)
362 363
{
    unsigned long long offset;
364
    unsigned int size;
365 366
    unsigned long long start;
    int version;
367 368

    *res = NULL;
369 370 371 372
    if (format)
        *format = VIR_STORAGE_FILE_AUTO;

    if (buf_size < QCOWX_HDR_BACKING_FILE_OFFSET+8+4)
373
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
374
    offset = virReadBufInt64BE(buf + QCOWX_HDR_BACKING_FILE_OFFSET);
375 376
    if (offset > buf_size)
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
377
    size = virReadBufInt32BE(buf + QCOWX_HDR_BACKING_FILE_SIZE);
E
Eric Blake 已提交
378 379 380
    if (size == 0) {
        if (format)
            *format = VIR_STORAGE_FILE_NONE;
381
        return BACKING_STORE_OK;
E
Eric Blake 已提交
382
    }
383 384 385 386
    if (offset + size > buf_size || offset + size < offset)
        return BACKING_STORE_INVALID;
    if (size + 1 == 0)
        return BACKING_STORE_INVALID;
387
    if (VIR_ALLOC_N(*res, size + 1) < 0)
388 389 390
        return BACKING_STORE_ERROR;
    memcpy(*res, buf + offset, size);
    (*res)[size] = '\0';
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414

    /*
     * Traditionally QCow2 files had a layout of
     *
     * [header]
     * [backingStoreName]
     *
     * Although the backingStoreName typically followed
     * the header immediately, this was not required by
     * the format. By specifying a higher byte offset for
     * the backing file offset in the header, it was
     * possible to leave space between the header and
     * start of backingStore.
     *
     * This hack is now used to store extensions to the
     * qcow2 format:
     *
     * [header]
     * [extensions]
     * [backingStoreName]
     *
     * Thus the file region to search for extensions is
     * between the end of the header (QCOW2_HDR_TOTAL_SIZE)
     * and the start of the backingStoreName (offset)
415 416 417
     *
     * for qcow2 v3 images, the length of the header
     * is stored at QCOW2v3_HDR_SIZE
418
     */
419 420 421 422 423 424 425 426 427 428
    if (isQCow2 && format) {
        version = virReadBufInt32BE(buf + QCOWX_HDR_VERSION);
        if (version == 2)
            start = QCOW2_HDR_TOTAL_SIZE;
        else
            start = virReadBufInt32BE(buf + QCOW2v3_HDR_SIZE);
        if (qcow2GetBackingStoreFormat(format, buf, buf_size,
                                       start, offset) < 0)
            return BACKING_STORE_INVALID;
    }
429

430 431 432 433
    return BACKING_STORE_OK;
}


434 435 436
static int
qcow1GetBackingStore(char **res,
                     int *format,
E
Eric Blake 已提交
437
                     const char *buf,
438 439
                     size_t buf_size)
{
E
Eric Blake 已提交
440 441
    int ret;

442 443 444
    /* QCow1 doesn't have the extensions capability
     * used to store backing format */
    *format = VIR_STORAGE_FILE_AUTO;
E
Eric Blake 已提交
445 446 447 448
    ret = qcowXGetBackingStore(res, NULL, buf, buf_size, false);
    if (ret == 0 && *buf == '\0')
        *format = VIR_STORAGE_FILE_NONE;
    return ret;
449 450 451 452 453
}

static int
qcow2GetBackingStore(char **res,
                     int *format,
E
Eric Blake 已提交
454
                     const char *buf,
455 456 457 458 459 460
                     size_t buf_size)
{
    return qcowXGetBackingStore(res, format, buf, buf_size, true);
}


461
static int
462
vmdk4GetBackingStore(char **res,
463
                     int *format,
E
Eric Blake 已提交
464
                     const char *buf,
465 466 467
                     size_t buf_size)
{
    static const char prefix[] = "parentFileNameHint=\"";
468
    char *desc, *start, *end;
469
    size_t len;
470 471
    int ret = BACKING_STORE_ERROR;

472
    if (VIR_ALLOC_N(desc, VIR_STORAGE_MAX_HEADER) < 0)
473
        goto cleanup;
474 475

    *res = NULL;
476 477 478 479 480 481 482 483
    /*
     * Technically this should have been VMDK, since
     * VMDK spec / VMWare impl only support VMDK backed
     * by VMDK. QEMU isn't following this though and
     * does probing on VMDK backing files, hence we set
     * AUTO
     */
    *format = VIR_STORAGE_FILE_AUTO;
484

485 486 487 488
    if (buf_size <= 0x200) {
        ret = BACKING_STORE_INVALID;
        goto cleanup;
    }
489
    len = buf_size - 0x200;
490 491
    if (len > VIR_STORAGE_MAX_HEADER)
        len = VIR_STORAGE_MAX_HEADER;
492 493 494
    memcpy(desc, buf + 0x200, len);
    desc[len] = '\0';
    start = strstr(desc, prefix);
495
    if (start == NULL) {
E
Eric Blake 已提交
496
        *format = VIR_STORAGE_FILE_NONE;
497 498 499
        ret = BACKING_STORE_OK;
        goto cleanup;
    }
500 501
    start += strlen(prefix);
    end = strchr(start, '"');
502 503 504 505 506
    if (end == NULL) {
        ret = BACKING_STORE_INVALID;
        goto cleanup;
    }
    if (end == start) {
E
Eric Blake 已提交
507
        *format = VIR_STORAGE_FILE_NONE;
508 509 510
        ret = BACKING_STORE_OK;
        goto cleanup;
    }
511
    *end = '\0';
512
    if (VIR_STRDUP(*res, start) < 0)
513 514 515 516
        goto cleanup;

    ret = BACKING_STORE_OK;

517
 cleanup:
518 519
    VIR_FREE(desc);
    return ret;
520 521
}

522 523 524
static int
qedGetBackingStore(char **res,
                   int *format,
E
Eric Blake 已提交
525
                   const char *buf,
526 527 528 529 530 531 532 533 534
                   size_t buf_size)
{
    unsigned long long flags;
    unsigned long offset, size;

    *res = NULL;
    /* Check if this image has a backing file */
    if (buf_size < QED_HDR_FEATURES_OFFSET+8)
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
535
    flags = virReadBufInt64LE(buf + QED_HDR_FEATURES_OFFSET);
E
Eric Blake 已提交
536 537
    if (!(flags & QED_F_BACKING_FILE)) {
        *format = VIR_STORAGE_FILE_NONE;
538
        return BACKING_STORE_OK;
E
Eric Blake 已提交
539
    }
540 541 542 543

    /* Parse the backing file */
    if (buf_size < QED_HDR_BACKING_FILE_OFFSET+8)
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
544
    offset = virReadBufInt32LE(buf + QED_HDR_BACKING_FILE_OFFSET);
545 546
    if (offset > buf_size)
        return BACKING_STORE_INVALID;
E
Eric Blake 已提交
547
    size = virReadBufInt32LE(buf + QED_HDR_BACKING_FILE_SIZE);
548 549 550 551
    if (size == 0)
        return BACKING_STORE_OK;
    if (offset + size > buf_size || offset + size < offset)
        return BACKING_STORE_INVALID;
552
    if (VIR_ALLOC_N(*res, size + 1) < 0)
553 554 555 556
        return BACKING_STORE_ERROR;
    memcpy(*res, buf + offset, size);
    (*res)[size] = '\0';

E
Eric Blake 已提交
557 558 559 560
    if (flags & QED_F_BACKING_FORMAT_NO_PROBE)
        *format = VIR_STORAGE_FILE_RAW;
    else
        *format = VIR_STORAGE_FILE_AUTO_SAFE;
561 562 563 564

    return BACKING_STORE_OK;
}

565
/**
566 567 568 569 570 571
 * Given a starting point START (a directory containing the original
 * file, if the original file was opened via a relative path; ignored
 * if NAME is absolute), determine the location of the backing file
 * NAME (possibly relative), and compute the relative DIRECTORY
 * (optional) and CANONICAL (mandatory) location of the backing file.
 * Return 0 on success, negative on error.
572
 */
573 574
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4)
virFindBackingFile(const char *start, const char *path,
575
                   char **directory, char **canonical)
576
{
577 578 579 580 581 582 583 584
    /* FIXME - when we eventually allow non-raw network devices, we
     * must ensure that we handle backing files the same way as qemu.
     * For a qcow2 top file of gluster://server/vol/img, qemu treats
     * the relative backing file 'rel' as meaning
     * 'gluster://server/vol/rel', while the backing file '/abs' is
     * used as a local file.  But we cannot canonicalize network
     * devices via canonicalize_file_name(), because they are not part
     * of the local file system.  */
585 586
    char *combined = NULL;
    int ret = -1;
587

588 589 590
    if (*path == '/') {
        /* Safe to cast away const */
        combined = (char *)path;
591 592
    } else if (virAsprintf(&combined, "%s/%s", start, path) < 0) {
        goto cleanup;
593
    }
594

595 596
    if (directory && !(*directory = mdir_name(combined))) {
        virReportOOMError();
597 598
        goto cleanup;
    }
599

600
    if (virFileAccessibleAs(combined, F_OK, geteuid(), getegid()) < 0) {
601 602 603 604 605 606
        virReportSystemError(errno,
                             _("Cannot access backing file '%s'"),
                             combined);
        goto cleanup;
    }

607 608 609
    if (!(*canonical = canonicalize_file_name(combined))) {
        virReportSystemError(errno,
                             _("Can't canonicalize path '%s'"), path);
610 611 612
        goto cleanup;
    }

613
    ret = 0;
614

615
 cleanup:
616 617 618
    if (combined != path)
        VIR_FREE(combined);
    return ret;
619 620
}

621 622 623

static bool
virStorageFileMatchesMagic(int format,
E
Eric Blake 已提交
624
                           char *buf,
625
                           size_t buflen)
626
{
627
    int mlen;
628 629
    int magicOffset = fileTypeInfo[format].magicOffset;
    const char *magic = fileTypeInfo[format].magic;
630

631
    if (magic == NULL)
632
        return false;
633

634
    /* Validate magic data */
635 636
    mlen = strlen(magic);
    if (magicOffset + mlen > buflen)
637
        return false;
638

639
    if (memcmp(buf + magicOffset, magic, mlen) != 0)
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
        return false;

    return true;
}


static bool
virStorageFileMatchesExtension(int format,
                               const char *path)
{
    if (fileTypeInfo[format].extension == NULL)
        return false;

    if (virFileHasSuffix(path, fileTypeInfo[format].extension))
        return true;

    return false;
}


static bool
virStorageFileMatchesVersion(int format,
E
Eric Blake 已提交
662
                             char *buf,
663 664
                             size_t buflen)
{
665 666
    int version;
    size_t i;
667 668 669

    /* Validate version number info */
    if (fileTypeInfo[format].versionOffset == -1)
E
Eric Blake 已提交
670
        return false;
671

672 673 674 675
    /* -2 == non-versioned file format, so trivially match */
    if (fileTypeInfo[format].versionOffset == -2)
        return true;

676 677 678
    if ((fileTypeInfo[format].versionOffset + 4) > buflen)
        return false;

E
Eric Blake 已提交
679 680 681 682
    if (fileTypeInfo[format].endian == LV_LITTLE_ENDIAN)
        version = virReadBufInt32LE(buf + fileTypeInfo[format].versionOffset);
    else
        version = virReadBufInt32BE(buf + fileTypeInfo[format].versionOffset);
683

684 685 686 687 688 689 690 691
    for (i = 0;
         i < FILE_TYPE_VERSIONS_LAST && fileTypeInfo[format].versionNumbers[i];
         i++) {
        VIR_DEBUG("Compare detected version %d vs one of the expected versions %d",
                  version, fileTypeInfo[format].versionNumbers[i]);
        if (version == fileTypeInfo[format].versionNumbers[i])
            return true;
    }
692

693
    return false;
694
}
695

696 697
bool
virStorageIsFile(const char *backing)
A
Adam Litke 已提交
698
{
699 700 701 702 703 704 705 706
    char *colon;
    char *slash;

    if (!backing)
        return false;

    colon = strchr(backing, ':');
    slash = strchr(backing, '/');
707 708 709 710 711

    /* Reject anything that looks like a protocol (such as nbd: or
     * rbd:); if someone really does want a relative file name that
     * includes ':', they can always prefix './'.  */
    if (colon && (!slash || colon < slash))
A
Adam Litke 已提交
712 713 714
        return false;
    return true;
}
715

716
int
E
Eric Blake 已提交
717
virStorageFileProbeFormatFromBuf(const char *path,
E
Eric Blake 已提交
718
                                 char *buf,
E
Eric Blake 已提交
719 720 721
                                 size_t buflen)
{
    int format = VIR_STORAGE_FILE_RAW;
722
    size_t i;
E
Eric Blake 已提交
723
    int possibleFormat = VIR_STORAGE_FILE_RAW;
724
    VIR_DEBUG("path=%s, buf=%p, buflen=%zu", path, buf, buflen);
E
Eric Blake 已提交
725 726

    /* First check file magic */
727
    for (i = 0; i < VIR_STORAGE_FILE_LAST; i++) {
E
Eric Blake 已提交
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
        if (virStorageFileMatchesMagic(i, buf, buflen)) {
            if (!virStorageFileMatchesVersion(i, buf, buflen)) {
                possibleFormat = i;
                continue;
            }
            format = i;
            goto cleanup;
        }
    }

    if (possibleFormat != VIR_STORAGE_FILE_RAW)
        VIR_WARN("File %s matches %s magic, but version is wrong. "
                 "Please report new version to libvir-list@redhat.com",
                 path, virStorageFileFormatTypeToString(possibleFormat));

    /* No magic, so check file extension */
744
    for (i = 0; i < VIR_STORAGE_FILE_LAST; i++) {
E
Eric Blake 已提交
745 746 747 748 749 750
        if (virStorageFileMatchesExtension(i, path)) {
            format = i;
            goto cleanup;
        }
    }

751
 cleanup:
E
Eric Blake 已提交
752 753 754 755 756
    VIR_DEBUG("format=%d", format);
    return format;
}


757 758 759
static int
qcow2GetFeatures(virBitmapPtr *features,
                 int format,
E
Eric Blake 已提交
760
                 char *buf,
761 762 763 764 765
                 ssize_t len)
{
    int version = -1;
    virBitmapPtr feat = NULL;
    uint64_t bits;
766
    size_t i;
767 768 769 770 771 772 773 774 775

    version = virReadBufInt32BE(buf + fileTypeInfo[format].versionOffset);

    if (version == 2)
        return 0;

    if (len < QCOW2v3_HDR_SIZE)
        return -1;

776
    if (!(feat = virBitmapNew(VIR_STORAGE_FILE_FEATURE_LAST)))
777 778 779 780 781 782 783 784 785 786 787 788 789 790
        return -1;

    /* todo: check for incompatible or autoclear features? */
    bits = virReadBufInt64BE(buf + QCOW2v3_HDR_FEATURES_COMPATIBLE);
    for (i = 0; i < QCOW2_COMPATIBLE_FEATURE_LAST; i++) {
        if (bits & ((uint64_t) 1 << i))
            ignore_value(virBitmapSetBit(feat, qcow2CompatibleFeatureArray[i]));
    }

    *features = feat;
    return 0;
}


791 792 793 794 795
/* Given a header in BUF with length LEN, as parsed from the storage file
 * assuming it has the given FORMAT, populate information into META
 * with information about the file and its backing store. Return format
 * of the backing store as BACKING_FORMAT. PATH and FORMAT have to be
 * pre-populated in META */
796
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
797 798
ATTRIBUTE_NONNULL(4)
virStorageFileGetMetadataInternal(virStorageFileMetadataPtr meta,
799 800
                                  char *buf,
                                  size_t len,
801
                                  int *backingFormat)
802
{
803
    int ret = -1;
E
Eric Blake 已提交
804

805 806
    VIR_DEBUG("relPath=%s, buf=%p, len=%zu, meta->format=%d",
              meta->relPath, buf, len, meta->format);
E
Eric Blake 已提交
807

808
    if (meta->format == VIR_STORAGE_FILE_AUTO)
809
        meta->format = virStorageFileProbeFormatFromBuf(meta->relPath, buf, len);
810

811 812 813 814
    if (meta->format <= VIR_STORAGE_FILE_NONE ||
        meta->format >= VIR_STORAGE_FILE_LAST) {
        virReportSystemError(EINVAL, _("unknown storage file meta->format %d"),
                             meta->format);
E
Eric Blake 已提交
815 816
        goto cleanup;
    }
817

818 819 820
    /* XXX we should consider moving virStorageBackendUpdateVolInfo
     * code into this method, for non-magic files
     */
821
    if (!fileTypeInfo[meta->format].magic)
E
Eric Blake 已提交
822
        goto done;
823

824
    /* Optionally extract capacity from file */
825 826
    if (fileTypeInfo[meta->format].sizeOffset != -1) {
        if ((fileTypeInfo[meta->format].sizeOffset + 8) > len)
E
Eric Blake 已提交
827
            goto done;
828

829
        if (fileTypeInfo[meta->format].endian == LV_LITTLE_ENDIAN)
E
Eric Blake 已提交
830
            meta->capacity = virReadBufInt64LE(buf +
831
                                               fileTypeInfo[meta->format].sizeOffset);
E
Eric Blake 已提交
832 833
        else
            meta->capacity = virReadBufInt64BE(buf +
834
                                               fileTypeInfo[meta->format].sizeOffset);
835
        /* Avoid unlikely, but theoretically possible overflow */
E
Eric Blake 已提交
836
        if (meta->capacity > (ULLONG_MAX /
837
                              fileTypeInfo[meta->format].sizeMultiplier))
E
Eric Blake 已提交
838
            goto done;
839
        meta->capacity *= fileTypeInfo[meta->format].sizeMultiplier;
840
    }
841

842
    if (fileTypeInfo[meta->format].qcowCryptOffset != -1) {
843
        int crypt_format;
844

E
Eric Blake 已提交
845
        crypt_format = virReadBufInt32BE(buf +
846
                                         fileTypeInfo[meta->format].qcowCryptOffset);
847 848
        if (crypt_format && VIR_ALLOC(meta->encryption) < 0)
            goto cleanup;
849
    }
850

851 852
    if (fileTypeInfo[meta->format].getBackingStore != NULL) {
        int store = fileTypeInfo[meta->format].getBackingStore(&meta->backingStoreRaw,
853
                                                         backingFormat,
E
Eric Blake 已提交
854 855 856
                                                         buf, len);
        if (store == BACKING_STORE_INVALID)
            goto done;
857

E
Eric Blake 已提交
858 859
        if (store == BACKING_STORE_ERROR)
            goto cleanup;
860 861
    }

862 863
    if (fileTypeInfo[meta->format].getFeatures != NULL &&
        fileTypeInfo[meta->format].getFeatures(&meta->features, meta->format, buf, len) < 0)
864 865
        goto cleanup;

866
    if (meta->format == VIR_STORAGE_FILE_QCOW2 && meta->features &&
867 868 869
        VIR_STRDUP(meta->compat, "1.1") < 0)
        goto cleanup;

870
 done:
871
    ret = 0;
E
Eric Blake 已提交
872

873
 cleanup:
E
Eric Blake 已提交
874
    return ret;
875 876 877 878
}


/**
879
 * virStorageFileProbeFormat:
880
 *
881 882
 * Probe for the format of 'path', returning the detected
 * disk format.
883 884 885
 *
 * Callers are advised never to trust the returned 'format'
 * unless it is listed as VIR_STORAGE_FILE_RAW, since a
886
 * malicious guest can turn a raw file into any other non-raw
887 888 889 890 891
 * format at will.
 *
 * Best option: Don't use this function
 */
int
892
virStorageFileProbeFormat(const char *path, uid_t uid, gid_t gid)
893
{
894
    int fd;
895
    int ret = -1;
896
    struct stat sb;
897 898
    ssize_t len = VIR_STORAGE_MAX_HEADER;
    char *header = NULL;
899

900 901
    if ((fd = virFileOpenAs(path, O_RDONLY, 0, uid, gid, 0)) < 0) {
        virReportSystemError(-fd, _("Failed to open file '%s'"), path);
902 903 904
        return -1;
    }

905 906 907 908 909
    if (fstat(fd, &sb) < 0) {
        virReportSystemError(errno, _("cannot stat file '%s'"), path);
        goto cleanup;
    }

910 911
    /* No header to probe for directories */
    if (S_ISDIR(sb.st_mode)) {
912 913
        ret = VIR_STORAGE_FILE_DIR;
        goto cleanup;
914
    }
915 916 917 918 919 920

    if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
        virReportSystemError(errno, _("cannot set to start of '%s'"), path);
        goto cleanup;
    }

921
    if ((len = virFileReadHeaderFD(fd, len, &header)) < 0) {
922 923 924 925
        virReportSystemError(errno, _("cannot read header '%s'"), path);
        goto cleanup;
    }

926
    ret = virStorageFileProbeFormatFromBuf(path, header, len);
927

928
 cleanup:
929
    VIR_FREE(header);
930
    VIR_FORCE_CLOSE(fd);
931 932 933 934

    return ret;
}

935

936 937 938 939 940 941 942 943 944 945 946 947
static virStorageFileMetadataPtr
virStorageFileMetadataNew(const char *path,
                          int format)
{
    virStorageFileMetadataPtr ret = NULL;

    if (VIR_ALLOC(ret) < 0)
        return NULL;

    ret->format = format;
    ret->type = VIR_STORAGE_TYPE_FILE;

948
    if (VIR_STRDUP(ret->relPath, path) < 0)
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
        goto error;

    if (virStorageIsFile(path)) {
        if (!(ret->canonPath = canonicalize_file_name(path))) {
            virReportSystemError(errno, _("unable to resolve '%s'"), path);
            goto error;
        }
    } else {
        if (VIR_STRDUP(ret->canonPath, path) < 0)
            goto error;
    }

    return ret;

 error:
    virStorageFileFreeMetadata(ret);
    return NULL;
}


969 970 971 972 973 974
/**
 * virStorageFileGetMetadataFromBuf:
 * @path: name of file, for error messages
 * @buf: header bytes from @path
 * @len: length of @buf
 * @format: expected image format
975 976
 * @backing: output malloc'd name of backing image, if any
 * @backingFormat: format of @backing
977 978 979 980 981 982 983 984 985
 *
 * Extract metadata about the storage volume with the specified
 * image format. If image format is VIR_STORAGE_FILE_AUTO, it
 * will probe to automatically identify the format.  Does not recurse.
 *
 * Callers are advised never to use VIR_STORAGE_FILE_AUTO as a
 * format, since a malicious guest can turn a raw file into any
 * other non-raw format at will.
 *
986
 * If the returned @backingFormat is VIR_STORAGE_FILE_AUTO
987 988 989 990 991 992 993 994 995 996
 * it indicates the image didn't specify an explicit format for its
 * backing store. Callers are advised against probing for the
 * backing store format in this case.
 *
 * Caller MUST free the result after use via virStorageFileFreeMetadata.
 */
virStorageFileMetadataPtr
virStorageFileGetMetadataFromBuf(const char *path,
                                 char *buf,
                                 size_t len,
997 998 999
                                 int format,
                                 char **backing,
                                 int *backingFormat)
1000
{
1001
    virStorageFileMetadataPtr ret = NULL;
1002

1003
    if (!(ret = virStorageFileMetadataNew(path, format)))
1004
        return NULL;
1005

1006
    if (virStorageFileGetMetadataInternal(ret, buf, len,
1007
                                          backingFormat) < 0) {
1008 1009 1010
        virStorageFileFreeMetadata(ret);
        ret = NULL;
    }
1011

1012 1013 1014 1015 1016
    if (VIR_STRDUP(*backing, ret->backingStoreRaw) < 0) {
        virStorageFileFreeMetadata(ret);
        ret = NULL;
    }

1017
    return ret;
1018 1019 1020 1021
}


/* Internal version that also supports a containing directory name.  */
1022
static int
1023
virStorageFileGetMetadataFromFDInternal(virStorageFileMetadataPtr meta,
1024
                                        int fd,
1025
                                        int *backingFormat)
1026 1027
{
    char *buf = NULL;
1028
    ssize_t len = VIR_STORAGE_MAX_HEADER;
1029
    struct stat sb;
1030
    int ret = -1;
1031
    int dummy;
1032

1033 1034
    if (!backingFormat)
        backingFormat = &dummy;
1035

1036
    *backingFormat = VIR_STORAGE_FILE_NONE;
1037

1038 1039 1040
    if (fstat(fd, &sb) < 0) {
        virReportSystemError(errno,
                             _("cannot stat file '%s'"),
1041
                             meta->relPath);
1042
        return -1;
1043 1044 1045
    }

    if (S_ISDIR(sb.st_mode)) {
1046 1047 1048
        /* No header to probe for directories, but also no backing
         * file; therefore, no inclusion loop is possible, and we
         * don't need canonName or relDir.  */
1049 1050
        VIR_FREE(meta->relDir);
        VIR_FREE(meta->canonPath);
1051 1052
        meta->type = VIR_STORAGE_TYPE_DIR;
        meta->format = VIR_STORAGE_FILE_DIR;
1053
        ret = 0;
1054 1055 1056 1057
        goto cleanup;
    }

    if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
1058
        virReportSystemError(errno, _("cannot seek to start of '%s'"), meta->relPath);
1059 1060 1061 1062
        goto cleanup;
    }

    if ((len = virFileReadHeaderFD(fd, len, &buf)) < 0) {
1063
        virReportSystemError(errno, _("cannot read header '%s'"), meta->relPath);
1064 1065 1066
        goto cleanup;
    }

1067
    ret = virStorageFileGetMetadataInternal(meta, buf, len, backingFormat);
1068

1069 1070 1071 1072 1073 1074
    if (ret == 0) {
        if (S_ISREG(sb.st_mode))
            meta->type = VIR_STORAGE_TYPE_FILE;
        else if (S_ISBLK(sb.st_mode))
            meta->type = VIR_STORAGE_TYPE_BLOCK;
    }
1075
 cleanup:
1076 1077 1078 1079 1080
    VIR_FREE(buf);
    return ret;
}


1081 1082 1083
/**
 * virStorageFileGetMetadataFromFD:
 *
1084 1085
 * Extract metadata about the storage volume with the specified
 * image format. If image format is VIR_STORAGE_FILE_AUTO, it
1086
 * will probe to automatically identify the format.  Does not recurse.
1087
 *
1088 1089 1090 1091
 * Callers are advised never to use VIR_STORAGE_FILE_AUTO as a
 * format, since a malicious guest can turn a raw file into any
 * other non-raw format at will.
 *
1092
 * Caller MUST free the result after use via virStorageFileFreeMetadata.
1093
 */
1094
virStorageFileMetadataPtr
1095 1096
virStorageFileGetMetadataFromFD(const char *path,
                                int fd,
1097
                                int format)
1098
{
1099
    virStorageFileMetadataPtr ret = NULL;
1100

1101
    if (!(ret = virStorageFileMetadataNew(path, format)))
1102
        goto cleanup;
1103 1104

    if (virStorageFileGetMetadataFromFDInternal(ret, fd, NULL) < 0) {
1105 1106 1107 1108 1109
        virStorageFileFreeMetadata(ret);
        ret = NULL;
    }

 cleanup:
1110
    return ret;
1111 1112
}

1113

1114
/* Recursive workhorse for virStorageFileGetMetadata.  */
1115
static int
1116 1117
virStorageFileGetMetadataRecurse(const char *path, const char *canonPath,
                                 const char *directory,
1118
                                 int format, uid_t uid, gid_t gid,
1119 1120
                                 bool allow_probe, virHashTablePtr cycle,
                                 virStorageFileMetadataPtr meta)
1121 1122
{
    int fd;
1123
    int ret = -1;
1124
    int backingFormat;
1125
    char *backingDirectory = NULL;
1126

1127 1128 1129
    VIR_DEBUG("path=%s canonPath=%s dir=%s format=%d uid=%d gid=%d probe=%d",
              path, canonPath, NULLSTR(directory), format,
              (int)uid, (int)gid, allow_probe);
1130

1131
    if (virHashLookup(cycle, canonPath)) {
1132 1133 1134
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("backing store for %s is self-referential"),
                       path);
1135
        return -1;
1136
    }
1137
    if (virHashAddEntry(cycle, canonPath, (void *)1) < 0)
1138
        return -1;
1139

1140
    if (virStorageIsFile(path)) {
1141
        if (VIR_STRDUP(meta->relPath, path) < 0)
1142 1143 1144 1145 1146 1147 1148
            return -1;
        if (VIR_STRDUP(meta->canonPath, canonPath) < 0)
            return -1;
        if (VIR_STRDUP(meta->relDir, directory) < 0)
            return -1;
        meta->format = format;

1149 1150 1151 1152
        if ((fd = virFileOpenAs(canonPath, O_RDONLY, 0, uid, gid, 0)) < 0) {
            virReportSystemError(-fd, _("Failed to open file '%s'"), path);
            return -1;
        }
1153

1154
        ret = virStorageFileGetMetadataFromFDInternal(meta, fd, &backingFormat);
1155

1156 1157 1158 1159 1160 1161
        if (VIR_CLOSE(fd) < 0)
            VIR_WARN("could not close file %s", path);
    } else {
        /* FIXME: when the proper storage drivers are compiled in, it
         * would be nice to read metadata from the network storage to
         * allow for non-raw images.  */
1162
        if (VIR_STRDUP(meta->relPath, path) < 0)
1163 1164 1165 1166 1167 1168 1169
            return -1;
        if (VIR_STRDUP(meta->canonPath, path) < 0)
            return -1;
        meta->type = VIR_STORAGE_TYPE_NETWORK;
        meta->format = VIR_STORAGE_FILE_RAW;
        ret = 0;
    }
1170

1171
    if (ret == 0 && meta->backingStoreRaw) {
1172 1173
        virStorageFileMetadataPtr backing;

1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
        if (virStorageIsFile(meta->backingStoreRaw)) {
            if (virFindBackingFile(directory,
                                   meta->backingStoreRaw,
                                   &backingDirectory,
                                   &meta->backingStore) < 0) {
                /* the backing file is (currently) unavailable, treat this
                 * file as standalone:
                 * backingStoreRaw is kept to mark broken image chains */
                VIR_WARN("Backing file '%s' of image '%s' is missing.",
                         meta->backingStoreRaw, path);

                return 0;
            }
        } else {
            if (VIR_STRDUP(meta->backingStore, meta->backingStoreRaw) < 0)
                return -1;
        }

1192 1193 1194 1195
        if (backingFormat == VIR_STORAGE_FILE_AUTO && !allow_probe)
            backingFormat = VIR_STORAGE_FILE_RAW;
        else if (backingFormat == VIR_STORAGE_FILE_AUTO_SAFE)
            backingFormat = VIR_STORAGE_FILE_AUTO;
1196 1197 1198
        if (VIR_ALLOC(backing) < 0 ||
            virStorageFileGetMetadataRecurse(meta->backingStoreRaw,
                                             meta->backingStore,
1199
                                             backingDirectory, backingFormat,
1200 1201
                                             uid, gid, allow_probe,
                                             cycle, backing) < 0) {
1202
            /* If we failed to get backing data, mark the chain broken */
1203 1204 1205 1206
            VIR_FREE(meta->backingStore);
            virStorageFileFreeMetadata(backing);
        } else {
            meta->backingMeta = backing;
1207
        }
1208
    }
1209
    VIR_FREE(backingDirectory);
1210 1211 1212
    return ret;
}

1213 1214 1215
/**
 * virStorageFileGetMetadata:
 *
1216 1217
 * Extract metadata about the storage volume with the specified
 * image format. If image format is VIR_STORAGE_FILE_AUTO, it
1218 1219 1220 1221 1222
 * will probe to automatically identify the format.  Recurses through
 * the entire chain.
 *
 * Open files using UID and GID (or pass -1 for the current user/group).
 * Treat any backing files without explicit type as raw, unless ALLOW_PROBE.
1223
 *
1224 1225 1226 1227
 * Callers are advised never to use VIR_STORAGE_FILE_AUTO as a
 * format, since a malicious guest can turn a raw file into any
 * other non-raw format at will.
 *
1228
 * Caller MUST free result after use via virStorageFileFreeMetadata.
1229
 */
1230 1231 1232 1233
virStorageFileMetadataPtr
virStorageFileGetMetadata(const char *path, int format,
                          uid_t uid, gid_t gid,
                          bool allow_probe)
1234
{
1235 1236 1237
    VIR_DEBUG("path=%s format=%d uid=%d gid=%d probe=%d",
              path, format, (int)uid, (int)gid, allow_probe);

1238
    virHashTablePtr cycle = virHashCreate(5, NULL);
1239
    virStorageFileMetadataPtr meta = NULL;
1240
    virStorageFileMetadataPtr ret = NULL;
1241 1242
    char *canonPath = NULL;
    char *directory = NULL;
1243

E
Eric Blake 已提交
1244
    if (!cycle)
1245
        return NULL;
1246

1247
    if (virStorageIsFile(path)) {
1248 1249 1250 1251 1252 1253 1254 1255 1256
        if (!(canonPath = canonicalize_file_name(path))) {
            virReportSystemError(errno, _("unable to resolve '%s'"), path);
            goto cleanup;
        }
        if (!(directory = mdir_name(path))) {
            virReportOOMError();
            goto cleanup;
        }
    } else if (VIR_STRDUP(canonPath, path) < 0) {
1257 1258
        goto cleanup;
    }
1259 1260
    if (VIR_ALLOC(meta) < 0)
        goto cleanup;
1261

1262 1263
    if (format <= VIR_STORAGE_FILE_NONE)
        format = allow_probe ? VIR_STORAGE_FILE_AUTO : VIR_STORAGE_FILE_RAW;
1264 1265 1266 1267 1268 1269 1270
    if (virStorageFileGetMetadataRecurse(path, canonPath, directory, format,
                                         uid, gid, allow_probe, cycle,
                                         meta) < 0)
        goto cleanup;
    ret = meta;
    meta = NULL;

1271
 cleanup:
1272
    virStorageFileFreeMetadata(meta);
1273
    VIR_FREE(canonPath);
1274
    VIR_FREE(directory);
1275
    virHashFree(cycle);
1276 1277
    return ret;
}
1278

1279 1280 1281 1282 1283
/**
 * virStorageFileChainCheckBroken
 *
 * If CHAIN is broken, set *brokenFile to the broken file name,
 * otherwise set it to NULL. Caller MUST free *brokenFile after use.
1284 1285
 * Return 0 on success (including when brokenFile is set), negative on
 * error (allocation failure).
1286 1287 1288 1289 1290 1291 1292
 */
int
virStorageFileChainGetBroken(virStorageFileMetadataPtr chain,
                             char **brokenFile)
{
    virStorageFileMetadataPtr tmp;

1293 1294
    *brokenFile = NULL;

1295 1296 1297
    if (!chain)
        return 0;

1298
    for (tmp = chain; tmp; tmp = tmp->backingMeta) {
1299 1300
        /* Break when we hit end of chain; report error if we detected
         * a missing backing file, infinite loop, or other error */
1301 1302 1303
        if (!tmp->backingMeta && tmp->backingStoreRaw) {
            if (VIR_STRDUP(*brokenFile, tmp->backingStoreRaw) < 0)
                return -1;
1304

1305 1306 1307
           return 0;
        }
    }
1308

1309
    return 0;
1310 1311 1312
}


1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
/**
 * virStorageFileFreeMetadata:
 *
 * Free pointers in passed structure and structure itself.
 */
void
virStorageFileFreeMetadata(virStorageFileMetadata *meta)
{
    if (!meta)
        return;

1324
    VIR_FREE(meta->relPath);
1325 1326 1327
    VIR_FREE(meta->canonPath);
    VIR_FREE(meta->relDir);

1328
    virStorageFileFreeMetadata(meta->backingMeta);
1329
    VIR_FREE(meta->backingStore);
1330
    VIR_FREE(meta->backingStoreRaw);
1331 1332
    VIR_FREE(meta->compat);
    virBitmapFree(meta->features);
1333
    virStorageEncryptionFree(meta->encryption);
1334 1335
    VIR_FREE(meta);
}
1336

1337 1338 1339 1340 1341 1342
/**
 * virStorageFileResize:
 *
 * Change the capacity of the raw storage file at 'path'.
 */
int
1343 1344 1345 1346
virStorageFileResize(const char *path,
                     unsigned long long capacity,
                     unsigned long long orig_capacity,
                     bool pre_allocate)
1347
{
1348 1349
    int fd = -1;
    int ret = -1;
1350 1351 1352 1353 1354 1355
    int rc ATTRIBUTE_UNUSED;
    off_t offset ATTRIBUTE_UNUSED;
    off_t len ATTRIBUTE_UNUSED;

    offset = orig_capacity;
    len = capacity - orig_capacity;
1356 1357 1358 1359 1360 1361

    if ((fd = open(path, O_RDWR)) < 0) {
        virReportSystemError(errno, _("Unable to open '%s'"), path);
        goto cleanup;
    }

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
    if (pre_allocate) {
#if HAVE_POSIX_FALLOCATE
        if ((rc = posix_fallocate(fd, offset, len)) != 0) {
            virReportSystemError(rc,
                                 _("Failed to pre-allocate space for "
                                   "file '%s'"), path);
            goto cleanup;
        }
#elif HAVE_SYS_SYSCALL_H && defined(SYS_fallocate)
        if (syscall(SYS_fallocate, fd, 0, offset, len) != 0) {
            virReportSystemError(errno,
1373
                                 _("Failed to pre-allocate space for "
1374 1375 1376 1377 1378
                                   "file '%s'"), path);
            goto cleanup;
        }
#else
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
1379
                       _("preallocate is not supported on this platform"));
1380
        goto cleanup;
1381 1382 1383 1384 1385 1386 1387
#endif
    } else {
        if (ftruncate(fd, capacity) < 0) {
            virReportSystemError(errno,
                                 _("Failed to truncate file '%s'"), path);
            goto cleanup;
        }
1388 1389
    }

1390 1391 1392 1393 1394 1395 1396
    if (VIR_CLOSE(fd) < 0) {
        virReportSystemError(errno, _("Unable to save '%s'"), path);
        goto cleanup;
    }

    ret = 0;

1397
 cleanup:
1398 1399
    VIR_FORCE_CLOSE(fd);
    return ret;
1400 1401
}

1402 1403 1404 1405 1406 1407

int virStorageFileIsClusterFS(const char *path)
{
    /* These are coherent cluster filesystems known to be safe for
     * migration with cache != none
     */
1408 1409 1410
    return virFileIsSharedFSType(path,
                                 VIR_FILE_SHFS_GFS2 |
                                 VIR_FILE_SHFS_OCFS);
1411
}
1412 1413

#ifdef LVS
1414 1415
int virStorageFileGetLVMKey(const char *path,
                            char **key)
1416 1417 1418 1419 1420
{
    /*
     *  # lvs --noheadings --unbuffered --nosuffix --options "uuid" LVNAME
     *    06UgP5-2rhb-w3Bo-3mdR-WeoL-pytO-SAa2ky
     */
1421
    int status;
1422 1423 1424 1425 1426 1427
    virCommandPtr cmd = virCommandNewArgList(
        LVS,
        "--noheadings", "--unbuffered", "--nosuffix",
        "--options", "uuid", path,
        NULL
        );
1428 1429 1430
    int ret = -1;

    *key = NULL;
1431 1432

    /* Run the program and capture its output */
1433 1434
    virCommandSetOutputBuffer(cmd, key);
    if (virCommandRun(cmd, &status) < 0)
1435 1436
        goto cleanup;

1437 1438 1439 1440 1441 1442
    /* Explicitly check status == 0, rather than passing NULL
     * to virCommandRun because we don't want to raise an actual
     * error in this scenario, just return a NULL key.
     */

    if (status == 0 && *key) {
1443
        char *nl;
1444
        char *tmp = *key;
1445 1446 1447 1448 1449 1450

        /* Find first non-space character */
        while (*tmp && c_isspace(*tmp)) {
            tmp++;
        }
        /* Kill leading spaces */
1451 1452
        if (tmp != *key)
            memmove(*key, tmp, strlen(tmp)+1);
1453 1454

        /* Kill trailing newline */
1455
        if ((nl = strchr(*key, '\n')))
1456 1457 1458
            *nl = '\0';
    }

1459
    ret = 0;
1460

1461
 cleanup:
1462 1463 1464
    if (*key && STREQ(*key, ""))
        VIR_FREE(*key);

1465 1466
    virCommandFree(cmd);

1467
    return ret;
1468 1469
}
#else
1470 1471
int virStorageFileGetLVMKey(const char *path,
                            char **key ATTRIBUTE_UNUSED)
1472 1473
{
    virReportSystemError(ENOSYS, _("Unable to get LVM key for %s"), path);
1474
    return -1;
1475 1476 1477
}
#endif

1478
#ifdef WITH_UDEV
1479 1480
int virStorageFileGetSCSIKey(const char *path,
                             char **key)
1481
{
1482
    int status;
1483 1484 1485 1486 1487 1488 1489
    virCommandPtr cmd = virCommandNewArgList(
        "/lib/udev/scsi_id",
        "--replace-whitespace",
        "--whitelisted",
        "--device", path,
        NULL
        );
1490 1491 1492
    int ret = -1;

    *key = NULL;
1493 1494

    /* Run the program and capture its output */
1495 1496
    virCommandSetOutputBuffer(cmd, key);
    if (virCommandRun(cmd, &status) < 0)
1497 1498
        goto cleanup;

1499 1500 1501 1502 1503 1504
    /* Explicitly check status == 0, rather than passing NULL
     * to virCommandRun because we don't want to raise an actual
     * error in this scenario, just return a NULL key.
     */
    if (status == 0 && *key) {
        char *nl = strchr(*key, '\n');
1505 1506 1507 1508
        if (nl)
            *nl = '\0';
    }

1509 1510
    ret = 0;

1511
 cleanup:
1512 1513 1514
    if (*key && STREQ(*key, ""))
        VIR_FREE(*key);

1515 1516
    virCommandFree(cmd);

1517
    return ret;
1518 1519
}
#else
1520 1521
int virStorageFileGetSCSIKey(const char *path,
                             char **key ATTRIBUTE_UNUSED)
1522 1523
{
    virReportSystemError(ENOSYS, _("Unable to get SCSI key for %s"), path);
1524
    return -1;
1525 1526
}
#endif
1527

1528 1529 1530 1531 1532 1533 1534
/* Given a CHAIN, look for the backing file NAME within the chain and
 * return its canonical name.  Pass NULL for NAME to find the base of
 * the chain.  If META is not NULL, set *META to the point in the
 * chain that describes NAME (or to NULL if the backing element is not
 * a file).  If PARENT is not NULL, set *PARENT to the preferred name
 * of the parent (or to NULL if NAME matches the start of the chain).
 * Since the results point within CHAIN, they must not be
1535 1536
 * independently freed.  Reports an error and returns NULL if NAME is
 * not found.  */
1537
const char *
1538
virStorageFileChainLookup(virStorageFileMetadataPtr chain,
1539 1540 1541
                          const char *name, virStorageFileMetadataPtr *meta,
                          const char **parent)
{
1542
    const char *start = chain->canonPath;
1543
    const char *tmp;
E
Eric Blake 已提交
1544 1545
    const char *parentDir = ".";
    bool nameIsFile = virStorageIsFile(name);
1546 1547 1548 1549 1550

    if (!parent)
        parent = &tmp;

    *parent = NULL;
E
Eric Blake 已提交
1551
    while (chain) {
1552
        if (!name) {
E
Eric Blake 已提交
1553
            if (!chain->backingMeta)
1554
                break;
E
Eric Blake 已提交
1555
        } else {
1556
            if (STREQ(name, chain->relPath))
1557
                break;
E
Eric Blake 已提交
1558 1559 1560 1561 1562 1563 1564 1565 1566
            if (nameIsFile && (chain->type == VIR_STORAGE_TYPE_FILE ||
                               chain->type == VIR_STORAGE_TYPE_BLOCK)) {
                int result = virFileRelLinkPointsTo(parentDir, name,
                                                    chain->canonPath);
                if (result < 0)
                    goto error;
                if (result > 0)
                    break;
            }
1567
        }
E
Eric Blake 已提交
1568 1569 1570
        *parent = chain->canonPath;
        parentDir = chain->relDir;
        chain = chain->backingMeta;
1571
    }
E
Eric Blake 已提交
1572
    if (!chain)
1573 1574
        goto error;
    if (meta)
E
Eric Blake 已提交
1575 1576
        *meta = chain;
    return chain->canonPath;
1577

1578
 error:
1579 1580 1581 1582 1583 1584 1585 1586
    if (name)
        virReportError(VIR_ERR_INVALID_ARG,
                       _("could not find image '%s' in chain for '%s'"),
                       name, start);
    else
        virReportError(VIR_ERR_INVALID_ARG,
                       _("could not find base image in chain for '%s'"),
                       start);
1587 1588 1589 1590 1591
    *parent = NULL;
    if (meta)
        *meta = NULL;
    return NULL;
}
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653


void
virStorageNetHostDefClear(virStorageNetHostDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->name);
    VIR_FREE(def->port);
    VIR_FREE(def->socket);
}


void
virStorageNetHostDefFree(size_t nhosts,
                         virStorageNetHostDefPtr hosts)
{
    size_t i;

    if (!hosts)
        return;

    for (i = 0; i < nhosts; i++)
        virStorageNetHostDefClear(&hosts[i]);

    VIR_FREE(hosts);
}


virStorageNetHostDefPtr
virStorageNetHostDefCopy(size_t nhosts,
                         virStorageNetHostDefPtr hosts)
{
    virStorageNetHostDefPtr ret = NULL;
    size_t i;

    if (VIR_ALLOC_N(ret, nhosts) < 0)
        goto error;

    for (i = 0; i < nhosts; i++) {
        virStorageNetHostDefPtr src = &hosts[i];
        virStorageNetHostDefPtr dst = &ret[i];

        dst->transport = src->transport;

        if (VIR_STRDUP(dst->name, src->name) < 0)
            goto error;

        if (VIR_STRDUP(dst->port, src->port) < 0)
            goto error;

        if (VIR_STRDUP(dst->socket, src->socket) < 0)
            goto error;
    }

    return ret;

 error:
    virStorageNetHostDefFree(nhosts, ret);
    return NULL;
}
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680


void
virStorageSourcePoolDefFree(virStorageSourcePoolDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->pool);
    VIR_FREE(def->volume);

    VIR_FREE(def);
}


void
virStorageSourceAuthClear(virStorageSourcePtr def)
{
    VIR_FREE(def->auth.username);

    if (def->auth.secretType == VIR_STORAGE_SECRET_TYPE_USAGE)
        VIR_FREE(def->auth.secret.usage);

    def->auth.secretType = VIR_STORAGE_SECRET_TYPE_NONE;
}


1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
int
virStorageSourceGetActualType(virStorageSourcePtr def)
{
    if (def->type == VIR_STORAGE_TYPE_VOLUME && def->srcpool)
        return def->srcpool->actualtype;

    return def->type;
}


1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
void
virStorageSourceClear(virStorageSourcePtr def)
{
    size_t i;

    if (!def)
        return;

    VIR_FREE(def->path);
    virStorageSourcePoolDefFree(def->srcpool);
    VIR_FREE(def->driverName);
E
Eric Blake 已提交
1702 1703
    virBitmapFree(def->features);
    VIR_FREE(def->compat);
1704 1705 1706 1707 1708 1709 1710
    virStorageEncryptionFree(def->encryption);

    if (def->seclabels) {
        for (i = 0; i < def->nseclabels; i++)
            virSecurityDeviceLabelDefFree(def->seclabels[i]);
        VIR_FREE(def->seclabels);
    }
E
Eric Blake 已提交
1711 1712 1713 1714 1715
    if (def->perms) {
        VIR_FREE(def->perms->label);
        VIR_FREE(def->perms);
    }
    VIR_FREE(def->timestamps);
1716 1717 1718 1719

    virStorageNetHostDefFree(def->nhosts, def->hosts);
    virStorageSourceAuthClear(def);
}