diff options
Diffstat (limited to 'sys/ufs/lfs/lfs.h')
| -rw-r--r-- | sys/ufs/lfs/lfs.h | 353 |
1 files changed, 353 insertions, 0 deletions
diff --git a/sys/ufs/lfs/lfs.h b/sys/ufs/lfs/lfs.h new file mode 100644 index 0000000..87b8c22 --- /dev/null +++ b/sys/ufs/lfs/lfs.h @@ -0,0 +1,353 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)lfs.h 8.3 (Berkeley) 9/23/93 + */ + +#define LFS_LABELPAD 8192 /* LFS label size */ +#define LFS_SBPAD 8192 /* LFS superblock size */ + +/* + * XXX + * This is a kluge and NEEDS to go away. + * + * Right now, ufs code handles most of the calls for directory operations + * such as create, mkdir, link, etc. As a result VOP_UPDATE is being + * called with waitfor set (since ffs does these things synchronously). + * Since LFS does not want to do these synchronously, we treat the last + * argument to lfs_update as a set of flags. If LFS_SYNC is set, then + * the update should be synchronous, if not, do it asynchronously. + * Unfortunately, this means that LFS won't work with NFS yet because + * NFS goes through paths that will make normal calls to ufs which will + * call lfs with a last argument of 1. + */ +#define LFS_SYNC 0x02 + +/* On-disk and in-memory checkpoint segment usage structure. */ +typedef struct segusage SEGUSE; +struct segusage { + u_long su_nbytes; /* number of live bytes */ + u_long su_lastmod; /* SEGUSE last modified timestamp */ + u_short su_nsums; /* number of summaries in segment */ + u_short su_ninos; /* number of inode blocks in seg */ +#define SEGUSE_ACTIVE 0x1 /* segment is currently being written */ +#define SEGUSE_DIRTY 0x2 /* segment has data in it */ +#define SEGUSE_SUPERBLOCK 0x4 /* segment contains a superblock */ + u_long su_flags; +}; + +#define SEGUPB(fs) (1 << (fs)->lfs_sushift) +#define SEGTABSIZE_SU(fs) \ + (((fs)->lfs_nseg + SEGUPB(fs) - 1) >> (fs)->lfs_sushift) + +/* On-disk file information. One per file with data blocks in the segment. */ +typedef struct finfo FINFO; +struct finfo { + u_long fi_nblocks; /* number of blocks */ + u_long fi_version; /* version number */ + u_long fi_ino; /* inode number */ + long fi_blocks[1]; /* array of logical block numbers */ +}; + +/* On-disk and in-memory super block. */ +struct lfs { +#define LFS_MAGIC 0x070162 + u_long lfs_magic; /* magic number */ +#define LFS_VERSION 1 + u_long lfs_version; /* version number */ + + u_long lfs_size; /* number of blocks in fs */ + u_long lfs_ssize; /* number of blocks per segment */ + u_long lfs_dsize; /* number of disk blocks in fs */ + u_long lfs_bsize; /* file system block size */ + u_long lfs_fsize; /* size of frag blocks in fs */ + u_long lfs_frag; /* number of frags in a block in fs */ + +/* Checkpoint region. */ + ino_t lfs_free; /* start of the free list */ + u_long lfs_bfree; /* number of free disk blocks */ + u_long lfs_nfiles; /* number of allocated inodes */ + long lfs_avail; /* blocks available for writing */ + u_long lfs_uinodes; /* inodes in cache not yet on disk */ + daddr_t lfs_idaddr; /* inode file disk address */ + ino_t lfs_ifile; /* inode file inode number */ + daddr_t lfs_lastseg; /* address of last segment written */ + daddr_t lfs_nextseg; /* address of next segment to write */ + daddr_t lfs_curseg; /* current segment being written */ + daddr_t lfs_offset; /* offset in curseg for next partial */ + daddr_t lfs_lastpseg; /* address of last partial written */ + u_long lfs_tstamp; /* time stamp */ + +/* These are configuration parameters. */ + u_long lfs_minfree; /* minimum percentage of free blocks */ + +/* These fields can be computed from the others. */ + u_quad_t lfs_maxfilesize; /* maximum representable file size */ + u_long lfs_dbpseg; /* disk blocks per segment */ + u_long lfs_inopb; /* inodes per block */ + u_long lfs_ifpb; /* IFILE entries per block */ + u_long lfs_sepb; /* SEGUSE entries per block */ + u_long lfs_nindir; /* indirect pointers per block */ + u_long lfs_nseg; /* number of segments */ + u_long lfs_nspf; /* number of sectors per fragment */ + u_long lfs_cleansz; /* cleaner info size in blocks */ + u_long lfs_segtabsz; /* segment table size in blocks */ + + u_long lfs_segmask; /* calculate offset within a segment */ + u_long lfs_segshift; /* fast mult/div for segments */ + u_long lfs_bmask; /* calc block offset from file offset */ + u_long lfs_bshift; /* calc block number from file offset */ + u_long lfs_ffmask; /* calc frag offset from file offset */ + u_long lfs_ffshift; /* fast mult/div for frag from file */ + u_long lfs_fbmask; /* calc frag offset from block offset */ + u_long lfs_fbshift; /* fast mult/div for frag from block */ + u_long lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ + u_long lfs_sushift; /* fast mult/div for segusage table */ + +#define LFS_MIN_SBINTERVAL 5 /* minimum superblock segment spacing */ +#define LFS_MAXNUMSB 10 /* superblock disk offsets */ + daddr_t lfs_sboffs[LFS_MAXNUMSB]; + +/* These fields are set at mount time and are meaningless on disk. */ + struct segment *lfs_sp; /* current segment being written */ + struct vnode *lfs_ivnode; /* vnode for the ifile */ + u_long lfs_seglock; /* single-thread the segment writer */ + pid_t lfs_lockpid; /* pid of lock holder */ + u_long lfs_iocount; /* number of ios pending */ + u_long lfs_writer; /* don't allow any dirops to start */ + u_long lfs_dirops; /* count of active directory ops */ + u_long lfs_doifile; /* Write ifile blocks on next write */ + u_long lfs_nactive; /* Number of segments since last ckp */ + u_char lfs_fmod; /* super block modified flag */ + u_char lfs_clean; /* file system is clean flag */ + u_char lfs_ronly; /* mounted read-only flag */ + u_char lfs_flags; /* currently unused flag */ + u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ + u_char pad[3]; /* long-align */ + +/* Checksum; valid on disk. */ + u_long lfs_cksum; /* checksum for superblock checking */ +}; + +/* + * Inode 0 is the out-of-band inode number, inode 1 is the inode number for + * the IFILE, the root inode is 2 and the lost+found inode is 3. + */ + +/* Fixed inode numbers. */ +#define LFS_UNUSED_INUM 0 /* out of band inode number */ +#define LFS_IFILE_INUM 1 /* IFILE inode number */ +#define LOSTFOUNDINO 3 /* lost+found inode number */ +#define LFS_FIRST_INUM 4 /* first free inode number */ + +/* Address calculations for metadata located in the inode */ +#define S_INDIR(fs) -NDADDR +#define D_INDIR(fs) (S_INDIR(fs) - NINDIR(fs) - 1) +#define T_INDIR(fs) (D_INDIR(fs) - NINDIR(fs) * NINDIR(fs) - 1) + +/* Unassigned disk address. */ +#define UNASSIGNED -1 + +/* Unused logical block number */ +#define LFS_UNUSED_LBN -1 + +typedef struct ifile IFILE; +struct ifile { + u_long if_version; /* inode version number */ +#define LFS_UNUSED_DADDR 0 /* out-of-band daddr */ + daddr_t if_daddr; /* inode disk address */ + ino_t if_nextfree; /* next-unallocated inode */ +}; + +/* + * Cleaner information structure. This resides in the ifile and is used + * to pass information between the cleaner and the kernel. + */ +typedef struct _cleanerinfo { + u_long clean; /* K: number of clean segments */ + u_long dirty; /* K: number of dirty segments */ +} CLEANERINFO; + +#define CLEANSIZE_SU(fs) \ + ((sizeof(CLEANERINFO) + (fs)->lfs_bsize - 1) >> (fs)->lfs_bshift) + +/* + * All summary blocks are the same size, so we can always read a summary + * block easily from a segment. + */ +#define LFS_SUMMARY_SIZE 512 + +/* On-disk segment summary information */ +typedef struct segsum SEGSUM; +struct segsum { + u_long ss_sumsum; /* check sum of summary block */ + u_long ss_datasum; /* check sum of data */ + daddr_t ss_next; /* next segment */ + u_long ss_create; /* creation time stamp */ + u_short ss_nfinfo; /* number of file info structures */ + u_short ss_ninos; /* number of inodes in summary */ +#define SS_DIROP 0x01 /* segment begins a dirop */ +#define SS_CONT 0x02 /* more partials to finish this write*/ + u_short ss_flags; /* used for directory operations */ + u_short ss_pad; /* extra space */ + /* FINFO's and inode daddr's... */ +}; + +/* NINDIR is the number of indirects in a file system block. */ +#define NINDIR(fs) ((fs)->lfs_nindir) + +/* INOPB is the number of inodes in a secondary storage block. */ +#define INOPB(fs) ((fs)->lfs_inopb) + +#define blksize(fs) ((fs)->lfs_bsize) +#define blkoff(fs, loc) ((loc) & (fs)->lfs_bmask) +#define fsbtodb(fs, b) ((b) << (fs)->lfs_fsbtodb) +#define dbtofsb(fs, b) ((b) >> (fs)->lfs_fsbtodb) +#define lblkno(fs, loc) ((loc) >> (fs)->lfs_bshift) +#define lblktosize(fs, blk) ((blk) << (fs)->lfs_bshift) +#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \ + ((loc) >> (fs)->lfs_bshift) + +#define datosn(fs, daddr) /* disk address to segment number */ \ + (((daddr) - (fs)->lfs_sboffs[0]) / fsbtodb((fs), (fs)->lfs_ssize)) +#define sntoda(fs, sn) /* segment number to disk address */ \ + ((daddr_t)((sn) * ((fs)->lfs_ssize << (fs)->lfs_fsbtodb) + \ + (fs)->lfs_sboffs[0])) + +/* Read in the block with the cleaner info from the ifile. */ +#define LFS_CLEANERINFO(CP, F, BP) { \ + VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ + if (bread((F)->lfs_ivnode, \ + (daddr_t)0, (F)->lfs_bsize, NOCRED, &(BP))) \ + panic("lfs: ifile read"); \ + (CP) = (CLEANERINFO *)(BP)->b_data; \ +} + +/* Read in the block with a specific inode from the ifile. */ +#define LFS_IENTRY(IP, F, IN, BP) { \ + int _e; \ + VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ + if (_e = bread((F)->lfs_ivnode, \ + (IN) / (F)->lfs_ifpb + (F)->lfs_cleansz + (F)->lfs_segtabsz,\ + (F)->lfs_bsize, NOCRED, &(BP))) \ + panic("lfs: ifile read %d", _e); \ + (IP) = (IFILE *)(BP)->b_data + (IN) % (F)->lfs_ifpb; \ +} + +/* Read in the block with a specific segment usage entry from the ifile. */ +#define LFS_SEGENTRY(SP, F, IN, BP) { \ + int _e; \ + VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ + if (_e = bread((F)->lfs_ivnode, \ + ((IN) >> (F)->lfs_sushift) + (F)->lfs_cleansz, \ + (F)->lfs_bsize, NOCRED, &(BP))) \ + panic("lfs: ifile read: %d", _e); \ + (SP) = (SEGUSE *)(BP)->b_data + ((IN) & (F)->lfs_sepb - 1); \ +} + +/* + * Determine if there is enough room currently available to write db + * disk blocks. We need enough blocks for the new blocks, the current, + * inode blocks, a summary block, plus potentially the ifile inode and + * the segment usage table, plus an ifile page. + */ +#define LFS_FITS(fs, db) \ + ((long)((db + ((fs)->lfs_uinodes + INOPB((fs))) / INOPB((fs)) + \ + fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ + (fs)->lfs_segtabsz)) < (fs)->lfs_avail) + +/* Determine if a buffer belongs to the ifile */ +#define IS_IFILE(bp) (VTOI(bp->b_vp)->i_number == LFS_IFILE_INUM) + +/* + * Structures used by lfs_bmapv and lfs_markv to communicate information + * about inodes and data blocks. + */ +typedef struct block_info { + ino_t bi_inode; /* inode # */ + daddr_t bi_lbn; /* logical block w/in file */ + daddr_t bi_daddr; /* disk address of block */ + time_t bi_segcreate; /* origin segment create time */ + int bi_version; /* file version number */ + void *bi_bp; /* data buffer */ +} BLOCK_INFO; + +/* In-memory description of a segment about to be written. */ +struct segment { + struct lfs *fs; /* file system pointer */ + struct buf **bpp; /* pointer to buffer array */ + struct buf **cbpp; /* pointer to next available bp */ + struct buf **start_bpp; /* pointer to first bp in this set */ + struct buf *ibp; /* buffer pointer to inode page */ + struct finfo *fip; /* current fileinfo pointer */ + struct vnode *vp; /* vnode being gathered */ + void *segsum; /* segment summary info */ + u_long ninodes; /* number of inodes in this segment */ + u_long seg_bytes_left; /* bytes left in segment */ + u_long sum_bytes_left; /* bytes left in summary block */ + u_long seg_number; /* number of this segment */ + daddr_t *start_lbp; /* beginning lbn for this set */ +#define SEGM_CKP 0x01 /* doing a checkpoint */ +#define SEGM_CLEAN 0x02 /* cleaner call; don't sort */ +#define SEGM_SYNC 0x04 /* wait for segment */ + u_long seg_flags; /* run-time flags for this segment */ +}; + +#define ISSPACE(F, BB, C) \ + (((C)->cr_uid == 0 && (F)->lfs_bfree >= (BB)) || \ + ((C)->cr_uid != 0 && IS_FREESPACE(F, BB))) + +#define IS_FREESPACE(F, BB) \ + ((F)->lfs_bfree > ((F)->lfs_dsize * (F)->lfs_minfree / 100 + (BB))) + +#define ISSPACE_XXX(F, BB) \ + ((F)->lfs_bfree >= (BB)) + +#define DOSTATS +#ifdef DOSTATS +/* Statistics Counters */ +struct lfs_stats { + int segsused; + int psegwrites; + int psyncwrites; + int pcleanwrites; + int blocktot; + int cleanblocks; + int ncheckpoints; + int nwrites; + int nsync_writes; + int wait_exceeded; + int write_exceeded; + int flush_invoked; +}; +extern struct lfs_stats lfs_stats; +#endif |
