libzfs.h revision 332525
1234370Sjasone/* 2234370Sjasone * CDDL HEADER START 3234370Sjasone * 4234370Sjasone * The contents of this file are subject to the terms of the 5234370Sjasone * Common Development and Distribution License (the "License"). 6234370Sjasone * You may not use this file except in compliance with the License. 7234543Sjasone * 8234370Sjasone * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9234370Sjasone * or http://www.opensolaris.org/os/licensing. 10234370Sjasone * See the License for the specific language governing permissions 11234370Sjasone * and limitations under the License. 12234370Sjasone * 13234370Sjasone * When distributing Covered Code, include this CDDL HEADER in each 14234370Sjasone * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15234370Sjasone * If applicable, add the following below this CDDL HEADER, with the 16234370Sjasone * fields enclosed by brackets "[]" replaced with your own identifying 17234370Sjasone * information: Portions Copyright [yyyy] [name of copyright owner] 18234370Sjasone * 19234370Sjasone * CDDL HEADER END 20234370Sjasone */ 21234370Sjasone 22234370Sjasone/* 23234370Sjasone * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24234370Sjasone * Copyright (c) 2011 Pawel Jakub Dawidek. All rights reserved. 25234370Sjasone * Copyright (c) 2011, 2017 by Delphix. All rights reserved. 26234370Sjasone * Copyright (c) 2012, Joyent, Inc. All rights reserved. 27234370Sjasone * Copyright (c) 2012 Martin Matuska <mm@FreeBSD.org>. All rights reserved. 28234370Sjasone * Copyright (c) 2013 Steven Hartland. All rights reserved. 29234370Sjasone * Copyright (c) 2014 Integros [integros.com] 30234370Sjasone * Copyright 2016 Nexenta Systems, Inc. 31234370Sjasone * Copyright (c) 2017 Datto Inc. 32234370Sjasone */ 33234370Sjasone 34234370Sjasone#ifndef _LIBZFS_H 35234370Sjasone#define _LIBZFS_H 36234370Sjasone 37234370Sjasone#include <assert.h> 38234370Sjasone#include <libnvpair.h> 39234370Sjasone#include <sys/mnttab.h> 40234370Sjasone#include <sys/param.h> 41234370Sjasone#include <sys/types.h> 42234370Sjasone#include <sys/varargs.h> 43234370Sjasone#include <sys/fs/zfs.h> 44234370Sjasone#include <sys/avl.h> 45234370Sjasone#include <sys/zfs_ioctl.h> 46234370Sjasone#include <libzfs_core.h> 47234370Sjasone 48234370Sjasone#ifdef __cplusplus 49234370Sjasoneextern "C" { 50234370Sjasone#endif 51234370Sjasone 52234370Sjasone/* 53234370Sjasone * Miscellaneous ZFS constants 54234370Sjasone */ 55234370Sjasone#define ZFS_MAXPROPLEN MAXPATHLEN 56234370Sjasone#define ZPOOL_MAXPROPLEN MAXPATHLEN 57234370Sjasone 58234370Sjasone/* 59234370Sjasone * libzfs errors 60234370Sjasone */ 61234370Sjasonetypedef enum zfs_error { 62234370Sjasone EZFS_SUCCESS = 0, /* no error -- success */ 63234370Sjasone EZFS_NOMEM = 2000, /* out of memory */ 64234370Sjasone EZFS_BADPROP, /* invalid property value */ 65234370Sjasone EZFS_PROPREADONLY, /* cannot set readonly property */ 66234370Sjasone EZFS_PROPTYPE, /* property does not apply to dataset type */ 67234370Sjasone EZFS_PROPNONINHERIT, /* property is not inheritable */ 68234370Sjasone EZFS_PROPSPACE, /* bad quota or reservation */ 69234370Sjasone EZFS_BADTYPE, /* dataset is not of appropriate type */ 70234370Sjasone EZFS_BUSY, /* pool or dataset is busy */ 71234370Sjasone EZFS_EXISTS, /* pool or dataset already exists */ 72234370Sjasone EZFS_NOENT, /* no such pool or dataset */ 73234370Sjasone EZFS_BADSTREAM, /* bad backup stream */ 74234370Sjasone EZFS_DSREADONLY, /* dataset is readonly */ 75234370Sjasone EZFS_VOLTOOBIG, /* volume is too large for 32-bit system */ 76234370Sjasone EZFS_INVALIDNAME, /* invalid dataset name */ 77234370Sjasone EZFS_BADRESTORE, /* unable to restore to destination */ 78234370Sjasone EZFS_BADBACKUP, /* backup failed */ 79234370Sjasone EZFS_BADTARGET, /* bad attach/detach/replace target */ 80234370Sjasone EZFS_NODEVICE, /* no such device in pool */ 81234370Sjasone EZFS_BADDEV, /* invalid device to add */ 82234370Sjasone EZFS_NOREPLICAS, /* no valid replicas */ 83234370Sjasone EZFS_RESILVERING, /* currently resilvering */ 84234370Sjasone EZFS_BADVERSION, /* unsupported version */ 85234370Sjasone EZFS_POOLUNAVAIL, /* pool is currently unavailable */ 86234370Sjasone EZFS_DEVOVERFLOW, /* too many devices in one vdev */ 87234370Sjasone EZFS_BADPATH, /* must be an absolute path */ 88234370Sjasone EZFS_CROSSTARGET, /* rename or clone across pool or dataset */ 89234370Sjasone EZFS_ZONED, /* used improperly in local zone */ 90234370Sjasone EZFS_MOUNTFAILED, /* failed to mount dataset */ 91234370Sjasone EZFS_UMOUNTFAILED, /* failed to unmount dataset */ 92234370Sjasone EZFS_UNSHARENFSFAILED, /* unshare(1M) failed */ 93234370Sjasone EZFS_SHARENFSFAILED, /* share(1M) failed */ 94234370Sjasone EZFS_PERM, /* permission denied */ 95234370Sjasone EZFS_NOSPC, /* out of space */ 96234370Sjasone EZFS_FAULT, /* bad address */ 97234370Sjasone EZFS_IO, /* I/O error */ 98234370Sjasone EZFS_INTR, /* signal received */ 99234370Sjasone EZFS_ISSPARE, /* device is a hot spare */ 100234370Sjasone EZFS_INVALCONFIG, /* invalid vdev configuration */ 101234370Sjasone EZFS_RECURSIVE, /* recursive dependency */ 102234370Sjasone EZFS_NOHISTORY, /* no history object */ 103234370Sjasone EZFS_POOLPROPS, /* couldn't retrieve pool props */ 104234370Sjasone EZFS_POOL_NOTSUP, /* ops not supported for this type of pool */ 105234370Sjasone EZFS_POOL_INVALARG, /* invalid argument for this pool operation */ 106234370Sjasone EZFS_NAMETOOLONG, /* dataset name is too long */ 107234370Sjasone EZFS_OPENFAILED, /* open of device failed */ 108234370Sjasone EZFS_NOCAP, /* couldn't get capacity */ 109234543Sjasone EZFS_LABELFAILED, /* write of label failed */ 110234370Sjasone EZFS_BADWHO, /* invalid permission who */ 111234370Sjasone EZFS_BADPERM, /* invalid permission */ 112234370Sjasone EZFS_BADPERMSET, /* invalid permission set name */ 113234370Sjasone EZFS_NODELEGATION, /* delegated administration is disabled */ 114234569Sjasone EZFS_UNSHARESMBFAILED, /* failed to unshare over smb */ 115234370Sjasone EZFS_SHARESMBFAILED, /* failed to share over smb */ 116234370Sjasone EZFS_BADCACHE, /* bad cache file */ 117234370Sjasone EZFS_ISL2CACHE, /* device is for the level 2 ARC */ 118234370Sjasone EZFS_VDEVNOTSUP, /* unsupported vdev type */ 119234370Sjasone EZFS_NOTSUP, /* ops not supported on this dataset */ 120234370Sjasone EZFS_ACTIVE_SPARE, /* pool has active shared spare devices */ 121234370Sjasone EZFS_UNPLAYED_LOGS, /* log device has unplayed logs */ 122234370Sjasone EZFS_REFTAG_RELE, /* snapshot release: tag not found */ 123234370Sjasone EZFS_REFTAG_HOLD, /* snapshot hold: tag already exists */ 124234543Sjasone EZFS_TAGTOOLONG, /* snapshot hold/rele: tag too long */ 125234370Sjasone EZFS_PIPEFAILED, /* pipe create failed */ 126234370Sjasone EZFS_THREADCREATEFAILED, /* thread create failed */ 127234370Sjasone EZFS_POSTSPLIT_ONLINE, /* onlining a disk after splitting it */ 128234370Sjasone EZFS_SCRUBBING, /* currently scrubbing */ 129234370Sjasone EZFS_NO_SCRUB, /* no active scrub */ 130234370Sjasone EZFS_DIFF, /* general failure of zfs diff */ 131234370Sjasone EZFS_DIFFDATA, /* bad zfs diff data */ 132234370Sjasone EZFS_POOLREADONLY, /* pool is in read-only mode */ 133234370Sjasone EZFS_SCRUB_PAUSED, /* scrub currently paused */ 134234370Sjasone EZFS_NO_PENDING, /* cannot cancel, no operation is pending */ 135234370Sjasone EZFS_UNKNOWN 136234370Sjasone} zfs_error_t; 137234370Sjasone 138234370Sjasone/* 139234370Sjasone * UEFI boot support parameters. When creating whole disk boot pool, 140234370Sjasone * zpool create should allow to create EFI System partition for UEFI boot 141234370Sjasone * program. In case of BIOS, the EFI System partition is not used 142234370Sjasone * even if it does exist. 143234370Sjasone */ 144234370Sjasonetypedef enum zpool_boot_label { 145234370Sjasone ZPOOL_NO_BOOT_LABEL = 0, 146234370Sjasone ZPOOL_CREATE_BOOT_LABEL, 147234370Sjasone ZPOOL_COPY_BOOT_LABEL 148234370Sjasone} zpool_boot_label_t; 149234370Sjasone 150234370Sjasone/* 151234370Sjasone * The following data structures are all part 152234370Sjasone * of the zfs_allow_t data structure which is 153234370Sjasone * used for printing 'allow' permissions. 154234370Sjasone * It is a linked list of zfs_allow_t's which 155234370Sjasone * then contain avl tree's for user/group/sets/... 156234370Sjasone * and each one of the entries in those trees have 157234370Sjasone * avl tree's for the permissions they belong to and 158234370Sjasone * whether they are local,descendent or local+descendent 159234370Sjasone * permissions. The AVL trees are used primarily for 160234370Sjasone * sorting purposes, but also so that we can quickly find 161234370Sjasone * a given user and or permission. 162234370Sjasone */ 163234370Sjasonetypedef struct zfs_perm_node { 164234370Sjasone avl_node_t z_node; 165234370Sjasone char z_pname[MAXPATHLEN]; 166234370Sjasone} zfs_perm_node_t; 167234370Sjasone 168234370Sjasonetypedef struct zfs_allow_node { 169234370Sjasone avl_node_t z_node; 170234370Sjasone char z_key[MAXPATHLEN]; /* name, such as joe */ 171234370Sjasone avl_tree_t z_localdescend; /* local+descendent perms */ 172234370Sjasone avl_tree_t z_local; /* local permissions */ 173234370Sjasone avl_tree_t z_descend; /* descendent permissions */ 174234370Sjasone} zfs_allow_node_t; 175234370Sjasone 176234370Sjasonetypedef struct zfs_allow { 177234370Sjasone struct zfs_allow *z_next; 178234370Sjasone char z_setpoint[MAXPATHLEN]; 179234370Sjasone avl_tree_t z_sets; 180234370Sjasone avl_tree_t z_crperms; 181234370Sjasone avl_tree_t z_user; 182234370Sjasone avl_tree_t z_group; 183234370Sjasone avl_tree_t z_everyone; 184234370Sjasone} zfs_allow_t; 185234370Sjasone 186234370Sjasone/* 187234370Sjasone * Basic handle types 188234370Sjasone */ 189234370Sjasonetypedef struct zfs_handle zfs_handle_t; 190234370Sjasonetypedef struct zpool_handle zpool_handle_t; 191234370Sjasonetypedef struct libzfs_handle libzfs_handle_t; 192234370Sjasone 193234370Sjasone/* 194234370Sjasone * Library initialization 195234370Sjasone */ 196234370Sjasoneextern libzfs_handle_t *libzfs_init(void); 197234370Sjasoneextern void libzfs_fini(libzfs_handle_t *); 198234370Sjasone 199234370Sjasoneextern libzfs_handle_t *zpool_get_handle(zpool_handle_t *); 200234370Sjasoneextern libzfs_handle_t *zfs_get_handle(zfs_handle_t *); 201234370Sjasone 202234370Sjasoneextern void libzfs_print_on_error(libzfs_handle_t *, boolean_t); 203234370Sjasone 204234370Sjasoneextern void zfs_save_arguments(int argc, char **, char *, int); 205234370Sjasoneextern int zpool_log_history(libzfs_handle_t *, const char *); 206234370Sjasone 207234370Sjasoneextern int libzfs_errno(libzfs_handle_t *); 208234370Sjasoneextern const char *libzfs_error_action(libzfs_handle_t *); 209234370Sjasoneextern const char *libzfs_error_description(libzfs_handle_t *); 210234370Sjasoneextern int zfs_standard_error(libzfs_handle_t *, int, const char *); 211234370Sjasoneextern void libzfs_mnttab_init(libzfs_handle_t *); 212234370Sjasoneextern void libzfs_mnttab_fini(libzfs_handle_t *); 213234370Sjasoneextern void libzfs_mnttab_cache(libzfs_handle_t *, boolean_t); 214234370Sjasoneextern int libzfs_mnttab_find(libzfs_handle_t *, const char *, 215234543Sjasone struct mnttab *); 216234370Sjasoneextern void libzfs_mnttab_add(libzfs_handle_t *, const char *, 217234370Sjasone const char *, const char *); 218234370Sjasoneextern void libzfs_mnttab_remove(libzfs_handle_t *, const char *); 219234370Sjasone 220234370Sjasone/* 221234370Sjasone * Basic handle functions 222234370Sjasone */ 223234370Sjasoneextern zpool_handle_t *zpool_open(libzfs_handle_t *, const char *); 224234370Sjasoneextern zpool_handle_t *zpool_open_canfail(libzfs_handle_t *, const char *); 225234370Sjasoneextern void zpool_close(zpool_handle_t *); 226234370Sjasoneextern const char *zpool_get_name(zpool_handle_t *); 227234370Sjasoneextern int zpool_get_state(zpool_handle_t *); 228234370Sjasoneextern const char *zpool_state_to_name(vdev_state_t, vdev_aux_t); 229234370Sjasoneextern const char *zpool_pool_state_to_name(pool_state_t); 230234370Sjasoneextern void zpool_free_handles(libzfs_handle_t *); 231234370Sjasoneextern int zpool_nextboot(libzfs_handle_t *, uint64_t, uint64_t, const char *); 232234370Sjasone 233234370Sjasone/* 234234370Sjasone * Iterate over all active pools in the system. 235234370Sjasone */ 236234370Sjasonetypedef int (*zpool_iter_f)(zpool_handle_t *, void *); 237234370Sjasoneextern int zpool_iter(libzfs_handle_t *, zpool_iter_f, void *); 238234370Sjasoneextern boolean_t zpool_skip_pool(const char *); 239234370Sjasone 240234543Sjasone/* 241234370Sjasone * Functions to create and destroy pools 242234370Sjasone */ 243234543Sjasoneextern int zpool_create(libzfs_handle_t *, const char *, nvlist_t *, 244234370Sjasone nvlist_t *, nvlist_t *); 245234370Sjasoneextern int zpool_destroy(zpool_handle_t *, const char *); 246234370Sjasoneextern int zpool_add(zpool_handle_t *, nvlist_t *); 247234370Sjasone 248234370Sjasonetypedef struct splitflags { 249234370Sjasone /* do not split, but return the config that would be split off */ 250234543Sjasone int dryrun : 1; 251234370Sjasone 252234370Sjasone /* after splitting, import the pool */ 253234370Sjasone int import : 1; 254234370Sjasone} splitflags_t; 255234370Sjasone 256234370Sjasone/* 257234370Sjasone * Functions to manipulate pool and vdev state 258234370Sjasone */ 259234370Sjasoneextern int zpool_scan(zpool_handle_t *, pool_scan_func_t, pool_scrub_cmd_t); 260234370Sjasoneextern int zpool_clear(zpool_handle_t *, const char *, nvlist_t *); 261234370Sjasoneextern int zpool_reguid(zpool_handle_t *); 262234370Sjasoneextern int zpool_reopen(zpool_handle_t *); 263234370Sjasone 264234370Sjasoneextern int zpool_vdev_online(zpool_handle_t *, const char *, int, 265234370Sjasone vdev_state_t *); 266234370Sjasoneextern int zpool_vdev_offline(zpool_handle_t *, const char *, boolean_t); 267234370Sjasoneextern int zpool_vdev_attach(zpool_handle_t *, const char *, 268234370Sjasone const char *, nvlist_t *, int); 269234370Sjasoneextern int zpool_vdev_detach(zpool_handle_t *, const char *); 270234370Sjasoneextern int zpool_vdev_remove(zpool_handle_t *, const char *); 271234370Sjasoneextern int zpool_vdev_remove_cancel(zpool_handle_t *); 272234370Sjasoneextern int zpool_vdev_indirect_size(zpool_handle_t *, const char *, uint64_t *); 273234370Sjasoneextern int zpool_vdev_split(zpool_handle_t *, char *, nvlist_t **, nvlist_t *, 274234370Sjasone splitflags_t); 275234370Sjasone 276234370Sjasoneextern int zpool_vdev_fault(zpool_handle_t *, uint64_t, vdev_aux_t); 277234370Sjasoneextern int zpool_vdev_degrade(zpool_handle_t *, uint64_t, vdev_aux_t); 278234370Sjasoneextern int zpool_vdev_clear(zpool_handle_t *, uint64_t); 279234370Sjasone 280234370Sjasoneextern nvlist_t *zpool_find_vdev(zpool_handle_t *, const char *, boolean_t *, 281234370Sjasone boolean_t *, boolean_t *); 282234370Sjasoneextern nvlist_t *zpool_find_vdev_by_physpath(zpool_handle_t *, const char *, 283234370Sjasone boolean_t *, boolean_t *, boolean_t *); 284234370Sjasoneextern int zpool_label_disk(libzfs_handle_t *, zpool_handle_t *, const char *, 285234370Sjasone zpool_boot_label_t, uint64_t, int *); 286234370Sjasone 287234370Sjasone/* 288234543Sjasone * Functions to manage pool properties 289234370Sjasone */ 290234370Sjasoneextern int zpool_set_prop(zpool_handle_t *, const char *, const char *); 291234370Sjasoneextern int zpool_get_prop(zpool_handle_t *, zpool_prop_t, char *, 292234370Sjasone size_t proplen, zprop_source_t *, boolean_t); 293234370Sjasoneextern uint64_t zpool_get_prop_int(zpool_handle_t *, zpool_prop_t, 294234370Sjasone zprop_source_t *); 295234370Sjasone 296234370Sjasoneextern const char *zpool_prop_to_name(zpool_prop_t); 297extern const char *zpool_prop_values(zpool_prop_t); 298 299/* 300 * Pool health statistics. 301 */ 302typedef enum { 303 /* 304 * The following correspond to faults as defined in the (fault.fs.zfs.*) 305 * event namespace. Each is associated with a corresponding message ID. 306 */ 307 ZPOOL_STATUS_CORRUPT_CACHE, /* corrupt /kernel/drv/zpool.cache */ 308 ZPOOL_STATUS_MISSING_DEV_R, /* missing device with replicas */ 309 ZPOOL_STATUS_MISSING_DEV_NR, /* missing device with no replicas */ 310 ZPOOL_STATUS_CORRUPT_LABEL_R, /* bad device label with replicas */ 311 ZPOOL_STATUS_CORRUPT_LABEL_NR, /* bad device label with no replicas */ 312 ZPOOL_STATUS_BAD_GUID_SUM, /* sum of device guids didn't match */ 313 ZPOOL_STATUS_CORRUPT_POOL, /* pool metadata is corrupted */ 314 ZPOOL_STATUS_CORRUPT_DATA, /* data errors in user (meta)data */ 315 ZPOOL_STATUS_FAILING_DEV, /* device experiencing errors */ 316 ZPOOL_STATUS_VERSION_NEWER, /* newer on-disk version */ 317 ZPOOL_STATUS_HOSTID_MISMATCH, /* last accessed by another system */ 318 ZPOOL_STATUS_IO_FAILURE_WAIT, /* failed I/O, failmode 'wait' */ 319 ZPOOL_STATUS_IO_FAILURE_CONTINUE, /* failed I/O, failmode 'continue' */ 320 ZPOOL_STATUS_BAD_LOG, /* cannot read log chain(s) */ 321 322 /* 323 * If the pool has unsupported features but can still be opened in 324 * read-only mode, its status is ZPOOL_STATUS_UNSUP_FEAT_WRITE. If the 325 * pool has unsupported features but cannot be opened at all, its 326 * status is ZPOOL_STATUS_UNSUP_FEAT_READ. 327 */ 328 ZPOOL_STATUS_UNSUP_FEAT_READ, /* unsupported features for read */ 329 ZPOOL_STATUS_UNSUP_FEAT_WRITE, /* unsupported features for write */ 330 331 /* 332 * These faults have no corresponding message ID. At the time we are 333 * checking the status, the original reason for the FMA fault (I/O or 334 * checksum errors) has been lost. 335 */ 336 ZPOOL_STATUS_FAULTED_DEV_R, /* faulted device with replicas */ 337 ZPOOL_STATUS_FAULTED_DEV_NR, /* faulted device with no replicas */ 338 339 /* 340 * The following are not faults per se, but still an error possibly 341 * requiring administrative attention. There is no corresponding 342 * message ID. 343 */ 344 ZPOOL_STATUS_VERSION_OLDER, /* older legacy on-disk version */ 345 ZPOOL_STATUS_FEAT_DISABLED, /* supported features are disabled */ 346 ZPOOL_STATUS_RESILVERING, /* device being resilvered */ 347 ZPOOL_STATUS_OFFLINE_DEV, /* device offline */ 348 ZPOOL_STATUS_REMOVED_DEV, /* removed device */ 349 ZPOOL_STATUS_NON_NATIVE_ASHIFT, /* (e.g. 512e dev with ashift of 9) */ 350 351 /* 352 * Finally, the following indicates a healthy pool. 353 */ 354 ZPOOL_STATUS_OK 355} zpool_status_t; 356 357extern zpool_status_t zpool_get_status(zpool_handle_t *, char **); 358extern zpool_status_t zpool_import_status(nvlist_t *, char **); 359extern void zpool_dump_ddt(const ddt_stat_t *dds, const ddt_histogram_t *ddh); 360 361/* 362 * Statistics and configuration functions. 363 */ 364extern nvlist_t *zpool_get_config(zpool_handle_t *, nvlist_t **); 365extern nvlist_t *zpool_get_features(zpool_handle_t *); 366extern int zpool_refresh_stats(zpool_handle_t *, boolean_t *); 367extern int zpool_get_errlog(zpool_handle_t *, nvlist_t **); 368extern boolean_t zpool_is_bootable(zpool_handle_t *); 369 370/* 371 * Import and export functions 372 */ 373extern int zpool_export(zpool_handle_t *, boolean_t, const char *); 374extern int zpool_export_force(zpool_handle_t *, const char *); 375extern int zpool_import(libzfs_handle_t *, nvlist_t *, const char *, 376 char *altroot); 377extern int zpool_import_props(libzfs_handle_t *, nvlist_t *, const char *, 378 nvlist_t *, int); 379extern void zpool_print_unsup_feat(nvlist_t *config); 380 381/* 382 * Search for pools to import 383 */ 384 385typedef struct importargs { 386 char **path; /* a list of paths to search */ 387 int paths; /* number of paths to search */ 388 char *poolname; /* name of a pool to find */ 389 uint64_t guid; /* guid of a pool to find */ 390 char *cachefile; /* cachefile to use for import */ 391 int can_be_active : 1; /* can the pool be active? */ 392 int unique : 1; /* does 'poolname' already exist? */ 393 int exists : 1; /* set on return if pool already exists */ 394} importargs_t; 395 396extern nvlist_t *zpool_search_import(libzfs_handle_t *, importargs_t *); 397 398/* legacy pool search routines */ 399extern nvlist_t *zpool_find_import(libzfs_handle_t *, int, char **); 400extern nvlist_t *zpool_find_import_cached(libzfs_handle_t *, const char *, 401 char *, uint64_t); 402 403/* 404 * Miscellaneous pool functions 405 */ 406struct zfs_cmd; 407 408extern const char *zfs_history_event_names[]; 409 410extern char *zpool_vdev_name(libzfs_handle_t *, zpool_handle_t *, nvlist_t *, 411 boolean_t verbose); 412extern int zpool_upgrade(zpool_handle_t *, uint64_t); 413extern int zpool_get_history(zpool_handle_t *, nvlist_t **); 414extern int zpool_history_unpack(char *, uint64_t, uint64_t *, 415 nvlist_t ***, uint_t *); 416extern void zpool_obj_to_path(zpool_handle_t *, uint64_t, uint64_t, char *, 417 size_t len); 418extern int zfs_ioctl(libzfs_handle_t *, int request, struct zfs_cmd *); 419extern int zpool_get_physpath(zpool_handle_t *, char *, size_t); 420extern void zpool_explain_recover(libzfs_handle_t *, const char *, int, 421 nvlist_t *); 422 423/* 424 * Basic handle manipulations. These functions do not create or destroy the 425 * underlying datasets, only the references to them. 426 */ 427extern zfs_handle_t *zfs_open(libzfs_handle_t *, const char *, int); 428extern zfs_handle_t *zfs_handle_dup(zfs_handle_t *); 429extern void zfs_close(zfs_handle_t *); 430extern zfs_type_t zfs_get_type(const zfs_handle_t *); 431extern const char *zfs_get_name(const zfs_handle_t *); 432extern zpool_handle_t *zfs_get_pool_handle(const zfs_handle_t *); 433extern const char *zfs_get_pool_name(const zfs_handle_t *); 434 435/* 436 * Property management functions. Some functions are shared with the kernel, 437 * and are found in sys/fs/zfs.h. 438 */ 439 440/* 441 * zfs dataset property management 442 */ 443extern const char *zfs_prop_default_string(zfs_prop_t); 444extern uint64_t zfs_prop_default_numeric(zfs_prop_t); 445extern const char *zfs_prop_column_name(zfs_prop_t); 446extern boolean_t zfs_prop_align_right(zfs_prop_t); 447 448extern nvlist_t *zfs_valid_proplist(libzfs_handle_t *, zfs_type_t, 449 nvlist_t *, uint64_t, zfs_handle_t *, zpool_handle_t *, const char *); 450 451extern const char *zfs_prop_to_name(zfs_prop_t); 452extern int zfs_prop_set(zfs_handle_t *, const char *, const char *); 453extern int zfs_prop_set_list(zfs_handle_t *, nvlist_t *); 454extern int zfs_prop_get(zfs_handle_t *, zfs_prop_t, char *, size_t, 455 zprop_source_t *, char *, size_t, boolean_t); 456extern int zfs_prop_get_recvd(zfs_handle_t *, const char *, char *, size_t, 457 boolean_t); 458extern int zfs_prop_get_numeric(zfs_handle_t *, zfs_prop_t, uint64_t *, 459 zprop_source_t *, char *, size_t); 460extern int zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname, 461 uint64_t *propvalue); 462extern int zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname, 463 char *propbuf, int proplen, boolean_t literal); 464extern int zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname, 465 uint64_t *propvalue); 466extern int zfs_prop_get_written(zfs_handle_t *zhp, const char *propname, 467 char *propbuf, int proplen, boolean_t literal); 468extern int zfs_prop_get_feature(zfs_handle_t *zhp, const char *propname, 469 char *buf, size_t len); 470extern uint64_t zfs_prop_get_int(zfs_handle_t *, zfs_prop_t); 471extern int zfs_prop_inherit(zfs_handle_t *, const char *, boolean_t); 472extern const char *zfs_prop_values(zfs_prop_t); 473extern int zfs_prop_is_string(zfs_prop_t prop); 474extern nvlist_t *zfs_get_user_props(zfs_handle_t *); 475extern nvlist_t *zfs_get_recvd_props(zfs_handle_t *); 476extern nvlist_t *zfs_get_clones_nvl(zfs_handle_t *); 477 478 479typedef struct zprop_list { 480 int pl_prop; 481 char *pl_user_prop; 482 struct zprop_list *pl_next; 483 boolean_t pl_all; 484 size_t pl_width; 485 size_t pl_recvd_width; 486 boolean_t pl_fixed; 487} zprop_list_t; 488 489extern int zfs_expand_proplist(zfs_handle_t *, zprop_list_t **, boolean_t, 490 boolean_t); 491extern void zfs_prune_proplist(zfs_handle_t *, uint8_t *); 492 493#define ZFS_MOUNTPOINT_NONE "none" 494#define ZFS_MOUNTPOINT_LEGACY "legacy" 495 496#define ZFS_FEATURE_DISABLED "disabled" 497#define ZFS_FEATURE_ENABLED "enabled" 498#define ZFS_FEATURE_ACTIVE "active" 499 500#define ZFS_UNSUPPORTED_INACTIVE "inactive" 501#define ZFS_UNSUPPORTED_READONLY "readonly" 502 503/* 504 * zpool property management 505 */ 506extern int zpool_expand_proplist(zpool_handle_t *, zprop_list_t **); 507extern int zpool_prop_get_feature(zpool_handle_t *, const char *, char *, 508 size_t); 509extern const char *zpool_prop_default_string(zpool_prop_t); 510extern uint64_t zpool_prop_default_numeric(zpool_prop_t); 511extern const char *zpool_prop_column_name(zpool_prop_t); 512extern boolean_t zpool_prop_align_right(zpool_prop_t); 513 514/* 515 * Functions shared by zfs and zpool property management. 516 */ 517extern int zprop_iter(zprop_func func, void *cb, boolean_t show_all, 518 boolean_t ordered, zfs_type_t type); 519extern int zprop_get_list(libzfs_handle_t *, char *, zprop_list_t **, 520 zfs_type_t); 521extern void zprop_free_list(zprop_list_t *); 522 523#define ZFS_GET_NCOLS 5 524 525typedef enum { 526 GET_COL_NONE, 527 GET_COL_NAME, 528 GET_COL_PROPERTY, 529 GET_COL_VALUE, 530 GET_COL_RECVD, 531 GET_COL_SOURCE 532} zfs_get_column_t; 533 534/* 535 * Functions for printing zfs or zpool properties 536 */ 537typedef struct zprop_get_cbdata { 538 int cb_sources; 539 zfs_get_column_t cb_columns[ZFS_GET_NCOLS]; 540 int cb_colwidths[ZFS_GET_NCOLS + 1]; 541 boolean_t cb_scripted; 542 boolean_t cb_literal; 543 boolean_t cb_first; 544 zprop_list_t *cb_proplist; 545 zfs_type_t cb_type; 546} zprop_get_cbdata_t; 547 548void zprop_print_one_property(const char *, zprop_get_cbdata_t *, 549 const char *, const char *, zprop_source_t, const char *, 550 const char *); 551 552/* 553 * Iterator functions. 554 */ 555typedef int (*zfs_iter_f)(zfs_handle_t *, void *); 556extern int zfs_iter_root(libzfs_handle_t *, zfs_iter_f, void *); 557extern int zfs_iter_children(zfs_handle_t *, zfs_iter_f, void *); 558extern int zfs_iter_dependents(zfs_handle_t *, boolean_t, zfs_iter_f, void *); 559extern int zfs_iter_filesystems(zfs_handle_t *, zfs_iter_f, void *); 560extern int zfs_iter_snapshots(zfs_handle_t *, boolean_t, zfs_iter_f, void *); 561extern int zfs_iter_snapshots_sorted(zfs_handle_t *, zfs_iter_f, void *); 562extern int zfs_iter_snapspec(zfs_handle_t *, const char *, zfs_iter_f, void *); 563extern int zfs_iter_bookmarks(zfs_handle_t *, zfs_iter_f, void *); 564 565typedef struct get_all_cb { 566 zfs_handle_t **cb_handles; 567 size_t cb_alloc; 568 size_t cb_used; 569 boolean_t cb_verbose; 570 int (*cb_getone)(zfs_handle_t *, void *); 571} get_all_cb_t; 572 573void libzfs_add_handle(get_all_cb_t *, zfs_handle_t *); 574int libzfs_dataset_cmp(const void *, const void *); 575 576/* 577 * Functions to create and destroy datasets. 578 */ 579extern int zfs_create(libzfs_handle_t *, const char *, zfs_type_t, 580 nvlist_t *); 581extern int zfs_create_ancestors(libzfs_handle_t *, const char *); 582extern int zfs_destroy(zfs_handle_t *, boolean_t); 583extern int zfs_destroy_snaps(zfs_handle_t *, char *, boolean_t); 584extern int zfs_destroy_snaps_nvl(libzfs_handle_t *, nvlist_t *, boolean_t); 585extern int zfs_clone(zfs_handle_t *, const char *, nvlist_t *); 586extern int zfs_snapshot(libzfs_handle_t *, const char *, boolean_t, nvlist_t *); 587extern int zfs_snapshot_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, 588 nvlist_t *props); 589extern int zfs_rollback(zfs_handle_t *, zfs_handle_t *, boolean_t); 590 591typedef struct renameflags { 592 /* recursive rename */ 593 int recurse : 1; 594 595 /* don't unmount file systems */ 596 int nounmount : 1; 597 598 /* force unmount file systems */ 599 int forceunmount : 1; 600} renameflags_t; 601 602extern int zfs_rename(zfs_handle_t *, const char *, const char *, 603 renameflags_t flags); 604 605typedef struct sendflags { 606 /* print informational messages (ie, -v was specified) */ 607 boolean_t verbose; 608 609 /* recursive send (ie, -R) */ 610 boolean_t replicate; 611 612 /* for incrementals, do all intermediate snapshots */ 613 boolean_t doall; 614 615 /* if dataset is a clone, do incremental from its origin */ 616 boolean_t fromorigin; 617 618 /* do deduplication */ 619 boolean_t dedup; 620 621 /* send properties (ie, -p) */ 622 boolean_t props; 623 624 /* do not send (no-op, ie. -n) */ 625 boolean_t dryrun; 626 627 /* parsable verbose output (ie. -P) */ 628 boolean_t parsable; 629 630 /* show progress (ie. -v) */ 631 boolean_t progress; 632 633 /* large blocks (>128K) are permitted */ 634 boolean_t largeblock; 635 636 /* WRITE_EMBEDDED records of type DATA are permitted */ 637 boolean_t embed_data; 638 639 /* compressed WRITE records are permitted */ 640 boolean_t compress; 641} sendflags_t; 642 643typedef boolean_t (snapfilter_cb_t)(zfs_handle_t *, void *); 644 645extern int zfs_send(zfs_handle_t *, const char *, const char *, 646 sendflags_t *, int, snapfilter_cb_t, void *, nvlist_t **); 647extern int zfs_send_one(zfs_handle_t *, const char *, int, enum lzc_send_flags); 648extern int zfs_send_resume(libzfs_handle_t *, sendflags_t *, int outfd, 649 const char *); 650extern nvlist_t *zfs_send_resume_token_to_nvlist(libzfs_handle_t *hdl, 651 const char *token); 652 653extern int zfs_promote(zfs_handle_t *); 654extern int zfs_hold(zfs_handle_t *, const char *, const char *, 655 boolean_t, int); 656extern int zfs_hold_nvl(zfs_handle_t *, int, nvlist_t *); 657extern int zfs_release(zfs_handle_t *, const char *, const char *, boolean_t); 658extern int zfs_get_holds(zfs_handle_t *, nvlist_t **); 659extern uint64_t zvol_volsize_to_reservation(uint64_t, nvlist_t *); 660 661typedef int (*zfs_userspace_cb_t)(void *arg, const char *domain, 662 uid_t rid, uint64_t space); 663 664extern int zfs_userspace(zfs_handle_t *, zfs_userquota_prop_t, 665 zfs_userspace_cb_t, void *); 666 667extern int zfs_get_fsacl(zfs_handle_t *, nvlist_t **); 668extern int zfs_set_fsacl(zfs_handle_t *, boolean_t, nvlist_t *); 669 670typedef struct recvflags { 671 /* print informational messages (ie, -v was specified) */ 672 boolean_t verbose; 673 674 /* the destination is a prefix, not the exact fs (ie, -d) */ 675 boolean_t isprefix; 676 677 /* 678 * Only the tail of the sent snapshot path is appended to the 679 * destination to determine the received snapshot name (ie, -e). 680 */ 681 boolean_t istail; 682 683 /* do not actually do the recv, just check if it would work (ie, -n) */ 684 boolean_t dryrun; 685 686 /* rollback/destroy filesystems as necessary (eg, -F) */ 687 boolean_t force; 688 689 /* set "canmount=off" on all modified filesystems */ 690 boolean_t canmountoff; 691 692 /* 693 * Mark the file systems as "resumable" and do not destroy them if the 694 * receive is interrupted 695 */ 696 boolean_t resumable; 697 698 /* byteswap flag is used internally; callers need not specify */ 699 boolean_t byteswap; 700 701 /* do not mount file systems as they are extracted (private) */ 702 boolean_t nomount; 703} recvflags_t; 704 705extern int zfs_receive(libzfs_handle_t *, const char *, nvlist_t *, 706 recvflags_t *, int, avl_tree_t *); 707 708typedef enum diff_flags { 709 ZFS_DIFF_PARSEABLE = 0x1, 710 ZFS_DIFF_TIMESTAMP = 0x2, 711 ZFS_DIFF_CLASSIFY = 0x4 712} diff_flags_t; 713 714extern int zfs_show_diffs(zfs_handle_t *, int, const char *, const char *, 715 int); 716 717/* 718 * Miscellaneous functions. 719 */ 720extern const char *zfs_type_to_name(zfs_type_t); 721extern void zfs_refresh_properties(zfs_handle_t *); 722extern int zfs_name_valid(const char *, zfs_type_t); 723extern zfs_handle_t *zfs_path_to_zhandle(libzfs_handle_t *, char *, zfs_type_t); 724extern boolean_t zfs_dataset_exists(libzfs_handle_t *, const char *, 725 zfs_type_t); 726extern int zfs_spa_version(zfs_handle_t *, int *); 727extern boolean_t zfs_bookmark_exists(const char *path); 728 729/* 730 * Mount support functions. 731 */ 732extern boolean_t is_mounted(libzfs_handle_t *, const char *special, char **); 733extern boolean_t zfs_is_mounted(zfs_handle_t *, char **); 734extern int zfs_mount(zfs_handle_t *, const char *, int); 735extern int zfs_unmount(zfs_handle_t *, const char *, int); 736extern int zfs_unmountall(zfs_handle_t *, int); 737 738/* 739 * Share support functions. 740 */ 741extern boolean_t zfs_is_shared(zfs_handle_t *); 742extern int zfs_share(zfs_handle_t *); 743extern int zfs_unshare(zfs_handle_t *); 744 745/* 746 * Protocol-specific share support functions. 747 */ 748extern boolean_t zfs_is_shared_nfs(zfs_handle_t *, char **); 749extern boolean_t zfs_is_shared_smb(zfs_handle_t *, char **); 750extern int zfs_share_nfs(zfs_handle_t *); 751extern int zfs_share_smb(zfs_handle_t *); 752extern int zfs_shareall(zfs_handle_t *); 753extern int zfs_unshare_nfs(zfs_handle_t *, const char *); 754extern int zfs_unshare_smb(zfs_handle_t *, const char *); 755extern int zfs_unshareall_nfs(zfs_handle_t *); 756extern int zfs_unshareall_smb(zfs_handle_t *); 757extern int zfs_unshareall_bypath(zfs_handle_t *, const char *); 758extern int zfs_unshareall(zfs_handle_t *); 759extern int zfs_deleg_share_nfs(libzfs_handle_t *, char *, char *, char *, 760 void *, void *, int, zfs_share_op_t); 761 762/* 763 * FreeBSD-specific jail support function. 764 */ 765extern int zfs_jail(zfs_handle_t *, int, int); 766 767/* 768 * When dealing with nvlists, verify() is extremely useful 769 */ 770#ifndef verify 771#ifdef NDEBUG 772#define verify(EX) ((void)(EX)) 773#else 774#define verify(EX) assert(EX) 775#endif 776#endif 777 778/* 779 * Utility function to convert a number to a human-readable form. 780 */ 781extern void zfs_nicenum(uint64_t, char *, size_t); 782extern int zfs_nicestrtonum(libzfs_handle_t *, const char *, uint64_t *); 783 784/* 785 * Given a device or file, determine if it is part of a pool. 786 */ 787extern int zpool_in_use(libzfs_handle_t *, int, pool_state_t *, char **, 788 boolean_t *); 789 790/* 791 * Label manipulation. 792 */ 793extern int zpool_read_label(int, nvlist_t **); 794extern int zpool_read_all_labels(int, nvlist_t **); 795extern int zpool_clear_label(int); 796 797/* is this zvol valid for use as a dump device? */ 798extern int zvol_check_dump_config(char *); 799 800/* 801 * Management interfaces for SMB ACL files 802 */ 803 804int zfs_smb_acl_add(libzfs_handle_t *, char *, char *, char *); 805int zfs_smb_acl_remove(libzfs_handle_t *, char *, char *, char *); 806int zfs_smb_acl_purge(libzfs_handle_t *, char *, char *); 807int zfs_smb_acl_rename(libzfs_handle_t *, char *, char *, char *, char *); 808 809/* 810 * Enable and disable datasets within a pool by mounting/unmounting and 811 * sharing/unsharing them. 812 */ 813extern int zpool_enable_datasets(zpool_handle_t *, const char *, int); 814extern int zpool_disable_datasets(zpool_handle_t *, boolean_t); 815 816/* 817 * Mappings between vdev and FRU. 818 */ 819extern void libzfs_fru_refresh(libzfs_handle_t *); 820extern const char *libzfs_fru_lookup(libzfs_handle_t *, const char *); 821extern const char *libzfs_fru_devpath(libzfs_handle_t *, const char *); 822extern boolean_t libzfs_fru_compare(libzfs_handle_t *, const char *, 823 const char *); 824extern boolean_t libzfs_fru_notself(libzfs_handle_t *, const char *); 825extern int zpool_fru_set(zpool_handle_t *, uint64_t, const char *); 826 827#ifndef illumos 828extern int zmount(const char *, const char *, int, char *, char *, int, char *, 829 int); 830#endif 831extern int zfs_remap_indirects(libzfs_handle_t *hdl, const char *); 832 833#ifdef __cplusplus 834} 835#endif 836 837#endif /* _LIBZFS_H */ 838