xref: /titanic_41/usr/src/uts/common/fs/zfs/sys/zil.h (revision 416c5cd35f208639bac01e53f6a6ea81657b4521)
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  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright (c) 2012 by Delphix. All rights reserved.
24  */
25 
26 /* Portions Copyright 2010 Robert Milkowski */
27 
28 #ifndef	_SYS_ZIL_H
29 #define	_SYS_ZIL_H
30 
31 #include <sys/types.h>
32 #include <sys/spa.h>
33 #include <sys/zio.h>
34 #include <sys/dmu.h>
35 
36 #ifdef	__cplusplus
37 extern "C" {
38 #endif
39 
40 struct dsl_pool;
41 struct dsl_dataset;
42 
43 /*
44  * Intent log format:
45  *
46  * Each objset has its own intent log.  The log header (zil_header_t)
47  * for objset N's intent log is kept in the Nth object of the SPA's
48  * intent_log objset.  The log header points to a chain of log blocks,
49  * each of which contains log records (i.e., transactions) followed by
50  * a log block trailer (zil_trailer_t).  The format of a log record
51  * depends on the record (or transaction) type, but all records begin
52  * with a common structure that defines the type, length, and txg.
53  */
54 
55 /*
56  * Intent log header - this on disk structure holds fields to manage
57  * the log.  All fields are 64 bit to easily handle cross architectures.
58  */
59 typedef struct zil_header {
60 	uint64_t zh_claim_txg;	/* txg in which log blocks were claimed */
61 	uint64_t zh_replay_seq;	/* highest replayed sequence number */
62 	blkptr_t zh_log;	/* log chain */
63 	uint64_t zh_claim_blk_seq; /* highest claimed block sequence number */
64 	uint64_t zh_flags;	/* header flags */
65 	uint64_t zh_claim_lr_seq; /* highest claimed lr sequence number */
66 	uint64_t zh_pad[3];
67 } zil_header_t;
68 
69 /*
70  * zh_flags bit settings
71  */
72 #define	ZIL_REPLAY_NEEDED	0x1	/* replay needed - internal only */
73 #define	ZIL_CLAIM_LR_SEQ_VALID	0x2	/* zh_claim_lr_seq field is valid */
74 
75 /*
76  * Log block chaining.
77  *
78  * Log blocks are chained together. Originally they were chained at the
79  * end of the block. For performance reasons the chain was moved to the
80  * beginning of the block which allows writes for only the data being used.
81  * The older position is supported for backwards compatability.
82  *
83  * The zio_eck_t contains a zec_cksum which for the intent log is
84  * the sequence number of this log block. A seq of 0 is invalid.
85  * The zec_cksum is checked by the SPA against the sequence
86  * number passed in the blk_cksum field of the blkptr_t
87  */
88 typedef struct zil_chain {
89 	uint64_t zc_pad;
90 	blkptr_t zc_next_blk;	/* next block in chain */
91 	uint64_t zc_nused;	/* bytes in log block used */
92 	zio_eck_t zc_eck;	/* block trailer */
93 } zil_chain_t;
94 
95 #define	ZIL_MIN_BLKSZ	4096ULL
96 
97 /*
98  * The words of a log block checksum.
99  */
100 #define	ZIL_ZC_GUID_0	0
101 #define	ZIL_ZC_GUID_1	1
102 #define	ZIL_ZC_OBJSET	2
103 #define	ZIL_ZC_SEQ	3
104 
105 typedef enum zil_create {
106 	Z_FILE,
107 	Z_DIR,
108 	Z_XATTRDIR,
109 } zil_create_t;
110 
111 /*
112  * size of xvattr log section.
113  * its composed of lr_attr_t + xvattr bitmap + 2 64 bit timestamps
114  * for create time and a single 64 bit integer for all of the attributes,
115  * and 4 64 bit integers (32 bytes) for the scanstamp.
116  *
117  */
118 
119 #define	ZIL_XVAT_SIZE(mapsize) \
120 	sizeof (lr_attr_t) + (sizeof (uint32_t) * (mapsize - 1)) + \
121 	(sizeof (uint64_t) * 7)
122 
123 /*
124  * Size of ACL in log.  The ACE data is padded out to properly align
125  * on 8 byte boundary.
126  */
127 
128 #define	ZIL_ACE_LENGTH(x)	(roundup(x, sizeof (uint64_t)))
129 
130 /*
131  * Intent log transaction types and record structures
132  */
133 #define	TX_CREATE		1	/* Create file */
134 #define	TX_MKDIR		2	/* Make directory */
135 #define	TX_MKXATTR		3	/* Make XATTR directory */
136 #define	TX_SYMLINK		4	/* Create symbolic link to a file */
137 #define	TX_REMOVE		5	/* Remove file */
138 #define	TX_RMDIR		6	/* Remove directory */
139 #define	TX_LINK			7	/* Create hard link to a file */
140 #define	TX_RENAME		8	/* Rename a file */
141 #define	TX_WRITE		9	/* File write */
142 #define	TX_TRUNCATE		10	/* Truncate a file */
143 #define	TX_SETATTR		11	/* Set file attributes */
144 #define	TX_ACL_V0		12	/* Set old formatted ACL */
145 #define	TX_ACL			13	/* Set ACL */
146 #define	TX_CREATE_ACL		14	/* create with ACL */
147 #define	TX_CREATE_ATTR		15	/* create + attrs */
148 #define	TX_CREATE_ACL_ATTR 	16	/* create with ACL + attrs */
149 #define	TX_MKDIR_ACL		17	/* mkdir with ACL */
150 #define	TX_MKDIR_ATTR		18	/* mkdir with attr */
151 #define	TX_MKDIR_ACL_ATTR	19	/* mkdir with ACL + attrs */
152 #define	TX_WRITE2		20	/* dmu_sync EALREADY write */
153 #define	TX_MAX_TYPE		21	/* Max transaction type */
154 
155 /*
156  * The transactions for mkdir, symlink, remove, rmdir, link, and rename
157  * may have the following bit set, indicating the original request
158  * specified case-insensitive handling of names.
159  */
160 #define	TX_CI	((uint64_t)0x1 << 63) /* case-insensitive behavior requested */
161 
162 /*
163  * Transactions for write, truncate, setattr, acl_v0, and acl can be logged
164  * out of order.  For convenience in the code, all such records must have
165  * lr_foid at the same offset.
166  */
167 #define	TX_OOO(txtype)			\
168 	((txtype) == TX_WRITE ||	\
169 	(txtype) == TX_TRUNCATE ||	\
170 	(txtype) == TX_SETATTR ||	\
171 	(txtype) == TX_ACL_V0 ||	\
172 	(txtype) == TX_ACL ||		\
173 	(txtype) == TX_WRITE2)
174 
175 /*
176  * Format of log records.
177  * The fields are carefully defined to allow them to be aligned
178  * and sized the same on sparc & intel architectures.
179  * Each log record has a common structure at the beginning.
180  *
181  * The log record on disk (lrc_seq) holds the sequence number of all log
182  * records which is used to ensure we don't replay the same record.
183  */
184 typedef struct {			/* common log record header */
185 	uint64_t	lrc_txtype;	/* intent log transaction type */
186 	uint64_t	lrc_reclen;	/* transaction record length */
187 	uint64_t	lrc_txg;	/* dmu transaction group number */
188 	uint64_t	lrc_seq;	/* see comment above */
189 } lr_t;
190 
191 /*
192  * Common start of all out-of-order record types (TX_OOO() above).
193  */
194 typedef struct {
195 	lr_t		lr_common;	/* common portion of log record */
196 	uint64_t	lr_foid;	/* object id */
197 } lr_ooo_t;
198 
199 /*
200  * Handle option extended vattr attributes.
201  *
202  * Whenever new attributes are added the version number
203  * will need to be updated as will code in
204  * zfs_log.c and zfs_replay.c
205  */
206 typedef struct {
207 	uint32_t	lr_attr_masksize; /* number of elements in array */
208 	uint32_t	lr_attr_bitmap; /* First entry of array */
209 	/* remainder of array and any additional fields */
210 } lr_attr_t;
211 
212 /*
213  * log record for creates without optional ACL.
214  * This log record does support optional xvattr_t attributes.
215  */
216 typedef struct {
217 	lr_t		lr_common;	/* common portion of log record */
218 	uint64_t	lr_doid;	/* object id of directory */
219 	uint64_t	lr_foid;	/* object id of created file object */
220 	uint64_t	lr_mode;	/* mode of object */
221 	uint64_t	lr_uid;		/* uid of object */
222 	uint64_t	lr_gid;		/* gid of object */
223 	uint64_t	lr_gen;		/* generation (txg of creation) */
224 	uint64_t	lr_crtime[2];	/* creation time */
225 	uint64_t	lr_rdev;	/* rdev of object to create */
226 	/* name of object to create follows this */
227 	/* for symlinks, link content follows name */
228 	/* for creates with xvattr data, the name follows the xvattr info */
229 } lr_create_t;
230 
231 /*
232  * FUID ACL record will be an array of ACEs from the original ACL.
233  * If this array includes ephemeral IDs, the record will also include
234  * an array of log-specific FUIDs to replace the ephemeral IDs.
235  * Only one copy of each unique domain will be present, so the log-specific
236  * FUIDs will use an index into a compressed domain table.  On replay this
237  * information will be used to construct real FUIDs (and bypass idmap,
238  * since it may not be available).
239  */
240 
241 /*
242  * Log record for creates with optional ACL
243  * This log record is also used for recording any FUID
244  * information needed for replaying the create.  If the
245  * file doesn't have any actual ACEs then the lr_aclcnt
246  * would be zero.
247  *
248  * After lr_acl_flags, there are a lr_acl_bytes number of variable sized ace's.
249  * If create is also setting xvattr's, then acl data follows xvattr.
250  * If ACE FUIDs are needed then they will follow the xvattr_t.  Following
251  * the FUIDs will be the domain table information.  The FUIDs for the owner
252  * and group will be in lr_create.  Name follows ACL data.
253  */
254 typedef struct {
255 	lr_create_t	lr_create;	/* common create portion */
256 	uint64_t	lr_aclcnt;	/* number of ACEs in ACL */
257 	uint64_t	lr_domcnt;	/* number of unique domains */
258 	uint64_t	lr_fuidcnt;	/* number of real fuids */
259 	uint64_t	lr_acl_bytes;	/* number of bytes in ACL */
260 	uint64_t	lr_acl_flags;	/* ACL flags */
261 } lr_acl_create_t;
262 
263 typedef struct {
264 	lr_t		lr_common;	/* common portion of log record */
265 	uint64_t	lr_doid;	/* obj id of directory */
266 	/* name of object to remove follows this */
267 } lr_remove_t;
268 
269 typedef struct {
270 	lr_t		lr_common;	/* common portion of log record */
271 	uint64_t	lr_doid;	/* obj id of directory */
272 	uint64_t	lr_link_obj;	/* obj id of link */
273 	/* name of object to link follows this */
274 } lr_link_t;
275 
276 typedef struct {
277 	lr_t		lr_common;	/* common portion of log record */
278 	uint64_t	lr_sdoid;	/* obj id of source directory */
279 	uint64_t	lr_tdoid;	/* obj id of target directory */
280 	/* 2 strings: names of source and destination follow this */
281 } lr_rename_t;
282 
283 typedef struct {
284 	lr_t		lr_common;	/* common portion of log record */
285 	uint64_t	lr_foid;	/* file object to write */
286 	uint64_t	lr_offset;	/* offset to write to */
287 	uint64_t	lr_length;	/* user data length to write */
288 	uint64_t	lr_blkoff;	/* no longer used */
289 	blkptr_t	lr_blkptr;	/* spa block pointer for replay */
290 	/* write data will follow for small writes */
291 } lr_write_t;
292 
293 typedef struct {
294 	lr_t		lr_common;	/* common portion of log record */
295 	uint64_t	lr_foid;	/* object id of file to truncate */
296 	uint64_t	lr_offset;	/* offset to truncate from */
297 	uint64_t	lr_length;	/* length to truncate */
298 } lr_truncate_t;
299 
300 typedef struct {
301 	lr_t		lr_common;	/* common portion of log record */
302 	uint64_t	lr_foid;	/* file object to change attributes */
303 	uint64_t	lr_mask;	/* mask of attributes to set */
304 	uint64_t	lr_mode;	/* mode to set */
305 	uint64_t	lr_uid;		/* uid to set */
306 	uint64_t	lr_gid;		/* gid to set */
307 	uint64_t	lr_size;	/* size to set */
308 	uint64_t	lr_atime[2];	/* access time */
309 	uint64_t	lr_mtime[2];	/* modification time */
310 	/* optional attribute lr_attr_t may be here */
311 } lr_setattr_t;
312 
313 typedef struct {
314 	lr_t		lr_common;	/* common portion of log record */
315 	uint64_t	lr_foid;	/* obj id of file */
316 	uint64_t	lr_aclcnt;	/* number of acl entries */
317 	/* lr_aclcnt number of ace_t entries follow this */
318 } lr_acl_v0_t;
319 
320 typedef struct {
321 	lr_t		lr_common;	/* common portion of log record */
322 	uint64_t	lr_foid;	/* obj id of file */
323 	uint64_t	lr_aclcnt;	/* number of ACEs in ACL */
324 	uint64_t	lr_domcnt;	/* number of unique domains */
325 	uint64_t	lr_fuidcnt;	/* number of real fuids */
326 	uint64_t	lr_acl_bytes;	/* number of bytes in ACL */
327 	uint64_t	lr_acl_flags;	/* ACL flags */
328 	/* lr_acl_bytes number of variable sized ace's follows */
329 } lr_acl_t;
330 
331 /*
332  * ZIL structure definitions, interface function prototype and globals.
333  */
334 
335 /*
336  * Writes are handled in three different ways:
337  *
338  * WR_INDIRECT:
339  *    In this mode, if we need to commit the write later, then the block
340  *    is immediately written into the file system (using dmu_sync),
341  *    and a pointer to the block is put into the log record.
342  *    When the txg commits the block is linked in.
343  *    This saves additionally writing the data into the log record.
344  *    There are a few requirements for this to occur:
345  *	- write is greater than zfs/zvol_immediate_write_sz
346  *	- not using slogs (as slogs are assumed to always be faster
347  *	  than writing into the main pool)
348  *	- the write occupies only one block
349  * WR_COPIED:
350  *    If we know we'll immediately be committing the
351  *    transaction (FSYNC or FDSYNC), the we allocate a larger
352  *    log record here for the data and copy the data in.
353  * WR_NEED_COPY:
354  *    Otherwise we don't allocate a buffer, and *if* we need to
355  *    flush the write later then a buffer is allocated and
356  *    we retrieve the data using the dmu.
357  */
358 typedef enum {
359 	WR_INDIRECT,	/* indirect - a large write (dmu_sync() data */
360 			/* and put blkptr in log, rather than actual data) */
361 	WR_COPIED,	/* immediate - data is copied into lr_write_t */
362 	WR_NEED_COPY,	/* immediate - data needs to be copied if pushed */
363 	WR_NUM_STATES	/* number of states */
364 } itx_wr_state_t;
365 
366 typedef struct itx {
367 	list_node_t	itx_node;	/* linkage on zl_itx_list */
368 	void		*itx_private;	/* type-specific opaque data */
369 	itx_wr_state_t	itx_wr_state;	/* write state */
370 	uint8_t		itx_sync;	/* synchronous transaction */
371 	uint64_t	itx_sod;	/* record size on disk */
372 	uint64_t	itx_oid;	/* object id */
373 	lr_t		itx_lr;		/* common part of log record */
374 	/* followed by type-specific part of lr_xx_t and its immediate data */
375 } itx_t;
376 
377 typedef int zil_parse_blk_func_t(zilog_t *zilog, blkptr_t *bp, void *arg,
378     uint64_t txg);
379 typedef int zil_parse_lr_func_t(zilog_t *zilog, lr_t *lr, void *arg,
380     uint64_t txg);
381 typedef int zil_replay_func_t();
382 typedef int zil_get_data_t(void *arg, lr_write_t *lr, char *dbuf, zio_t *zio);
383 
384 extern int zil_parse(zilog_t *zilog, zil_parse_blk_func_t *parse_blk_func,
385     zil_parse_lr_func_t *parse_lr_func, void *arg, uint64_t txg);
386 
387 extern void	zil_init(void);
388 extern void	zil_fini(void);
389 
390 extern zilog_t	*zil_alloc(objset_t *os, zil_header_t *zh_phys);
391 extern void	zil_free(zilog_t *zilog);
392 
393 extern zilog_t	*zil_open(objset_t *os, zil_get_data_t *get_data);
394 extern void	zil_close(zilog_t *zilog);
395 
396 extern void	zil_replay(objset_t *os, void *arg,
397     zil_replay_func_t *replay_func[TX_MAX_TYPE]);
398 extern boolean_t zil_replaying(zilog_t *zilog, dmu_tx_t *tx);
399 extern void	zil_destroy(zilog_t *zilog, boolean_t keep_first);
400 extern void	zil_destroy_sync(zilog_t *zilog, dmu_tx_t *tx);
401 extern void	zil_rollback_destroy(zilog_t *zilog, dmu_tx_t *tx);
402 
403 extern itx_t	*zil_itx_create(uint64_t txtype, size_t lrsize);
404 extern void	zil_itx_destroy(itx_t *itx);
405 extern void	zil_itx_assign(zilog_t *zilog, itx_t *itx, dmu_tx_t *tx);
406 
407 extern void	zil_commit(zilog_t *zilog, uint64_t oid);
408 
409 extern int	zil_vdev_offline(const char *osname, void *txarg);
410 extern int	zil_claim(struct dsl_pool *dp,
411     struct dsl_dataset *ds, void *txarg);
412 extern int 	zil_check_log_chain(struct dsl_pool *dp,
413     struct dsl_dataset *ds, void *tx);
414 extern void	zil_sync(zilog_t *zilog, dmu_tx_t *tx);
415 extern void	zil_clean(zilog_t *zilog, uint64_t synced_txg);
416 
417 extern int	zil_suspend(const char *osname, void **cookiep);
418 extern void	zil_resume(void *cookie);
419 
420 extern void	zil_add_block(zilog_t *zilog, const blkptr_t *bp);
421 extern int	zil_bp_tree_add(zilog_t *zilog, const blkptr_t *bp);
422 
423 extern void	zil_set_sync(zilog_t *zilog, uint64_t syncval);
424 
425 extern void	zil_set_logbias(zilog_t *zilog, uint64_t slogval);
426 
427 extern int zil_replay_disable;
428 
429 #ifdef	__cplusplus
430 }
431 #endif
432 
433 #endif	/* _SYS_ZIL_H */
434