![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qed.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to qed.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 ! root 1: /* ! 2: * QEMU Enhanced Disk Format ! 3: * ! 4: * Copyright IBM, Corp. 2010 ! 5: * ! 6: * Authors: ! 7: * Stefan Hajnoczi <[email protected]> ! 8: * Anthony Liguori <[email protected]> ! 9: * ! 10: * This work is licensed under the terms of the GNU LGPL, version 2 or later. ! 11: * See the COPYING.LIB file in the top-level directory. ! 12: * ! 13: */ ! 14: ! 15: #include "trace.h" ! 16: #include "qed.h" ! 17: #include "qerror.h" ! 18: ! 19: static void qed_aio_cancel(BlockDriverAIOCB *blockacb) ! 20: { ! 21: QEDAIOCB *acb = (QEDAIOCB *)blockacb; ! 22: bool finished = false; ! 23: ! 24: /* Wait for the request to finish */ ! 25: acb->finished = &finished; ! 26: while (!finished) { ! 27: qemu_aio_wait(); ! 28: } ! 29: } ! 30: ! 31: static AIOPool qed_aio_pool = { ! 32: .aiocb_size = sizeof(QEDAIOCB), ! 33: .cancel = qed_aio_cancel, ! 34: }; ! 35: ! 36: static int bdrv_qed_probe(const uint8_t *buf, int buf_size, ! 37: const char *filename) ! 38: { ! 39: const QEDHeader *header = (const QEDHeader *)buf; ! 40: ! 41: if (buf_size < sizeof(*header)) { ! 42: return 0; ! 43: } ! 44: if (le32_to_cpu(header->magic) != QED_MAGIC) { ! 45: return 0; ! 46: } ! 47: return 100; ! 48: } ! 49: ! 50: /** ! 51: * Check whether an image format is raw ! 52: * ! 53: * @fmt: Backing file format, may be NULL ! 54: */ ! 55: static bool qed_fmt_is_raw(const char *fmt) ! 56: { ! 57: return fmt && strcmp(fmt, "raw") == 0; ! 58: } ! 59: ! 60: static void qed_header_le_to_cpu(const QEDHeader *le, QEDHeader *cpu) ! 61: { ! 62: cpu->magic = le32_to_cpu(le->magic); ! 63: cpu->cluster_size = le32_to_cpu(le->cluster_size); ! 64: cpu->table_size = le32_to_cpu(le->table_size); ! 65: cpu->header_size = le32_to_cpu(le->header_size); ! 66: cpu->features = le64_to_cpu(le->features); ! 67: cpu->compat_features = le64_to_cpu(le->compat_features); ! 68: cpu->autoclear_features = le64_to_cpu(le->autoclear_features); ! 69: cpu->l1_table_offset = le64_to_cpu(le->l1_table_offset); ! 70: cpu->image_size = le64_to_cpu(le->image_size); ! 71: cpu->backing_filename_offset = le32_to_cpu(le->backing_filename_offset); ! 72: cpu->backing_filename_size = le32_to_cpu(le->backing_filename_size); ! 73: } ! 74: ! 75: static void qed_header_cpu_to_le(const QEDHeader *cpu, QEDHeader *le) ! 76: { ! 77: le->magic = cpu_to_le32(cpu->magic); ! 78: le->cluster_size = cpu_to_le32(cpu->cluster_size); ! 79: le->table_size = cpu_to_le32(cpu->table_size); ! 80: le->header_size = cpu_to_le32(cpu->header_size); ! 81: le->features = cpu_to_le64(cpu->features); ! 82: le->compat_features = cpu_to_le64(cpu->compat_features); ! 83: le->autoclear_features = cpu_to_le64(cpu->autoclear_features); ! 84: le->l1_table_offset = cpu_to_le64(cpu->l1_table_offset); ! 85: le->image_size = cpu_to_le64(cpu->image_size); ! 86: le->backing_filename_offset = cpu_to_le32(cpu->backing_filename_offset); ! 87: le->backing_filename_size = cpu_to_le32(cpu->backing_filename_size); ! 88: } ! 89: ! 90: static int qed_write_header_sync(BDRVQEDState *s) ! 91: { ! 92: QEDHeader le; ! 93: int ret; ! 94: ! 95: qed_header_cpu_to_le(&s->header, &le); ! 96: ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le)); ! 97: if (ret != sizeof(le)) { ! 98: return ret; ! 99: } ! 100: return 0; ! 101: } ! 102: ! 103: typedef struct { ! 104: GenericCB gencb; ! 105: BDRVQEDState *s; ! 106: struct iovec iov; ! 107: QEMUIOVector qiov; ! 108: int nsectors; ! 109: uint8_t *buf; ! 110: } QEDWriteHeaderCB; ! 111: ! 112: static void qed_write_header_cb(void *opaque, int ret) ! 113: { ! 114: QEDWriteHeaderCB *write_header_cb = opaque; ! 115: ! 116: qemu_vfree(write_header_cb->buf); ! 117: gencb_complete(write_header_cb, ret); ! 118: } ! 119: ! 120: static void qed_write_header_read_cb(void *opaque, int ret) ! 121: { ! 122: QEDWriteHeaderCB *write_header_cb = opaque; ! 123: BDRVQEDState *s = write_header_cb->s; ! 124: BlockDriverAIOCB *acb; ! 125: ! 126: if (ret) { ! 127: qed_write_header_cb(write_header_cb, ret); ! 128: return; ! 129: } ! 130: ! 131: /* Update header */ ! 132: qed_header_cpu_to_le(&s->header, (QEDHeader *)write_header_cb->buf); ! 133: ! 134: acb = bdrv_aio_writev(s->bs->file, 0, &write_header_cb->qiov, ! 135: write_header_cb->nsectors, qed_write_header_cb, ! 136: write_header_cb); ! 137: if (!acb) { ! 138: qed_write_header_cb(write_header_cb, -EIO); ! 139: } ! 140: } ! 141: ! 142: /** ! 143: * Update header in-place (does not rewrite backing filename or other strings) ! 144: * ! 145: * This function only updates known header fields in-place and does not affect ! 146: * extra data after the QED header. ! 147: */ ! 148: static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, ! 149: void *opaque) ! 150: { ! 151: /* We must write full sectors for O_DIRECT but cannot necessarily generate ! 152: * the data following the header if an unrecognized compat feature is ! 153: * active. Therefore, first read the sectors containing the header, update ! 154: * them, and write back. ! 155: */ ! 156: ! 157: BlockDriverAIOCB *acb; ! 158: int nsectors = (sizeof(QEDHeader) + BDRV_SECTOR_SIZE - 1) / ! 159: BDRV_SECTOR_SIZE; ! 160: size_t len = nsectors * BDRV_SECTOR_SIZE; ! 161: QEDWriteHeaderCB *write_header_cb = gencb_alloc(sizeof(*write_header_cb), ! 162: cb, opaque); ! 163: ! 164: write_header_cb->s = s; ! 165: write_header_cb->nsectors = nsectors; ! 166: write_header_cb->buf = qemu_blockalign(s->bs, len); ! 167: write_header_cb->iov.iov_base = write_header_cb->buf; ! 168: write_header_cb->iov.iov_len = len; ! 169: qemu_iovec_init_external(&write_header_cb->qiov, &write_header_cb->iov, 1); ! 170: ! 171: acb = bdrv_aio_readv(s->bs->file, 0, &write_header_cb->qiov, nsectors, ! 172: qed_write_header_read_cb, write_header_cb); ! 173: if (!acb) { ! 174: qed_write_header_cb(write_header_cb, -EIO); ! 175: } ! 176: } ! 177: ! 178: static uint64_t qed_max_image_size(uint32_t cluster_size, uint32_t table_size) ! 179: { ! 180: uint64_t table_entries; ! 181: uint64_t l2_size; ! 182: ! 183: table_entries = (table_size * cluster_size) / sizeof(uint64_t); ! 184: l2_size = table_entries * cluster_size; ! 185: ! 186: return l2_size * table_entries; ! 187: } ! 188: ! 189: static bool qed_is_cluster_size_valid(uint32_t cluster_size) ! 190: { ! 191: if (cluster_size < QED_MIN_CLUSTER_SIZE || ! 192: cluster_size > QED_MAX_CLUSTER_SIZE) { ! 193: return false; ! 194: } ! 195: if (cluster_size & (cluster_size - 1)) { ! 196: return false; /* not power of 2 */ ! 197: } ! 198: return true; ! 199: } ! 200: ! 201: static bool qed_is_table_size_valid(uint32_t table_size) ! 202: { ! 203: if (table_size < QED_MIN_TABLE_SIZE || ! 204: table_size > QED_MAX_TABLE_SIZE) { ! 205: return false; ! 206: } ! 207: if (table_size & (table_size - 1)) { ! 208: return false; /* not power of 2 */ ! 209: } ! 210: return true; ! 211: } ! 212: ! 213: static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size, ! 214: uint32_t table_size) ! 215: { ! 216: if (image_size % BDRV_SECTOR_SIZE != 0) { ! 217: return false; /* not multiple of sector size */ ! 218: } ! 219: if (image_size > qed_max_image_size(cluster_size, table_size)) { ! 220: return false; /* image is too large */ ! 221: } ! 222: return true; ! 223: } ! 224: ! 225: /** ! 226: * Read a string of known length from the image file ! 227: * ! 228: * @file: Image file ! 229: * @offset: File offset to start of string, in bytes ! 230: * @n: String length in bytes ! 231: * @buf: Destination buffer ! 232: * @buflen: Destination buffer length in bytes ! 233: * @ret: 0 on success, -errno on failure ! 234: * ! 235: * The string is NUL-terminated. ! 236: */ ! 237: static int qed_read_string(BlockDriverState *file, uint64_t offset, size_t n, ! 238: char *buf, size_t buflen) ! 239: { ! 240: int ret; ! 241: if (n >= buflen) { ! 242: return -EINVAL; ! 243: } ! 244: ret = bdrv_pread(file, offset, buf, n); ! 245: if (ret < 0) { ! 246: return ret; ! 247: } ! 248: buf[n] = '\0'; ! 249: return 0; ! 250: } ! 251: ! 252: /** ! 253: * Allocate new clusters ! 254: * ! 255: * @s: QED state ! 256: * @n: Number of contiguous clusters to allocate ! 257: * @ret: Offset of first allocated cluster ! 258: * ! 259: * This function only produces the offset where the new clusters should be ! 260: * written. It updates BDRVQEDState but does not make any changes to the image ! 261: * file. ! 262: */ ! 263: static uint64_t qed_alloc_clusters(BDRVQEDState *s, unsigned int n) ! 264: { ! 265: uint64_t offset = s->file_size; ! 266: s->file_size += n * s->header.cluster_size; ! 267: return offset; ! 268: } ! 269: ! 270: QEDTable *qed_alloc_table(BDRVQEDState *s) ! 271: { ! 272: /* Honor O_DIRECT memory alignment requirements */ ! 273: return qemu_blockalign(s->bs, ! 274: s->header.cluster_size * s->header.table_size); ! 275: } ! 276: ! 277: /** ! 278: * Allocate a new zeroed L2 table ! 279: */ ! 280: static CachedL2Table *qed_new_l2_table(BDRVQEDState *s) ! 281: { ! 282: CachedL2Table *l2_table = qed_alloc_l2_cache_entry(&s->l2_cache); ! 283: ! 284: l2_table->table = qed_alloc_table(s); ! 285: l2_table->offset = qed_alloc_clusters(s, s->header.table_size); ! 286: ! 287: memset(l2_table->table->offsets, 0, ! 288: s->header.cluster_size * s->header.table_size); ! 289: return l2_table; ! 290: } ! 291: ! 292: static void qed_aio_next_io(void *opaque, int ret); ! 293: ! 294: static int bdrv_qed_open(BlockDriverState *bs, int flags) ! 295: { ! 296: BDRVQEDState *s = bs->opaque; ! 297: QEDHeader le_header; ! 298: int64_t file_size; ! 299: int ret; ! 300: ! 301: s->bs = bs; ! 302: QSIMPLEQ_INIT(&s->allocating_write_reqs); ! 303: ! 304: ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header)); ! 305: if (ret < 0) { ! 306: return ret; ! 307: } ! 308: ret = 0; /* ret should always be 0 or -errno */ ! 309: qed_header_le_to_cpu(&le_header, &s->header); ! 310: ! 311: if (s->header.magic != QED_MAGIC) { ! 312: return -EINVAL; ! 313: } ! 314: if (s->header.features & ~QED_FEATURE_MASK) { ! 315: /* image uses unsupported feature bits */ ! 316: char buf[64]; ! 317: snprintf(buf, sizeof(buf), "%" PRIx64, ! 318: s->header.features & ~QED_FEATURE_MASK); ! 319: qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, ! 320: bs->device_name, "QED", buf); ! 321: return -ENOTSUP; ! 322: } ! 323: if (!qed_is_cluster_size_valid(s->header.cluster_size)) { ! 324: return -EINVAL; ! 325: } ! 326: ! 327: /* Round down file size to the last cluster */ ! 328: file_size = bdrv_getlength(bs->file); ! 329: if (file_size < 0) { ! 330: return file_size; ! 331: } ! 332: s->file_size = qed_start_of_cluster(s, file_size); ! 333: ! 334: if (!qed_is_table_size_valid(s->header.table_size)) { ! 335: return -EINVAL; ! 336: } ! 337: if (!qed_is_image_size_valid(s->header.image_size, ! 338: s->header.cluster_size, ! 339: s->header.table_size)) { ! 340: return -EINVAL; ! 341: } ! 342: if (!qed_check_table_offset(s, s->header.l1_table_offset)) { ! 343: return -EINVAL; ! 344: } ! 345: ! 346: s->table_nelems = (s->header.cluster_size * s->header.table_size) / ! 347: sizeof(uint64_t); ! 348: s->l2_shift = ffs(s->header.cluster_size) - 1; ! 349: s->l2_mask = s->table_nelems - 1; ! 350: s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1; ! 351: ! 352: if ((s->header.features & QED_F_BACKING_FILE)) { ! 353: if ((uint64_t)s->header.backing_filename_offset + ! 354: s->header.backing_filename_size > ! 355: s->header.cluster_size * s->header.header_size) { ! 356: return -EINVAL; ! 357: } ! 358: ! 359: ret = qed_read_string(bs->file, s->header.backing_filename_offset, ! 360: s->header.backing_filename_size, bs->backing_file, ! 361: sizeof(bs->backing_file)); ! 362: if (ret < 0) { ! 363: return ret; ! 364: } ! 365: ! 366: if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) { ! 367: pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw"); ! 368: } ! 369: } ! 370: ! 371: /* Reset unknown autoclear feature bits. This is a backwards ! 372: * compatibility mechanism that allows images to be opened by older ! 373: * programs, which "knock out" unknown feature bits. When an image is ! 374: * opened by a newer program again it can detect that the autoclear ! 375: * feature is no longer valid. ! 376: */ ! 377: if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 && ! 378: !bdrv_is_read_only(bs->file)) { ! 379: s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK; ! 380: ! 381: ret = qed_write_header_sync(s); ! 382: if (ret) { ! 383: return ret; ! 384: } ! 385: ! 386: /* From here on only known autoclear feature bits are valid */ ! 387: bdrv_flush(bs->file); ! 388: } ! 389: ! 390: s->l1_table = qed_alloc_table(s); ! 391: qed_init_l2_cache(&s->l2_cache); ! 392: ! 393: ret = qed_read_l1_table_sync(s); ! 394: if (ret) { ! 395: goto out; ! 396: } ! 397: ! 398: /* If image was not closed cleanly, check consistency */ ! 399: if (s->header.features & QED_F_NEED_CHECK) { ! 400: /* Read-only images cannot be fixed. There is no risk of corruption ! 401: * since write operations are not possible. Therefore, allow ! 402: * potentially inconsistent images to be opened read-only. This can ! 403: * aid data recovery from an otherwise inconsistent image. ! 404: */ ! 405: if (!bdrv_is_read_only(bs->file)) { ! 406: BdrvCheckResult result = {0}; ! 407: ! 408: ret = qed_check(s, &result, true); ! 409: if (!ret && !result.corruptions && !result.check_errors) { ! 410: /* Ensure fixes reach storage before clearing check bit */ ! 411: bdrv_flush(s->bs); ! 412: ! 413: s->header.features &= ~QED_F_NEED_CHECK; ! 414: qed_write_header_sync(s); ! 415: } ! 416: } ! 417: } ! 418: ! 419: out: ! 420: if (ret) { ! 421: qed_free_l2_cache(&s->l2_cache); ! 422: qemu_vfree(s->l1_table); ! 423: } ! 424: return ret; ! 425: } ! 426: ! 427: static void bdrv_qed_close(BlockDriverState *bs) ! 428: { ! 429: BDRVQEDState *s = bs->opaque; ! 430: ! 431: /* Ensure writes reach stable storage */ ! 432: bdrv_flush(bs->file); ! 433: ! 434: /* Clean shutdown, no check required on next open */ ! 435: if (s->header.features & QED_F_NEED_CHECK) { ! 436: s->header.features &= ~QED_F_NEED_CHECK; ! 437: qed_write_header_sync(s); ! 438: } ! 439: ! 440: qed_free_l2_cache(&s->l2_cache); ! 441: qemu_vfree(s->l1_table); ! 442: } ! 443: ! 444: static int bdrv_qed_flush(BlockDriverState *bs) ! 445: { ! 446: return bdrv_flush(bs->file); ! 447: } ! 448: ! 449: static int qed_create(const char *filename, uint32_t cluster_size, ! 450: uint64_t image_size, uint32_t table_size, ! 451: const char *backing_file, const char *backing_fmt) ! 452: { ! 453: QEDHeader header = { ! 454: .magic = QED_MAGIC, ! 455: .cluster_size = cluster_size, ! 456: .table_size = table_size, ! 457: .header_size = 1, ! 458: .features = 0, ! 459: .compat_features = 0, ! 460: .l1_table_offset = cluster_size, ! 461: .image_size = image_size, ! 462: }; ! 463: QEDHeader le_header; ! 464: uint8_t *l1_table = NULL; ! 465: size_t l1_size = header.cluster_size * header.table_size; ! 466: int ret = 0; ! 467: BlockDriverState *bs = NULL; ! 468: ! 469: ret = bdrv_create_file(filename, NULL); ! 470: if (ret < 0) { ! 471: return ret; ! 472: } ! 473: ! 474: ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR | BDRV_O_CACHE_WB); ! 475: if (ret < 0) { ! 476: return ret; ! 477: } ! 478: ! 479: /* File must start empty and grow, check truncate is supported */ ! 480: ret = bdrv_truncate(bs, 0); ! 481: if (ret < 0) { ! 482: goto out; ! 483: } ! 484: ! 485: if (backing_file) { ! 486: header.features |= QED_F_BACKING_FILE; ! 487: header.backing_filename_offset = sizeof(le_header); ! 488: header.backing_filename_size = strlen(backing_file); ! 489: ! 490: if (qed_fmt_is_raw(backing_fmt)) { ! 491: header.features |= QED_F_BACKING_FORMAT_NO_PROBE; ! 492: } ! 493: } ! 494: ! 495: qed_header_cpu_to_le(&header, &le_header); ! 496: ret = bdrv_pwrite(bs, 0, &le_header, sizeof(le_header)); ! 497: if (ret < 0) { ! 498: goto out; ! 499: } ! 500: ret = bdrv_pwrite(bs, sizeof(le_header), backing_file, ! 501: header.backing_filename_size); ! 502: if (ret < 0) { ! 503: goto out; ! 504: } ! 505: ! 506: l1_table = qemu_mallocz(l1_size); ! 507: ret = bdrv_pwrite(bs, header.l1_table_offset, l1_table, l1_size); ! 508: if (ret < 0) { ! 509: goto out; ! 510: } ! 511: ! 512: ret = 0; /* success */ ! 513: out: ! 514: qemu_free(l1_table); ! 515: bdrv_delete(bs); ! 516: return ret; ! 517: } ! 518: ! 519: static int bdrv_qed_create(const char *filename, QEMUOptionParameter *options) ! 520: { ! 521: uint64_t image_size = 0; ! 522: uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE; ! 523: uint32_t table_size = QED_DEFAULT_TABLE_SIZE; ! 524: const char *backing_file = NULL; ! 525: const char *backing_fmt = NULL; ! 526: ! 527: while (options && options->name) { ! 528: if (!strcmp(options->name, BLOCK_OPT_SIZE)) { ! 529: image_size = options->value.n; ! 530: } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { ! 531: backing_file = options->value.s; ! 532: } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { ! 533: backing_fmt = options->value.s; ! 534: } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { ! 535: if (options->value.n) { ! 536: cluster_size = options->value.n; ! 537: } ! 538: } else if (!strcmp(options->name, BLOCK_OPT_TABLE_SIZE)) { ! 539: if (options->value.n) { ! 540: table_size = options->value.n; ! 541: } ! 542: } ! 543: options++; ! 544: } ! 545: ! 546: if (!qed_is_cluster_size_valid(cluster_size)) { ! 547: fprintf(stderr, "QED cluster size must be within range [%u, %u] and power of 2\n", ! 548: QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE); ! 549: return -EINVAL; ! 550: } ! 551: if (!qed_is_table_size_valid(table_size)) { ! 552: fprintf(stderr, "QED table size must be within range [%u, %u] and power of 2\n", ! 553: QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE); ! 554: return -EINVAL; ! 555: } ! 556: if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) { ! 557: fprintf(stderr, "QED image size must be a non-zero multiple of " ! 558: "cluster size and less than %" PRIu64 " bytes\n", ! 559: qed_max_image_size(cluster_size, table_size)); ! 560: return -EINVAL; ! 561: } ! 562: ! 563: return qed_create(filename, cluster_size, image_size, table_size, ! 564: backing_file, backing_fmt); ! 565: } ! 566: ! 567: typedef struct { ! 568: int is_allocated; ! 569: int *pnum; ! 570: } QEDIsAllocatedCB; ! 571: ! 572: static void qed_is_allocated_cb(void *opaque, int ret, uint64_t offset, size_t len) ! 573: { ! 574: QEDIsAllocatedCB *cb = opaque; ! 575: *cb->pnum = len / BDRV_SECTOR_SIZE; ! 576: cb->is_allocated = ret == QED_CLUSTER_FOUND; ! 577: } ! 578: ! 579: static int bdrv_qed_is_allocated(BlockDriverState *bs, int64_t sector_num, ! 580: int nb_sectors, int *pnum) ! 581: { ! 582: BDRVQEDState *s = bs->opaque; ! 583: uint64_t pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE; ! 584: size_t len = (size_t)nb_sectors * BDRV_SECTOR_SIZE; ! 585: QEDIsAllocatedCB cb = { ! 586: .is_allocated = -1, ! 587: .pnum = pnum, ! 588: }; ! 589: QEDRequest request = { .l2_table = NULL }; ! 590: ! 591: async_context_push(); ! 592: ! 593: qed_find_cluster(s, &request, pos, len, qed_is_allocated_cb, &cb); ! 594: ! 595: while (cb.is_allocated == -1) { ! 596: qemu_aio_wait(); ! 597: } ! 598: ! 599: async_context_pop(); ! 600: ! 601: qed_unref_l2_cache_entry(request.l2_table); ! 602: ! 603: return cb.is_allocated; ! 604: } ! 605: ! 606: static int bdrv_qed_make_empty(BlockDriverState *bs) ! 607: { ! 608: return -ENOTSUP; ! 609: } ! 610: ! 611: static BDRVQEDState *acb_to_s(QEDAIOCB *acb) ! 612: { ! 613: return acb->common.bs->opaque; ! 614: } ! 615: ! 616: /** ! 617: * Read from the backing file or zero-fill if no backing file ! 618: * ! 619: * @s: QED state ! 620: * @pos: Byte position in device ! 621: * @qiov: Destination I/O vector ! 622: * @cb: Completion function ! 623: * @opaque: User data for completion function ! 624: * ! 625: * This function reads qiov->size bytes starting at pos from the backing file. ! 626: * If there is no backing file then zeroes are read. ! 627: */ ! 628: static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, ! 629: QEMUIOVector *qiov, ! 630: BlockDriverCompletionFunc *cb, void *opaque) ! 631: { ! 632: BlockDriverAIOCB *aiocb; ! 633: uint64_t backing_length = 0; ! 634: size_t size; ! 635: ! 636: /* If there is a backing file, get its length. Treat the absence of a ! 637: * backing file like a zero length backing file. ! 638: */ ! 639: if (s->bs->backing_hd) { ! 640: int64_t l = bdrv_getlength(s->bs->backing_hd); ! 641: if (l < 0) { ! 642: cb(opaque, l); ! 643: return; ! 644: } ! 645: backing_length = l; ! 646: } ! 647: ! 648: /* Zero all sectors if reading beyond the end of the backing file */ ! 649: if (pos >= backing_length || ! 650: pos + qiov->size > backing_length) { ! 651: qemu_iovec_memset(qiov, 0, qiov->size); ! 652: } ! 653: ! 654: /* Complete now if there are no backing file sectors to read */ ! 655: if (pos >= backing_length) { ! 656: cb(opaque, 0); ! 657: return; ! 658: } ! 659: ! 660: /* If the read straddles the end of the backing file, shorten it */ ! 661: size = MIN((uint64_t)backing_length - pos, qiov->size); ! 662: ! 663: BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING); ! 664: aiocb = bdrv_aio_readv(s->bs->backing_hd, pos / BDRV_SECTOR_SIZE, ! 665: qiov, size / BDRV_SECTOR_SIZE, cb, opaque); ! 666: if (!aiocb) { ! 667: cb(opaque, -EIO); ! 668: } ! 669: } ! 670: ! 671: typedef struct { ! 672: GenericCB gencb; ! 673: BDRVQEDState *s; ! 674: QEMUIOVector qiov; ! 675: struct iovec iov; ! 676: uint64_t offset; ! 677: } CopyFromBackingFileCB; ! 678: ! 679: static void qed_copy_from_backing_file_cb(void *opaque, int ret) ! 680: { ! 681: CopyFromBackingFileCB *copy_cb = opaque; ! 682: qemu_vfree(copy_cb->iov.iov_base); ! 683: gencb_complete(©_cb->gencb, ret); ! 684: } ! 685: ! 686: static void qed_copy_from_backing_file_write(void *opaque, int ret) ! 687: { ! 688: CopyFromBackingFileCB *copy_cb = opaque; ! 689: BDRVQEDState *s = copy_cb->s; ! 690: BlockDriverAIOCB *aiocb; ! 691: ! 692: if (ret) { ! 693: qed_copy_from_backing_file_cb(copy_cb, ret); ! 694: return; ! 695: } ! 696: ! 697: BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE); ! 698: aiocb = bdrv_aio_writev(s->bs->file, copy_cb->offset / BDRV_SECTOR_SIZE, ! 699: ©_cb->qiov, ! 700: copy_cb->qiov.size / BDRV_SECTOR_SIZE, ! 701: qed_copy_from_backing_file_cb, copy_cb); ! 702: if (!aiocb) { ! 703: qed_copy_from_backing_file_cb(copy_cb, -EIO); ! 704: } ! 705: } ! 706: ! 707: /** ! 708: * Copy data from backing file into the image ! 709: * ! 710: * @s: QED state ! 711: * @pos: Byte position in device ! 712: * @len: Number of bytes ! 713: * @offset: Byte offset in image file ! 714: * @cb: Completion function ! 715: * @opaque: User data for completion function ! 716: */ ! 717: static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, ! 718: uint64_t len, uint64_t offset, ! 719: BlockDriverCompletionFunc *cb, ! 720: void *opaque) ! 721: { ! 722: CopyFromBackingFileCB *copy_cb; ! 723: ! 724: /* Skip copy entirely if there is no work to do */ ! 725: if (len == 0) { ! 726: cb(opaque, 0); ! 727: return; ! 728: } ! 729: ! 730: copy_cb = gencb_alloc(sizeof(*copy_cb), cb, opaque); ! 731: copy_cb->s = s; ! 732: copy_cb->offset = offset; ! 733: copy_cb->iov.iov_base = qemu_blockalign(s->bs, len); ! 734: copy_cb->iov.iov_len = len; ! 735: qemu_iovec_init_external(©_cb->qiov, ©_cb->iov, 1); ! 736: ! 737: qed_read_backing_file(s, pos, ©_cb->qiov, ! 738: qed_copy_from_backing_file_write, copy_cb); ! 739: } ! 740: ! 741: /** ! 742: * Link one or more contiguous clusters into a table ! 743: * ! 744: * @s: QED state ! 745: * @table: L2 table ! 746: * @index: First cluster index ! 747: * @n: Number of contiguous clusters ! 748: * @cluster: First cluster byte offset in image file ! 749: */ ! 750: static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index, ! 751: unsigned int n, uint64_t cluster) ! 752: { ! 753: int i; ! 754: for (i = index; i < index + n; i++) { ! 755: table->offsets[i] = cluster; ! 756: cluster += s->header.cluster_size; ! 757: } ! 758: } ! 759: ! 760: static void qed_aio_complete_bh(void *opaque) ! 761: { ! 762: QEDAIOCB *acb = opaque; ! 763: BlockDriverCompletionFunc *cb = acb->common.cb; ! 764: void *user_opaque = acb->common.opaque; ! 765: int ret = acb->bh_ret; ! 766: bool *finished = acb->finished; ! 767: ! 768: qemu_bh_delete(acb->bh); ! 769: qemu_aio_release(acb); ! 770: ! 771: /* Invoke callback */ ! 772: cb(user_opaque, ret); ! 773: ! 774: /* Signal cancel completion */ ! 775: if (finished) { ! 776: *finished = true; ! 777: } ! 778: } ! 779: ! 780: static void qed_aio_complete(QEDAIOCB *acb, int ret) ! 781: { ! 782: BDRVQEDState *s = acb_to_s(acb); ! 783: ! 784: trace_qed_aio_complete(s, acb, ret); ! 785: ! 786: /* Free resources */ ! 787: qemu_iovec_destroy(&acb->cur_qiov); ! 788: qed_unref_l2_cache_entry(acb->request.l2_table); ! 789: ! 790: /* Arrange for a bh to invoke the completion function */ ! 791: acb->bh_ret = ret; ! 792: acb->bh = qemu_bh_new(qed_aio_complete_bh, acb); ! 793: qemu_bh_schedule(acb->bh); ! 794: ! 795: /* Start next allocating write request waiting behind this one. Note that ! 796: * requests enqueue themselves when they first hit an unallocated cluster ! 797: * but they wait until the entire request is finished before waking up the ! 798: * next request in the queue. This ensures that we don't cycle through ! 799: * requests multiple times but rather finish one at a time completely. ! 800: */ ! 801: if (acb == QSIMPLEQ_FIRST(&s->allocating_write_reqs)) { ! 802: QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next); ! 803: acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs); ! 804: if (acb) { ! 805: qed_aio_next_io(acb, 0); ! 806: } ! 807: } ! 808: } ! 809: ! 810: /** ! 811: * Commit the current L2 table to the cache ! 812: */ ! 813: static void qed_commit_l2_update(void *opaque, int ret) ! 814: { ! 815: QEDAIOCB *acb = opaque; ! 816: BDRVQEDState *s = acb_to_s(acb); ! 817: CachedL2Table *l2_table = acb->request.l2_table; ! 818: ! 819: qed_commit_l2_cache_entry(&s->l2_cache, l2_table); ! 820: ! 821: /* This is guaranteed to succeed because we just committed the entry to the ! 822: * cache. ! 823: */ ! 824: acb->request.l2_table = qed_find_l2_cache_entry(&s->l2_cache, ! 825: l2_table->offset); ! 826: assert(acb->request.l2_table != NULL); ! 827: ! 828: qed_aio_next_io(opaque, ret); ! 829: } ! 830: ! 831: /** ! 832: * Update L1 table with new L2 table offset and write it out ! 833: */ ! 834: static void qed_aio_write_l1_update(void *opaque, int ret) ! 835: { ! 836: QEDAIOCB *acb = opaque; ! 837: BDRVQEDState *s = acb_to_s(acb); ! 838: int index; ! 839: ! 840: if (ret) { ! 841: qed_aio_complete(acb, ret); ! 842: return; ! 843: } ! 844: ! 845: index = qed_l1_index(s, acb->cur_pos); ! 846: s->l1_table->offsets[index] = acb->request.l2_table->offset; ! 847: ! 848: qed_write_l1_table(s, index, 1, qed_commit_l2_update, acb); ! 849: } ! 850: ! 851: /** ! 852: * Update L2 table with new cluster offsets and write them out ! 853: */ ! 854: static void qed_aio_write_l2_update(void *opaque, int ret) ! 855: { ! 856: QEDAIOCB *acb = opaque; ! 857: BDRVQEDState *s = acb_to_s(acb); ! 858: bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1; ! 859: int index; ! 860: ! 861: if (ret) { ! 862: goto err; ! 863: } ! 864: ! 865: if (need_alloc) { ! 866: qed_unref_l2_cache_entry(acb->request.l2_table); ! 867: acb->request.l2_table = qed_new_l2_table(s); ! 868: } ! 869: ! 870: index = qed_l2_index(s, acb->cur_pos); ! 871: qed_update_l2_table(s, acb->request.l2_table->table, index, acb->cur_nclusters, ! 872: acb->cur_cluster); ! 873: ! 874: if (need_alloc) { ! 875: /* Write out the whole new L2 table */ ! 876: qed_write_l2_table(s, &acb->request, 0, s->table_nelems, true, ! 877: qed_aio_write_l1_update, acb); ! 878: } else { ! 879: /* Write out only the updated part of the L2 table */ ! 880: qed_write_l2_table(s, &acb->request, index, acb->cur_nclusters, false, ! 881: qed_aio_next_io, acb); ! 882: } ! 883: return; ! 884: ! 885: err: ! 886: qed_aio_complete(acb, ret); ! 887: } ! 888: ! 889: /** ! 890: * Flush new data clusters before updating the L2 table ! 891: * ! 892: * This flush is necessary when a backing file is in use. A crash during an ! 893: * allocating write could result in empty clusters in the image. If the write ! 894: * only touched a subregion of the cluster, then backing image sectors have ! 895: * been lost in the untouched region. The solution is to flush after writing a ! 896: * new data cluster and before updating the L2 table. ! 897: */ ! 898: static void qed_aio_write_flush_before_l2_update(void *opaque, int ret) ! 899: { ! 900: QEDAIOCB *acb = opaque; ! 901: BDRVQEDState *s = acb_to_s(acb); ! 902: ! 903: if (!bdrv_aio_flush(s->bs->file, qed_aio_write_l2_update, opaque)) { ! 904: qed_aio_complete(acb, -EIO); ! 905: } ! 906: } ! 907: ! 908: /** ! 909: * Write data to the image file ! 910: */ ! 911: static void qed_aio_write_main(void *opaque, int ret) ! 912: { ! 913: QEDAIOCB *acb = opaque; ! 914: BDRVQEDState *s = acb_to_s(acb); ! 915: uint64_t offset = acb->cur_cluster + ! 916: qed_offset_into_cluster(s, acb->cur_pos); ! 917: BlockDriverCompletionFunc *next_fn; ! 918: BlockDriverAIOCB *file_acb; ! 919: ! 920: trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size); ! 921: ! 922: if (ret) { ! 923: qed_aio_complete(acb, ret); ! 924: return; ! 925: } ! 926: ! 927: if (acb->find_cluster_ret == QED_CLUSTER_FOUND) { ! 928: next_fn = qed_aio_next_io; ! 929: } else { ! 930: if (s->bs->backing_hd) { ! 931: next_fn = qed_aio_write_flush_before_l2_update; ! 932: } else { ! 933: next_fn = qed_aio_write_l2_update; ! 934: } ! 935: } ! 936: ! 937: BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO); ! 938: file_acb = bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE, ! 939: &acb->cur_qiov, ! 940: acb->cur_qiov.size / BDRV_SECTOR_SIZE, ! 941: next_fn, acb); ! 942: if (!file_acb) { ! 943: qed_aio_complete(acb, -EIO); ! 944: } ! 945: } ! 946: ! 947: /** ! 948: * Populate back untouched region of new data cluster ! 949: */ ! 950: static void qed_aio_write_postfill(void *opaque, int ret) ! 951: { ! 952: QEDAIOCB *acb = opaque; ! 953: BDRVQEDState *s = acb_to_s(acb); ! 954: uint64_t start = acb->cur_pos + acb->cur_qiov.size; ! 955: uint64_t len = ! 956: qed_start_of_cluster(s, start + s->header.cluster_size - 1) - start; ! 957: uint64_t offset = acb->cur_cluster + ! 958: qed_offset_into_cluster(s, acb->cur_pos) + ! 959: acb->cur_qiov.size; ! 960: ! 961: if (ret) { ! 962: qed_aio_complete(acb, ret); ! 963: return; ! 964: } ! 965: ! 966: trace_qed_aio_write_postfill(s, acb, start, len, offset); ! 967: qed_copy_from_backing_file(s, start, len, offset, ! 968: qed_aio_write_main, acb); ! 969: } ! 970: ! 971: /** ! 972: * Populate front untouched region of new data cluster ! 973: */ ! 974: static void qed_aio_write_prefill(void *opaque, int ret) ! 975: { ! 976: QEDAIOCB *acb = opaque; ! 977: BDRVQEDState *s = acb_to_s(acb); ! 978: uint64_t start = qed_start_of_cluster(s, acb->cur_pos); ! 979: uint64_t len = qed_offset_into_cluster(s, acb->cur_pos); ! 980: ! 981: trace_qed_aio_write_prefill(s, acb, start, len, acb->cur_cluster); ! 982: qed_copy_from_backing_file(s, start, len, acb->cur_cluster, ! 983: qed_aio_write_postfill, acb); ! 984: } ! 985: ! 986: /** ! 987: * Check if the QED_F_NEED_CHECK bit should be set during allocating write ! 988: */ ! 989: static bool qed_should_set_need_check(BDRVQEDState *s) ! 990: { ! 991: /* The flush before L2 update path ensures consistency */ ! 992: if (s->bs->backing_hd) { ! 993: return false; ! 994: } ! 995: ! 996: return !(s->header.features & QED_F_NEED_CHECK); ! 997: } ! 998: ! 999: /** ! 1000: * Write new data cluster ! 1001: * ! 1002: * @acb: Write request ! 1003: * @len: Length in bytes ! 1004: * ! 1005: * This path is taken when writing to previously unallocated clusters. ! 1006: */ ! 1007: static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len) ! 1008: { ! 1009: BDRVQEDState *s = acb_to_s(acb); ! 1010: ! 1011: /* Freeze this request if another allocating write is in progress */ ! 1012: if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs)) { ! 1013: QSIMPLEQ_INSERT_TAIL(&s->allocating_write_reqs, acb, next); ! 1014: } ! 1015: if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs)) { ! 1016: return; /* wait for existing request to finish */ ! 1017: } ! 1018: ! 1019: acb->cur_nclusters = qed_bytes_to_clusters(s, ! 1020: qed_offset_into_cluster(s, acb->cur_pos) + len); ! 1021: acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters); ! 1022: qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); ! 1023: ! 1024: if (qed_should_set_need_check(s)) { ! 1025: s->header.features |= QED_F_NEED_CHECK; ! 1026: qed_write_header(s, qed_aio_write_prefill, acb); ! 1027: } else { ! 1028: qed_aio_write_prefill(acb, 0); ! 1029: } ! 1030: } ! 1031: ! 1032: /** ! 1033: * Write data cluster in place ! 1034: * ! 1035: * @acb: Write request ! 1036: * @offset: Cluster offset in bytes ! 1037: * @len: Length in bytes ! 1038: * ! 1039: * This path is taken when writing to already allocated clusters. ! 1040: */ ! 1041: static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len) ! 1042: { ! 1043: /* Calculate the I/O vector */ ! 1044: acb->cur_cluster = offset; ! 1045: qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); ! 1046: ! 1047: /* Do the actual write */ ! 1048: qed_aio_write_main(acb, 0); ! 1049: } ! 1050: ! 1051: /** ! 1052: * Write data cluster ! 1053: * ! 1054: * @opaque: Write request ! 1055: * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1, ! 1056: * or -errno ! 1057: * @offset: Cluster offset in bytes ! 1058: * @len: Length in bytes ! 1059: * ! 1060: * Callback from qed_find_cluster(). ! 1061: */ ! 1062: static void qed_aio_write_data(void *opaque, int ret, ! 1063: uint64_t offset, size_t len) ! 1064: { ! 1065: QEDAIOCB *acb = opaque; ! 1066: ! 1067: trace_qed_aio_write_data(acb_to_s(acb), acb, ret, offset, len); ! 1068: ! 1069: acb->find_cluster_ret = ret; ! 1070: ! 1071: switch (ret) { ! 1072: case QED_CLUSTER_FOUND: ! 1073: qed_aio_write_inplace(acb, offset, len); ! 1074: break; ! 1075: ! 1076: case QED_CLUSTER_L2: ! 1077: case QED_CLUSTER_L1: ! 1078: qed_aio_write_alloc(acb, len); ! 1079: break; ! 1080: ! 1081: default: ! 1082: qed_aio_complete(acb, ret); ! 1083: break; ! 1084: } ! 1085: } ! 1086: ! 1087: /** ! 1088: * Read data cluster ! 1089: * ! 1090: * @opaque: Read request ! 1091: * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1, ! 1092: * or -errno ! 1093: * @offset: Cluster offset in bytes ! 1094: * @len: Length in bytes ! 1095: * ! 1096: * Callback from qed_find_cluster(). ! 1097: */ ! 1098: static void qed_aio_read_data(void *opaque, int ret, ! 1099: uint64_t offset, size_t len) ! 1100: { ! 1101: QEDAIOCB *acb = opaque; ! 1102: BDRVQEDState *s = acb_to_s(acb); ! 1103: BlockDriverState *bs = acb->common.bs; ! 1104: BlockDriverAIOCB *file_acb; ! 1105: ! 1106: /* Adjust offset into cluster */ ! 1107: offset += qed_offset_into_cluster(s, acb->cur_pos); ! 1108: ! 1109: trace_qed_aio_read_data(s, acb, ret, offset, len); ! 1110: ! 1111: if (ret < 0) { ! 1112: goto err; ! 1113: } ! 1114: ! 1115: qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); ! 1116: ! 1117: /* Handle backing file and unallocated sparse hole reads */ ! 1118: if (ret != QED_CLUSTER_FOUND) { ! 1119: qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov, ! 1120: qed_aio_next_io, acb); ! 1121: return; ! 1122: } ! 1123: ! 1124: BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); ! 1125: file_acb = bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE, ! 1126: &acb->cur_qiov, ! 1127: acb->cur_qiov.size / BDRV_SECTOR_SIZE, ! 1128: qed_aio_next_io, acb); ! 1129: if (!file_acb) { ! 1130: ret = -EIO; ! 1131: goto err; ! 1132: } ! 1133: return; ! 1134: ! 1135: err: ! 1136: qed_aio_complete(acb, ret); ! 1137: } ! 1138: ! 1139: /** ! 1140: * Begin next I/O or complete the request ! 1141: */ ! 1142: static void qed_aio_next_io(void *opaque, int ret) ! 1143: { ! 1144: QEDAIOCB *acb = opaque; ! 1145: BDRVQEDState *s = acb_to_s(acb); ! 1146: QEDFindClusterFunc *io_fn = ! 1147: acb->is_write ? qed_aio_write_data : qed_aio_read_data; ! 1148: ! 1149: trace_qed_aio_next_io(s, acb, ret, acb->cur_pos + acb->cur_qiov.size); ! 1150: ! 1151: /* Handle I/O error */ ! 1152: if (ret) { ! 1153: qed_aio_complete(acb, ret); ! 1154: return; ! 1155: } ! 1156: ! 1157: acb->qiov_offset += acb->cur_qiov.size; ! 1158: acb->cur_pos += acb->cur_qiov.size; ! 1159: qemu_iovec_reset(&acb->cur_qiov); ! 1160: ! 1161: /* Complete request */ ! 1162: if (acb->cur_pos >= acb->end_pos) { ! 1163: qed_aio_complete(acb, 0); ! 1164: return; ! 1165: } ! 1166: ! 1167: /* Find next cluster and start I/O */ ! 1168: qed_find_cluster(s, &acb->request, ! 1169: acb->cur_pos, acb->end_pos - acb->cur_pos, ! 1170: io_fn, acb); ! 1171: } ! 1172: ! 1173: static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs, ! 1174: int64_t sector_num, ! 1175: QEMUIOVector *qiov, int nb_sectors, ! 1176: BlockDriverCompletionFunc *cb, ! 1177: void *opaque, bool is_write) ! 1178: { ! 1179: QEDAIOCB *acb = qemu_aio_get(&qed_aio_pool, bs, cb, opaque); ! 1180: ! 1181: trace_qed_aio_setup(bs->opaque, acb, sector_num, nb_sectors, ! 1182: opaque, is_write); ! 1183: ! 1184: acb->is_write = is_write; ! 1185: acb->finished = NULL; ! 1186: acb->qiov = qiov; ! 1187: acb->qiov_offset = 0; ! 1188: acb->cur_pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE; ! 1189: acb->end_pos = acb->cur_pos + nb_sectors * BDRV_SECTOR_SIZE; ! 1190: acb->request.l2_table = NULL; ! 1191: qemu_iovec_init(&acb->cur_qiov, qiov->niov); ! 1192: ! 1193: /* Start request */ ! 1194: qed_aio_next_io(acb, 0); ! 1195: return &acb->common; ! 1196: } ! 1197: ! 1198: static BlockDriverAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, ! 1199: int64_t sector_num, ! 1200: QEMUIOVector *qiov, int nb_sectors, ! 1201: BlockDriverCompletionFunc *cb, ! 1202: void *opaque) ! 1203: { ! 1204: return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, false); ! 1205: } ! 1206: ! 1207: static BlockDriverAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, ! 1208: int64_t sector_num, ! 1209: QEMUIOVector *qiov, int nb_sectors, ! 1210: BlockDriverCompletionFunc *cb, ! 1211: void *opaque) ! 1212: { ! 1213: return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, true); ! 1214: } ! 1215: ! 1216: static BlockDriverAIOCB *bdrv_qed_aio_flush(BlockDriverState *bs, ! 1217: BlockDriverCompletionFunc *cb, ! 1218: void *opaque) ! 1219: { ! 1220: return bdrv_aio_flush(bs->file, cb, opaque); ! 1221: } ! 1222: ! 1223: static int bdrv_qed_truncate(BlockDriverState *bs, int64_t offset) ! 1224: { ! 1225: return -ENOTSUP; ! 1226: } ! 1227: ! 1228: static int64_t bdrv_qed_getlength(BlockDriverState *bs) ! 1229: { ! 1230: BDRVQEDState *s = bs->opaque; ! 1231: return s->header.image_size; ! 1232: } ! 1233: ! 1234: static int bdrv_qed_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) ! 1235: { ! 1236: BDRVQEDState *s = bs->opaque; ! 1237: ! 1238: memset(bdi, 0, sizeof(*bdi)); ! 1239: bdi->cluster_size = s->header.cluster_size; ! 1240: return 0; ! 1241: } ! 1242: ! 1243: static int bdrv_qed_change_backing_file(BlockDriverState *bs, ! 1244: const char *backing_file, ! 1245: const char *backing_fmt) ! 1246: { ! 1247: BDRVQEDState *s = bs->opaque; ! 1248: QEDHeader new_header, le_header; ! 1249: void *buffer; ! 1250: size_t buffer_len, backing_file_len; ! 1251: int ret; ! 1252: ! 1253: /* Refuse to set backing filename if unknown compat feature bits are ! 1254: * active. If the image uses an unknown compat feature then we may not ! 1255: * know the layout of data following the header structure and cannot safely ! 1256: * add a new string. ! 1257: */ ! 1258: if (backing_file && (s->header.compat_features & ! 1259: ~QED_COMPAT_FEATURE_MASK)) { ! 1260: return -ENOTSUP; ! 1261: } ! 1262: ! 1263: memcpy(&new_header, &s->header, sizeof(new_header)); ! 1264: ! 1265: new_header.features &= ~(QED_F_BACKING_FILE | ! 1266: QED_F_BACKING_FORMAT_NO_PROBE); ! 1267: ! 1268: /* Adjust feature flags */ ! 1269: if (backing_file) { ! 1270: new_header.features |= QED_F_BACKING_FILE; ! 1271: ! 1272: if (qed_fmt_is_raw(backing_fmt)) { ! 1273: new_header.features |= QED_F_BACKING_FORMAT_NO_PROBE; ! 1274: } ! 1275: } ! 1276: ! 1277: /* Calculate new header size */ ! 1278: backing_file_len = 0; ! 1279: ! 1280: if (backing_file) { ! 1281: backing_file_len = strlen(backing_file); ! 1282: } ! 1283: ! 1284: buffer_len = sizeof(new_header); ! 1285: new_header.backing_filename_offset = buffer_len; ! 1286: new_header.backing_filename_size = backing_file_len; ! 1287: buffer_len += backing_file_len; ! 1288: ! 1289: /* Make sure we can rewrite header without failing */ ! 1290: if (buffer_len > new_header.header_size * new_header.cluster_size) { ! 1291: return -ENOSPC; ! 1292: } ! 1293: ! 1294: /* Prepare new header */ ! 1295: buffer = qemu_malloc(buffer_len); ! 1296: ! 1297: qed_header_cpu_to_le(&new_header, &le_header); ! 1298: memcpy(buffer, &le_header, sizeof(le_header)); ! 1299: buffer_len = sizeof(le_header); ! 1300: ! 1301: memcpy(buffer + buffer_len, backing_file, backing_file_len); ! 1302: buffer_len += backing_file_len; ! 1303: ! 1304: /* Write new header */ ! 1305: ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len); ! 1306: qemu_free(buffer); ! 1307: if (ret == 0) { ! 1308: memcpy(&s->header, &new_header, sizeof(new_header)); ! 1309: } ! 1310: return ret; ! 1311: } ! 1312: ! 1313: static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result) ! 1314: { ! 1315: BDRVQEDState *s = bs->opaque; ! 1316: ! 1317: return qed_check(s, result, false); ! 1318: } ! 1319: ! 1320: static QEMUOptionParameter qed_create_options[] = { ! 1321: { ! 1322: .name = BLOCK_OPT_SIZE, ! 1323: .type = OPT_SIZE, ! 1324: .help = "Virtual disk size (in bytes)" ! 1325: }, { ! 1326: .name = BLOCK_OPT_BACKING_FILE, ! 1327: .type = OPT_STRING, ! 1328: .help = "File name of a base image" ! 1329: }, { ! 1330: .name = BLOCK_OPT_BACKING_FMT, ! 1331: .type = OPT_STRING, ! 1332: .help = "Image format of the base image" ! 1333: }, { ! 1334: .name = BLOCK_OPT_CLUSTER_SIZE, ! 1335: .type = OPT_SIZE, ! 1336: .help = "Cluster size (in bytes)" ! 1337: }, { ! 1338: .name = BLOCK_OPT_TABLE_SIZE, ! 1339: .type = OPT_SIZE, ! 1340: .help = "L1/L2 table size (in clusters)" ! 1341: }, ! 1342: { /* end of list */ } ! 1343: }; ! 1344: ! 1345: static BlockDriver bdrv_qed = { ! 1346: .format_name = "qed", ! 1347: .instance_size = sizeof(BDRVQEDState), ! 1348: .create_options = qed_create_options, ! 1349: ! 1350: .bdrv_probe = bdrv_qed_probe, ! 1351: .bdrv_open = bdrv_qed_open, ! 1352: .bdrv_close = bdrv_qed_close, ! 1353: .bdrv_create = bdrv_qed_create, ! 1354: .bdrv_flush = bdrv_qed_flush, ! 1355: .bdrv_is_allocated = bdrv_qed_is_allocated, ! 1356: .bdrv_make_empty = bdrv_qed_make_empty, ! 1357: .bdrv_aio_readv = bdrv_qed_aio_readv, ! 1358: .bdrv_aio_writev = bdrv_qed_aio_writev, ! 1359: .bdrv_aio_flush = bdrv_qed_aio_flush, ! 1360: .bdrv_truncate = bdrv_qed_truncate, ! 1361: .bdrv_getlength = bdrv_qed_getlength, ! 1362: .bdrv_get_info = bdrv_qed_get_info, ! 1363: .bdrv_change_backing_file = bdrv_qed_change_backing_file, ! 1364: .bdrv_check = bdrv_qed_check, ! 1365: }; ! 1366: ! 1367: static void bdrv_qed_init(void) ! 1368: { ! 1369: bdrv_register(&bdrv_qed); ! 1370: } ! 1371: ! 1372: block_init(bdrv_qed_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.