FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/module/zfs/blkptr.c

     /*
      * CDDL HEADER START
      *
      * This file and its contents are supplied under the terms of the
      * Common Development and Distribution License ("CDDL"), version 1.0.
      * You may only use this file in accordance with the terms of version
      * 1.0 of the CDDL.
      *
      * A full copy of the text of the CDDL should have accompanied this
     * source.  A copy of the CDDL is also available via the Internet at
     * http://www.illumos.org/license/CDDL.
     *
     * CDDL HEADER END
     */
    
    /*
     * Copyright (c) 2013, 2016 by Delphix. All rights reserved.
     */
    
    #include <sys/blkptr.h>
    #include <sys/zfs_context.h>
    #include <sys/zio.h>
    #include <sys/zio_compress.h>
    
    /*
     * Embedded-data Block Pointers
     *
     * Normally, block pointers point (via their DVAs) to a block which holds data.
     * If the data that we need to store is very small, this is an inefficient
     * use of space, because a block must be at minimum 1 sector (typically 512
     * bytes or 4KB).  Additionally, reading these small blocks tends to generate
     * more random reads.
     *
     * Embedded-data Block Pointers allow small pieces of data (the "payload",
     * up to 112 bytes) to be stored in the block pointer itself, instead of
     * being pointed to.  The "Pointer" part of this name is a bit of a
     * misnomer, as nothing is pointed to.
     *
     * BP_EMBEDDED_TYPE_DATA block pointers allow highly-compressible data to
     * be embedded in the block pointer.  The logic for this is handled in
     * the SPA, by the zio pipeline.  Therefore most code outside the zio
     * pipeline doesn't need special-cases to handle these block pointers.
     *
     * See spa.h for details on the exact layout of embedded block pointers.
     */
    
    void
    encode_embedded_bp_compressed(blkptr_t *bp, void *data,
        enum zio_compress comp, int uncompressed_size, int compressed_size)
    {
            uint64_t *bp64 = (uint64_t *)bp;
            uint64_t w = 0;
            uint8_t *data8 = data;
    
            ASSERT3U(compressed_size, <=, BPE_PAYLOAD_SIZE);
            ASSERT(uncompressed_size == compressed_size ||
                comp != ZIO_COMPRESS_OFF);
            ASSERT3U(comp, >=, ZIO_COMPRESS_OFF);
            ASSERT3U(comp, <, ZIO_COMPRESS_FUNCTIONS);
    
            memset(bp, 0, sizeof (*bp));
            BP_SET_EMBEDDED(bp, B_TRUE);
            BP_SET_COMPRESS(bp, comp);
            BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
            BPE_SET_LSIZE(bp, uncompressed_size);
            BPE_SET_PSIZE(bp, compressed_size);
    
            /*
             * Encode the byte array into the words of the block pointer.
             * First byte goes into low bits of first word (little endian).
             */
            for (int i = 0; i < compressed_size; i++) {
                    BF64_SET(w, (i % sizeof (w)) * NBBY, NBBY, data8[i]);
                    if (i % sizeof (w) == sizeof (w) - 1) {
                            /* we've reached the end of a word */
                            ASSERT3P(bp64, <, bp + 1);
                            *bp64 = w;
                            bp64++;
                            if (!BPE_IS_PAYLOADWORD(bp, bp64))
                                    bp64++;
                            w = 0;
                    }
            }
            /* write last partial word */
            if (bp64 < (uint64_t *)(bp + 1))
                    *bp64 = w;
    }
    
    /*
     * buf must be at least BPE_GET_PSIZE(bp) bytes long (which will never be
     * more than BPE_PAYLOAD_SIZE bytes).
     */
    void
    decode_embedded_bp_compressed(const blkptr_t *bp, void *buf)
    {
            int psize;
            uint8_t *buf8 = buf;
            uint64_t w = 0;
            const uint64_t *bp64 = (const uint64_t *)bp;
   
           ASSERT(BP_IS_EMBEDDED(bp));
   
           psize = BPE_GET_PSIZE(bp);
   
           /*
            * Decode the words of the block pointer into the byte array.
            * Low bits of first word are the first byte (little endian).
            */
           for (int i = 0; i < psize; i++) {
                   if (i % sizeof (w) == 0) {
                           /* beginning of a word */
                           ASSERT3P(bp64, <, bp + 1);
                           w = *bp64;
                           bp64++;
                           if (!BPE_IS_PAYLOADWORD(bp, bp64))
                                   bp64++;
                   }
                   buf8[i] = BF64_GET(w, (i % sizeof (w)) * NBBY, NBBY);
           }
   }
   
   /*
    * Fill in the buffer with the (decompressed) payload of the embedded
    * blkptr_t.  Takes into account compression and byteorder (the payload is
    * treated as a stream of bytes).
    * Return 0 on success, or ENOSPC if it won't fit in the buffer.
    */
   int
   decode_embedded_bp(const blkptr_t *bp, void *buf, int buflen)
   {
           int lsize, psize;
   
           ASSERT(BP_IS_EMBEDDED(bp));
   
           lsize = BPE_GET_LSIZE(bp);
           psize = BPE_GET_PSIZE(bp);
   
           if (lsize > buflen)
                   return (SET_ERROR(ENOSPC));
           ASSERT3U(lsize, ==, buflen);
   
           if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF) {
                   uint8_t dstbuf[BPE_PAYLOAD_SIZE];
                   decode_embedded_bp_compressed(bp, dstbuf);
                   VERIFY0(zio_decompress_data_buf(BP_GET_COMPRESS(bp),
                       dstbuf, buf, psize, buflen, NULL));
           } else {
                   ASSERT3U(lsize, ==, psize);
                   decode_embedded_bp_compressed(bp, buf);
           }
   
           return (0);
   }

Cache object: d94340d323e6d18a3f09b816f3ec8427