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