xref: /freebsd/sys/ufs/ffs/softdep.h (revision e6bfd18d21b225af6a0ed67ceeaf1293b7b9eba5)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
5  *
6  * The soft updates code is derived from the appendix of a University
7  * of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
8  * "Soft Updates: A Solution to the Metadata Update Problem in File
9  * Systems", CSE-TR-254-95, August 1995).
10  *
11  * Further information about soft updates can be obtained from:
12  *
13  *	Marshall Kirk McKusick		http://www.mckusick.com/softdep/
14  *	1614 Oxford Street		mckusick@mckusick.com
15  *	Berkeley, CA 94709-1608		+1-510-843-9542
16  *	USA
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  *
22  * 1. Redistributions of source code must retain the above copyright
23  *    notice, this list of conditions and the following disclaimer.
24  * 2. Redistributions in binary form must reproduce the above copyright
25  *    notice, this list of conditions and the following disclaimer in the
26  *    documentation and/or other materials provided with the distribution.
27  *
28  * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
29  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
30  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
31  * DISCLAIMED.  IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
32  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38  * SUCH DAMAGE.
39  *
40  *	@(#)softdep.h	9.7 (McKusick) 6/21/00
41  * $FreeBSD$
42  */
43 
44 #include <sys/queue.h>
45 
46 /*
47  * Allocation dependencies are handled with undo/redo on the in-memory
48  * copy of the data. A particular data dependency is eliminated when
49  * it is ALLCOMPLETE: that is ATTACHED, DEPCOMPLETE, and COMPLETE.
50  *
51  * The ATTACHED flag means that the data is not currently being written
52  * to disk.
53  *
54  * The UNDONE flag means that the data has been rolled back to a safe
55  * state for writing to the disk. When the I/O completes, the data is
56  * restored to its current form and the state reverts to ATTACHED.
57  * The data must be locked throughout the rollback, I/O, and roll
58  * forward so that the rolled back information is never visible to
59  * user processes.
60  *
61  * The COMPLETE flag indicates that the item has been written. For example,
62  * a dependency that requires that an inode be written will be marked
63  * COMPLETE after the inode has been written to disk.
64  *
65  * The DEPCOMPLETE flag indicates the completion of any other
66  * dependencies such as the writing of a cylinder group map has been
67  * completed. A dependency structure may be freed only when both it
68  * and its dependencies have completed and any rollbacks that are in
69  * progress have finished as indicated by the set of ALLCOMPLETE flags
70  * all being set.
71  *
72  * The two MKDIR flags indicate additional dependencies that must be done
73  * when creating a new directory. MKDIR_BODY is cleared when the directory
74  * data block containing the "." and ".." entries has been written.
75  * MKDIR_PARENT is cleared when the parent inode with the increased link
76  * count for ".." has been written. When both MKDIR flags have been
77  * cleared, the DEPCOMPLETE flag is set to indicate that the directory
78  * dependencies have been completed. The writing of the directory inode
79  * itself sets the COMPLETE flag which then allows the directory entry for
80  * the new directory to be written to disk. The RMDIR flag marks a dirrem
81  * structure as representing the removal of a directory rather than a
82  * file. When the removal dependencies are completed, additional work needs
83  * to be done* (an additional decrement of the associated inode, and a
84  * decrement of the parent inode).
85  *
86  * The DIRCHG flag marks a diradd structure as representing the changing
87  * of an existing entry rather than the addition of a new one. When
88  * the update is complete the dirrem associated with the inode for
89  * the old name must be added to the worklist to do the necessary
90  * reference count decrement.
91  *
92  * The GOINGAWAY flag indicates that the data structure is frozen from
93  * further change until its dependencies have been completed and its
94  * resources freed after which it will be discarded.
95  *
96  * The IOSTARTED flag prevents multiple calls to the I/O start routine from
97  * doing multiple rollbacks.
98  *
99  * The NEWBLOCK flag marks pagedep structures that have just been allocated,
100  * so must be claimed by the inode before all dependencies are complete.
101  *
102  * The INPROGRESS flag marks worklist structures that are still on the
103  * worklist, but are being considered for action by some process.
104  *
105  * The UFS1FMT flag indicates that the inode being processed is a ufs1 format.
106  *
107  * The EXTDATA flag indicates that the allocdirect describes an
108  * extended-attributes dependency.
109  *
110  * The ONWORKLIST flag shows whether the structure is currently linked
111  * onto a worklist.
112  *
113  * The UNLINK* flags track the progress of updating the on-disk linked
114  * list of active but unlinked inodes. When an inode is first unlinked
115  * it is marked as UNLINKED. When its on-disk di_freelink has been
116  * written its UNLINKNEXT flags is set. When its predecessor in the
117  * list has its di_freelink pointing at us its UNLINKPREV is set.
118  * When the on-disk list can reach it from the superblock, its
119  * UNLINKONLIST flag is set. Once all of these flags are set, it
120  * is safe to let its last name be removed.
121  */
122 #define	ATTACHED	0x000001
123 #define	UNDONE		0x000002
124 #define	COMPLETE	0x000004
125 #define	DEPCOMPLETE	0x000008
126 #define	MKDIR_PARENT	0x000010 /* diradd, mkdir, jaddref, jsegdep only */
127 #define	MKDIR_BODY	0x000020 /* diradd, mkdir, jaddref only */
128 #define	RMDIR		0x000040 /* dirrem only */
129 #define	DIRCHG		0x000080 /* diradd, dirrem only */
130 #define	GOINGAWAY	0x000100 /* indirdep, jremref only */
131 #define	IOSTARTED	0x000200 /* inodedep, pagedep, bmsafemap only */
132 #define	DELAYEDFREE	0x000400 /* allocindirect free delayed. */
133 #define	NEWBLOCK	0x000800 /* pagedep, jaddref only */
134 #define	INPROGRESS	0x001000 /* dirrem, freeblks, freefrag, freefile only */
135 #define	UFS1FMT		0x002000 /* indirdep only */
136 #define	EXTDATA		0x004000 /* allocdirect only */
137 #define	ONWORKLIST	0x008000
138 #define	IOWAITING	0x010000 /* Thread is waiting for IO to complete. */
139 #define	ONDEPLIST	0x020000 /* Structure is on a dependency list. */
140 #define	UNLINKED	0x040000 /* inodedep has been unlinked. */
141 #define	UNLINKNEXT	0x080000 /* inodedep has valid di_freelink */
142 #define	UNLINKPREV	0x100000 /* inodedep is pointed at in the unlink list */
143 #define	UNLINKONLIST	0x200000 /* inodedep is in the unlinked list on disk */
144 #define	UNLINKLINKS	(UNLINKNEXT | UNLINKPREV)
145 #define	WRITESUCCEEDED	0x400000 /* the disk write completed successfully */
146 
147 #define	ALLCOMPLETE	(ATTACHED | COMPLETE | DEPCOMPLETE)
148 
149 #define PRINT_SOFTDEP_FLAGS "\20\27writesucceeded\26unlinkonlist" \
150 	"\25unlinkprev\24unlinknext\23unlinked\22ondeplist\21iowaiting" \
151 	"\20onworklist\17extdata\16ufs1fmt\15inprogress\14newblock" \
152 	"\13delayedfree\12iostarted\11goingaway\10dirchg\7rmdir\6mkdir_body" \
153 	"\5mkdir_parent\4depcomplete\3complete\2undone\1attached"
154 
155 /*
156  * Values for each of the soft dependency types.
157  */
158 #define	D_UNUSED	0
159 #define	D_FIRST		D_PAGEDEP
160 #define	D_PAGEDEP	1
161 #define	D_INODEDEP	2
162 #define	D_BMSAFEMAP	3
163 #define	D_NEWBLK	4
164 #define	D_ALLOCDIRECT	5
165 #define	D_INDIRDEP	6
166 #define	D_ALLOCINDIR	7
167 #define	D_FREEFRAG	8
168 #define	D_FREEBLKS	9
169 #define	D_FREEFILE	10
170 #define	D_DIRADD	11
171 #define	D_MKDIR		12
172 #define	D_DIRREM	13
173 #define	D_NEWDIRBLK	14
174 #define	D_FREEWORK	15
175 #define	D_FREEDEP	16
176 #define	D_JADDREF	17
177 #define	D_JREMREF	18
178 #define	D_JMVREF	19
179 #define	D_JNEWBLK	20
180 #define	D_JFREEBLK	21
181 #define	D_JFREEFRAG	22
182 #define	D_JSEG		23
183 #define	D_JSEGDEP	24
184 #define	D_SBDEP		25
185 #define	D_JTRUNC	26
186 #define	D_JFSYNC	27
187 #define	D_SENTINEL	28
188 #define	D_LAST		D_SENTINEL
189 
190 /*
191  * The workitem queue.
192  *
193  * It is sometimes useful and/or necessary to clean up certain dependencies
194  * in the background rather than during execution of an application process
195  * or interrupt service routine. To realize this, we append dependency
196  * structures corresponding to such tasks to a "workitem" queue. In a soft
197  * updates implementation, most pending workitems should not wait for more
198  * than a couple of seconds, so the filesystem syncer process awakens once
199  * per second to process the items on the queue.
200  */
201 
202 /* LIST_HEAD(workhead, worklist);	-- declared in buf.h */
203 
204 /*
205  * Each request can be linked onto a work queue through its worklist structure.
206  * To avoid the need for a pointer to the structure itself, this structure
207  * MUST be declared FIRST in each type in which it appears! If more than one
208  * worklist is needed in the structure, then a wk_data field must be added
209  * and the macros below changed to use it.
210  */
211 struct worklist {
212 	LIST_ENTRY(worklist)	wk_list;	/* list of work requests */
213 	struct mount		*wk_mp;		/* Mount we live in */
214 	unsigned int		wk_type:8,	/* type of request */
215 				wk_state:24;	/* state flags */
216 	LIST_ENTRY(worklist)	wk_all;		/* list of deps of this type */
217 #ifdef INVARIANTS
218 	const char		*wk_func;	/* func where added / removed */
219 	int			wk_line;	/* line where added / removed */
220 #endif
221 };
222 #define	WK_DATA(wk) ((void *)(wk))
223 #define	WK_PAGEDEP(wk) ((struct pagedep *)(wk))
224 #define	WK_INODEDEP(wk) ((struct inodedep *)(wk))
225 #define	WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk))
226 #define	WK_NEWBLK(wk)  ((struct newblk *)(wk))
227 #define	WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk))
228 #define	WK_INDIRDEP(wk) ((struct indirdep *)(wk))
229 #define	WK_ALLOCINDIR(wk) ((struct allocindir *)(wk))
230 #define	WK_FREEFRAG(wk) ((struct freefrag *)(wk))
231 #define	WK_FREEBLKS(wk) ((struct freeblks *)(wk))
232 #define	WK_FREEWORK(wk) ((struct freework *)(wk))
233 #define	WK_FREEFILE(wk) ((struct freefile *)(wk))
234 #define	WK_DIRADD(wk) ((struct diradd *)(wk))
235 #define	WK_MKDIR(wk) ((struct mkdir *)(wk))
236 #define	WK_DIRREM(wk) ((struct dirrem *)(wk))
237 #define	WK_NEWDIRBLK(wk) ((struct newdirblk *)(wk))
238 #define	WK_JADDREF(wk) ((struct jaddref *)(wk))
239 #define	WK_JREMREF(wk) ((struct jremref *)(wk))
240 #define	WK_JMVREF(wk) ((struct jmvref *)(wk))
241 #define	WK_JSEGDEP(wk) ((struct jsegdep *)(wk))
242 #define	WK_JSEG(wk) ((struct jseg *)(wk))
243 #define	WK_JNEWBLK(wk) ((struct jnewblk *)(wk))
244 #define	WK_JFREEBLK(wk) ((struct jfreeblk *)(wk))
245 #define	WK_FREEDEP(wk) ((struct freedep *)(wk))
246 #define	WK_JFREEFRAG(wk) ((struct jfreefrag *)(wk))
247 #define	WK_SBDEP(wk) ((struct sbdep *)(wk))
248 #define	WK_JTRUNC(wk) ((struct jtrunc *)(wk))
249 #define	WK_JFSYNC(wk) ((struct jfsync *)(wk))
250 
251 /*
252  * Various types of lists
253  */
254 LIST_HEAD(dirremhd, dirrem);
255 LIST_HEAD(diraddhd, diradd);
256 LIST_HEAD(newblkhd, newblk);
257 LIST_HEAD(inodedephd, inodedep);
258 LIST_HEAD(allocindirhd, allocindir);
259 LIST_HEAD(allocdirecthd, allocdirect);
260 TAILQ_HEAD(allocdirectlst, allocdirect);
261 LIST_HEAD(indirdephd, indirdep);
262 LIST_HEAD(jaddrefhd, jaddref);
263 LIST_HEAD(jremrefhd, jremref);
264 LIST_HEAD(jmvrefhd, jmvref);
265 LIST_HEAD(jnewblkhd, jnewblk);
266 LIST_HEAD(jblkdephd, jblkdep);
267 LIST_HEAD(freeworkhd, freework);
268 TAILQ_HEAD(freeworklst, freework);
269 TAILQ_HEAD(jseglst, jseg);
270 TAILQ_HEAD(inoreflst, inoref);
271 TAILQ_HEAD(freeblklst, freeblks);
272 
273 /*
274  * The "pagedep" structure tracks the various dependencies related to
275  * a particular directory page. If a directory page has any dependencies,
276  * it will have a pagedep linked to its associated buffer. The
277  * pd_dirremhd list holds the list of dirrem requests which decrement
278  * inode reference counts. These requests are processed after the
279  * directory page with the corresponding zero'ed entries has been
280  * written. The pd_diraddhd list maintains the list of diradd requests
281  * which cannot be committed until their corresponding inode has been
282  * written to disk. Because a directory may have many new entries
283  * being created, several lists are maintained hashed on bits of the
284  * offset of the entry into the directory page to keep the lists from
285  * getting too long. Once a new directory entry has been cleared to
286  * be written, it is moved to the pd_pendinghd list. After the new
287  * entry has been written to disk it is removed from the pd_pendinghd
288  * list, any removed operations are done, and the dependency structure
289  * is freed.
290  */
291 #define	DAHASHSZ 5
292 #define	DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ)
293 struct pagedep {
294 	struct	worklist pd_list;	/* page buffer */
295 #	define	pd_state pd_list.wk_state /* check for multiple I/O starts */
296 	LIST_ENTRY(pagedep) pd_hash;	/* hashed lookup */
297 	ino_t	pd_ino;			/* associated file */
298 	ufs_lbn_t pd_lbn;		/* block within file */
299 	struct	newdirblk *pd_newdirblk; /* associated newdirblk if NEWBLOCK */
300 	struct	dirremhd pd_dirremhd;	/* dirrem's waiting for page */
301 	struct	diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */
302 	struct	diraddhd pd_pendinghd;	/* directory entries awaiting write */
303 	struct	jmvrefhd pd_jmvrefhd;	/* Dependent journal writes. */
304 };
305 
306 /*
307  * The "inodedep" structure tracks the set of dependencies associated
308  * with an inode. One task that it must manage is delayed operations
309  * (i.e., work requests that must be held until the inodedep's associated
310  * inode has been written to disk). Getting an inode from its incore
311  * state to the disk requires two steps to be taken by the filesystem
312  * in this order: first the inode must be copied to its disk buffer by
313  * the VOP_UPDATE operation; second the inode's buffer must be written
314  * to disk. To ensure that both operations have happened in the required
315  * order, the inodedep maintains two lists. Delayed operations are
316  * placed on the id_inowait list. When the VOP_UPDATE is done, all
317  * operations on the id_inowait list are moved to the id_bufwait list.
318  * When the buffer is written, the items on the id_bufwait list can be
319  * safely moved to the work queue to be processed. A second task of the
320  * inodedep structure is to track the status of block allocation within
321  * the inode.  Each block that is allocated is represented by an
322  * "allocdirect" structure (see below). It is linked onto the id_newinoupdt
323  * list until both its contents and its allocation in the cylinder
324  * group map have been written to disk. Once these dependencies have been
325  * satisfied, it is removed from the id_newinoupdt list and any followup
326  * actions such as releasing the previous block or fragment are placed
327  * on the id_inowait list. When an inode is updated (a VOP_UPDATE is
328  * done), the "inodedep" structure is linked onto the buffer through
329  * its worklist. Thus, it will be notified when the buffer is about
330  * to be written and when it is done. At the update time, all the
331  * elements on the id_newinoupdt list are moved to the id_inoupdt list
332  * since those changes are now relevant to the copy of the inode in the
333  * buffer. Also at update time, the tasks on the id_inowait list are
334  * moved to the id_bufwait list so that they will be executed when
335  * the updated inode has been written to disk. When the buffer containing
336  * the inode is written to disk, any updates listed on the id_inoupdt
337  * list are rolled back as they are not yet safe. Following the write,
338  * the changes are once again rolled forward and any actions on the
339  * id_bufwait list are processed (since those actions are now safe).
340  * The entries on the id_inoupdt and id_newinoupdt lists must be kept
341  * sorted by logical block number to speed the calculation of the size
342  * of the rolled back inode (see explanation in initiate_write_inodeblock).
343  * When a directory entry is created, it is represented by a diradd.
344  * The diradd is added to the id_inowait list as it cannot be safely
345  * written to disk until the inode that it represents is on disk. After
346  * the inode is written, the id_bufwait list is processed and the diradd
347  * entries are moved to the id_pendinghd list where they remain until
348  * the directory block containing the name has been written to disk.
349  * The purpose of keeping the entries on the id_pendinghd list is so that
350  * the softdep_fsync function can find and push the inode's directory
351  * name(s) as part of the fsync operation for that file.
352  */
353 struct inodedep {
354 	struct	worklist id_list;	/* buffer holding inode block */
355 #	define	id_state id_list.wk_state /* inode dependency state */
356 	LIST_ENTRY(inodedep) id_hash;	/* hashed lookup */
357 	TAILQ_ENTRY(inodedep) id_unlinked;	/* Unlinked but ref'd inodes */
358 	struct	fs *id_fs;		/* associated filesystem */
359 	ino_t	id_ino;			/* dependent inode */
360 	nlink_t	id_nlinkdelta;		/* saved effective link count */
361 	nlink_t	id_nlinkwrote;		/* i_nlink that we wrote to disk */
362 	nlink_t	id_savednlink;		/* Link saved during rollback */
363 	LIST_ENTRY(inodedep) id_deps;	/* bmsafemap's list of inodedep's */
364 	struct	bmsafemap *id_bmsafemap; /* related bmsafemap (if pending) */
365 	struct	diradd *id_mkdiradd;	/* diradd for a mkdir. */
366 	struct	inoreflst id_inoreflst;	/* Inode reference adjustments. */
367 	long	id_savedextsize;	/* ext size saved during rollback */
368 	off_t	id_savedsize;		/* file size saved during rollback */
369 	struct	dirremhd id_dirremhd;	/* Removals pending. */
370 	struct	workhead id_pendinghd;	/* entries awaiting directory write */
371 	struct	workhead id_bufwait;	/* operations after inode written */
372 	struct	workhead id_inowait;	/* operations waiting inode update */
373 	struct	allocdirectlst id_inoupdt; /* updates before inode written */
374 	struct	allocdirectlst id_newinoupdt; /* updates when inode written */
375 	struct	allocdirectlst id_extupdt; /* extdata updates pre-inode write */
376 	struct	allocdirectlst id_newextupdt; /* extdata updates at ino write */
377 	struct	freeblklst id_freeblklst; /* List of partial truncates. */
378 	union {
379 	struct	ufs1_dinode *idu_savedino1; /* saved ufs1_dinode contents */
380 	struct	ufs2_dinode *idu_savedino2; /* saved ufs2_dinode contents */
381 	} id_un;
382 };
383 #define	id_savedino1 id_un.idu_savedino1
384 #define	id_savedino2 id_un.idu_savedino2
385 
386 /*
387  * A "bmsafemap" structure maintains a list of dependency structures
388  * that depend on the update of a particular cylinder group map.
389  * It has lists for newblks, allocdirects, allocindirs, and inodedeps.
390  * It is attached to the buffer of a cylinder group block when any of
391  * these things are allocated from the cylinder group. It is freed
392  * after the cylinder group map is written and the state of its
393  * dependencies are updated with DEPCOMPLETE to indicate that it has
394  * been processed.
395  */
396 struct bmsafemap {
397 	struct	worklist sm_list;	/* cylgrp buffer */
398 #	define	sm_state sm_list.wk_state
399 	LIST_ENTRY(bmsafemap) sm_hash;	/* Hash links. */
400 	LIST_ENTRY(bmsafemap) sm_next;	/* Mount list. */
401 	int	sm_cg;
402 	struct	buf *sm_buf;		/* associated buffer */
403 	struct	allocdirecthd sm_allocdirecthd; /* allocdirect deps */
404 	struct	allocdirecthd sm_allocdirectwr; /* writing allocdirect deps */
405 	struct	allocindirhd sm_allocindirhd; /* allocindir deps */
406 	struct	allocindirhd sm_allocindirwr; /* writing allocindir deps */
407 	struct	inodedephd sm_inodedephd; /* inodedep deps */
408 	struct	inodedephd sm_inodedepwr; /* writing inodedep deps */
409 	struct	newblkhd sm_newblkhd;	/* newblk deps */
410 	struct	newblkhd sm_newblkwr;	/* writing newblk deps */
411 	struct	jaddrefhd sm_jaddrefhd;	/* Pending inode allocations. */
412 	struct	jnewblkhd sm_jnewblkhd;	/* Pending block allocations. */
413 	struct	workhead sm_freehd;	/* Freedep deps. */
414 	struct	workhead sm_freewr;	/* Written freedeps. */
415 };
416 
417 /*
418  * A "newblk" structure is attached to a bmsafemap structure when a block
419  * or fragment is allocated from a cylinder group. Its state is set to
420  * DEPCOMPLETE when its cylinder group map is written. It is converted to
421  * an allocdirect or allocindir allocation once the allocator calls the
422  * appropriate setup function. It will initially be linked onto a bmsafemap
423  * list. Once converted it can be linked onto the lists described for
424  * allocdirect or allocindir as described below.
425  */
426 struct newblk {
427 	struct	worklist nb_list;	/* See comment above. */
428 #	define	nb_state nb_list.wk_state
429 	LIST_ENTRY(newblk) nb_hash;	/* Hashed lookup. */
430 	LIST_ENTRY(newblk) nb_deps;	/* Bmsafemap's list of newblks. */
431 	struct	jnewblk *nb_jnewblk;	/* New block journal entry. */
432 	struct	bmsafemap *nb_bmsafemap;/* Cylgrp dep (if pending). */
433 	struct	freefrag *nb_freefrag;	/* Fragment to be freed (if any). */
434 	struct	indirdephd nb_indirdeps; /* Children indirect blocks. */
435 	struct	workhead nb_newdirblk;	/* Dir block to notify when written. */
436 	struct	workhead nb_jwork;	/* Journal work pending. */
437 	ufs2_daddr_t	nb_newblkno;	/* New value of block pointer. */
438 };
439 
440 /*
441  * An "allocdirect" structure is attached to an "inodedep" when a new block
442  * or fragment is allocated and pointed to by the inode described by
443  * "inodedep". The worklist is linked to the buffer that holds the block.
444  * When the block is first allocated, it is linked to the bmsafemap
445  * structure associated with the buffer holding the cylinder group map
446  * from which it was allocated. When the cylinder group map is written
447  * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself
448  * is written, the COMPLETE flag is set. Once both the cylinder group map
449  * and the data itself have been written, it is safe to write the inode
450  * that claims the block. If there was a previous fragment that had been
451  * allocated before the file was increased in size, the old fragment may
452  * be freed once the inode claiming the new block is written to disk.
453  * This ad_fragfree request is attached to the id_inowait list of the
454  * associated inodedep (pointed to by ad_inodedep) for processing after
455  * the inode is written. When a block is allocated to a directory, an
456  * fsync of a file whose name is within that block must ensure not only
457  * that the block containing the file name has been written, but also
458  * that the on-disk inode references that block. When a new directory
459  * block is created, we allocate a newdirblk structure which is linked
460  * to the associated allocdirect (on its ad_newdirblk list). When the
461  * allocdirect has been satisfied, the newdirblk structure is moved to
462  * the inodedep id_bufwait list of its directory to await the inode
463  * being written. When the inode is written, the directory entries are
464  * fully committed and can be deleted from their pagedep->id_pendinghd
465  * and inodedep->id_pendinghd lists.
466  */
467 struct allocdirect {
468 	struct	newblk ad_block;	/* Common block logic */
469 #	define	ad_list ad_block.nb_list /* block pointer worklist */
470 #	define	ad_state ad_list.wk_state /* block pointer state */
471 	TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */
472 	struct	inodedep *ad_inodedep;	/* associated inodedep */
473 	ufs2_daddr_t	ad_oldblkno;	/* old value of block pointer */
474 	int		ad_offset;	/* Pointer offset in parent. */
475 	long		ad_newsize;	/* size of new block */
476 	long		ad_oldsize;	/* size of old block */
477 };
478 #define	ad_newblkno	ad_block.nb_newblkno
479 #define	ad_freefrag	ad_block.nb_freefrag
480 #define	ad_newdirblk	ad_block.nb_newdirblk
481 
482 /*
483  * A single "indirdep" structure manages all allocation dependencies for
484  * pointers in an indirect block. The up-to-date state of the indirect
485  * block is stored in ir_savedata. The set of pointers that may be safely
486  * written to the disk is stored in ir_savebp. The state field is used
487  * only to track whether the buffer is currently being written (in which
488  * case it is not safe to update ir_savebp). Ir_deplisthd contains the
489  * list of allocindir structures, one for each block that needs to be
490  * written to disk. Once the block and its bitmap allocation have been
491  * written the safecopy can be updated to reflect the allocation and the
492  * allocindir structure freed. If ir_state indicates that an I/O on the
493  * indirect block is in progress when ir_savebp is to be updated, the
494  * update is deferred by placing the allocindir on the ir_donehd list.
495  * When the I/O on the indirect block completes, the entries on the
496  * ir_donehd list are processed by updating their corresponding ir_savebp
497  * pointers and then freeing the allocindir structure.
498  */
499 struct indirdep {
500 	struct	worklist ir_list;	/* buffer holding indirect block */
501 #	define	ir_state ir_list.wk_state /* indirect block pointer state */
502 	LIST_ENTRY(indirdep) ir_next;	/* alloc{direct,indir} list */
503 	TAILQ_HEAD(, freework) ir_trunc;	/* List of truncations. */
504 	caddr_t	ir_saveddata;		/* buffer cache contents */
505 	struct	buf *ir_savebp;		/* buffer holding safe copy */
506 	struct	buf *ir_bp;		/* buffer holding live copy */
507 	struct	allocindirhd ir_completehd; /* waiting for indirdep complete */
508 	struct	allocindirhd ir_writehd; /* Waiting for the pointer write. */
509 	struct	allocindirhd ir_donehd;	/* done waiting to update safecopy */
510 	struct	allocindirhd ir_deplisthd; /* allocindir deps for this block */
511 	struct	freeblks *ir_freeblks;	/* Freeblks that frees this indir. */
512 };
513 
514 /*
515  * An "allocindir" structure is attached to an "indirdep" when a new block
516  * is allocated and pointed to by the indirect block described by the
517  * "indirdep". The worklist is linked to the buffer that holds the new block.
518  * When the block is first allocated, it is linked to the bmsafemap
519  * structure associated with the buffer holding the cylinder group map
520  * from which it was allocated. When the cylinder group map is written
521  * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself
522  * is written, the COMPLETE flag is set. Once both the cylinder group map
523  * and the data itself have been written, it is safe to write the entry in
524  * the indirect block that claims the block; the "allocindir" dependency
525  * can then be freed as it is no longer applicable.
526  */
527 struct allocindir {
528 	struct	newblk ai_block;	/* Common block area */
529 #	define	ai_state ai_block.nb_list.wk_state /* indirect pointer state */
530 	LIST_ENTRY(allocindir) ai_next;	/* indirdep's list of allocindir's */
531 	struct	indirdep *ai_indirdep;	/* address of associated indirdep */
532 	ufs2_daddr_t	ai_oldblkno;	/* old value of block pointer */
533 	ufs_lbn_t	ai_lbn;		/* Logical block number. */
534 	int		ai_offset;	/* Pointer offset in parent. */
535 };
536 #define	ai_newblkno	ai_block.nb_newblkno
537 #define	ai_freefrag	ai_block.nb_freefrag
538 #define	ai_newdirblk	ai_block.nb_newdirblk
539 
540 /*
541  * The allblk union is used to size the newblk structure on allocation so
542  * that it may be any one of three types.
543  */
544 union allblk {
545 	struct	allocindir ab_allocindir;
546 	struct	allocdirect ab_allocdirect;
547 	struct	newblk	ab_newblk;
548 };
549 
550 /*
551  * A "freefrag" structure is attached to an "inodedep" when a previously
552  * allocated fragment is replaced with a larger fragment, rather than extended.
553  * The "freefrag" structure is constructed and attached when the replacement
554  * block is first allocated. It is processed after the inode claiming the
555  * bigger block that replaces it has been written to disk.
556  */
557 struct freefrag {
558 	struct	worklist ff_list;	/* id_inowait or delayed worklist */
559 #	define	ff_state ff_list.wk_state
560 	struct	worklist *ff_jdep;	/* Associated journal entry. */
561 	struct	workhead ff_jwork;	/* Journal work pending. */
562 	ufs2_daddr_t ff_blkno;		/* fragment physical block number */
563 	long	ff_fragsize;		/* size of fragment being deleted */
564 	ino_t	ff_inum;		/* owning inode number */
565 	enum	vtype ff_vtype;		/* owning inode's file type */
566 	int	ff_key;			/* trim key when deleted */
567 };
568 
569 /*
570  * A "freeblks" structure is attached to an "inodedep" when the
571  * corresponding file's length is reduced to zero. It records all
572  * the information needed to free the blocks of a file after its
573  * zero'ed inode has been written to disk.  The actual work is done
574  * by child freework structures which are responsible for individual
575  * inode pointers while freeblks is responsible for retiring the
576  * entire operation when it is complete and holding common members.
577  */
578 struct freeblks {
579 	struct	worklist fb_list;	/* id_inowait or delayed worklist */
580 #	define	fb_state fb_list.wk_state /* inode and dirty block state */
581 	TAILQ_ENTRY(freeblks) fb_next;	/* List of inode truncates. */
582 	struct	jblkdephd fb_jblkdephd;	/* Journal entries pending */
583 	struct	workhead fb_freeworkhd;	/* Work items pending */
584 	struct	workhead fb_jwork;	/* Journal work pending */
585 	struct	vnode *fb_devvp;	/* filesystem device vnode */
586 #ifdef QUOTA
587 	struct	dquot *fb_quota[MAXQUOTAS]; /* quotas to be adjusted */
588 #endif
589 	uint64_t fb_modrev;		/* Inode revision at start of trunc. */
590 	off_t	fb_len;			/* Length we're truncating to. */
591 	ufs2_daddr_t fb_chkcnt;		/* Blocks released. */
592 	ino_t	fb_inum;		/* inode owner of blocks */
593 	enum	vtype fb_vtype;		/* inode owner's file type */
594 	uid_t	fb_uid;			/* uid of previous owner of blocks */
595 	int	fb_ref;			/* Children outstanding. */
596 	int	fb_cgwait;		/* cg writes outstanding. */
597 };
598 
599 /*
600  * A "freework" structure handles the release of a tree of blocks or a single
601  * block.  Each indirect block in a tree is allocated its own freework
602  * structure so that the indirect block may be freed only when all of its
603  * children are freed.  In this way we enforce the rule that an allocated
604  * block must have a valid path to a root that is journaled.  Each child
605  * block acquires a reference and when the ref hits zero the parent ref
606  * is decremented.  If there is no parent the freeblks ref is decremented.
607  */
608 struct freework {
609 	struct	worklist fw_list;		/* Delayed worklist. */
610 #	define	fw_state fw_list.wk_state
611 	LIST_ENTRY(freework) fw_segs;		/* Seg list. */
612 	TAILQ_ENTRY(freework) fw_next;		/* Hash/Trunc list. */
613 	struct	jnewblk	 *fw_jnewblk;		/* Journal entry to cancel. */
614 	struct	freeblks *fw_freeblks;		/* Root of operation. */
615 	struct	freework *fw_parent;		/* Parent indirect. */
616 	struct	indirdep *fw_indir;		/* indirect block. */
617 	ufs2_daddr_t	 fw_blkno;		/* Our block #. */
618 	ufs_lbn_t	 fw_lbn;		/* Original lbn before free. */
619 	uint16_t	 fw_frags;		/* Number of frags. */
620 	uint16_t	 fw_ref;		/* Number of children out. */
621 	uint16_t	 fw_off;		/* Current working position. */
622 	uint16_t	 fw_start;		/* Start of partial truncate. */
623 };
624 
625 /*
626  * A "freedep" structure is allocated to track the completion of a bitmap
627  * write for a freework.  One freedep may cover many freed blocks so long
628  * as they reside in the same cylinder group.  When the cg is written
629  * the freedep decrements the ref on the freework which may permit it
630  * to be freed as well.
631  */
632 struct freedep {
633 	struct	worklist fd_list;	/* Delayed worklist. */
634 	struct	freework *fd_freework;	/* Parent freework. */
635 };
636 
637 /*
638  * A "freefile" structure is attached to an inode when its
639  * link count is reduced to zero. It marks the inode as free in
640  * the cylinder group map after the zero'ed inode has been written
641  * to disk and any associated blocks and fragments have been freed.
642  */
643 struct freefile {
644 	struct	worklist fx_list;	/* id_inowait or delayed worklist */
645 	mode_t	fx_mode;		/* mode of inode */
646 	ino_t	fx_oldinum;		/* inum of the unlinked file */
647 	struct	vnode *fx_devvp;	/* filesystem device vnode */
648 	struct	workhead fx_jwork;	/* journal work pending. */
649 };
650 
651 /*
652  * A "diradd" structure is linked to an "inodedep" id_inowait list when a
653  * new directory entry is allocated that references the inode described
654  * by "inodedep". When the inode itself is written (either the initial
655  * allocation for new inodes or with the increased link count for
656  * existing inodes), the COMPLETE flag is set in da_state. If the entry
657  * is for a newly allocated inode, the "inodedep" structure is associated
658  * with a bmsafemap which prevents the inode from being written to disk
659  * until the cylinder group has been updated. Thus the da_state COMPLETE
660  * flag cannot be set until the inode bitmap dependency has been removed.
661  * When creating a new file, it is safe to write the directory entry that
662  * claims the inode once the referenced inode has been written. Since
663  * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag
664  * in the diradd can be set unconditionally when creating a file. When
665  * creating a directory, there are two additional dependencies described by
666  * mkdir structures (see their description below). When these dependencies
667  * are resolved the DEPCOMPLETE flag is set in the diradd structure.
668  * If there are multiple links created to the same inode, there will be
669  * a separate diradd structure created for each link. The diradd is
670  * linked onto the pg_diraddhd list of the pagedep for the directory
671  * page that contains the entry. When a directory page is written,
672  * the pg_diraddhd list is traversed to rollback any entries that are
673  * not yet ready to be written to disk. If a directory entry is being
674  * changed (by rename) rather than added, the DIRCHG flag is set and
675  * the da_previous entry points to the entry that will be "removed"
676  * once the new entry has been committed. During rollback, entries
677  * with da_previous are replaced with the previous inode number rather
678  * than zero.
679  *
680  * The overlaying of da_pagedep and da_previous is done to keep the
681  * structure down. If a da_previous entry is present, the pointer to its
682  * pagedep is available in the associated dirrem entry. If the DIRCHG flag
683  * is set, the da_previous entry is valid; if not set the da_pagedep entry
684  * is valid. The DIRCHG flag never changes; it is set when the structure
685  * is created if appropriate and is never cleared.
686  */
687 struct diradd {
688 	struct	worklist da_list;	/* id_inowait or id_pendinghd list */
689 #	define	da_state da_list.wk_state /* state of the new directory entry */
690 	LIST_ENTRY(diradd) da_pdlist;	/* pagedep holding directory block */
691 	doff_t	da_offset;		/* offset of new dir entry in dir blk */
692 	ino_t	da_newinum;		/* inode number for the new dir entry */
693 	union {
694 	struct	dirrem *dau_previous;	/* entry being replaced in dir change */
695 	struct	pagedep *dau_pagedep;	/* pagedep dependency for addition */
696 	} da_un;
697 	struct workhead da_jwork;	/* Journal work awaiting completion. */
698 };
699 #define	da_previous da_un.dau_previous
700 #define	da_pagedep da_un.dau_pagedep
701 
702 /*
703  * Two "mkdir" structures are needed to track the additional dependencies
704  * associated with creating a new directory entry. Normally a directory
705  * addition can be committed as soon as the newly referenced inode has been
706  * written to disk with its increased link count. When a directory is
707  * created there are two additional dependencies: writing the directory
708  * data block containing the "." and ".." entries (MKDIR_BODY) and writing
709  * the parent inode with the increased link count for ".." (MKDIR_PARENT).
710  * These additional dependencies are tracked by two mkdir structures that
711  * reference the associated "diradd" structure. When they have completed,
712  * they set the DEPCOMPLETE flag on the diradd so that it knows that its
713  * extra dependencies have been completed. The md_state field is used only
714  * to identify which type of dependency the mkdir structure is tracking.
715  * It is not used in the mainline code for any purpose other than consistency
716  * checking. All the mkdir structures in the system are linked together on
717  * a list. This list is needed so that a diradd can find its associated
718  * mkdir structures and deallocate them if it is prematurely freed (as for
719  * example if a mkdir is immediately followed by a rmdir of the same directory).
720  * Here, the free of the diradd must traverse the list to find the associated
721  * mkdir structures that reference it. The deletion would be faster if the
722  * diradd structure were simply augmented to have two pointers that referenced
723  * the associated mkdir's. However, this would increase the size of the diradd
724  * structure to speed a very infrequent operation.
725  */
726 struct mkdir {
727 	struct	worklist md_list;	/* id_inowait or buffer holding dir */
728 #	define	md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */
729 	struct	diradd *md_diradd;	/* associated diradd */
730 	struct	jaddref *md_jaddref;	/* dependent jaddref. */
731 	struct	buf *md_buf;		/* MKDIR_BODY: buffer holding dir */
732 	LIST_ENTRY(mkdir) md_mkdirs;	/* list of all mkdirs */
733 };
734 
735 /*
736  * A "dirrem" structure describes an operation to decrement the link
737  * count on an inode. The dirrem structure is attached to the pg_dirremhd
738  * list of the pagedep for the directory page that contains the entry.
739  * It is processed after the directory page with the deleted entry has
740  * been written to disk.
741  */
742 struct dirrem {
743 	struct	worklist dm_list;	/* delayed worklist */
744 #	define	dm_state dm_list.wk_state /* state of the old directory entry */
745 	LIST_ENTRY(dirrem) dm_next;	/* pagedep's list of dirrem's */
746 	LIST_ENTRY(dirrem) dm_inonext;	/* inodedep's list of dirrem's */
747 	struct	jremrefhd dm_jremrefhd;	/* Pending remove reference deps. */
748 	ino_t	dm_oldinum;		/* inum of the removed dir entry */
749 	doff_t	dm_offset;		/* offset of removed dir entry in blk */
750 	union {
751 	struct	pagedep *dmu_pagedep;	/* pagedep dependency for remove */
752 	ino_t	dmu_dirinum;		/* parent inode number (for rmdir) */
753 	} dm_un;
754 	struct workhead dm_jwork;	/* Journal work awaiting completion. */
755 };
756 #define	dm_pagedep dm_un.dmu_pagedep
757 #define	dm_dirinum dm_un.dmu_dirinum
758 
759 /*
760  * A "newdirblk" structure tracks the progress of a newly allocated
761  * directory block from its creation until it is claimed by its on-disk
762  * inode. When a block is allocated to a directory, an fsync of a file
763  * whose name is within that block must ensure not only that the block
764  * containing the file name has been written, but also that the on-disk
765  * inode references that block. When a new directory block is created,
766  * we allocate a newdirblk structure which is linked to the associated
767  * allocdirect (on its ad_newdirblk list). When the allocdirect has been
768  * satisfied, the newdirblk structure is moved to the inodedep id_bufwait
769  * list of its directory to await the inode being written. When the inode
770  * is written, the directory entries are fully committed and can be
771  * deleted from their pagedep->id_pendinghd and inodedep->id_pendinghd
772  * lists. Note that we could track directory blocks allocated to indirect
773  * blocks using a similar scheme with the allocindir structures. Rather
774  * than adding this level of complexity, we simply write those newly
775  * allocated indirect blocks synchronously as such allocations are rare.
776  * In the case of a new directory the . and .. links are tracked with
777  * a mkdir rather than a pagedep.  In this case we track the mkdir
778  * so it can be released when it is written.  A workhead is used
779  * to simplify canceling a mkdir that is removed by a subsequent dirrem.
780  */
781 struct newdirblk {
782 	struct	worklist db_list;	/* id_inowait or pg_newdirblk */
783 #	define	db_state db_list.wk_state
784 	struct	pagedep *db_pagedep;	/* associated pagedep */
785 	struct	workhead db_mkdir;
786 };
787 
788 /*
789  * The inoref structure holds the elements common to jaddref and jremref
790  * so they may easily be queued in-order on the inodedep.
791  */
792 struct inoref {
793 	struct	worklist if_list;	/* Journal pending or jseg entries. */
794 #	define	if_state if_list.wk_state
795 	TAILQ_ENTRY(inoref) if_deps;	/* Links for inodedep. */
796 	struct	jsegdep	*if_jsegdep;	/* Will track our journal record. */
797 	off_t		if_diroff;	/* Directory offset. */
798 	ino_t		if_ino;		/* Inode number. */
799 	ino_t		if_parent;	/* Parent inode number. */
800 	nlink_t		if_nlink;	/* nlink before addition. */
801 	uint16_t	if_mode;	/* File mode, needed for IFMT. */
802 };
803 
804 /*
805  * A "jaddref" structure tracks a new reference (link count) on an inode
806  * and prevents the link count increase and bitmap allocation until a
807  * journal entry can be written.  Once the journal entry is written,
808  * the inode is put on the pendinghd of the bmsafemap and a diradd or
809  * mkdir entry is placed on the bufwait list of the inode.  The DEPCOMPLETE
810  * flag is used to indicate that all of the required information for writing
811  * the journal entry is present.  MKDIR_BODY and MKDIR_PARENT are used to
812  * differentiate . and .. links from regular file names.  NEWBLOCK indicates
813  * a bitmap is still pending.  If a new reference is canceled by a delete
814  * prior to writing the journal the jaddref write is canceled and the
815  * structure persists to prevent any disk-visible changes until it is
816  * ultimately released when the file is freed or the link is dropped again.
817  */
818 struct jaddref {
819 	struct	inoref	ja_ref;		/* see inoref above. */
820 #	define	ja_list	ja_ref.if_list	/* Jrnl pending, id_inowait, dm_jwork.*/
821 #	define	ja_state ja_ref.if_list.wk_state
822 	LIST_ENTRY(jaddref) ja_bmdeps;	/* Links for bmsafemap. */
823 	union {
824 		struct	diradd	*jau_diradd;	/* Pending diradd. */
825 		struct	mkdir	*jau_mkdir;	/* MKDIR_{PARENT,BODY} */
826 	} ja_un;
827 };
828 #define	ja_diradd	ja_un.jau_diradd
829 #define	ja_mkdir	ja_un.jau_mkdir
830 #define	ja_diroff	ja_ref.if_diroff
831 #define	ja_ino		ja_ref.if_ino
832 #define	ja_parent	ja_ref.if_parent
833 #define	ja_mode		ja_ref.if_mode
834 
835 /*
836  * A "jremref" structure tracks a removed reference (unlink) on an
837  * inode and prevents the directory remove from proceeding until the
838  * journal entry is written.  Once the journal has been written the remove
839  * may proceed as normal.
840  */
841 struct jremref {
842 	struct	inoref	jr_ref;		/* see inoref above. */
843 #	define	jr_list	jr_ref.if_list	/* Linked to softdep_journal_pending. */
844 #	define	jr_state jr_ref.if_list.wk_state
845 	LIST_ENTRY(jremref) jr_deps;	/* Links for dirrem. */
846 	struct	dirrem	*jr_dirrem;	/* Back pointer to dirrem. */
847 };
848 
849 /*
850  * A "jmvref" structure tracks a name relocations within the same
851  * directory block that occur as a result of directory compaction.
852  * It prevents the updated directory entry from being written to disk
853  * until the journal entry is written. Once the journal has been
854  * written the compacted directory may be written to disk.
855  */
856 struct jmvref {
857 	struct	worklist jm_list;	/* Linked to softdep_journal_pending. */
858 	LIST_ENTRY(jmvref) jm_deps;	/* Jmvref on pagedep. */
859 	struct pagedep	*jm_pagedep;	/* Back pointer to pagedep. */
860 	ino_t		jm_parent;	/* Containing directory inode number. */
861 	ino_t		jm_ino;		/* Inode number of our entry. */
862 	off_t		jm_oldoff;	/* Our old offset in directory. */
863 	off_t		jm_newoff;	/* Our new offset in directory. */
864 };
865 
866 /*
867  * A "jnewblk" structure tracks a newly allocated block or fragment and
868  * prevents the direct or indirect block pointer as well as the cg bitmap
869  * from being written until it is logged.  After it is logged the jsegdep
870  * is attached to the allocdirect or allocindir until the operation is
871  * completed or reverted.  If the operation is reverted prior to the journal
872  * write the jnewblk structure is maintained to prevent the bitmaps from
873  * reaching the disk.  Ultimately the jnewblk structure will be passed
874  * to the free routine as the in memory cg is modified back to the free
875  * state at which time it can be released. It may be held on any of the
876  * fx_jwork, fw_jwork, fb_jwork, ff_jwork, nb_jwork, or ir_jwork lists.
877  */
878 struct jnewblk {
879 	struct	worklist jn_list;	/* See lists above. */
880 #	define	jn_state jn_list.wk_state
881 	struct	jsegdep	*jn_jsegdep;	/* Will track our journal record. */
882 	LIST_ENTRY(jnewblk) jn_deps;	/* Jnewblks on sm_jnewblkhd. */
883 	struct	worklist *jn_dep;	/* Dependency to ref completed seg. */
884 	ufs_lbn_t	jn_lbn;		/* Lbn to which allocated. */
885 	ufs2_daddr_t	jn_blkno;	/* Blkno allocated */
886 	ino_t		jn_ino;		/* Ino to which allocated. */
887 	int		jn_oldfrags;	/* Previous fragments when extended. */
888 	int		jn_frags;	/* Number of fragments. */
889 };
890 
891 /*
892  * A "jblkdep" structure tracks jfreeblk and jtrunc records attached to a
893  * freeblks structure.
894  */
895 struct jblkdep {
896 	struct	worklist jb_list;	/* For softdep journal pending. */
897 	struct	jsegdep *jb_jsegdep;	/* Reference to the jseg. */
898 	struct	freeblks *jb_freeblks;	/* Back pointer to freeblks. */
899 	LIST_ENTRY(jblkdep) jb_deps;	/* Dep list on freeblks. */
900 
901 };
902 
903 /*
904  * A "jfreeblk" structure tracks the journal write for freeing a block
905  * or tree of blocks.  The block pointer must not be cleared in the inode
906  * or indirect prior to the jfreeblk being written to the journal.
907  */
908 struct jfreeblk {
909 	struct	jblkdep	jf_dep;		/* freeblks linkage. */
910 	ufs_lbn_t	jf_lbn;		/* Lbn from which blocks freed. */
911 	ufs2_daddr_t	jf_blkno;	/* Blkno being freed. */
912 	ino_t		jf_ino;		/* Ino from which blocks freed. */
913 	int		jf_frags;	/* Number of frags being freed. */
914 };
915 
916 /*
917  * A "jfreefrag" tracks the freeing of a single block when a fragment is
918  * extended or an indirect page is replaced.  It is not part of a larger
919  * freeblks operation.
920  */
921 struct jfreefrag {
922 	struct	worklist fr_list;	/* Linked to softdep_journal_pending. */
923 #	define	fr_state fr_list.wk_state
924 	struct	jsegdep	*fr_jsegdep;	/* Will track our journal record. */
925 	struct freefrag	*fr_freefrag;	/* Back pointer to freefrag. */
926 	ufs_lbn_t	fr_lbn;		/* Lbn from which frag freed. */
927 	ufs2_daddr_t	fr_blkno;	/* Blkno being freed. */
928 	ino_t		fr_ino;		/* Ino from which frag freed. */
929 	int		fr_frags;	/* Size of frag being freed. */
930 };
931 
932 /*
933  * A "jtrunc" journals the intent to truncate an inode's data or extent area.
934  */
935 struct jtrunc {
936 	struct	jblkdep	jt_dep;		/* freeblks linkage. */
937 	off_t		jt_size;	/* Final file size. */
938 	int		jt_extsize;	/* Final extent size. */
939 	ino_t		jt_ino;		/* Ino being truncated. */
940 };
941 
942 /*
943  * A "jfsync" journals the completion of an fsync which invalidates earlier
944  * jtrunc records in the journal.
945  */
946 struct jfsync {
947 	struct worklist	jfs_list;	/* For softdep journal pending. */
948 	off_t		jfs_size;	/* Sync file size. */
949 	int		jfs_extsize;	/* Sync extent size. */
950 	ino_t		jfs_ino;	/* ino being synced. */
951 };
952 
953 /*
954  * A "jsegdep" structure tracks a single reference to a written journal
955  * segment so the journal space can be reclaimed when all dependencies
956  * have been written. It can hang off of id_inowait, dm_jwork, da_jwork,
957  * nb_jwork, ff_jwork, or fb_jwork lists.
958  */
959 struct jsegdep {
960 	struct	worklist jd_list;	/* See above for lists. */
961 #	define	jd_state jd_list.wk_state
962 	struct	jseg	*jd_seg;	/* Our journal record. */
963 };
964 
965 /*
966  * A "jseg" structure contains all of the journal records written in a
967  * single disk write.  The jaddref and jremref structures are linked into
968  * js_entries so thay may be completed when the write completes.  The
969  * js_entries also include the write dependency structures: jmvref,
970  * jnewblk, jfreeblk, jfreefrag, and jtrunc.  The js_refs field counts
971  * the number of entries on the js_entries list. Thus there is a single
972  * jseg entry to describe each journal write.
973  */
974 struct jseg {
975 	struct	worklist js_list;	/* b_deps link for journal */
976 #	define	js_state js_list.wk_state
977 	struct	workhead js_entries;	/* Entries awaiting write */
978 	LIST_HEAD(, freework) js_indirs;/* List of indirects in this seg. */
979 	TAILQ_ENTRY(jseg) js_next;	/* List of all unfinished segments. */
980 	struct	jblocks *js_jblocks;	/* Back pointer to block/seg list */
981 	struct	buf *js_buf;		/* Buffer while unwritten */
982 	uint64_t js_seq;		/* Journal record sequence number. */
983 	uint64_t js_oldseq;		/* Oldest valid sequence number. */
984 	int	js_size;		/* Size of journal record in bytes. */
985 	int	js_cnt;			/* Total items allocated. */
986 	int	js_refs;		/* Count of js_entries items. */
987 };
988 
989 /*
990  * A 'sbdep' structure tracks the head of the free inode list and
991  * superblock writes.  This makes sure the superblock is always pointing at
992  * the first possible unlinked inode for the suj recovery process.  If a
993  * block write completes and we discover a new head is available the buf
994  * is dirtied and the dep is kept. See the description of the UNLINK*
995  * flags above for more details.
996  */
997 struct sbdep {
998 	struct	worklist sb_list;	/* b_dep linkage */
999 	struct	fs	*sb_fs;		/* Filesystem pointer within buf. */
1000 	struct	ufsmount *sb_ump;	/* Our mount structure */
1001 };
1002 
1003 /*
1004  * Private journaling structures.
1005  */
1006 struct jblocks {
1007 	struct jseglst	jb_segs;	/* TAILQ of current segments. */
1008 	struct jseg	*jb_writeseg;	/* Next write to complete. */
1009 	struct jseg	*jb_oldestseg;	/* Oldest segment with valid entries. */
1010 	struct jextent	*jb_extent;	/* Extent array. */
1011 	uint64_t	jb_nextseq;	/* Next sequence number. */
1012 	uint64_t	jb_oldestwrseq;	/* Oldest written sequence number. */
1013 	uint8_t		jb_needseg;	/* Need a forced segment. */
1014 	uint8_t		jb_suspended;	/* Did journal suspend writes? */
1015 	int		jb_avail;	/* Available extents. */
1016 	int		jb_used;	/* Last used extent. */
1017 	int		jb_head;	/* Allocator head. */
1018 	int		jb_off;		/* Allocator extent offset. */
1019 	int		jb_blocks;	/* Total disk blocks covered. */
1020 	int		jb_free;	/* Total disk blocks free. */
1021 	int		jb_min;		/* Minimum free space. */
1022 	int		jb_low;		/* Low on space. */
1023 	int		jb_age;		/* Insertion time of oldest rec. */
1024 };
1025 
1026 struct jextent {
1027 	ufs2_daddr_t	je_daddr;	/* Disk block address. */
1028 	int		je_blocks;	/* Disk block count. */
1029 };
1030 
1031 /*
1032  * Hash table declarations.
1033  */
1034 LIST_HEAD(mkdirlist, mkdir);
1035 LIST_HEAD(pagedep_hashhead, pagedep);
1036 LIST_HEAD(inodedep_hashhead, inodedep);
1037 LIST_HEAD(newblk_hashhead, newblk);
1038 LIST_HEAD(bmsafemap_hashhead, bmsafemap);
1039 TAILQ_HEAD(indir_hashhead, freework);
1040 
1041 /*
1042  * Per-filesystem soft dependency data.
1043  * Allocated at mount and freed at unmount.
1044  */
1045 struct mount_softdeps {
1046 	struct	rwlock sd_fslock;		/* softdep lock */
1047 	struct	workhead sd_workitem_pending;	/* softdep work queue */
1048 	struct	worklist *sd_worklist_tail;	/* Tail pointer for above */
1049 	struct	workhead sd_journal_pending;	/* journal work queue */
1050 	struct	worklist *sd_journal_tail;	/* Tail pointer for above */
1051 	struct	jblocks *sd_jblocks;		/* Journal block information */
1052 	struct	inodedeplst sd_unlinked;	/* Unlinked inodes */
1053 	struct	bmsafemaphd sd_dirtycg;		/* Dirty CGs */
1054 	struct	mkdirlist sd_mkdirlisthd;	/* Track mkdirs */
1055 	struct	pagedep_hashhead *sd_pdhash;	/* pagedep hash table */
1056 	u_long	sd_pdhashsize;			/* pagedep hash table size-1 */
1057 	long	sd_pdnextclean;			/* next hash bucket to clean */
1058 	struct	inodedep_hashhead *sd_idhash;	/* inodedep hash table */
1059 	u_long	sd_idhashsize;			/* inodedep hash table size-1 */
1060 	long	sd_idnextclean;			/* next hash bucket to clean */
1061 	struct	newblk_hashhead *sd_newblkhash;	/* newblk hash table */
1062 	u_long	sd_newblkhashsize;		/* newblk hash table size-1 */
1063 	struct	bmsafemap_hashhead *sd_bmhash;	/* bmsafemap hash table */
1064 	u_long	sd_bmhashsize;			/* bmsafemap hash table size-1*/
1065 	struct	indir_hashhead *sd_indirhash;	/* indir hash table */
1066 	u_long	sd_indirhashsize;		/* indir hash table size-1 */
1067 	int	sd_on_journal;			/* Items on the journal list */
1068 	int	sd_on_worklist;			/* Items on the worklist */
1069 	int	sd_deps;			/* Total dependency count */
1070 	int	sd_accdeps;			/* accumulated dep count */
1071 	int	sd_req;				/* Wakeup when deps hits 0. */
1072 	int	sd_flags;			/* comm with flushing thread */
1073 	int	sd_cleanups;			/* Calls to cleanup */
1074 	struct	thread *sd_flushtd;		/* thread handling flushing */
1075 	TAILQ_ENTRY(mount_softdeps) sd_next;	/* List of softdep filesystem */
1076 	struct	ufsmount *sd_ump;		/* our ufsmount structure */
1077 	u_long	sd_curdeps[D_LAST + 1];		/* count of current deps */
1078 	struct	workhead sd_alldeps[D_LAST + 1];/* Lists of all deps */
1079 };
1080 /*
1081  * Flags for communicating with the syncer thread.
1082  */
1083 #define FLUSH_EXIT	0x0001	/* time to exit */
1084 #define FLUSH_CLEANUP	0x0002	/* need to clear out softdep structures */
1085 #define	FLUSH_STARTING	0x0004	/* flush thread not yet started */
1086 #define	FLUSH_RC_ACTIVE	0x0008	/* a thread is flushing the mount point */
1087 #define	FLUSH_DI_ACTIVE	0x0010	/* a thread is processing delayed
1088 				   inactivations */
1089 
1090 /*
1091  * Keep the old names from when these were in the ufsmount structure.
1092  */
1093 #define	softdep_workitem_pending	um_softdep->sd_workitem_pending
1094 #define	softdep_worklist_tail		um_softdep->sd_worklist_tail
1095 #define	softdep_journal_pending		um_softdep->sd_journal_pending
1096 #define	softdep_journal_tail		um_softdep->sd_journal_tail
1097 #define	softdep_jblocks			um_softdep->sd_jblocks
1098 #define	softdep_unlinked		um_softdep->sd_unlinked
1099 #define	softdep_dirtycg			um_softdep->sd_dirtycg
1100 #define	softdep_mkdirlisthd		um_softdep->sd_mkdirlisthd
1101 #define	pagedep_hashtbl			um_softdep->sd_pdhash
1102 #define	pagedep_hash_size		um_softdep->sd_pdhashsize
1103 #define	pagedep_nextclean		um_softdep->sd_pdnextclean
1104 #define	inodedep_hashtbl		um_softdep->sd_idhash
1105 #define	inodedep_hash_size		um_softdep->sd_idhashsize
1106 #define	inodedep_nextclean		um_softdep->sd_idnextclean
1107 #define	newblk_hashtbl			um_softdep->sd_newblkhash
1108 #define	newblk_hash_size		um_softdep->sd_newblkhashsize
1109 #define	bmsafemap_hashtbl		um_softdep->sd_bmhash
1110 #define	bmsafemap_hash_size		um_softdep->sd_bmhashsize
1111 #define	indir_hashtbl			um_softdep->sd_indirhash
1112 #define	indir_hash_size			um_softdep->sd_indirhashsize
1113 #define	softdep_on_journal		um_softdep->sd_on_journal
1114 #define	softdep_on_worklist		um_softdep->sd_on_worklist
1115 #define	softdep_deps			um_softdep->sd_deps
1116 #define	softdep_accdeps			um_softdep->sd_accdeps
1117 #define	softdep_req			um_softdep->sd_req
1118 #define	softdep_flags			um_softdep->sd_flags
1119 #define	softdep_flushtd			um_softdep->sd_flushtd
1120 #define	softdep_curdeps			um_softdep->sd_curdeps
1121 #define	softdep_alldeps			um_softdep->sd_alldeps
1122