Print this page
FAR: generating send-streams in portable format
This commit adds a switch '-F' to zfs send. This set, zfs send generates
a stream in FAR-format instead of the traditional zfs stream format. The
generated send stream is compatible with the stream generated from 'btrfs send'
and can in principle easily be received to any filesystem.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libzfs/common/libzfs.h
+++ new/usr/src/lib/libzfs/common/libzfs.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 25 * Copyright (c) 2012 by Delphix. All rights reserved.
26 26 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
27 27 */
28 28
29 29 #ifndef _LIBZFS_H
30 30 #define _LIBZFS_H
31 31
32 32 #include <assert.h>
33 33 #include <libnvpair.h>
34 34 #include <sys/mnttab.h>
35 35 #include <sys/param.h>
36 36 #include <sys/types.h>
37 37 #include <sys/varargs.h>
38 38 #include <sys/fs/zfs.h>
39 39 #include <sys/avl.h>
40 40 #include <ucred.h>
41 41
42 42 #ifdef __cplusplus
43 43 extern "C" {
44 44 #endif
45 45
46 46 /*
47 47 * Miscellaneous ZFS constants
48 48 */
49 49 #define ZFS_MAXNAMELEN MAXNAMELEN
50 50 #define ZPOOL_MAXNAMELEN MAXNAMELEN
51 51 #define ZFS_MAXPROPLEN MAXPATHLEN
52 52 #define ZPOOL_MAXPROPLEN MAXPATHLEN
53 53
54 54 /*
55 55 * libzfs errors
56 56 */
57 57 typedef enum zfs_error {
58 58 EZFS_SUCCESS = 0, /* no error -- success */
59 59 EZFS_NOMEM = 2000, /* out of memory */
60 60 EZFS_BADPROP, /* invalid property value */
61 61 EZFS_PROPREADONLY, /* cannot set readonly property */
62 62 EZFS_PROPTYPE, /* property does not apply to dataset type */
63 63 EZFS_PROPNONINHERIT, /* property is not inheritable */
64 64 EZFS_PROPSPACE, /* bad quota or reservation */
65 65 EZFS_BADTYPE, /* dataset is not of appropriate type */
66 66 EZFS_BUSY, /* pool or dataset is busy */
67 67 EZFS_EXISTS, /* pool or dataset already exists */
68 68 EZFS_NOENT, /* no such pool or dataset */
69 69 EZFS_BADSTREAM, /* bad backup stream */
70 70 EZFS_DSREADONLY, /* dataset is readonly */
71 71 EZFS_VOLTOOBIG, /* volume is too large for 32-bit system */
72 72 EZFS_INVALIDNAME, /* invalid dataset name */
73 73 EZFS_BADRESTORE, /* unable to restore to destination */
74 74 EZFS_BADBACKUP, /* backup failed */
75 75 EZFS_BADTARGET, /* bad attach/detach/replace target */
76 76 EZFS_NODEVICE, /* no such device in pool */
77 77 EZFS_BADDEV, /* invalid device to add */
78 78 EZFS_NOREPLICAS, /* no valid replicas */
79 79 EZFS_RESILVERING, /* currently resilvering */
80 80 EZFS_BADVERSION, /* unsupported version */
81 81 EZFS_POOLUNAVAIL, /* pool is currently unavailable */
82 82 EZFS_DEVOVERFLOW, /* too many devices in one vdev */
83 83 EZFS_BADPATH, /* must be an absolute path */
84 84 EZFS_CROSSTARGET, /* rename or clone across pool or dataset */
85 85 EZFS_ZONED, /* used improperly in local zone */
86 86 EZFS_MOUNTFAILED, /* failed to mount dataset */
87 87 EZFS_UMOUNTFAILED, /* failed to unmount dataset */
88 88 EZFS_UNSHARENFSFAILED, /* unshare(1M) failed */
89 89 EZFS_SHARENFSFAILED, /* share(1M) failed */
90 90 EZFS_PERM, /* permission denied */
91 91 EZFS_NOSPC, /* out of space */
92 92 EZFS_FAULT, /* bad address */
93 93 EZFS_IO, /* I/O error */
94 94 EZFS_INTR, /* signal received */
95 95 EZFS_ISSPARE, /* device is a hot spare */
96 96 EZFS_INVALCONFIG, /* invalid vdev configuration */
97 97 EZFS_RECURSIVE, /* recursive dependency */
98 98 EZFS_NOHISTORY, /* no history object */
99 99 EZFS_POOLPROPS, /* couldn't retrieve pool props */
100 100 EZFS_POOL_NOTSUP, /* ops not supported for this type of pool */
101 101 EZFS_POOL_INVALARG, /* invalid argument for this pool operation */
102 102 EZFS_NAMETOOLONG, /* dataset name is too long */
103 103 EZFS_OPENFAILED, /* open of device failed */
104 104 EZFS_NOCAP, /* couldn't get capacity */
105 105 EZFS_LABELFAILED, /* write of label failed */
106 106 EZFS_BADWHO, /* invalid permission who */
107 107 EZFS_BADPERM, /* invalid permission */
108 108 EZFS_BADPERMSET, /* invalid permission set name */
109 109 EZFS_NODELEGATION, /* delegated administration is disabled */
110 110 EZFS_UNSHARESMBFAILED, /* failed to unshare over smb */
111 111 EZFS_SHARESMBFAILED, /* failed to share over smb */
112 112 EZFS_BADCACHE, /* bad cache file */
113 113 EZFS_ISL2CACHE, /* device is for the level 2 ARC */
114 114 EZFS_VDEVNOTSUP, /* unsupported vdev type */
115 115 EZFS_NOTSUP, /* ops not supported on this dataset */
116 116 EZFS_ACTIVE_SPARE, /* pool has active shared spare devices */
117 117 EZFS_UNPLAYED_LOGS, /* log device has unplayed logs */
118 118 EZFS_REFTAG_RELE, /* snapshot release: tag not found */
119 119 EZFS_REFTAG_HOLD, /* snapshot hold: tag already exists */
120 120 EZFS_TAGTOOLONG, /* snapshot hold/rele: tag too long */
121 121 EZFS_PIPEFAILED, /* pipe create failed */
122 122 EZFS_THREADCREATEFAILED, /* thread create failed */
123 123 EZFS_POSTSPLIT_ONLINE, /* onlining a disk after splitting it */
124 124 EZFS_SCRUBBING, /* currently scrubbing */
125 125 EZFS_NO_SCRUB, /* no active scrub */
126 126 EZFS_DIFF, /* general failure of zfs diff */
127 127 EZFS_DIFFDATA, /* bad zfs diff data */
128 128 EZFS_POOLREADONLY, /* pool is in read-only mode */
129 129 EZFS_UNKNOWN
130 130 } zfs_error_t;
131 131
132 132 /*
133 133 * The following data structures are all part
134 134 * of the zfs_allow_t data structure which is
135 135 * used for printing 'allow' permissions.
136 136 * It is a linked list of zfs_allow_t's which
137 137 * then contain avl tree's for user/group/sets/...
138 138 * and each one of the entries in those trees have
139 139 * avl tree's for the permissions they belong to and
140 140 * whether they are local,descendent or local+descendent
141 141 * permissions. The AVL trees are used primarily for
142 142 * sorting purposes, but also so that we can quickly find
143 143 * a given user and or permission.
144 144 */
145 145 typedef struct zfs_perm_node {
146 146 avl_node_t z_node;
147 147 char z_pname[MAXPATHLEN];
148 148 } zfs_perm_node_t;
149 149
150 150 typedef struct zfs_allow_node {
151 151 avl_node_t z_node;
152 152 char z_key[MAXPATHLEN]; /* name, such as joe */
153 153 avl_tree_t z_localdescend; /* local+descendent perms */
154 154 avl_tree_t z_local; /* local permissions */
155 155 avl_tree_t z_descend; /* descendent permissions */
156 156 } zfs_allow_node_t;
157 157
158 158 typedef struct zfs_allow {
159 159 struct zfs_allow *z_next;
160 160 char z_setpoint[MAXPATHLEN];
161 161 avl_tree_t z_sets;
162 162 avl_tree_t z_crperms;
163 163 avl_tree_t z_user;
164 164 avl_tree_t z_group;
165 165 avl_tree_t z_everyone;
166 166 } zfs_allow_t;
167 167
168 168 /*
169 169 * Basic handle types
170 170 */
171 171 typedef struct zfs_handle zfs_handle_t;
172 172 typedef struct zpool_handle zpool_handle_t;
173 173 typedef struct libzfs_handle libzfs_handle_t;
174 174
175 175 /*
176 176 * Library initialization
177 177 */
178 178 extern libzfs_handle_t *libzfs_init(void);
179 179 extern void libzfs_fini(libzfs_handle_t *);
180 180
181 181 extern libzfs_handle_t *zpool_get_handle(zpool_handle_t *);
182 182 extern libzfs_handle_t *zfs_get_handle(zfs_handle_t *);
183 183
184 184 extern void libzfs_print_on_error(libzfs_handle_t *, boolean_t);
185 185
186 186 extern void zfs_save_arguments(int argc, char **, char *, int);
187 187 extern int zpool_log_history(libzfs_handle_t *, const char *);
188 188
189 189 extern int libzfs_errno(libzfs_handle_t *);
190 190 extern const char *libzfs_error_action(libzfs_handle_t *);
191 191 extern const char *libzfs_error_description(libzfs_handle_t *);
192 192 extern void libzfs_mnttab_init(libzfs_handle_t *);
193 193 extern void libzfs_mnttab_fini(libzfs_handle_t *);
194 194 extern void libzfs_mnttab_cache(libzfs_handle_t *, boolean_t);
195 195 extern int libzfs_mnttab_find(libzfs_handle_t *, const char *,
196 196 struct mnttab *);
197 197 extern void libzfs_mnttab_add(libzfs_handle_t *, const char *,
198 198 const char *, const char *);
199 199 extern void libzfs_mnttab_remove(libzfs_handle_t *, const char *);
200 200
201 201 /*
202 202 * Basic handle functions
203 203 */
204 204 extern zpool_handle_t *zpool_open(libzfs_handle_t *, const char *);
205 205 extern zpool_handle_t *zpool_open_canfail(libzfs_handle_t *, const char *);
206 206 extern void zpool_close(zpool_handle_t *);
207 207 extern const char *zpool_get_name(zpool_handle_t *);
208 208 extern int zpool_get_state(zpool_handle_t *);
209 209 extern char *zpool_state_to_name(vdev_state_t, vdev_aux_t);
210 210 extern void zpool_free_handles(libzfs_handle_t *);
211 211
212 212 /*
213 213 * Iterate over all active pools in the system.
214 214 */
215 215 typedef int (*zpool_iter_f)(zpool_handle_t *, void *);
216 216 extern int zpool_iter(libzfs_handle_t *, zpool_iter_f, void *);
217 217
218 218 /*
219 219 * Functions to create and destroy pools
220 220 */
221 221 extern int zpool_create(libzfs_handle_t *, const char *, nvlist_t *,
222 222 nvlist_t *, nvlist_t *);
223 223 extern int zpool_destroy(zpool_handle_t *, const char *);
224 224 extern int zpool_add(zpool_handle_t *, nvlist_t *);
225 225
226 226 typedef struct splitflags {
227 227 /* do not split, but return the config that would be split off */
228 228 int dryrun : 1;
229 229
230 230 /* after splitting, import the pool */
231 231 int import : 1;
232 232 } splitflags_t;
233 233
234 234 /*
235 235 * Functions to manipulate pool and vdev state
236 236 */
237 237 extern int zpool_scan(zpool_handle_t *, pool_scan_func_t);
238 238 extern int zpool_clear(zpool_handle_t *, const char *, nvlist_t *);
239 239 extern int zpool_reguid(zpool_handle_t *);
240 240 extern int zpool_reopen(zpool_handle_t *);
241 241
242 242 extern int zpool_vdev_online(zpool_handle_t *, const char *, int,
243 243 vdev_state_t *);
244 244 extern int zpool_vdev_offline(zpool_handle_t *, const char *, boolean_t);
245 245 extern int zpool_vdev_attach(zpool_handle_t *, const char *,
246 246 const char *, nvlist_t *, int);
247 247 extern int zpool_vdev_detach(zpool_handle_t *, const char *);
248 248 extern int zpool_vdev_remove(zpool_handle_t *, const char *);
249 249 extern int zpool_vdev_split(zpool_handle_t *, char *, nvlist_t **, nvlist_t *,
250 250 splitflags_t);
251 251
252 252 extern int zpool_vdev_fault(zpool_handle_t *, uint64_t, vdev_aux_t);
253 253 extern int zpool_vdev_degrade(zpool_handle_t *, uint64_t, vdev_aux_t);
254 254 extern int zpool_vdev_clear(zpool_handle_t *, uint64_t);
255 255
256 256 extern nvlist_t *zpool_find_vdev(zpool_handle_t *, const char *, boolean_t *,
257 257 boolean_t *, boolean_t *);
258 258 extern nvlist_t *zpool_find_vdev_by_physpath(zpool_handle_t *, const char *,
259 259 boolean_t *, boolean_t *, boolean_t *);
260 260 extern int zpool_label_disk(libzfs_handle_t *, zpool_handle_t *, char *);
261 261
262 262 /*
263 263 * Functions to manage pool properties
264 264 */
265 265 extern int zpool_set_prop(zpool_handle_t *, const char *, const char *);
266 266 extern int zpool_get_prop(zpool_handle_t *, zpool_prop_t, char *,
267 267 size_t proplen, zprop_source_t *);
268 268 extern uint64_t zpool_get_prop_int(zpool_handle_t *, zpool_prop_t,
269 269 zprop_source_t *);
270 270
271 271 extern const char *zpool_prop_to_name(zpool_prop_t);
272 272 extern const char *zpool_prop_values(zpool_prop_t);
273 273
274 274 /*
275 275 * Pool health statistics.
276 276 */
277 277 typedef enum {
278 278 /*
279 279 * The following correspond to faults as defined in the (fault.fs.zfs.*)
280 280 * event namespace. Each is associated with a corresponding message ID.
281 281 */
282 282 ZPOOL_STATUS_CORRUPT_CACHE, /* corrupt /kernel/drv/zpool.cache */
283 283 ZPOOL_STATUS_MISSING_DEV_R, /* missing device with replicas */
284 284 ZPOOL_STATUS_MISSING_DEV_NR, /* missing device with no replicas */
285 285 ZPOOL_STATUS_CORRUPT_LABEL_R, /* bad device label with replicas */
286 286 ZPOOL_STATUS_CORRUPT_LABEL_NR, /* bad device label with no replicas */
287 287 ZPOOL_STATUS_BAD_GUID_SUM, /* sum of device guids didn't match */
288 288 ZPOOL_STATUS_CORRUPT_POOL, /* pool metadata is corrupted */
289 289 ZPOOL_STATUS_CORRUPT_DATA, /* data errors in user (meta)data */
290 290 ZPOOL_STATUS_FAILING_DEV, /* device experiencing errors */
291 291 ZPOOL_STATUS_VERSION_NEWER, /* newer on-disk version */
292 292 ZPOOL_STATUS_HOSTID_MISMATCH, /* last accessed by another system */
293 293 ZPOOL_STATUS_IO_FAILURE_WAIT, /* failed I/O, failmode 'wait' */
294 294 ZPOOL_STATUS_IO_FAILURE_CONTINUE, /* failed I/O, failmode 'continue' */
295 295 ZPOOL_STATUS_BAD_LOG, /* cannot read log chain(s) */
296 296
297 297 /*
298 298 * If the pool has unsupported features but can still be opened in
299 299 * read-only mode, its status is ZPOOL_STATUS_UNSUP_FEAT_WRITE. If the
300 300 * pool has unsupported features but cannot be opened at all, its
301 301 * status is ZPOOL_STATUS_UNSUP_FEAT_READ.
302 302 */
303 303 ZPOOL_STATUS_UNSUP_FEAT_READ, /* unsupported features for read */
304 304 ZPOOL_STATUS_UNSUP_FEAT_WRITE, /* unsupported features for write */
305 305
306 306 /*
307 307 * These faults have no corresponding message ID. At the time we are
308 308 * checking the status, the original reason for the FMA fault (I/O or
309 309 * checksum errors) has been lost.
310 310 */
311 311 ZPOOL_STATUS_FAULTED_DEV_R, /* faulted device with replicas */
312 312 ZPOOL_STATUS_FAULTED_DEV_NR, /* faulted device with no replicas */
313 313
314 314 /*
315 315 * The following are not faults per se, but still an error possibly
316 316 * requiring administrative attention. There is no corresponding
317 317 * message ID.
318 318 */
319 319 ZPOOL_STATUS_VERSION_OLDER, /* older legacy on-disk version */
320 320 ZPOOL_STATUS_FEAT_DISABLED, /* supported features are disabled */
321 321 ZPOOL_STATUS_RESILVERING, /* device being resilvered */
322 322 ZPOOL_STATUS_OFFLINE_DEV, /* device online */
323 323 ZPOOL_STATUS_REMOVED_DEV, /* removed device */
324 324
325 325 /*
326 326 * Finally, the following indicates a healthy pool.
327 327 */
328 328 ZPOOL_STATUS_OK
329 329 } zpool_status_t;
330 330
331 331 extern zpool_status_t zpool_get_status(zpool_handle_t *, char **);
332 332 extern zpool_status_t zpool_import_status(nvlist_t *, char **);
333 333 extern void zpool_dump_ddt(const ddt_stat_t *dds, const ddt_histogram_t *ddh);
334 334
335 335 /*
336 336 * Statistics and configuration functions.
337 337 */
338 338 extern nvlist_t *zpool_get_config(zpool_handle_t *, nvlist_t **);
339 339 extern nvlist_t *zpool_get_features(zpool_handle_t *);
340 340 extern int zpool_refresh_stats(zpool_handle_t *, boolean_t *);
341 341 extern int zpool_get_errlog(zpool_handle_t *, nvlist_t **);
342 342
343 343 /*
344 344 * Import and export functions
345 345 */
346 346 extern int zpool_export(zpool_handle_t *, boolean_t, const char *);
347 347 extern int zpool_export_force(zpool_handle_t *, const char *);
348 348 extern int zpool_import(libzfs_handle_t *, nvlist_t *, const char *,
349 349 char *altroot);
350 350 extern int zpool_import_props(libzfs_handle_t *, nvlist_t *, const char *,
351 351 nvlist_t *, int);
352 352 extern void zpool_print_unsup_feat(nvlist_t *config);
353 353
354 354 /*
355 355 * Search for pools to import
356 356 */
357 357
358 358 typedef struct importargs {
359 359 char **path; /* a list of paths to search */
360 360 int paths; /* number of paths to search */
361 361 char *poolname; /* name of a pool to find */
362 362 uint64_t guid; /* guid of a pool to find */
363 363 char *cachefile; /* cachefile to use for import */
364 364 int can_be_active : 1; /* can the pool be active? */
365 365 int unique : 1; /* does 'poolname' already exist? */
366 366 int exists : 1; /* set on return if pool already exists */
367 367 } importargs_t;
368 368
369 369 extern nvlist_t *zpool_search_import(libzfs_handle_t *, importargs_t *);
370 370
371 371 /* legacy pool search routines */
372 372 extern nvlist_t *zpool_find_import(libzfs_handle_t *, int, char **);
373 373 extern nvlist_t *zpool_find_import_cached(libzfs_handle_t *, const char *,
374 374 char *, uint64_t);
375 375
376 376 /*
377 377 * Miscellaneous pool functions
378 378 */
379 379 struct zfs_cmd;
380 380
381 381 extern const char *zfs_history_event_names[];
382 382
383 383 extern char *zpool_vdev_name(libzfs_handle_t *, zpool_handle_t *, nvlist_t *,
384 384 boolean_t verbose);
385 385 extern int zpool_upgrade(zpool_handle_t *, uint64_t);
386 386 extern int zpool_get_history(zpool_handle_t *, nvlist_t **);
387 387 extern int zpool_history_unpack(char *, uint64_t, uint64_t *,
388 388 nvlist_t ***, uint_t *);
389 389 extern void zpool_obj_to_path(zpool_handle_t *, uint64_t, uint64_t, char *,
390 390 size_t len);
391 391 extern int zfs_ioctl(libzfs_handle_t *, int, struct zfs_cmd *);
392 392 extern int zpool_get_physpath(zpool_handle_t *, char *, size_t);
393 393 extern void zpool_explain_recover(libzfs_handle_t *, const char *, int,
394 394 nvlist_t *);
395 395
396 396 /*
397 397 * Basic handle manipulations. These functions do not create or destroy the
398 398 * underlying datasets, only the references to them.
399 399 */
400 400 extern zfs_handle_t *zfs_open(libzfs_handle_t *, const char *, int);
401 401 extern zfs_handle_t *zfs_handle_dup(zfs_handle_t *);
402 402 extern void zfs_close(zfs_handle_t *);
403 403 extern zfs_type_t zfs_get_type(const zfs_handle_t *);
404 404 extern const char *zfs_get_name(const zfs_handle_t *);
405 405 extern zpool_handle_t *zfs_get_pool_handle(const zfs_handle_t *);
406 406
407 407 /*
408 408 * Property management functions. Some functions are shared with the kernel,
409 409 * and are found in sys/fs/zfs.h.
410 410 */
411 411
412 412 /*
413 413 * zfs dataset property management
414 414 */
415 415 extern const char *zfs_prop_default_string(zfs_prop_t);
416 416 extern uint64_t zfs_prop_default_numeric(zfs_prop_t);
417 417 extern const char *zfs_prop_column_name(zfs_prop_t);
418 418 extern boolean_t zfs_prop_align_right(zfs_prop_t);
419 419
420 420 extern nvlist_t *zfs_valid_proplist(libzfs_handle_t *, zfs_type_t,
421 421 nvlist_t *, uint64_t, zfs_handle_t *, const char *);
422 422
423 423 extern const char *zfs_prop_to_name(zfs_prop_t);
424 424 extern int zfs_prop_set(zfs_handle_t *, const char *, const char *);
425 425 extern int zfs_prop_get(zfs_handle_t *, zfs_prop_t, char *, size_t,
426 426 zprop_source_t *, char *, size_t, boolean_t);
427 427 extern int zfs_prop_get_recvd(zfs_handle_t *, const char *, char *, size_t,
428 428 boolean_t);
429 429 extern int zfs_prop_get_numeric(zfs_handle_t *, zfs_prop_t, uint64_t *,
430 430 zprop_source_t *, char *, size_t);
431 431 extern int zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname,
432 432 uint64_t *propvalue);
433 433 extern int zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname,
434 434 char *propbuf, int proplen, boolean_t literal);
435 435 extern int zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname,
436 436 uint64_t *propvalue);
437 437 extern int zfs_prop_get_written(zfs_handle_t *zhp, const char *propname,
438 438 char *propbuf, int proplen, boolean_t literal);
439 439 extern int zfs_prop_get_feature(zfs_handle_t *zhp, const char *propname,
440 440 char *buf, size_t len);
441 441 extern uint64_t zfs_prop_get_int(zfs_handle_t *, zfs_prop_t);
442 442 extern int zfs_prop_inherit(zfs_handle_t *, const char *, boolean_t);
443 443 extern const char *zfs_prop_values(zfs_prop_t);
444 444 extern int zfs_prop_is_string(zfs_prop_t prop);
445 445 extern nvlist_t *zfs_get_user_props(zfs_handle_t *);
446 446 extern nvlist_t *zfs_get_recvd_props(zfs_handle_t *);
447 447 extern nvlist_t *zfs_get_clones_nvl(zfs_handle_t *);
448 448
449 449
450 450 typedef struct zprop_list {
451 451 int pl_prop;
452 452 char *pl_user_prop;
453 453 struct zprop_list *pl_next;
454 454 boolean_t pl_all;
455 455 size_t pl_width;
456 456 size_t pl_recvd_width;
457 457 boolean_t pl_fixed;
458 458 } zprop_list_t;
459 459
460 460 extern int zfs_expand_proplist(zfs_handle_t *, zprop_list_t **, boolean_t);
461 461 extern void zfs_prune_proplist(zfs_handle_t *, uint8_t *);
462 462
463 463 #define ZFS_MOUNTPOINT_NONE "none"
464 464 #define ZFS_MOUNTPOINT_LEGACY "legacy"
465 465
466 466 #define ZFS_FEATURE_DISABLED "disabled"
467 467 #define ZFS_FEATURE_ENABLED "enabled"
468 468 #define ZFS_FEATURE_ACTIVE "active"
469 469
470 470 #define ZFS_UNSUPPORTED_INACTIVE "inactive"
471 471 #define ZFS_UNSUPPORTED_READONLY "readonly"
472 472
473 473 /*
474 474 * zpool property management
475 475 */
476 476 extern int zpool_expand_proplist(zpool_handle_t *, zprop_list_t **);
477 477 extern int zpool_prop_get_feature(zpool_handle_t *, const char *, char *,
478 478 size_t);
479 479 extern const char *zpool_prop_default_string(zpool_prop_t);
480 480 extern uint64_t zpool_prop_default_numeric(zpool_prop_t);
481 481 extern const char *zpool_prop_column_name(zpool_prop_t);
482 482 extern boolean_t zpool_prop_align_right(zpool_prop_t);
483 483
484 484 /*
485 485 * Functions shared by zfs and zpool property management.
486 486 */
487 487 extern int zprop_iter(zprop_func func, void *cb, boolean_t show_all,
488 488 boolean_t ordered, zfs_type_t type);
489 489 extern int zprop_get_list(libzfs_handle_t *, char *, zprop_list_t **,
490 490 zfs_type_t);
491 491 extern void zprop_free_list(zprop_list_t *);
492 492
493 493 #define ZFS_GET_NCOLS 5
494 494
495 495 typedef enum {
496 496 GET_COL_NONE,
497 497 GET_COL_NAME,
498 498 GET_COL_PROPERTY,
499 499 GET_COL_VALUE,
500 500 GET_COL_RECVD,
501 501 GET_COL_SOURCE
502 502 } zfs_get_column_t;
503 503
504 504 /*
505 505 * Functions for printing zfs or zpool properties
506 506 */
507 507 typedef struct zprop_get_cbdata {
508 508 int cb_sources;
509 509 zfs_get_column_t cb_columns[ZFS_GET_NCOLS];
510 510 int cb_colwidths[ZFS_GET_NCOLS + 1];
511 511 boolean_t cb_scripted;
512 512 boolean_t cb_literal;
513 513 boolean_t cb_first;
514 514 zprop_list_t *cb_proplist;
515 515 zfs_type_t cb_type;
516 516 } zprop_get_cbdata_t;
517 517
518 518 void zprop_print_one_property(const char *, zprop_get_cbdata_t *,
519 519 const char *, const char *, zprop_source_t, const char *,
520 520 const char *);
521 521
522 522 /*
523 523 * Iterator functions.
524 524 */
525 525 typedef int (*zfs_iter_f)(zfs_handle_t *, void *);
526 526 extern int zfs_iter_root(libzfs_handle_t *, zfs_iter_f, void *);
527 527 extern int zfs_iter_children(zfs_handle_t *, zfs_iter_f, void *);
528 528 extern int zfs_iter_dependents(zfs_handle_t *, boolean_t, zfs_iter_f, void *);
529 529 extern int zfs_iter_filesystems(zfs_handle_t *, zfs_iter_f, void *);
530 530 extern int zfs_iter_snapshots(zfs_handle_t *, zfs_iter_f, void *);
531 531 extern int zfs_iter_snapshots_sorted(zfs_handle_t *, zfs_iter_f, void *);
532 532 extern int zfs_iter_snapspec(zfs_handle_t *, const char *, zfs_iter_f, void *);
533 533
534 534 typedef struct get_all_cb {
535 535 zfs_handle_t **cb_handles;
536 536 size_t cb_alloc;
537 537 size_t cb_used;
538 538 boolean_t cb_verbose;
539 539 int (*cb_getone)(zfs_handle_t *, void *);
540 540 } get_all_cb_t;
541 541
542 542 void libzfs_add_handle(get_all_cb_t *, zfs_handle_t *);
543 543 int libzfs_dataset_cmp(const void *, const void *);
544 544
545 545 /*
546 546 * Functions to create and destroy datasets.
547 547 */
548 548 extern int zfs_create(libzfs_handle_t *, const char *, zfs_type_t,
549 549 nvlist_t *);
550 550 extern int zfs_create_ancestors(libzfs_handle_t *, const char *);
551 551 extern int zfs_destroy(zfs_handle_t *, boolean_t);
552 552 extern int zfs_destroy_snaps(zfs_handle_t *, char *, boolean_t);
553 553 extern int zfs_destroy_snaps_nvl(zfs_handle_t *, nvlist_t *, boolean_t);
554 554 extern int zfs_clone(zfs_handle_t *, const char *, nvlist_t *);
555 555 extern int zfs_snapshot(libzfs_handle_t *, const char *, boolean_t, nvlist_t *);
556 556 extern int zfs_snapshot_nvl(libzfs_handle_t *hdl, nvlist_t *snaps,
557 557 nvlist_t *props);
558 558 extern int zfs_rollback(zfs_handle_t *, zfs_handle_t *, boolean_t);
559 559 extern int zfs_rename(zfs_handle_t *, const char *, boolean_t, boolean_t);
560 560
561 561 typedef struct sendflags {
562 562 /* print informational messages (ie, -v was specified) */
563 563 boolean_t verbose;
564 564
565 565 /* recursive send (ie, -R) */
566 566 boolean_t replicate;
567 567
568 568 /* for incrementals, do all intermediate snapshots */
569 569 boolean_t doall;
570 570
571 571 /* if dataset is a clone, do incremental from its origin */
572 572 boolean_t fromorigin;
573 573
574 574 /* do deduplication */
575 575 boolean_t dedup;
576 576
577 577 /* send properties (ie, -p) */
|
↓ open down ↓ |
577 lines elided |
↑ open up ↑ |
578 578 boolean_t props;
579 579
580 580 /* do not send (no-op, ie. -n) */
581 581 boolean_t dryrun;
582 582
583 583 /* parsable verbose output (ie. -P) */
584 584 boolean_t parsable;
585 585
586 586 /* show progress (ie. -v) */
587 587 boolean_t progress;
588 +
589 + /* send output as FAR-stream */
590 + boolean_t far;
588 591 } sendflags_t;
589 592
590 593 typedef boolean_t (snapfilter_cb_t)(zfs_handle_t *, void *);
591 594
592 595 extern int zfs_send(zfs_handle_t *, const char *, const char *,
593 596 sendflags_t *, int, snapfilter_cb_t, void *, nvlist_t **);
594 597
595 598 extern int zfs_promote(zfs_handle_t *);
596 599 extern int zfs_hold(zfs_handle_t *, const char *, const char *, boolean_t,
597 600 boolean_t, boolean_t, int, uint64_t, uint64_t);
598 601 extern int zfs_release(zfs_handle_t *, const char *, const char *, boolean_t);
599 602 extern int zfs_get_holds(zfs_handle_t *, nvlist_t **);
600 603 extern uint64_t zvol_volsize_to_reservation(uint64_t, nvlist_t *);
601 604
602 605 typedef int (*zfs_userspace_cb_t)(void *arg, const char *domain,
603 606 uid_t rid, uint64_t space);
604 607
605 608 extern int zfs_userspace(zfs_handle_t *, zfs_userquota_prop_t,
606 609 zfs_userspace_cb_t, void *);
607 610
608 611 extern int zfs_get_fsacl(zfs_handle_t *, nvlist_t **);
609 612 extern int zfs_set_fsacl(zfs_handle_t *, boolean_t, nvlist_t *);
610 613
611 614 typedef struct recvflags {
612 615 /* print informational messages (ie, -v was specified) */
613 616 boolean_t verbose;
614 617
615 618 /* the destination is a prefix, not the exact fs (ie, -d) */
616 619 boolean_t isprefix;
617 620
618 621 /*
619 622 * Only the tail of the sent snapshot path is appended to the
620 623 * destination to determine the received snapshot name (ie, -e).
621 624 */
622 625 boolean_t istail;
623 626
624 627 /* do not actually do the recv, just check if it would work (ie, -n) */
625 628 boolean_t dryrun;
626 629
627 630 /* rollback/destroy filesystems as necessary (eg, -F) */
628 631 boolean_t force;
629 632
630 633 /* set "canmount=off" on all modified filesystems */
631 634 boolean_t canmountoff;
632 635
633 636 /* byteswap flag is used internally; callers need not specify */
634 637 boolean_t byteswap;
635 638
636 639 /* do not mount file systems as they are extracted (private) */
637 640 boolean_t nomount;
638 641 } recvflags_t;
639 642
640 643 extern int zfs_receive(libzfs_handle_t *, const char *, recvflags_t *,
641 644 int, avl_tree_t *);
642 645
643 646 typedef enum diff_flags {
644 647 ZFS_DIFF_PARSEABLE = 0x1,
645 648 ZFS_DIFF_TIMESTAMP = 0x2,
646 649 ZFS_DIFF_CLASSIFY = 0x4
647 650 } diff_flags_t;
648 651
649 652 extern int zfs_show_diffs(zfs_handle_t *, int, const char *, const char *,
650 653 int);
651 654
652 655 /*
653 656 * Miscellaneous functions.
654 657 */
655 658 extern const char *zfs_type_to_name(zfs_type_t);
656 659 extern void zfs_refresh_properties(zfs_handle_t *);
657 660 extern int zfs_name_valid(const char *, zfs_type_t);
658 661 extern zfs_handle_t *zfs_path_to_zhandle(libzfs_handle_t *, char *, zfs_type_t);
659 662 extern boolean_t zfs_dataset_exists(libzfs_handle_t *, const char *,
660 663 zfs_type_t);
661 664 extern int zfs_spa_version(zfs_handle_t *, int *);
662 665
663 666 /*
664 667 * Mount support functions.
665 668 */
666 669 extern boolean_t is_mounted(libzfs_handle_t *, const char *special, char **);
667 670 extern boolean_t zfs_is_mounted(zfs_handle_t *, char **);
668 671 extern int zfs_mount(zfs_handle_t *, const char *, int);
669 672 extern int zfs_unmount(zfs_handle_t *, const char *, int);
670 673 extern int zfs_unmountall(zfs_handle_t *, int);
671 674
672 675 /*
673 676 * Share support functions.
674 677 */
675 678 extern boolean_t zfs_is_shared(zfs_handle_t *);
676 679 extern int zfs_share(zfs_handle_t *);
677 680 extern int zfs_unshare(zfs_handle_t *);
678 681
679 682 /*
680 683 * Protocol-specific share support functions.
681 684 */
682 685 extern boolean_t zfs_is_shared_nfs(zfs_handle_t *, char **);
683 686 extern boolean_t zfs_is_shared_smb(zfs_handle_t *, char **);
684 687 extern int zfs_share_nfs(zfs_handle_t *);
685 688 extern int zfs_share_smb(zfs_handle_t *);
686 689 extern int zfs_shareall(zfs_handle_t *);
687 690 extern int zfs_unshare_nfs(zfs_handle_t *, const char *);
688 691 extern int zfs_unshare_smb(zfs_handle_t *, const char *);
689 692 extern int zfs_unshareall_nfs(zfs_handle_t *);
690 693 extern int zfs_unshareall_smb(zfs_handle_t *);
691 694 extern int zfs_unshareall_bypath(zfs_handle_t *, const char *);
692 695 extern int zfs_unshareall(zfs_handle_t *);
693 696 extern int zfs_deleg_share_nfs(libzfs_handle_t *, char *, char *, char *,
694 697 void *, void *, int, zfs_share_op_t);
695 698
696 699 /*
697 700 * When dealing with nvlists, verify() is extremely useful
698 701 */
699 702 #ifdef NDEBUG
700 703 #define verify(EX) ((void)(EX))
701 704 #else
702 705 #define verify(EX) assert(EX)
703 706 #endif
704 707
705 708 /*
706 709 * Utility function to convert a number to a human-readable form.
707 710 */
708 711 extern void zfs_nicenum(uint64_t, char *, size_t);
709 712 extern int zfs_nicestrtonum(libzfs_handle_t *, const char *, uint64_t *);
710 713
711 714 /*
712 715 * Given a device or file, determine if it is part of a pool.
713 716 */
714 717 extern int zpool_in_use(libzfs_handle_t *, int, pool_state_t *, char **,
715 718 boolean_t *);
716 719
717 720 /*
718 721 * Label manipulation.
719 722 */
720 723 extern int zpool_read_label(int, nvlist_t **);
721 724 extern int zpool_clear_label(int);
722 725
723 726 /* is this zvol valid for use as a dump device? */
724 727 extern int zvol_check_dump_config(char *);
725 728
726 729 /*
727 730 * Management interfaces for SMB ACL files
728 731 */
729 732
730 733 int zfs_smb_acl_add(libzfs_handle_t *, char *, char *, char *);
731 734 int zfs_smb_acl_remove(libzfs_handle_t *, char *, char *, char *);
732 735 int zfs_smb_acl_purge(libzfs_handle_t *, char *, char *);
733 736 int zfs_smb_acl_rename(libzfs_handle_t *, char *, char *, char *, char *);
734 737
735 738 /*
736 739 * Enable and disable datasets within a pool by mounting/unmounting and
737 740 * sharing/unsharing them.
738 741 */
739 742 extern int zpool_enable_datasets(zpool_handle_t *, const char *, int);
740 743 extern int zpool_disable_datasets(zpool_handle_t *, boolean_t);
741 744
742 745 /*
743 746 * Mappings between vdev and FRU.
744 747 */
745 748 extern void libzfs_fru_refresh(libzfs_handle_t *);
746 749 extern const char *libzfs_fru_lookup(libzfs_handle_t *, const char *);
747 750 extern const char *libzfs_fru_devpath(libzfs_handle_t *, const char *);
748 751 extern boolean_t libzfs_fru_compare(libzfs_handle_t *, const char *,
749 752 const char *);
750 753 extern boolean_t libzfs_fru_notself(libzfs_handle_t *, const char *);
751 754 extern int zpool_fru_set(zpool_handle_t *, uint64_t, const char *);
752 755
753 756 #ifdef __cplusplus
754 757 }
755 758 #endif
756 759
757 760 #endif /* _LIBZFS_H */
|
↓ open down ↓ |
160 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX