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