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$ 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 SPACECOUNTED flag 86 * says that the files space has been accounted to the pending free 87 * space count. The NEWBLOCK flag marks pagedep structures that have 88 * just been allocated, so must be claimed by the inode before all 89 * dependencies are complete. The INPROGRESS flag marks worklist 90 * structures that are still on the worklist, but are being considered 91 * for action by some process. The UFS1FMT flag indicates that the 92 * inode being processed is a ufs1 format. The EXTDATA flag indicates 93 * that the allocdirect describes an extended-attributes dependency. 94 * The ONWORKLIST flag shows whether the structure is currently linked 95 * onto a worklist. 96 */ 97 #define ATTACHED 0x000001 98 #define UNDONE 0x000002 99 #define COMPLETE 0x000004 100 #define DEPCOMPLETE 0x000008 101 #define MKDIR_PARENT 0x000010 /* diradd, mkdir, jaddref, jsegdep only */ 102 #define MKDIR_BODY 0x000020 /* diradd, mkdir, jaddref only */ 103 #define RMDIR 0x000040 /* dirrem only */ 104 #define DIRCHG 0x000080 /* diradd, dirrem only */ 105 #define GOINGAWAY 0x000100 /* indirdep, jremref only */ 106 #define IOSTARTED 0x000200 /* inodedep, pagedep, bmsafemap only */ 107 #define SPACECOUNTED 0x000400 /* inodedep only */ 108 #define NEWBLOCK 0x000800 /* pagedep, jaddref only */ 109 #define INPROGRESS 0x001000 /* dirrem, freeblks, freefrag, freefile only */ 110 #define UFS1FMT 0x002000 /* indirdep only */ 111 #define EXTDATA 0x004000 /* allocdirect only */ 112 #define ONWORKLIST 0x008000 113 #define IOWAITING 0x010000 /* Thread is waiting for IO to complete. */ 114 #define ONDEPLIST 0x020000 /* Structure is on a dependency list. */ 115 #define UNLINKED 0x040000 /* inodedep has been unlinked. */ 116 #define UNLINKNEXT 0x080000 /* inodedep has valid di_freelink */ 117 #define UNLINKPREV 0x100000 /* inodedep is pointed at in the unlink list */ 118 #define UNLINKONLIST 0x200000 /* inodedep is in the unlinked list on disk */ 119 #define UNLINKLINKS (UNLINKNEXT | UNLINKPREV) 120 121 #define ALLCOMPLETE (ATTACHED | COMPLETE | DEPCOMPLETE) 122 123 /* 124 * The workitem queue. 125 * 126 * It is sometimes useful and/or necessary to clean up certain dependencies 127 * in the background rather than during execution of an application process 128 * or interrupt service routine. To realize this, we append dependency 129 * structures corresponding to such tasks to a "workitem" queue. In a soft 130 * updates implementation, most pending workitems should not wait for more 131 * than a couple of seconds, so the filesystem syncer process awakens once 132 * per second to process the items on the queue. 133 */ 134 135 /* LIST_HEAD(workhead, worklist); -- declared in buf.h */ 136 137 /* 138 * Each request can be linked onto a work queue through its worklist structure. 139 * To avoid the need for a pointer to the structure itself, this structure 140 * MUST be declared FIRST in each type in which it appears! If more than one 141 * worklist is needed in the structure, then a wk_data field must be added 142 * and the macros below changed to use it. 143 */ 144 struct worklist { 145 LIST_ENTRY(worklist) wk_list; /* list of work requests */ 146 struct mount *wk_mp; /* Mount we live in */ 147 unsigned int wk_type:8, /* type of request */ 148 wk_state:24; /* state flags */ 149 }; 150 #define WK_DATA(wk) ((void *)(wk)) 151 #define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) 152 #define WK_INODEDEP(wk) ((struct inodedep *)(wk)) 153 #define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) 154 #define WK_NEWBLK(wk) ((struct newblk *)(wk)) 155 #define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) 156 #define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) 157 #define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) 158 #define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) 159 #define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) 160 #define WK_FREEWORK(wk) ((struct freework *)(wk)) 161 #define WK_FREEFILE(wk) ((struct freefile *)(wk)) 162 #define WK_DIRADD(wk) ((struct diradd *)(wk)) 163 #define WK_MKDIR(wk) ((struct mkdir *)(wk)) 164 #define WK_DIRREM(wk) ((struct dirrem *)(wk)) 165 #define WK_NEWDIRBLK(wk) ((struct newdirblk *)(wk)) 166 #define WK_JADDREF(wk) ((struct jaddref *)(wk)) 167 #define WK_JREMREF(wk) ((struct jremref *)(wk)) 168 #define WK_JMVREF(wk) ((struct jmvref *)(wk)) 169 #define WK_JSEGDEP(wk) ((struct jsegdep *)(wk)) 170 #define WK_JSEG(wk) ((struct jseg *)(wk)) 171 #define WK_JNEWBLK(wk) ((struct jnewblk *)(wk)) 172 #define WK_JFREEBLK(wk) ((struct jfreeblk *)(wk)) 173 #define WK_FREEDEP(wk) ((struct freedep *)(wk)) 174 #define WK_JFREEFRAG(wk) ((struct jfreefrag *)(wk)) 175 #define WK_SBDEP(wk) ((struct sbdep *)wk) 176 #define WK_JTRUNC(wk) ((struct jtrunc *)(wk)) 177 178 /* 179 * Various types of lists 180 */ 181 LIST_HEAD(dirremhd, dirrem); 182 LIST_HEAD(diraddhd, diradd); 183 LIST_HEAD(newblkhd, newblk); 184 LIST_HEAD(inodedephd, inodedep); 185 LIST_HEAD(allocindirhd, allocindir); 186 LIST_HEAD(allocdirecthd, allocdirect); 187 TAILQ_HEAD(allocdirectlst, allocdirect); 188 LIST_HEAD(indirdephd, indirdep); 189 LIST_HEAD(jaddrefhd, jaddref); 190 LIST_HEAD(jremrefhd, jremref); 191 LIST_HEAD(jmvrefhd, jmvref); 192 LIST_HEAD(jnewblkhd, jnewblk); 193 LIST_HEAD(jfreeblkhd, jfreeblk); 194 LIST_HEAD(freeworkhd, freework); 195 TAILQ_HEAD(jseglst, jseg); 196 TAILQ_HEAD(inoreflst, inoref); 197 198 /* 199 * The "pagedep" structure tracks the various dependencies related to 200 * a particular directory page. If a directory page has any dependencies, 201 * it will have a pagedep linked to its associated buffer. The 202 * pd_dirremhd list holds the list of dirrem requests which decrement 203 * inode reference counts. These requests are processed after the 204 * directory page with the corresponding zero'ed entries has been 205 * written. The pd_diraddhd list maintains the list of diradd requests 206 * which cannot be committed until their corresponding inode has been 207 * written to disk. Because a directory may have many new entries 208 * being created, several lists are maintained hashed on bits of the 209 * offset of the entry into the directory page to keep the lists from 210 * getting too long. Once a new directory entry has been cleared to 211 * be written, it is moved to the pd_pendinghd list. After the new 212 * entry has been written to disk it is removed from the pd_pendinghd 213 * list, any removed operations are done, and the dependency structure 214 * is freed. 215 */ 216 #define DAHASHSZ 5 217 #define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) 218 struct pagedep { 219 struct worklist pd_list; /* page buffer */ 220 # define pd_state pd_list.wk_state /* check for multiple I/O starts */ 221 LIST_ENTRY(pagedep) pd_hash; /* hashed lookup */ 222 ino_t pd_ino; /* associated file */ 223 ufs_lbn_t pd_lbn; /* block within file */ 224 struct newdirblk *pd_newdirblk; /* associated newdirblk if NEWBLOCK */ 225 struct dirremhd pd_dirremhd; /* dirrem's waiting for page */ 226 struct diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */ 227 struct diraddhd pd_pendinghd; /* directory entries awaiting write */ 228 struct jmvrefhd pd_jmvrefhd; /* Dependent journal writes. */ 229 }; 230 231 /* 232 * The "inodedep" structure tracks the set of dependencies associated 233 * with an inode. One task that it must manage is delayed operations 234 * (i.e., work requests that must be held until the inodedep's associated 235 * inode has been written to disk). Getting an inode from its incore 236 * state to the disk requires two steps to be taken by the filesystem 237 * in this order: first the inode must be copied to its disk buffer by 238 * the VOP_UPDATE operation; second the inode's buffer must be written 239 * to disk. To ensure that both operations have happened in the required 240 * order, the inodedep maintains two lists. Delayed operations are 241 * placed on the id_inowait list. When the VOP_UPDATE is done, all 242 * operations on the id_inowait list are moved to the id_bufwait list. 243 * When the buffer is written, the items on the id_bufwait list can be 244 * safely moved to the work queue to be processed. A second task of the 245 * inodedep structure is to track the status of block allocation within 246 * the inode. Each block that is allocated is represented by an 247 * "allocdirect" structure (see below). It is linked onto the id_newinoupdt 248 * list until both its contents and its allocation in the cylinder 249 * group map have been written to disk. Once these dependencies have been 250 * satisfied, it is removed from the id_newinoupdt list and any followup 251 * actions such as releasing the previous block or fragment are placed 252 * on the id_inowait list. When an inode is updated (a VOP_UPDATE is 253 * done), the "inodedep" structure is linked onto the buffer through 254 * its worklist. Thus, it will be notified when the buffer is about 255 * to be written and when it is done. At the update time, all the 256 * elements on the id_newinoupdt list are moved to the id_inoupdt list 257 * since those changes are now relevant to the copy of the inode in the 258 * buffer. Also at update time, the tasks on the id_inowait list are 259 * moved to the id_bufwait list so that they will be executed when 260 * the updated inode has been written to disk. When the buffer containing 261 * the inode is written to disk, any updates listed on the id_inoupdt 262 * list are rolled back as they are not yet safe. Following the write, 263 * the changes are once again rolled forward and any actions on the 264 * id_bufwait list are processed (since those actions are now safe). 265 * The entries on the id_inoupdt and id_newinoupdt lists must be kept 266 * sorted by logical block number to speed the calculation of the size 267 * of the rolled back inode (see explanation in initiate_write_inodeblock). 268 * When a directory entry is created, it is represented by a diradd. 269 * The diradd is added to the id_inowait list as it cannot be safely 270 * written to disk until the inode that it represents is on disk. After 271 * the inode is written, the id_bufwait list is processed and the diradd 272 * entries are moved to the id_pendinghd list where they remain until 273 * the directory block containing the name has been written to disk. 274 * The purpose of keeping the entries on the id_pendinghd list is so that 275 * the softdep_fsync function can find and push the inode's directory 276 * name(s) as part of the fsync operation for that file. 277 */ 278 struct inodedep { 279 struct worklist id_list; /* buffer holding inode block */ 280 # define id_state id_list.wk_state /* inode dependency state */ 281 LIST_ENTRY(inodedep) id_hash; /* hashed lookup */ 282 TAILQ_ENTRY(inodedep) id_unlinked; /* Unlinked but ref'd inodes */ 283 struct fs *id_fs; /* associated filesystem */ 284 ino_t id_ino; /* dependent inode */ 285 nlink_t id_nlinkdelta; /* saved effective link count */ 286 nlink_t id_savednlink; /* Link saved during rollback */ 287 LIST_ENTRY(inodedep) id_deps; /* bmsafemap's list of inodedep's */ 288 struct bmsafemap *id_bmsafemap; /* related bmsafemap (if pending) */ 289 struct diradd *id_mkdiradd; /* diradd for a mkdir. */ 290 struct inoreflst id_inoreflst; /* Inode reference adjustments. */ 291 long id_savedextsize; /* ext size saved during rollback */ 292 off_t id_savedsize; /* file size saved during rollback */ 293 struct dirremhd id_dirremhd; /* Removals pending. */ 294 struct workhead id_pendinghd; /* entries awaiting directory write */ 295 struct workhead id_bufwait; /* operations after inode written */ 296 struct workhead id_inowait; /* operations waiting inode update */ 297 struct allocdirectlst id_inoupdt; /* updates before inode written */ 298 struct allocdirectlst id_newinoupdt; /* updates when inode written */ 299 struct allocdirectlst id_extupdt; /* extdata updates pre-inode write */ 300 struct allocdirectlst id_newextupdt; /* extdata updates at ino write */ 301 union { 302 struct ufs1_dinode *idu_savedino1; /* saved ufs1_dinode contents */ 303 struct ufs2_dinode *idu_savedino2; /* saved ufs2_dinode contents */ 304 } id_un; 305 }; 306 #define id_savedino1 id_un.idu_savedino1 307 #define id_savedino2 id_un.idu_savedino2 308 309 /* 310 * A "bmsafemap" structure maintains a list of dependency structures 311 * that depend on the update of a particular cylinder group map. 312 * It has lists for newblks, allocdirects, allocindirs, and inodedeps. 313 * It is attached to the buffer of a cylinder group block when any of 314 * these things are allocated from the cylinder group. It is freed 315 * after the cylinder group map is written and the state of its 316 * dependencies are updated with DEPCOMPLETE to indicate that it has 317 * been processed. 318 */ 319 struct bmsafemap { 320 struct worklist sm_list; /* cylgrp buffer */ 321 # define sm_state sm_list.wk_state 322 int sm_cg; 323 LIST_ENTRY(bmsafemap) sm_hash; /* Hash links. */ 324 struct buf *sm_buf; /* associated buffer */ 325 struct allocdirecthd sm_allocdirecthd; /* allocdirect deps */ 326 struct allocdirecthd sm_allocdirectwr; /* writing allocdirect deps */ 327 struct allocindirhd sm_allocindirhd; /* allocindir deps */ 328 struct allocindirhd sm_allocindirwr; /* writing allocindir deps */ 329 struct inodedephd sm_inodedephd; /* inodedep deps */ 330 struct inodedephd sm_inodedepwr; /* writing inodedep deps */ 331 struct newblkhd sm_newblkhd; /* newblk deps */ 332 struct newblkhd sm_newblkwr; /* writing newblk deps */ 333 struct jaddrefhd sm_jaddrefhd; /* Pending inode allocations. */ 334 struct jnewblkhd sm_jnewblkhd; /* Pending block allocations. */ 335 }; 336 337 /* 338 * A "newblk" structure is attached to a bmsafemap structure when a block 339 * or fragment is allocated from a cylinder group. Its state is set to 340 * DEPCOMPLETE when its cylinder group map is written. It is converted to 341 * an allocdirect or allocindir allocation once the allocator calls the 342 * appropriate setup function. 343 */ 344 struct newblk { 345 struct worklist nb_list; 346 # define nb_state nb_list.wk_state 347 LIST_ENTRY(newblk) nb_hash; /* hashed lookup */ 348 LIST_ENTRY(newblk) nb_deps; /* bmsafemap's list of newblks */ 349 struct jnewblk *nb_jnewblk; /* New block journal entry. */ 350 struct bmsafemap *nb_bmsafemap;/* cylgrp dep (if pending) */ 351 struct freefrag *nb_freefrag; /* fragment to be freed (if any) */ 352 struct indirdephd nb_indirdeps; /* Children indirect blocks. */ 353 struct workhead nb_newdirblk; /* dir block to notify when written */ 354 struct workhead nb_jwork; /* Journal work pending. */ 355 ufs2_daddr_t nb_newblkno; /* new value of block pointer */ 356 }; 357 358 /* 359 * An "allocdirect" structure is attached to an "inodedep" when a new block 360 * or fragment is allocated and pointed to by the inode described by 361 * "inodedep". The worklist is linked to the buffer that holds the block. 362 * When the block is first allocated, it is linked to the bmsafemap 363 * structure associated with the buffer holding the cylinder group map 364 * from which it was allocated. When the cylinder group map is written 365 * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself 366 * is written, the COMPLETE flag is set. Once both the cylinder group map 367 * and the data itself have been written, it is safe to write the inode 368 * that claims the block. If there was a previous fragment that had been 369 * allocated before the file was increased in size, the old fragment may 370 * be freed once the inode claiming the new block is written to disk. 371 * This ad_fragfree request is attached to the id_inowait list of the 372 * associated inodedep (pointed to by ad_inodedep) for processing after 373 * the inode is written. When a block is allocated to a directory, an 374 * fsync of a file whose name is within that block must ensure not only 375 * that the block containing the file name has been written, but also 376 * that the on-disk inode references that block. When a new directory 377 * block is created, we allocate a newdirblk structure which is linked 378 * to the associated allocdirect (on its ad_newdirblk list). When the 379 * allocdirect has been satisfied, the newdirblk structure is moved to 380 * the inodedep id_bufwait list of its directory to await the inode 381 * being written. When the inode is written, the directory entries are 382 * fully committed and can be deleted from their pagedep->id_pendinghd 383 * and inodedep->id_pendinghd lists. 384 */ 385 struct allocdirect { 386 struct newblk ad_block; /* Common block logic */ 387 # define ad_state ad_block.nb_list.wk_state /* block pointer state */ 388 TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */ 389 struct inodedep *ad_inodedep; /* associated inodedep */ 390 ufs2_daddr_t ad_oldblkno; /* old value of block pointer */ 391 int ad_offset; /* Pointer offset in parent. */ 392 long ad_newsize; /* size of new block */ 393 long ad_oldsize; /* size of old block */ 394 }; 395 #define ad_newblkno ad_block.nb_newblkno 396 #define ad_freefrag ad_block.nb_freefrag 397 #define ad_newdirblk ad_block.nb_newdirblk 398 399 /* 400 * A single "indirdep" structure manages all allocation dependencies for 401 * pointers in an indirect block. The up-to-date state of the indirect 402 * block is stored in ir_savedata. The set of pointers that may be safely 403 * written to the disk is stored in ir_safecopy. The state field is used 404 * only to track whether the buffer is currently being written (in which 405 * case it is not safe to update ir_safecopy). Ir_deplisthd contains the 406 * list of allocindir structures, one for each block that needs to be 407 * written to disk. Once the block and its bitmap allocation have been 408 * written the safecopy can be updated to reflect the allocation and the 409 * allocindir structure freed. If ir_state indicates that an I/O on the 410 * indirect block is in progress when ir_safecopy is to be updated, the 411 * update is deferred by placing the allocindir on the ir_donehd list. 412 * When the I/O on the indirect block completes, the entries on the 413 * ir_donehd list are processed by updating their corresponding ir_safecopy 414 * pointers and then freeing the allocindir structure. 415 */ 416 struct indirdep { 417 struct worklist ir_list; /* buffer holding indirect block */ 418 # define ir_state ir_list.wk_state /* indirect block pointer state */ 419 LIST_ENTRY(indirdep) ir_next; /* alloc{direct,indir} list */ 420 caddr_t ir_saveddata; /* buffer cache contents */ 421 struct buf *ir_savebp; /* buffer holding safe copy */ 422 struct allocindirhd ir_completehd; /* waiting for indirdep complete */ 423 struct allocindirhd ir_writehd; /* Waiting for the pointer write. */ 424 struct allocindirhd ir_donehd; /* done waiting to update safecopy */ 425 struct allocindirhd ir_deplisthd; /* allocindir deps for this block */ 426 struct workhead ir_jwork; /* Journal work pending. */ 427 }; 428 429 /* 430 * An "allocindir" structure is attached to an "indirdep" when a new block 431 * is allocated and pointed to by the indirect block described by the 432 * "indirdep". The worklist is linked to the buffer that holds the new block. 433 * When the block is first allocated, it is linked to the bmsafemap 434 * structure associated with the buffer holding the cylinder group map 435 * from which it was allocated. When the cylinder group map is written 436 * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself 437 * is written, the COMPLETE flag is set. Once both the cylinder group map 438 * and the data itself have been written, it is safe to write the entry in 439 * the indirect block that claims the block; the "allocindir" dependency 440 * can then be freed as it is no longer applicable. 441 */ 442 struct allocindir { 443 struct newblk ai_block; /* Common block area */ 444 # define ai_state ai_block.nb_list.wk_state /* indirect pointer state */ 445 LIST_ENTRY(allocindir) ai_next; /* indirdep's list of allocindir's */ 446 struct indirdep *ai_indirdep; /* address of associated indirdep */ 447 ufs2_daddr_t ai_oldblkno; /* old value of block pointer */ 448 int ai_offset; /* Pointer offset in parent. */ 449 }; 450 #define ai_newblkno ai_block.nb_newblkno 451 #define ai_freefrag ai_block.nb_freefrag 452 #define ai_newdirblk ai_block.nb_newdirblk 453 454 /* 455 * The allblk union is used to size the newblk structure on allocation so 456 * that it may be any one of three types. 457 */ 458 union allblk { 459 struct allocindir ab_allocindir; 460 struct allocdirect ab_allocdirect; 461 struct newblk ab_newblk; 462 }; 463 464 /* 465 * A "freefrag" structure is attached to an "inodedep" when a previously 466 * allocated fragment is replaced with a larger fragment, rather than extended. 467 * The "freefrag" structure is constructed and attached when the replacement 468 * block is first allocated. It is processed after the inode claiming the 469 * bigger block that replaces it has been written to disk. 470 */ 471 struct freefrag { 472 struct worklist ff_list; /* id_inowait or delayed worklist */ 473 # define ff_state ff_list.wk_state 474 struct jfreefrag *ff_jfreefrag; /* Associated journal entry. */ 475 struct workhead ff_jwork; /* Journal work pending. */ 476 ufs2_daddr_t ff_blkno; /* fragment physical block number */ 477 long ff_fragsize; /* size of fragment being deleted */ 478 ino_t ff_inum; /* owning inode number */ 479 }; 480 481 /* 482 * A "freeblks" structure is attached to an "inodedep" when the 483 * corresponding file's length is reduced to zero. It records all 484 * the information needed to free the blocks of a file after its 485 * zero'ed inode has been written to disk. The actual work is done 486 * by child freework structures which are responsible for individual 487 * inode pointers while freeblks is responsible for retiring the 488 * entire operation when it is complete and holding common members. 489 */ 490 struct freeblks { 491 struct worklist fb_list; /* id_inowait or delayed worklist */ 492 # define fb_state fb_list.wk_state /* inode and dirty block state */ 493 struct jfreeblkhd fb_jfreeblkhd; /* Journal entries pending */ 494 struct workhead fb_freeworkhd; /* Work items pending */ 495 struct workhead fb_jwork; /* Journal work pending */ 496 ino_t fb_previousinum; /* inode of previous owner of blocks */ 497 uid_t fb_uid; /* uid of previous owner of blocks */ 498 struct vnode *fb_devvp; /* filesystem device vnode */ 499 ufs2_daddr_t fb_chkcnt; /* used to check cnt of blks released */ 500 int fb_ref; /* Children outstanding. */ 501 }; 502 503 /* 504 * A "freework" structure handles the release of a tree of blocks or a single 505 * block. Each indirect block in a tree is allocated its own freework 506 * structure so that the indrect block may be freed only when all of its 507 * children are freed. In this way we enforce the rule that an allocated 508 * block must have a valid path to a root that is journaled. Each child 509 * block acquires a reference and when the ref hits zero the parent ref 510 * is decremented. If there is no parent the freeblks ref is decremented. 511 */ 512 struct freework { 513 struct worklist fw_list; 514 # define fw_state fw_list.wk_state 515 LIST_ENTRY(freework) fw_next; /* Queue for freeblksk. */ 516 struct freeblks *fw_freeblks; /* Root of operation. */ 517 struct freework *fw_parent; /* Parent indirect. */ 518 ufs2_daddr_t fw_blkno; /* Our block #. */ 519 ufs_lbn_t fw_lbn; /* Original lbn before free. */ 520 int fw_frags; /* Number of frags. */ 521 int fw_ref; /* Number of children out. */ 522 int fw_off; /* Current working position. */ 523 struct workhead fw_jwork; /* Journal work pending. */ 524 }; 525 526 /* 527 * A "freedep" structure is allocated to track the completion of a bitmap 528 * write for a freework. One freedep may cover many freed blocks so long 529 * as they reside in the same cylinder group. When the cg is written 530 * the freedep decrements the ref on the freework which may permit it 531 * to be freed as well. 532 */ 533 struct freedep { 534 struct worklist fd_list; 535 struct freework *fd_freework; /* Parent freework. */ 536 }; 537 538 /* 539 * A "freefile" structure is attached to an inode when its 540 * link count is reduced to zero. It marks the inode as free in 541 * the cylinder group map after the zero'ed inode has been written 542 * to disk and any associated blocks and fragments have been freed. 543 */ 544 struct freefile { 545 struct worklist fx_list; /* id_inowait or delayed worklist */ 546 mode_t fx_mode; /* mode of inode */ 547 ino_t fx_oldinum; /* inum of the unlinked file */ 548 struct vnode *fx_devvp; /* filesystem device vnode */ 549 struct workhead fx_jwork; /* journal work pending. */ 550 }; 551 552 /* 553 * A "diradd" structure is linked to an "inodedep" id_inowait list when a 554 * new directory entry is allocated that references the inode described 555 * by "inodedep". When the inode itself is written (either the initial 556 * allocation for new inodes or with the increased link count for 557 * existing inodes), the COMPLETE flag is set in da_state. If the entry 558 * is for a newly allocated inode, the "inodedep" structure is associated 559 * with a bmsafemap which prevents the inode from being written to disk 560 * until the cylinder group has been updated. Thus the da_state COMPLETE 561 * flag cannot be set until the inode bitmap dependency has been removed. 562 * When creating a new file, it is safe to write the directory entry that 563 * claims the inode once the referenced inode has been written. Since 564 * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag 565 * in the diradd can be set unconditionally when creating a file. When 566 * creating a directory, there are two additional dependencies described by 567 * mkdir structures (see their description below). When these dependencies 568 * are resolved the DEPCOMPLETE flag is set in the diradd structure. 569 * If there are multiple links created to the same inode, there will be 570 * a separate diradd structure created for each link. The diradd is 571 * linked onto the pg_diraddhd list of the pagedep for the directory 572 * page that contains the entry. When a directory page is written, 573 * the pg_diraddhd list is traversed to rollback any entries that are 574 * not yet ready to be written to disk. If a directory entry is being 575 * changed (by rename) rather than added, the DIRCHG flag is set and 576 * the da_previous entry points to the entry that will be "removed" 577 * once the new entry has been committed. During rollback, entries 578 * with da_previous are replaced with the previous inode number rather 579 * than zero. 580 * 581 * The overlaying of da_pagedep and da_previous is done to keep the 582 * structure down. If a da_previous entry is present, the pointer to its 583 * pagedep is available in the associated dirrem entry. If the DIRCHG flag 584 * is set, the da_previous entry is valid; if not set the da_pagedep entry 585 * is valid. The DIRCHG flag never changes; it is set when the structure 586 * is created if appropriate and is never cleared. 587 */ 588 struct diradd { 589 struct worklist da_list; /* id_inowait or id_pendinghd list */ 590 # define da_state da_list.wk_state /* state of the new directory entry */ 591 LIST_ENTRY(diradd) da_pdlist; /* pagedep holding directory block */ 592 doff_t da_offset; /* offset of new dir entry in dir blk */ 593 ino_t da_newinum; /* inode number for the new dir entry */ 594 union { 595 struct dirrem *dau_previous; /* entry being replaced in dir change */ 596 struct pagedep *dau_pagedep; /* pagedep dependency for addition */ 597 } da_un; 598 struct workhead da_jwork; /* Journal work awaiting completion. */ 599 }; 600 #define da_previous da_un.dau_previous 601 #define da_pagedep da_un.dau_pagedep 602 603 /* 604 * Two "mkdir" structures are needed to track the additional dependencies 605 * associated with creating a new directory entry. Normally a directory 606 * addition can be committed as soon as the newly referenced inode has been 607 * written to disk with its increased link count. When a directory is 608 * created there are two additional dependencies: writing the directory 609 * data block containing the "." and ".." entries (MKDIR_BODY) and writing 610 * the parent inode with the increased link count for ".." (MKDIR_PARENT). 611 * These additional dependencies are tracked by two mkdir structures that 612 * reference the associated "diradd" structure. When they have completed, 613 * they set the DEPCOMPLETE flag on the diradd so that it knows that its 614 * extra dependencies have been completed. The md_state field is used only 615 * to identify which type of dependency the mkdir structure is tracking. 616 * It is not used in the mainline code for any purpose other than consistency 617 * checking. All the mkdir structures in the system are linked together on 618 * a list. This list is needed so that a diradd can find its associated 619 * mkdir structures and deallocate them if it is prematurely freed (as for 620 * example if a mkdir is immediately followed by a rmdir of the same directory). 621 * Here, the free of the diradd must traverse the list to find the associated 622 * mkdir structures that reference it. The deletion would be faster if the 623 * diradd structure were simply augmented to have two pointers that referenced 624 * the associated mkdir's. However, this would increase the size of the diradd 625 * structure to speed a very infrequent operation. 626 */ 627 struct mkdir { 628 struct worklist md_list; /* id_inowait or buffer holding dir */ 629 # define md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */ 630 struct diradd *md_diradd; /* associated diradd */ 631 struct jaddref *md_jaddref; /* dependent jaddref. */ 632 struct buf *md_buf; /* MKDIR_BODY: buffer holding dir */ 633 LIST_ENTRY(mkdir) md_mkdirs; /* list of all mkdirs */ 634 }; 635 LIST_HEAD(mkdirlist, mkdir) mkdirlisthd; 636 637 /* 638 * A "dirrem" structure describes an operation to decrement the link 639 * count on an inode. The dirrem structure is attached to the pg_dirremhd 640 * list of the pagedep for the directory page that contains the entry. 641 * It is processed after the directory page with the deleted entry has 642 * been written to disk. 643 */ 644 struct dirrem { 645 struct worklist dm_list; /* delayed worklist */ 646 # define dm_state dm_list.wk_state /* state of the old directory entry */ 647 LIST_ENTRY(dirrem) dm_next; /* pagedep's list of dirrem's */ 648 LIST_ENTRY(dirrem) dm_inonext; /* inodedep's list of dirrem's */ 649 struct jremrefhd dm_jremrefhd; /* Pending remove reference deps. */ 650 ino_t dm_oldinum; /* inum of the removed dir entry */ 651 union { 652 struct pagedep *dmu_pagedep; /* pagedep dependency for remove */ 653 ino_t dmu_dirinum; /* parent inode number (for rmdir) */ 654 } dm_un; 655 struct workhead dm_jwork; /* Journal work awaiting completion. */ 656 }; 657 #define dm_pagedep dm_un.dmu_pagedep 658 #define dm_dirinum dm_un.dmu_dirinum 659 660 /* 661 * A "newdirblk" structure tracks the progress of a newly allocated 662 * directory block from its creation until it is claimed by its on-disk 663 * inode. When a block is allocated to a directory, an fsync of a file 664 * whose name is within that block must ensure not only that the block 665 * containing the file name has been written, but also that the on-disk 666 * inode references that block. When a new directory block is created, 667 * we allocate a newdirblk structure which is linked to the associated 668 * allocdirect (on its ad_newdirblk list). When the allocdirect has been 669 * satisfied, the newdirblk structure is moved to the inodedep id_bufwait 670 * list of its directory to await the inode being written. When the inode 671 * is written, the directory entries are fully committed and can be 672 * deleted from their pagedep->id_pendinghd and inodedep->id_pendinghd 673 * lists. Note that we could track directory blocks allocated to indirect 674 * blocks using a similar scheme with the allocindir structures. Rather 675 * than adding this level of complexity, we simply write those newly 676 * allocated indirect blocks synchronously as such allocations are rare. 677 * In the case of a new directory the . and .. links are tracked with 678 * a mkdir rather than a pagedep. In this case we track the mkdir 679 * so it can be released when it is written. A workhead is used 680 * to simplify canceling a mkdir that is removed by a subsequent dirrem. 681 */ 682 struct newdirblk { 683 struct worklist db_list; /* id_inowait or pg_newdirblk */ 684 # define db_state db_list.wk_state /* unused */ 685 struct pagedep *db_pagedep; /* associated pagedep */ 686 struct workhead db_mkdir; 687 }; 688 689 /* 690 * The inoref structure holds the elements common to jaddref and jremref 691 * so they may easily be queued in-order on the inodedep. 692 */ 693 struct inoref { 694 struct worklist if_list; 695 # define if_state if_list.wk_state 696 TAILQ_ENTRY(inoref) if_deps; /* Links for inodedep. */ 697 struct jsegdep *if_jsegdep; 698 off_t if_diroff; /* Directory offset. */ 699 ino_t if_ino; /* Inode number. */ 700 ino_t if_parent; /* Parent inode number. */ 701 nlink_t if_nlink; /* nlink before addition. */ 702 uint16_t if_mode; /* File mode, needed for IFMT. */ 703 }; 704 705 /* 706 * A "jaddref" structure tracks a new reference (link count) on an inode 707 * and prevents the link count increase and bitmap allocation until a 708 * journal entry can be written. Once the journal entry is written, 709 * the inode is put on the pendinghd of the bmsafemap and a diradd or 710 * mkdir entry is placed on the bufwait list of the inode. The DEPCOMPLETE 711 * flag is used to indicate that all of the required information for writing 712 * the journal entry is present. MKDIR_BODY and MKDIR_PARENT are used to 713 * differentiate . and .. links from regular file names. NEWBLOCK indicates 714 * a bitmap is still pending. If a new reference is canceled by a delete 715 * prior to writing the journal the jaddref write is canceled and the 716 * structure persists to prevent any disk-visible changes until it is 717 * ultimately released when the file is freed or the link is dropped again. 718 */ 719 struct jaddref { 720 struct inoref ja_ref; 721 # define ja_list ja_ref.if_list /* Journal pending or jseg entries. */ 722 # define ja_state ja_ref.if_list.wk_state 723 LIST_ENTRY(jaddref) ja_bmdeps; /* Links for bmsafemap. */ 724 union { 725 struct diradd *jau_diradd; /* Pending diradd. */ 726 struct mkdir *jau_mkdir; /* MKDIR_{PARENT,BODY} */ 727 } ja_un; 728 }; 729 #define ja_diradd ja_un.jau_diradd 730 #define ja_mkdir ja_un.jau_mkdir 731 #define ja_diroff ja_ref.if_diroff 732 #define ja_ino ja_ref.if_ino 733 #define ja_parent ja_ref.if_parent 734 #define ja_mode ja_ref.if_mode 735 736 /* 737 * A "jremref" structure tracks a removed reference (unlink) on an 738 * inode and prevents the directory remove from proceeding until the 739 * journal entry is written. Once the journal has been written the remove 740 * may proceed as normal. 741 */ 742 struct jremref { 743 struct inoref jr_ref; 744 # define jr_list jr_ref.if_list /* Journal pending or jseg entries. */ 745 # define jr_state jr_ref.if_list.wk_state 746 LIST_ENTRY(jremref) jr_deps; /* Links for pagdep. */ 747 struct dirrem *jr_dirrem; /* Back pointer to dirrem. */ 748 }; 749 750 struct jmvref { 751 struct worklist jm_list; 752 LIST_ENTRY(jmvref) jm_deps; 753 struct pagedep *jm_pagedep; 754 ino_t jm_parent; 755 ino_t jm_ino; 756 off_t jm_oldoff; 757 off_t jm_newoff; 758 }; 759 760 /* 761 * A "jnewblk" structure tracks a newly allocated block or fragment and 762 * prevents the direct or indirect block pointer as well as the cg bitmap 763 * from being written until it is logged. After it is logged the jsegdep 764 * is attached to the allocdirect or allocindir until the operation is 765 * completed or reverted. If the operation is reverted prior to the journal 766 * write the jnewblk structure is maintained to prevent the bitmaps from 767 * reaching the disk. Ultimately the jnewblk structure will be passed 768 * to the free routine as the in memory cg is modified back to the free 769 * state at which time it can be released. 770 */ 771 struct jnewblk { 772 struct worklist jn_list; 773 # define jn_state jn_list.wk_state 774 struct jsegdep *jn_jsegdep; 775 LIST_ENTRY(jnewblk) jn_deps; /* All jnewblks on bmsafemap */ 776 struct newblk *jn_newblk; 777 ino_t jn_ino; 778 ufs_lbn_t jn_lbn; 779 ufs2_daddr_t jn_blkno; 780 int jn_oldfrags; 781 int jn_frags; 782 }; 783 784 /* 785 * A "jfreeblk" structure tracks the journal write for freeing a block 786 * or tree of blocks. The block pointer must not be cleared in the inode 787 * or indirect prior to the jfreeblk being written. 788 */ 789 struct jfreeblk { 790 struct worklist jf_list; 791 # define jf_state jf_list.wk_state 792 struct jsegdep *jf_jsegdep; 793 struct freeblks *jf_freeblks; 794 LIST_ENTRY(jfreeblk) jf_deps; 795 ino_t jf_ino; 796 ufs_lbn_t jf_lbn; 797 ufs2_daddr_t jf_blkno; 798 int jf_frags; 799 }; 800 801 /* 802 * A "jfreefrag" tracks the freeing of a single block when a fragment is 803 * extended or an indirect page is replaced. It is not part of a larger 804 * freeblks operation. 805 */ 806 struct jfreefrag { 807 struct worklist fr_list; 808 # define fr_state fr_list.wk_state 809 struct jsegdep *fr_jsegdep; 810 struct freefrag *fr_freefrag; 811 ino_t fr_ino; 812 ufs_lbn_t fr_lbn; 813 ufs2_daddr_t fr_blkno; 814 int fr_frags; 815 }; 816 817 /* 818 * A "jtrunc" journals the intent to truncate an inode to a non-zero 819 * value. This is done synchronously prior to the synchronous partial 820 * truncation process. The jsegdep is not released until the truncation 821 * is complete and the truncated inode is fsync'd. 822 */ 823 struct jtrunc { 824 struct worklist jt_list; 825 struct jsegdep *jt_jsegdep; 826 ino_t jt_ino; 827 off_t jt_size; 828 int jt_extsize; 829 }; 830 831 /* 832 * A "jsegdep" structure tracks a single reference to a written journal 833 * segment so the journal space can be reclaimed when all dependencies 834 * have been written. 835 */ 836 struct jsegdep { 837 struct worklist jd_list; 838 # define jd_state jd_list.wk_state 839 struct jseg *jd_seg; 840 }; 841 842 /* 843 * A "jseg" structure contains all of the journal records written in a 844 * single disk write. jaddref and jremref structures are linked into 845 * js_entries so thay may be completed when the write completes. The 846 * js_deps array contains as many entries as there are ref counts to 847 * reduce the number of allocations required per journal write to one. 848 */ 849 struct jseg { 850 struct worklist js_list; /* b_deps link for journal */ 851 # define js_state js_list.wk_state 852 struct workhead js_entries; /* Entries awaiting write */ 853 TAILQ_ENTRY(jseg) js_next; 854 struct jblocks *js_jblocks; /* Back pointer to block/seg list */ 855 struct buf *js_buf; /* Buffer while unwritten */ 856 uint64_t js_seq; 857 int js_size; /* Allocated size in bytes */ 858 int js_cnt; /* Total items allocated */ 859 int js_refs; /* Count of items pending completion */ 860 }; 861 862 /* 863 * A 'sbdep' structure tracks the head of the free inode list and 864 * superblock writes. This makes sure the superblock is always pointing at 865 * the first possible unlinked inode for the suj recovery process. If a 866 * block write completes and we discover a new head is available the buf 867 * is dirtied and the dep is kept. 868 */ 869 struct sbdep { 870 struct worklist sb_list; /* b_dep linkage */ 871 struct fs *sb_fs; /* Filesystem pointer within buf. */ 872 struct ufsmount *sb_ump; 873 }; 874