xref: /dragonfly/sys/vfs/ufs/softdep.h (revision c309c6d4)
1 /*-
2  * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
3  *
4  * The soft updates code is derived from the appendix of a University
5  * of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
6  * "Soft Updates: A Solution to the Metadata Update Problem in File
7  * Systems", CSE-TR-254-95, August 1995).
8  *
9  * Further information about soft updates can be obtained from:
10  *
11  *	Marshall Kirk McKusick		http://www.mckusick.com/softdep/
12  *	1614 Oxford Street		mckusick@mckusick.com
13  *	Berkeley, CA 94709-1608		+1-510-843-9542
14  *	USA
15  *
16  * Redistribution and use in source and binary forms, with or without
17  * modification, are permitted provided that the following conditions
18  * are met:
19  *
20  * 1. Redistributions of source code must retain the above copyright
21  *    notice, this list of conditions and the following disclaimer.
22  * 2. Redistributions in binary form must reproduce the above copyright
23  *    notice, this list of conditions and the following disclaimer in the
24  *    documentation and/or other materials provided with the distribution.
25  *
26  * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
27  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29  * DISCLAIMED.  IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
30  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *	@(#)softdep.h	9.7 (McKusick) 6/21/00
39  * $FreeBSD: src/sys/ufs/ffs/softdep.h,v 1.7.2.1 2000/06/22 19:27:42 peter Exp $
40  */
41 
42 #include <sys/queue.h>
43 
44 /*
45  * Allocation dependencies are handled with undo/redo on the in-memory
46  * copy of the data. A particular data dependency is eliminated when
47  * it is ALLCOMPLETE: that is ATTACHED, DEPCOMPLETE, and COMPLETE.
48  *
49  * ATTACHED means that the data is not currently being written to
50  * disk. UNDONE means that the data has been rolled back to a safe
51  * state for writing to the disk. When the I/O completes, the data is
52  * restored to its current form and the state reverts to ATTACHED.
53  * The data must be locked throughout the rollback, I/O, and roll
54  * forward so that the rolled back information is never visible to
55  * user processes. The COMPLETE flag indicates that the item has been
56  * written. For example, a dependency that requires that an inode be
57  * written will be marked COMPLETE after the inode has been written
58  * to disk. The DEPCOMPLETE flag indicates the completion of any other
59  * dependencies such as the writing of a cylinder group map has been
60  * completed. A dependency structure may be freed only when both it
61  * and its dependencies have completed and any rollbacks that are in
62  * progress have finished as indicated by the set of ALLCOMPLETE flags
63  * all being set. The two MKDIR flags indicate additional dependencies
64  * that must be done when creating a new directory. MKDIR_BODY is
65  * cleared when the directory data block containing the "." and ".."
66  * entries has been written. MKDIR_PARENT is cleared when the parent
67  * inode with the increased link count for ".." has been written. When
68  * both MKDIR flags have been cleared, the DEPCOMPLETE flag is set to
69  * indicate that the directory dependencies have been completed. The
70  * writing of the directory inode itself sets the COMPLETE flag which
71  * then allows the directory entry for the new directory to be written
72  * to disk. The RMDIR flag marks a dirrem structure as representing
73  * the removal of a directory rather than a file. When the removal
74  * dependencies are completed, additional work needs to be done
75  * (truncation of the "." and ".." entries, an additional decrement
76  * of the associated inode, and a decrement of the parent inode). The
77  * DIRCHG flag marks a diradd structure as representing the changing
78  * of an existing entry rather than the addition of a new one. When
79  * the update is complete the dirrem associated with the inode for
80  * the old name must be added to the worklist to do the necessary
81  * reference count decrement. The GOINGAWAY flag indicates that the
82  * data structure is frozen from further change until its dependencies
83  * have been completed and its resources freed after which it will be
84  * discarded. The IOSTARTED flag prevents multiple calls to the I/O
85  * start routine from doing multiple rollbacks. The ONWORKLIST flag
86  * shows whether the structure is currently linked onto a worklist.
87  */
88 #define	ATTACHED	0x0001
89 #define	UNDONE		0x0002
90 #define	COMPLETE	0x0004
91 #define	DEPCOMPLETE	0x0008
92 #define MKDIR_PARENT	0x0010
93 #define MKDIR_BODY	0x0020
94 #define RMDIR		0x0040
95 #define DIRCHG		0x0080
96 #define GOINGAWAY	0x0100
97 #define IOSTARTED	0x0200
98 #define ONWORKLIST	0x8000
99 
100 #define	ALLCOMPLETE	(ATTACHED | COMPLETE | DEPCOMPLETE)
101 
102 /*
103  * The workitem queue.
104  *
105  * It is sometimes useful and/or necessary to clean up certain dependencies
106  * in the background rather than during execution of an application process
107  * or interrupt service routine. To realize this, we append dependency
108  * structures corresponding to such tasks to a "workitem" queue. In a soft
109  * updates implementation, most pending workitems should not wait for more
110  * than a couple of seconds, so the filesystem syncer process awakens once
111  * per second to process the items on the queue.
112  */
113 
114 /* LIST_HEAD(workhead, worklist);	-- declared in buf.h */
115 
116 /*
117  * Each request can be linked onto a work queue through its worklist structure.
118  * To avoid the need for a pointer to the structure itself, this structure
119  * MUST be declared FIRST in each type in which it appears! If more than one
120  * worklist is needed in the structure, then a wk_data field must be added
121  * and the macros below changed to use it.
122  */
123 struct worklist {
124 	LIST_ENTRY(worklist)	wk_list;	/* list of work requests */
125 	unsigned short		wk_type;	/* type of request */
126 	unsigned short		wk_state;	/* state flags */
127 };
128 #define WK_DATA(wk) ((void *)(wk))
129 #define WK_PAGEDEP(wk) ((struct pagedep *)(wk))
130 #define WK_INODEDEP(wk) ((struct inodedep *)(wk))
131 #define WK_NEWBLK(wk) ((struct newblk *)(wk))
132 #define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk))
133 #define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk))
134 #define WK_INDIRDEP(wk) ((struct indirdep *)(wk))
135 #define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk))
136 #define WK_FREEFRAG(wk) ((struct freefrag *)(wk))
137 #define WK_FREEBLKS(wk) ((struct freeblks *)(wk))
138 #define WK_FREEFILE(wk) ((struct freefile *)(wk))
139 #define WK_DIRADD(wk) ((struct diradd *)(wk))
140 #define WK_MKDIR(wk) ((struct mkdir *)(wk))
141 #define WK_DIRREM(wk) ((struct dirrem *)(wk))
142 
143 /*
144  * Various types of lists
145  */
146 LIST_HEAD(dirremhd, dirrem);
147 LIST_HEAD(diraddhd, diradd);
148 LIST_HEAD(newblkhd, newblk);
149 LIST_HEAD(inodedephd, inodedep);
150 LIST_HEAD(allocindirhd, allocindir);
151 LIST_HEAD(allocdirecthd, allocdirect);
152 TAILQ_HEAD(allocdirectlst, allocdirect);
153 
154 /*
155  * The "pagedep" structure tracks the various dependencies related to
156  * a particular directory page. If a directory page has any dependencies,
157  * it will have a pagedep linked to its associated buffer. The
158  * pd_dirremhd list holds the list of dirrem requests which decrement
159  * inode reference counts. These requests are processed after the
160  * directory page with the corresponding zero'ed entries has been
161  * written. The pd_diraddhd list maintains the list of diradd requests
162  * which cannot be committed until their corresponding inode has been
163  * written to disk. Because a directory may have many new entries
164  * being created, several lists are maintained hashed on bits of the
165  * offset of the entry into the directory page to keep the lists from
166  * getting too long. Once a new directory entry has been cleared to
167  * be written, it is moved to the pd_pendinghd list. After the new
168  * entry has been written to disk it is removed from the pd_pendinghd
169  * list, any removed operations are done, and the dependency structure
170  * is freed.
171  */
172 #define DAHASHSZ 6
173 #define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ)
174 struct pagedep {
175 	struct	worklist pd_list;	/* page buffer */
176 #	define	pd_state pd_list.wk_state /* check for multiple I/O starts */
177 	LIST_ENTRY(pagedep) pd_hash;	/* hashed lookup */
178 	struct	mount *pd_mnt;		/* associated mount point */
179 	ino_t	pd_ino;			/* associated file */
180 	ufs_lbn_t pd_lbn;		/* block within file */
181 	struct	dirremhd pd_dirremhd;	/* dirrem's waiting for page */
182 	struct	diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */
183 	struct	diraddhd pd_pendinghd;	/* directory entries awaiting write */
184 };
185 
186 /*
187  * The "inodedep" structure tracks the set of dependencies associated
188  * with an inode. One task that it must manage is delayed operations
189  * (i.e., work requests that must be held until the inodedep's associated
190  * inode has been written to disk). Getting an inode from its incore
191  * state to the disk requires two steps to be taken by the filesystem
192  * in this order: first the inode must be copied to its disk buffer by
193  * the VOP_UPDATE operation; second the inode's buffer must be written
194  * to disk. To ensure that both operations have happened in the required
195  * order, the inodedep maintains two lists. Delayed operations are
196  * placed on the id_inowait list. When the VOP_UPDATE is done, all
197  * operations on the id_inowait list are moved to the id_bufwait list.
198  * When the buffer is written, the items on the id_bufwait list can be
199  * safely moved to the work queue to be processed. A second task of the
200  * inodedep structure is to track the status of block allocation within
201  * the inode.  Each block that is allocated is represented by an
202  * "allocdirect" structure (see below). It is linked onto the id_newinoupdt
203  * list until both its contents and its allocation in the cylinder
204  * group map have been written to disk. Once these dependencies have been
205  * satisfied, it is removed from the id_newinoupdt list and any followup
206  * actions such as releasing the previous block or fragment are placed
207  * on the id_inowait list. When an inode is updated (a VOP_UPDATE is
208  * done), the "inodedep" structure is linked onto the buffer through
209  * its worklist. Thus, it will be notified when the buffer is about
210  * to be written and when it is done. At the update time, all the
211  * elements on the id_newinoupdt list are moved to the id_inoupdt list
212  * since those changes are now relevant to the copy of the inode in the
213  * buffer. Also at update time, the tasks on the id_inowait list are
214  * moved to the id_bufwait list so that they will be executed when
215  * the updated inode has been written to disk. When the buffer containing
216  * the inode is written to disk, any updates listed on the id_inoupdt
217  * list are rolled back as they are not yet safe. Following the write,
218  * the changes are once again rolled forward and any actions on the
219  * id_bufwait list are processed (since those actions are now safe).
220  * The entries on the id_inoupdt and id_newinoupdt lists must be kept
221  * sorted by logical block number to speed the calculation of the size
222  * of the rolled back inode (see explanation in initiate_write_inodeblock).
223  * When a directory entry is created, it is represented by a diradd.
224  * The diradd is added to the id_inowait list as it cannot be safely
225  * written to disk until the inode that it represents is on disk. After
226  * the inode is written, the id_bufwait list is processed and the diradd
227  * entries are moved to the id_pendinghd list where they remain until
228  * the directory block containing the name has been written to disk.
229  * The purpose of keeping the entries on the id_pendinghd list is so that
230  * the softdep_fsync function can find and push the inode's directory
231  * name(s) as part of the fsync operation for that file.
232  */
233 struct inodedep {
234 	struct	worklist id_list;	/* buffer holding inode block */
235 #	define	id_state id_list.wk_state /* inode dependency state */
236 	LIST_ENTRY(inodedep) id_hash;	/* hashed lookup */
237 	struct	fs *id_fs;		/* associated filesystem */
238 	ino_t	id_ino;			/* dependent inode */
239 	nlink_t	id_nlinkdelta;		/* saved effective link count */
240 	struct	ufs1_dinode *id_savedino; /* saved dinode contents */
241 	LIST_ENTRY(inodedep) id_deps;	/* bmsafemap's list of inodedep's */
242 	struct	buf *id_buf;		/* related bmsafemap (if pending) */
243 	off_t	id_savedsize;		/* file size saved during rollback */
244 	struct	workhead id_pendinghd;	/* entries awaiting directory write */
245 	struct	workhead id_bufwait;	/* operations after inode written */
246 	struct	workhead id_inowait;	/* operations waiting inode update */
247 	struct	allocdirectlst id_inoupdt; /* updates before inode written */
248 	struct	allocdirectlst id_newinoupdt; /* updates when inode written */
249 };
250 
251 /*
252  * A "newblk" structure is attached to a bmsafemap structure when a block
253  * or fragment is allocated from a cylinder group. Its state is set to
254  * DEPCOMPLETE when its cylinder group map is written. It is consumed by
255  * an associated allocdirect or allocindir allocation which will attach
256  * themselves to the bmsafemap structure if the newblk's DEPCOMPLETE flag
257  * is not set (i.e., its cylinder group map has not been written).
258  */
259 struct newblk {
260 	LIST_ENTRY(newblk) nb_hash;	/* hashed lookup */
261 	struct	fs *nb_fs;		/* associated filesystem */
262 	ufs_daddr_t nb_newblkno;	/* allocated block number */
263 	int	nb_state;		/* state of bitmap dependency */
264 	LIST_ENTRY(newblk) nb_deps;	/* bmsafemap's list of newblk's */
265 	struct	bmsafemap *nb_bmsafemap; /* associated bmsafemap */
266 };
267 
268 /*
269  * A "bmsafemap" structure maintains a list of dependency structures
270  * that depend on the update of a particular cylinder group map.
271  * It has lists for newblks, allocdirects, allocindirs, and inodedeps.
272  * It is attached to the buffer of a cylinder group block when any of
273  * these things are allocated from the cylinder group. It is freed
274  * after the cylinder group map is written and the state of its
275  * dependencies are updated with DEPCOMPLETE to indicate that it has
276  * been processed.
277  */
278 struct bmsafemap {
279 	struct	worklist sm_list;	/* cylgrp buffer */
280 	struct	buf *sm_buf;		/* associated buffer */
281 	struct	allocdirecthd sm_allocdirecthd; /* allocdirect deps */
282 	struct	allocindirhd sm_allocindirhd; /* allocindir deps */
283 	struct	inodedephd sm_inodedephd; /* inodedep deps */
284 	struct	newblkhd sm_newblkhd;	/* newblk deps */
285 };
286 
287 /*
288  * An "allocdirect" structure is attached to an "inodedep" when a new block
289  * or fragment is allocated and pointed to by the inode described by
290  * "inodedep". The worklist is linked to the buffer that holds the block.
291  * When the block is first allocated, it is linked to the bmsafemap
292  * structure associated with the buffer holding the cylinder group map
293  * from which it was allocated. When the cylinder group map is written
294  * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself
295  * is written, the COMPLETE flag is set. Once both the cylinder group map
296  * and the data itself have been written, it is safe to write the inode
297  * that claims the block. If there was a previous fragment that had been
298  * allocated before the file was increased in size, the old fragment may
299  * be freed once the inode claiming the new block is written to disk.
300  * This ad_fragfree request is attached to the id_inowait list of the
301  * associated inodedep (pointed to by ad_inodedep) for processing after
302  * the inode is written.
303  */
304 struct allocdirect {
305 	struct	worklist ad_list;	/* buffer holding block */
306 #	define	ad_state ad_list.wk_state /* block pointer state */
307 	TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */
308 	ufs_lbn_t ad_lbn;		/* block within file */
309 	ufs_daddr_t ad_newblkno;	/* new value of block pointer */
310 	ufs_daddr_t ad_oldblkno;	/* old value of block pointer */
311 	long	ad_newsize;		/* size of new block */
312 	long	ad_oldsize;		/* size of old block */
313 	LIST_ENTRY(allocdirect) ad_deps; /* bmsafemap's list of allocdirect's */
314 	struct	buf *ad_buf;		/* cylgrp buffer (if pending) */
315 	struct	inodedep *ad_inodedep;	/* associated inodedep */
316 	struct	freefrag *ad_freefrag;	/* fragment to be freed (if any) */
317 };
318 
319 /*
320  * A single "indirdep" structure manages all allocation dependencies for
321  * pointers in an indirect block. The up-to-date state of the indirect
322  * block is stored in ir_savedata. The set of pointers that may be safely
323  * written to the disk is stored in ir_safecopy. The state field is used
324  * only to track whether the buffer is currently being written (in which
325  * case it is not safe to update ir_safecopy). Ir_deplisthd contains the
326  * list of allocindir structures, one for each block that needs to be
327  * written to disk. Once the block and its bitmap allocation have been
328  * written the safecopy can be updated to reflect the allocation and the
329  * allocindir structure freed. If ir_state indicates that an I/O on the
330  * indirect block is in progress when ir_safecopy is to be updated, the
331  * update is deferred by placing the allocindir on the ir_donehd list.
332  * When the I/O on the indirect block completes, the entries on the
333  * ir_donehd list are processed by updating their corresponding ir_safecopy
334  * pointers and then freeing the allocindir structure.
335  */
336 struct indirdep {
337 	struct	worklist ir_list;	/* buffer holding indirect block */
338 #	define	ir_state ir_list.wk_state /* indirect block pointer state */
339 	caddr_t ir_saveddata;		/* buffer cache contents */
340 	struct	buf *ir_savebp;		/* buffer holding safe copy */
341 	struct	allocindirhd ir_donehd;	/* done waiting to update safecopy */
342 	struct	allocindirhd ir_deplisthd; /* allocindir deps for this block */
343 };
344 
345 /*
346  * An "allocindir" structure is attached to an "indirdep" when a new block
347  * is allocated and pointed to by the indirect block described by the
348  * "indirdep". The worklist is linked to the buffer that holds the new block.
349  * When the block is first allocated, it is linked to the bmsafemap
350  * structure associated with the buffer holding the cylinder group map
351  * from which it was allocated. When the cylinder group map is written
352  * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself
353  * is written, the COMPLETE flag is set. Once both the cylinder group map
354  * and the data itself have been written, it is safe to write the entry in
355  * the indirect block that claims the block; the "allocindir" dependency
356  * can then be freed as it is no longer applicable.
357  */
358 struct allocindir {
359 	struct	worklist ai_list;	/* buffer holding indirect block */
360 #	define	ai_state ai_list.wk_state /* indirect block pointer state */
361 	LIST_ENTRY(allocindir) ai_next;	/* indirdep's list of allocindir's */
362 	int	ai_offset;		/* pointer offset in indirect block */
363 	ufs_daddr_t ai_newblkno;	/* new block pointer value */
364 	ufs_daddr_t ai_oldblkno;	/* old block pointer value */
365 	struct	freefrag *ai_freefrag;	/* block to be freed when complete */
366 	struct	indirdep *ai_indirdep;	/* address of associated indirdep */
367 	LIST_ENTRY(allocindir) ai_deps;	/* bmsafemap's list of allocindir's */
368 	struct	buf *ai_buf;		/* cylgrp buffer (if pending) */
369 };
370 
371 /*
372  * A "freefrag" structure is attached to an "inodedep" when a previously
373  * allocated fragment is replaced with a larger fragment, rather than extended.
374  * The "freefrag" structure is constructed and attached when the replacement
375  * block is first allocated. It is processed after the inode claiming the
376  * bigger block that replaces it has been written to disk. Note that the
377  * ff_state field is used to store the uid, so may lose data. However,
378  * the uid is used only in printing an error message, so is not critical.
379  * Keeping it in a short keeps the data structure down to 32 bytes.
380  */
381 struct freefrag {
382 	struct	worklist ff_list;	/* id_inowait or delayed worklist */
383 #	define	ff_state ff_list.wk_state /* owning user; should be uid_t */
384 	struct	vnode *ff_devvp;	/* filesystem device vnode */
385 	struct	fs *ff_fs;		/* addr of superblock */
386 	ufs_daddr_t ff_blkno;		/* fragment physical block number */
387 	long	ff_fragsize;		/* size of fragment being deleted */
388 	ino_t	ff_inum;		/* owning inode number */
389 };
390 
391 /*
392  * A "freeblks" structure is attached to an "inodedep" when the
393  * corresponding file's length is reduced to zero. It records all
394  * the information needed to free the blocks of a file after its
395  * zero'ed inode has been written to disk.
396  */
397 struct freeblks {
398 	struct	worklist fb_list;	/* id_inowait or delayed worklist */
399 #	define  fb_state fb_list.wk_state /* inode and dirty block state */
400 	ino_t	fb_previousinum;	/* inode of previous owner of blocks */
401 	struct	vnode *fb_devvp;	/* filesystem device vnode */
402 	struct	fs *fb_fs;		/* addr of superblock */
403 	off_t	fb_oldsize;		/* previous file size */
404 	off_t	fb_newsize;		/* new file size */
405 	int	fb_chkcnt;		/* used to check cnt of blks released */
406 	uid_t	fb_uid;			/* uid of previous owner of blocks */
407 	ufs_daddr_t fb_dblks[UFS_NDADDR]; /* direct blk ptrs to deallocate */
408 	ufs_daddr_t fb_iblks[UFS_NIADDR]; /* indirect blk ptrs to deallocate */
409 };
410 
411 /*
412  * A "freefile" structure is attached to an inode when its
413  * link count is reduced to zero. It marks the inode as free in
414  * the cylinder group map after the zero'ed inode has been written
415  * to disk and any associated blocks and fragments have been freed.
416  */
417 struct freefile {
418 	struct	worklist fx_list;	/* id_inowait or delayed worklist */
419 	mode_t	fx_mode;		/* mode of inode */
420 	ino_t	fx_oldinum;		/* inum of the unlinked file */
421 	struct	vnode *fx_devvp;	/* filesystem device vnode */
422 	struct	fs *fx_fs;		/* addr of superblock */
423 };
424 
425 /*
426  * A "diradd" structure is linked to an "inodedep" id_inowait list when a
427  * new directory entry is allocated that references the inode described
428  * by "inodedep". When the inode itself is written (either the initial
429  * allocation for new inodes or with the increased link count for
430  * existing inodes), the COMPLETE flag is set in da_state. If the entry
431  * is for a newly allocated inode, the "inodedep" structure is associated
432  * with a bmsafemap which prevents the inode from being written to disk
433  * until the cylinder group has been updated. Thus the da_state COMPLETE
434  * flag cannot be set until the inode bitmap dependency has been removed.
435  * When creating a new file, it is safe to write the directory entry that
436  * claims the inode once the referenced inode has been written. Since
437  * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag
438  * in the diradd can be set unconditionally when creating a file. When
439  * creating a directory, there are two additional dependencies described by
440  * mkdir structures (see their description below). When these dependencies
441  * are resolved the DEPCOMPLETE flag is set in the diradd structure.
442  * If there are multiple links created to the same inode, there will be
443  * a separate diradd structure created for each link. The diradd is
444  * linked onto the pg_diraddhd list of the pagedep for the directory
445  * page that contains the entry. When a directory page is written,
446  * the pg_diraddhd list is traversed to rollback any entries that are
447  * not yet ready to be written to disk. If a directory entry is being
448  * changed (by rename) rather than added, the DIRCHG flag is set and
449  * the da_previous entry points to the entry that will be "removed"
450  * once the new entry has been committed. During rollback, entries
451  * with da_previous are replaced with the previous inode number rather
452  * than zero.
453  *
454  * The overlaying of da_pagedep and da_previous is done to keep the
455  * structure down to 32 bytes in size on a 32-bit machine. If a
456  * da_previous entry is present, the pointer to its pagedep is available
457  * in the associated dirrem entry. If the DIRCHG flag is set, the
458  * da_previous entry is valid; if not set the da_pagedep entry is valid.
459  * The DIRCHG flag never changes; it is set when the structure is created
460  * if appropriate and is never cleared.
461  */
462 struct diradd {
463 	struct	worklist da_list;	/* id_inowait or id_pendinghd list */
464 #	define	da_state da_list.wk_state /* state of the new directory entry */
465 	LIST_ENTRY(diradd) da_pdlist;	/* pagedep holding directory block */
466 	doff_t	da_offset;		/* offset of new dir entry in dir blk */
467 	ino_t	da_newinum;		/* inode number for the new dir entry */
468 	union {
469 	struct	dirrem *dau_previous;	/* entry being replaced in dir change */
470 	struct	pagedep *dau_pagedep;	/* pagedep dependency for addition */
471 	} da_un;
472 };
473 #define da_previous da_un.dau_previous
474 #define da_pagedep da_un.dau_pagedep
475 
476 /*
477  * Two "mkdir" structures are needed to track the additional dependencies
478  * associated with creating a new directory entry. Normally a directory
479  * addition can be committed as soon as the newly referenced inode has been
480  * written to disk with its increased link count. When a directory is
481  * created there are two additional dependencies: writing the directory
482  * data block containing the "." and ".." entries (MKDIR_BODY) and writing
483  * the parent inode with the increased link count for ".." (MKDIR_PARENT).
484  * These additional dependencies are tracked by two mkdir structures that
485  * reference the associated "diradd" structure. When they have completed,
486  * they set the DEPCOMPLETE flag on the diradd so that it knows that its
487  * extra dependencies have been completed. The md_state field is used only
488  * to identify which type of dependency the mkdir structure is tracking.
489  * It is not used in the mainline code for any purpose other than consistency
490  * checking. All the mkdir structures in the system are linked together on
491  * a list. This list is needed so that a diradd can find its associated
492  * mkdir structures and deallocate them if it is prematurely freed (as for
493  * example if a mkdir is immediately followed by a rmdir of the same directory).
494  * Here, the free of the diradd must traverse the list to find the associated
495  * mkdir structures that reference it. The deletion would be faster if the
496  * diradd structure were simply augmented to have two pointers that referenced
497  * the associated mkdir's. However, this would increase the size of the diradd
498  * structure from 32 to 64-bits to speed a very infrequent operation.
499  */
500 struct mkdir {
501 	struct	worklist md_list;	/* id_inowait or buffer holding dir */
502 #	define	md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */
503 	struct	diradd *md_diradd;	/* associated diradd */
504 	struct	buf *md_buf;		/* MKDIR_BODY: buffer holding dir */
505 	LIST_ENTRY(mkdir) md_mkdirs;	/* list of all mkdirs */
506 };
507 LIST_HEAD(mkdirlist, mkdir) mkdirlisthd;
508 
509 /*
510  * A "dirrem" structure describes an operation to decrement the link
511  * count on an inode. The dirrem structure is attached to the pg_dirremhd
512  * list of the pagedep for the directory page that contains the entry.
513  * It is processed after the directory page with the deleted entry has
514  * been written to disk.
515  *
516  * The overlaying of dm_pagedep and dm_dirinum is done to keep the
517  * structure down to 32 bytes in size on a 32-bit machine. It works
518  * because they are never used concurrently.
519  */
520 struct dirrem {
521 	struct	worklist dm_list;	/* delayed worklist */
522 #	define	dm_state dm_list.wk_state /* state of the old directory entry */
523 	LIST_ENTRY(dirrem) dm_next;	/* pagedep's list of dirrem's */
524 	struct	mount *dm_mnt;		/* associated mount point */
525 	ino_t	dm_oldinum;		/* inum of the removed dir entry */
526 	union {
527 	struct	pagedep *dmu_pagedep;	/* pagedep dependency for remove */
528 	ino_t	dmu_dirinum;		/* parent inode number (for rmdir) */
529 	} dm_un;
530 };
531 #define dm_pagedep dm_un.dmu_pagedep
532 #define dm_dirinum dm_un.dmu_dirinum
533