Lines Matching full:gang
684 * Logical I/Os can have logical, gang, or vdev children.
685 * Gang I/Os can have gang or vdev children.
720 * Logical I/Os can have logical, gang, or vdev children.
721 * Gang I/Os can have gang or vdev children.
1373 * deferred, and which will not need to do a read (i.e. not GANG or
1417 * GANG, DEDUP and BRT blocks can induce a read (for the gang
2654 * Gang blocks.
2656 * A gang block is a collection of small blocks that looks to the DMU
2662 * A gang block consists of a gang header (zio_gbh_phys_t) and up to
2663 * three (SPA_GBH_NBLKPTRS) gang members. The gang header is just like
2666 * The gang header's bps point to its gang members, which hold the data.
2668 * Gang blocks are self-checksumming, using the bp's <vdev, offset, txg>
2670 * Critically, the gang block bp's blk_cksum is the checksum of the data,
2671 * not the gang header. This ensures that data block signatures (needed for
2674 * Gang blocks can be nested: a gang member may itself be a gang block.
2675 * Thus every gang block is a tree in which root and all interior nodes are
2676 * gang headers, and the leaves are normal blocks that contain user data.
2677 * The root of the gang tree is called the gang leader.
2679 * To perform any operation (read, rewrite, free, claim) on a gang block,
2680 * zio_gang_assemble() first assembles the gang tree (minus data leaves)
2682 * reading the gang leader and all gang headers below it. This yields
2683 * an in-core tree containing the contents of every gang header and the
2684 * bps for every constituent of the gang block.
2686 * With the gang tree now assembled, zio_gang_issue() just walks the gang tree
2687 * and invokes a callback on each bp. To free a gang block, zio_gang_issue()
2690 * zio_read_gang() is a wrapper around zio_read() that omits reading gang
2692 * performs a zio_rewrite() of the data or, for gang headers, a zio_rewrite()
2693 * of the gang header plus zio_checksum_compute() of the data to update the
2694 * gang header's blk_cksum as described above.
2697 * what if you'd freed part of a gang block but then couldn't read the
2698 * gang header for another part? Assembling the entire gang tree first
2699 * ensures that all the necessary gang header I/O has succeeded before
2700 * starting the actual work of free, claim, or write. Once the gang tree
2703 * In the event that a gang write fails, zio_dva_unallocate() walks the
2704 * gang tree to immediately free (i.e. insert back into the space map)
2708 * Gang rewrites only happen during sync-to-convergence. If we can't assemble
2709 * the gang tree, we won't modify the block, so we can safely defer the free
2710 * (knowing that the block is still intact). If we *can* assemble the gang
2714 * In all cases, the gang tree allows complete recovery from partial failure.
2751 * As we rewrite each gang header, the pipeline will compute
2752 * a new gang block header checksum for it; but no one will
2754 * exception is the gang leader: the pipeline already computed
2755 * its data checksum because that stage precedes gang assembly.
2916 * If you're a gang header, your data is in gn->gn_gbh.
2917 * If you're a gang member, your data is in 'data' and gn == NULL.
3068 * 'copies' allocation slots but gang blocks may require
3072 * additional reservations for gang blocks.
3087 * If we failed to allocate the gang block header then
3114 * Create the gang header.
3123 * Create and nowait the gang children.
3160 * Gang children won't throttle but we should
4044 * If that's full, allocate as a gang block,
4156 * This handles both normal blocks and gang blocks.
5112 * Parents of gang children can have two flavors -- ones that
5113 * allocated the gang header (will have ZIO_FLAG_IO_REWRITE set)
5120 * If our parent is a rewrite gang child then our grandparent
5225 * If there were child vdev/gang/ddt errors, they apply to us now.