zio.c revision 260338
1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2013 by Delphix. All rights reserved. 24 */ 25 26#include <sys/zfs_context.h> 27#include <sys/fm/fs/zfs.h> 28#include <sys/spa.h> 29#include <sys/txg.h> 30#include <sys/spa_impl.h> 31#include <sys/vdev_impl.h> 32#include <sys/zio_impl.h> 33#include <sys/zio_compress.h> 34#include <sys/zio_checksum.h> 35#include <sys/dmu_objset.h> 36#include <sys/arc.h> 37#include <sys/ddt.h> 38#include <sys/trim_map.h> 39 40SYSCTL_DECL(_vfs_zfs); 41SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO"); 42#if defined(__amd64__) 43static int zio_use_uma = 1; 44#else 45static int zio_use_uma = 0; 46#endif 47TUNABLE_INT("vfs.zfs.zio.use_uma", &zio_use_uma); 48SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, use_uma, CTLFLAG_RDTUN, &zio_use_uma, 0, 49 "Use uma(9) for ZIO allocations"); 50static int zio_exclude_metadata = 0; 51TUNABLE_INT("vfs.zfs.zio.exclude_metadata", &zio_exclude_metadata); 52SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata, CTLFLAG_RDTUN, &zio_exclude_metadata, 0, 53 "Exclude metadata buffers from dumps as well"); 54 55zio_trim_stats_t zio_trim_stats = { 56 { "bytes", KSTAT_DATA_UINT64, 57 "Number of bytes successfully TRIMmed" }, 58 { "success", KSTAT_DATA_UINT64, 59 "Number of successful TRIM requests" }, 60 { "unsupported", KSTAT_DATA_UINT64, 61 "Number of TRIM requests that failed because TRIM is not supported" }, 62 { "failed", KSTAT_DATA_UINT64, 63 "Number of TRIM requests that failed for reasons other than not supported" }, 64}; 65 66static kstat_t *zio_trim_ksp; 67 68/* 69 * ========================================================================== 70 * I/O priority table 71 * ========================================================================== 72 */ 73uint8_t zio_priority_table[ZIO_PRIORITY_TABLE_SIZE] = { 74 0, /* ZIO_PRIORITY_NOW */ 75 0, /* ZIO_PRIORITY_SYNC_READ */ 76 0, /* ZIO_PRIORITY_SYNC_WRITE */ 77 0, /* ZIO_PRIORITY_LOG_WRITE */ 78 1, /* ZIO_PRIORITY_CACHE_FILL */ 79 1, /* ZIO_PRIORITY_AGG */ 80 4, /* ZIO_PRIORITY_FREE */ 81 4, /* ZIO_PRIORITY_ASYNC_WRITE */ 82 6, /* ZIO_PRIORITY_ASYNC_READ */ 83 10, /* ZIO_PRIORITY_RESILVER */ 84 20, /* ZIO_PRIORITY_SCRUB */ 85 2, /* ZIO_PRIORITY_DDT_PREFETCH */ 86 30, /* ZIO_PRIORITY_TRIM */ 87}; 88 89/* 90 * ========================================================================== 91 * I/O type descriptions 92 * ========================================================================== 93 */ 94char *zio_type_name[ZIO_TYPES] = { 95 "zio_null", "zio_read", "zio_write", "zio_free", "zio_claim", 96 "zio_ioctl" 97}; 98 99/* 100 * ========================================================================== 101 * I/O kmem caches 102 * ========================================================================== 103 */ 104kmem_cache_t *zio_cache; 105kmem_cache_t *zio_link_cache; 106kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT]; 107kmem_cache_t *zio_data_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT]; 108 109#ifdef _KERNEL 110extern vmem_t *zio_alloc_arena; 111#endif 112extern int zfs_mg_alloc_failures; 113 114/* 115 * The following actions directly effect the spa's sync-to-convergence logic. 116 * The values below define the sync pass when we start performing the action. 117 * Care should be taken when changing these values as they directly impact 118 * spa_sync() performance. Tuning these values may introduce subtle performance 119 * pathologies and should only be done in the context of performance analysis. 120 * These tunables will eventually be removed and replaced with #defines once 121 * enough analysis has been done to determine optimal values. 122 * 123 * The 'zfs_sync_pass_deferred_free' pass must be greater than 1 to ensure that 124 * regular blocks are not deferred. 125 */ 126int zfs_sync_pass_deferred_free = 2; /* defer frees starting in this pass */ 127TUNABLE_INT("vfs.zfs.sync_pass_deferred_free", &zfs_sync_pass_deferred_free); 128SYSCTL_INT(_vfs_zfs, OID_AUTO, sync_pass_deferred_free, CTLFLAG_RDTUN, 129 &zfs_sync_pass_deferred_free, 0, "defer frees starting in this pass"); 130int zfs_sync_pass_dont_compress = 5; /* don't compress starting in this pass */ 131TUNABLE_INT("vfs.zfs.sync_pass_dont_compress", &zfs_sync_pass_dont_compress); 132SYSCTL_INT(_vfs_zfs, OID_AUTO, sync_pass_dont_compress, CTLFLAG_RDTUN, 133 &zfs_sync_pass_dont_compress, 0, "don't compress starting in this pass"); 134int zfs_sync_pass_rewrite = 2; /* rewrite new bps starting in this pass */ 135TUNABLE_INT("vfs.zfs.sync_pass_rewrite", &zfs_sync_pass_rewrite); 136SYSCTL_INT(_vfs_zfs, OID_AUTO, sync_pass_rewrite, CTLFLAG_RDTUN, 137 &zfs_sync_pass_rewrite, 0, "rewrite new bps starting in this pass"); 138 139/* 140 * An allocating zio is one that either currently has the DVA allocate 141 * stage set or will have it later in its lifetime. 142 */ 143#define IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE) 144 145boolean_t zio_requeue_io_start_cut_in_line = B_TRUE; 146 147#ifdef ZFS_DEBUG 148int zio_buf_debug_limit = 16384; 149#else 150int zio_buf_debug_limit = 0; 151#endif 152 153void 154zio_init(void) 155{ 156 size_t c; 157 zio_cache = kmem_cache_create("zio_cache", 158 sizeof (zio_t), 0, NULL, NULL, NULL, NULL, NULL, 0); 159 zio_link_cache = kmem_cache_create("zio_link_cache", 160 sizeof (zio_link_t), 0, NULL, NULL, NULL, NULL, NULL, 0); 161 if (!zio_use_uma) 162 goto out; 163 164 /* 165 * For small buffers, we want a cache for each multiple of 166 * SPA_MINBLOCKSIZE. For medium-size buffers, we want a cache 167 * for each quarter-power of 2. For large buffers, we want 168 * a cache for each multiple of PAGESIZE. 169 */ 170 for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) { 171 size_t size = (c + 1) << SPA_MINBLOCKSHIFT; 172 size_t p2 = size; 173 size_t align = 0; 174 size_t cflags = (size > zio_buf_debug_limit) ? KMC_NODEBUG : 0; 175 176 while (p2 & (p2 - 1)) 177 p2 &= p2 - 1; 178 179#ifdef illumos 180#ifndef _KERNEL 181 /* 182 * If we are using watchpoints, put each buffer on its own page, 183 * to eliminate the performance overhead of trapping to the 184 * kernel when modifying a non-watched buffer that shares the 185 * page with a watched buffer. 186 */ 187 if (arc_watch && !IS_P2ALIGNED(size, PAGESIZE)) 188 continue; 189#endif 190#endif /* illumos */ 191 if (size <= 4 * SPA_MINBLOCKSIZE) { 192 align = SPA_MINBLOCKSIZE; 193 } else if (IS_P2ALIGNED(size, PAGESIZE)) { 194 align = PAGESIZE; 195 } else if (IS_P2ALIGNED(size, p2 >> 2)) { 196 align = p2 >> 2; 197 } 198 199 if (align != 0) { 200 char name[36]; 201 (void) sprintf(name, "zio_buf_%lu", (ulong_t)size); 202 zio_buf_cache[c] = kmem_cache_create(name, size, 203 align, NULL, NULL, NULL, NULL, NULL, cflags); 204 205 /* 206 * Since zio_data bufs do not appear in crash dumps, we 207 * pass KMC_NOTOUCH so that no allocator metadata is 208 * stored with the buffers. 209 */ 210 (void) sprintf(name, "zio_data_buf_%lu", (ulong_t)size); 211 zio_data_buf_cache[c] = kmem_cache_create(name, size, 212 align, NULL, NULL, NULL, NULL, NULL, 213 cflags | KMC_NOTOUCH | KMC_NODEBUG); 214 } 215 } 216 217 while (--c != 0) { 218 ASSERT(zio_buf_cache[c] != NULL); 219 if (zio_buf_cache[c - 1] == NULL) 220 zio_buf_cache[c - 1] = zio_buf_cache[c]; 221 222 ASSERT(zio_data_buf_cache[c] != NULL); 223 if (zio_data_buf_cache[c - 1] == NULL) 224 zio_data_buf_cache[c - 1] = zio_data_buf_cache[c]; 225 } 226out: 227 228 /* 229 * The zio write taskqs have 1 thread per cpu, allow 1/2 of the taskqs 230 * to fail 3 times per txg or 8 failures, whichever is greater. 231 */ 232 if (zfs_mg_alloc_failures == 0) 233 zfs_mg_alloc_failures = MAX((3 * max_ncpus / 2), 8); 234 else if (zfs_mg_alloc_failures < 8) 235 zfs_mg_alloc_failures = 8; 236 237 zio_inject_init(); 238 239 zio_trim_ksp = kstat_create("zfs", 0, "zio_trim", "misc", 240 KSTAT_TYPE_NAMED, 241 sizeof(zio_trim_stats) / sizeof(kstat_named_t), 242 KSTAT_FLAG_VIRTUAL); 243 244 if (zio_trim_ksp != NULL) { 245 zio_trim_ksp->ks_data = &zio_trim_stats; 246 kstat_install(zio_trim_ksp); 247 } 248} 249 250void 251zio_fini(void) 252{ 253 size_t c; 254 kmem_cache_t *last_cache = NULL; 255 kmem_cache_t *last_data_cache = NULL; 256 257 for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) { 258 if (zio_buf_cache[c] != last_cache) { 259 last_cache = zio_buf_cache[c]; 260 kmem_cache_destroy(zio_buf_cache[c]); 261 } 262 zio_buf_cache[c] = NULL; 263 264 if (zio_data_buf_cache[c] != last_data_cache) { 265 last_data_cache = zio_data_buf_cache[c]; 266 kmem_cache_destroy(zio_data_buf_cache[c]); 267 } 268 zio_data_buf_cache[c] = NULL; 269 } 270 271 kmem_cache_destroy(zio_link_cache); 272 kmem_cache_destroy(zio_cache); 273 274 zio_inject_fini(); 275 276 if (zio_trim_ksp != NULL) { 277 kstat_delete(zio_trim_ksp); 278 zio_trim_ksp = NULL; 279 } 280} 281 282/* 283 * ========================================================================== 284 * Allocate and free I/O buffers 285 * ========================================================================== 286 */ 287 288/* 289 * Use zio_buf_alloc to allocate ZFS metadata. This data will appear in a 290 * crashdump if the kernel panics, so use it judiciously. Obviously, it's 291 * useful to inspect ZFS metadata, but if possible, we should avoid keeping 292 * excess / transient data in-core during a crashdump. 293 */ 294void * 295zio_buf_alloc(size_t size) 296{ 297 size_t c = (size - 1) >> SPA_MINBLOCKSHIFT; 298 int flags = zio_exclude_metadata ? KM_NODEBUG : 0; 299 300 ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT); 301 302 if (zio_use_uma) 303 return (kmem_cache_alloc(zio_buf_cache[c], KM_PUSHPAGE)); 304 else 305 return (kmem_alloc(size, KM_SLEEP|flags)); 306} 307 308/* 309 * Use zio_data_buf_alloc to allocate data. The data will not appear in a 310 * crashdump if the kernel panics. This exists so that we will limit the amount 311 * of ZFS data that shows up in a kernel crashdump. (Thus reducing the amount 312 * of kernel heap dumped to disk when the kernel panics) 313 */ 314void * 315zio_data_buf_alloc(size_t size) 316{ 317 size_t c = (size - 1) >> SPA_MINBLOCKSHIFT; 318 319 ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT); 320 321 if (zio_use_uma) 322 return (kmem_cache_alloc(zio_data_buf_cache[c], KM_PUSHPAGE)); 323 else 324 return (kmem_alloc(size, KM_SLEEP | KM_NODEBUG)); 325} 326 327void 328zio_buf_free(void *buf, size_t size) 329{ 330 size_t c = (size - 1) >> SPA_MINBLOCKSHIFT; 331 332 ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT); 333 334 if (zio_use_uma) 335 kmem_cache_free(zio_buf_cache[c], buf); 336 else 337 kmem_free(buf, size); 338} 339 340void 341zio_data_buf_free(void *buf, size_t size) 342{ 343 size_t c = (size - 1) >> SPA_MINBLOCKSHIFT; 344 345 ASSERT(c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT); 346 347 if (zio_use_uma) 348 kmem_cache_free(zio_data_buf_cache[c], buf); 349 else 350 kmem_free(buf, size); 351} 352 353/* 354 * ========================================================================== 355 * Push and pop I/O transform buffers 356 * ========================================================================== 357 */ 358static void 359zio_push_transform(zio_t *zio, void *data, uint64_t size, uint64_t bufsize, 360 zio_transform_func_t *transform) 361{ 362 zio_transform_t *zt = kmem_alloc(sizeof (zio_transform_t), KM_SLEEP); 363 364 zt->zt_orig_data = zio->io_data; 365 zt->zt_orig_size = zio->io_size; 366 zt->zt_bufsize = bufsize; 367 zt->zt_transform = transform; 368 369 zt->zt_next = zio->io_transform_stack; 370 zio->io_transform_stack = zt; 371 372 zio->io_data = data; 373 zio->io_size = size; 374} 375 376static void 377zio_pop_transforms(zio_t *zio) 378{ 379 zio_transform_t *zt; 380 381 while ((zt = zio->io_transform_stack) != NULL) { 382 if (zt->zt_transform != NULL) 383 zt->zt_transform(zio, 384 zt->zt_orig_data, zt->zt_orig_size); 385 386 if (zt->zt_bufsize != 0) 387 zio_buf_free(zio->io_data, zt->zt_bufsize); 388 389 zio->io_data = zt->zt_orig_data; 390 zio->io_size = zt->zt_orig_size; 391 zio->io_transform_stack = zt->zt_next; 392 393 kmem_free(zt, sizeof (zio_transform_t)); 394 } 395} 396 397/* 398 * ========================================================================== 399 * I/O transform callbacks for subblocks and decompression 400 * ========================================================================== 401 */ 402static void 403zio_subblock(zio_t *zio, void *data, uint64_t size) 404{ 405 ASSERT(zio->io_size > size); 406 407 if (zio->io_type == ZIO_TYPE_READ) 408 bcopy(zio->io_data, data, size); 409} 410 411static void 412zio_decompress(zio_t *zio, void *data, uint64_t size) 413{ 414 if (zio->io_error == 0 && 415 zio_decompress_data(BP_GET_COMPRESS(zio->io_bp), 416 zio->io_data, data, zio->io_size, size) != 0) 417 zio->io_error = SET_ERROR(EIO); 418} 419 420/* 421 * ========================================================================== 422 * I/O parent/child relationships and pipeline interlocks 423 * ========================================================================== 424 */ 425/* 426 * NOTE - Callers to zio_walk_parents() and zio_walk_children must 427 * continue calling these functions until they return NULL. 428 * Otherwise, the next caller will pick up the list walk in 429 * some indeterminate state. (Otherwise every caller would 430 * have to pass in a cookie to keep the state represented by 431 * io_walk_link, which gets annoying.) 432 */ 433zio_t * 434zio_walk_parents(zio_t *cio) 435{ 436 zio_link_t *zl = cio->io_walk_link; 437 list_t *pl = &cio->io_parent_list; 438 439 zl = (zl == NULL) ? list_head(pl) : list_next(pl, zl); 440 cio->io_walk_link = zl; 441 442 if (zl == NULL) 443 return (NULL); 444 445 ASSERT(zl->zl_child == cio); 446 return (zl->zl_parent); 447} 448 449zio_t * 450zio_walk_children(zio_t *pio) 451{ 452 zio_link_t *zl = pio->io_walk_link; 453 list_t *cl = &pio->io_child_list; 454 455 zl = (zl == NULL) ? list_head(cl) : list_next(cl, zl); 456 pio->io_walk_link = zl; 457 458 if (zl == NULL) 459 return (NULL); 460 461 ASSERT(zl->zl_parent == pio); 462 return (zl->zl_child); 463} 464 465zio_t * 466zio_unique_parent(zio_t *cio) 467{ 468 zio_t *pio = zio_walk_parents(cio); 469 470 VERIFY(zio_walk_parents(cio) == NULL); 471 return (pio); 472} 473 474void 475zio_add_child(zio_t *pio, zio_t *cio) 476{ 477 zio_link_t *zl = kmem_cache_alloc(zio_link_cache, KM_SLEEP); 478 479 /* 480 * Logical I/Os can have logical, gang, or vdev children. 481 * Gang I/Os can have gang or vdev children. 482 * Vdev I/Os can only have vdev children. 483 * The following ASSERT captures all of these constraints. 484 */ 485 ASSERT(cio->io_child_type <= pio->io_child_type); 486 487 zl->zl_parent = pio; 488 zl->zl_child = cio; 489 490 mutex_enter(&cio->io_lock); 491 mutex_enter(&pio->io_lock); 492 493 ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0); 494 495 for (int w = 0; w < ZIO_WAIT_TYPES; w++) 496 pio->io_children[cio->io_child_type][w] += !cio->io_state[w]; 497 498 list_insert_head(&pio->io_child_list, zl); 499 list_insert_head(&cio->io_parent_list, zl); 500 501 pio->io_child_count++; 502 cio->io_parent_count++; 503 504 mutex_exit(&pio->io_lock); 505 mutex_exit(&cio->io_lock); 506} 507 508static void 509zio_remove_child(zio_t *pio, zio_t *cio, zio_link_t *zl) 510{ 511 ASSERT(zl->zl_parent == pio); 512 ASSERT(zl->zl_child == cio); 513 514 mutex_enter(&cio->io_lock); 515 mutex_enter(&pio->io_lock); 516 517 list_remove(&pio->io_child_list, zl); 518 list_remove(&cio->io_parent_list, zl); 519 520 pio->io_child_count--; 521 cio->io_parent_count--; 522 523 mutex_exit(&pio->io_lock); 524 mutex_exit(&cio->io_lock); 525 526 kmem_cache_free(zio_link_cache, zl); 527} 528 529static boolean_t 530zio_wait_for_children(zio_t *zio, enum zio_child child, enum zio_wait_type wait) 531{ 532 uint64_t *countp = &zio->io_children[child][wait]; 533 boolean_t waiting = B_FALSE; 534 535 mutex_enter(&zio->io_lock); 536 ASSERT(zio->io_stall == NULL); 537 if (*countp != 0) { 538 zio->io_stage >>= 1; 539 zio->io_stall = countp; 540 waiting = B_TRUE; 541 } 542 mutex_exit(&zio->io_lock); 543 544 return (waiting); 545} 546 547static void 548zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait) 549{ 550 uint64_t *countp = &pio->io_children[zio->io_child_type][wait]; 551 int *errorp = &pio->io_child_error[zio->io_child_type]; 552 553 mutex_enter(&pio->io_lock); 554 if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE)) 555 *errorp = zio_worst_error(*errorp, zio->io_error); 556 pio->io_reexecute |= zio->io_reexecute; 557 ASSERT3U(*countp, >, 0); 558 if (--*countp == 0 && pio->io_stall == countp) { 559 pio->io_stall = NULL; 560 mutex_exit(&pio->io_lock); 561 zio_execute(pio); 562 } else { 563 mutex_exit(&pio->io_lock); 564 } 565} 566 567static void 568zio_inherit_child_errors(zio_t *zio, enum zio_child c) 569{ 570 if (zio->io_child_error[c] != 0 && zio->io_error == 0) 571 zio->io_error = zio->io_child_error[c]; 572} 573 574/* 575 * ========================================================================== 576 * Create the various types of I/O (read, write, free, etc) 577 * ========================================================================== 578 */ 579static zio_t * 580zio_create(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, 581 void *data, uint64_t size, zio_done_func_t *done, void *private, 582 zio_type_t type, int priority, enum zio_flag flags, 583 vdev_t *vd, uint64_t offset, const zbookmark_t *zb, 584 enum zio_stage stage, enum zio_stage pipeline) 585{ 586 zio_t *zio; 587 588 ASSERT3U(type == ZIO_TYPE_FREE || size, <=, SPA_MAXBLOCKSIZE); 589 ASSERT(P2PHASE(size, SPA_MINBLOCKSIZE) == 0); 590 ASSERT(P2PHASE(offset, SPA_MINBLOCKSIZE) == 0); 591 592 ASSERT(!vd || spa_config_held(spa, SCL_STATE_ALL, RW_READER)); 593 ASSERT(!bp || !(flags & ZIO_FLAG_CONFIG_WRITER)); 594 ASSERT(vd || stage == ZIO_STAGE_OPEN); 595 596 zio = kmem_cache_alloc(zio_cache, KM_SLEEP); 597 bzero(zio, sizeof (zio_t)); 598 599 mutex_init(&zio->io_lock, NULL, MUTEX_DEFAULT, NULL); 600 cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL); 601 602 list_create(&zio->io_parent_list, sizeof (zio_link_t), 603 offsetof(zio_link_t, zl_parent_node)); 604 list_create(&zio->io_child_list, sizeof (zio_link_t), 605 offsetof(zio_link_t, zl_child_node)); 606 607 if (vd != NULL) 608 zio->io_child_type = ZIO_CHILD_VDEV; 609 else if (flags & ZIO_FLAG_GANG_CHILD) 610 zio->io_child_type = ZIO_CHILD_GANG; 611 else if (flags & ZIO_FLAG_DDT_CHILD) 612 zio->io_child_type = ZIO_CHILD_DDT; 613 else 614 zio->io_child_type = ZIO_CHILD_LOGICAL; 615 616 if (bp != NULL) { 617 zio->io_bp = (blkptr_t *)bp; 618 zio->io_bp_copy = *bp; 619 zio->io_bp_orig = *bp; 620 if (type != ZIO_TYPE_WRITE || 621 zio->io_child_type == ZIO_CHILD_DDT) 622 zio->io_bp = &zio->io_bp_copy; /* so caller can free */ 623 if (zio->io_child_type == ZIO_CHILD_LOGICAL) 624 zio->io_logical = zio; 625 if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp)) 626 pipeline |= ZIO_GANG_STAGES; 627 } 628 629 zio->io_spa = spa; 630 zio->io_txg = txg; 631 zio->io_done = done; 632 zio->io_private = private; 633 zio->io_type = type; 634 zio->io_priority = priority; 635 zio->io_vd = vd; 636 zio->io_offset = offset; 637 zio->io_orig_data = zio->io_data = data; 638 zio->io_orig_size = zio->io_size = size; 639 zio->io_orig_flags = zio->io_flags = flags; 640 zio->io_orig_stage = zio->io_stage = stage; 641 zio->io_orig_pipeline = zio->io_pipeline = pipeline; 642 643 zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY); 644 zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE); 645 646 if (zb != NULL) 647 zio->io_bookmark = *zb; 648 649 if (pio != NULL) { 650 if (zio->io_logical == NULL) 651 zio->io_logical = pio->io_logical; 652 if (zio->io_child_type == ZIO_CHILD_GANG) 653 zio->io_gang_leader = pio->io_gang_leader; 654 zio_add_child(pio, zio); 655 } 656 657 return (zio); 658} 659 660static void 661zio_destroy(zio_t *zio) 662{ 663 list_destroy(&zio->io_parent_list); 664 list_destroy(&zio->io_child_list); 665 mutex_destroy(&zio->io_lock); 666 cv_destroy(&zio->io_cv); 667 kmem_cache_free(zio_cache, zio); 668} 669 670zio_t * 671zio_null(zio_t *pio, spa_t *spa, vdev_t *vd, zio_done_func_t *done, 672 void *private, enum zio_flag flags) 673{ 674 zio_t *zio; 675 676 zio = zio_create(pio, spa, 0, NULL, NULL, 0, done, private, 677 ZIO_TYPE_NULL, ZIO_PRIORITY_NOW, flags, vd, 0, NULL, 678 ZIO_STAGE_OPEN, ZIO_INTERLOCK_PIPELINE); 679 680 return (zio); 681} 682 683zio_t * 684zio_root(spa_t *spa, zio_done_func_t *done, void *private, enum zio_flag flags) 685{ 686 return (zio_null(NULL, spa, NULL, done, private, flags)); 687} 688 689zio_t * 690zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, 691 void *data, uint64_t size, zio_done_func_t *done, void *private, 692 int priority, enum zio_flag flags, const zbookmark_t *zb) 693{ 694 zio_t *zio; 695 696 zio = zio_create(pio, spa, BP_PHYSICAL_BIRTH(bp), bp, 697 data, size, done, private, 698 ZIO_TYPE_READ, priority, flags, NULL, 0, zb, 699 ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ? 700 ZIO_DDT_CHILD_READ_PIPELINE : ZIO_READ_PIPELINE); 701 702 return (zio); 703} 704 705zio_t * 706zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, 707 void *data, uint64_t size, const zio_prop_t *zp, 708 zio_done_func_t *ready, zio_done_func_t *done, void *private, 709 int priority, enum zio_flag flags, const zbookmark_t *zb) 710{ 711 zio_t *zio; 712 713 ASSERT(zp->zp_checksum >= ZIO_CHECKSUM_OFF && 714 zp->zp_checksum < ZIO_CHECKSUM_FUNCTIONS && 715 zp->zp_compress >= ZIO_COMPRESS_OFF && 716 zp->zp_compress < ZIO_COMPRESS_FUNCTIONS && 717 DMU_OT_IS_VALID(zp->zp_type) && 718 zp->zp_level < 32 && 719 zp->zp_copies > 0 && 720 zp->zp_copies <= spa_max_replication(spa)); 721 722 zio = zio_create(pio, spa, txg, bp, data, size, done, private, 723 ZIO_TYPE_WRITE, priority, flags, NULL, 0, zb, 724 ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ? 725 ZIO_DDT_CHILD_WRITE_PIPELINE : ZIO_WRITE_PIPELINE); 726 727 zio->io_ready = ready; 728 zio->io_prop = *zp; 729 730 return (zio); 731} 732 733zio_t * 734zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, void *data, 735 uint64_t size, zio_done_func_t *done, void *private, int priority, 736 enum zio_flag flags, zbookmark_t *zb) 737{ 738 zio_t *zio; 739 740 zio = zio_create(pio, spa, txg, bp, data, size, done, private, 741 ZIO_TYPE_WRITE, priority, flags, NULL, 0, zb, 742 ZIO_STAGE_OPEN, ZIO_REWRITE_PIPELINE); 743 744 return (zio); 745} 746 747void 748zio_write_override(zio_t *zio, blkptr_t *bp, int copies, boolean_t nopwrite) 749{ 750 ASSERT(zio->io_type == ZIO_TYPE_WRITE); 751 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 752 ASSERT(zio->io_stage == ZIO_STAGE_OPEN); 753 ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa)); 754 755 /* 756 * We must reset the io_prop to match the values that existed 757 * when the bp was first written by dmu_sync() keeping in mind 758 * that nopwrite and dedup are mutually exclusive. 759 */ 760 zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup; 761 zio->io_prop.zp_nopwrite = nopwrite; 762 zio->io_prop.zp_copies = copies; 763 zio->io_bp_override = bp; 764} 765 766void 767zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp) 768{ 769 metaslab_check_free(spa, bp); 770 771 /* 772 * Frees that are for the currently-syncing txg, are not going to be 773 * deferred, and which will not need to do a read (i.e. not GANG or 774 * DEDUP), can be processed immediately. Otherwise, put them on the 775 * in-memory list for later processing. 776 */ 777 if (zfs_trim_enabled || BP_IS_GANG(bp) || BP_GET_DEDUP(bp) || 778 txg != spa->spa_syncing_txg || 779 spa_sync_pass(spa) >= zfs_sync_pass_deferred_free) { 780 bplist_append(&spa->spa_free_bplist[txg & TXG_MASK], bp); 781 } else { 782 VERIFY0(zio_wait(zio_free_sync(NULL, spa, txg, bp, 783 BP_GET_PSIZE(bp), 0))); 784 } 785} 786 787zio_t * 788zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, 789 uint64_t size, enum zio_flag flags) 790{ 791 zio_t *zio; 792 enum zio_stage stage = ZIO_FREE_PIPELINE; 793 794 dprintf_bp(bp, "freeing in txg %llu, pass %u", 795 (longlong_t)txg, spa->spa_sync_pass); 796 797 ASSERT(!BP_IS_HOLE(bp)); 798 ASSERT(spa_syncing_txg(spa) == txg); 799 ASSERT(spa_sync_pass(spa) < zfs_sync_pass_deferred_free); 800 801 metaslab_check_free(spa, bp); 802 arc_freed(spa, bp); 803 804 if (zfs_trim_enabled) 805 stage |= ZIO_STAGE_ISSUE_ASYNC | ZIO_STAGE_VDEV_IO_START | 806 ZIO_STAGE_VDEV_IO_ASSESS; 807 /* 808 * GANG and DEDUP blocks can induce a read (for the gang block header, 809 * or the DDT), so issue them asynchronously so that this thread is 810 * not tied up. 811 */ 812 else if (BP_IS_GANG(bp) || BP_GET_DEDUP(bp)) 813 stage |= ZIO_STAGE_ISSUE_ASYNC; 814 815 zio = zio_create(pio, spa, txg, bp, NULL, size, 816 NULL, NULL, ZIO_TYPE_FREE, ZIO_PRIORITY_FREE, flags, 817 NULL, 0, NULL, ZIO_STAGE_OPEN, stage); 818 819 return (zio); 820} 821 822zio_t * 823zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, 824 zio_done_func_t *done, void *private, enum zio_flag flags) 825{ 826 zio_t *zio; 827 828 /* 829 * A claim is an allocation of a specific block. Claims are needed 830 * to support immediate writes in the intent log. The issue is that 831 * immediate writes contain committed data, but in a txg that was 832 * *not* committed. Upon opening the pool after an unclean shutdown, 833 * the intent log claims all blocks that contain immediate write data 834 * so that the SPA knows they're in use. 835 * 836 * All claims *must* be resolved in the first txg -- before the SPA 837 * starts allocating blocks -- so that nothing is allocated twice. 838 * If txg == 0 we just verify that the block is claimable. 839 */ 840 ASSERT3U(spa->spa_uberblock.ub_rootbp.blk_birth, <, spa_first_txg(spa)); 841 ASSERT(txg == spa_first_txg(spa) || txg == 0); 842 ASSERT(!BP_GET_DEDUP(bp) || !spa_writeable(spa)); /* zdb(1M) */ 843 844 zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp), 845 done, private, ZIO_TYPE_CLAIM, ZIO_PRIORITY_NOW, flags, 846 NULL, 0, NULL, ZIO_STAGE_OPEN, ZIO_CLAIM_PIPELINE); 847 848 return (zio); 849} 850 851zio_t * 852zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd, uint64_t offset, 853 uint64_t size, zio_done_func_t *done, void *private, int priority, 854 enum zio_flag flags) 855{ 856 zio_t *zio; 857 int c; 858 859 if (vd->vdev_children == 0) { 860 zio = zio_create(pio, spa, 0, NULL, NULL, size, done, private, 861 ZIO_TYPE_IOCTL, priority, flags, vd, offset, NULL, 862 ZIO_STAGE_OPEN, ZIO_IOCTL_PIPELINE); 863 864 zio->io_cmd = cmd; 865 } else { 866 zio = zio_null(pio, spa, NULL, NULL, NULL, flags); 867 868 for (c = 0; c < vd->vdev_children; c++) 869 zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd, 870 offset, size, done, private, priority, flags)); 871 } 872 873 return (zio); 874} 875 876zio_t * 877zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size, 878 void *data, int checksum, zio_done_func_t *done, void *private, 879 int priority, enum zio_flag flags, boolean_t labels) 880{ 881 zio_t *zio; 882 883 ASSERT(vd->vdev_children == 0); 884 ASSERT(!labels || offset + size <= VDEV_LABEL_START_SIZE || 885 offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE); 886 ASSERT3U(offset + size, <=, vd->vdev_psize); 887 888 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, done, private, 889 ZIO_TYPE_READ, priority, flags, vd, offset, NULL, 890 ZIO_STAGE_OPEN, ZIO_READ_PHYS_PIPELINE); 891 892 zio->io_prop.zp_checksum = checksum; 893 894 return (zio); 895} 896 897zio_t * 898zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size, 899 void *data, int checksum, zio_done_func_t *done, void *private, 900 int priority, enum zio_flag flags, boolean_t labels) 901{ 902 zio_t *zio; 903 904 ASSERT(vd->vdev_children == 0); 905 ASSERT(!labels || offset + size <= VDEV_LABEL_START_SIZE || 906 offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE); 907 ASSERT3U(offset + size, <=, vd->vdev_psize); 908 909 zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, done, private, 910 ZIO_TYPE_WRITE, priority, flags, vd, offset, NULL, 911 ZIO_STAGE_OPEN, ZIO_WRITE_PHYS_PIPELINE); 912 913 zio->io_prop.zp_checksum = checksum; 914 915 if (zio_checksum_table[checksum].ci_eck) { 916 /* 917 * zec checksums are necessarily destructive -- they modify 918 * the end of the write buffer to hold the verifier/checksum. 919 * Therefore, we must make a local copy in case the data is 920 * being written to multiple places in parallel. 921 */ 922 void *wbuf = zio_buf_alloc(size); 923 bcopy(data, wbuf, size); 924 zio_push_transform(zio, wbuf, size, size, NULL); 925 } 926 927 return (zio); 928} 929 930/* 931 * Create a child I/O to do some work for us. 932 */ 933zio_t * 934zio_vdev_child_io(zio_t *pio, blkptr_t *bp, vdev_t *vd, uint64_t offset, 935 void *data, uint64_t size, int type, int priority, enum zio_flag flags, 936 zio_done_func_t *done, void *private) 937{ 938 enum zio_stage pipeline = ZIO_VDEV_CHILD_PIPELINE; 939 zio_t *zio; 940 941 ASSERT(vd->vdev_parent == 942 (pio->io_vd ? pio->io_vd : pio->io_spa->spa_root_vdev)); 943 944 if (type == ZIO_TYPE_READ && bp != NULL) { 945 /* 946 * If we have the bp, then the child should perform the 947 * checksum and the parent need not. This pushes error 948 * detection as close to the leaves as possible and 949 * eliminates redundant checksums in the interior nodes. 950 */ 951 pipeline |= ZIO_STAGE_CHECKSUM_VERIFY; 952 pio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY; 953 } 954 955 if (vd->vdev_children == 0) 956 offset += VDEV_LABEL_START_SIZE; 957 958 flags |= ZIO_VDEV_CHILD_FLAGS(pio) | ZIO_FLAG_DONT_PROPAGATE; 959 960 /* 961 * If we've decided to do a repair, the write is not speculative -- 962 * even if the original read was. 963 */ 964 if (flags & ZIO_FLAG_IO_REPAIR) 965 flags &= ~ZIO_FLAG_SPECULATIVE; 966 967 zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, 968 done, private, type, priority, flags, vd, offset, &pio->io_bookmark, 969 ZIO_STAGE_VDEV_IO_START >> 1, pipeline); 970 971 return (zio); 972} 973 974zio_t * 975zio_vdev_delegated_io(vdev_t *vd, uint64_t offset, void *data, uint64_t size, 976 int type, int priority, enum zio_flag flags, 977 zio_done_func_t *done, void *private) 978{ 979 zio_t *zio; 980 981 ASSERT(vd->vdev_ops->vdev_op_leaf); 982 983 zio = zio_create(NULL, vd->vdev_spa, 0, NULL, 984 data, size, done, private, type, priority, 985 flags | ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_RETRY, 986 vd, offset, NULL, 987 ZIO_STAGE_VDEV_IO_START >> 1, ZIO_VDEV_CHILD_PIPELINE); 988 989 return (zio); 990} 991 992void 993zio_flush(zio_t *zio, vdev_t *vd) 994{ 995 zio_nowait(zio_ioctl(zio, zio->io_spa, vd, DKIOCFLUSHWRITECACHE, 0, 0, 996 NULL, NULL, ZIO_PRIORITY_NOW, 997 ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY)); 998} 999 1000zio_t * 1001zio_trim(zio_t *zio, spa_t *spa, vdev_t *vd, uint64_t offset, uint64_t size) 1002{ 1003 1004 ASSERT(vd->vdev_ops->vdev_op_leaf); 1005 1006 return zio_ioctl(zio, spa, vd, DKIOCTRIM, offset, size, 1007 NULL, NULL, ZIO_PRIORITY_TRIM, 1008 ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY); 1009} 1010 1011void 1012zio_shrink(zio_t *zio, uint64_t size) 1013{ 1014 ASSERT(zio->io_executor == NULL); 1015 ASSERT(zio->io_orig_size == zio->io_size); 1016 ASSERT(size <= zio->io_size); 1017 1018 /* 1019 * We don't shrink for raidz because of problems with the 1020 * reconstruction when reading back less than the block size. 1021 * Note, BP_IS_RAIDZ() assumes no compression. 1022 */ 1023 ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF); 1024 if (!BP_IS_RAIDZ(zio->io_bp)) 1025 zio->io_orig_size = zio->io_size = size; 1026} 1027 1028/* 1029 * ========================================================================== 1030 * Prepare to read and write logical blocks 1031 * ========================================================================== 1032 */ 1033 1034static int 1035zio_read_bp_init(zio_t *zio) 1036{ 1037 blkptr_t *bp = zio->io_bp; 1038 1039 if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF && 1040 zio->io_child_type == ZIO_CHILD_LOGICAL && 1041 !(zio->io_flags & ZIO_FLAG_RAW)) { 1042 uint64_t psize = BP_GET_PSIZE(bp); 1043 void *cbuf = zio_buf_alloc(psize); 1044 1045 zio_push_transform(zio, cbuf, psize, psize, zio_decompress); 1046 } 1047 1048 if (!DMU_OT_IS_METADATA(BP_GET_TYPE(bp)) && BP_GET_LEVEL(bp) == 0) 1049 zio->io_flags |= ZIO_FLAG_DONT_CACHE; 1050 1051 if (BP_GET_TYPE(bp) == DMU_OT_DDT_ZAP) 1052 zio->io_flags |= ZIO_FLAG_DONT_CACHE; 1053 1054 if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL) 1055 zio->io_pipeline = ZIO_DDT_READ_PIPELINE; 1056 1057 return (ZIO_PIPELINE_CONTINUE); 1058} 1059 1060static int 1061zio_write_bp_init(zio_t *zio) 1062{ 1063 spa_t *spa = zio->io_spa; 1064 zio_prop_t *zp = &zio->io_prop; 1065 enum zio_compress compress = zp->zp_compress; 1066 blkptr_t *bp = zio->io_bp; 1067 uint64_t lsize = zio->io_size; 1068 uint64_t psize = lsize; 1069 int pass = 1; 1070 1071 /* 1072 * If our children haven't all reached the ready stage, 1073 * wait for them and then repeat this pipeline stage. 1074 */ 1075 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) || 1076 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_READY)) 1077 return (ZIO_PIPELINE_STOP); 1078 1079 if (!IO_IS_ALLOCATING(zio)) 1080 return (ZIO_PIPELINE_CONTINUE); 1081 1082 ASSERT(zio->io_child_type != ZIO_CHILD_DDT); 1083 1084 if (zio->io_bp_override) { 1085 ASSERT(bp->blk_birth != zio->io_txg); 1086 ASSERT(BP_GET_DEDUP(zio->io_bp_override) == 0); 1087 1088 *bp = *zio->io_bp_override; 1089 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 1090 1091 /* 1092 * If we've been overridden and nopwrite is set then 1093 * set the flag accordingly to indicate that a nopwrite 1094 * has already occurred. 1095 */ 1096 if (!BP_IS_HOLE(bp) && zp->zp_nopwrite) { 1097 ASSERT(!zp->zp_dedup); 1098 zio->io_flags |= ZIO_FLAG_NOPWRITE; 1099 return (ZIO_PIPELINE_CONTINUE); 1100 } 1101 1102 ASSERT(!zp->zp_nopwrite); 1103 1104 if (BP_IS_HOLE(bp) || !zp->zp_dedup) 1105 return (ZIO_PIPELINE_CONTINUE); 1106 1107 ASSERT(zio_checksum_table[zp->zp_checksum].ci_dedup || 1108 zp->zp_dedup_verify); 1109 1110 if (BP_GET_CHECKSUM(bp) == zp->zp_checksum) { 1111 BP_SET_DEDUP(bp, 1); 1112 zio->io_pipeline |= ZIO_STAGE_DDT_WRITE; 1113 return (ZIO_PIPELINE_CONTINUE); 1114 } 1115 zio->io_bp_override = NULL; 1116 BP_ZERO(bp); 1117 } 1118 1119 if (bp->blk_birth == zio->io_txg) { 1120 /* 1121 * We're rewriting an existing block, which means we're 1122 * working on behalf of spa_sync(). For spa_sync() to 1123 * converge, it must eventually be the case that we don't 1124 * have to allocate new blocks. But compression changes 1125 * the blocksize, which forces a reallocate, and makes 1126 * convergence take longer. Therefore, after the first 1127 * few passes, stop compressing to ensure convergence. 1128 */ 1129 pass = spa_sync_pass(spa); 1130 1131 ASSERT(zio->io_txg == spa_syncing_txg(spa)); 1132 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 1133 ASSERT(!BP_GET_DEDUP(bp)); 1134 1135 if (pass >= zfs_sync_pass_dont_compress) 1136 compress = ZIO_COMPRESS_OFF; 1137 1138 /* Make sure someone doesn't change their mind on overwrites */ 1139 ASSERT(MIN(zp->zp_copies + BP_IS_GANG(bp), 1140 spa_max_replication(spa)) == BP_GET_NDVAS(bp)); 1141 } 1142 1143 if (compress != ZIO_COMPRESS_OFF) { 1144 metaslab_class_t *mc = spa_normal_class(spa); 1145 void *cbuf = zio_buf_alloc(lsize); 1146 psize = zio_compress_data(compress, zio->io_data, cbuf, lsize, 1147 (size_t)metaslab_class_get_minblocksize(mc)); 1148 if (psize == 0 || psize == lsize) { 1149 compress = ZIO_COMPRESS_OFF; 1150 zio_buf_free(cbuf, lsize); 1151 } else { 1152 ASSERT(psize < lsize); 1153 zio_push_transform(zio, cbuf, psize, lsize, NULL); 1154 } 1155 } 1156 1157 /* 1158 * The final pass of spa_sync() must be all rewrites, but the first 1159 * few passes offer a trade-off: allocating blocks defers convergence, 1160 * but newly allocated blocks are sequential, so they can be written 1161 * to disk faster. Therefore, we allow the first few passes of 1162 * spa_sync() to allocate new blocks, but force rewrites after that. 1163 * There should only be a handful of blocks after pass 1 in any case. 1164 */ 1165 if (bp->blk_birth == zio->io_txg && BP_GET_PSIZE(bp) == psize && 1166 pass >= zfs_sync_pass_rewrite) { 1167 ASSERT(psize != 0); 1168 enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES; 1169 zio->io_pipeline = ZIO_REWRITE_PIPELINE | gang_stages; 1170 zio->io_flags |= ZIO_FLAG_IO_REWRITE; 1171 } else { 1172 BP_ZERO(bp); 1173 zio->io_pipeline = ZIO_WRITE_PIPELINE; 1174 } 1175 1176 if (psize == 0) { 1177 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 1178 } else { 1179 ASSERT(zp->zp_checksum != ZIO_CHECKSUM_GANG_HEADER); 1180 BP_SET_LSIZE(bp, lsize); 1181 BP_SET_PSIZE(bp, psize); 1182 BP_SET_COMPRESS(bp, compress); 1183 BP_SET_CHECKSUM(bp, zp->zp_checksum); 1184 BP_SET_TYPE(bp, zp->zp_type); 1185 BP_SET_LEVEL(bp, zp->zp_level); 1186 BP_SET_DEDUP(bp, zp->zp_dedup); 1187 BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER); 1188 if (zp->zp_dedup) { 1189 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 1190 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE)); 1191 zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE; 1192 } 1193 if (zp->zp_nopwrite) { 1194 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 1195 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE)); 1196 zio->io_pipeline |= ZIO_STAGE_NOP_WRITE; 1197 } 1198 } 1199 1200 return (ZIO_PIPELINE_CONTINUE); 1201} 1202 1203static int 1204zio_free_bp_init(zio_t *zio) 1205{ 1206 blkptr_t *bp = zio->io_bp; 1207 1208 if (zio->io_child_type == ZIO_CHILD_LOGICAL) { 1209 if (BP_GET_DEDUP(bp)) 1210 zio->io_pipeline = ZIO_DDT_FREE_PIPELINE; 1211 } 1212 1213 return (ZIO_PIPELINE_CONTINUE); 1214} 1215 1216/* 1217 * ========================================================================== 1218 * Execute the I/O pipeline 1219 * ========================================================================== 1220 */ 1221 1222static void 1223zio_taskq_dispatch(zio_t *zio, enum zio_taskq_type q, boolean_t cutinline) 1224{ 1225 spa_t *spa = zio->io_spa; 1226 zio_type_t t = zio->io_type; 1227 int flags = TQ_SLEEP | (cutinline ? TQ_FRONT : 0); 1228 1229 ASSERT(q == ZIO_TASKQ_ISSUE || q == ZIO_TASKQ_INTERRUPT); 1230 1231 /* 1232 * If we're a config writer or a probe, the normal issue and 1233 * interrupt threads may all be blocked waiting for the config lock. 1234 * In this case, select the otherwise-unused taskq for ZIO_TYPE_NULL. 1235 */ 1236 if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_PROBE)) 1237 t = ZIO_TYPE_NULL; 1238 1239 /* 1240 * A similar issue exists for the L2ARC write thread until L2ARC 2.0. 1241 */ 1242 if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux) 1243 t = ZIO_TYPE_NULL; 1244 1245 /* 1246 * If this is a high priority I/O, then use the high priority taskq. 1247 */ 1248 if (zio->io_priority == ZIO_PRIORITY_NOW && 1249 spa->spa_zio_taskq[t][q + 1] != NULL) 1250 q++; 1251 1252 ASSERT3U(q, <, ZIO_TASKQ_TYPES); 1253#ifdef _KERNEL 1254 (void) taskq_dispatch_safe(spa->spa_zio_taskq[t][q], 1255 (task_func_t *)zio_execute, zio, flags, &zio->io_task); 1256#else 1257 (void) taskq_dispatch(spa->spa_zio_taskq[t][q], 1258 (task_func_t *)zio_execute, zio, flags); 1259#endif 1260} 1261 1262static boolean_t 1263zio_taskq_member(zio_t *zio, enum zio_taskq_type q) 1264{ 1265 kthread_t *executor = zio->io_executor; 1266 spa_t *spa = zio->io_spa; 1267 1268 for (zio_type_t t = 0; t < ZIO_TYPES; t++) 1269 if (taskq_member(spa->spa_zio_taskq[t][q], executor)) 1270 return (B_TRUE); 1271 1272 return (B_FALSE); 1273} 1274 1275static int 1276zio_issue_async(zio_t *zio) 1277{ 1278 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE); 1279 1280 return (ZIO_PIPELINE_STOP); 1281} 1282 1283void 1284zio_interrupt(zio_t *zio) 1285{ 1286 zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE); 1287} 1288 1289/* 1290 * Execute the I/O pipeline until one of the following occurs: 1291 * 1292 * (1) the I/O completes 1293 * (2) the pipeline stalls waiting for dependent child I/Os 1294 * (3) the I/O issues, so we're waiting for an I/O completion interrupt 1295 * (4) the I/O is delegated by vdev-level caching or aggregation 1296 * (5) the I/O is deferred due to vdev-level queueing 1297 * (6) the I/O is handed off to another thread. 1298 * 1299 * In all cases, the pipeline stops whenever there's no CPU work; it never 1300 * burns a thread in cv_wait(). 1301 * 1302 * There's no locking on io_stage because there's no legitimate way 1303 * for multiple threads to be attempting to process the same I/O. 1304 */ 1305static zio_pipe_stage_t *zio_pipeline[]; 1306 1307void 1308zio_execute(zio_t *zio) 1309{ 1310 zio->io_executor = curthread; 1311 1312 while (zio->io_stage < ZIO_STAGE_DONE) { 1313 enum zio_stage pipeline = zio->io_pipeline; 1314 enum zio_stage stage = zio->io_stage; 1315 int rv; 1316 1317 ASSERT(!MUTEX_HELD(&zio->io_lock)); 1318 ASSERT(ISP2(stage)); 1319 ASSERT(zio->io_stall == NULL); 1320 1321 do { 1322 stage <<= 1; 1323 } while ((stage & pipeline) == 0); 1324 1325 ASSERT(stage <= ZIO_STAGE_DONE); 1326 1327 /* 1328 * If we are in interrupt context and this pipeline stage 1329 * will grab a config lock that is held across I/O, 1330 * or may wait for an I/O that needs an interrupt thread 1331 * to complete, issue async to avoid deadlock. 1332 * 1333 * For VDEV_IO_START, we cut in line so that the io will 1334 * be sent to disk promptly. 1335 */ 1336 if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL && 1337 zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) { 1338 boolean_t cut = (stage == ZIO_STAGE_VDEV_IO_START) ? 1339 zio_requeue_io_start_cut_in_line : B_FALSE; 1340 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut); 1341 return; 1342 } 1343 1344 zio->io_stage = stage; 1345 rv = zio_pipeline[highbit(stage) - 1](zio); 1346 1347 if (rv == ZIO_PIPELINE_STOP) 1348 return; 1349 1350 ASSERT(rv == ZIO_PIPELINE_CONTINUE); 1351 } 1352} 1353 1354/* 1355 * ========================================================================== 1356 * Initiate I/O, either sync or async 1357 * ========================================================================== 1358 */ 1359int 1360zio_wait(zio_t *zio) 1361{ 1362 int error; 1363 1364 ASSERT(zio->io_stage == ZIO_STAGE_OPEN); 1365 ASSERT(zio->io_executor == NULL); 1366 1367 zio->io_waiter = curthread; 1368 1369 zio_execute(zio); 1370 1371 mutex_enter(&zio->io_lock); 1372 while (zio->io_executor != NULL) 1373 cv_wait(&zio->io_cv, &zio->io_lock); 1374 mutex_exit(&zio->io_lock); 1375 1376 error = zio->io_error; 1377 zio_destroy(zio); 1378 1379 return (error); 1380} 1381 1382void 1383zio_nowait(zio_t *zio) 1384{ 1385 ASSERT(zio->io_executor == NULL); 1386 1387 if (zio->io_child_type == ZIO_CHILD_LOGICAL && 1388 zio_unique_parent(zio) == NULL) { 1389 /* 1390 * This is a logical async I/O with no parent to wait for it. 1391 * We add it to the spa_async_root_zio "Godfather" I/O which 1392 * will ensure they complete prior to unloading the pool. 1393 */ 1394 spa_t *spa = zio->io_spa; 1395 1396 zio_add_child(spa->spa_async_zio_root, zio); 1397 } 1398 1399 zio_execute(zio); 1400} 1401 1402/* 1403 * ========================================================================== 1404 * Reexecute or suspend/resume failed I/O 1405 * ========================================================================== 1406 */ 1407 1408static void 1409zio_reexecute(zio_t *pio) 1410{ 1411 zio_t *cio, *cio_next; 1412 1413 ASSERT(pio->io_child_type == ZIO_CHILD_LOGICAL); 1414 ASSERT(pio->io_orig_stage == ZIO_STAGE_OPEN); 1415 ASSERT(pio->io_gang_leader == NULL); 1416 ASSERT(pio->io_gang_tree == NULL); 1417 1418 pio->io_flags = pio->io_orig_flags; 1419 pio->io_stage = pio->io_orig_stage; 1420 pio->io_pipeline = pio->io_orig_pipeline; 1421 pio->io_reexecute = 0; 1422 pio->io_flags |= ZIO_FLAG_REEXECUTED; 1423 pio->io_error = 0; 1424 for (int w = 0; w < ZIO_WAIT_TYPES; w++) 1425 pio->io_state[w] = 0; 1426 for (int c = 0; c < ZIO_CHILD_TYPES; c++) 1427 pio->io_child_error[c] = 0; 1428 1429 if (IO_IS_ALLOCATING(pio)) 1430 BP_ZERO(pio->io_bp); 1431 1432 /* 1433 * As we reexecute pio's children, new children could be created. 1434 * New children go to the head of pio's io_child_list, however, 1435 * so we will (correctly) not reexecute them. The key is that 1436 * the remainder of pio's io_child_list, from 'cio_next' onward, 1437 * cannot be affected by any side effects of reexecuting 'cio'. 1438 */ 1439 for (cio = zio_walk_children(pio); cio != NULL; cio = cio_next) { 1440 cio_next = zio_walk_children(pio); 1441 mutex_enter(&pio->io_lock); 1442 for (int w = 0; w < ZIO_WAIT_TYPES; w++) 1443 pio->io_children[cio->io_child_type][w]++; 1444 mutex_exit(&pio->io_lock); 1445 zio_reexecute(cio); 1446 } 1447 1448 /* 1449 * Now that all children have been reexecuted, execute the parent. 1450 * We don't reexecute "The Godfather" I/O here as it's the 1451 * responsibility of the caller to wait on him. 1452 */ 1453 if (!(pio->io_flags & ZIO_FLAG_GODFATHER)) 1454 zio_execute(pio); 1455} 1456 1457void 1458zio_suspend(spa_t *spa, zio_t *zio) 1459{ 1460 if (spa_get_failmode(spa) == ZIO_FAILURE_MODE_PANIC) 1461 fm_panic("Pool '%s' has encountered an uncorrectable I/O " 1462 "failure and the failure mode property for this pool " 1463 "is set to panic.", spa_name(spa)); 1464 1465 zfs_ereport_post(FM_EREPORT_ZFS_IO_FAILURE, spa, NULL, NULL, 0, 0); 1466 1467 mutex_enter(&spa->spa_suspend_lock); 1468 1469 if (spa->spa_suspend_zio_root == NULL) 1470 spa->spa_suspend_zio_root = zio_root(spa, NULL, NULL, 1471 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | 1472 ZIO_FLAG_GODFATHER); 1473 1474 spa->spa_suspended = B_TRUE; 1475 1476 if (zio != NULL) { 1477 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER)); 1478 ASSERT(zio != spa->spa_suspend_zio_root); 1479 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 1480 ASSERT(zio_unique_parent(zio) == NULL); 1481 ASSERT(zio->io_stage == ZIO_STAGE_DONE); 1482 zio_add_child(spa->spa_suspend_zio_root, zio); 1483 } 1484 1485 mutex_exit(&spa->spa_suspend_lock); 1486} 1487 1488int 1489zio_resume(spa_t *spa) 1490{ 1491 zio_t *pio; 1492 1493 /* 1494 * Reexecute all previously suspended i/o. 1495 */ 1496 mutex_enter(&spa->spa_suspend_lock); 1497 spa->spa_suspended = B_FALSE; 1498 cv_broadcast(&spa->spa_suspend_cv); 1499 pio = spa->spa_suspend_zio_root; 1500 spa->spa_suspend_zio_root = NULL; 1501 mutex_exit(&spa->spa_suspend_lock); 1502 1503 if (pio == NULL) 1504 return (0); 1505 1506 zio_reexecute(pio); 1507 return (zio_wait(pio)); 1508} 1509 1510void 1511zio_resume_wait(spa_t *spa) 1512{ 1513 mutex_enter(&spa->spa_suspend_lock); 1514 while (spa_suspended(spa)) 1515 cv_wait(&spa->spa_suspend_cv, &spa->spa_suspend_lock); 1516 mutex_exit(&spa->spa_suspend_lock); 1517} 1518 1519/* 1520 * ========================================================================== 1521 * Gang blocks. 1522 * 1523 * A gang block is a collection of small blocks that looks to the DMU 1524 * like one large block. When zio_dva_allocate() cannot find a block 1525 * of the requested size, due to either severe fragmentation or the pool 1526 * being nearly full, it calls zio_write_gang_block() to construct the 1527 * block from smaller fragments. 1528 * 1529 * A gang block consists of a gang header (zio_gbh_phys_t) and up to 1530 * three (SPA_GBH_NBLKPTRS) gang members. The gang header is just like 1531 * an indirect block: it's an array of block pointers. It consumes 1532 * only one sector and hence is allocatable regardless of fragmentation. 1533 * The gang header's bps point to its gang members, which hold the data. 1534 * 1535 * Gang blocks are self-checksumming, using the bp's <vdev, offset, txg> 1536 * as the verifier to ensure uniqueness of the SHA256 checksum. 1537 * Critically, the gang block bp's blk_cksum is the checksum of the data, 1538 * not the gang header. This ensures that data block signatures (needed for 1539 * deduplication) are independent of how the block is physically stored. 1540 * 1541 * Gang blocks can be nested: a gang member may itself be a gang block. 1542 * Thus every gang block is a tree in which root and all interior nodes are 1543 * gang headers, and the leaves are normal blocks that contain user data. 1544 * The root of the gang tree is called the gang leader. 1545 * 1546 * To perform any operation (read, rewrite, free, claim) on a gang block, 1547 * zio_gang_assemble() first assembles the gang tree (minus data leaves) 1548 * in the io_gang_tree field of the original logical i/o by recursively 1549 * reading the gang leader and all gang headers below it. This yields 1550 * an in-core tree containing the contents of every gang header and the 1551 * bps for every constituent of the gang block. 1552 * 1553 * With the gang tree now assembled, zio_gang_issue() just walks the gang tree 1554 * and invokes a callback on each bp. To free a gang block, zio_gang_issue() 1555 * calls zio_free_gang() -- a trivial wrapper around zio_free() -- for each bp. 1556 * zio_claim_gang() provides a similarly trivial wrapper for zio_claim(). 1557 * zio_read_gang() is a wrapper around zio_read() that omits reading gang 1558 * headers, since we already have those in io_gang_tree. zio_rewrite_gang() 1559 * performs a zio_rewrite() of the data or, for gang headers, a zio_rewrite() 1560 * of the gang header plus zio_checksum_compute() of the data to update the 1561 * gang header's blk_cksum as described above. 1562 * 1563 * The two-phase assemble/issue model solves the problem of partial failure -- 1564 * what if you'd freed part of a gang block but then couldn't read the 1565 * gang header for another part? Assembling the entire gang tree first 1566 * ensures that all the necessary gang header I/O has succeeded before 1567 * starting the actual work of free, claim, or write. Once the gang tree 1568 * is assembled, free and claim are in-memory operations that cannot fail. 1569 * 1570 * In the event that a gang write fails, zio_dva_unallocate() walks the 1571 * gang tree to immediately free (i.e. insert back into the space map) 1572 * everything we've allocated. This ensures that we don't get ENOSPC 1573 * errors during repeated suspend/resume cycles due to a flaky device. 1574 * 1575 * Gang rewrites only happen during sync-to-convergence. If we can't assemble 1576 * the gang tree, we won't modify the block, so we can safely defer the free 1577 * (knowing that the block is still intact). If we *can* assemble the gang 1578 * tree, then even if some of the rewrites fail, zio_dva_unallocate() will free 1579 * each constituent bp and we can allocate a new block on the next sync pass. 1580 * 1581 * In all cases, the gang tree allows complete recovery from partial failure. 1582 * ========================================================================== 1583 */ 1584 1585static zio_t * 1586zio_read_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, void *data) 1587{ 1588 if (gn != NULL) 1589 return (pio); 1590 1591 return (zio_read(pio, pio->io_spa, bp, data, BP_GET_PSIZE(bp), 1592 NULL, NULL, pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio), 1593 &pio->io_bookmark)); 1594} 1595 1596zio_t * 1597zio_rewrite_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, void *data) 1598{ 1599 zio_t *zio; 1600 1601 if (gn != NULL) { 1602 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp, 1603 gn->gn_gbh, SPA_GANGBLOCKSIZE, NULL, NULL, pio->io_priority, 1604 ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark); 1605 /* 1606 * As we rewrite each gang header, the pipeline will compute 1607 * a new gang block header checksum for it; but no one will 1608 * compute a new data checksum, so we do that here. The one 1609 * exception is the gang leader: the pipeline already computed 1610 * its data checksum because that stage precedes gang assembly. 1611 * (Presently, nothing actually uses interior data checksums; 1612 * this is just good hygiene.) 1613 */ 1614 if (gn != pio->io_gang_leader->io_gang_tree) { 1615 zio_checksum_compute(zio, BP_GET_CHECKSUM(bp), 1616 data, BP_GET_PSIZE(bp)); 1617 } 1618 /* 1619 * If we are here to damage data for testing purposes, 1620 * leave the GBH alone so that we can detect the damage. 1621 */ 1622 if (pio->io_gang_leader->io_flags & ZIO_FLAG_INDUCE_DAMAGE) 1623 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES; 1624 } else { 1625 zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp, 1626 data, BP_GET_PSIZE(bp), NULL, NULL, pio->io_priority, 1627 ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark); 1628 } 1629 1630 return (zio); 1631} 1632 1633/* ARGSUSED */ 1634zio_t * 1635zio_free_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, void *data) 1636{ 1637 return (zio_free_sync(pio, pio->io_spa, pio->io_txg, bp, 1638 BP_IS_GANG(bp) ? SPA_GANGBLOCKSIZE : BP_GET_PSIZE(bp), 1639 ZIO_GANG_CHILD_FLAGS(pio))); 1640} 1641 1642/* ARGSUSED */ 1643zio_t * 1644zio_claim_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, void *data) 1645{ 1646 return (zio_claim(pio, pio->io_spa, pio->io_txg, bp, 1647 NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio))); 1648} 1649 1650static zio_gang_issue_func_t *zio_gang_issue_func[ZIO_TYPES] = { 1651 NULL, 1652 zio_read_gang, 1653 zio_rewrite_gang, 1654 zio_free_gang, 1655 zio_claim_gang, 1656 NULL 1657}; 1658 1659static void zio_gang_tree_assemble_done(zio_t *zio); 1660 1661static zio_gang_node_t * 1662zio_gang_node_alloc(zio_gang_node_t **gnpp) 1663{ 1664 zio_gang_node_t *gn; 1665 1666 ASSERT(*gnpp == NULL); 1667 1668 gn = kmem_zalloc(sizeof (*gn), KM_SLEEP); 1669 gn->gn_gbh = zio_buf_alloc(SPA_GANGBLOCKSIZE); 1670 *gnpp = gn; 1671 1672 return (gn); 1673} 1674 1675static void 1676zio_gang_node_free(zio_gang_node_t **gnpp) 1677{ 1678 zio_gang_node_t *gn = *gnpp; 1679 1680 for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) 1681 ASSERT(gn->gn_child[g] == NULL); 1682 1683 zio_buf_free(gn->gn_gbh, SPA_GANGBLOCKSIZE); 1684 kmem_free(gn, sizeof (*gn)); 1685 *gnpp = NULL; 1686} 1687 1688static void 1689zio_gang_tree_free(zio_gang_node_t **gnpp) 1690{ 1691 zio_gang_node_t *gn = *gnpp; 1692 1693 if (gn == NULL) 1694 return; 1695 1696 for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) 1697 zio_gang_tree_free(&gn->gn_child[g]); 1698 1699 zio_gang_node_free(gnpp); 1700} 1701 1702static void 1703zio_gang_tree_assemble(zio_t *gio, blkptr_t *bp, zio_gang_node_t **gnpp) 1704{ 1705 zio_gang_node_t *gn = zio_gang_node_alloc(gnpp); 1706 1707 ASSERT(gio->io_gang_leader == gio); 1708 ASSERT(BP_IS_GANG(bp)); 1709 1710 zio_nowait(zio_read(gio, gio->io_spa, bp, gn->gn_gbh, 1711 SPA_GANGBLOCKSIZE, zio_gang_tree_assemble_done, gn, 1712 gio->io_priority, ZIO_GANG_CHILD_FLAGS(gio), &gio->io_bookmark)); 1713} 1714 1715static void 1716zio_gang_tree_assemble_done(zio_t *zio) 1717{ 1718 zio_t *gio = zio->io_gang_leader; 1719 zio_gang_node_t *gn = zio->io_private; 1720 blkptr_t *bp = zio->io_bp; 1721 1722 ASSERT(gio == zio_unique_parent(zio)); 1723 ASSERT(zio->io_child_count == 0); 1724 1725 if (zio->io_error) 1726 return; 1727 1728 if (BP_SHOULD_BYTESWAP(bp)) 1729 byteswap_uint64_array(zio->io_data, zio->io_size); 1730 1731 ASSERT(zio->io_data == gn->gn_gbh); 1732 ASSERT(zio->io_size == SPA_GANGBLOCKSIZE); 1733 ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC); 1734 1735 for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) { 1736 blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g]; 1737 if (!BP_IS_GANG(gbp)) 1738 continue; 1739 zio_gang_tree_assemble(gio, gbp, &gn->gn_child[g]); 1740 } 1741} 1742 1743static void 1744zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, void *data) 1745{ 1746 zio_t *gio = pio->io_gang_leader; 1747 zio_t *zio; 1748 1749 ASSERT(BP_IS_GANG(bp) == !!gn); 1750 ASSERT(BP_GET_CHECKSUM(bp) == BP_GET_CHECKSUM(gio->io_bp)); 1751 ASSERT(BP_GET_LSIZE(bp) == BP_GET_PSIZE(bp) || gn == gio->io_gang_tree); 1752 1753 /* 1754 * If you're a gang header, your data is in gn->gn_gbh. 1755 * If you're a gang member, your data is in 'data' and gn == NULL. 1756 */ 1757 zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data); 1758 1759 if (gn != NULL) { 1760 ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC); 1761 1762 for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) { 1763 blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g]; 1764 if (BP_IS_HOLE(gbp)) 1765 continue; 1766 zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data); 1767 data = (char *)data + BP_GET_PSIZE(gbp); 1768 } 1769 } 1770 1771 if (gn == gio->io_gang_tree && gio->io_data != NULL) 1772 ASSERT3P((char *)gio->io_data + gio->io_size, ==, data); 1773 1774 if (zio != pio) 1775 zio_nowait(zio); 1776} 1777 1778static int 1779zio_gang_assemble(zio_t *zio) 1780{ 1781 blkptr_t *bp = zio->io_bp; 1782 1783 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL); 1784 ASSERT(zio->io_child_type > ZIO_CHILD_GANG); 1785 1786 zio->io_gang_leader = zio; 1787 1788 zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree); 1789 1790 return (ZIO_PIPELINE_CONTINUE); 1791} 1792 1793static int 1794zio_gang_issue(zio_t *zio) 1795{ 1796 blkptr_t *bp = zio->io_bp; 1797 1798 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE)) 1799 return (ZIO_PIPELINE_STOP); 1800 1801 ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio); 1802 ASSERT(zio->io_child_type > ZIO_CHILD_GANG); 1803 1804 if (zio->io_child_error[ZIO_CHILD_GANG] == 0) 1805 zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_data); 1806 else 1807 zio_gang_tree_free(&zio->io_gang_tree); 1808 1809 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 1810 1811 return (ZIO_PIPELINE_CONTINUE); 1812} 1813 1814static void 1815zio_write_gang_member_ready(zio_t *zio) 1816{ 1817 zio_t *pio = zio_unique_parent(zio); 1818 zio_t *gio = zio->io_gang_leader; 1819 dva_t *cdva = zio->io_bp->blk_dva; 1820 dva_t *pdva = pio->io_bp->blk_dva; 1821 uint64_t asize; 1822 1823 if (BP_IS_HOLE(zio->io_bp)) 1824 return; 1825 1826 ASSERT(BP_IS_HOLE(&zio->io_bp_orig)); 1827 1828 ASSERT(zio->io_child_type == ZIO_CHILD_GANG); 1829 ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies); 1830 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp)); 1831 ASSERT3U(pio->io_prop.zp_copies, <=, BP_GET_NDVAS(pio->io_bp)); 1832 ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp)); 1833 1834 mutex_enter(&pio->io_lock); 1835 for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) { 1836 ASSERT(DVA_GET_GANG(&pdva[d])); 1837 asize = DVA_GET_ASIZE(&pdva[d]); 1838 asize += DVA_GET_ASIZE(&cdva[d]); 1839 DVA_SET_ASIZE(&pdva[d], asize); 1840 } 1841 mutex_exit(&pio->io_lock); 1842} 1843 1844static int 1845zio_write_gang_block(zio_t *pio) 1846{ 1847 spa_t *spa = pio->io_spa; 1848 blkptr_t *bp = pio->io_bp; 1849 zio_t *gio = pio->io_gang_leader; 1850 zio_t *zio; 1851 zio_gang_node_t *gn, **gnpp; 1852 zio_gbh_phys_t *gbh; 1853 uint64_t txg = pio->io_txg; 1854 uint64_t resid = pio->io_size; 1855 uint64_t lsize; 1856 int copies = gio->io_prop.zp_copies; 1857 int gbh_copies = MIN(copies + 1, spa_max_replication(spa)); 1858 zio_prop_t zp; 1859 int error; 1860 1861 error = metaslab_alloc(spa, spa_normal_class(spa), SPA_GANGBLOCKSIZE, 1862 bp, gbh_copies, txg, pio == gio ? NULL : gio->io_bp, 1863 METASLAB_HINTBP_FAVOR | METASLAB_GANG_HEADER); 1864 if (error) { 1865 pio->io_error = error; 1866 return (ZIO_PIPELINE_CONTINUE); 1867 } 1868 1869 if (pio == gio) { 1870 gnpp = &gio->io_gang_tree; 1871 } else { 1872 gnpp = pio->io_private; 1873 ASSERT(pio->io_ready == zio_write_gang_member_ready); 1874 } 1875 1876 gn = zio_gang_node_alloc(gnpp); 1877 gbh = gn->gn_gbh; 1878 bzero(gbh, SPA_GANGBLOCKSIZE); 1879 1880 /* 1881 * Create the gang header. 1882 */ 1883 zio = zio_rewrite(pio, spa, txg, bp, gbh, SPA_GANGBLOCKSIZE, NULL, NULL, 1884 pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark); 1885 1886 /* 1887 * Create and nowait the gang children. 1888 */ 1889 for (int g = 0; resid != 0; resid -= lsize, g++) { 1890 lsize = P2ROUNDUP(resid / (SPA_GBH_NBLKPTRS - g), 1891 SPA_MINBLOCKSIZE); 1892 ASSERT(lsize >= SPA_MINBLOCKSIZE && lsize <= resid); 1893 1894 zp.zp_checksum = gio->io_prop.zp_checksum; 1895 zp.zp_compress = ZIO_COMPRESS_OFF; 1896 zp.zp_type = DMU_OT_NONE; 1897 zp.zp_level = 0; 1898 zp.zp_copies = gio->io_prop.zp_copies; 1899 zp.zp_dedup = B_FALSE; 1900 zp.zp_dedup_verify = B_FALSE; 1901 zp.zp_nopwrite = B_FALSE; 1902 1903 zio_nowait(zio_write(zio, spa, txg, &gbh->zg_blkptr[g], 1904 (char *)pio->io_data + (pio->io_size - resid), lsize, &zp, 1905 zio_write_gang_member_ready, NULL, &gn->gn_child[g], 1906 pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio), 1907 &pio->io_bookmark)); 1908 } 1909 1910 /* 1911 * Set pio's pipeline to just wait for zio to finish. 1912 */ 1913 pio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 1914 1915 zio_nowait(zio); 1916 1917 return (ZIO_PIPELINE_CONTINUE); 1918} 1919 1920/* 1921 * The zio_nop_write stage in the pipeline determines if allocating 1922 * a new bp is necessary. By leveraging a cryptographically secure checksum, 1923 * such as SHA256, we can compare the checksums of the new data and the old 1924 * to determine if allocating a new block is required. The nopwrite 1925 * feature can handle writes in either syncing or open context (i.e. zil 1926 * writes) and as a result is mutually exclusive with dedup. 1927 */ 1928static int 1929zio_nop_write(zio_t *zio) 1930{ 1931 blkptr_t *bp = zio->io_bp; 1932 blkptr_t *bp_orig = &zio->io_bp_orig; 1933 zio_prop_t *zp = &zio->io_prop; 1934 1935 ASSERT(BP_GET_LEVEL(bp) == 0); 1936 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE)); 1937 ASSERT(zp->zp_nopwrite); 1938 ASSERT(!zp->zp_dedup); 1939 ASSERT(zio->io_bp_override == NULL); 1940 ASSERT(IO_IS_ALLOCATING(zio)); 1941 1942 /* 1943 * Check to see if the original bp and the new bp have matching 1944 * characteristics (i.e. same checksum, compression algorithms, etc). 1945 * If they don't then just continue with the pipeline which will 1946 * allocate a new bp. 1947 */ 1948 if (BP_IS_HOLE(bp_orig) || 1949 !zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_dedup || 1950 BP_GET_CHECKSUM(bp) != BP_GET_CHECKSUM(bp_orig) || 1951 BP_GET_COMPRESS(bp) != BP_GET_COMPRESS(bp_orig) || 1952 BP_GET_DEDUP(bp) != BP_GET_DEDUP(bp_orig) || 1953 zp->zp_copies != BP_GET_NDVAS(bp_orig)) 1954 return (ZIO_PIPELINE_CONTINUE); 1955 1956 /* 1957 * If the checksums match then reset the pipeline so that we 1958 * avoid allocating a new bp and issuing any I/O. 1959 */ 1960 if (ZIO_CHECKSUM_EQUAL(bp->blk_cksum, bp_orig->blk_cksum)) { 1961 ASSERT(zio_checksum_table[zp->zp_checksum].ci_dedup); 1962 ASSERT3U(BP_GET_PSIZE(bp), ==, BP_GET_PSIZE(bp_orig)); 1963 ASSERT3U(BP_GET_LSIZE(bp), ==, BP_GET_LSIZE(bp_orig)); 1964 ASSERT(zp->zp_compress != ZIO_COMPRESS_OFF); 1965 ASSERT(bcmp(&bp->blk_prop, &bp_orig->blk_prop, 1966 sizeof (uint64_t)) == 0); 1967 1968 *bp = *bp_orig; 1969 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 1970 zio->io_flags |= ZIO_FLAG_NOPWRITE; 1971 } 1972 1973 return (ZIO_PIPELINE_CONTINUE); 1974} 1975 1976/* 1977 * ========================================================================== 1978 * Dedup 1979 * ========================================================================== 1980 */ 1981static void 1982zio_ddt_child_read_done(zio_t *zio) 1983{ 1984 blkptr_t *bp = zio->io_bp; 1985 ddt_entry_t *dde = zio->io_private; 1986 ddt_phys_t *ddp; 1987 zio_t *pio = zio_unique_parent(zio); 1988 1989 mutex_enter(&pio->io_lock); 1990 ddp = ddt_phys_select(dde, bp); 1991 if (zio->io_error == 0) 1992 ddt_phys_clear(ddp); /* this ddp doesn't need repair */ 1993 if (zio->io_error == 0 && dde->dde_repair_data == NULL) 1994 dde->dde_repair_data = zio->io_data; 1995 else 1996 zio_buf_free(zio->io_data, zio->io_size); 1997 mutex_exit(&pio->io_lock); 1998} 1999 2000static int 2001zio_ddt_read_start(zio_t *zio) 2002{ 2003 blkptr_t *bp = zio->io_bp; 2004 2005 ASSERT(BP_GET_DEDUP(bp)); 2006 ASSERT(BP_GET_PSIZE(bp) == zio->io_size); 2007 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 2008 2009 if (zio->io_child_error[ZIO_CHILD_DDT]) { 2010 ddt_t *ddt = ddt_select(zio->io_spa, bp); 2011 ddt_entry_t *dde = ddt_repair_start(ddt, bp); 2012 ddt_phys_t *ddp = dde->dde_phys; 2013 ddt_phys_t *ddp_self = ddt_phys_select(dde, bp); 2014 blkptr_t blk; 2015 2016 ASSERT(zio->io_vsd == NULL); 2017 zio->io_vsd = dde; 2018 2019 if (ddp_self == NULL) 2020 return (ZIO_PIPELINE_CONTINUE); 2021 2022 for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) { 2023 if (ddp->ddp_phys_birth == 0 || ddp == ddp_self) 2024 continue; 2025 ddt_bp_create(ddt->ddt_checksum, &dde->dde_key, ddp, 2026 &blk); 2027 zio_nowait(zio_read(zio, zio->io_spa, &blk, 2028 zio_buf_alloc(zio->io_size), zio->io_size, 2029 zio_ddt_child_read_done, dde, zio->io_priority, 2030 ZIO_DDT_CHILD_FLAGS(zio) | ZIO_FLAG_DONT_PROPAGATE, 2031 &zio->io_bookmark)); 2032 } 2033 return (ZIO_PIPELINE_CONTINUE); 2034 } 2035 2036 zio_nowait(zio_read(zio, zio->io_spa, bp, 2037 zio->io_data, zio->io_size, NULL, NULL, zio->io_priority, 2038 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark)); 2039 2040 return (ZIO_PIPELINE_CONTINUE); 2041} 2042 2043static int 2044zio_ddt_read_done(zio_t *zio) 2045{ 2046 blkptr_t *bp = zio->io_bp; 2047 2048 if (zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE)) 2049 return (ZIO_PIPELINE_STOP); 2050 2051 ASSERT(BP_GET_DEDUP(bp)); 2052 ASSERT(BP_GET_PSIZE(bp) == zio->io_size); 2053 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 2054 2055 if (zio->io_child_error[ZIO_CHILD_DDT]) { 2056 ddt_t *ddt = ddt_select(zio->io_spa, bp); 2057 ddt_entry_t *dde = zio->io_vsd; 2058 if (ddt == NULL) { 2059 ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE); 2060 return (ZIO_PIPELINE_CONTINUE); 2061 } 2062 if (dde == NULL) { 2063 zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1; 2064 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE); 2065 return (ZIO_PIPELINE_STOP); 2066 } 2067 if (dde->dde_repair_data != NULL) { 2068 bcopy(dde->dde_repair_data, zio->io_data, zio->io_size); 2069 zio->io_child_error[ZIO_CHILD_DDT] = 0; 2070 } 2071 ddt_repair_done(ddt, dde); 2072 zio->io_vsd = NULL; 2073 } 2074 2075 ASSERT(zio->io_vsd == NULL); 2076 2077 return (ZIO_PIPELINE_CONTINUE); 2078} 2079 2080static boolean_t 2081zio_ddt_collision(zio_t *zio, ddt_t *ddt, ddt_entry_t *dde) 2082{ 2083 spa_t *spa = zio->io_spa; 2084 2085 /* 2086 * Note: we compare the original data, not the transformed data, 2087 * because when zio->io_bp is an override bp, we will not have 2088 * pushed the I/O transforms. That's an important optimization 2089 * because otherwise we'd compress/encrypt all dmu_sync() data twice. 2090 */ 2091 for (int p = DDT_PHYS_SINGLE; p <= DDT_PHYS_TRIPLE; p++) { 2092 zio_t *lio = dde->dde_lead_zio[p]; 2093 2094 if (lio != NULL) { 2095 return (lio->io_orig_size != zio->io_orig_size || 2096 bcmp(zio->io_orig_data, lio->io_orig_data, 2097 zio->io_orig_size) != 0); 2098 } 2099 } 2100 2101 for (int p = DDT_PHYS_SINGLE; p <= DDT_PHYS_TRIPLE; p++) { 2102 ddt_phys_t *ddp = &dde->dde_phys[p]; 2103 2104 if (ddp->ddp_phys_birth != 0) { 2105 arc_buf_t *abuf = NULL; 2106 uint32_t aflags = ARC_WAIT; 2107 blkptr_t blk = *zio->io_bp; 2108 int error; 2109 2110 ddt_bp_fill(ddp, &blk, ddp->ddp_phys_birth); 2111 2112 ddt_exit(ddt); 2113 2114 error = arc_read(NULL, spa, &blk, 2115 arc_getbuf_func, &abuf, ZIO_PRIORITY_SYNC_READ, 2116 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE, 2117 &aflags, &zio->io_bookmark); 2118 2119 if (error == 0) { 2120 if (arc_buf_size(abuf) != zio->io_orig_size || 2121 bcmp(abuf->b_data, zio->io_orig_data, 2122 zio->io_orig_size) != 0) 2123 error = SET_ERROR(EEXIST); 2124 VERIFY(arc_buf_remove_ref(abuf, &abuf)); 2125 } 2126 2127 ddt_enter(ddt); 2128 return (error != 0); 2129 } 2130 } 2131 2132 return (B_FALSE); 2133} 2134 2135static void 2136zio_ddt_child_write_ready(zio_t *zio) 2137{ 2138 int p = zio->io_prop.zp_copies; 2139 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp); 2140 ddt_entry_t *dde = zio->io_private; 2141 ddt_phys_t *ddp = &dde->dde_phys[p]; 2142 zio_t *pio; 2143 2144 if (zio->io_error) 2145 return; 2146 2147 ddt_enter(ddt); 2148 2149 ASSERT(dde->dde_lead_zio[p] == zio); 2150 2151 ddt_phys_fill(ddp, zio->io_bp); 2152 2153 while ((pio = zio_walk_parents(zio)) != NULL) 2154 ddt_bp_fill(ddp, pio->io_bp, zio->io_txg); 2155 2156 ddt_exit(ddt); 2157} 2158 2159static void 2160zio_ddt_child_write_done(zio_t *zio) 2161{ 2162 int p = zio->io_prop.zp_copies; 2163 ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp); 2164 ddt_entry_t *dde = zio->io_private; 2165 ddt_phys_t *ddp = &dde->dde_phys[p]; 2166 2167 ddt_enter(ddt); 2168 2169 ASSERT(ddp->ddp_refcnt == 0); 2170 ASSERT(dde->dde_lead_zio[p] == zio); 2171 dde->dde_lead_zio[p] = NULL; 2172 2173 if (zio->io_error == 0) { 2174 while (zio_walk_parents(zio) != NULL) 2175 ddt_phys_addref(ddp); 2176 } else { 2177 ddt_phys_clear(ddp); 2178 } 2179 2180 ddt_exit(ddt); 2181} 2182 2183static void 2184zio_ddt_ditto_write_done(zio_t *zio) 2185{ 2186 int p = DDT_PHYS_DITTO; 2187 zio_prop_t *zp = &zio->io_prop; 2188 blkptr_t *bp = zio->io_bp; 2189 ddt_t *ddt = ddt_select(zio->io_spa, bp); 2190 ddt_entry_t *dde = zio->io_private; 2191 ddt_phys_t *ddp = &dde->dde_phys[p]; 2192 ddt_key_t *ddk = &dde->dde_key; 2193 2194 ddt_enter(ddt); 2195 2196 ASSERT(ddp->ddp_refcnt == 0); 2197 ASSERT(dde->dde_lead_zio[p] == zio); 2198 dde->dde_lead_zio[p] = NULL; 2199 2200 if (zio->io_error == 0) { 2201 ASSERT(ZIO_CHECKSUM_EQUAL(bp->blk_cksum, ddk->ddk_cksum)); 2202 ASSERT(zp->zp_copies < SPA_DVAS_PER_BP); 2203 ASSERT(zp->zp_copies == BP_GET_NDVAS(bp) - BP_IS_GANG(bp)); 2204 if (ddp->ddp_phys_birth != 0) 2205 ddt_phys_free(ddt, ddk, ddp, zio->io_txg); 2206 ddt_phys_fill(ddp, bp); 2207 } 2208 2209 ddt_exit(ddt); 2210} 2211 2212static int 2213zio_ddt_write(zio_t *zio) 2214{ 2215 spa_t *spa = zio->io_spa; 2216 blkptr_t *bp = zio->io_bp; 2217 uint64_t txg = zio->io_txg; 2218 zio_prop_t *zp = &zio->io_prop; 2219 int p = zp->zp_copies; 2220 int ditto_copies; 2221 zio_t *cio = NULL; 2222 zio_t *dio = NULL; 2223 ddt_t *ddt = ddt_select(spa, bp); 2224 ddt_entry_t *dde; 2225 ddt_phys_t *ddp; 2226 2227 ASSERT(BP_GET_DEDUP(bp)); 2228 ASSERT(BP_GET_CHECKSUM(bp) == zp->zp_checksum); 2229 ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override); 2230 2231 ddt_enter(ddt); 2232 dde = ddt_lookup(ddt, bp, B_TRUE); 2233 ddp = &dde->dde_phys[p]; 2234 2235 if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) { 2236 /* 2237 * If we're using a weak checksum, upgrade to a strong checksum 2238 * and try again. If we're already using a strong checksum, 2239 * we can't resolve it, so just convert to an ordinary write. 2240 * (And automatically e-mail a paper to Nature?) 2241 */ 2242 if (!zio_checksum_table[zp->zp_checksum].ci_dedup) { 2243 zp->zp_checksum = spa_dedup_checksum(spa); 2244 zio_pop_transforms(zio); 2245 zio->io_stage = ZIO_STAGE_OPEN; 2246 BP_ZERO(bp); 2247 } else { 2248 zp->zp_dedup = B_FALSE; 2249 } 2250 zio->io_pipeline = ZIO_WRITE_PIPELINE; 2251 ddt_exit(ddt); 2252 return (ZIO_PIPELINE_CONTINUE); 2253 } 2254 2255 ditto_copies = ddt_ditto_copies_needed(ddt, dde, ddp); 2256 ASSERT(ditto_copies < SPA_DVAS_PER_BP); 2257 2258 if (ditto_copies > ddt_ditto_copies_present(dde) && 2259 dde->dde_lead_zio[DDT_PHYS_DITTO] == NULL) { 2260 zio_prop_t czp = *zp; 2261 2262 czp.zp_copies = ditto_copies; 2263 2264 /* 2265 * If we arrived here with an override bp, we won't have run 2266 * the transform stack, so we won't have the data we need to 2267 * generate a child i/o. So, toss the override bp and restart. 2268 * This is safe, because using the override bp is just an 2269 * optimization; and it's rare, so the cost doesn't matter. 2270 */ 2271 if (zio->io_bp_override) { 2272 zio_pop_transforms(zio); 2273 zio->io_stage = ZIO_STAGE_OPEN; 2274 zio->io_pipeline = ZIO_WRITE_PIPELINE; 2275 zio->io_bp_override = NULL; 2276 BP_ZERO(bp); 2277 ddt_exit(ddt); 2278 return (ZIO_PIPELINE_CONTINUE); 2279 } 2280 2281 dio = zio_write(zio, spa, txg, bp, zio->io_orig_data, 2282 zio->io_orig_size, &czp, NULL, 2283 zio_ddt_ditto_write_done, dde, zio->io_priority, 2284 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark); 2285 2286 zio_push_transform(dio, zio->io_data, zio->io_size, 0, NULL); 2287 dde->dde_lead_zio[DDT_PHYS_DITTO] = dio; 2288 } 2289 2290 if (ddp->ddp_phys_birth != 0 || dde->dde_lead_zio[p] != NULL) { 2291 if (ddp->ddp_phys_birth != 0) 2292 ddt_bp_fill(ddp, bp, txg); 2293 if (dde->dde_lead_zio[p] != NULL) 2294 zio_add_child(zio, dde->dde_lead_zio[p]); 2295 else 2296 ddt_phys_addref(ddp); 2297 } else if (zio->io_bp_override) { 2298 ASSERT(bp->blk_birth == txg); 2299 ASSERT(BP_EQUAL(bp, zio->io_bp_override)); 2300 ddt_phys_fill(ddp, bp); 2301 ddt_phys_addref(ddp); 2302 } else { 2303 cio = zio_write(zio, spa, txg, bp, zio->io_orig_data, 2304 zio->io_orig_size, zp, zio_ddt_child_write_ready, 2305 zio_ddt_child_write_done, dde, zio->io_priority, 2306 ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark); 2307 2308 zio_push_transform(cio, zio->io_data, zio->io_size, 0, NULL); 2309 dde->dde_lead_zio[p] = cio; 2310 } 2311 2312 ddt_exit(ddt); 2313 2314 if (cio) 2315 zio_nowait(cio); 2316 if (dio) 2317 zio_nowait(dio); 2318 2319 return (ZIO_PIPELINE_CONTINUE); 2320} 2321 2322ddt_entry_t *freedde; /* for debugging */ 2323 2324static int 2325zio_ddt_free(zio_t *zio) 2326{ 2327 spa_t *spa = zio->io_spa; 2328 blkptr_t *bp = zio->io_bp; 2329 ddt_t *ddt = ddt_select(spa, bp); 2330 ddt_entry_t *dde; 2331 ddt_phys_t *ddp; 2332 2333 ASSERT(BP_GET_DEDUP(bp)); 2334 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 2335 2336 ddt_enter(ddt); 2337 freedde = dde = ddt_lookup(ddt, bp, B_TRUE); 2338 ddp = ddt_phys_select(dde, bp); 2339 ddt_phys_decref(ddp); 2340 ddt_exit(ddt); 2341 2342 return (ZIO_PIPELINE_CONTINUE); 2343} 2344 2345/* 2346 * ========================================================================== 2347 * Allocate and free blocks 2348 * ========================================================================== 2349 */ 2350static int 2351zio_dva_allocate(zio_t *zio) 2352{ 2353 spa_t *spa = zio->io_spa; 2354 metaslab_class_t *mc = spa_normal_class(spa); 2355 blkptr_t *bp = zio->io_bp; 2356 int error; 2357 int flags = 0; 2358 2359 if (zio->io_gang_leader == NULL) { 2360 ASSERT(zio->io_child_type > ZIO_CHILD_GANG); 2361 zio->io_gang_leader = zio; 2362 } 2363 2364 ASSERT(BP_IS_HOLE(bp)); 2365 ASSERT0(BP_GET_NDVAS(bp)); 2366 ASSERT3U(zio->io_prop.zp_copies, >, 0); 2367 ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa)); 2368 ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp)); 2369 2370 /* 2371 * The dump device does not support gang blocks so allocation on 2372 * behalf of the dump device (i.e. ZIO_FLAG_NODATA) must avoid 2373 * the "fast" gang feature. 2374 */ 2375 flags |= (zio->io_flags & ZIO_FLAG_NODATA) ? METASLAB_GANG_AVOID : 0; 2376 flags |= (zio->io_flags & ZIO_FLAG_GANG_CHILD) ? 2377 METASLAB_GANG_CHILD : 0; 2378 error = metaslab_alloc(spa, mc, zio->io_size, bp, 2379 zio->io_prop.zp_copies, zio->io_txg, NULL, flags); 2380 2381 if (error) { 2382 spa_dbgmsg(spa, "%s: metaslab allocation failure: zio %p, " 2383 "size %llu, error %d", spa_name(spa), zio, zio->io_size, 2384 error); 2385 if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE) 2386 return (zio_write_gang_block(zio)); 2387 zio->io_error = error; 2388 } 2389 2390 return (ZIO_PIPELINE_CONTINUE); 2391} 2392 2393static int 2394zio_dva_free(zio_t *zio) 2395{ 2396 metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE); 2397 2398 return (ZIO_PIPELINE_CONTINUE); 2399} 2400 2401static int 2402zio_dva_claim(zio_t *zio) 2403{ 2404 int error; 2405 2406 error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg); 2407 if (error) 2408 zio->io_error = error; 2409 2410 return (ZIO_PIPELINE_CONTINUE); 2411} 2412 2413/* 2414 * Undo an allocation. This is used by zio_done() when an I/O fails 2415 * and we want to give back the block we just allocated. 2416 * This handles both normal blocks and gang blocks. 2417 */ 2418static void 2419zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp) 2420{ 2421 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp)); 2422 ASSERT(zio->io_bp_override == NULL); 2423 2424 if (!BP_IS_HOLE(bp)) 2425 metaslab_free(zio->io_spa, bp, bp->blk_birth, B_TRUE); 2426 2427 if (gn != NULL) { 2428 for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) { 2429 zio_dva_unallocate(zio, gn->gn_child[g], 2430 &gn->gn_gbh->zg_blkptr[g]); 2431 } 2432 } 2433} 2434 2435/* 2436 * Try to allocate an intent log block. Return 0 on success, errno on failure. 2437 */ 2438int 2439zio_alloc_zil(spa_t *spa, uint64_t txg, blkptr_t *new_bp, blkptr_t *old_bp, 2440 uint64_t size, boolean_t use_slog) 2441{ 2442 int error = 1; 2443 2444 ASSERT(txg > spa_syncing_txg(spa)); 2445 2446 /* 2447 * ZIL blocks are always contiguous (i.e. not gang blocks) so we 2448 * set the METASLAB_GANG_AVOID flag so that they don't "fast gang" 2449 * when allocating them. 2450 */ 2451 if (use_slog) { 2452 error = metaslab_alloc(spa, spa_log_class(spa), size, 2453 new_bp, 1, txg, old_bp, 2454 METASLAB_HINTBP_AVOID | METASLAB_GANG_AVOID); 2455 } 2456 2457 if (error) { 2458 error = metaslab_alloc(spa, spa_normal_class(spa), size, 2459 new_bp, 1, txg, old_bp, 2460 METASLAB_HINTBP_AVOID | METASLAB_GANG_AVOID); 2461 } 2462 2463 if (error == 0) { 2464 BP_SET_LSIZE(new_bp, size); 2465 BP_SET_PSIZE(new_bp, size); 2466 BP_SET_COMPRESS(new_bp, ZIO_COMPRESS_OFF); 2467 BP_SET_CHECKSUM(new_bp, 2468 spa_version(spa) >= SPA_VERSION_SLIM_ZIL 2469 ? ZIO_CHECKSUM_ZILOG2 : ZIO_CHECKSUM_ZILOG); 2470 BP_SET_TYPE(new_bp, DMU_OT_INTENT_LOG); 2471 BP_SET_LEVEL(new_bp, 0); 2472 BP_SET_DEDUP(new_bp, 0); 2473 BP_SET_BYTEORDER(new_bp, ZFS_HOST_BYTEORDER); 2474 } 2475 2476 return (error); 2477} 2478 2479/* 2480 * Free an intent log block. 2481 */ 2482void 2483zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp) 2484{ 2485 ASSERT(BP_GET_TYPE(bp) == DMU_OT_INTENT_LOG); 2486 ASSERT(!BP_IS_GANG(bp)); 2487 2488 zio_free(spa, txg, bp); 2489} 2490 2491/* 2492 * ========================================================================== 2493 * Read, write and delete to physical devices 2494 * ========================================================================== 2495 */ 2496static int 2497zio_vdev_io_start(zio_t *zio) 2498{ 2499 vdev_t *vd = zio->io_vd; 2500 uint64_t align; 2501 spa_t *spa = zio->io_spa; 2502 2503 ASSERT(zio->io_error == 0); 2504 ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0); 2505 2506 if (vd == NULL) { 2507 if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER)) 2508 spa_config_enter(spa, SCL_ZIO, zio, RW_READER); 2509 2510 /* 2511 * The mirror_ops handle multiple DVAs in a single BP. 2512 */ 2513 return (vdev_mirror_ops.vdev_op_io_start(zio)); 2514 } 2515 2516 if (vd->vdev_ops->vdev_op_leaf && zio->io_type == ZIO_TYPE_FREE) { 2517 trim_map_free(vd, zio->io_offset, zio->io_size, zio->io_txg); 2518 return (ZIO_PIPELINE_CONTINUE); 2519 } 2520 2521 /* 2522 * We keep track of time-sensitive I/Os so that the scan thread 2523 * can quickly react to certain workloads. In particular, we care 2524 * about non-scrubbing, top-level reads and writes with the following 2525 * characteristics: 2526 * - synchronous writes of user data to non-slog devices 2527 * - any reads of user data 2528 * When these conditions are met, adjust the timestamp of spa_last_io 2529 * which allows the scan thread to adjust its workload accordingly. 2530 */ 2531 if (!(zio->io_flags & ZIO_FLAG_SCAN_THREAD) && zio->io_bp != NULL && 2532 vd == vd->vdev_top && !vd->vdev_islog && 2533 zio->io_bookmark.zb_objset != DMU_META_OBJSET && 2534 zio->io_txg != spa_syncing_txg(spa)) { 2535 uint64_t old = spa->spa_last_io; 2536 uint64_t new = ddi_get_lbolt64(); 2537 if (old != new) 2538 (void) atomic_cas_64(&spa->spa_last_io, old, new); 2539 } 2540 2541 align = 1ULL << vd->vdev_top->vdev_ashift; 2542 2543 if (P2PHASE(zio->io_size, align) != 0) { 2544 uint64_t asize = P2ROUNDUP(zio->io_size, align); 2545 char *abuf = NULL; 2546 if (zio->io_type == ZIO_TYPE_READ || 2547 zio->io_type == ZIO_TYPE_WRITE) 2548 abuf = zio_buf_alloc(asize); 2549 ASSERT(vd == vd->vdev_top); 2550 if (zio->io_type == ZIO_TYPE_WRITE) { 2551 bcopy(zio->io_data, abuf, zio->io_size); 2552 bzero(abuf + zio->io_size, asize - zio->io_size); 2553 } 2554 zio_push_transform(zio, abuf, asize, abuf ? asize : 0, 2555 zio_subblock); 2556 } 2557 2558 ASSERT(P2PHASE(zio->io_offset, align) == 0); 2559 ASSERT(P2PHASE(zio->io_size, align) == 0); 2560 VERIFY(zio->io_type == ZIO_TYPE_READ || spa_writeable(spa)); 2561 2562 /* 2563 * If this is a repair I/O, and there's no self-healing involved -- 2564 * that is, we're just resilvering what we expect to resilver -- 2565 * then don't do the I/O unless zio's txg is actually in vd's DTL. 2566 * This prevents spurious resilvering with nested replication. 2567 * For example, given a mirror of mirrors, (A+B)+(C+D), if only 2568 * A is out of date, we'll read from C+D, then use the data to 2569 * resilver A+B -- but we don't actually want to resilver B, just A. 2570 * The top-level mirror has no way to know this, so instead we just 2571 * discard unnecessary repairs as we work our way down the vdev tree. 2572 * The same logic applies to any form of nested replication: 2573 * ditto + mirror, RAID-Z + replacing, etc. This covers them all. 2574 */ 2575 if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) && 2576 !(zio->io_flags & ZIO_FLAG_SELF_HEAL) && 2577 zio->io_txg != 0 && /* not a delegated i/o */ 2578 !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) { 2579 ASSERT(zio->io_type == ZIO_TYPE_WRITE); 2580 zio_vdev_io_bypass(zio); 2581 return (ZIO_PIPELINE_CONTINUE); 2582 } 2583 2584 if (vd->vdev_ops->vdev_op_leaf && 2585 (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE)) { 2586 2587 if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio) == 0) 2588 return (ZIO_PIPELINE_CONTINUE); 2589 2590 if ((zio = vdev_queue_io(zio)) == NULL) 2591 return (ZIO_PIPELINE_STOP); 2592 2593 if (!vdev_accessible(vd, zio)) { 2594 zio->io_error = SET_ERROR(ENXIO); 2595 zio_interrupt(zio); 2596 return (ZIO_PIPELINE_STOP); 2597 } 2598 } 2599 2600 /* 2601 * Note that we ignore repair writes for TRIM because they can conflict 2602 * with normal writes. This isn't an issue because, by definition, we 2603 * only repair blocks that aren't freed. 2604 */ 2605 if (vd->vdev_ops->vdev_op_leaf && zio->io_type == ZIO_TYPE_WRITE && 2606 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) { 2607 if (!trim_map_write_start(zio)) 2608 return (ZIO_PIPELINE_STOP); 2609 } 2610 2611 return (vd->vdev_ops->vdev_op_io_start(zio)); 2612} 2613 2614static int 2615zio_vdev_io_done(zio_t *zio) 2616{ 2617 vdev_t *vd = zio->io_vd; 2618 vdev_ops_t *ops = vd ? vd->vdev_ops : &vdev_mirror_ops; 2619 boolean_t unexpected_error = B_FALSE; 2620 2621 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE)) 2622 return (ZIO_PIPELINE_STOP); 2623 2624 ASSERT(zio->io_type == ZIO_TYPE_READ || 2625 zio->io_type == ZIO_TYPE_WRITE || zio->io_type == ZIO_TYPE_FREE); 2626 2627 if (vd != NULL && vd->vdev_ops->vdev_op_leaf && 2628 (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE)) { 2629 2630 if (zio->io_type == ZIO_TYPE_WRITE && 2631 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) 2632 trim_map_write_done(zio); 2633 2634 vdev_queue_io_done(zio); 2635 2636 if (zio->io_type == ZIO_TYPE_WRITE) 2637 vdev_cache_write(zio); 2638 2639 if (zio_injection_enabled && zio->io_error == 0) 2640 zio->io_error = zio_handle_device_injection(vd, 2641 zio, EIO); 2642 2643 if (zio_injection_enabled && zio->io_error == 0) 2644 zio->io_error = zio_handle_label_injection(zio, EIO); 2645 2646 if (zio->io_error) { 2647 if (!vdev_accessible(vd, zio)) { 2648 zio->io_error = SET_ERROR(ENXIO); 2649 } else { 2650 unexpected_error = B_TRUE; 2651 } 2652 } 2653 } 2654 2655 ops->vdev_op_io_done(zio); 2656 2657 if (unexpected_error) 2658 VERIFY(vdev_probe(vd, zio) == NULL); 2659 2660 return (ZIO_PIPELINE_CONTINUE); 2661} 2662 2663/* 2664 * For non-raidz ZIOs, we can just copy aside the bad data read from the 2665 * disk, and use that to finish the checksum ereport later. 2666 */ 2667static void 2668zio_vsd_default_cksum_finish(zio_cksum_report_t *zcr, 2669 const void *good_buf) 2670{ 2671 /* no processing needed */ 2672 zfs_ereport_finish_checksum(zcr, good_buf, zcr->zcr_cbdata, B_FALSE); 2673} 2674 2675/*ARGSUSED*/ 2676void 2677zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored) 2678{ 2679 void *buf = zio_buf_alloc(zio->io_size); 2680 2681 bcopy(zio->io_data, buf, zio->io_size); 2682 2683 zcr->zcr_cbinfo = zio->io_size; 2684 zcr->zcr_cbdata = buf; 2685 zcr->zcr_finish = zio_vsd_default_cksum_finish; 2686 zcr->zcr_free = zio_buf_free; 2687} 2688 2689static int 2690zio_vdev_io_assess(zio_t *zio) 2691{ 2692 vdev_t *vd = zio->io_vd; 2693 2694 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE)) 2695 return (ZIO_PIPELINE_STOP); 2696 2697 if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER)) 2698 spa_config_exit(zio->io_spa, SCL_ZIO, zio); 2699 2700 if (zio->io_vsd != NULL) { 2701 zio->io_vsd_ops->vsd_free(zio); 2702 zio->io_vsd = NULL; 2703 } 2704 2705 if (zio_injection_enabled && zio->io_error == 0) 2706 zio->io_error = zio_handle_fault_injection(zio, EIO); 2707 2708 if (zio->io_type == ZIO_TYPE_IOCTL && zio->io_cmd == DKIOCTRIM) 2709 switch (zio->io_error) { 2710 case 0: 2711 ZIO_TRIM_STAT_INCR(bytes, zio->io_size); 2712 ZIO_TRIM_STAT_BUMP(success); 2713 break; 2714 case EOPNOTSUPP: 2715 ZIO_TRIM_STAT_BUMP(unsupported); 2716 break; 2717 default: 2718 ZIO_TRIM_STAT_BUMP(failed); 2719 break; 2720 } 2721 2722 /* 2723 * If the I/O failed, determine whether we should attempt to retry it. 2724 * 2725 * On retry, we cut in line in the issue queue, since we don't want 2726 * compression/checksumming/etc. work to prevent our (cheap) IO reissue. 2727 */ 2728 if (zio->io_error && vd == NULL && 2729 !(zio->io_flags & (ZIO_FLAG_DONT_RETRY | ZIO_FLAG_IO_RETRY))) { 2730 ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE)); /* not a leaf */ 2731 ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS)); /* not a leaf */ 2732 zio->io_error = 0; 2733 zio->io_flags |= ZIO_FLAG_IO_RETRY | 2734 ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_AGGREGATE; 2735 zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1; 2736 zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, 2737 zio_requeue_io_start_cut_in_line); 2738 return (ZIO_PIPELINE_STOP); 2739 } 2740 2741 /* 2742 * If we got an error on a leaf device, convert it to ENXIO 2743 * if the device is not accessible at all. 2744 */ 2745 if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf && 2746 !vdev_accessible(vd, zio)) 2747 zio->io_error = SET_ERROR(ENXIO); 2748 2749 /* 2750 * If we can't write to an interior vdev (mirror or RAID-Z), 2751 * set vdev_cant_write so that we stop trying to allocate from it. 2752 */ 2753 if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE && 2754 vd != NULL && !vd->vdev_ops->vdev_op_leaf) { 2755 vd->vdev_cant_write = B_TRUE; 2756 } 2757 2758 if (zio->io_error) 2759 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 2760 2761 return (ZIO_PIPELINE_CONTINUE); 2762} 2763 2764void 2765zio_vdev_io_reissue(zio_t *zio) 2766{ 2767 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START); 2768 ASSERT(zio->io_error == 0); 2769 2770 zio->io_stage >>= 1; 2771} 2772 2773void 2774zio_vdev_io_redone(zio_t *zio) 2775{ 2776 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE); 2777 2778 zio->io_stage >>= 1; 2779} 2780 2781void 2782zio_vdev_io_bypass(zio_t *zio) 2783{ 2784 ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START); 2785 ASSERT(zio->io_error == 0); 2786 2787 zio->io_flags |= ZIO_FLAG_IO_BYPASS; 2788 zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1; 2789} 2790 2791/* 2792 * ========================================================================== 2793 * Generate and verify checksums 2794 * ========================================================================== 2795 */ 2796static int 2797zio_checksum_generate(zio_t *zio) 2798{ 2799 blkptr_t *bp = zio->io_bp; 2800 enum zio_checksum checksum; 2801 2802 if (bp == NULL) { 2803 /* 2804 * This is zio_write_phys(). 2805 * We're either generating a label checksum, or none at all. 2806 */ 2807 checksum = zio->io_prop.zp_checksum; 2808 2809 if (checksum == ZIO_CHECKSUM_OFF) 2810 return (ZIO_PIPELINE_CONTINUE); 2811 2812 ASSERT(checksum == ZIO_CHECKSUM_LABEL); 2813 } else { 2814 if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) { 2815 ASSERT(!IO_IS_ALLOCATING(zio)); 2816 checksum = ZIO_CHECKSUM_GANG_HEADER; 2817 } else { 2818 checksum = BP_GET_CHECKSUM(bp); 2819 } 2820 } 2821 2822 zio_checksum_compute(zio, checksum, zio->io_data, zio->io_size); 2823 2824 return (ZIO_PIPELINE_CONTINUE); 2825} 2826 2827static int 2828zio_checksum_verify(zio_t *zio) 2829{ 2830 zio_bad_cksum_t info; 2831 blkptr_t *bp = zio->io_bp; 2832 int error; 2833 2834 ASSERT(zio->io_vd != NULL); 2835 2836 if (bp == NULL) { 2837 /* 2838 * This is zio_read_phys(). 2839 * We're either verifying a label checksum, or nothing at all. 2840 */ 2841 if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF) 2842 return (ZIO_PIPELINE_CONTINUE); 2843 2844 ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL); 2845 } 2846 2847 if ((error = zio_checksum_error(zio, &info)) != 0) { 2848 zio->io_error = error; 2849 if (!(zio->io_flags & ZIO_FLAG_SPECULATIVE)) { 2850 zfs_ereport_start_checksum(zio->io_spa, 2851 zio->io_vd, zio, zio->io_offset, 2852 zio->io_size, NULL, &info); 2853 } 2854 } 2855 2856 return (ZIO_PIPELINE_CONTINUE); 2857} 2858 2859/* 2860 * Called by RAID-Z to ensure we don't compute the checksum twice. 2861 */ 2862void 2863zio_checksum_verified(zio_t *zio) 2864{ 2865 zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY; 2866} 2867 2868/* 2869 * ========================================================================== 2870 * Error rank. Error are ranked in the order 0, ENXIO, ECKSUM, EIO, other. 2871 * An error of 0 indictes success. ENXIO indicates whole-device failure, 2872 * which may be transient (e.g. unplugged) or permament. ECKSUM and EIO 2873 * indicate errors that are specific to one I/O, and most likely permanent. 2874 * Any other error is presumed to be worse because we weren't expecting it. 2875 * ========================================================================== 2876 */ 2877int 2878zio_worst_error(int e1, int e2) 2879{ 2880 static int zio_error_rank[] = { 0, ENXIO, ECKSUM, EIO }; 2881 int r1, r2; 2882 2883 for (r1 = 0; r1 < sizeof (zio_error_rank) / sizeof (int); r1++) 2884 if (e1 == zio_error_rank[r1]) 2885 break; 2886 2887 for (r2 = 0; r2 < sizeof (zio_error_rank) / sizeof (int); r2++) 2888 if (e2 == zio_error_rank[r2]) 2889 break; 2890 2891 return (r1 > r2 ? e1 : e2); 2892} 2893 2894/* 2895 * ========================================================================== 2896 * I/O completion 2897 * ========================================================================== 2898 */ 2899static int 2900zio_ready(zio_t *zio) 2901{ 2902 blkptr_t *bp = zio->io_bp; 2903 zio_t *pio, *pio_next; 2904 2905 if (zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_READY) || 2906 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_READY)) 2907 return (ZIO_PIPELINE_STOP); 2908 2909 if (zio->io_ready) { 2910 ASSERT(IO_IS_ALLOCATING(zio)); 2911 ASSERT(bp->blk_birth == zio->io_txg || BP_IS_HOLE(bp) || 2912 (zio->io_flags & ZIO_FLAG_NOPWRITE)); 2913 ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0); 2914 2915 zio->io_ready(zio); 2916 } 2917 2918 if (bp != NULL && bp != &zio->io_bp_copy) 2919 zio->io_bp_copy = *bp; 2920 2921 if (zio->io_error) 2922 zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; 2923 2924 mutex_enter(&zio->io_lock); 2925 zio->io_state[ZIO_WAIT_READY] = 1; 2926 pio = zio_walk_parents(zio); 2927 mutex_exit(&zio->io_lock); 2928 2929 /* 2930 * As we notify zio's parents, new parents could be added. 2931 * New parents go to the head of zio's io_parent_list, however, 2932 * so we will (correctly) not notify them. The remainder of zio's 2933 * io_parent_list, from 'pio_next' onward, cannot change because 2934 * all parents must wait for us to be done before they can be done. 2935 */ 2936 for (; pio != NULL; pio = pio_next) { 2937 pio_next = zio_walk_parents(zio); 2938 zio_notify_parent(pio, zio, ZIO_WAIT_READY); 2939 } 2940 2941 if (zio->io_flags & ZIO_FLAG_NODATA) { 2942 if (BP_IS_GANG(bp)) { 2943 zio->io_flags &= ~ZIO_FLAG_NODATA; 2944 } else { 2945 ASSERT((uintptr_t)zio->io_data < SPA_MAXBLOCKSIZE); 2946 zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES; 2947 } 2948 } 2949 2950 if (zio_injection_enabled && 2951 zio->io_spa->spa_syncing_txg == zio->io_txg) 2952 zio_handle_ignored_writes(zio); 2953 2954 return (ZIO_PIPELINE_CONTINUE); 2955} 2956 2957static int 2958zio_done(zio_t *zio) 2959{ 2960 spa_t *spa = zio->io_spa; 2961 zio_t *lio = zio->io_logical; 2962 blkptr_t *bp = zio->io_bp; 2963 vdev_t *vd = zio->io_vd; 2964 uint64_t psize = zio->io_size; 2965 zio_t *pio, *pio_next; 2966 2967 /* 2968 * If our children haven't all completed, 2969 * wait for them and then repeat this pipeline stage. 2970 */ 2971 if (zio_wait_for_children(zio, ZIO_CHILD_VDEV, ZIO_WAIT_DONE) || 2972 zio_wait_for_children(zio, ZIO_CHILD_GANG, ZIO_WAIT_DONE) || 2973 zio_wait_for_children(zio, ZIO_CHILD_DDT, ZIO_WAIT_DONE) || 2974 zio_wait_for_children(zio, ZIO_CHILD_LOGICAL, ZIO_WAIT_DONE)) 2975 return (ZIO_PIPELINE_STOP); 2976 2977 for (int c = 0; c < ZIO_CHILD_TYPES; c++) 2978 for (int w = 0; w < ZIO_WAIT_TYPES; w++) 2979 ASSERT(zio->io_children[c][w] == 0); 2980 2981 if (bp != NULL) { 2982 ASSERT(bp->blk_pad[0] == 0); 2983 ASSERT(bp->blk_pad[1] == 0); 2984 ASSERT(bcmp(bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 || 2985 (bp == zio_unique_parent(zio)->io_bp)); 2986 if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(bp) && 2987 zio->io_bp_override == NULL && 2988 !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) { 2989 ASSERT(!BP_SHOULD_BYTESWAP(bp)); 2990 ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(bp)); 2991 ASSERT(BP_COUNT_GANG(bp) == 0 || 2992 (BP_COUNT_GANG(bp) == BP_GET_NDVAS(bp))); 2993 } 2994 if (zio->io_flags & ZIO_FLAG_NOPWRITE) 2995 VERIFY(BP_EQUAL(bp, &zio->io_bp_orig)); 2996 } 2997 2998 /* 2999 * If there were child vdev/gang/ddt errors, they apply to us now. 3000 */ 3001 zio_inherit_child_errors(zio, ZIO_CHILD_VDEV); 3002 zio_inherit_child_errors(zio, ZIO_CHILD_GANG); 3003 zio_inherit_child_errors(zio, ZIO_CHILD_DDT); 3004 3005 /* 3006 * If the I/O on the transformed data was successful, generate any 3007 * checksum reports now while we still have the transformed data. 3008 */ 3009 if (zio->io_error == 0) { 3010 while (zio->io_cksum_report != NULL) { 3011 zio_cksum_report_t *zcr = zio->io_cksum_report; 3012 uint64_t align = zcr->zcr_align; 3013 uint64_t asize = P2ROUNDUP(psize, align); 3014 char *abuf = zio->io_data; 3015 3016 if (asize != psize) { 3017 abuf = zio_buf_alloc(asize); 3018 bcopy(zio->io_data, abuf, psize); 3019 bzero(abuf + psize, asize - psize); 3020 } 3021 3022 zio->io_cksum_report = zcr->zcr_next; 3023 zcr->zcr_next = NULL; 3024 zcr->zcr_finish(zcr, abuf); 3025 zfs_ereport_free_checksum(zcr); 3026 3027 if (asize != psize) 3028 zio_buf_free(abuf, asize); 3029 } 3030 } 3031 3032 zio_pop_transforms(zio); /* note: may set zio->io_error */ 3033 3034 vdev_stat_update(zio, psize); 3035 3036 if (zio->io_error) { 3037 /* 3038 * If this I/O is attached to a particular vdev, 3039 * generate an error message describing the I/O failure 3040 * at the block level. We ignore these errors if the 3041 * device is currently unavailable. 3042 */ 3043 if (zio->io_error != ECKSUM && vd != NULL && !vdev_is_dead(vd)) 3044 zfs_ereport_post(FM_EREPORT_ZFS_IO, spa, vd, zio, 0, 0); 3045 3046 if ((zio->io_error == EIO || !(zio->io_flags & 3047 (ZIO_FLAG_SPECULATIVE | ZIO_FLAG_DONT_PROPAGATE))) && 3048 zio == lio) { 3049 /* 3050 * For logical I/O requests, tell the SPA to log the 3051 * error and generate a logical data ereport. 3052 */ 3053 spa_log_error(spa, zio); 3054 zfs_ereport_post(FM_EREPORT_ZFS_DATA, spa, NULL, zio, 3055 0, 0); 3056 } 3057 } 3058 3059 if (zio->io_error && zio == lio) { 3060 /* 3061 * Determine whether zio should be reexecuted. This will 3062 * propagate all the way to the root via zio_notify_parent(). 3063 */ 3064 ASSERT(vd == NULL && bp != NULL); 3065 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 3066 3067 if (IO_IS_ALLOCATING(zio) && 3068 !(zio->io_flags & ZIO_FLAG_CANFAIL)) { 3069 if (zio->io_error != ENOSPC) 3070 zio->io_reexecute |= ZIO_REEXECUTE_NOW; 3071 else 3072 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND; 3073 } 3074 3075 if ((zio->io_type == ZIO_TYPE_READ || 3076 zio->io_type == ZIO_TYPE_FREE) && 3077 !(zio->io_flags & ZIO_FLAG_SCAN_THREAD) && 3078 zio->io_error == ENXIO && 3079 spa_load_state(spa) == SPA_LOAD_NONE && 3080 spa_get_failmode(spa) != ZIO_FAILURE_MODE_CONTINUE) 3081 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND; 3082 3083 if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute) 3084 zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND; 3085 3086 /* 3087 * Here is a possibly good place to attempt to do 3088 * either combinatorial reconstruction or error correction 3089 * based on checksums. It also might be a good place 3090 * to send out preliminary ereports before we suspend 3091 * processing. 3092 */ 3093 } 3094 3095 /* 3096 * If there were logical child errors, they apply to us now. 3097 * We defer this until now to avoid conflating logical child 3098 * errors with errors that happened to the zio itself when 3099 * updating vdev stats and reporting FMA events above. 3100 */ 3101 zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL); 3102 3103 if ((zio->io_error || zio->io_reexecute) && 3104 IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio && 3105 !(zio->io_flags & (ZIO_FLAG_IO_REWRITE | ZIO_FLAG_NOPWRITE))) 3106 zio_dva_unallocate(zio, zio->io_gang_tree, bp); 3107 3108 zio_gang_tree_free(&zio->io_gang_tree); 3109 3110 /* 3111 * Godfather I/Os should never suspend. 3112 */ 3113 if ((zio->io_flags & ZIO_FLAG_GODFATHER) && 3114 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) 3115 zio->io_reexecute = 0; 3116 3117 if (zio->io_reexecute) { 3118 /* 3119 * This is a logical I/O that wants to reexecute. 3120 * 3121 * Reexecute is top-down. When an i/o fails, if it's not 3122 * the root, it simply notifies its parent and sticks around. 3123 * The parent, seeing that it still has children in zio_done(), 3124 * does the same. This percolates all the way up to the root. 3125 * The root i/o will reexecute or suspend the entire tree. 3126 * 3127 * This approach ensures that zio_reexecute() honors 3128 * all the original i/o dependency relationships, e.g. 3129 * parents not executing until children are ready. 3130 */ 3131 ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL); 3132 3133 zio->io_gang_leader = NULL; 3134 3135 mutex_enter(&zio->io_lock); 3136 zio->io_state[ZIO_WAIT_DONE] = 1; 3137 mutex_exit(&zio->io_lock); 3138 3139 /* 3140 * "The Godfather" I/O monitors its children but is 3141 * not a true parent to them. It will track them through 3142 * the pipeline but severs its ties whenever they get into 3143 * trouble (e.g. suspended). This allows "The Godfather" 3144 * I/O to return status without blocking. 3145 */ 3146 for (pio = zio_walk_parents(zio); pio != NULL; pio = pio_next) { 3147 zio_link_t *zl = zio->io_walk_link; 3148 pio_next = zio_walk_parents(zio); 3149 3150 if ((pio->io_flags & ZIO_FLAG_GODFATHER) && 3151 (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) { 3152 zio_remove_child(pio, zio, zl); 3153 zio_notify_parent(pio, zio, ZIO_WAIT_DONE); 3154 } 3155 } 3156 3157 if ((pio = zio_unique_parent(zio)) != NULL) { 3158 /* 3159 * We're not a root i/o, so there's nothing to do 3160 * but notify our parent. Don't propagate errors 3161 * upward since we haven't permanently failed yet. 3162 */ 3163 ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER)); 3164 zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE; 3165 zio_notify_parent(pio, zio, ZIO_WAIT_DONE); 3166 } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) { 3167 /* 3168 * We'd fail again if we reexecuted now, so suspend 3169 * until conditions improve (e.g. device comes online). 3170 */ 3171 zio_suspend(spa, zio); 3172 } else { 3173 /* 3174 * Reexecution is potentially a huge amount of work. 3175 * Hand it off to the otherwise-unused claim taskq. 3176 */ 3177#ifdef _KERNEL 3178 (void) taskq_dispatch_safe( 3179 spa->spa_zio_taskq[ZIO_TYPE_CLAIM][ZIO_TASKQ_ISSUE], 3180 (task_func_t *)zio_reexecute, zio, TQ_SLEEP, 3181 &zio->io_task); 3182#else 3183 (void) taskq_dispatch( 3184 spa->spa_zio_taskq[ZIO_TYPE_CLAIM][ZIO_TASKQ_ISSUE], 3185 (task_func_t *)zio_reexecute, zio, TQ_SLEEP); 3186#endif 3187 } 3188 return (ZIO_PIPELINE_STOP); 3189 } 3190 3191 ASSERT(zio->io_child_count == 0); 3192 ASSERT(zio->io_reexecute == 0); 3193 ASSERT(zio->io_error == 0 || (zio->io_flags & ZIO_FLAG_CANFAIL)); 3194 3195 /* 3196 * Report any checksum errors, since the I/O is complete. 3197 */ 3198 while (zio->io_cksum_report != NULL) { 3199 zio_cksum_report_t *zcr = zio->io_cksum_report; 3200 zio->io_cksum_report = zcr->zcr_next; 3201 zcr->zcr_next = NULL; 3202 zcr->zcr_finish(zcr, NULL); 3203 zfs_ereport_free_checksum(zcr); 3204 } 3205 3206 /* 3207 * It is the responsibility of the done callback to ensure that this 3208 * particular zio is no longer discoverable for adoption, and as 3209 * such, cannot acquire any new parents. 3210 */ 3211 if (zio->io_done) 3212 zio->io_done(zio); 3213 3214 mutex_enter(&zio->io_lock); 3215 zio->io_state[ZIO_WAIT_DONE] = 1; 3216 mutex_exit(&zio->io_lock); 3217 3218 for (pio = zio_walk_parents(zio); pio != NULL; pio = pio_next) { 3219 zio_link_t *zl = zio->io_walk_link; 3220 pio_next = zio_walk_parents(zio); 3221 zio_remove_child(pio, zio, zl); 3222 zio_notify_parent(pio, zio, ZIO_WAIT_DONE); 3223 } 3224 3225 if (zio->io_waiter != NULL) { 3226 mutex_enter(&zio->io_lock); 3227 zio->io_executor = NULL; 3228 cv_broadcast(&zio->io_cv); 3229 mutex_exit(&zio->io_lock); 3230 } else { 3231 zio_destroy(zio); 3232 } 3233 3234 return (ZIO_PIPELINE_STOP); 3235} 3236 3237/* 3238 * ========================================================================== 3239 * I/O pipeline definition 3240 * ========================================================================== 3241 */ 3242static zio_pipe_stage_t *zio_pipeline[] = { 3243 NULL, 3244 zio_read_bp_init, 3245 zio_free_bp_init, 3246 zio_issue_async, 3247 zio_write_bp_init, 3248 zio_checksum_generate, 3249 zio_nop_write, 3250 zio_ddt_read_start, 3251 zio_ddt_read_done, 3252 zio_ddt_write, 3253 zio_ddt_free, 3254 zio_gang_assemble, 3255 zio_gang_issue, 3256 zio_dva_allocate, 3257 zio_dva_free, 3258 zio_dva_claim, 3259 zio_ready, 3260 zio_vdev_io_start, 3261 zio_vdev_io_done, 3262 zio_vdev_io_assess, 3263 zio_checksum_verify, 3264 zio_done 3265}; 3266 3267/* dnp is the dnode for zb1->zb_object */ 3268boolean_t 3269zbookmark_is_before(const dnode_phys_t *dnp, const zbookmark_t *zb1, 3270 const zbookmark_t *zb2) 3271{ 3272 uint64_t zb1nextL0, zb2thisobj; 3273 3274 ASSERT(zb1->zb_objset == zb2->zb_objset); 3275 ASSERT(zb2->zb_level == 0); 3276 3277 /* 3278 * A bookmark in the deadlist is considered to be after 3279 * everything else. 3280 */ 3281 if (zb2->zb_object == DMU_DEADLIST_OBJECT) 3282 return (B_TRUE); 3283 3284 /* The objset_phys_t isn't before anything. */ 3285 if (dnp == NULL) 3286 return (B_FALSE); 3287 3288 zb1nextL0 = (zb1->zb_blkid + 1) << 3289 ((zb1->zb_level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT)); 3290 3291 zb2thisobj = zb2->zb_object ? zb2->zb_object : 3292 zb2->zb_blkid << (DNODE_BLOCK_SHIFT - DNODE_SHIFT); 3293 3294 if (zb1->zb_object == DMU_META_DNODE_OBJECT) { 3295 uint64_t nextobj = zb1nextL0 * 3296 (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT) >> DNODE_SHIFT; 3297 return (nextobj <= zb2thisobj); 3298 } 3299 3300 if (zb1->zb_object < zb2thisobj) 3301 return (B_TRUE); 3302 if (zb1->zb_object > zb2thisobj) 3303 return (B_FALSE); 3304 if (zb2->zb_object == DMU_META_DNODE_OBJECT) 3305 return (B_FALSE); 3306 return (zb1nextL0 <= zb2->zb_blkid); 3307} 3308