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
| 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
|
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
| 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
|
98#define ONWORKLIST 0x8000 99 100#define ALLCOMPLETE (ATTACHED | COMPLETE | DEPCOMPLETE) 101 102/* 103 * The workitem queue. 104 * 105 * It is sometimes useful and/or necessary to clean up certain dependencies 106 * in the background rather than during execution of an application process 107 * or interrupt service routine. To realize this, we append dependency 108 * structures corresponding to such tasks to a "workitem" queue. In a soft 109 * updates implementation, most pending workitems should not wait for more 110 * than a couple of seconds, so the filesystem syncer process awakens once 111 * per second to process the items on the queue. 112 */ 113 114/* LIST_HEAD(workhead, worklist); -- declared in buf.h */ 115 116/* 117 * Each request can be linked onto a work queue through its worklist structure. 118 * To avoid the need for a pointer to the structure itself, this structure 119 * MUST be declared FIRST in each type in which it appears! If more than one 120 * worklist is needed in the structure, then a wk_data field must be added 121 * and the macros below changed to use it. 122 */ 123struct worklist { 124 LIST_ENTRY(worklist) wk_list; /* list of work requests */ 125 unsigned short wk_type; /* type of request */ 126 unsigned short wk_state; /* state flags */ 127}; 128#define WK_DATA(wk) ((void *)(wk)) 129#define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) 130#define WK_INODEDEP(wk) ((struct inodedep *)(wk)) 131#define WK_NEWBLK(wk) ((struct newblk *)(wk)) 132#define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) 133#define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) 134#define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) 135#define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) 136#define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) 137#define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) 138#define WK_FREEFILE(wk) ((struct freefile *)(wk)) 139#define WK_DIRADD(wk) ((struct diradd *)(wk)) 140#define WK_MKDIR(wk) ((struct mkdir *)(wk)) 141#define WK_DIRREM(wk) ((struct dirrem *)(wk)) 142 143/* 144 * Various types of lists 145 */ 146LIST_HEAD(dirremhd, dirrem); 147LIST_HEAD(diraddhd, diradd); 148LIST_HEAD(newblkhd, newblk); 149LIST_HEAD(inodedephd, inodedep); 150LIST_HEAD(allocindirhd, allocindir); 151LIST_HEAD(allocdirecthd, allocdirect); 152TAILQ_HEAD(allocdirectlst, allocdirect); 153 154/* 155 * The "pagedep" structure tracks the various dependencies related to 156 * a particular directory page. If a directory page has any dependencies, 157 * it will have a pagedep linked to its associated buffer. The 158 * pd_dirremhd list holds the list of dirrem requests which decrement 159 * inode reference counts. These requests are processed after the 160 * directory page with the corresponding zero'ed entries has been 161 * written. The pd_diraddhd list maintains the list of diradd requests 162 * which cannot be committed until their corresponding inode has been 163 * written to disk. Because a directory may have many new entries 164 * being created, several lists are maintained hashed on bits of the 165 * offset of the entry into the directory page to keep the lists from 166 * getting too long. Once a new directory entry has been cleared to 167 * be written, it is moved to the pd_pendinghd list. After the new 168 * entry has been written to disk it is removed from the pd_pendinghd 169 * list, any removed operations are done, and the dependency structure 170 * is freed. 171 */ 172#define DAHASHSZ 6 173#define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) 174struct pagedep { 175 struct worklist pd_list; /* page buffer */ 176# define pd_state pd_list.wk_state /* check for multiple I/O starts */ 177 LIST_ENTRY(pagedep) pd_hash; /* hashed lookup */ 178 struct mount *pd_mnt; /* associated mount point */ 179 ino_t pd_ino; /* associated file */ 180 ufs_lbn_t pd_lbn; /* block within file */ 181 struct dirremhd pd_dirremhd; /* dirrem's waiting for page */ 182 struct diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */ 183 struct diraddhd pd_pendinghd; /* directory entries awaiting write */ 184}; 185 186/* 187 * The "inodedep" structure tracks the set of dependencies associated 188 * with an inode. One task that it must manage is delayed operations 189 * (i.e., work requests that must be held until the inodedep's associated 190 * inode has been written to disk). Getting an inode from its incore 191 * state to the disk requires two steps to be taken by the filesystem 192 * in this order: first the inode must be copied to its disk buffer by 193 * the VOP_UPDATE operation; second the inode's buffer must be written 194 * to disk. To ensure that both operations have happened in the required 195 * order, the inodedep maintains two lists. Delayed operations are 196 * placed on the id_inowait list. When the VOP_UPDATE is done, all 197 * operations on the id_inowait list are moved to the id_bufwait list. 198 * When the buffer is written, the items on the id_bufwait list can be 199 * safely moved to the work queue to be processed. A second task of the 200 * inodedep structure is to track the status of block allocation within 201 * the inode. Each block that is allocated is represented by an 202 * "allocdirect" structure (see below). It is linked onto the id_newinoupdt 203 * list until both its contents and its allocation in the cylinder 204 * group map have been written to disk. Once these dependencies have been 205 * satisfied, it is removed from the id_newinoupdt list and any followup 206 * actions such as releasing the previous block or fragment are placed 207 * on the id_inowait list. When an inode is updated (a VOP_UPDATE is 208 * done), the "inodedep" structure is linked onto the buffer through 209 * its worklist. Thus, it will be notified when the buffer is about 210 * to be written and when it is done. At the update time, all the 211 * elements on the id_newinoupdt list are moved to the id_inoupdt list 212 * since those changes are now relevant to the copy of the inode in the 213 * buffer. Also at update time, the tasks on the id_inowait list are 214 * moved to the id_bufwait list so that they will be executed when 215 * the updated inode has been written to disk. When the buffer containing 216 * the inode is written to disk, any updates listed on the id_inoupdt 217 * list are rolled back as they are not yet safe. Following the write, 218 * the changes are once again rolled forward and any actions on the 219 * id_bufwait list are processed (since those actions are now safe). 220 * The entries on the id_inoupdt and id_newinoupdt lists must be kept 221 * sorted by logical block number to speed the calculation of the size 222 * of the rolled back inode (see explanation in initiate_write_inodeblock). 223 * When a directory entry is created, it is represented by a diradd. 224 * The diradd is added to the id_inowait list as it cannot be safely 225 * written to disk until the inode that it represents is on disk. After 226 * the inode is written, the id_bufwait list is processed and the diradd 227 * entries are moved to the id_pendinghd list where they remain until 228 * the directory block containing the name has been written to disk. 229 * The purpose of keeping the entries on the id_pendinghd list is so that 230 * the softdep_fsync function can find and push the inode's directory 231 * name(s) as part of the fsync operation for that file. 232 */ 233struct inodedep { 234 struct worklist id_list; /* buffer holding inode block */ 235# define id_state id_list.wk_state /* inode dependency state */ 236 LIST_ENTRY(inodedep) id_hash; /* hashed lookup */ 237 struct fs *id_fs; /* associated filesystem */ 238 ino_t id_ino; /* dependent inode */ 239 nlink_t id_nlinkdelta; /* saved effective link count */ 240 struct dinode *id_savedino; /* saved dinode contents */ 241 LIST_ENTRY(inodedep) id_deps; /* bmsafemap's list of inodedep's */ 242 struct buf *id_buf; /* related bmsafemap (if pending) */ 243 off_t id_savedsize; /* file size saved during rollback */ 244 struct workhead id_pendinghd; /* entries awaiting directory write */ 245 struct workhead id_bufwait; /* operations after inode written */ 246 struct workhead id_inowait; /* operations waiting inode update */ 247 struct allocdirectlst id_inoupdt; /* updates before inode written */ 248 struct allocdirectlst id_newinoupdt; /* updates when inode written */ 249}; 250 251/* 252 * A "newblk" structure is attached to a bmsafemap structure when a block 253 * or fragment is allocated from a cylinder group. Its state is set to 254 * DEPCOMPLETE when its cylinder group map is written. It is consumed by 255 * an associated allocdirect or allocindir allocation which will attach 256 * themselves to the bmsafemap structure if the newblk's DEPCOMPLETE flag 257 * is not set (i.e., its cylinder group map has not been written). 258 */ 259struct newblk { 260 LIST_ENTRY(newblk) nb_hash; /* hashed lookup */ 261 struct fs *nb_fs; /* associated filesystem */ 262 ufs_daddr_t nb_newblkno; /* allocated block number */ 263 int nb_state; /* state of bitmap dependency */ 264 LIST_ENTRY(newblk) nb_deps; /* bmsafemap's list of newblk's */ 265 struct bmsafemap *nb_bmsafemap; /* associated bmsafemap */ 266}; 267 268/* 269 * A "bmsafemap" structure maintains a list of dependency structures 270 * that depend on the update of a particular cylinder group map. 271 * It has lists for newblks, allocdirects, allocindirs, and inodedeps. 272 * It is attached to the buffer of a cylinder group block when any of 273 * these things are allocated from the cylinder group. It is freed 274 * after the cylinder group map is written and the state of its 275 * dependencies are updated with DEPCOMPLETE to indicate that it has 276 * been processed. 277 */ 278struct bmsafemap { 279 struct worklist sm_list; /* cylgrp buffer */ 280 struct buf *sm_buf; /* associated buffer */ 281 struct allocdirecthd sm_allocdirecthd; /* allocdirect deps */ 282 struct allocindirhd sm_allocindirhd; /* allocindir deps */ 283 struct inodedephd sm_inodedephd; /* inodedep deps */ 284 struct newblkhd sm_newblkhd; /* newblk deps */ 285}; 286 287/* 288 * An "allocdirect" structure is attached to an "inodedep" when a new block 289 * or fragment is allocated and pointed to by the inode described by 290 * "inodedep". The worklist is linked to the buffer that holds the block. 291 * When the block is first allocated, it is linked to the bmsafemap 292 * structure associated with the buffer holding the cylinder group map 293 * from which it was allocated. When the cylinder group map is written 294 * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself 295 * is written, the COMPLETE flag is set. Once both the cylinder group map 296 * and the data itself have been written, it is safe to write the inode 297 * that claims the block. If there was a previous fragment that had been 298 * allocated before the file was increased in size, the old fragment may 299 * be freed once the inode claiming the new block is written to disk. 300 * This ad_fragfree request is attached to the id_inowait list of the 301 * associated inodedep (pointed to by ad_inodedep) for processing after 302 * the inode is written. 303 */ 304struct allocdirect { 305 struct worklist ad_list; /* buffer holding block */ 306# define ad_state ad_list.wk_state /* block pointer state */ 307 TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */ 308 ufs_lbn_t ad_lbn; /* block within file */ 309 ufs_daddr_t ad_newblkno; /* new value of block pointer */ 310 ufs_daddr_t ad_oldblkno; /* old value of block pointer */ 311 long ad_newsize; /* size of new block */ 312 long ad_oldsize; /* size of old block */ 313 LIST_ENTRY(allocdirect) ad_deps; /* bmsafemap's list of allocdirect's */ 314 struct buf *ad_buf; /* cylgrp buffer (if pending) */ 315 struct inodedep *ad_inodedep; /* associated inodedep */ 316 struct freefrag *ad_freefrag; /* fragment to be freed (if any) */ 317}; 318 319/* 320 * A single "indirdep" structure manages all allocation dependencies for 321 * pointers in an indirect block. The up-to-date state of the indirect 322 * block is stored in ir_savedata. The set of pointers that may be safely 323 * written to the disk is stored in ir_safecopy. The state field is used 324 * only to track whether the buffer is currently being written (in which 325 * case it is not safe to update ir_safecopy). Ir_deplisthd contains the 326 * list of allocindir structures, one for each block that needs to be 327 * written to disk. Once the block and its bitmap allocation have been 328 * written the safecopy can be updated to reflect the allocation and the 329 * allocindir structure freed. If ir_state indicates that an I/O on the 330 * indirect block is in progress when ir_safecopy is to be updated, the 331 * update is deferred by placing the allocindir on the ir_donehd list. 332 * When the I/O on the indirect block completes, the entries on the 333 * ir_donehd list are processed by updating their corresponding ir_safecopy 334 * pointers and then freeing the allocindir structure. 335 */ 336struct indirdep { 337 struct worklist ir_list; /* buffer holding indirect block */ 338# define ir_state ir_list.wk_state /* indirect block pointer state */ 339 caddr_t ir_saveddata; /* buffer cache contents */ 340 struct buf *ir_savebp; /* buffer holding safe copy */ 341 struct allocindirhd ir_donehd; /* done waiting to update safecopy */ 342 struct allocindirhd ir_deplisthd; /* allocindir deps for this block */ 343}; 344 345/* 346 * An "allocindir" structure is attached to an "indirdep" when a new block 347 * is allocated and pointed to by the indirect block described by the 348 * "indirdep". The worklist is linked to the buffer that holds the new block. 349 * When the block is first allocated, it is linked to the bmsafemap 350 * structure associated with the buffer holding the cylinder group map 351 * from which it was allocated. When the cylinder group map is written 352 * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself 353 * is written, the COMPLETE flag is set. Once both the cylinder group map 354 * and the data itself have been written, it is safe to write the entry in 355 * the indirect block that claims the block; the "allocindir" dependency 356 * can then be freed as it is no longer applicable. 357 */ 358struct allocindir { 359 struct worklist ai_list; /* buffer holding indirect block */ 360# define ai_state ai_list.wk_state /* indirect block pointer state */ 361 LIST_ENTRY(allocindir) ai_next; /* indirdep's list of allocindir's */ 362 int ai_offset; /* pointer offset in indirect block */ 363 ufs_daddr_t ai_newblkno; /* new block pointer value */ 364 ufs_daddr_t ai_oldblkno; /* old block pointer value */ 365 struct freefrag *ai_freefrag; /* block to be freed when complete */ 366 struct indirdep *ai_indirdep; /* address of associated indirdep */ 367 LIST_ENTRY(allocindir) ai_deps; /* bmsafemap's list of allocindir's */ 368 struct buf *ai_buf; /* cylgrp buffer (if pending) */ 369}; 370 371/* 372 * A "freefrag" structure is attached to an "inodedep" when a previously 373 * allocated fragment is replaced with a larger fragment, rather than extended. 374 * The "freefrag" structure is constructed and attached when the replacement 375 * block is first allocated. It is processed after the inode claiming the 376 * bigger block that replaces it has been written to disk. Note that the 377 * ff_state field is is used to store the uid, so may lose data. However, 378 * the uid is used only in printing an error message, so is not critical. 379 * Keeping it in a short keeps the data structure down to 32 bytes. 380 */ 381struct freefrag { 382 struct worklist ff_list; /* id_inowait or delayed worklist */ 383# define ff_state ff_list.wk_state /* owning user; should be uid_t */ 384 struct vnode *ff_devvp; /* filesystem device vnode */ 385 struct mount *ff_mnt; /* associated mount point */ 386 ufs_daddr_t ff_blkno; /* fragment physical block number */ 387 long ff_fragsize; /* size of fragment being deleted */ 388 ino_t ff_inum; /* owning inode number */ 389}; 390 391/* 392 * A "freeblks" structure is attached to an "inodedep" when the 393 * corresponding file's length is reduced to zero. It records all 394 * the information needed to free the blocks of a file after its 395 * zero'ed inode has been written to disk. 396 */ 397struct freeblks { 398 struct worklist fb_list; /* id_inowait or delayed worklist */ 399 ino_t fb_previousinum; /* inode of previous owner of blocks */ 400 struct vnode *fb_devvp; /* filesystem device vnode */ 401 struct mount *fb_mnt; /* associated mount point */ 402 off_t fb_oldsize; /* previous file size */ 403 off_t fb_newsize; /* new file size */ 404 int fb_chkcnt; /* used to check cnt of blks released */ 405 uid_t fb_uid; /* uid of previous owner of blocks */ 406 ufs_daddr_t fb_dblks[NDADDR]; /* direct blk ptrs to deallocate */ 407 ufs_daddr_t fb_iblks[NIADDR]; /* indirect blk ptrs to deallocate */ 408}; 409 410/* 411 * A "freefile" structure is attached to an inode when its 412 * link count is reduced to zero. It marks the inode as free in 413 * the cylinder group map after the zero'ed inode has been written 414 * to disk and any associated blocks and fragments have been freed. 415 */ 416struct freefile { 417 struct worklist fx_list; /* id_inowait or delayed worklist */ 418 mode_t fx_mode; /* mode of inode */ 419 ino_t fx_oldinum; /* inum of the unlinked file */ 420 struct vnode *fx_devvp; /* filesystem device vnode */ 421 struct mount *fx_mnt; /* associated mount point */ 422}; 423 424/* 425 * A "diradd" structure is linked to an "inodedep" id_inowait list when a 426 * new directory entry is allocated that references the inode described 427 * by "inodedep". When the inode itself is written (either the initial 428 * allocation for new inodes or with the increased link count for 429 * existing inodes), the COMPLETE flag is set in da_state. If the entry 430 * is for a newly allocated inode, the "inodedep" structure is associated 431 * with a bmsafemap which prevents the inode from being written to disk 432 * until the cylinder group has been updated. Thus the da_state COMPLETE 433 * flag cannot be set until the inode bitmap dependency has been removed. 434 * When creating a new file, it is safe to write the directory entry that 435 * claims the inode once the referenced inode has been written. Since 436 * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag 437 * in the diradd can be set unconditionally when creating a file. When 438 * creating a directory, there are two additional dependencies described by 439 * mkdir structures (see their description below). When these dependencies 440 * are resolved the DEPCOMPLETE flag is set in the diradd structure. 441 * If there are multiple links created to the same inode, there will be 442 * a separate diradd structure created for each link. The diradd is 443 * linked onto the pg_diraddhd list of the pagedep for the directory 444 * page that contains the entry. When a directory page is written, 445 * the pg_diraddhd list is traversed to rollback any entries that are 446 * not yet ready to be written to disk. If a directory entry is being 447 * changed (by rename) rather than added, the DIRCHG flag is set and 448 * the da_previous entry points to the entry that will be "removed" 449 * once the new entry has been committed. During rollback, entries 450 * with da_previous are replaced with the previous inode number rather 451 * than zero. 452 * 453 * The overlaying of da_pagedep and da_previous is done to keep the 454 * structure down to 32 bytes in size on a 32-bit machine. If a 455 * da_previous entry is present, the pointer to its pagedep is available 456 * in the associated dirrem entry. If the DIRCHG flag is set, the 457 * da_previous entry is valid; if not set the da_pagedep entry is valid. 458 * The DIRCHG flag never changes; it is set when the structure is created 459 * if appropriate and is never cleared. 460 */ 461struct diradd { 462 struct worklist da_list; /* id_inowait or id_pendinghd list */ 463# define da_state da_list.wk_state /* state of the new directory entry */ 464 LIST_ENTRY(diradd) da_pdlist; /* pagedep holding directory block */ 465 doff_t da_offset; /* offset of new dir entry in dir blk */ 466 ino_t da_newinum; /* inode number for the new dir entry */ 467 union { 468 struct dirrem *dau_previous; /* entry being replaced in dir change */ 469 struct pagedep *dau_pagedep; /* pagedep dependency for addition */ 470 } da_un; 471}; 472#define da_previous da_un.dau_previous 473#define da_pagedep da_un.dau_pagedep 474 475/* 476 * Two "mkdir" structures are needed to track the additional dependencies 477 * associated with creating a new directory entry. Normally a directory 478 * addition can be committed as soon as the newly referenced inode has been 479 * written to disk with its increased link count. When a directory is 480 * created there are two additional dependencies: writing the directory 481 * data block containing the "." and ".." entries (MKDIR_BODY) and writing 482 * the parent inode with the increased link count for ".." (MKDIR_PARENT). 483 * These additional dependencies are tracked by two mkdir structures that 484 * reference the associated "diradd" structure. When they have completed, 485 * they set the DEPCOMPLETE flag on the diradd so that it knows that its 486 * extra dependencies have been completed. The md_state field is used only 487 * to identify which type of dependency the mkdir structure is tracking. 488 * It is not used in the mainline code for any purpose other than consistency 489 * checking. All the mkdir structures in the system are linked together on 490 * a list. This list is needed so that a diradd can find its associated 491 * mkdir structures and deallocate them if it is prematurely freed (as for 492 * example if a mkdir is immediately followed by a rmdir of the same directory). 493 * Here, the free of the diradd must traverse the list to find the associated 494 * mkdir structures that reference it. The deletion would be faster if the 495 * diradd structure were simply augmented to have two pointers that referenced 496 * the associated mkdir's. However, this would increase the size of the diradd 497 * structure from 32 to 64-bits to speed a very infrequent operation. 498 */ 499struct mkdir { 500 struct worklist md_list; /* id_inowait or buffer holding dir */ 501# define md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */ 502 struct diradd *md_diradd; /* associated diradd */ 503 struct buf *md_buf; /* MKDIR_BODY: buffer holding dir */ 504 LIST_ENTRY(mkdir) md_mkdirs; /* list of all mkdirs */ 505}; 506LIST_HEAD(mkdirlist, mkdir) mkdirlisthd; 507 508/* 509 * A "dirrem" structure describes an operation to decrement the link 510 * count on an inode. The dirrem structure is attached to the pg_dirremhd 511 * list of the pagedep for the directory page that contains the entry. 512 * It is processed after the directory page with the deleted entry has 513 * been written to disk. 514 * 515 * The overlaying of dm_pagedep and dm_dirinum is done to keep the 516 * structure down to 32 bytes in size on a 32-bit machine. It works 517 * because they are never used concurrently. 518 */ 519struct dirrem { 520 struct worklist dm_list; /* delayed worklist */ 521# define dm_state dm_list.wk_state /* state of the old directory entry */ 522 LIST_ENTRY(dirrem) dm_next; /* pagedep's list of dirrem's */ 523 struct mount *dm_mnt; /* associated mount point */ 524 ino_t dm_oldinum; /* inum of the removed dir entry */ 525 union { 526 struct pagedep *dmu_pagedep; /* pagedep dependency for remove */ 527 ino_t dmu_dirinum; /* parent inode number (for rmdir) */ 528 } dm_un; 529}; 530#define dm_pagedep dm_un.dmu_pagedep 531#define dm_dirinum dm_un.dmu_dirinum
| 101#define ONWORKLIST 0x8000 102 103#define ALLCOMPLETE (ATTACHED | COMPLETE | DEPCOMPLETE) 104 105/* 106 * The workitem queue. 107 * 108 * It is sometimes useful and/or necessary to clean up certain dependencies 109 * in the background rather than during execution of an application process 110 * or interrupt service routine. To realize this, we append dependency 111 * structures corresponding to such tasks to a "workitem" queue. In a soft 112 * updates implementation, most pending workitems should not wait for more 113 * than a couple of seconds, so the filesystem syncer process awakens once 114 * per second to process the items on the queue. 115 */ 116 117/* LIST_HEAD(workhead, worklist); -- declared in buf.h */ 118 119/* 120 * Each request can be linked onto a work queue through its worklist structure. 121 * To avoid the need for a pointer to the structure itself, this structure 122 * MUST be declared FIRST in each type in which it appears! If more than one 123 * worklist is needed in the structure, then a wk_data field must be added 124 * and the macros below changed to use it. 125 */ 126struct worklist { 127 LIST_ENTRY(worklist) wk_list; /* list of work requests */ 128 unsigned short wk_type; /* type of request */ 129 unsigned short wk_state; /* state flags */ 130}; 131#define WK_DATA(wk) ((void *)(wk)) 132#define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) 133#define WK_INODEDEP(wk) ((struct inodedep *)(wk)) 134#define WK_NEWBLK(wk) ((struct newblk *)(wk)) 135#define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) 136#define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) 137#define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) 138#define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) 139#define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) 140#define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) 141#define WK_FREEFILE(wk) ((struct freefile *)(wk)) 142#define WK_DIRADD(wk) ((struct diradd *)(wk)) 143#define WK_MKDIR(wk) ((struct mkdir *)(wk)) 144#define WK_DIRREM(wk) ((struct dirrem *)(wk)) 145 146/* 147 * Various types of lists 148 */ 149LIST_HEAD(dirremhd, dirrem); 150LIST_HEAD(diraddhd, diradd); 151LIST_HEAD(newblkhd, newblk); 152LIST_HEAD(inodedephd, inodedep); 153LIST_HEAD(allocindirhd, allocindir); 154LIST_HEAD(allocdirecthd, allocdirect); 155TAILQ_HEAD(allocdirectlst, allocdirect); 156 157/* 158 * The "pagedep" structure tracks the various dependencies related to 159 * a particular directory page. If a directory page has any dependencies, 160 * it will have a pagedep linked to its associated buffer. The 161 * pd_dirremhd list holds the list of dirrem requests which decrement 162 * inode reference counts. These requests are processed after the 163 * directory page with the corresponding zero'ed entries has been 164 * written. The pd_diraddhd list maintains the list of diradd requests 165 * which cannot be committed until their corresponding inode has been 166 * written to disk. Because a directory may have many new entries 167 * being created, several lists are maintained hashed on bits of the 168 * offset of the entry into the directory page to keep the lists from 169 * getting too long. Once a new directory entry has been cleared to 170 * be written, it is moved to the pd_pendinghd list. After the new 171 * entry has been written to disk it is removed from the pd_pendinghd 172 * list, any removed operations are done, and the dependency structure 173 * is freed. 174 */ 175#define DAHASHSZ 6 176#define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) 177struct pagedep { 178 struct worklist pd_list; /* page buffer */ 179# define pd_state pd_list.wk_state /* check for multiple I/O starts */ 180 LIST_ENTRY(pagedep) pd_hash; /* hashed lookup */ 181 struct mount *pd_mnt; /* associated mount point */ 182 ino_t pd_ino; /* associated file */ 183 ufs_lbn_t pd_lbn; /* block within file */ 184 struct dirremhd pd_dirremhd; /* dirrem's waiting for page */ 185 struct diraddhd pd_diraddhd[DAHASHSZ]; /* diradd dir entry updates */ 186 struct diraddhd pd_pendinghd; /* directory entries awaiting write */ 187}; 188 189/* 190 * The "inodedep" structure tracks the set of dependencies associated 191 * with an inode. One task that it must manage is delayed operations 192 * (i.e., work requests that must be held until the inodedep's associated 193 * inode has been written to disk). Getting an inode from its incore 194 * state to the disk requires two steps to be taken by the filesystem 195 * in this order: first the inode must be copied to its disk buffer by 196 * the VOP_UPDATE operation; second the inode's buffer must be written 197 * to disk. To ensure that both operations have happened in the required 198 * order, the inodedep maintains two lists. Delayed operations are 199 * placed on the id_inowait list. When the VOP_UPDATE is done, all 200 * operations on the id_inowait list are moved to the id_bufwait list. 201 * When the buffer is written, the items on the id_bufwait list can be 202 * safely moved to the work queue to be processed. A second task of the 203 * inodedep structure is to track the status of block allocation within 204 * the inode. Each block that is allocated is represented by an 205 * "allocdirect" structure (see below). It is linked onto the id_newinoupdt 206 * list until both its contents and its allocation in the cylinder 207 * group map have been written to disk. Once these dependencies have been 208 * satisfied, it is removed from the id_newinoupdt list and any followup 209 * actions such as releasing the previous block or fragment are placed 210 * on the id_inowait list. When an inode is updated (a VOP_UPDATE is 211 * done), the "inodedep" structure is linked onto the buffer through 212 * its worklist. Thus, it will be notified when the buffer is about 213 * to be written and when it is done. At the update time, all the 214 * elements on the id_newinoupdt list are moved to the id_inoupdt list 215 * since those changes are now relevant to the copy of the inode in the 216 * buffer. Also at update time, the tasks on the id_inowait list are 217 * moved to the id_bufwait list so that they will be executed when 218 * the updated inode has been written to disk. When the buffer containing 219 * the inode is written to disk, any updates listed on the id_inoupdt 220 * list are rolled back as they are not yet safe. Following the write, 221 * the changes are once again rolled forward and any actions on the 222 * id_bufwait list are processed (since those actions are now safe). 223 * The entries on the id_inoupdt and id_newinoupdt lists must be kept 224 * sorted by logical block number to speed the calculation of the size 225 * of the rolled back inode (see explanation in initiate_write_inodeblock). 226 * When a directory entry is created, it is represented by a diradd. 227 * The diradd is added to the id_inowait list as it cannot be safely 228 * written to disk until the inode that it represents is on disk. After 229 * the inode is written, the id_bufwait list is processed and the diradd 230 * entries are moved to the id_pendinghd list where they remain until 231 * the directory block containing the name has been written to disk. 232 * The purpose of keeping the entries on the id_pendinghd list is so that 233 * the softdep_fsync function can find and push the inode's directory 234 * name(s) as part of the fsync operation for that file. 235 */ 236struct inodedep { 237 struct worklist id_list; /* buffer holding inode block */ 238# define id_state id_list.wk_state /* inode dependency state */ 239 LIST_ENTRY(inodedep) id_hash; /* hashed lookup */ 240 struct fs *id_fs; /* associated filesystem */ 241 ino_t id_ino; /* dependent inode */ 242 nlink_t id_nlinkdelta; /* saved effective link count */ 243 struct dinode *id_savedino; /* saved dinode contents */ 244 LIST_ENTRY(inodedep) id_deps; /* bmsafemap's list of inodedep's */ 245 struct buf *id_buf; /* related bmsafemap (if pending) */ 246 off_t id_savedsize; /* file size saved during rollback */ 247 struct workhead id_pendinghd; /* entries awaiting directory write */ 248 struct workhead id_bufwait; /* operations after inode written */ 249 struct workhead id_inowait; /* operations waiting inode update */ 250 struct allocdirectlst id_inoupdt; /* updates before inode written */ 251 struct allocdirectlst id_newinoupdt; /* updates when inode written */ 252}; 253 254/* 255 * A "newblk" structure is attached to a bmsafemap structure when a block 256 * or fragment is allocated from a cylinder group. Its state is set to 257 * DEPCOMPLETE when its cylinder group map is written. It is consumed by 258 * an associated allocdirect or allocindir allocation which will attach 259 * themselves to the bmsafemap structure if the newblk's DEPCOMPLETE flag 260 * is not set (i.e., its cylinder group map has not been written). 261 */ 262struct newblk { 263 LIST_ENTRY(newblk) nb_hash; /* hashed lookup */ 264 struct fs *nb_fs; /* associated filesystem */ 265 ufs_daddr_t nb_newblkno; /* allocated block number */ 266 int nb_state; /* state of bitmap dependency */ 267 LIST_ENTRY(newblk) nb_deps; /* bmsafemap's list of newblk's */ 268 struct bmsafemap *nb_bmsafemap; /* associated bmsafemap */ 269}; 270 271/* 272 * A "bmsafemap" structure maintains a list of dependency structures 273 * that depend on the update of a particular cylinder group map. 274 * It has lists for newblks, allocdirects, allocindirs, and inodedeps. 275 * It is attached to the buffer of a cylinder group block when any of 276 * these things are allocated from the cylinder group. It is freed 277 * after the cylinder group map is written and the state of its 278 * dependencies are updated with DEPCOMPLETE to indicate that it has 279 * been processed. 280 */ 281struct bmsafemap { 282 struct worklist sm_list; /* cylgrp buffer */ 283 struct buf *sm_buf; /* associated buffer */ 284 struct allocdirecthd sm_allocdirecthd; /* allocdirect deps */ 285 struct allocindirhd sm_allocindirhd; /* allocindir deps */ 286 struct inodedephd sm_inodedephd; /* inodedep deps */ 287 struct newblkhd sm_newblkhd; /* newblk deps */ 288}; 289 290/* 291 * An "allocdirect" structure is attached to an "inodedep" when a new block 292 * or fragment is allocated and pointed to by the inode described by 293 * "inodedep". The worklist is linked to the buffer that holds the block. 294 * When the block is first allocated, it is linked to the bmsafemap 295 * structure associated with the buffer holding the cylinder group map 296 * from which it was allocated. When the cylinder group map is written 297 * to disk, ad_state has the DEPCOMPLETE flag set. When the block itself 298 * is written, the COMPLETE flag is set. Once both the cylinder group map 299 * and the data itself have been written, it is safe to write the inode 300 * that claims the block. If there was a previous fragment that had been 301 * allocated before the file was increased in size, the old fragment may 302 * be freed once the inode claiming the new block is written to disk. 303 * This ad_fragfree request is attached to the id_inowait list of the 304 * associated inodedep (pointed to by ad_inodedep) for processing after 305 * the inode is written. 306 */ 307struct allocdirect { 308 struct worklist ad_list; /* buffer holding block */ 309# define ad_state ad_list.wk_state /* block pointer state */ 310 TAILQ_ENTRY(allocdirect) ad_next; /* inodedep's list of allocdirect's */ 311 ufs_lbn_t ad_lbn; /* block within file */ 312 ufs_daddr_t ad_newblkno; /* new value of block pointer */ 313 ufs_daddr_t ad_oldblkno; /* old value of block pointer */ 314 long ad_newsize; /* size of new block */ 315 long ad_oldsize; /* size of old block */ 316 LIST_ENTRY(allocdirect) ad_deps; /* bmsafemap's list of allocdirect's */ 317 struct buf *ad_buf; /* cylgrp buffer (if pending) */ 318 struct inodedep *ad_inodedep; /* associated inodedep */ 319 struct freefrag *ad_freefrag; /* fragment to be freed (if any) */ 320}; 321 322/* 323 * A single "indirdep" structure manages all allocation dependencies for 324 * pointers in an indirect block. The up-to-date state of the indirect 325 * block is stored in ir_savedata. The set of pointers that may be safely 326 * written to the disk is stored in ir_safecopy. The state field is used 327 * only to track whether the buffer is currently being written (in which 328 * case it is not safe to update ir_safecopy). Ir_deplisthd contains the 329 * list of allocindir structures, one for each block that needs to be 330 * written to disk. Once the block and its bitmap allocation have been 331 * written the safecopy can be updated to reflect the allocation and the 332 * allocindir structure freed. If ir_state indicates that an I/O on the 333 * indirect block is in progress when ir_safecopy is to be updated, the 334 * update is deferred by placing the allocindir on the ir_donehd list. 335 * When the I/O on the indirect block completes, the entries on the 336 * ir_donehd list are processed by updating their corresponding ir_safecopy 337 * pointers and then freeing the allocindir structure. 338 */ 339struct indirdep { 340 struct worklist ir_list; /* buffer holding indirect block */ 341# define ir_state ir_list.wk_state /* indirect block pointer state */ 342 caddr_t ir_saveddata; /* buffer cache contents */ 343 struct buf *ir_savebp; /* buffer holding safe copy */ 344 struct allocindirhd ir_donehd; /* done waiting to update safecopy */ 345 struct allocindirhd ir_deplisthd; /* allocindir deps for this block */ 346}; 347 348/* 349 * An "allocindir" structure is attached to an "indirdep" when a new block 350 * is allocated and pointed to by the indirect block described by the 351 * "indirdep". The worklist is linked to the buffer that holds the new block. 352 * When the block is first allocated, it is linked to the bmsafemap 353 * structure associated with the buffer holding the cylinder group map 354 * from which it was allocated. When the cylinder group map is written 355 * to disk, ai_state has the DEPCOMPLETE flag set. When the block itself 356 * is written, the COMPLETE flag is set. Once both the cylinder group map 357 * and the data itself have been written, it is safe to write the entry in 358 * the indirect block that claims the block; the "allocindir" dependency 359 * can then be freed as it is no longer applicable. 360 */ 361struct allocindir { 362 struct worklist ai_list; /* buffer holding indirect block */ 363# define ai_state ai_list.wk_state /* indirect block pointer state */ 364 LIST_ENTRY(allocindir) ai_next; /* indirdep's list of allocindir's */ 365 int ai_offset; /* pointer offset in indirect block */ 366 ufs_daddr_t ai_newblkno; /* new block pointer value */ 367 ufs_daddr_t ai_oldblkno; /* old block pointer value */ 368 struct freefrag *ai_freefrag; /* block to be freed when complete */ 369 struct indirdep *ai_indirdep; /* address of associated indirdep */ 370 LIST_ENTRY(allocindir) ai_deps; /* bmsafemap's list of allocindir's */ 371 struct buf *ai_buf; /* cylgrp buffer (if pending) */ 372}; 373 374/* 375 * A "freefrag" structure is attached to an "inodedep" when a previously 376 * allocated fragment is replaced with a larger fragment, rather than extended. 377 * The "freefrag" structure is constructed and attached when the replacement 378 * block is first allocated. It is processed after the inode claiming the 379 * bigger block that replaces it has been written to disk. Note that the 380 * ff_state field is is used to store the uid, so may lose data. However, 381 * the uid is used only in printing an error message, so is not critical. 382 * Keeping it in a short keeps the data structure down to 32 bytes. 383 */ 384struct freefrag { 385 struct worklist ff_list; /* id_inowait or delayed worklist */ 386# define ff_state ff_list.wk_state /* owning user; should be uid_t */ 387 struct vnode *ff_devvp; /* filesystem device vnode */ 388 struct mount *ff_mnt; /* associated mount point */ 389 ufs_daddr_t ff_blkno; /* fragment physical block number */ 390 long ff_fragsize; /* size of fragment being deleted */ 391 ino_t ff_inum; /* owning inode number */ 392}; 393 394/* 395 * A "freeblks" structure is attached to an "inodedep" when the 396 * corresponding file's length is reduced to zero. It records all 397 * the information needed to free the blocks of a file after its 398 * zero'ed inode has been written to disk. 399 */ 400struct freeblks { 401 struct worklist fb_list; /* id_inowait or delayed worklist */ 402 ino_t fb_previousinum; /* inode of previous owner of blocks */ 403 struct vnode *fb_devvp; /* filesystem device vnode */ 404 struct mount *fb_mnt; /* associated mount point */ 405 off_t fb_oldsize; /* previous file size */ 406 off_t fb_newsize; /* new file size */ 407 int fb_chkcnt; /* used to check cnt of blks released */ 408 uid_t fb_uid; /* uid of previous owner of blocks */ 409 ufs_daddr_t fb_dblks[NDADDR]; /* direct blk ptrs to deallocate */ 410 ufs_daddr_t fb_iblks[NIADDR]; /* indirect blk ptrs to deallocate */ 411}; 412 413/* 414 * A "freefile" structure is attached to an inode when its 415 * link count is reduced to zero. It marks the inode as free in 416 * the cylinder group map after the zero'ed inode has been written 417 * to disk and any associated blocks and fragments have been freed. 418 */ 419struct freefile { 420 struct worklist fx_list; /* id_inowait or delayed worklist */ 421 mode_t fx_mode; /* mode of inode */ 422 ino_t fx_oldinum; /* inum of the unlinked file */ 423 struct vnode *fx_devvp; /* filesystem device vnode */ 424 struct mount *fx_mnt; /* associated mount point */ 425}; 426 427/* 428 * A "diradd" structure is linked to an "inodedep" id_inowait list when a 429 * new directory entry is allocated that references the inode described 430 * by "inodedep". When the inode itself is written (either the initial 431 * allocation for new inodes or with the increased link count for 432 * existing inodes), the COMPLETE flag is set in da_state. If the entry 433 * is for a newly allocated inode, the "inodedep" structure is associated 434 * with a bmsafemap which prevents the inode from being written to disk 435 * until the cylinder group has been updated. Thus the da_state COMPLETE 436 * flag cannot be set until the inode bitmap dependency has been removed. 437 * When creating a new file, it is safe to write the directory entry that 438 * claims the inode once the referenced inode has been written. Since 439 * writing the inode clears the bitmap dependencies, the DEPCOMPLETE flag 440 * in the diradd can be set unconditionally when creating a file. When 441 * creating a directory, there are two additional dependencies described by 442 * mkdir structures (see their description below). When these dependencies 443 * are resolved the DEPCOMPLETE flag is set in the diradd structure. 444 * If there are multiple links created to the same inode, there will be 445 * a separate diradd structure created for each link. The diradd is 446 * linked onto the pg_diraddhd list of the pagedep for the directory 447 * page that contains the entry. When a directory page is written, 448 * the pg_diraddhd list is traversed to rollback any entries that are 449 * not yet ready to be written to disk. If a directory entry is being 450 * changed (by rename) rather than added, the DIRCHG flag is set and 451 * the da_previous entry points to the entry that will be "removed" 452 * once the new entry has been committed. During rollback, entries 453 * with da_previous are replaced with the previous inode number rather 454 * than zero. 455 * 456 * The overlaying of da_pagedep and da_previous is done to keep the 457 * structure down to 32 bytes in size on a 32-bit machine. If a 458 * da_previous entry is present, the pointer to its pagedep is available 459 * in the associated dirrem entry. If the DIRCHG flag is set, the 460 * da_previous entry is valid; if not set the da_pagedep entry is valid. 461 * The DIRCHG flag never changes; it is set when the structure is created 462 * if appropriate and is never cleared. 463 */ 464struct diradd { 465 struct worklist da_list; /* id_inowait or id_pendinghd list */ 466# define da_state da_list.wk_state /* state of the new directory entry */ 467 LIST_ENTRY(diradd) da_pdlist; /* pagedep holding directory block */ 468 doff_t da_offset; /* offset of new dir entry in dir blk */ 469 ino_t da_newinum; /* inode number for the new dir entry */ 470 union { 471 struct dirrem *dau_previous; /* entry being replaced in dir change */ 472 struct pagedep *dau_pagedep; /* pagedep dependency for addition */ 473 } da_un; 474}; 475#define da_previous da_un.dau_previous 476#define da_pagedep da_un.dau_pagedep 477 478/* 479 * Two "mkdir" structures are needed to track the additional dependencies 480 * associated with creating a new directory entry. Normally a directory 481 * addition can be committed as soon as the newly referenced inode has been 482 * written to disk with its increased link count. When a directory is 483 * created there are two additional dependencies: writing the directory 484 * data block containing the "." and ".." entries (MKDIR_BODY) and writing 485 * the parent inode with the increased link count for ".." (MKDIR_PARENT). 486 * These additional dependencies are tracked by two mkdir structures that 487 * reference the associated "diradd" structure. When they have completed, 488 * they set the DEPCOMPLETE flag on the diradd so that it knows that its 489 * extra dependencies have been completed. The md_state field is used only 490 * to identify which type of dependency the mkdir structure is tracking. 491 * It is not used in the mainline code for any purpose other than consistency 492 * checking. All the mkdir structures in the system are linked together on 493 * a list. This list is needed so that a diradd can find its associated 494 * mkdir structures and deallocate them if it is prematurely freed (as for 495 * example if a mkdir is immediately followed by a rmdir of the same directory). 496 * Here, the free of the diradd must traverse the list to find the associated 497 * mkdir structures that reference it. The deletion would be faster if the 498 * diradd structure were simply augmented to have two pointers that referenced 499 * the associated mkdir's. However, this would increase the size of the diradd 500 * structure from 32 to 64-bits to speed a very infrequent operation. 501 */ 502struct mkdir { 503 struct worklist md_list; /* id_inowait or buffer holding dir */ 504# define md_state md_list.wk_state /* type: MKDIR_PARENT or MKDIR_BODY */ 505 struct diradd *md_diradd; /* associated diradd */ 506 struct buf *md_buf; /* MKDIR_BODY: buffer holding dir */ 507 LIST_ENTRY(mkdir) md_mkdirs; /* list of all mkdirs */ 508}; 509LIST_HEAD(mkdirlist, mkdir) mkdirlisthd; 510 511/* 512 * A "dirrem" structure describes an operation to decrement the link 513 * count on an inode. The dirrem structure is attached to the pg_dirremhd 514 * list of the pagedep for the directory page that contains the entry. 515 * It is processed after the directory page with the deleted entry has 516 * been written to disk. 517 * 518 * The overlaying of dm_pagedep and dm_dirinum is done to keep the 519 * structure down to 32 bytes in size on a 32-bit machine. It works 520 * because they are never used concurrently. 521 */ 522struct dirrem { 523 struct worklist dm_list; /* delayed worklist */ 524# define dm_state dm_list.wk_state /* state of the old directory entry */ 525 LIST_ENTRY(dirrem) dm_next; /* pagedep's list of dirrem's */ 526 struct mount *dm_mnt; /* associated mount point */ 527 ino_t dm_oldinum; /* inum of the removed dir entry */ 528 union { 529 struct pagedep *dmu_pagedep; /* pagedep dependency for remove */ 530 ino_t dmu_dirinum; /* parent inode number (for rmdir) */ 531 } dm_un; 532}; 533#define dm_pagedep dm_un.dmu_pagedep 534#define dm_dirinum dm_un.dmu_dirinum
|