]>
Commit | Line | Data |
---|---|---|
34dc7c2f | 1 | /* |
dd4bc569 | 2 | * CDDL HEADER START |
34dc7c2f BB |
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 | |
1d3ba0bf | 9 | * or https://opensource.org/licenses/CDDL-1.0. |
34dc7c2f BB |
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 | /* | |
572e2857 | 23 | * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. |
196bee4c | 24 | * Copyright (c) 2011, 2020 by Delphix. All rights reserved. |
50a343d8 | 25 | * Copyright (c) 2018 Datto Inc. |
c14ca145 | 26 | * Copyright 2020 Joyent, Inc. |
34dc7c2f BB |
27 | */ |
28 | ||
6f1ffb06 MA |
29 | #ifndef _LIBZFS_IMPL_H |
30 | #define _LIBZFS_IMPL_H | |
34dc7c2f | 31 | |
34dc7c2f | 32 | #include <sys/fs/zfs.h> |
34dc7c2f | 33 | #include <sys/nvpair.h> |
eca7b760 IK |
34 | #include <sys/dmu.h> |
35 | #include <sys/zfs_ioctl.h> | |
c14ca145 | 36 | #include <regex.h> |
34dc7c2f BB |
37 | |
38 | #include <libuutil.h> | |
39 | #include <libzfs.h> | |
40 | #include <libshare.h> | |
6f1ffb06 | 41 | #include <libzfs_core.h> |
34dc7c2f BB |
42 | |
43 | #ifdef __cplusplus | |
44 | extern "C" { | |
45 | #endif | |
46 | ||
d68a2bfa RM |
47 | #define ERRBUFLEN 1024 |
48 | ||
34dc7c2f BB |
49 | struct libzfs_handle { |
50 | int libzfs_error; | |
51 | int libzfs_fd; | |
b128c09f | 52 | zpool_handle_t *libzfs_pool_handles; |
34dc7c2f BB |
53 | uu_avl_pool_t *libzfs_ns_avlpool; |
54 | uu_avl_t *libzfs_ns_avl; | |
55 | uint64_t libzfs_ns_gen; | |
56 | int libzfs_desc_active; | |
57 | char libzfs_action[1024]; | |
58 | char libzfs_desc[1024]; | |
34dc7c2f | 59 | int libzfs_printerr; |
9babb374 | 60 | boolean_t libzfs_mnttab_enable; |
a10d50f9 SR |
61 | /* |
62 | * We need a lock to handle the case where parallel mount | |
63 | * threads are populating the mnttab cache simultaneously. The | |
64 | * lock only protects the integrity of the avl tree, and does | |
65 | * not protect the contents of the mnttab entries themselves. | |
66 | */ | |
67 | pthread_mutex_t libzfs_mnttab_cache_lock; | |
fb5f0bc8 | 68 | avl_tree_t libzfs_mnttab_cache; |
428870ff | 69 | int libzfs_pool_iter; |
d99a0153 | 70 | boolean_t libzfs_prop_debug; |
c14ca145 | 71 | regex_t libzfs_urire; |
7a6c12fd | 72 | uint64_t libzfs_max_nvlist; |
37086897 AZ |
73 | void *libfetch; |
74 | char *libfetch_load_error; | |
34dc7c2f | 75 | }; |
428870ff | 76 | |
34dc7c2f BB |
77 | struct zfs_handle { |
78 | libzfs_handle_t *zfs_hdl; | |
b128c09f | 79 | zpool_handle_t *zpool_hdl; |
eca7b760 | 80 | char zfs_name[ZFS_MAX_DATASET_NAME_LEN]; |
34dc7c2f BB |
81 | zfs_type_t zfs_type; /* type including snapshot */ |
82 | zfs_type_t zfs_head_type; /* type excluding snapshot */ | |
83 | dmu_objset_stats_t zfs_dmustats; | |
84 | nvlist_t *zfs_props; | |
85 | nvlist_t *zfs_user_props; | |
428870ff | 86 | nvlist_t *zfs_recvd_props; |
34dc7c2f BB |
87 | boolean_t zfs_mntcheck; |
88 | char *zfs_mntopts; | |
9babb374 | 89 | uint8_t *zfs_props_table; |
34dc7c2f BB |
90 | }; |
91 | ||
92 | /* | |
93 | * This is different from checking zfs_type, because it will also catch | |
94 | * snapshots of volumes. | |
95 | */ | |
96 | #define ZFS_IS_VOLUME(zhp) ((zhp)->zfs_head_type == ZFS_TYPE_VOLUME) | |
97 | ||
98 | struct zpool_handle { | |
99 | libzfs_handle_t *zpool_hdl; | |
b128c09f | 100 | zpool_handle_t *zpool_next; |
eca7b760 | 101 | char zpool_name[ZFS_MAX_DATASET_NAME_LEN]; |
34dc7c2f BB |
102 | int zpool_state; |
103 | size_t zpool_config_size; | |
104 | nvlist_t *zpool_config; | |
105 | nvlist_t *zpool_old_config; | |
106 | nvlist_t *zpool_props; | |
107 | diskaddr_t zpool_start_block; | |
108 | }; | |
109 | ||
c14ca145 JK |
110 | typedef int (*zfs_uri_handler_fn_t)(struct libzfs_handle *, const char *, |
111 | const char *, zfs_keyformat_t, boolean_t, uint8_t **, size_t *); | |
112 | ||
113 | typedef struct zfs_uri_handler { | |
114 | const char *zuh_scheme; | |
115 | zfs_uri_handler_fn_t zuh_handler; | |
116 | } zfs_uri_handler_t; | |
117 | ||
379ca9cf | 118 | #define CONFIG_BUF_MINSIZE 262144 |
28b40c8a | 119 | |
739cfb96 AZ |
120 | extern int zfs_error(libzfs_handle_t *, int, const char *); |
121 | extern int zfs_error_fmt(libzfs_handle_t *, int, const char *, ...) | |
122 | __attribute__((format(printf, 3, 4))); | |
123 | extern void zfs_error_aux(libzfs_handle_t *, const char *, ...) | |
124 | __attribute__((format(printf, 2, 3))); | |
125 | extern void *zfs_alloc(libzfs_handle_t *, size_t); | |
126 | extern void *zfs_realloc(libzfs_handle_t *, void *, size_t, size_t); | |
127 | extern char *zfs_asprintf(libzfs_handle_t *, const char *, ...) | |
128 | __attribute__((format(printf, 2, 3))); | |
129 | extern char *zfs_strdup(libzfs_handle_t *, const char *); | |
130 | extern int no_memory(libzfs_handle_t *); | |
131 | ||
132 | extern int zfs_standard_error_fmt(libzfs_handle_t *, int, const char *, ...) | |
133 | __attribute__((format(printf, 3, 4))); | |
134 | extern void zfs_setprop_error(libzfs_handle_t *, zfs_prop_t, int, char *); | |
135 | extern int zpool_standard_error(libzfs_handle_t *, int, const char *); | |
136 | extern int zpool_standard_error_fmt(libzfs_handle_t *, int, const char *, ...) | |
137 | __attribute__((format(printf, 3, 4))); | |
138 | ||
139 | extern zfs_handle_t *make_dataset_handle_zc(libzfs_handle_t *, zfs_cmd_t *); | |
140 | extern zfs_handle_t *make_dataset_simple_handle_zc(zfs_handle_t *, zfs_cmd_t *); | |
141 | ||
142 | extern int zprop_parse_value(libzfs_handle_t *, nvpair_t *, int, zfs_type_t, | |
d1807f16 | 143 | nvlist_t *, const char **, uint64_t *, const char *); |
739cfb96 | 144 | extern int zprop_expand_list(libzfs_handle_t *hdl, zprop_list_t **plp, |
34dc7c2f BB |
145 | zfs_type_t type); |
146 | ||
b128c09f BB |
147 | /* |
148 | * Use this changelist_gather() flag to force attempting mounts | |
149 | * on each change node regardless of whether or not it is currently | |
150 | * mounted. | |
151 | */ | |
152 | #define CL_GATHER_MOUNT_ALWAYS 1 | |
50a343d8 AP |
153 | /* |
154 | * changelist_gather() flag to force it to iterate on mounted datasets only | |
155 | */ | |
156 | #define CL_GATHER_ITER_MOUNTED 2 | |
7b4e2723 RM |
157 | /* |
158 | * Use this changelist_gather() flag to prevent unmounting of file systems. | |
159 | */ | |
160 | #define CL_GATHER_DONT_UNMOUNT 4 | |
b128c09f | 161 | |
34dc7c2f BB |
162 | typedef struct prop_changelist prop_changelist_t; |
163 | ||
18dbf5c8 AZ |
164 | extern void zcmd_alloc_dst_nvlist(libzfs_handle_t *, zfs_cmd_t *, size_t); |
165 | extern void zcmd_write_src_nvlist(libzfs_handle_t *, zfs_cmd_t *, nvlist_t *); | |
166 | extern void zcmd_write_conf_nvlist(libzfs_handle_t *, zfs_cmd_t *, nvlist_t *); | |
167 | extern void zcmd_expand_dst_nvlist(libzfs_handle_t *, zfs_cmd_t *); | |
739cfb96 AZ |
168 | extern int zcmd_read_dst_nvlist(libzfs_handle_t *, zfs_cmd_t *, nvlist_t **); |
169 | extern void zcmd_free_nvlists(zfs_cmd_t *); | |
170 | ||
171 | extern int changelist_prefix(prop_changelist_t *); | |
172 | extern int changelist_postfix(prop_changelist_t *); | |
173 | extern void changelist_rename(prop_changelist_t *, const char *, const char *); | |
174 | extern void changelist_remove(prop_changelist_t *, const char *); | |
175 | extern void changelist_free(prop_changelist_t *); | |
176 | extern prop_changelist_t *changelist_gather(zfs_handle_t *, zfs_prop_t, int, | |
177 | int); | |
471e9a10 | 178 | extern int changelist_unshare(prop_changelist_t *, const enum sa_protocol *); |
739cfb96 AZ |
179 | extern int changelist_haszonedchild(prop_changelist_t *); |
180 | ||
181 | extern void remove_mountpoint(zfs_handle_t *); | |
182 | extern int create_parents(libzfs_handle_t *, char *, int); | |
183 | ||
184 | extern zfs_handle_t *make_dataset_handle(libzfs_handle_t *, const char *); | |
185 | extern zfs_handle_t *make_bookmark_handle(zfs_handle_t *, const char *, | |
da536844 | 186 | nvlist_t *props); |
34dc7c2f | 187 | |
739cfb96 AZ |
188 | extern int zpool_open_silent(libzfs_handle_t *, const char *, |
189 | zpool_handle_t **); | |
34dc7c2f | 190 | |
739cfb96 | 191 | extern boolean_t zpool_name_valid(libzfs_handle_t *, boolean_t, const char *); |
34dc7c2f | 192 | |
739cfb96 | 193 | extern int zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type, |
572e2857 BB |
194 | boolean_t modifying); |
195 | ||
739cfb96 | 196 | extern void namespace_clear(libzfs_handle_t *); |
34dc7c2f | 197 | |
73cdcc63 MM |
198 | typedef struct { |
199 | zfs_prop_t p_prop; | |
73cdcc63 MM |
200 | int p_share_err; |
201 | int p_unshare_err; | |
202 | } proto_table_t; | |
203 | ||
204 | typedef struct differ_info { | |
205 | zfs_handle_t *zhp; | |
206 | char *fromsnap; | |
207 | char *frommnt; | |
208 | char *tosnap; | |
209 | char *tomnt; | |
210 | char *ds; | |
211 | char *dsmnt; | |
212 | char *tmpsnap; | |
d68a2bfa | 213 | char errbuf[ERRBUFLEN]; |
73cdcc63 MM |
214 | boolean_t isclone; |
215 | boolean_t scripted; | |
216 | boolean_t classify; | |
217 | boolean_t timestamped; | |
344bbc82 | 218 | boolean_t no_mangle; |
73cdcc63 MM |
219 | uint64_t shares; |
220 | int zerr; | |
221 | int cleanupfd; | |
222 | int outputfd; | |
223 | int datafd; | |
224 | } differ_info_t; | |
225 | ||
a926aab9 | 226 | extern int do_mount(zfs_handle_t *zhp, const char *mntpt, const char *opts, |
501a1511 | 227 | int flags); |
41eba770 | 228 | extern int do_unmount(zfs_handle_t *zhp, const char *mntpt, int flags); |
73cdcc63 MM |
229 | extern int libzfs_load_module(void); |
230 | extern int zpool_relabel_disk(libzfs_handle_t *hdl, const char *path, | |
231 | const char *msg); | |
232 | extern int find_shares_object(differ_info_t *di); | |
73cdcc63 | 233 | |
34dc7c2f BB |
234 | #ifdef __cplusplus |
235 | } | |
236 | #endif | |
237 | ||
6f1ffb06 | 238 | #endif /* _LIBZFS_IMPL_H */ |