1 /* 2 * CDDL HEADER START 3 * 4 * This file and its contents are supplied under the terms of the 5 * Common Development and Distribution License ("CDDL"), version 1.0. 6 * You may only use this file in accordance with the terms of version 7 * 1.0 of the CDDL. 8 * 9 * A full copy of the text of the CDDL should have accompanied this 10 * source. A copy of the CDDL is also available via the Internet at 11 * http://www.illumos.org/license/CDDL. 12 * 13 * CDDL HEADER END 14 */ 15 16 /* 17 * Copyright (c) 2013, 2016 by Delphix. All rights reserved. 18 */ 19 20 #include <sys/blkptr.h> 21 #include <sys/zfs_context.h> 22 #include <sys/zio.h> 23 #include <sys/zio_compress.h> 24 25 /* 26 * Embedded-data Block Pointers 27 * 28 * Normally, block pointers point (via their DVAs) to a block which holds data. 29 * If the data that we need to store is very small, this is an inefficient 30 * use of space, because a block must be at minimum 1 sector (typically 512 31 * bytes or 4KB). Additionally, reading these small blocks tends to generate 32 * more random reads. 33 * 34 * Embedded-data Block Pointers allow small pieces of data (the "payload", 35 * up to 112 bytes) to be stored in the block pointer itself, instead of 36 * being pointed to. The "Pointer" part of this name is a bit of a 37 * misnomer, as nothing is pointed to. 38 * 39 * BP_EMBEDDED_TYPE_DATA block pointers allow highly-compressible data to 40 * be embedded in the block pointer. The logic for this is handled in 41 * the SPA, by the zio pipeline. Therefore most code outside the zio 42 * pipeline doesn't need special-cases to handle these block pointers. 43 * 44 * See spa.h for details on the exact layout of embedded block pointers. 45 */ 46 47 void 48 encode_embedded_bp_compressed(blkptr_t *bp, void *data, 49 enum zio_compress comp, int uncompressed_size, int compressed_size) 50 { 51 uint64_t *bp64 = (uint64_t *)bp; 52 uint64_t w = 0; 53 uint8_t *data8 = data; 54 55 ASSERT3U(compressed_size, <=, BPE_PAYLOAD_SIZE); 56 ASSERT(uncompressed_size == compressed_size || 57 comp != ZIO_COMPRESS_OFF); 58 ASSERT3U(comp, >=, ZIO_COMPRESS_OFF); 59 ASSERT3U(comp, <, ZIO_COMPRESS_FUNCTIONS); 60 61 memset(bp, 0, sizeof (*bp)); 62 BP_SET_EMBEDDED(bp, B_TRUE); 63 BP_SET_COMPRESS(bp, comp); 64 BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER); 65 BPE_SET_LSIZE(bp, uncompressed_size); 66 BPE_SET_PSIZE(bp, compressed_size); 67 68 /* 69 * Encode the byte array into the words of the block pointer. 70 * First byte goes into low bits of first word (little endian). 71 */ 72 for (int i = 0; i < compressed_size; i++) { 73 BF64_SET(w, (i % sizeof (w)) * NBBY, NBBY, data8[i]); 74 if (i % sizeof (w) == sizeof (w) - 1) { 75 /* we've reached the end of a word */ 76 ASSERT3P(bp64, <, bp + 1); 77 *bp64 = w; 78 bp64++; 79 if (!BPE_IS_PAYLOADWORD(bp, bp64)) 80 bp64++; 81 w = 0; 82 } 83 } 84 /* write last partial word */ 85 if (bp64 < (uint64_t *)(bp + 1)) 86 *bp64 = w; 87 } 88 89 /* 90 * buf must be at least BPE_GET_PSIZE(bp) bytes long (which will never be 91 * more than BPE_PAYLOAD_SIZE bytes). 92 */ 93 void 94 decode_embedded_bp_compressed(const blkptr_t *bp, void *buf) 95 { 96 int psize; 97 uint8_t *buf8 = buf; 98 uint64_t w = 0; 99 const uint64_t *bp64 = (const uint64_t *)bp; 100 101 ASSERT(BP_IS_EMBEDDED(bp)); 102 103 psize = BPE_GET_PSIZE(bp); 104 105 /* 106 * Decode the words of the block pointer into the byte array. 107 * Low bits of first word are the first byte (little endian). 108 */ 109 for (int i = 0; i < psize; i++) { 110 if (i % sizeof (w) == 0) { 111 /* beginning of a word */ 112 ASSERT3P(bp64, <, bp + 1); 113 w = *bp64; 114 bp64++; 115 if (!BPE_IS_PAYLOADWORD(bp, bp64)) 116 bp64++; 117 } 118 buf8[i] = BF64_GET(w, (i % sizeof (w)) * NBBY, NBBY); 119 } 120 } 121 122 /* 123 * Fill in the buffer with the (decompressed) payload of the embedded 124 * blkptr_t. Takes into account compression and byteorder (the payload is 125 * treated as a stream of bytes). 126 * Return 0 on success, or ENOSPC if it won't fit in the buffer. 127 */ 128 int 129 decode_embedded_bp(const blkptr_t *bp, void *buf, int buflen) 130 { 131 int lsize, psize; 132 133 ASSERT(BP_IS_EMBEDDED(bp)); 134 135 lsize = BPE_GET_LSIZE(bp); 136 psize = BPE_GET_PSIZE(bp); 137 138 if (lsize > buflen) 139 return (SET_ERROR(ENOSPC)); 140 ASSERT3U(lsize, ==, buflen); 141 142 if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF) { 143 uint8_t dstbuf[BPE_PAYLOAD_SIZE]; 144 decode_embedded_bp_compressed(bp, dstbuf); 145 abd_t cabd, dabd; 146 abd_get_from_buf_struct(&cabd, dstbuf, psize); 147 abd_get_from_buf_struct(&dabd, buf, buflen); 148 VERIFY0(zio_decompress_data(BP_GET_COMPRESS(bp), &cabd, 149 &dabd, psize, buflen, NULL)); 150 abd_free(&dabd); 151 abd_free(&cabd); 152 } else { 153 ASSERT3U(lsize, ==, psize); 154 decode_embedded_bp_compressed(bp, buf); 155 } 156 157 return (0); 158 } 159