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