include/sys/abd.h

   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 https://opensource.org/licenses/CDDL-1.0.
  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) 2014 by Chunwei Chen. All rights reserved.
  23  * Copyright (c) 2016, 2019 by Delphix. All rights reserved.
  24  */
  25
  26 #ifndef _ABD_H
  27 #define _ABD_H
  28
  29 #include <sys/isa_defs.h>
  30 #include <sys/debug.h>
  31 #include <sys/zfs_refcount.h>
  32 #include <sys/uio.h>
  33 #include <sys/abd_os.h>
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 typedef enum abd_flags {
  40         ABD_FLAG_LINEAR         = 1 << 0, /* is buffer linear (or scattered)? */
  41         ABD_FLAG_OWNER          = 1 << 1, /* does it own its data buffers? */
  42         ABD_FLAG_META           = 1 << 2, /* does this represent FS metadata? */
  43         ABD_FLAG_MULTI_ZONE     = 1 << 3, /* pages split over memory zones */
  44         ABD_FLAG_MULTI_CHUNK    = 1 << 4, /* pages split over multiple chunks */
  45         ABD_FLAG_LINEAR_PAGE    = 1 << 5, /* linear but allocd from page */
  46         ABD_FLAG_GANG           = 1 << 6, /* mult ABDs chained together */
  47         ABD_FLAG_GANG_FREE      = 1 << 7, /* gang ABD is responsible for mem */
  48         ABD_FLAG_ALLOCD         = 1 << 8, /* we allocated the abd_t */
  49         ABD_FLAG_FROM_PAGES     = 1 << 9, /* does not own pages */
  50 } abd_flags_t;
  51
  52 typedef struct abd {
  53         abd_flags_t     abd_flags;
  54         uint_t          abd_size;       /* excludes scattered abd_offset */
  55         list_node_t     abd_gang_link;
  56 #ifdef ZFS_DEBUG
  57         struct abd      *abd_parent;
  58         zfs_refcount_t  abd_children;
  59 #endif
  60         kmutex_t        abd_mtx;
  61         union {
  62                 struct abd_scatter      abd_scatter;
  63                 struct abd_linear       abd_linear;
  64                 struct abd_gang {
  65                         list_t abd_gang_chain;
  66                 } abd_gang;
  67         } abd_u;
  68 } abd_t;
  69
  70 typedef int abd_iter_func_t(void *buf, size_t len, void *priv);
  71 typedef int abd_iter_func2_t(void *bufa, void *bufb, size_t len, void *priv);
  72
  73 extern int zfs_abd_scatter_enabled;
  74
  75 /*
  76  * Allocations and deallocations
  77  */
  78
  79 __attribute__((malloc))
  80 abd_t *abd_alloc(size_t, boolean_t);
  81 __attribute__((malloc))
  82 abd_t *abd_alloc_linear(size_t, boolean_t);
  83 __attribute__((malloc))
  84 abd_t *abd_alloc_gang(void);
  85 __attribute__((malloc))
  86 abd_t *abd_alloc_for_io(size_t, boolean_t);
  87 __attribute__((malloc))
  88 abd_t *abd_alloc_sametype(abd_t *, size_t);
  89 boolean_t abd_size_alloc_linear(size_t);
  90 void abd_gang_add(abd_t *, abd_t *, boolean_t);
  91 void abd_free(abd_t *);
  92 abd_t *abd_get_offset(abd_t *, size_t);
  93 abd_t *abd_get_offset_size(abd_t *, size_t, size_t);
  94 abd_t *abd_get_offset_struct(abd_t *, abd_t *, size_t, size_t);
  95 abd_t *abd_get_zeros(size_t);
  96 abd_t *abd_get_from_buf(void *, size_t);
  97 abd_t *abd_get_from_buf_struct(abd_t *, void *, size_t);
  98 void abd_cache_reap_now(void);
  99
 100 /*
 101  * Conversion to and from a normal buffer
 102  */
 103
 104 void *abd_to_buf(abd_t *);
 105 void *abd_borrow_buf(abd_t *, size_t);
 106 void *abd_borrow_buf_copy(abd_t *, size_t);
 107 void abd_return_buf(abd_t *, void *, size_t);
 108 void abd_return_buf_copy(abd_t *, void *, size_t);
 109 void abd_take_ownership_of_buf(abd_t *, boolean_t);
 110 void abd_release_ownership_of_buf(abd_t *);
 111
 112 /*
 113  * ABD operations
 114  */
 115
 116 int abd_iterate_func(abd_t *, size_t, size_t, abd_iter_func_t *, void *);
 117 int abd_iterate_func2(abd_t *, abd_t *, size_t, size_t, size_t,
 118     abd_iter_func2_t *, void *);
 119 void abd_copy_off(abd_t *, abd_t *, size_t, size_t, size_t);
 120 void abd_copy_from_buf_off(abd_t *, const void *, size_t, size_t);
 121 void abd_copy_to_buf_off(void *, abd_t *, size_t, size_t);
 122 int abd_cmp(abd_t *, abd_t *);
 123 int abd_cmp_buf_off(abd_t *, const void *, size_t, size_t);
 124 int abd_cmp_zero_off(abd_t *, size_t, size_t);
 125 void abd_zero_off(abd_t *, size_t, size_t);
 126 void abd_verify(abd_t *);
 127
 128 void abd_raidz_gen_iterate(abd_t **cabds, abd_t *dabd, size_t off,
 129         size_t csize, size_t dsize, const unsigned parity,
 130         void (*func_raidz_gen)(void **, const void *, size_t, size_t));
 131 void abd_raidz_rec_iterate(abd_t **cabds, abd_t **tabds,
 132         size_t tsize, const unsigned parity,
 133         void (*func_raidz_rec)(void **t, const size_t tsize, void **c,
 134         const unsigned *mul),
 135         const unsigned *mul);
 136
 137 /*
 138  * Wrappers for calls with offsets of 0
 139  */
 140
 141 static inline void
 142 abd_copy(abd_t *dabd, abd_t *sabd, size_t size)
 143 {
 144         abd_copy_off(dabd, sabd, 0, 0, size);
 145 }
 146
 147 static inline void
 148 abd_copy_from_buf(abd_t *abd, const void *buf, size_t size)
 149 {
 150         abd_copy_from_buf_off(abd, buf, 0, size);
 151 }
 152
 153 static inline void
 154 abd_copy_to_buf(void* buf, abd_t *abd, size_t size)
 155 {
 156         abd_copy_to_buf_off(buf, abd, 0, size);
 157 }
 158
 159 static inline int
 160 abd_cmp_buf(abd_t *abd, const void *buf, size_t size)
 161 {
 162         return (abd_cmp_buf_off(abd, buf, 0, size));
 163 }
 164
 165 static inline void
 166 abd_zero(abd_t *abd, size_t size)
 167 {
 168         abd_zero_off(abd, 0, size);
 169 }
 170
 171 static inline int
 172 abd_cmp_zero(abd_t *abd, size_t size)
 173 {
 174         return (abd_cmp_zero_off(abd, 0, size));
 175 }
 176
 177 /*
 178  * ABD type check functions
 179  */
 180 static inline boolean_t
 181 abd_is_linear(abd_t *abd)
 182 {
 183         return ((abd->abd_flags & ABD_FLAG_LINEAR) ? B_TRUE : B_FALSE);
 184 }
 185
 186 static inline boolean_t
 187 abd_is_linear_page(abd_t *abd)
 188 {
 189         return ((abd->abd_flags & ABD_FLAG_LINEAR_PAGE) ? B_TRUE : B_FALSE);
 190 }
 191
 192 static inline boolean_t
 193 abd_is_gang(abd_t *abd)
 194 {
 195         return ((abd->abd_flags & ABD_FLAG_GANG) ? B_TRUE : B_FALSE);
 196 }
 197
 198 static inline uint_t
 199 abd_get_size(abd_t *abd)
 200 {
 201         return (abd->abd_size);
 202 }
 203
 204 static inline boolean_t
 205 abd_is_from_pages(abd_t *abd)
 206 {
 207         return ((abd->abd_flags & ABD_FLAG_FROM_PAGES) ? B_TRUE : B_FALSE);
 208 }
 209
 210 /*
 211  * Module lifecycle
 212  * Defined in each specific OS's abd_os.c
 213  */
 214
 215 void abd_init(void);
 216 void abd_fini(void);
 217
 218 #ifdef __cplusplus
 219 }
 220 #endif
 221
 222 #endif  /* _ABD_H */