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