From b4d210b85cee9665fda000d597907a8637a86961 Mon Sep 17 00:00:00 2001 From: pfg Date: Wed, 5 Mar 2014 04:23:19 +0000 Subject: MFC r262678; ufs: small formatting fixes. Cleanup some extra space. Use of tabs vs. spaces. No functional change. Reviewed by: mckusick --- sys/ufs/ffs/ffs_alloc.c | 4 +- sys/ufs/ffs/ffs_balloc.c | 4 +- sys/ufs/ffs/ffs_extern.h | 8 +-- sys/ufs/ffs/ffs_snapshot.c | 2 +- sys/ufs/ffs/ffs_softdep.c | 26 +++++----- sys/ufs/ffs/ffs_vfsops.c | 2 +- sys/ufs/ffs/ffs_vnops.c | 6 +-- sys/ufs/ffs/fs.h | 118 ++++++++++++++++++++++----------------------- sys/ufs/ffs/softdep.h | 100 +++++++++++++++++++------------------- 9 files changed, 135 insertions(+), 135 deletions(-) (limited to 'sys/ufs/ffs') diff --git a/sys/ufs/ffs/ffs_alloc.c b/sys/ufs/ffs/ffs_alloc.c index 76ead41..4890bd0 100644 --- a/sys/ufs/ffs/ffs_alloc.c +++ b/sys/ufs/ffs/ffs_alloc.c @@ -1182,14 +1182,14 @@ ffs_dirpref(pip) for (cg = prefcg; cg < fs->fs_ncg; cg++) if (fs->fs_cs(fs, cg).cs_ndir < maxndir && fs->fs_cs(fs, cg).cs_nifree >= minifree && - fs->fs_cs(fs, cg).cs_nbfree >= minbfree) { + fs->fs_cs(fs, cg).cs_nbfree >= minbfree) { if (fs->fs_contigdirs[cg] < maxcontigdirs) return ((ino_t)(fs->fs_ipg * cg)); } for (cg = 0; cg < prefcg; cg++) if (fs->fs_cs(fs, cg).cs_ndir < maxndir && fs->fs_cs(fs, cg).cs_nifree >= minifree && - fs->fs_cs(fs, cg).cs_nbfree >= minbfree) { + fs->fs_cs(fs, cg).cs_nbfree >= minbfree) { if (fs->fs_contigdirs[cg] < maxcontigdirs) return ((ino_t)(fs->fs_ipg * cg)); } diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c index 1b830ae..9c33a7f 100644 --- a/sys/ufs/ffs/ffs_balloc.c +++ b/sys/ufs/ffs/ffs_balloc.c @@ -248,7 +248,7 @@ ffs_balloc_ufs1(struct vnode *vp, off_t startoffset, int size, UFS_LOCK(ump); pref = ffs_blkpref_ufs1(ip, lbn, -indirs[0].in_off - 1, (ufs1_daddr_t *)0); - if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, + if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags, cred, &newb)) != 0) { curthread_pflags_restore(saved_inbdflush); return (error); @@ -809,7 +809,7 @@ ffs_balloc_ufs2(struct vnode *vp, off_t startoffset, int size, UFS_LOCK(ump); pref = ffs_blkpref_ufs2(ip, lbn, -indirs[0].in_off - 1, (ufs2_daddr_t *)0); - if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, + if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, flags, cred, &newb)) != 0) { curthread_pflags_restore(saved_inbdflush); return (error); diff --git a/sys/ufs/ffs/ffs_extern.h b/sys/ufs/ffs/ffs_extern.h index a50a88a..c29e5d5 100644 --- a/sys/ufs/ffs/ffs_extern.h +++ b/sys/ufs/ffs/ffs_extern.h @@ -165,10 +165,10 @@ void softdep_freework(struct workhead *); /* * Things to request flushing in softdep_request_cleanup() */ -#define FLUSH_INODES 1 -#define FLUSH_INODES_WAIT 2 -#define FLUSH_BLOCKS 3 -#define FLUSH_BLOCKS_WAIT 4 +#define FLUSH_INODES 1 +#define FLUSH_INODES_WAIT 2 +#define FLUSH_BLOCKS 3 +#define FLUSH_BLOCKS_WAIT 4 /* * Flag to ffs_syncvnode() to request flushing of data only, * but skip the ffs_update() on the inode itself. Used to avoid diff --git a/sys/ufs/ffs/ffs_snapshot.c b/sys/ufs/ffs/ffs_snapshot.c index c37706b..3df8932 100644 --- a/sys/ufs/ffs/ffs_snapshot.c +++ b/sys/ufs/ffs/ffs_snapshot.c @@ -2642,7 +2642,7 @@ ffs_snapdata_acquire(struct vnode *devvp) struct snapdata *sn; /* - * Allocate a free snapdata. This is done before acquiring the + * Allocate a free snapdata. This is done before acquiring the * devvp lock to avoid allocation while the devvp interlock is * held. */ diff --git a/sys/ufs/ffs/ffs_softdep.c b/sys/ufs/ffs/ffs_softdep.c index 827cc72..d65554b 100644 --- a/sys/ufs/ffs/ffs_softdep.c +++ b/sys/ufs/ffs/ffs_softdep.c @@ -119,7 +119,7 @@ softdep_mount(devvp, mp, fs, cred) return (0); } -void +void softdep_initialize() { @@ -174,7 +174,7 @@ softdep_setup_blkmapdep(bp, mp, newblkno, frags, oldfrags) panic("softdep_setup_blkmapdep called"); } -void +void softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp) struct inode *ip; ufs_lbn_t lbn; @@ -188,7 +188,7 @@ softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp) panic("softdep_setup_allocdirect called"); } -void +void softdep_setup_allocext(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp) struct inode *ip; ufs_lbn_t lbn; @@ -267,7 +267,7 @@ softdep_freefile(pvp, ino, mode) panic("softdep_freefile called"); } -int +int softdep_setup_directory_add(bp, dp, diroffset, newinum, newdirbp, isnewblk) struct buf *bp; struct inode *dp; @@ -280,7 +280,7 @@ softdep_setup_directory_add(bp, dp, diroffset, newinum, newdirbp, isnewblk) panic("softdep_setup_directory_add called"); } -void +void softdep_change_directoryentry_offset(bp, dp, base, oldloc, newloc, entrysize) struct buf *bp; struct inode *dp; @@ -293,7 +293,7 @@ softdep_change_directoryentry_offset(bp, dp, base, oldloc, newloc, entrysize) panic("softdep_change_directoryentry_offset called"); } -void +void softdep_setup_remove(bp, dp, ip, isrmdir) struct buf *bp; struct inode *dp; @@ -304,7 +304,7 @@ softdep_setup_remove(bp, dp, ip, isrmdir) panic("softdep_setup_remove called"); } -void +void softdep_setup_directory_change(bp, dp, ip, newinum, isrmdir) struct buf *bp; struct inode *dp; @@ -463,7 +463,7 @@ softdep_load_inodeblock(ip) panic("softdep_load_inodeblock called"); } -void +void softdep_update_inodeblock(ip, bp, waitfor) struct inode *ip; struct buf *bp; @@ -753,7 +753,7 @@ static int sync_cgs(struct mount *, int); static int handle_written_filepage(struct pagedep *, struct buf *); static int handle_written_sbdep(struct sbdep *, struct buf *); static void initiate_write_sbdep(struct sbdep *); -static void diradd_inode_written(struct diradd *, struct inodedep *); +static void diradd_inode_written(struct diradd *, struct inodedep *); static int handle_written_indirdep(struct indirdep *, struct buf *, struct buf**); static int handle_written_inodeblock(struct inodedep *, struct buf *); @@ -3246,7 +3246,7 @@ softdep_process_journal(mp, needwk, flags) cnt++; /* * Verify some free journal space. softdep_prealloc() should - * guarantee that we don't run out so this is indicative of + * guarantee that we don't run out so this is indicative of * a problem with the flow control. Try to recover * gracefully in any event. */ @@ -10488,7 +10488,7 @@ softdep_setup_inofree(mp, bp, ino, wkhd) * We can free immediately even if the jaddref * isn't attached in a background write as now * the bitmaps are reconciled. - */ + */ wk->wk_state |= COMPLETE | ATTACHED; free_jaddref(WK_JADDREF(wk)); } @@ -10662,7 +10662,7 @@ jnewblk_rollback(jnewblk, fs, cgp, blksfree) /* Add back in counts associated with the new frags */ blk = blkmap(fs, blksfree, bbase); ffs_fragacct(fs, blk, cgp->cg_frsum, 1); - /* If a complete block has been reassembled, account for it. */ + /* If a complete block has been reassembled, account for it. */ fragno = fragstoblks(fs, bbase); if (ffs_isblock(fs, blksfree, fragno)) { cgp->cg_cs.cs_nffree -= fs->fs_frag; @@ -10677,7 +10677,7 @@ jnewblk_rollback(jnewblk, fs, cgp, blksfree) return (frags); } -static void +static void initiate_write_bmsafemap(bmsafemap, bp) struct bmsafemap *bmsafemap; struct buf *bp; /* The cg block. */ diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c index 079e684..3cc2a6d 100644 --- a/sys/ufs/ffs/ffs_vfsops.c +++ b/sys/ufs/ffs/ffs_vfsops.c @@ -1677,7 +1677,7 @@ ffs_vgetf(mp, ino, flags, vpp, ffs_flags) /* * We must promote to an exclusive lock for vnode creation. This * can happen if lookup is passed LOCKSHARED. - */ + */ if ((flags & LK_TYPE_MASK) == LK_SHARED) { flags &= ~LK_TYPE_MASK; flags |= LK_EXCLUSIVE; diff --git a/sys/ufs/ffs/ffs_vnops.c b/sys/ufs/ffs/ffs_vnops.c index 792d253..a498587 100644 --- a/sys/ufs/ffs/ffs_vnops.c +++ b/sys/ufs/ffs/ffs_vnops.c @@ -720,10 +720,10 @@ ffs_write(ap) if (uio->uio_offset + xfersize > ip->i_size) vnode_pager_setsize(vp, uio->uio_offset + xfersize); - /* + /* * We must perform a read-before-write if the transfer size * does not cover the entire buffer. - */ + */ if (fs->fs_bsize > xfersize) flags |= BA_CLRBUF; else @@ -1082,7 +1082,7 @@ ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *ucred) /* * We must perform a read-before-write if the transfer size * does not cover the entire buffer. - */ + */ if (fs->fs_bsize > xfersize) flags |= BA_CLRBUF; else diff --git a/sys/ufs/ffs/fs.h b/sys/ufs/ffs/fs.h index b154a80..835a8f9 100644 --- a/sys/ufs/ffs/fs.h +++ b/sys/ufs/ffs/fs.h @@ -31,7 +31,7 @@ */ #ifndef _UFS_FFS_FS_H_ -#define _UFS_FFS_FS_H_ +#define _UFS_FFS_FS_H_ #include #include @@ -68,18 +68,18 @@ * given in byte-offset form, so they do not imply a sector size. The * SBLOCKSEARCH specifies the order in which the locations should be searched. */ -#define SBLOCK_FLOPPY 0 -#define SBLOCK_UFS1 8192 -#define SBLOCK_UFS2 65536 -#define SBLOCK_PIGGY 262144 -#define SBLOCKSIZE 8192 -#define SBLOCKSEARCH \ +#define SBLOCK_FLOPPY 0 +#define SBLOCK_UFS1 8192 +#define SBLOCK_UFS2 65536 +#define SBLOCK_PIGGY 262144 +#define SBLOCKSIZE 8192 +#define SBLOCKSEARCH \ { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 } /* * Max number of fragments per block. This value is NOT tweakable. */ -#define MAXFRAG 8 +#define MAXFRAG 8 /* * Addresses stored in inodes are capable of addressing fragments @@ -109,20 +109,20 @@ * Note that super blocks are always of size SBLOCKSIZE, * and that both SBLOCKSIZE and MAXBSIZE must be >= MINBSIZE. */ -#define MINBSIZE 4096 +#define MINBSIZE 4096 /* * The path name on which the filesystem is mounted is maintained * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in * the super block for this name. */ -#define MAXMNTLEN 468 +#define MAXMNTLEN 468 /* * The volume name for this filesystem is maintained in fs_volname. * MAXVOLLEN defines the length of the buffer allocated. */ -#define MAXVOLLEN 32 +#define MAXVOLLEN 32 /* * There is a 128-byte region in the superblock reserved for in-core @@ -147,7 +147,7 @@ * value of fs_maxcontig. To conserve space, a maximum summary size * is set by FS_MAXCONTIG. */ -#define FS_MAXCONTIG 16 +#define FS_MAXCONTIG 16 /* * MINFREE gives the minimum acceptable percentage of filesystem @@ -161,8 +161,8 @@ * default value. With 10% free space, fragmentation is not a * problem, so we choose to optimize for time. */ -#define MINFREE 8 -#define DEFAULTOPT FS_OPTTIME +#define MINFREE 8 +#define DEFAULTOPT FS_OPTTIME /* * Grigoriy Orlov has done some extensive work to fine @@ -173,8 +173,8 @@ * filesystems, but may need to be tuned for odd cases like filesystems * being used for squid caches or news spools. */ -#define AVFILESIZ 16384 /* expected average file size */ -#define AFPDIR 64 /* expected number of files per directory */ +#define AVFILESIZ 16384 /* expected average file size */ +#define AFPDIR 64 /* expected number of files per directory */ /* * The maximum number of snapshot nodes that can be associated @@ -184,7 +184,7 @@ * maintaining too many will slow the filesystem performance, so * having this limit is a good idea. */ -#define FSMAXSNAP 20 +#define FSMAXSNAP 20 /* * Used to identify special blocks in snapshots: @@ -197,8 +197,8 @@ * identify blocks that are in use by other snapshots (which are * expunged from this snapshot). */ -#define BLK_NOCOPY ((ufs2_daddr_t)(1)) -#define BLK_SNAP ((ufs2_daddr_t)(2)) +#define BLK_NOCOPY ((ufs2_daddr_t)(1)) +#define BLK_SNAP ((ufs2_daddr_t)(2)) /* * Sysctl values for the fast filesystem. @@ -214,7 +214,7 @@ #define FFS_ADJ_NIFREE 9 /* adjust number of free inodes */ #define FFS_ADJ_NFFREE 10 /* adjust number of free frags */ #define FFS_ADJ_NUMCLUSTERS 11 /* adjust number of free clusters */ -#define FFS_SET_CWD 12 /* set current directory */ +#define FFS_SET_CWD 12 /* set current directory */ #define FFS_SET_DOTDOT 13 /* set inode number for ".." */ #define FFS_UNLINK 14 /* remove a name in the filesystem */ #define FFS_SET_INODE 15 /* update an on-disk inode */ @@ -377,14 +377,14 @@ CTASSERT(sizeof(struct fs) == 1376); #define FS_UFS2_MAGIC 0x19540119 /* UFS2 fast filesystem magic number */ #define FS_BAD_MAGIC 0x19960408 /* UFS incomplete newfs magic number */ #define FS_OKAY 0x7c269d38 /* superblock checksum */ -#define FS_42INODEFMT -1 /* 4.2BSD inode format */ -#define FS_44INODEFMT 2 /* 4.4BSD inode format */ +#define FS_42INODEFMT -1 /* 4.2BSD inode format */ +#define FS_44INODEFMT 2 /* 4.4BSD inode format */ /* * Preference for optimization. */ -#define FS_OPTTIME 0 /* minimize allocation time */ -#define FS_OPTSPACE 1 /* minimize disk fragmentation */ +#define FS_OPTTIME 0 /* minimize allocation time */ +#define FS_OPTSPACE 1 /* minimize disk fragmentation */ /* * Filesystem flags. @@ -414,16 +414,16 @@ CTASSERT(sizeof(struct fs) == 1376); * labels into extended attributes on the file system rather than maintain * a single mount label for all objects. */ -#define FS_UNCLEAN 0x0001 /* filesystem not clean at mount */ -#define FS_DOSOFTDEP 0x0002 /* filesystem using soft dependencies */ -#define FS_NEEDSFSCK 0x0004 /* filesystem needs sync fsck before mount */ +#define FS_UNCLEAN 0x0001 /* filesystem not clean at mount */ +#define FS_DOSOFTDEP 0x0002 /* filesystem using soft dependencies */ +#define FS_NEEDSFSCK 0x0004 /* filesystem needs sync fsck before mount */ #define FS_SUJ 0x0008 /* Filesystem using softupdate journal */ -#define FS_ACLS 0x0010 /* file system has POSIX.1e ACLs enabled */ -#define FS_MULTILABEL 0x0020 /* file system is MAC multi-label */ -#define FS_GJOURNAL 0x0040 /* gjournaled file system */ -#define FS_FLAGS_UPDATED 0x0080 /* flags have been moved to new location */ -#define FS_NFS4ACLS 0x0100 /* file system has NFSv4 ACLs enabled */ -#define FS_INDEXDIRS 0x0200 /* kernel supports indexed directories */ +#define FS_ACLS 0x0010 /* file system has POSIX.1e ACLs enabled */ +#define FS_MULTILABEL 0x0020 /* file system is MAC multi-label */ +#define FS_GJOURNAL 0x0040 /* gjournaled file system */ +#define FS_FLAGS_UPDATED 0x0080 /* flags have been moved to new location */ +#define FS_NFS4ACLS 0x0100 /* file system has NFSv4 ACLs enabled */ +#define FS_INDEXDIRS 0x0200 /* kernel supports indexed directories */ #define FS_TRIM 0x0400 /* issue BIO_DELETE for deleted blocks */ /* @@ -446,7 +446,7 @@ CTASSERT(sizeof(struct fs) == 1376); * Its size is derived from the size of the maps maintained in the * cylinder group and the (struct cg) size. */ -#define CGSIZE(fs) \ +#define CGSIZE(fs) \ /* base cg */ (sizeof(struct cg) + sizeof(int32_t) + \ /* old btotoff */ (fs)->fs_old_cpg * sizeof(int32_t) + \ /* old boff */ (fs)->fs_old_cpg * sizeof(u_int16_t) + \ @@ -459,12 +459,12 @@ CTASSERT(sizeof(struct fs) == 1376); /* * The minimal number of cylinder groups that should be created. */ -#define MINCYLGRPS 4 +#define MINCYLGRPS 4 /* * Convert cylinder group to base address of its global summary info. */ -#define fs_cs(fs, indx) fs_csp[indx] +#define fs_cs(fs, indx) fs_csp[indx] /* * Cylinder group block for a filesystem. @@ -504,14 +504,14 @@ struct cg { /* * Macros for access to cylinder group array structures */ -#define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC) -#define cg_inosused(cgp) \ +#define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC) +#define cg_inosused(cgp) \ ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff)) -#define cg_blksfree(cgp) \ +#define cg_blksfree(cgp) \ ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff)) -#define cg_clustersfree(cgp) \ +#define cg_clustersfree(cgp) \ ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_clusteroff)) -#define cg_clustersum(cgp) \ +#define cg_clustersum(cgp) \ ((int32_t *)((uintptr_t)(cgp) + (cgp)->cg_clustersumoff)) /* @@ -532,7 +532,7 @@ struct cg { #define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */ #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */ #define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */ -#define cgstart(fs, c) \ +#define cgstart(fs, c) \ ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) : \ (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask)))) @@ -559,7 +559,7 @@ struct cg { * Extract the bits for a block from a map. * Compute the cylinder and rotational position of a cyl block addr. */ -#define blkmap(fs, map, loc) \ +#define blkmap(fs, map, loc) \ (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag))) /* @@ -567,39 +567,39 @@ struct cg { * quantities by using shifts and masks in place of divisions * modulos and multiplications. */ -#define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \ +#define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \ ((loc) & (fs)->fs_qbmask) -#define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \ +#define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \ ((loc) & (fs)->fs_qfmask) -#define lfragtosize(fs, frag) /* calculates ((off_t)frag * fs->fs_fsize) */ \ +#define lfragtosize(fs, frag) /* calculates ((off_t)frag * fs->fs_fsize) */ \ (((off_t)(frag)) << (fs)->fs_fshift) -#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \ +#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \ (((off_t)(blk)) << (fs)->fs_bshift) /* Use this only when `blk' is known to be small, e.g., < NDADDR. */ -#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \ +#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \ ((blk) << (fs)->fs_bshift) -#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \ +#define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \ ((loc) >> (fs)->fs_bshift) -#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \ +#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \ ((loc) >> (fs)->fs_fshift) -#define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \ +#define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \ (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask) -#define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \ +#define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \ (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask) -#define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \ +#define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \ ((frags) >> (fs)->fs_fragshift) -#define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \ +#define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \ ((blks) << (fs)->fs_fragshift) -#define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \ +#define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \ ((fsb) & ((fs)->fs_frag - 1)) -#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \ +#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \ ((fsb) &~ ((fs)->fs_frag - 1)) /* * Determine the number of available frags given a * percentage to hold in reserve. */ -#define freespace(fs, percentreserved) \ +#define freespace(fs, percentreserved) \ (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \ (fs)->fs_cstotal.cs_nffree - \ (((off_t)((fs)->fs_dsize)) * (percentreserved) / 100)) @@ -607,11 +607,11 @@ struct cg { /* * Determining the size of a file block in the filesystem. */ -#define blksize(fs, ip, lbn) \ +#define blksize(fs, ip, lbn) \ (((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \ ? (fs)->fs_bsize \ : (fragroundup(fs, blkoff(fs, (ip)->i_size)))) -#define sblksize(fs, size, lbn) \ +#define sblksize(fs, size, lbn) \ (((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \ ? (fs)->fs_bsize \ : (fragroundup(fs, blkoff(fs, (size))))) diff --git a/sys/ufs/ffs/softdep.h b/sys/ufs/ffs/softdep.h index 8a8a63a..cfd9b77 100644 --- a/sys/ufs/ffs/softdep.h +++ b/sys/ufs/ffs/softdep.h @@ -203,22 +203,22 @@ struct worklist { unsigned int wk_type:8, /* type of request */ wk_state:24; /* state flags */ }; -#define WK_DATA(wk) ((void *)(wk)) -#define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) -#define WK_INODEDEP(wk) ((struct inodedep *)(wk)) -#define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) +#define WK_DATA(wk) ((void *)(wk)) +#define WK_PAGEDEP(wk) ((struct pagedep *)(wk)) +#define WK_INODEDEP(wk) ((struct inodedep *)(wk)) +#define WK_BMSAFEMAP(wk) ((struct bmsafemap *)(wk)) #define WK_NEWBLK(wk) ((struct newblk *)(wk)) -#define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) -#define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) -#define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) -#define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) -#define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) -#define WK_FREEWORK(wk) ((struct freework *)(wk)) -#define WK_FREEFILE(wk) ((struct freefile *)(wk)) -#define WK_DIRADD(wk) ((struct diradd *)(wk)) -#define WK_MKDIR(wk) ((struct mkdir *)(wk)) -#define WK_DIRREM(wk) ((struct dirrem *)(wk)) -#define WK_NEWDIRBLK(wk) ((struct newdirblk *)(wk)) +#define WK_ALLOCDIRECT(wk) ((struct allocdirect *)(wk)) +#define WK_INDIRDEP(wk) ((struct indirdep *)(wk)) +#define WK_ALLOCINDIR(wk) ((struct allocindir *)(wk)) +#define WK_FREEFRAG(wk) ((struct freefrag *)(wk)) +#define WK_FREEBLKS(wk) ((struct freeblks *)(wk)) +#define WK_FREEWORK(wk) ((struct freework *)(wk)) +#define WK_FREEFILE(wk) ((struct freefile *)(wk)) +#define WK_DIRADD(wk) ((struct diradd *)(wk)) +#define WK_MKDIR(wk) ((struct mkdir *)(wk)) +#define WK_DIRREM(wk) ((struct dirrem *)(wk)) +#define WK_NEWDIRBLK(wk) ((struct newdirblk *)(wk)) #define WK_JADDREF(wk) ((struct jaddref *)(wk)) #define WK_JREMREF(wk) ((struct jremref *)(wk)) #define WK_JMVREF(wk) ((struct jmvref *)(wk)) @@ -272,8 +272,8 @@ TAILQ_HEAD(freeblklst, freeblks); * list, any removed operations are done, and the dependency structure * is freed. */ -#define DAHASHSZ 5 -#define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) +#define DAHASHSZ 5 +#define DIRADDHASH(offset) (((offset) >> 2) % DAHASHSZ) struct pagedep { struct worklist pd_list; /* page buffer */ # define pd_state pd_list.wk_state /* check for multiple I/O starts */ @@ -363,8 +363,8 @@ struct inodedep { struct ufs2_dinode *idu_savedino2; /* saved ufs2_dinode contents */ } id_un; }; -#define id_savedino1 id_un.idu_savedino1 -#define id_savedino2 id_un.idu_savedino2 +#define id_savedino1 id_un.idu_savedino1 +#define id_savedino2 id_un.idu_savedino2 /* * A "bmsafemap" structure maintains a list of dependency structures @@ -678,8 +678,8 @@ struct diradd { } da_un; struct workhead da_jwork; /* Journal work awaiting completion. */ }; -#define da_previous da_un.dau_previous -#define da_pagedep da_un.dau_pagedep +#define da_previous da_un.dau_previous +#define da_pagedep da_un.dau_pagedep /* * Two "mkdir" structures are needed to track the additional dependencies @@ -735,8 +735,8 @@ struct dirrem { } dm_un; struct workhead dm_jwork; /* Journal work awaiting completion. */ }; -#define dm_pagedep dm_un.dmu_pagedep -#define dm_dirinum dm_un.dmu_dirinum +#define dm_pagedep dm_un.dmu_pagedep +#define dm_dirinum dm_un.dmu_dirinum /* * A "newdirblk" structure tracks the progress of a newly allocated @@ -1057,30 +1057,30 @@ struct mount_softdeps { /* * Keep the old names from when these were in the ufsmount structure. */ -#define softdep_workitem_pending um_softdep->sd_workitem_pending -#define softdep_worklist_tail um_softdep->sd_worklist_tail -#define softdep_journal_pending um_softdep->sd_journal_pending -#define softdep_journal_tail um_softdep->sd_journal_tail -#define softdep_jblocks um_softdep->sd_jblocks -#define softdep_unlinked um_softdep->sd_unlinked -#define softdep_dirtycg um_softdep->sd_dirtycg -#define softdep_mkdirlisthd um_softdep->sd_mkdirlisthd -#define pagedep_hashtbl um_softdep->sd_pdhash -#define pagedep_hash_size um_softdep->sd_pdhashsize -#define pagedep_nextclean um_softdep->sd_pdnextclean -#define inodedep_hashtbl um_softdep->sd_idhash -#define inodedep_hash_size um_softdep->sd_idhashsize -#define inodedep_nextclean um_softdep->sd_idnextclean -#define newblk_hashtbl um_softdep->sd_newblkhash -#define newblk_hash_size um_softdep->sd_newblkhashsize -#define bmsafemap_hashtbl um_softdep->sd_bmhash -#define bmsafemap_hash_size um_softdep->sd_bmhashsize -#define indir_hashtbl um_softdep->sd_indirhash -#define indir_hash_size um_softdep->sd_indirhashsize -#define softdep_numindirdeps um_softdep->sd_numindirdeps -#define softdep_on_journal um_softdep->sd_on_journal -#define softdep_on_worklist um_softdep->sd_on_worklist -#define softdep_deps um_softdep->sd_deps -#define softdep_accdeps um_softdep->sd_accdeps -#define softdep_req um_softdep->sd_req -#define softdep_curdeps um_softdep->sd_curdeps +#define softdep_workitem_pending um_softdep->sd_workitem_pending +#define softdep_worklist_tail um_softdep->sd_worklist_tail +#define softdep_journal_pending um_softdep->sd_journal_pending +#define softdep_journal_tail um_softdep->sd_journal_tail +#define softdep_jblocks um_softdep->sd_jblocks +#define softdep_unlinked um_softdep->sd_unlinked +#define softdep_dirtycg um_softdep->sd_dirtycg +#define softdep_mkdirlisthd um_softdep->sd_mkdirlisthd +#define pagedep_hashtbl um_softdep->sd_pdhash +#define pagedep_hash_size um_softdep->sd_pdhashsize +#define pagedep_nextclean um_softdep->sd_pdnextclean +#define inodedep_hashtbl um_softdep->sd_idhash +#define inodedep_hash_size um_softdep->sd_idhashsize +#define inodedep_nextclean um_softdep->sd_idnextclean +#define newblk_hashtbl um_softdep->sd_newblkhash +#define newblk_hash_size um_softdep->sd_newblkhashsize +#define bmsafemap_hashtbl um_softdep->sd_bmhash +#define bmsafemap_hash_size um_softdep->sd_bmhashsize +#define indir_hashtbl um_softdep->sd_indirhash +#define indir_hash_size um_softdep->sd_indirhashsize +#define softdep_numindirdeps um_softdep->sd_numindirdeps +#define softdep_on_journal um_softdep->sd_on_journal +#define softdep_on_worklist um_softdep->sd_on_worklist +#define softdep_deps um_softdep->sd_deps +#define softdep_accdeps um_softdep->sd_accdeps +#define softdep_req um_softdep->sd_req +#define softdep_curdeps um_softdep->sd_curdeps -- cgit v1.1