xref: /illumos-gate/usr/src/uts/common/fs/zfs/sys/dmu.h (revision f17457368189aa911f774c38c1f21875a568bdca)
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 http://www.opensolaris.org/os/licensing.
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 /*
23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2012 by Delphix. All rights reserved.
25  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
26  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
27  */
28 
29 /* Portions Copyright 2010 Robert Milkowski */
30 
31 #ifndef	_SYS_DMU_H
32 #define	_SYS_DMU_H
33 
34 /*
35  * This file describes the interface that the DMU provides for its
36  * consumers.
37  *
38  * The DMU also interacts with the SPA.  That interface is described in
39  * dmu_spa.h.
40  */
41 
42 #include <sys/inttypes.h>
43 #include <sys/types.h>
44 #include <sys/param.h>
45 #include <sys/cred.h>
46 #include <sys/time.h>
47 #include <sys/fs/zfs.h>
48 
49 #ifdef	__cplusplus
50 extern "C" {
51 #endif
52 
53 struct uio;
54 struct xuio;
55 struct page;
56 struct vnode;
57 struct spa;
58 struct zilog;
59 struct zio;
60 struct blkptr;
61 struct zap_cursor;
62 struct dsl_dataset;
63 struct dsl_pool;
64 struct dnode;
65 struct drr_begin;
66 struct drr_end;
67 struct zbookmark;
68 struct spa;
69 struct nvlist;
70 struct arc_buf;
71 struct zio_prop;
72 struct sa_handle;
73 
74 typedef struct objset objset_t;
75 typedef struct dmu_tx dmu_tx_t;
76 typedef struct dsl_dir dsl_dir_t;
77 
78 typedef enum dmu_object_byteswap {
79 	DMU_BSWAP_UINT8,
80 	DMU_BSWAP_UINT16,
81 	DMU_BSWAP_UINT32,
82 	DMU_BSWAP_UINT64,
83 	DMU_BSWAP_ZAP,
84 	DMU_BSWAP_DNODE,
85 	DMU_BSWAP_OBJSET,
86 	DMU_BSWAP_ZNODE,
87 	DMU_BSWAP_OLDACL,
88 	DMU_BSWAP_ACL,
89 	/*
90 	 * Allocating a new byteswap type number makes the on-disk format
91 	 * incompatible with any other format that uses the same number.
92 	 *
93 	 * Data can usually be structured to work with one of the
94 	 * DMU_BSWAP_UINT* or DMU_BSWAP_ZAP types.
95 	 */
96 	DMU_BSWAP_NUMFUNCS
97 } dmu_object_byteswap_t;
98 
99 #define	DMU_OT_NEWTYPE 0x80
100 #define	DMU_OT_METADATA 0x40
101 #define	DMU_OT_BYTESWAP_MASK 0x3f
102 
103 /*
104  * Defines a uint8_t object type. Object types specify if the data
105  * in the object is metadata (boolean) and how to byteswap the data
106  * (dmu_object_byteswap_t).
107  */
108 #define	DMU_OT(byteswap, metadata) \
109 	(DMU_OT_NEWTYPE | \
110 	((metadata) ? DMU_OT_METADATA : 0) | \
111 	((byteswap) & DMU_OT_BYTESWAP_MASK))
112 
113 #define	DMU_OT_IS_VALID(ot) (((ot) & DMU_OT_NEWTYPE) ? \
114 	((ot) & DMU_OT_BYTESWAP_MASK) < DMU_BSWAP_NUMFUNCS : \
115 	(ot) < DMU_OT_NUMTYPES)
116 
117 #define	DMU_OT_IS_METADATA(ot) (((ot) & DMU_OT_NEWTYPE) ? \
118 	((ot) & DMU_OT_METADATA) : \
119 	dmu_ot[(ot)].ot_metadata)
120 
121 #define	DMU_OT_BYTESWAP(ot) (((ot) & DMU_OT_NEWTYPE) ? \
122 	((ot) & DMU_OT_BYTESWAP_MASK) : \
123 	dmu_ot[(ot)].ot_byteswap)
124 
125 typedef enum dmu_object_type {
126 	DMU_OT_NONE,
127 	/* general: */
128 	DMU_OT_OBJECT_DIRECTORY,	/* ZAP */
129 	DMU_OT_OBJECT_ARRAY,		/* UINT64 */
130 	DMU_OT_PACKED_NVLIST,		/* UINT8 (XDR by nvlist_pack/unpack) */
131 	DMU_OT_PACKED_NVLIST_SIZE,	/* UINT64 */
132 	DMU_OT_BPOBJ,			/* UINT64 */
133 	DMU_OT_BPOBJ_HDR,		/* UINT64 */
134 	/* spa: */
135 	DMU_OT_SPACE_MAP_HEADER,	/* UINT64 */
136 	DMU_OT_SPACE_MAP,		/* UINT64 */
137 	/* zil: */
138 	DMU_OT_INTENT_LOG,		/* UINT64 */
139 	/* dmu: */
140 	DMU_OT_DNODE,			/* DNODE */
141 	DMU_OT_OBJSET,			/* OBJSET */
142 	/* dsl: */
143 	DMU_OT_DSL_DIR,			/* UINT64 */
144 	DMU_OT_DSL_DIR_CHILD_MAP,	/* ZAP */
145 	DMU_OT_DSL_DS_SNAP_MAP,		/* ZAP */
146 	DMU_OT_DSL_PROPS,		/* ZAP */
147 	DMU_OT_DSL_DATASET,		/* UINT64 */
148 	/* zpl: */
149 	DMU_OT_ZNODE,			/* ZNODE */
150 	DMU_OT_OLDACL,			/* Old ACL */
151 	DMU_OT_PLAIN_FILE_CONTENTS,	/* UINT8 */
152 	DMU_OT_DIRECTORY_CONTENTS,	/* ZAP */
153 	DMU_OT_MASTER_NODE,		/* ZAP */
154 	DMU_OT_UNLINKED_SET,		/* ZAP */
155 	/* zvol: */
156 	DMU_OT_ZVOL,			/* UINT8 */
157 	DMU_OT_ZVOL_PROP,		/* ZAP */
158 	/* other; for testing only! */
159 	DMU_OT_PLAIN_OTHER,		/* UINT8 */
160 	DMU_OT_UINT64_OTHER,		/* UINT64 */
161 	DMU_OT_ZAP_OTHER,		/* ZAP */
162 	/* new object types: */
163 	DMU_OT_ERROR_LOG,		/* ZAP */
164 	DMU_OT_SPA_HISTORY,		/* UINT8 */
165 	DMU_OT_SPA_HISTORY_OFFSETS,	/* spa_his_phys_t */
166 	DMU_OT_POOL_PROPS,		/* ZAP */
167 	DMU_OT_DSL_PERMS,		/* ZAP */
168 	DMU_OT_ACL,			/* ACL */
169 	DMU_OT_SYSACL,			/* SYSACL */
170 	DMU_OT_FUID,			/* FUID table (Packed NVLIST UINT8) */
171 	DMU_OT_FUID_SIZE,		/* FUID table size UINT64 */
172 	DMU_OT_NEXT_CLONES,		/* ZAP */
173 	DMU_OT_SCAN_QUEUE,		/* ZAP */
174 	DMU_OT_USERGROUP_USED,		/* ZAP */
175 	DMU_OT_USERGROUP_QUOTA,		/* ZAP */
176 	DMU_OT_USERREFS,		/* ZAP */
177 	DMU_OT_DDT_ZAP,			/* ZAP */
178 	DMU_OT_DDT_STATS,		/* ZAP */
179 	DMU_OT_SA,			/* System attr */
180 	DMU_OT_SA_MASTER_NODE,		/* ZAP */
181 	DMU_OT_SA_ATTR_REGISTRATION,	/* ZAP */
182 	DMU_OT_SA_ATTR_LAYOUTS,		/* ZAP */
183 	DMU_OT_SCAN_XLATE,		/* ZAP */
184 	DMU_OT_DEDUP,			/* fake dedup BP from ddt_bp_create() */
185 	DMU_OT_DEADLIST,		/* ZAP */
186 	DMU_OT_DEADLIST_HDR,		/* UINT64 */
187 	DMU_OT_DSL_CLONES,		/* ZAP */
188 	DMU_OT_BPOBJ_SUBOBJ,		/* UINT64 */
189 	/*
190 	 * Do not allocate new object types here. Doing so makes the on-disk
191 	 * format incompatible with any other format that uses the same object
192 	 * type number.
193 	 *
194 	 * When creating an object which does not have one of the above types
195 	 * use the DMU_OTN_* type with the correct byteswap and metadata
196 	 * values.
197 	 *
198 	 * The DMU_OTN_* types do not have entries in the dmu_ot table,
199 	 * use the DMU_OT_IS_METDATA() and DMU_OT_BYTESWAP() macros instead
200 	 * of indexing into dmu_ot directly (this works for both DMU_OT_* types
201 	 * and DMU_OTN_* types).
202 	 */
203 	DMU_OT_NUMTYPES,
204 
205 	/*
206 	 * Names for valid types declared with DMU_OT().
207 	 */
208 	DMU_OTN_UINT8_DATA = DMU_OT(DMU_BSWAP_UINT8, B_FALSE),
209 	DMU_OTN_UINT8_METADATA = DMU_OT(DMU_BSWAP_UINT8, B_TRUE),
210 	DMU_OTN_UINT16_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE),
211 	DMU_OTN_UINT16_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE),
212 	DMU_OTN_UINT32_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE),
213 	DMU_OTN_UINT32_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE),
214 	DMU_OTN_UINT64_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE),
215 	DMU_OTN_UINT64_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE),
216 	DMU_OTN_ZAP_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE),
217 	DMU_OTN_ZAP_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE),
218 } dmu_object_type_t;
219 
220 void byteswap_uint64_array(void *buf, size_t size);
221 void byteswap_uint32_array(void *buf, size_t size);
222 void byteswap_uint16_array(void *buf, size_t size);
223 void byteswap_uint8_array(void *buf, size_t size);
224 void zap_byteswap(void *buf, size_t size);
225 void zfs_oldacl_byteswap(void *buf, size_t size);
226 void zfs_acl_byteswap(void *buf, size_t size);
227 void zfs_znode_byteswap(void *buf, size_t size);
228 
229 #define	DS_FIND_SNAPSHOTS	(1<<0)
230 #define	DS_FIND_CHILDREN	(1<<1)
231 
232 /*
233  * The maximum number of bytes that can be accessed as part of one
234  * operation, including metadata.
235  */
236 #define	DMU_MAX_ACCESS (10<<20) /* 10MB */
237 #define	DMU_MAX_DELETEBLKCNT (20480) /* ~5MB of indirect blocks */
238 
239 #define	DMU_USERUSED_OBJECT	(-1ULL)
240 #define	DMU_GROUPUSED_OBJECT	(-2ULL)
241 #define	DMU_DEADLIST_OBJECT	(-3ULL)
242 
243 /*
244  * artificial blkids for bonus buffer and spill blocks
245  */
246 #define	DMU_BONUS_BLKID		(-1ULL)
247 #define	DMU_SPILL_BLKID		(-2ULL)
248 /*
249  * Public routines to create, destroy, open, and close objsets.
250  */
251 int dmu_objset_hold(const char *name, void *tag, objset_t **osp);
252 int dmu_objset_own(const char *name, dmu_objset_type_t type,
253     boolean_t readonly, void *tag, objset_t **osp);
254 void dmu_objset_rele(objset_t *os, void *tag);
255 void dmu_objset_disown(objset_t *os, void *tag);
256 int dmu_objset_open_ds(struct dsl_dataset *ds, objset_t **osp);
257 
258 int dmu_objset_evict_dbufs(objset_t *os);
259 int dmu_objset_create(const char *name, dmu_objset_type_t type, uint64_t flags,
260     void (*func)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx), void *arg);
261 int dmu_objset_clone(const char *name, struct dsl_dataset *clone_origin,
262     uint64_t flags);
263 int dmu_objset_destroy(const char *name, boolean_t defer);
264 int dmu_snapshots_destroy_nvl(struct nvlist *snaps, boolean_t defer,
265     struct nvlist *errlist);
266 int dmu_objset_snapshot(struct nvlist *snaps, struct nvlist *, struct nvlist *);
267 int dmu_objset_snapshot_one(const char *fsname, const char *snapname);
268 int dmu_objset_snapshot_tmp(const char *, const char *, int);
269 int dmu_objset_rename(const char *name, const char *newname,
270     boolean_t recursive);
271 int dmu_objset_find(char *name, int func(const char *, void *), void *arg,
272     int flags);
273 void dmu_objset_byteswap(void *buf, size_t size);
274 
275 typedef struct dmu_buf {
276 	uint64_t db_object;		/* object that this buffer is part of */
277 	uint64_t db_offset;		/* byte offset in this object */
278 	uint64_t db_size;		/* size of buffer in bytes */
279 	void *db_data;			/* data in buffer */
280 } dmu_buf_t;
281 
282 typedef void dmu_buf_evict_func_t(struct dmu_buf *db, void *user_ptr);
283 
284 /*
285  * The names of zap entries in the DIRECTORY_OBJECT of the MOS.
286  */
287 #define	DMU_POOL_DIRECTORY_OBJECT	1
288 #define	DMU_POOL_CONFIG			"config"
289 #define	DMU_POOL_FEATURES_FOR_WRITE	"features_for_write"
290 #define	DMU_POOL_FEATURES_FOR_READ	"features_for_read"
291 #define	DMU_POOL_FEATURE_DESCRIPTIONS	"feature_descriptions"
292 #define	DMU_POOL_ROOT_DATASET		"root_dataset"
293 #define	DMU_POOL_SYNC_BPOBJ		"sync_bplist"
294 #define	DMU_POOL_ERRLOG_SCRUB		"errlog_scrub"
295 #define	DMU_POOL_ERRLOG_LAST		"errlog_last"
296 #define	DMU_POOL_SPARES			"spares"
297 #define	DMU_POOL_DEFLATE		"deflate"
298 #define	DMU_POOL_HISTORY		"history"
299 #define	DMU_POOL_PROPS			"pool_props"
300 #define	DMU_POOL_L2CACHE		"l2cache"
301 #define	DMU_POOL_TMP_USERREFS		"tmp_userrefs"
302 #define	DMU_POOL_DDT			"DDT-%s-%s-%s"
303 #define	DMU_POOL_DDT_STATS		"DDT-statistics"
304 #define	DMU_POOL_CREATION_VERSION	"creation_version"
305 #define	DMU_POOL_SCAN			"scan"
306 #define	DMU_POOL_FREE_BPOBJ		"free_bpobj"
307 #define	DMU_POOL_BPTREE_OBJ		"bptree_obj"
308 #define	DMU_POOL_EMPTY_BPOBJ		"empty_bpobj"
309 
310 /*
311  * Allocate an object from this objset.  The range of object numbers
312  * available is (0, DN_MAX_OBJECT).  Object 0 is the meta-dnode.
313  *
314  * The transaction must be assigned to a txg.  The newly allocated
315  * object will be "held" in the transaction (ie. you can modify the
316  * newly allocated object in this transaction).
317  *
318  * dmu_object_alloc() chooses an object and returns it in *objectp.
319  *
320  * dmu_object_claim() allocates a specific object number.  If that
321  * number is already allocated, it fails and returns EEXIST.
322  *
323  * Return 0 on success, or ENOSPC or EEXIST as specified above.
324  */
325 uint64_t dmu_object_alloc(objset_t *os, dmu_object_type_t ot,
326     int blocksize, dmu_object_type_t bonus_type, int bonus_len, dmu_tx_t *tx);
327 int dmu_object_claim(objset_t *os, uint64_t object, dmu_object_type_t ot,
328     int blocksize, dmu_object_type_t bonus_type, int bonus_len, dmu_tx_t *tx);
329 int dmu_object_reclaim(objset_t *os, uint64_t object, dmu_object_type_t ot,
330     int blocksize, dmu_object_type_t bonustype, int bonuslen);
331 
332 /*
333  * Free an object from this objset.
334  *
335  * The object's data will be freed as well (ie. you don't need to call
336  * dmu_free(object, 0, -1, tx)).
337  *
338  * The object need not be held in the transaction.
339  *
340  * If there are any holds on this object's buffers (via dmu_buf_hold()),
341  * or tx holds on the object (via dmu_tx_hold_object()), you can not
342  * free it; it fails and returns EBUSY.
343  *
344  * If the object is not allocated, it fails and returns ENOENT.
345  *
346  * Return 0 on success, or EBUSY or ENOENT as specified above.
347  */
348 int dmu_object_free(objset_t *os, uint64_t object, dmu_tx_t *tx);
349 
350 /*
351  * Find the next allocated or free object.
352  *
353  * The objectp parameter is in-out.  It will be updated to be the next
354  * object which is allocated.  Ignore objects which have not been
355  * modified since txg.
356  *
357  * XXX Can only be called on a objset with no dirty data.
358  *
359  * Returns 0 on success, or ENOENT if there are no more objects.
360  */
361 int dmu_object_next(objset_t *os, uint64_t *objectp,
362     boolean_t hole, uint64_t txg);
363 
364 /*
365  * Set the data blocksize for an object.
366  *
367  * The object cannot have any blocks allcated beyond the first.  If
368  * the first block is allocated already, the new size must be greater
369  * than the current block size.  If these conditions are not met,
370  * ENOTSUP will be returned.
371  *
372  * Returns 0 on success, or EBUSY if there are any holds on the object
373  * contents, or ENOTSUP as described above.
374  */
375 int dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size,
376     int ibs, dmu_tx_t *tx);
377 
378 /*
379  * Set the checksum property on a dnode.  The new checksum algorithm will
380  * apply to all newly written blocks; existing blocks will not be affected.
381  */
382 void dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
383     dmu_tx_t *tx);
384 
385 /*
386  * Set the compress property on a dnode.  The new compression algorithm will
387  * apply to all newly written blocks; existing blocks will not be affected.
388  */
389 void dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
390     dmu_tx_t *tx);
391 
392 /*
393  * Decide how to write a block: checksum, compression, number of copies, etc.
394  */
395 #define	WP_NOFILL	0x1
396 #define	WP_DMU_SYNC	0x2
397 #define	WP_SPILL	0x4
398 
399 void dmu_write_policy(objset_t *os, struct dnode *dn, int level, int wp,
400     struct zio_prop *zp);
401 /*
402  * The bonus data is accessed more or less like a regular buffer.
403  * You must dmu_bonus_hold() to get the buffer, which will give you a
404  * dmu_buf_t with db_offset==-1ULL, and db_size = the size of the bonus
405  * data.  As with any normal buffer, you must call dmu_buf_read() to
406  * read db_data, dmu_buf_will_dirty() before modifying it, and the
407  * object must be held in an assigned transaction before calling
408  * dmu_buf_will_dirty.  You may use dmu_buf_set_user() on the bonus
409  * buffer as well.  You must release your hold with dmu_buf_rele().
410  */
411 int dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **);
412 int dmu_bonus_max(void);
413 int dmu_set_bonus(dmu_buf_t *, int, dmu_tx_t *);
414 int dmu_set_bonustype(dmu_buf_t *, dmu_object_type_t, dmu_tx_t *);
415 dmu_object_type_t dmu_get_bonustype(dmu_buf_t *);
416 int dmu_rm_spill(objset_t *, uint64_t, dmu_tx_t *);
417 
418 /*
419  * Special spill buffer support used by "SA" framework
420  */
421 
422 int dmu_spill_hold_by_bonus(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp);
423 int dmu_spill_hold_by_dnode(struct dnode *dn, uint32_t flags,
424     void *tag, dmu_buf_t **dbp);
425 int dmu_spill_hold_existing(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp);
426 
427 /*
428  * Obtain the DMU buffer from the specified object which contains the
429  * specified offset.  dmu_buf_hold() puts a "hold" on the buffer, so
430  * that it will remain in memory.  You must release the hold with
431  * dmu_buf_rele().  You musn't access the dmu_buf_t after releasing your
432  * hold.  You must have a hold on any dmu_buf_t* you pass to the DMU.
433  *
434  * You must call dmu_buf_read, dmu_buf_will_dirty, or dmu_buf_will_fill
435  * on the returned buffer before reading or writing the buffer's
436  * db_data.  The comments for those routines describe what particular
437  * operations are valid after calling them.
438  *
439  * The object number must be a valid, allocated object number.
440  */
441 int dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset,
442     void *tag, dmu_buf_t **, int flags);
443 void dmu_buf_add_ref(dmu_buf_t *db, void* tag);
444 void dmu_buf_rele(dmu_buf_t *db, void *tag);
445 uint64_t dmu_buf_refcount(dmu_buf_t *db);
446 
447 /*
448  * dmu_buf_hold_array holds the DMU buffers which contain all bytes in a
449  * range of an object.  A pointer to an array of dmu_buf_t*'s is
450  * returned (in *dbpp).
451  *
452  * dmu_buf_rele_array releases the hold on an array of dmu_buf_t*'s, and
453  * frees the array.  The hold on the array of buffers MUST be released
454  * with dmu_buf_rele_array.  You can NOT release the hold on each buffer
455  * individually with dmu_buf_rele.
456  */
457 int dmu_buf_hold_array_by_bonus(dmu_buf_t *db, uint64_t offset,
458     uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp);
459 void dmu_buf_rele_array(dmu_buf_t **, int numbufs, void *tag);
460 
461 /*
462  * Returns NULL on success, or the existing user ptr if it's already
463  * been set.
464  *
465  * user_ptr is for use by the user and can be obtained via dmu_buf_get_user().
466  *
467  * user_data_ptr_ptr should be NULL, or a pointer to a pointer which
468  * will be set to db->db_data when you are allowed to access it.  Note
469  * that db->db_data (the pointer) can change when you do dmu_buf_read(),
470  * dmu_buf_tryupgrade(), dmu_buf_will_dirty(), or dmu_buf_will_fill().
471  * *user_data_ptr_ptr will be set to the new value when it changes.
472  *
473  * If non-NULL, pageout func will be called when this buffer is being
474  * excised from the cache, so that you can clean up the data structure
475  * pointed to by user_ptr.
476  *
477  * dmu_evict_user() will call the pageout func for all buffers in a
478  * objset with a given pageout func.
479  */
480 void *dmu_buf_set_user(dmu_buf_t *db, void *user_ptr, void *user_data_ptr_ptr,
481     dmu_buf_evict_func_t *pageout_func);
482 /*
483  * set_user_ie is the same as set_user, but request immediate eviction
484  * when hold count goes to zero.
485  */
486 void *dmu_buf_set_user_ie(dmu_buf_t *db, void *user_ptr,
487     void *user_data_ptr_ptr, dmu_buf_evict_func_t *pageout_func);
488 void *dmu_buf_update_user(dmu_buf_t *db_fake, void *old_user_ptr,
489     void *user_ptr, void *user_data_ptr_ptr,
490     dmu_buf_evict_func_t *pageout_func);
491 void dmu_evict_user(objset_t *os, dmu_buf_evict_func_t *func);
492 
493 /*
494  * Returns the user_ptr set with dmu_buf_set_user(), or NULL if not set.
495  */
496 void *dmu_buf_get_user(dmu_buf_t *db);
497 
498 /*
499  * Indicate that you are going to modify the buffer's data (db_data).
500  *
501  * The transaction (tx) must be assigned to a txg (ie. you've called
502  * dmu_tx_assign()).  The buffer's object must be held in the tx
503  * (ie. you've called dmu_tx_hold_object(tx, db->db_object)).
504  */
505 void dmu_buf_will_dirty(dmu_buf_t *db, dmu_tx_t *tx);
506 
507 /*
508  * Tells if the given dbuf is freeable.
509  */
510 boolean_t dmu_buf_freeable(dmu_buf_t *);
511 
512 /*
513  * You must create a transaction, then hold the objects which you will
514  * (or might) modify as part of this transaction.  Then you must assign
515  * the transaction to a transaction group.  Once the transaction has
516  * been assigned, you can modify buffers which belong to held objects as
517  * part of this transaction.  You can't modify buffers before the
518  * transaction has been assigned; you can't modify buffers which don't
519  * belong to objects which this transaction holds; you can't hold
520  * objects once the transaction has been assigned.  You may hold an
521  * object which you are going to free (with dmu_object_free()), but you
522  * don't have to.
523  *
524  * You can abort the transaction before it has been assigned.
525  *
526  * Note that you may hold buffers (with dmu_buf_hold) at any time,
527  * regardless of transaction state.
528  */
529 
530 #define	DMU_NEW_OBJECT	(-1ULL)
531 #define	DMU_OBJECT_END	(-1ULL)
532 
533 dmu_tx_t *dmu_tx_create(objset_t *os);
534 void dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len);
535 void dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off,
536     uint64_t len);
537 void dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name);
538 void dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object);
539 void dmu_tx_hold_spill(dmu_tx_t *tx, uint64_t object);
540 void dmu_tx_hold_sa(dmu_tx_t *tx, struct sa_handle *hdl, boolean_t may_grow);
541 void dmu_tx_hold_sa_create(dmu_tx_t *tx, int total_size);
542 void dmu_tx_abort(dmu_tx_t *tx);
543 int dmu_tx_assign(dmu_tx_t *tx, uint64_t txg_how);
544 void dmu_tx_wait(dmu_tx_t *tx);
545 void dmu_tx_commit(dmu_tx_t *tx);
546 
547 /*
548  * To register a commit callback, dmu_tx_callback_register() must be called.
549  *
550  * dcb_data is a pointer to caller private data that is passed on as a
551  * callback parameter. The caller is responsible for properly allocating and
552  * freeing it.
553  *
554  * When registering a callback, the transaction must be already created, but
555  * it cannot be committed or aborted. It can be assigned to a txg or not.
556  *
557  * The callback will be called after the transaction has been safely written
558  * to stable storage and will also be called if the dmu_tx is aborted.
559  * If there is any error which prevents the transaction from being committed to
560  * disk, the callback will be called with a value of error != 0.
561  */
562 typedef void dmu_tx_callback_func_t(void *dcb_data, int error);
563 
564 void dmu_tx_callback_register(dmu_tx_t *tx, dmu_tx_callback_func_t *dcb_func,
565     void *dcb_data);
566 
567 /*
568  * Free up the data blocks for a defined range of a file.  If size is
569  * -1, the range from offset to end-of-file is freed.
570  */
571 int dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
572 	uint64_t size, dmu_tx_t *tx);
573 int dmu_free_long_range(objset_t *os, uint64_t object, uint64_t offset,
574 	uint64_t size);
575 int dmu_free_object(objset_t *os, uint64_t object);
576 
577 /*
578  * Convenience functions.
579  *
580  * Canfail routines will return 0 on success, or an errno if there is a
581  * nonrecoverable I/O error.
582  */
583 #define	DMU_READ_PREFETCH	0 /* prefetch */
584 #define	DMU_READ_NO_PREFETCH	1 /* don't prefetch */
585 int dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
586 	void *buf, uint32_t flags);
587 void dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
588 	const void *buf, dmu_tx_t *tx);
589 void dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
590 	dmu_tx_t *tx);
591 int dmu_read_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size);
592 int dmu_write_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size,
593     dmu_tx_t *tx);
594 int dmu_write_uio_dbuf(dmu_buf_t *zdb, struct uio *uio, uint64_t size,
595     dmu_tx_t *tx);
596 int dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset,
597     uint64_t size, struct page *pp, dmu_tx_t *tx);
598 struct arc_buf *dmu_request_arcbuf(dmu_buf_t *handle, int size);
599 void dmu_return_arcbuf(struct arc_buf *buf);
600 void dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, struct arc_buf *buf,
601     dmu_tx_t *tx);
602 int dmu_xuio_init(struct xuio *uio, int niov);
603 void dmu_xuio_fini(struct xuio *uio);
604 int dmu_xuio_add(struct xuio *uio, struct arc_buf *abuf, offset_t off,
605     size_t n);
606 int dmu_xuio_cnt(struct xuio *uio);
607 struct arc_buf *dmu_xuio_arcbuf(struct xuio *uio, int i);
608 void dmu_xuio_clear(struct xuio *uio, int i);
609 void xuio_stat_wbuf_copied();
610 void xuio_stat_wbuf_nocopy();
611 
612 extern int zfs_prefetch_disable;
613 
614 /*
615  * Asynchronously try to read in the data.
616  */
617 void dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset,
618     uint64_t len);
619 
620 typedef struct dmu_object_info {
621 	/* All sizes are in bytes unless otherwise indicated. */
622 	uint32_t doi_data_block_size;
623 	uint32_t doi_metadata_block_size;
624 	dmu_object_type_t doi_type;
625 	dmu_object_type_t doi_bonus_type;
626 	uint64_t doi_bonus_size;
627 	uint8_t doi_indirection;		/* 2 = dnode->indirect->data */
628 	uint8_t doi_checksum;
629 	uint8_t doi_compress;
630 	uint8_t doi_pad[5];
631 	uint64_t doi_physical_blocks_512;	/* data + metadata, 512b blks */
632 	uint64_t doi_max_offset;
633 	uint64_t doi_fill_count;		/* number of non-empty blocks */
634 } dmu_object_info_t;
635 
636 typedef void arc_byteswap_func_t(void *buf, size_t size);
637 
638 typedef struct dmu_object_type_info {
639 	dmu_object_byteswap_t	ot_byteswap;
640 	boolean_t		ot_metadata;
641 	char			*ot_name;
642 } dmu_object_type_info_t;
643 
644 typedef struct dmu_object_byteswap_info {
645 	arc_byteswap_func_t	*ob_func;
646 	char			*ob_name;
647 } dmu_object_byteswap_info_t;
648 
649 extern const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES];
650 extern const dmu_object_byteswap_info_t dmu_ot_byteswap[DMU_BSWAP_NUMFUNCS];
651 
652 /*
653  * Get information on a DMU object.
654  *
655  * Return 0 on success or ENOENT if object is not allocated.
656  *
657  * If doi is NULL, just indicates whether the object exists.
658  */
659 int dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi);
660 void dmu_object_info_from_dnode(struct dnode *dn, dmu_object_info_t *doi);
661 void dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi);
662 void dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize,
663     u_longlong_t *nblk512);
664 
665 typedef struct dmu_objset_stats {
666 	uint64_t dds_num_clones; /* number of clones of this */
667 	uint64_t dds_creation_txg;
668 	uint64_t dds_guid;
669 	dmu_objset_type_t dds_type;
670 	uint8_t dds_is_snapshot;
671 	uint8_t dds_inconsistent;
672 	char dds_origin[MAXNAMELEN];
673 } dmu_objset_stats_t;
674 
675 /*
676  * Get stats on a dataset.
677  */
678 void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
679 
680 /*
681  * Add entries to the nvlist for all the objset's properties.  See
682  * zfs_prop_table[] and zfs(1m) for details on the properties.
683  */
684 void dmu_objset_stats(objset_t *os, struct nvlist *nv);
685 
686 /*
687  * Get the space usage statistics for statvfs().
688  *
689  * refdbytes is the amount of space "referenced" by this objset.
690  * availbytes is the amount of space available to this objset, taking
691  * into account quotas & reservations, assuming that no other objsets
692  * use the space first.  These values correspond to the 'referenced' and
693  * 'available' properties, described in the zfs(1m) manpage.
694  *
695  * usedobjs and availobjs are the number of objects currently allocated,
696  * and available.
697  */
698 void dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
699     uint64_t *usedobjsp, uint64_t *availobjsp);
700 
701 /*
702  * The fsid_guid is a 56-bit ID that can change to avoid collisions.
703  * (Contrast with the ds_guid which is a 64-bit ID that will never
704  * change, so there is a small probability that it will collide.)
705  */
706 uint64_t dmu_objset_fsid_guid(objset_t *os);
707 
708 /*
709  * Get the [cm]time for an objset's snapshot dir
710  */
711 timestruc_t dmu_objset_snap_cmtime(objset_t *os);
712 
713 int dmu_objset_is_snapshot(objset_t *os);
714 
715 extern struct spa *dmu_objset_spa(objset_t *os);
716 extern struct zilog *dmu_objset_zil(objset_t *os);
717 extern struct dsl_pool *dmu_objset_pool(objset_t *os);
718 extern struct dsl_dataset *dmu_objset_ds(objset_t *os);
719 extern void dmu_objset_name(objset_t *os, char *buf);
720 extern dmu_objset_type_t dmu_objset_type(objset_t *os);
721 extern uint64_t dmu_objset_id(objset_t *os);
722 extern uint64_t dmu_objset_syncprop(objset_t *os);
723 extern uint64_t dmu_objset_logbias(objset_t *os);
724 extern int dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
725     uint64_t *id, uint64_t *offp, boolean_t *case_conflict);
726 extern int dmu_snapshot_realname(objset_t *os, char *name, char *real,
727     int maxlen, boolean_t *conflict);
728 extern int dmu_dir_list_next(objset_t *os, int namelen, char *name,
729     uint64_t *idp, uint64_t *offp);
730 
731 typedef int objset_used_cb_t(dmu_object_type_t bonustype,
732     void *bonus, uint64_t *userp, uint64_t *groupp);
733 extern void dmu_objset_register_type(dmu_objset_type_t ost,
734     objset_used_cb_t *cb);
735 extern void dmu_objset_set_user(objset_t *os, void *user_ptr);
736 extern void *dmu_objset_get_user(objset_t *os);
737 
738 /*
739  * Return the txg number for the given assigned transaction.
740  */
741 uint64_t dmu_tx_get_txg(dmu_tx_t *tx);
742 
743 /*
744  * Synchronous write.
745  * If a parent zio is provided this function initiates a write on the
746  * provided buffer as a child of the parent zio.
747  * In the absence of a parent zio, the write is completed synchronously.
748  * At write completion, blk is filled with the bp of the written block.
749  * Note that while the data covered by this function will be on stable
750  * storage when the write completes this new data does not become a
751  * permanent part of the file until the associated transaction commits.
752  */
753 
754 /*
755  * {zfs,zvol,ztest}_get_done() args
756  */
757 typedef struct zgd {
758 	struct zilog	*zgd_zilog;
759 	struct blkptr	*zgd_bp;
760 	dmu_buf_t	*zgd_db;
761 	struct rl	*zgd_rl;
762 	void		*zgd_private;
763 } zgd_t;
764 
765 typedef void dmu_sync_cb_t(zgd_t *arg, int error);
766 int dmu_sync(struct zio *zio, uint64_t txg, dmu_sync_cb_t *done, zgd_t *zgd);
767 
768 /*
769  * Find the next hole or data block in file starting at *off
770  * Return found offset in *off. Return ESRCH for end of file.
771  */
772 int dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole,
773     uint64_t *off);
774 
775 /*
776  * Initial setup and final teardown.
777  */
778 extern void dmu_init(void);
779 extern void dmu_fini(void);
780 
781 typedef void (*dmu_traverse_cb_t)(objset_t *os, void *arg, struct blkptr *bp,
782     uint64_t object, uint64_t offset, int len);
783 void dmu_traverse_objset(objset_t *os, uint64_t txg_start,
784     dmu_traverse_cb_t cb, void *arg);
785 
786 int dmu_send(objset_t *tosnap, objset_t *fromsnap,
787     int outfd, struct vnode *vp, offset_t *off);
788 int dmu_send_estimate(objset_t *tosnap, objset_t *fromsnap, uint64_t *sizep);
789 
790 typedef struct dmu_recv_cookie {
791 	/*
792 	 * This structure is opaque!
793 	 *
794 	 * If logical and real are different, we are recving the stream
795 	 * into the "real" temporary clone, and then switching it with
796 	 * the "logical" target.
797 	 */
798 	struct dsl_dataset *drc_logical_ds;
799 	struct dsl_dataset *drc_real_ds;
800 	struct drr_begin *drc_drrb;
801 	char *drc_tosnap;
802 	char *drc_top_ds;
803 	boolean_t drc_newfs;
804 	boolean_t drc_force;
805 	struct avl_tree *drc_guid_to_ds_map;
806 } dmu_recv_cookie_t;
807 
808 int dmu_recv_begin(char *tofs, char *tosnap, char *topds, struct drr_begin *,
809     boolean_t force, objset_t *origin, dmu_recv_cookie_t *);
810 int dmu_recv_stream(dmu_recv_cookie_t *drc, struct vnode *vp, offset_t *voffp,
811     int cleanup_fd, uint64_t *action_handlep);
812 int dmu_recv_end(dmu_recv_cookie_t *drc);
813 
814 int dmu_diff(objset_t *tosnap, objset_t *fromsnap, struct vnode *vp,
815     offset_t *off);
816 
817 /* CRC64 table */
818 #define	ZFS_CRC64_POLY	0xC96C5795D7870F42ULL	/* ECMA-182, reflected form */
819 extern uint64_t zfs_crc64_table[256];
820 
821 #ifdef	__cplusplus
822 }
823 #endif
824 
825 #endif	/* _SYS_DMU_H */
826