1139825Simp/*- 261926Smckusick * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved. 336201Sjulian * 436206Sjulian * The soft updates code is derived from the appendix of a University 536206Sjulian * of Michigan technical report (Gregory R. Ganger and Yale N. Patt, 636206Sjulian * "Soft Updates: A Solution to the Metadata Update Problem in File 736206Sjulian * Systems", CSE-TR-254-95, August 1995). 836201Sjulian * 961926Smckusick * Further information about soft updates can be obtained from: 1036201Sjulian * 1161926Smckusick * Marshall Kirk McKusick http://www.mckusick.com/softdep/ 1261926Smckusick * 1614 Oxford Street mckusick@mckusick.com 1361926Smckusick * Berkeley, CA 94709-1608 +1-510-843-9542 1436201Sjulian * USA 1536201Sjulian * 1636201Sjulian * Redistribution and use in source and binary forms, with or without 1736201Sjulian * modification, are permitted provided that the following conditions 1836201Sjulian * are met: 1936201Sjulian * 2036201Sjulian * 1. Redistributions of source code must retain the above copyright 2136201Sjulian * notice, this list of conditions and the following disclaimer. 2236201Sjulian * 2. Redistributions in binary form must reproduce the above copyright 2336201Sjulian * notice, this list of conditions and the following disclaimer in the 2436201Sjulian * documentation and/or other materials provided with the distribution. 2536201Sjulian * 2636201Sjulian * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY 2736201Sjulian * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 2836201Sjulian * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 2936201Sjulian * DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR 3036201Sjulian * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 3136201Sjulian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 3236201Sjulian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3336201Sjulian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 3436201Sjulian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 3536201Sjulian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3636201Sjulian * SUCH DAMAGE. 3736201Sjulian * 3861926Smckusick * @(#)softdep.h 9.7 (McKusick) 6/21/00 3950480Speter * $FreeBSD$ 4036201Sjulian */ 4136201Sjulian 4236201Sjulian#include <sys/queue.h> 4336201Sjulian 4436201Sjulian/* 4536201Sjulian * Allocation dependencies are handled with undo/redo on the in-memory 4636201Sjulian * copy of the data. A particular data dependency is eliminated when 4736201Sjulian * it is ALLCOMPLETE: that is ATTACHED, DEPCOMPLETE, and COMPLETE. 4836201Sjulian * 49208287Sjeff * The ATTACHED flag means that the data is not currently being written 50208287Sjeff * to disk. 51208287Sjeff * 52208287Sjeff * The UNDONE flag means that the data has been rolled back to a safe 5336201Sjulian * state for writing to the disk. When the I/O completes, the data is 5436201Sjulian * restored to its current form and the state reverts to ATTACHED. 5536201Sjulian * The data must be locked throughout the rollback, I/O, and roll 5636201Sjulian * forward so that the rolled back information is never visible to 57208287Sjeff * user processes. 58208287Sjeff * 59208287Sjeff * The COMPLETE flag indicates that the item has been written. For example, 60208287Sjeff * a dependency that requires that an inode be written will be marked 61208287Sjeff * COMPLETE after the inode has been written to disk. 62208287Sjeff * 63208287Sjeff * The DEPCOMPLETE flag indicates the completion of any other 6436201Sjulian * dependencies such as the writing of a cylinder group map has been 6536201Sjulian * completed. A dependency structure may be freed only when both it 6636201Sjulian * and its dependencies have completed and any rollbacks that are in 6736201Sjulian * progress have finished as indicated by the set of ALLCOMPLETE flags 68208287Sjeff * all being set. 69208287Sjeff * 70208287Sjeff * The two MKDIR flags indicate additional dependencies that must be done 71208287Sjeff * when creating a new directory. MKDIR_BODY is cleared when the directory 72208287Sjeff * data block containing the "." and ".." entries has been written. 73208287Sjeff * MKDIR_PARENT is cleared when the parent inode with the increased link 74208287Sjeff * count for ".." has been written. When both MKDIR flags have been 75208287Sjeff * cleared, the DEPCOMPLETE flag is set to indicate that the directory 76208287Sjeff * dependencies have been completed. The writing of the directory inode 77208287Sjeff * itself sets the COMPLETE flag which then allows the directory entry for 78208287Sjeff * the new directory to be written to disk. The RMDIR flag marks a dirrem 79208287Sjeff * structure as representing the removal of a directory rather than a 80208287Sjeff * file. When the removal dependencies are completed, additional work needs 81208287Sjeff * to be done* (an additional decrement of the associated inode, and a 82208287Sjeff * decrement of the parent inode). 83208287Sjeff * 84208287Sjeff * The DIRCHG flag marks a diradd structure as representing the changing 8536201Sjulian * of an existing entry rather than the addition of a new one. When 8636201Sjulian * the update is complete the dirrem associated with the inode for 8736201Sjulian * the old name must be added to the worklist to do the necessary 88208287Sjeff * reference count decrement. 89208287Sjeff * 90208287Sjeff * The GOINGAWAY flag indicates that the data structure is frozen from 91208287Sjeff * further change until its dependencies have been completed and its 92208287Sjeff * resources freed after which it will be discarded. 93208287Sjeff * 94208287Sjeff * The IOSTARTED flag prevents multiple calls to the I/O start routine from 95208287Sjeff * doing multiple rollbacks. 96208287Sjeff * 97208287Sjeff * The NEWBLOCK flag marks pagedep structures that have just been allocated, 98208287Sjeff * so must be claimed by the inode before all dependencies are complete. 99208287Sjeff * 100208287Sjeff * The INPROGRESS flag marks worklist structures that are still on the 101208287Sjeff * worklist, but are being considered for action by some process. 102208287Sjeff * 103208287Sjeff * The UFS1FMT flag indicates that the inode being processed is a ufs1 format. 104208287Sjeff * 105208287Sjeff * The EXTDATA flag indicates that the allocdirect describes an 106208287Sjeff * extended-attributes dependency. 107208287Sjeff * 108100344Smckusick * The ONWORKLIST flag shows whether the structure is currently linked 109100344Smckusick * onto a worklist. 110212617Smckusick * 111212617Smckusick * The UNLINK* flags track the progress of updating the on-disk linked 112212617Smckusick * list of active but unlinked inodes. When an inode is first unlinked 113212617Smckusick * it is marked as UNLINKED. When its on-disk di_freelink has been 114212617Smckusick * written its UNLINKNEXT flags is set. When its predecessor in the 115212617Smckusick * list has its di_freelink pointing at us its UNLINKPREV is set. 116212617Smckusick * When the on-disk list can reach it from the superblock, its 117212617Smckusick * UNLINKONLIST flag is set. Once all of these flags are set, it 118212617Smckusick * is safe to let its last name be removed. 11936201Sjulian */ 120207141Sjeff#define ATTACHED 0x000001 121207141Sjeff#define UNDONE 0x000002 122207141Sjeff#define COMPLETE 0x000004 123207141Sjeff#define DEPCOMPLETE 0x000008 124207141Sjeff#define MKDIR_PARENT 0x000010 /* diradd, mkdir, jaddref, jsegdep only */ 125207141Sjeff#define MKDIR_BODY 0x000020 /* diradd, mkdir, jaddref only */ 126207141Sjeff#define RMDIR 0x000040 /* dirrem only */ 127207141Sjeff#define DIRCHG 0x000080 /* diradd, dirrem only */ 128207141Sjeff#define GOINGAWAY 0x000100 /* indirdep, jremref only */ 129207141Sjeff#define IOSTARTED 0x000200 /* inodedep, pagedep, bmsafemap only */ 130222958Sjeff#define DELAYEDFREE 0x000400 /* allocindirect free delayed. */ 131207141Sjeff#define NEWBLOCK 0x000800 /* pagedep, jaddref only */ 132207141Sjeff#define INPROGRESS 0x001000 /* dirrem, freeblks, freefrag, freefile only */ 133207141Sjeff#define UFS1FMT 0x002000 /* indirdep only */ 134207141Sjeff#define EXTDATA 0x004000 /* allocdirect only */ 135207141Sjeff#define ONWORKLIST 0x008000 136207141Sjeff#define IOWAITING 0x010000 /* Thread is waiting for IO to complete. */ 137207141Sjeff#define ONDEPLIST 0x020000 /* Structure is on a dependency list. */ 138207141Sjeff#define UNLINKED 0x040000 /* inodedep has been unlinked. */ 139207141Sjeff#define UNLINKNEXT 0x080000 /* inodedep has valid di_freelink */ 140207141Sjeff#define UNLINKPREV 0x100000 /* inodedep is pointed at in the unlink list */ 141207141Sjeff#define UNLINKONLIST 0x200000 /* inodedep is in the unlinked list on disk */ 142207141Sjeff#define UNLINKLINKS (UNLINKNEXT | UNLINKPREV) 14336201Sjulian 14436201Sjulian#define ALLCOMPLETE (ATTACHED | COMPLETE | DEPCOMPLETE) 14536201Sjulian 14636201Sjulian/* 14736201Sjulian * The workitem queue. 14836201Sjulian * 14936201Sjulian * It is sometimes useful and/or necessary to clean up certain dependencies 15036201Sjulian * in the background rather than during execution of an application process 15136201Sjulian * or interrupt service routine. To realize this, we append dependency 15236201Sjulian * structures corresponding to such tasks to a "workitem" queue. In a soft 15336201Sjulian * updates implementation, most pending workitems should not wait for more 15436201Sjulian * than a couple of seconds, so the filesystem syncer process awakens once 15536201Sjulian * per second to process the items on the queue. 15636201Sjulian */ 15736201Sjulian 15860938Sjake/* LIST_HEAD(workhead, worklist); -- declared in buf.h */ 15936201Sjulian 16036201Sjulian/* 16136201Sjulian * Each request can be linked onto a work queue through its worklist structure. 16236201Sjulian * To avoid the need for a pointer to the structure itself, this structure 16336201Sjulian * MUST be declared FIRST in each type in which it appears! If more than one 16436201Sjulian * worklist is needed in the structure, then a wk_data field must be added 16536201Sjulian * and the macros below changed to use it. 16636201Sjulian */ 16736201Sjulianstruct worklist { 168207141Sjeff LIST_ENTRY(worklist) wk_list; /* list of work requests */ 169156203Sjeff struct mount *wk_mp; /* Mount we live in */ 170207141Sjeff unsigned int wk_type:8, /* type of request */ 171207141Sjeff wk_state:24; /* state flags */ 17236201Sjulian}; 17336201Sjulian#define WK_DATA(wk) ((void *)(wk)) 17436201Sjulian#define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) 17536201Sjulian#define WK_INODEDEP(wk) ((struct inodedep *)(wk)) 17636201Sjulian#define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) 177207141Sjeff#define WK_NEWBLK(wk) ((struct newblk *)(wk)) 17836201Sjulian#define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) 17936201Sjulian#define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) 18036201Sjulian#define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) 18136201Sjulian#define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) 18236201Sjulian#define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) 183207141Sjeff#define WK_FREEWORK(wk) ((struct freework *)(wk)) 18436201Sjulian#define WK_FREEFILE(wk) ((struct freefile *)(wk)) 18536201Sjulian#define WK_DIRADD(wk) ((struct diradd *)(wk)) 18636201Sjulian#define WK_MKDIR(wk) ((struct mkdir *)(wk)) 18736201Sjulian#define WK_DIRREM(wk) ((struct dirrem *)(wk)) 18876724Smckusick#define WK_NEWDIRBLK(wk) ((struct newdirblk *)(wk)) 189207141Sjeff#define WK_JADDREF(wk) ((struct jaddref *)(wk)) 190207141Sjeff#define WK_JREMREF(wk) ((struct jremref *)(wk)) 191207141Sjeff#define WK_JMVREF(wk) ((struct jmvref *)(wk)) 192207141Sjeff#define WK_JSEGDEP(wk) ((struct jsegdep *)(wk)) 193207141Sjeff#define WK_JSEG(wk) ((struct jseg *)(wk)) 194207141Sjeff#define WK_JNEWBLK(wk) ((struct jnewblk *)(wk)) 195207141Sjeff#define WK_JFREEBLK(wk) ((struct jfreeblk *)(wk)) 196207141Sjeff#define WK_FREEDEP(wk) ((struct freedep *)(wk)) 197207141Sjeff#define WK_JFREEFRAG(wk) ((struct jfreefrag *)(wk)) 198222958Sjeff#define WK_SBDEP(wk) ((struct sbdep *)(wk)) 199207141Sjeff#define WK_JTRUNC(wk) ((struct jtrunc *)(wk)) 200222958Sjeff#define WK_JFSYNC(wk) ((struct jfsync *)(wk)) 20136201Sjulian 20236201Sjulian/* 20336201Sjulian * Various types of lists 20436201Sjulian */ 20560938SjakeLIST_HEAD(dirremhd, dirrem); 20660938SjakeLIST_HEAD(diraddhd, diradd); 20760938SjakeLIST_HEAD(newblkhd, newblk); 20860938SjakeLIST_HEAD(inodedephd, inodedep); 20960938SjakeLIST_HEAD(allocindirhd, allocindir); 21060938SjakeLIST_HEAD(allocdirecthd, allocdirect); 21160938SjakeTAILQ_HEAD(allocdirectlst, allocdirect); 212207141SjeffLIST_HEAD(indirdephd, indirdep); 213207141SjeffLIST_HEAD(jaddrefhd, jaddref); 214207141SjeffLIST_HEAD(jremrefhd, jremref); 215207141SjeffLIST_HEAD(jmvrefhd, jmvref); 216207141SjeffLIST_HEAD(jnewblkhd, jnewblk); 217222958SjeffLIST_HEAD(jblkdephd, jblkdep); 218207141SjeffLIST_HEAD(freeworkhd, freework); 219222958SjeffTAILQ_HEAD(freeworklst, freework); 220207141SjeffTAILQ_HEAD(jseglst, jseg); 221207141SjeffTAILQ_HEAD(inoreflst, inoref); 222222958SjeffTAILQ_HEAD(freeblklst, freeblks); 22336201Sjulian 22436201Sjulian/* 22536201Sjulian * The "pagedep" structure tracks the various dependencies related to 22636201Sjulian * a particular directory page. If a directory page has any dependencies, 22736201Sjulian * it will have a pagedep linked to its associated buffer. The 22836201Sjulian * pd_dirremhd list holds the list of dirrem requests which decrement 22936201Sjulian * inode reference counts. These requests are processed after the 23036201Sjulian * directory page with the corresponding zero'ed entries has been 23136201Sjulian * written. The pd_diraddhd list maintains the list of diradd requests 23236201Sjulian * which cannot be committed until their corresponding inode has been 23336201Sjulian * written to disk. Because a directory may have many new entries 23436201Sjulian * being created, several lists are maintained hashed on bits of the 23536201Sjulian * offset of the entry into the directory page to keep the lists from 23636201Sjulian * getting too long. Once a new directory entry has been cleared to 23736201Sjulian * be written, it is moved to the pd_pendinghd list. After the new 23836201Sjulian * entry has been written to disk it is removed from the pd_pendinghd 23936201Sjulian * list, any removed operations are done, and the dependency structure 24036201Sjulian * is freed. 24136201Sjulian */ 24298542Smckusick#define DAHASHSZ 5 24336201Sjulian#define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) 24436201Sjulianstruct pagedep { 24536201Sjulian struct worklist pd_list; /* page buffer */ 24636201Sjulian# define pd_state pd_list.wk_state /* check for multiple I/O starts */ 24760938Sjake LIST_ENTRY(pagedep) pd_hash; /* hashed lookup */ 24836201Sjulian ino_t pd_ino; /* associated file */ 24936201Sjulian ufs_lbn_t pd_lbn; /* block within file */ 250207141Sjeff struct newdirblk *pd_newdirblk; /* associated newdirblk if NEWBLOCK */ 25136201Sjulian struct dirremhd pd_dirremhd; /* dirrem's waiting for page */ 25236201Sjulian struct diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */ 25336201Sjulian struct diraddhd pd_pendinghd; /* directory entries awaiting write */ 254207141Sjeff struct jmvrefhd pd_jmvrefhd; /* Dependent journal writes. */ 25536201Sjulian}; 25636201Sjulian 25736201Sjulian/* 25836201Sjulian * The "inodedep" structure tracks the set of dependencies associated 25936225Sjulian * with an inode. One task that it must manage is delayed operations 26036225Sjulian * (i.e., work requests that must be held until the inodedep's associated 26136225Sjulian * inode has been written to disk). Getting an inode from its incore 26236225Sjulian * state to the disk requires two steps to be taken by the filesystem 26336225Sjulian * in this order: first the inode must be copied to its disk buffer by 26436225Sjulian * the VOP_UPDATE operation; second the inode's buffer must be written 26536225Sjulian * to disk. To ensure that both operations have happened in the required 26636225Sjulian * order, the inodedep maintains two lists. Delayed operations are 26736225Sjulian * placed on the id_inowait list. When the VOP_UPDATE is done, all 26836225Sjulian * operations on the id_inowait list are moved to the id_bufwait list. 26936225Sjulian * When the buffer is written, the items on the id_bufwait list can be 27036225Sjulian * safely moved to the work queue to be processed. A second task of the 27136225Sjulian * inodedep structure is to track the status of block allocation within 27236225Sjulian * the inode. Each block that is allocated is represented by an 27336201Sjulian * "allocdirect" structure (see below). It is linked onto the id_newinoupdt 27436201Sjulian * list until both its contents and its allocation in the cylinder 27536225Sjulian * group map have been written to disk. Once these dependencies have been 27636201Sjulian * satisfied, it is removed from the id_newinoupdt list and any followup 27736201Sjulian * actions such as releasing the previous block or fragment are placed 27836225Sjulian * on the id_inowait list. When an inode is updated (a VOP_UPDATE is 27936225Sjulian * done), the "inodedep" structure is linked onto the buffer through 28036225Sjulian * its worklist. Thus, it will be notified when the buffer is about 28136201Sjulian * to be written and when it is done. At the update time, all the 28236201Sjulian * elements on the id_newinoupdt list are moved to the id_inoupdt list 28336201Sjulian * since those changes are now relevant to the copy of the inode in the 28436225Sjulian * buffer. Also at update time, the tasks on the id_inowait list are 28536225Sjulian * moved to the id_bufwait list so that they will be executed when 28636225Sjulian * the updated inode has been written to disk. When the buffer containing 28736225Sjulian * the inode is written to disk, any updates listed on the id_inoupdt 28836225Sjulian * list are rolled back as they are not yet safe. Following the write, 28936225Sjulian * the changes are once again rolled forward and any actions on the 29036225Sjulian * id_bufwait list are processed (since those actions are now safe). 29136201Sjulian * The entries on the id_inoupdt and id_newinoupdt lists must be kept 29236201Sjulian * sorted by logical block number to speed the calculation of the size 29336201Sjulian * of the rolled back inode (see explanation in initiate_write_inodeblock). 29436206Sjulian * When a directory entry is created, it is represented by a diradd. 29536225Sjulian * The diradd is added to the id_inowait list as it cannot be safely 29636225Sjulian * written to disk until the inode that it represents is on disk. After 29736225Sjulian * the inode is written, the id_bufwait list is processed and the diradd 29836206Sjulian * entries are moved to the id_pendinghd list where they remain until 29936206Sjulian * the directory block containing the name has been written to disk. 30036206Sjulian * The purpose of keeping the entries on the id_pendinghd list is so that 30136206Sjulian * the softdep_fsync function can find and push the inode's directory 30236206Sjulian * name(s) as part of the fsync operation for that file. 30336201Sjulian */ 30436201Sjulianstruct inodedep { 30536201Sjulian struct worklist id_list; /* buffer holding inode block */ 30636201Sjulian# define id_state id_list.wk_state /* inode dependency state */ 30760938Sjake LIST_ENTRY(inodedep) id_hash; /* hashed lookup */ 308207141Sjeff TAILQ_ENTRY(inodedep) id_unlinked; /* Unlinked but ref'd inodes */ 30936201Sjulian struct fs *id_fs; /* associated filesystem */ 31036201Sjulian ino_t id_ino; /* dependent inode */ 31136201Sjulian nlink_t id_nlinkdelta; /* saved effective link count */ 312207141Sjeff nlink_t id_savednlink; /* Link saved during rollback */ 31360938Sjake LIST_ENTRY(inodedep) id_deps; /* bmsafemap's list of inodedep's */ 314207141Sjeff struct bmsafemap *id_bmsafemap; /* related bmsafemap (if pending) */ 315207141Sjeff struct diradd *id_mkdiradd; /* diradd for a mkdir. */ 316207141Sjeff struct inoreflst id_inoreflst; /* Inode reference adjustments. */ 317100344Smckusick long id_savedextsize; /* ext size saved during rollback */ 31836201Sjulian off_t id_savedsize; /* file size saved during rollback */ 319207141Sjeff struct dirremhd id_dirremhd; /* Removals pending. */ 32036201Sjulian struct workhead id_pendinghd; /* entries awaiting directory write */ 32136225Sjulian struct workhead id_bufwait; /* operations after inode written */ 32236225Sjulian struct workhead id_inowait; /* operations waiting inode update */ 32336201Sjulian struct allocdirectlst id_inoupdt; /* updates before inode written */ 32436201Sjulian struct allocdirectlst id_newinoupdt; /* updates when inode written */ 325100344Smckusick struct allocdirectlst id_extupdt; /* extdata updates pre-inode write */ 326100344Smckusick struct allocdirectlst id_newextupdt; /* extdata updates at ino write */ 327222958Sjeff struct freeblklst id_freeblklst; /* List of partial truncates. */ 32898542Smckusick union { 32998542Smckusick struct ufs1_dinode *idu_savedino1; /* saved ufs1_dinode contents */ 33098542Smckusick struct ufs2_dinode *idu_savedino2; /* saved ufs2_dinode contents */ 33198542Smckusick } id_un; 33236201Sjulian}; 33398542Smckusick#define id_savedino1 id_un.idu_savedino1 33498542Smckusick#define id_savedino2 id_un.idu_savedino2 33536201Sjulian 33636201Sjulian/* 33736201Sjulian * A "bmsafemap" structure maintains a list of dependency structures 33836201Sjulian * that depend on the update of a particular cylinder group map. 33936201Sjulian * It has lists for newblks, allocdirects, allocindirs, and inodedeps. 34036201Sjulian * It is attached to the buffer of a cylinder group block when any of 34136201Sjulian * these things are allocated from the cylinder group. It is freed 34236201Sjulian * after the cylinder group map is written and the state of its 34336201Sjulian * dependencies are updated with DEPCOMPLETE to indicate that it has 34436201Sjulian * been processed. 34536201Sjulian */ 34636201Sjulianstruct bmsafemap { 34736201Sjulian struct worklist sm_list; /* cylgrp buffer */ 348207141Sjeff# define sm_state sm_list.wk_state 349222958Sjeff LIST_ENTRY(bmsafemap) sm_hash; /* Hash links. */ 350222958Sjeff LIST_ENTRY(bmsafemap) sm_next; /* Mount list. */ 351207141Sjeff int sm_cg; 35236201Sjulian struct buf *sm_buf; /* associated buffer */ 35336201Sjulian struct allocdirecthd sm_allocdirecthd; /* allocdirect deps */ 354207141Sjeff struct allocdirecthd sm_allocdirectwr; /* writing allocdirect deps */ 35536201Sjulian struct allocindirhd sm_allocindirhd; /* allocindir deps */ 356207141Sjeff struct allocindirhd sm_allocindirwr; /* writing allocindir deps */ 35736201Sjulian struct inodedephd sm_inodedephd; /* inodedep deps */ 358207141Sjeff struct inodedephd sm_inodedepwr; /* writing inodedep deps */ 35936201Sjulian struct newblkhd sm_newblkhd; /* newblk deps */ 360207141Sjeff struct newblkhd sm_newblkwr; /* writing newblk deps */ 361207141Sjeff struct jaddrefhd sm_jaddrefhd; /* Pending inode allocations. */ 362207141Sjeff struct jnewblkhd sm_jnewblkhd; /* Pending block allocations. */ 363222958Sjeff struct workhead sm_freehd; /* Freedep deps. */ 364222958Sjeff struct workhead sm_freewr; /* Written freedeps. */ 36536201Sjulian}; 36636201Sjulian 36736201Sjulian/* 368207141Sjeff * A "newblk" structure is attached to a bmsafemap structure when a block 369207141Sjeff * or fragment is allocated from a cylinder group. Its state is set to 370207141Sjeff * DEPCOMPLETE when its cylinder group map is written. It is converted to 371207141Sjeff * an allocdirect or allocindir allocation once the allocator calls the 372212617Smckusick * appropriate setup function. It will initially be linked onto a bmsafemap 373212617Smckusick * list. Once converted it can be linked onto the lists described for 374212617Smckusick * allocdirect or allocindir as described below. 375207141Sjeff */ 376207141Sjeffstruct newblk { 377212617Smckusick struct worklist nb_list; /* See comment above. */ 378207141Sjeff# define nb_state nb_list.wk_state 379212617Smckusick LIST_ENTRY(newblk) nb_hash; /* Hashed lookup. */ 380212617Smckusick LIST_ENTRY(newblk) nb_deps; /* Bmsafemap's list of newblks. */ 381207141Sjeff struct jnewblk *nb_jnewblk; /* New block journal entry. */ 382212617Smckusick struct bmsafemap *nb_bmsafemap;/* Cylgrp dep (if pending). */ 383212617Smckusick struct freefrag *nb_freefrag; /* Fragment to be freed (if any). */ 384207141Sjeff struct indirdephd nb_indirdeps; /* Children indirect blocks. */ 385212617Smckusick struct workhead nb_newdirblk; /* Dir block to notify when written. */ 386207141Sjeff struct workhead nb_jwork; /* Journal work pending. */ 387212617Smckusick ufs2_daddr_t nb_newblkno; /* New value of block pointer. */ 388207141Sjeff}; 389207141Sjeff 390207141Sjeff/* 39136201Sjulian * An "allocdirect" structure is attached to an "inodedep" when a new block 39236201Sjulian * or fragment is allocated and pointed to by the inode described by 39336201Sjulian * "inodedep". The worklist is linked to the buffer that holds the block. 39436201Sjulian * When the block is first allocated, it is linked to the bmsafemap 39536201Sjulian * structure associated with the buffer holding the cylinder group map 39636201Sjulian * from which it was allocated. When the cylinder group map is written 39736201Sjulian * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself 39836201Sjulian * is written, the COMPLETE flag is set. Once both the cylinder group map 39936201Sjulian * and the data itself have been written, it is safe to write the inode 40036201Sjulian * that claims the block. If there was a previous fragment that had been 40136201Sjulian * allocated before the file was increased in size, the old fragment may 40236201Sjulian * be freed once the inode claiming the new block is written to disk. 40336201Sjulian * This ad_fragfree request is attached to the id_inowait list of the 40436201Sjulian * associated inodedep (pointed to by ad_inodedep) for processing after 40576724Smckusick * the inode is written. When a block is allocated to a directory, an 40676724Smckusick * fsync of a file whose name is within that block must ensure not only 40776724Smckusick * that the block containing the file name has been written, but also 40876724Smckusick * that the on-disk inode references that block. When a new directory 40976724Smckusick * block is created, we allocate a newdirblk structure which is linked 41076724Smckusick * to the associated allocdirect (on its ad_newdirblk list). When the 41176724Smckusick * allocdirect has been satisfied, the newdirblk structure is moved to 41276724Smckusick * the inodedep id_bufwait list of its directory to await the inode 41376724Smckusick * being written. When the inode is written, the directory entries are 41476724Smckusick * fully committed and can be deleted from their pagedep->id_pendinghd 41576724Smckusick * and inodedep->id_pendinghd lists. 41636201Sjulian */ 41736201Sjulianstruct allocdirect { 418207141Sjeff struct newblk ad_block; /* Common block logic */ 419207141Sjeff# define ad_state ad_block.nb_list.wk_state /* block pointer state */ 42060938Sjake TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */ 42136201Sjulian struct inodedep *ad_inodedep; /* associated inodedep */ 422207141Sjeff ufs2_daddr_t ad_oldblkno; /* old value of block pointer */ 423207141Sjeff int ad_offset; /* Pointer offset in parent. */ 424207141Sjeff long ad_newsize; /* size of new block */ 425207141Sjeff long ad_oldsize; /* size of old block */ 42636201Sjulian}; 427207141Sjeff#define ad_newblkno ad_block.nb_newblkno 428207141Sjeff#define ad_freefrag ad_block.nb_freefrag 429207141Sjeff#define ad_newdirblk ad_block.nb_newdirblk 43036201Sjulian 43136201Sjulian/* 43236201Sjulian * A single "indirdep" structure manages all allocation dependencies for 43336201Sjulian * pointers in an indirect block. The up-to-date state of the indirect 43436201Sjulian * block is stored in ir_savedata. The set of pointers that may be safely 43536201Sjulian * written to the disk is stored in ir_safecopy. The state field is used 43636201Sjulian * only to track whether the buffer is currently being written (in which 43736201Sjulian * case it is not safe to update ir_safecopy). Ir_deplisthd contains the 43836201Sjulian * list of allocindir structures, one for each block that needs to be 43936201Sjulian * written to disk. Once the block and its bitmap allocation have been 44036201Sjulian * written the safecopy can be updated to reflect the allocation and the 44136201Sjulian * allocindir structure freed. If ir_state indicates that an I/O on the 44236201Sjulian * indirect block is in progress when ir_safecopy is to be updated, the 44336201Sjulian * update is deferred by placing the allocindir on the ir_donehd list. 44436201Sjulian * When the I/O on the indirect block completes, the entries on the 44536201Sjulian * ir_donehd list are processed by updating their corresponding ir_safecopy 44636201Sjulian * pointers and then freeing the allocindir structure. 44736201Sjulian */ 44836201Sjulianstruct indirdep { 44936201Sjulian struct worklist ir_list; /* buffer holding indirect block */ 45036201Sjulian# define ir_state ir_list.wk_state /* indirect block pointer state */ 451207141Sjeff LIST_ENTRY(indirdep) ir_next; /* alloc{direct,indir} list */ 452222958Sjeff TAILQ_HEAD(, freework) ir_trunc; /* List of truncations. */ 453207141Sjeff caddr_t ir_saveddata; /* buffer cache contents */ 45436201Sjulian struct buf *ir_savebp; /* buffer holding safe copy */ 455222958Sjeff struct buf *ir_bp; /* buffer holding live copy */ 456207141Sjeff struct allocindirhd ir_completehd; /* waiting for indirdep complete */ 457207141Sjeff struct allocindirhd ir_writehd; /* Waiting for the pointer write. */ 45836201Sjulian struct allocindirhd ir_donehd; /* done waiting to update safecopy */ 45936201Sjulian struct allocindirhd ir_deplisthd; /* allocindir deps for this block */ 460222958Sjeff struct freeblks *ir_freeblks; /* Freeblks that frees this indir. */ 46136201Sjulian}; 46236201Sjulian 46336201Sjulian/* 46436201Sjulian * An "allocindir" structure is attached to an "indirdep" when a new block 46536201Sjulian * is allocated and pointed to by the indirect block described by the 46636201Sjulian * "indirdep". The worklist is linked to the buffer that holds the new block. 46736201Sjulian * When the block is first allocated, it is linked to the bmsafemap 46836201Sjulian * structure associated with the buffer holding the cylinder group map 46936201Sjulian * from which it was allocated. When the cylinder group map is written 47036201Sjulian * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself 47136201Sjulian * is written, the COMPLETE flag is set. Once both the cylinder group map 47236201Sjulian * and the data itself have been written, it is safe to write the entry in 47336201Sjulian * the indirect block that claims the block; the "allocindir" dependency 47436201Sjulian * can then be freed as it is no longer applicable. 47536201Sjulian */ 47636201Sjulianstruct allocindir { 477207141Sjeff struct newblk ai_block; /* Common block area */ 478207141Sjeff# define ai_state ai_block.nb_list.wk_state /* indirect pointer state */ 47960938Sjake LIST_ENTRY(allocindir) ai_next; /* indirdep's list of allocindir's */ 48036201Sjulian struct indirdep *ai_indirdep; /* address of associated indirdep */ 481207141Sjeff ufs2_daddr_t ai_oldblkno; /* old value of block pointer */ 482222958Sjeff ufs_lbn_t ai_lbn; /* Logical block number. */ 483207141Sjeff int ai_offset; /* Pointer offset in parent. */ 48436201Sjulian}; 485207141Sjeff#define ai_newblkno ai_block.nb_newblkno 486207141Sjeff#define ai_freefrag ai_block.nb_freefrag 487207141Sjeff#define ai_newdirblk ai_block.nb_newdirblk 48836201Sjulian 48936201Sjulian/* 490207141Sjeff * The allblk union is used to size the newblk structure on allocation so 491207141Sjeff * that it may be any one of three types. 492207141Sjeff */ 493207141Sjeffunion allblk { 494207141Sjeff struct allocindir ab_allocindir; 495207141Sjeff struct allocdirect ab_allocdirect; 496207141Sjeff struct newblk ab_newblk; 497207141Sjeff}; 498207141Sjeff 499207141Sjeff/* 50036201Sjulian * A "freefrag" structure is attached to an "inodedep" when a previously 50136201Sjulian * allocated fragment is replaced with a larger fragment, rather than extended. 50236201Sjulian * The "freefrag" structure is constructed and attached when the replacement 50336201Sjulian * block is first allocated. It is processed after the inode claiming the 504207141Sjeff * bigger block that replaces it has been written to disk. 50536201Sjulian */ 50636201Sjulianstruct freefrag { 50736201Sjulian struct worklist ff_list; /* id_inowait or delayed worklist */ 508207141Sjeff# define ff_state ff_list.wk_state 509220406Sjeff struct worklist *ff_jdep; /* Associated journal entry. */ 510207141Sjeff struct workhead ff_jwork; /* Journal work pending. */ 51198542Smckusick ufs2_daddr_t ff_blkno; /* fragment physical block number */ 51236201Sjulian long ff_fragsize; /* size of fragment being deleted */ 51336201Sjulian ino_t ff_inum; /* owning inode number */ 514223127Smckusick enum vtype ff_vtype; /* owning inode's file type */ 51536201Sjulian}; 51636201Sjulian 51736201Sjulian/* 51836201Sjulian * A "freeblks" structure is attached to an "inodedep" when the 51936201Sjulian * corresponding file's length is reduced to zero. It records all 52036201Sjulian * the information needed to free the blocks of a file after its 521207141Sjeff * zero'ed inode has been written to disk. The actual work is done 522207141Sjeff * by child freework structures which are responsible for individual 523207141Sjeff * inode pointers while freeblks is responsible for retiring the 524207141Sjeff * entire operation when it is complete and holding common members. 52536201Sjulian */ 52636201Sjulianstruct freeblks { 52736201Sjulian struct worklist fb_list; /* id_inowait or delayed worklist */ 528148608Sups# define fb_state fb_list.wk_state /* inode and dirty block state */ 529222958Sjeff TAILQ_ENTRY(freeblks) fb_next; /* List of inode truncates. */ 530222958Sjeff struct jblkdephd fb_jblkdephd; /* Journal entries pending */ 531207141Sjeff struct workhead fb_freeworkhd; /* Work items pending */ 532207141Sjeff struct workhead fb_jwork; /* Journal work pending */ 533222958Sjeff struct vnode *fb_devvp; /* filesystem device vnode */ 534222958Sjeff#ifdef QUOTA 535222958Sjeff struct dquot *fb_quota[MAXQUOTAS]; /* quotas to be adjusted */ 536222958Sjeff#endif 537222958Sjeff uint64_t fb_modrev; /* Inode revision at start of trunc. */ 538222958Sjeff off_t fb_len; /* Length we're truncating to. */ 539223772Sjeff ufs2_daddr_t fb_chkcnt; /* Blocks released. */ 540222958Sjeff ino_t fb_inum; /* inode owner of blocks */ 541223127Smckusick enum vtype fb_vtype; /* inode owner's file type */ 54298542Smckusick uid_t fb_uid; /* uid of previous owner of blocks */ 543207141Sjeff int fb_ref; /* Children outstanding. */ 544222958Sjeff int fb_cgwait; /* cg writes outstanding. */ 54536201Sjulian}; 54636201Sjulian 54736201Sjulian/* 548207141Sjeff * A "freework" structure handles the release of a tree of blocks or a single 549207141Sjeff * block. Each indirect block in a tree is allocated its own freework 550212617Smckusick * structure so that the indirect block may be freed only when all of its 551207141Sjeff * children are freed. In this way we enforce the rule that an allocated 552207141Sjeff * block must have a valid path to a root that is journaled. Each child 553207141Sjeff * block acquires a reference and when the ref hits zero the parent ref 554207141Sjeff * is decremented. If there is no parent the freeblks ref is decremented. 555207141Sjeff */ 556207141Sjeffstruct freework { 557212617Smckusick struct worklist fw_list; /* Delayed worklist. */ 558207141Sjeff# define fw_state fw_list.wk_state 559222958Sjeff LIST_ENTRY(freework) fw_segs; /* Seg list. */ 560222958Sjeff TAILQ_ENTRY(freework) fw_next; /* Hash/Trunc list. */ 561222958Sjeff struct jnewblk *fw_jnewblk; /* Journal entry to cancel. */ 562207141Sjeff struct freeblks *fw_freeblks; /* Root of operation. */ 563207141Sjeff struct freework *fw_parent; /* Parent indirect. */ 564222958Sjeff struct indirdep *fw_indir; /* indirect block. */ 565207141Sjeff ufs2_daddr_t fw_blkno; /* Our block #. */ 566207141Sjeff ufs_lbn_t fw_lbn; /* Original lbn before free. */ 567222958Sjeff uint16_t fw_frags; /* Number of frags. */ 568222958Sjeff uint16_t fw_ref; /* Number of children out. */ 569222958Sjeff uint16_t fw_off; /* Current working position. */ 570222958Sjeff uint16_t fw_start; /* Start of partial truncate. */ 571207141Sjeff}; 572207141Sjeff 573207141Sjeff/* 574207141Sjeff * A "freedep" structure is allocated to track the completion of a bitmap 575207141Sjeff * write for a freework. One freedep may cover many freed blocks so long 576207141Sjeff * as they reside in the same cylinder group. When the cg is written 577207141Sjeff * the freedep decrements the ref on the freework which may permit it 578207141Sjeff * to be freed as well. 579207141Sjeff */ 580207141Sjeffstruct freedep { 581212617Smckusick struct worklist fd_list; /* Delayed worklist. */ 582207141Sjeff struct freework *fd_freework; /* Parent freework. */ 583207141Sjeff}; 584207141Sjeff 585207141Sjeff/* 58636201Sjulian * A "freefile" structure is attached to an inode when its 58736201Sjulian * link count is reduced to zero. It marks the inode as free in 58836201Sjulian * the cylinder group map after the zero'ed inode has been written 58936201Sjulian * to disk and any associated blocks and fragments have been freed. 59036201Sjulian */ 59136201Sjulianstruct freefile { 59236201Sjulian struct worklist fx_list; /* id_inowait or delayed worklist */ 59336201Sjulian mode_t fx_mode; /* mode of inode */ 59436201Sjulian ino_t fx_oldinum; /* inum of the unlinked file */ 59536201Sjulian struct vnode *fx_devvp; /* filesystem device vnode */ 596207141Sjeff struct workhead fx_jwork; /* journal work pending. */ 59736201Sjulian}; 59836201Sjulian 59936201Sjulian/* 60036201Sjulian * A "diradd" structure is linked to an "inodedep" id_inowait list when a 60136201Sjulian * new directory entry is allocated that references the inode described 60236201Sjulian * by "inodedep". When the inode itself is written (either the initial 60336201Sjulian * allocation for new inodes or with the increased link count for 60436201Sjulian * existing inodes), the COMPLETE flag is set in da_state. If the entry 60536201Sjulian * is for a newly allocated inode, the "inodedep" structure is associated 60636201Sjulian * with a bmsafemap which prevents the inode from being written to disk 60736201Sjulian * until the cylinder group has been updated. Thus the da_state COMPLETE 60836201Sjulian * flag cannot be set until the inode bitmap dependency has been removed. 60936201Sjulian * When creating a new file, it is safe to write the directory entry that 61036201Sjulian * claims the inode once the referenced inode has been written. Since 61136201Sjulian * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag 61236201Sjulian * in the diradd can be set unconditionally when creating a file. When 61336201Sjulian * creating a directory, there are two additional dependencies described by 61436201Sjulian * mkdir structures (see their description below). When these dependencies 61536201Sjulian * are resolved the DEPCOMPLETE flag is set in the diradd structure. 61636201Sjulian * If there are multiple links created to the same inode, there will be 61736201Sjulian * a separate diradd structure created for each link. The diradd is 61836201Sjulian * linked onto the pg_diraddhd list of the pagedep for the directory 61936201Sjulian * page that contains the entry. When a directory page is written, 62036201Sjulian * the pg_diraddhd list is traversed to rollback any entries that are 62136201Sjulian * not yet ready to be written to disk. If a directory entry is being 62236201Sjulian * changed (by rename) rather than added, the DIRCHG flag is set and 62336201Sjulian * the da_previous entry points to the entry that will be "removed" 62436201Sjulian * once the new entry has been committed. During rollback, entries 62536201Sjulian * with da_previous are replaced with the previous inode number rather 62636201Sjulian * than zero. 62736201Sjulian * 62836201Sjulian * The overlaying of da_pagedep and da_previous is done to keep the 629207141Sjeff * structure down. If a da_previous entry is present, the pointer to its 630207141Sjeff * pagedep is available in the associated dirrem entry. If the DIRCHG flag 631207141Sjeff * is set, the da_previous entry is valid; if not set the da_pagedep entry 632207141Sjeff * is valid. The DIRCHG flag never changes; it is set when the structure 633207141Sjeff * is created if appropriate and is never cleared. 63436201Sjulian */ 63536201Sjulianstruct diradd { 63636225Sjulian struct worklist da_list; /* id_inowait or id_pendinghd list */ 63736201Sjulian# define da_state da_list.wk_state /* state of the new directory entry */ 63860938Sjake LIST_ENTRY(diradd) da_pdlist; /* pagedep holding directory block */ 63936201Sjulian doff_t da_offset; /* offset of new dir entry in dir blk */ 64036201Sjulian ino_t da_newinum; /* inode number for the new dir entry */ 64136201Sjulian union { 64236201Sjulian struct dirrem *dau_previous; /* entry being replaced in dir change */ 64336201Sjulian struct pagedep *dau_pagedep; /* pagedep dependency for addition */ 64436201Sjulian } da_un; 645207141Sjeff struct workhead da_jwork; /* Journal work awaiting completion. */ 64636201Sjulian}; 64736201Sjulian#define da_previous da_un.dau_previous 64836201Sjulian#define da_pagedep da_un.dau_pagedep 64936201Sjulian 65036201Sjulian/* 65136201Sjulian * Two "mkdir" structures are needed to track the additional dependencies 65236201Sjulian * associated with creating a new directory entry. Normally a directory 65336201Sjulian * addition can be committed as soon as the newly referenced inode has been 65436201Sjulian * written to disk with its increased link count. When a directory is 65536201Sjulian * created there are two additional dependencies: writing the directory 65636201Sjulian * data block containing the "." and ".." entries (MKDIR_BODY) and writing 65736201Sjulian * the parent inode with the increased link count for ".." (MKDIR_PARENT). 65836201Sjulian * These additional dependencies are tracked by two mkdir structures that 65936201Sjulian * reference the associated "diradd" structure. When they have completed, 66036201Sjulian * they set the DEPCOMPLETE flag on the diradd so that it knows that its 66136201Sjulian * extra dependencies have been completed. The md_state field is used only 66236201Sjulian * to identify which type of dependency the mkdir structure is tracking. 66336201Sjulian * It is not used in the mainline code for any purpose other than consistency 66436201Sjulian * checking. All the mkdir structures in the system are linked together on 66536201Sjulian * a list. This list is needed so that a diradd can find its associated 66636201Sjulian * mkdir structures and deallocate them if it is prematurely freed (as for 66736201Sjulian * example if a mkdir is immediately followed by a rmdir of the same directory). 66836201Sjulian * Here, the free of the diradd must traverse the list to find the associated 66936201Sjulian * mkdir structures that reference it. The deletion would be faster if the 67036201Sjulian * diradd structure were simply augmented to have two pointers that referenced 67136201Sjulian * the associated mkdir's. However, this would increase the size of the diradd 672207141Sjeff * structure to speed a very infrequent operation. 67336201Sjulian */ 67436201Sjulianstruct mkdir { 67536201Sjulian struct worklist md_list; /* id_inowait or buffer holding dir */ 67636201Sjulian# define md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */ 67736201Sjulian struct diradd *md_diradd; /* associated diradd */ 678207141Sjeff struct jaddref *md_jaddref; /* dependent jaddref. */ 67946618Smckusick struct buf *md_buf; /* MKDIR_BODY: buffer holding dir */ 68060938Sjake LIST_ENTRY(mkdir) md_mkdirs; /* list of all mkdirs */ 68136201Sjulian}; 68236201Sjulian 68336201Sjulian/* 68436201Sjulian * A "dirrem" structure describes an operation to decrement the link 68536201Sjulian * count on an inode. The dirrem structure is attached to the pg_dirremhd 68636201Sjulian * list of the pagedep for the directory page that contains the entry. 68736201Sjulian * It is processed after the directory page with the deleted entry has 68836201Sjulian * been written to disk. 68936201Sjulian */ 69036201Sjulianstruct dirrem { 69136201Sjulian struct worklist dm_list; /* delayed worklist */ 69236201Sjulian# define dm_state dm_list.wk_state /* state of the old directory entry */ 69360938Sjake LIST_ENTRY(dirrem) dm_next; /* pagedep's list of dirrem's */ 694207141Sjeff LIST_ENTRY(dirrem) dm_inonext; /* inodedep's list of dirrem's */ 695207141Sjeff struct jremrefhd dm_jremrefhd; /* Pending remove reference deps. */ 69636201Sjulian ino_t dm_oldinum; /* inum of the removed dir entry */ 697222958Sjeff doff_t dm_offset; /* offset of removed dir entry in blk */ 69836201Sjulian union { 69936201Sjulian struct pagedep *dmu_pagedep; /* pagedep dependency for remove */ 70036201Sjulian ino_t dmu_dirinum; /* parent inode number (for rmdir) */ 70136201Sjulian } dm_un; 702207141Sjeff struct workhead dm_jwork; /* Journal work awaiting completion. */ 70336201Sjulian}; 70436201Sjulian#define dm_pagedep dm_un.dmu_pagedep 70536201Sjulian#define dm_dirinum dm_un.dmu_dirinum 70676724Smckusick 70776724Smckusick/* 70876724Smckusick * A "newdirblk" structure tracks the progress of a newly allocated 70976724Smckusick * directory block from its creation until it is claimed by its on-disk 71076724Smckusick * inode. When a block is allocated to a directory, an fsync of a file 71176724Smckusick * whose name is within that block must ensure not only that the block 71276724Smckusick * containing the file name has been written, but also that the on-disk 71376724Smckusick * inode references that block. When a new directory block is created, 71476724Smckusick * we allocate a newdirblk structure which is linked to the associated 71576724Smckusick * allocdirect (on its ad_newdirblk list). When the allocdirect has been 71676724Smckusick * satisfied, the newdirblk structure is moved to the inodedep id_bufwait 71776724Smckusick * list of its directory to await the inode being written. When the inode 71876724Smckusick * is written, the directory entries are fully committed and can be 71976724Smckusick * deleted from their pagedep->id_pendinghd and inodedep->id_pendinghd 72076724Smckusick * lists. Note that we could track directory blocks allocated to indirect 72176724Smckusick * blocks using a similar scheme with the allocindir structures. Rather 72276724Smckusick * than adding this level of complexity, we simply write those newly 72376724Smckusick * allocated indirect blocks synchronously as such allocations are rare. 724207141Sjeff * In the case of a new directory the . and .. links are tracked with 725207141Sjeff * a mkdir rather than a pagedep. In this case we track the mkdir 726207141Sjeff * so it can be released when it is written. A workhead is used 727207141Sjeff * to simplify canceling a mkdir that is removed by a subsequent dirrem. 72876724Smckusick */ 72976724Smckusickstruct newdirblk { 73076724Smckusick struct worklist db_list; /* id_inowait or pg_newdirblk */ 731222958Sjeff# define db_state db_list.wk_state 73276724Smckusick struct pagedep *db_pagedep; /* associated pagedep */ 733207141Sjeff struct workhead db_mkdir; 73476724Smckusick}; 735207141Sjeff 736207141Sjeff/* 737207141Sjeff * The inoref structure holds the elements common to jaddref and jremref 738207141Sjeff * so they may easily be queued in-order on the inodedep. 739207141Sjeff */ 740207141Sjeffstruct inoref { 741212617Smckusick struct worklist if_list; /* Journal pending or jseg entries. */ 742207141Sjeff# define if_state if_list.wk_state 743207141Sjeff TAILQ_ENTRY(inoref) if_deps; /* Links for inodedep. */ 744212617Smckusick struct jsegdep *if_jsegdep; /* Will track our journal record. */ 745207141Sjeff off_t if_diroff; /* Directory offset. */ 746207141Sjeff ino_t if_ino; /* Inode number. */ 747207141Sjeff ino_t if_parent; /* Parent inode number. */ 748207141Sjeff nlink_t if_nlink; /* nlink before addition. */ 749207141Sjeff uint16_t if_mode; /* File mode, needed for IFMT. */ 750207141Sjeff}; 751207141Sjeff 752207141Sjeff/* 753207141Sjeff * A "jaddref" structure tracks a new reference (link count) on an inode 754207141Sjeff * and prevents the link count increase and bitmap allocation until a 755207141Sjeff * journal entry can be written. Once the journal entry is written, 756207141Sjeff * the inode is put on the pendinghd of the bmsafemap and a diradd or 757207141Sjeff * mkdir entry is placed on the bufwait list of the inode. The DEPCOMPLETE 758207141Sjeff * flag is used to indicate that all of the required information for writing 759207141Sjeff * the journal entry is present. MKDIR_BODY and MKDIR_PARENT are used to 760207141Sjeff * differentiate . and .. links from regular file names. NEWBLOCK indicates 761207141Sjeff * a bitmap is still pending. If a new reference is canceled by a delete 762207141Sjeff * prior to writing the journal the jaddref write is canceled and the 763207141Sjeff * structure persists to prevent any disk-visible changes until it is 764207141Sjeff * ultimately released when the file is freed or the link is dropped again. 765207141Sjeff */ 766207141Sjeffstruct jaddref { 767212617Smckusick struct inoref ja_ref; /* see inoref above. */ 768212617Smckusick# define ja_list ja_ref.if_list /* Jrnl pending, id_inowait, dm_jwork.*/ 769207141Sjeff# define ja_state ja_ref.if_list.wk_state 770207141Sjeff LIST_ENTRY(jaddref) ja_bmdeps; /* Links for bmsafemap. */ 771207141Sjeff union { 772207141Sjeff struct diradd *jau_diradd; /* Pending diradd. */ 773207141Sjeff struct mkdir *jau_mkdir; /* MKDIR_{PARENT,BODY} */ 774207141Sjeff } ja_un; 775207141Sjeff}; 776207141Sjeff#define ja_diradd ja_un.jau_diradd 777207141Sjeff#define ja_mkdir ja_un.jau_mkdir 778207141Sjeff#define ja_diroff ja_ref.if_diroff 779207141Sjeff#define ja_ino ja_ref.if_ino 780207141Sjeff#define ja_parent ja_ref.if_parent 781207141Sjeff#define ja_mode ja_ref.if_mode 782207141Sjeff 783207141Sjeff/* 784207141Sjeff * A "jremref" structure tracks a removed reference (unlink) on an 785207141Sjeff * inode and prevents the directory remove from proceeding until the 786207141Sjeff * journal entry is written. Once the journal has been written the remove 787207141Sjeff * may proceed as normal. 788207141Sjeff */ 789207141Sjeffstruct jremref { 790212617Smckusick struct inoref jr_ref; /* see inoref above. */ 791212617Smckusick# define jr_list jr_ref.if_list /* Linked to softdep_journal_pending. */ 792207141Sjeff# define jr_state jr_ref.if_list.wk_state 793212617Smckusick LIST_ENTRY(jremref) jr_deps; /* Links for dirrem. */ 794207141Sjeff struct dirrem *jr_dirrem; /* Back pointer to dirrem. */ 795207141Sjeff}; 796207141Sjeff 797212617Smckusick/* 798212617Smckusick * A "jmvref" structure tracks a name relocations within the same 799212617Smckusick * directory block that occur as a result of directory compaction. 800212617Smckusick * It prevents the updated directory entry from being written to disk 801212617Smckusick * until the journal entry is written. Once the journal has been 802212617Smckusick * written the compacted directory may be written to disk. 803212617Smckusick */ 804207141Sjeffstruct jmvref { 805212617Smckusick struct worklist jm_list; /* Linked to softdep_journal_pending. */ 806212617Smckusick LIST_ENTRY(jmvref) jm_deps; /* Jmvref on pagedep. */ 807212617Smckusick struct pagedep *jm_pagedep; /* Back pointer to pagedep. */ 808212617Smckusick ino_t jm_parent; /* Containing directory inode number. */ 809212617Smckusick ino_t jm_ino; /* Inode number of our entry. */ 810212617Smckusick off_t jm_oldoff; /* Our old offset in directory. */ 811212617Smckusick off_t jm_newoff; /* Our new offset in directory. */ 812207141Sjeff}; 813207141Sjeff 814207141Sjeff/* 815207141Sjeff * A "jnewblk" structure tracks a newly allocated block or fragment and 816207141Sjeff * prevents the direct or indirect block pointer as well as the cg bitmap 817207141Sjeff * from being written until it is logged. After it is logged the jsegdep 818207141Sjeff * is attached to the allocdirect or allocindir until the operation is 819207141Sjeff * completed or reverted. If the operation is reverted prior to the journal 820207141Sjeff * write the jnewblk structure is maintained to prevent the bitmaps from 821207141Sjeff * reaching the disk. Ultimately the jnewblk structure will be passed 822207141Sjeff * to the free routine as the in memory cg is modified back to the free 823212617Smckusick * state at which time it can be released. It may be held on any of the 824212617Smckusick * fx_jwork, fw_jwork, fb_jwork, ff_jwork, nb_jwork, or ir_jwork lists. 825207141Sjeff */ 826207141Sjeffstruct jnewblk { 827212617Smckusick struct worklist jn_list; /* See lists above. */ 828207141Sjeff# define jn_state jn_list.wk_state 829212617Smckusick struct jsegdep *jn_jsegdep; /* Will track our journal record. */ 830212617Smckusick LIST_ENTRY(jnewblk) jn_deps; /* Jnewblks on sm_jnewblkhd. */ 831220406Sjeff struct worklist *jn_dep; /* Dependency to ref completed seg. */ 832212617Smckusick ufs_lbn_t jn_lbn; /* Lbn to which allocated. */ 833212617Smckusick ufs2_daddr_t jn_blkno; /* Blkno allocated */ 834222958Sjeff ino_t jn_ino; /* Ino to which allocated. */ 835212617Smckusick int jn_oldfrags; /* Previous fragments when extended. */ 836212617Smckusick int jn_frags; /* Number of fragments. */ 837207141Sjeff}; 838207141Sjeff 839207141Sjeff/* 840222958Sjeff * A "jblkdep" structure tracks jfreeblk and jtrunc records attached to a 841222958Sjeff * freeblks structure. 842222958Sjeff */ 843222958Sjeffstruct jblkdep { 844222958Sjeff struct worklist jb_list; /* For softdep journal pending. */ 845222958Sjeff struct jsegdep *jb_jsegdep; /* Reference to the jseg. */ 846222958Sjeff struct freeblks *jb_freeblks; /* Back pointer to freeblks. */ 847222958Sjeff LIST_ENTRY(jblkdep) jb_deps; /* Dep list on freeblks. */ 848222958Sjeff 849222958Sjeff}; 850222958Sjeff 851222958Sjeff/* 852207141Sjeff * A "jfreeblk" structure tracks the journal write for freeing a block 853207141Sjeff * or tree of blocks. The block pointer must not be cleared in the inode 854212617Smckusick * or indirect prior to the jfreeblk being written to the journal. 855207141Sjeff */ 856207141Sjeffstruct jfreeblk { 857222958Sjeff struct jblkdep jf_dep; /* freeblks linkage. */ 858212617Smckusick ufs_lbn_t jf_lbn; /* Lbn from which blocks freed. */ 859212617Smckusick ufs2_daddr_t jf_blkno; /* Blkno being freed. */ 860222958Sjeff ino_t jf_ino; /* Ino from which blocks freed. */ 861212617Smckusick int jf_frags; /* Number of frags being freed. */ 862207141Sjeff}; 863207141Sjeff 864207141Sjeff/* 865207141Sjeff * A "jfreefrag" tracks the freeing of a single block when a fragment is 866207141Sjeff * extended or an indirect page is replaced. It is not part of a larger 867207141Sjeff * freeblks operation. 868207141Sjeff */ 869207141Sjeffstruct jfreefrag { 870212617Smckusick struct worklist fr_list; /* Linked to softdep_journal_pending. */ 871207141Sjeff# define fr_state fr_list.wk_state 872212617Smckusick struct jsegdep *fr_jsegdep; /* Will track our journal record. */ 873212617Smckusick struct freefrag *fr_freefrag; /* Back pointer to freefrag. */ 874212617Smckusick ufs_lbn_t fr_lbn; /* Lbn from which frag freed. */ 875212617Smckusick ufs2_daddr_t fr_blkno; /* Blkno being freed. */ 876222958Sjeff ino_t fr_ino; /* Ino from which frag freed. */ 877212617Smckusick int fr_frags; /* Size of frag being freed. */ 878207141Sjeff}; 879207141Sjeff 880207141Sjeff/* 881222958Sjeff * A "jtrunc" journals the intent to truncate an inode's data or extent area. 882207141Sjeff */ 883207141Sjeffstruct jtrunc { 884222958Sjeff struct jblkdep jt_dep; /* freeblks linkage. */ 885222958Sjeff off_t jt_size; /* Final file size. */ 886222958Sjeff int jt_extsize; /* Final extent size. */ 887222958Sjeff ino_t jt_ino; /* Ino being truncated. */ 888207141Sjeff}; 889207141Sjeff 890207141Sjeff/* 891222958Sjeff * A "jfsync" journals the completion of an fsync which invalidates earlier 892222958Sjeff * jtrunc records in the journal. 893222958Sjeff */ 894222958Sjeffstruct jfsync { 895222958Sjeff struct worklist jfs_list; /* For softdep journal pending. */ 896222958Sjeff off_t jfs_size; /* Sync file size. */ 897222958Sjeff int jfs_extsize; /* Sync extent size. */ 898222958Sjeff ino_t jfs_ino; /* ino being synced. */ 899222958Sjeff}; 900222958Sjeff 901222958Sjeff/* 902207141Sjeff * A "jsegdep" structure tracks a single reference to a written journal 903207141Sjeff * segment so the journal space can be reclaimed when all dependencies 904212617Smckusick * have been written. It can hang off of id_inowait, dm_jwork, da_jwork, 905212617Smckusick * nb_jwork, ff_jwork, or fb_jwork lists. 906207141Sjeff */ 907207141Sjeffstruct jsegdep { 908212617Smckusick struct worklist jd_list; /* See above for lists. */ 909207141Sjeff# define jd_state jd_list.wk_state 910212617Smckusick struct jseg *jd_seg; /* Our journal record. */ 911207141Sjeff}; 912207141Sjeff 913207141Sjeff/* 914207141Sjeff * A "jseg" structure contains all of the journal records written in a 915212617Smckusick * single disk write. The jaddref and jremref structures are linked into 916207141Sjeff * js_entries so thay may be completed when the write completes. The 917212617Smckusick * js_entries also include the write dependency structures: jmvref, 918212617Smckusick * jnewblk, jfreeblk, jfreefrag, and jtrunc. The js_refs field counts 919212617Smckusick * the number of entries on the js_entries list. Thus there is a single 920212617Smckusick * jseg entry to describe each journal write. 921207141Sjeff */ 922207141Sjeffstruct jseg { 923207141Sjeff struct worklist js_list; /* b_deps link for journal */ 924207141Sjeff# define js_state js_list.wk_state 925207141Sjeff struct workhead js_entries; /* Entries awaiting write */ 926220511Sjeff LIST_HEAD(, freework) js_indirs;/* List of indirects in this seg. */ 927212617Smckusick TAILQ_ENTRY(jseg) js_next; /* List of all unfinished segments. */ 928207141Sjeff struct jblocks *js_jblocks; /* Back pointer to block/seg list */ 929207141Sjeff struct buf *js_buf; /* Buffer while unwritten */ 930212617Smckusick uint64_t js_seq; /* Journal record sequence number. */ 931220511Sjeff uint64_t js_oldseq; /* Oldest valid sequence number. */ 932212617Smckusick int js_size; /* Size of journal record in bytes. */ 933212617Smckusick int js_cnt; /* Total items allocated. */ 934212617Smckusick int js_refs; /* Count of js_entries items. */ 935207141Sjeff}; 936207141Sjeff 937207141Sjeff/* 938207141Sjeff * A 'sbdep' structure tracks the head of the free inode list and 939207141Sjeff * superblock writes. This makes sure the superblock is always pointing at 940207141Sjeff * the first possible unlinked inode for the suj recovery process. If a 941207141Sjeff * block write completes and we discover a new head is available the buf 942212617Smckusick * is dirtied and the dep is kept. See the description of the UNLINK* 943212617Smckusick * flags above for more details. 944207141Sjeff */ 945207141Sjeffstruct sbdep { 946207141Sjeff struct worklist sb_list; /* b_dep linkage */ 947207141Sjeff struct fs *sb_fs; /* Filesystem pointer within buf. */ 948212617Smckusick struct ufsmount *sb_ump; /* Our mount structure */ 949207141Sjeff}; 950