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/uts/common/fs/zfs/sys/dsl_dataset.h
+++ new/usr/src/uts/common/fs/zfs/sys/dsl_dataset.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 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 2012 by Delphix. All rights reserved.
24 24 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
25 25 */
26 26
27 27 #ifndef _SYS_DSL_DATASET_H
28 28 #define _SYS_DSL_DATASET_H
29 29
30 30 #include <sys/dmu.h>
31 31 #include <sys/spa.h>
32 32 #include <sys/txg.h>
33 33 #include <sys/zio.h>
34 34 #include <sys/bplist.h>
35 35 #include <sys/dsl_synctask.h>
36 36 #include <sys/zfs_context.h>
37 37 #include <sys/dsl_deadlist.h>
38 38
39 39 #ifdef __cplusplus
40 40 extern "C" {
41 41 #endif
42 42
43 43 struct dsl_dataset;
44 44 struct dsl_dir;
45 45 struct dsl_pool;
46 46
47 47 #define DS_FLAG_INCONSISTENT (1ULL<<0)
48 48 #define DS_IS_INCONSISTENT(ds) \
49 49 ((ds)->ds_phys->ds_flags & DS_FLAG_INCONSISTENT)
50 50 /*
51 51 * NB: nopromote can not yet be set, but we want support for it in this
52 52 * on-disk version, so that we don't need to upgrade for it later. It
53 53 * will be needed when we implement 'zfs split' (where the split off
54 54 * clone should not be promoted).
55 55 */
56 56 #define DS_FLAG_NOPROMOTE (1ULL<<1)
57 57
58 58 /*
59 59 * DS_FLAG_UNIQUE_ACCURATE is set if ds_unique_bytes has been correctly
60 60 * calculated for head datasets (starting with SPA_VERSION_UNIQUE_ACCURATE,
61 61 * refquota/refreservations).
62 62 */
63 63 #define DS_FLAG_UNIQUE_ACCURATE (1ULL<<2)
64 64
65 65 /*
66 66 * DS_FLAG_DEFER_DESTROY is set after 'zfs destroy -d' has been called
67 67 * on a dataset. This allows the dataset to be destroyed using 'zfs release'.
68 68 */
69 69 #define DS_FLAG_DEFER_DESTROY (1ULL<<3)
70 70 #define DS_IS_DEFER_DESTROY(ds) \
71 71 ((ds)->ds_phys->ds_flags & DS_FLAG_DEFER_DESTROY)
72 72
73 73 /*
74 74 * DS_FLAG_CI_DATASET is set if the dataset contains a file system whose
75 75 * name lookups should be performed case-insensitively.
76 76 */
77 77 #define DS_FLAG_CI_DATASET (1ULL<<16)
78 78
79 79 typedef struct dsl_dataset_phys {
80 80 uint64_t ds_dir_obj; /* DMU_OT_DSL_DIR */
81 81 uint64_t ds_prev_snap_obj; /* DMU_OT_DSL_DATASET */
82 82 uint64_t ds_prev_snap_txg;
83 83 uint64_t ds_next_snap_obj; /* DMU_OT_DSL_DATASET */
84 84 uint64_t ds_snapnames_zapobj; /* DMU_OT_DSL_DS_SNAP_MAP 0 for snaps */
85 85 uint64_t ds_num_children; /* clone/snap children; ==0 for head */
86 86 uint64_t ds_creation_time; /* seconds since 1970 */
87 87 uint64_t ds_creation_txg;
88 88 uint64_t ds_deadlist_obj; /* DMU_OT_DEADLIST */
89 89 /*
90 90 * ds_referenced_bytes, ds_compressed_bytes, and ds_uncompressed_bytes
91 91 * include all blocks referenced by this dataset, including those
92 92 * shared with any other datasets.
93 93 */
94 94 uint64_t ds_referenced_bytes;
95 95 uint64_t ds_compressed_bytes;
96 96 uint64_t ds_uncompressed_bytes;
97 97 uint64_t ds_unique_bytes; /* only relevant to snapshots */
98 98 /*
99 99 * The ds_fsid_guid is a 56-bit ID that can change to avoid
100 100 * collisions. The ds_guid is a 64-bit ID that will never
101 101 * change, so there is a small probability that it will collide.
102 102 */
103 103 uint64_t ds_fsid_guid;
104 104 uint64_t ds_guid;
105 105 uint64_t ds_flags; /* DS_FLAG_* */
106 106 blkptr_t ds_bp;
107 107 uint64_t ds_next_clones_obj; /* DMU_OT_DSL_CLONES */
108 108 uint64_t ds_props_obj; /* DMU_OT_DSL_PROPS for snaps */
109 109 uint64_t ds_userrefs_obj; /* DMU_OT_USERREFS */
110 110 uint64_t ds_pad[5]; /* pad out to 320 bytes for good measure */
111 111 } dsl_dataset_phys_t;
112 112
113 113 typedef struct dsl_dataset {
114 114 /* Immutable: */
115 115 struct dsl_dir *ds_dir;
116 116 dsl_dataset_phys_t *ds_phys;
117 117 dmu_buf_t *ds_dbuf;
118 118 uint64_t ds_object;
119 119 uint64_t ds_fsid_guid;
120 120
121 121 /* only used in syncing context, only valid for non-snapshots: */
122 122 struct dsl_dataset *ds_prev;
123 123
124 124 /* has internal locking: */
125 125 dsl_deadlist_t ds_deadlist;
126 126 bplist_t ds_pending_deadlist;
127 127
128 128 /* to protect against multiple concurrent incremental recv */
129 129 kmutex_t ds_recvlock;
130 130
131 131 /* protected by lock on pool's dp_dirty_datasets list */
132 132 txg_node_t ds_dirty_link;
133 133 list_node_t ds_synced_link;
134 134
135 135 /*
136 136 * ds_phys->ds_<accounting> is also protected by ds_lock.
137 137 * Protected by ds_lock:
138 138 */
139 139 kmutex_t ds_lock;
140 140 objset_t *ds_objset;
141 141 uint64_t ds_userrefs;
142 142
143 143 /*
144 144 * ds_owner is protected by the ds_rwlock and the ds_lock
145 145 */
146 146 krwlock_t ds_rwlock;
147 147 kcondvar_t ds_exclusive_cv;
148 148 void *ds_owner;
149 149
150 150 /* no locking; only for making guesses */
151 151 uint64_t ds_trysnap_txg;
152 152
153 153 /* for objset_open() */
154 154 kmutex_t ds_opening_lock;
155 155
156 156 uint64_t ds_reserved; /* cached refreservation */
157 157 uint64_t ds_quota; /* cached refquota */
158 158
159 159 kmutex_t ds_sendstream_lock;
160 160 list_t ds_sendstreams;
161 161
162 162 /* Protected by ds_lock; keep at end of struct for better locality */
163 163 char ds_snapname[MAXNAMELEN];
164 164 } dsl_dataset_t;
165 165
166 166 struct dsl_ds_destroyarg {
167 167 dsl_dataset_t *ds; /* ds to destroy */
168 168 dsl_dataset_t *rm_origin; /* also remove our origin? */
169 169 boolean_t is_origin_rm; /* set if removing origin snap */
170 170 boolean_t defer; /* destroy -d requested? */
171 171 boolean_t releasing; /* destroying due to release? */
172 172 boolean_t need_prep; /* do we need to retry due to EBUSY? */
173 173 };
174 174
175 175 /*
176 176 * The max length of a temporary tag prefix is the number of hex digits
177 177 * required to express UINT64_MAX plus one for the hyphen.
178 178 */
179 179 #define MAX_TAG_PREFIX_LEN 17
180 180
181 181 struct dsl_ds_holdarg {
182 182 dsl_sync_task_group_t *dstg;
183 183 const char *htag;
184 184 char *snapname;
185 185 boolean_t recursive;
186 186 boolean_t gotone;
187 187 boolean_t temphold;
188 188 char failed[MAXPATHLEN];
189 189 };
190 190
191 191 #define dsl_dataset_is_snapshot(ds) \
192 192 ((ds)->ds_phys->ds_num_children != 0)
193 193
194 194 #define DS_UNIQUE_IS_ACCURATE(ds) \
|
↓ open down ↓ |
194 lines elided |
↑ open up ↑ |
195 195 (((ds)->ds_phys->ds_flags & DS_FLAG_UNIQUE_ACCURATE) != 0)
196 196
197 197 int dsl_dataset_hold(const char *name, void *tag, dsl_dataset_t **dsp);
198 198 int dsl_dataset_hold_obj(struct dsl_pool *dp, uint64_t dsobj,
199 199 void *tag, dsl_dataset_t **);
200 200 int dsl_dataset_own(const char *name, boolean_t inconsistentok,
201 201 void *tag, dsl_dataset_t **dsp);
202 202 int dsl_dataset_own_obj(struct dsl_pool *dp, uint64_t dsobj,
203 203 boolean_t inconsistentok, void *tag, dsl_dataset_t **dsp);
204 204 void dsl_dataset_name(dsl_dataset_t *ds, char *name);
205 +int dsl_dataset_namelen(dsl_dataset_t *ds);
205 206 void dsl_dataset_rele(dsl_dataset_t *ds, void *tag);
206 207 void dsl_dataset_disown(dsl_dataset_t *ds, void *tag);
207 208 void dsl_dataset_drop_ref(dsl_dataset_t *ds, void *tag);
208 209 boolean_t dsl_dataset_tryown(dsl_dataset_t *ds, boolean_t inconsistentok,
209 210 void *tag);
210 211 void dsl_dataset_make_exclusive(dsl_dataset_t *ds, void *tag);
211 212 void dsl_register_onexit_hold_cleanup(dsl_dataset_t *ds, const char *htag,
212 213 minor_t minor);
213 214 uint64_t dsl_dataset_create_sync(dsl_dir_t *pds, const char *lastname,
214 215 dsl_dataset_t *origin, uint64_t flags, cred_t *, dmu_tx_t *);
215 216 uint64_t dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
216 217 uint64_t flags, dmu_tx_t *tx);
217 218 int dsl_dataset_destroy(dsl_dataset_t *ds, void *tag, boolean_t defer);
218 219 dsl_checkfunc_t dsl_dataset_destroy_check;
219 220 dsl_syncfunc_t dsl_dataset_destroy_sync;
220 221 dsl_syncfunc_t dsl_dataset_user_hold_sync;
221 222 int dsl_dataset_snapshot_check(dsl_dataset_t *ds, const char *, dmu_tx_t *tx);
222 223 void dsl_dataset_snapshot_sync(dsl_dataset_t *ds, const char *, dmu_tx_t *tx);
223 224 int dsl_dataset_rename(char *name, const char *newname, boolean_t recursive);
224 225 int dsl_dataset_promote(const char *name, char *conflsnap);
225 226 int dsl_dataset_clone_swap(dsl_dataset_t *clone, dsl_dataset_t *origin_head,
226 227 boolean_t force);
227 228 int dsl_dataset_user_hold(char *dsname, char *snapname, char *htag,
228 229 boolean_t recursive, boolean_t temphold, int cleanup_fd);
229 230 int dsl_dataset_user_hold_for_send(dsl_dataset_t *ds, char *htag,
230 231 boolean_t temphold);
231 232 int dsl_dataset_user_release(char *dsname, char *snapname, char *htag,
232 233 boolean_t recursive);
233 234 int dsl_dataset_user_release_tmp(struct dsl_pool *dp, uint64_t dsobj,
234 235 char *htag, boolean_t retry);
235 236 int dsl_dataset_get_holds(const char *dsname, nvlist_t **nvp);
236 237
237 238 blkptr_t *dsl_dataset_get_blkptr(dsl_dataset_t *ds);
238 239 void dsl_dataset_set_blkptr(dsl_dataset_t *ds, blkptr_t *bp, dmu_tx_t *tx);
239 240
240 241 spa_t *dsl_dataset_get_spa(dsl_dataset_t *ds);
241 242
242 243 boolean_t dsl_dataset_modified_since_lastsnap(dsl_dataset_t *ds);
243 244
244 245 void dsl_dataset_sync(dsl_dataset_t *os, zio_t *zio, dmu_tx_t *tx);
245 246
246 247 void dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp,
247 248 dmu_tx_t *tx);
248 249 int dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp,
249 250 dmu_tx_t *tx, boolean_t async);
250 251 boolean_t dsl_dataset_block_freeable(dsl_dataset_t *ds, const blkptr_t *bp,
251 252 uint64_t blk_birth);
252 253 uint64_t dsl_dataset_prev_snap_txg(dsl_dataset_t *ds);
253 254
254 255 void dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx);
255 256 void dsl_dataset_stats(dsl_dataset_t *os, nvlist_t *nv);
256 257 void dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat);
257 258 void dsl_dataset_space(dsl_dataset_t *ds,
258 259 uint64_t *refdbytesp, uint64_t *availbytesp,
259 260 uint64_t *usedobjsp, uint64_t *availobjsp);
260 261 uint64_t dsl_dataset_fsid_guid(dsl_dataset_t *ds);
261 262 int dsl_dataset_space_written(dsl_dataset_t *oldsnap, dsl_dataset_t *new,
262 263 uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
263 264 int dsl_dataset_space_wouldfree(dsl_dataset_t *firstsnap, dsl_dataset_t *last,
264 265 uint64_t *usedp, uint64_t *compp, uint64_t *uncompp);
265 266 boolean_t dsl_dataset_is_dirty(dsl_dataset_t *ds);
266 267
267 268 int dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf);
268 269
269 270 int dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
270 271 uint64_t asize, uint64_t inflight, uint64_t *used,
271 272 uint64_t *ref_rsrv);
272 273 int dsl_dataset_set_quota(const char *dsname, zprop_source_t source,
273 274 uint64_t quota);
274 275 dsl_syncfunc_t dsl_dataset_set_quota_sync;
275 276 int dsl_dataset_set_reservation(const char *dsname, zprop_source_t source,
276 277 uint64_t reservation);
277 278
278 279 int dsl_destroy_inconsistent(const char *dsname, void *arg);
279 280
280 281 #ifdef ZFS_DEBUG
281 282 #define dprintf_ds(ds, fmt, ...) do { \
282 283 if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
283 284 char *__ds_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); \
284 285 dsl_dataset_name(ds, __ds_name); \
285 286 dprintf("ds=%s " fmt, __ds_name, __VA_ARGS__); \
286 287 kmem_free(__ds_name, MAXNAMELEN); \
287 288 } \
288 289 _NOTE(CONSTCOND) } while (0)
289 290 #else
290 291 #define dprintf_ds(dd, fmt, ...)
291 292 #endif
292 293
293 294 #ifdef __cplusplus
294 295 }
295 296 #endif
296 297
297 298 #endif /* _SYS_DSL_DATASET_H */
|
↓ open down ↓ |
83 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX