Author: kib
Date: Sat Sep 17 16:47:34 2016
New Revision: 305902
URL: https://svnweb.freebsd.org/changeset/base/305902

Log:
  Reduce size of ufs inode.
  
  Remove redunand i_dev and i_fs pointers, which are available as
  ip->i_ump->um_dev and ip->i_ump->um_fs, and reorder members by size to
  reduce padding.  To compensate added derefences, the most often i_ump
  access to differentiate between UFS1 and UFS2 dinode layout is
  removed, by addition of the new i_flag IN_UFS2.  Overall, this
  actually reduces the amount of memory dereferences.
  
  On 64bit machine, original struct inode size is 176, reduced to 152
  bytes with the change.
  
  Tested by:    pho (previous version)
  Reviewed by:  mckusick
  Sponsored by: The FreeBSD Foundation
  MFC after:    2 weeks

Modified:
  head/sys/ufs/ffs/ffs_alloc.c
  head/sys/ufs/ffs/ffs_balloc.c
  head/sys/ufs/ffs/ffs_inode.c
  head/sys/ufs/ffs/ffs_rawread.c
  head/sys/ufs/ffs/ffs_snapshot.c
  head/sys/ufs/ffs/ffs_softdep.c
  head/sys/ufs/ffs/ffs_subr.c
  head/sys/ufs/ffs/ffs_vfsops.c
  head/sys/ufs/ffs/ffs_vnops.c
  head/sys/ufs/ufs/inode.h
  head/sys/ufs/ufs/ufs_acl.c
  head/sys/ufs/ufs/ufs_bmap.c
  head/sys/ufs/ufs/ufs_gjournal.c
  head/sys/ufs/ufs/ufs_inode.c
  head/sys/ufs/ufs/ufs_quota.c
  head/sys/ufs/ufs/ufs_vnops.c
  head/sys/ufs/ufs/ufsmount.h

Modified: head/sys/ufs/ffs/ffs_alloc.c
==============================================================================
--- head/sys/ufs/ffs/ffs_alloc.c        Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_alloc.c        Sat Sep 17 16:47:34 2016        
(r305902)
@@ -163,13 +163,13 @@ ffs_alloc(ip, lbn, bpref, size, flags, c
 #endif
 
        *bnp = 0;
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        mtx_assert(UFS_MTX(ump), MA_OWNED);
 #ifdef INVARIANTS
        if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
                printf("dev = %s, bsize = %ld, size = %d, fs = %s\n",
-                   devtoname(ip->i_dev), (long)fs->fs_bsize, size,
+                   devtoname(ump->um_dev), (long)fs->fs_bsize, size,
                    fs->fs_fsmnt);
                panic("ffs_alloc: bad size");
        }
@@ -260,9 +260,9 @@ ffs_realloccg(ip, lbprev, bprev, bpref, 
        int64_t delta;
 
        vp = ITOV(ip);
-       fs = ip->i_fs;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        bp = NULL;
-       ump = ip->i_ump;
        gbflags = (flags & BA_UNMAPPED) != 0 ? GB_UNMAPPED : 0;
 
        mtx_assert(UFS_MTX(ump), MA_OWNED);
@@ -273,7 +273,7 @@ ffs_realloccg(ip, lbprev, bprev, bpref, 
            (u_int)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
                printf(
                "dev = %s, bsize = %ld, osize = %d, nsize = %d, fs = %s\n",
-                   devtoname(ip->i_dev), (long)fs->fs_bsize, osize,
+                   devtoname(ump->um_dev), (long)fs->fs_bsize, osize,
                    nsize, fs->fs_fsmnt);
                panic("ffs_realloccg: bad size");
        }
@@ -288,7 +288,7 @@ retry:
        }
        if (bprev == 0) {
                printf("dev = %s, bsize = %ld, bprev = %jd, fs = %s\n",
-                   devtoname(ip->i_dev), (long)fs->fs_bsize, (intmax_t)bprev,
+                   devtoname(ump->um_dev), (long)fs->fs_bsize, (intmax_t)bprev,
                    fs->fs_fsmnt);
                panic("ffs_realloccg: bad bprev");
        }
@@ -383,7 +383,7 @@ retry:
                break;
        default:
                printf("dev = %s, optim = %ld, fs = %s\n",
-                   devtoname(ip->i_dev), (long)fs->fs_optim, fs->fs_fsmnt);
+                   devtoname(ump->um_dev), (long)fs->fs_optim, fs->fs_fsmnt);
                panic("ffs_realloccg: bad optim");
                /* NOTREACHED */
        }
@@ -391,7 +391,7 @@ retry:
        if (bno > 0) {
                bp->b_blkno = fsbtodb(fs, bno);
                if (!DOINGSOFTDEP(vp))
-                       ffs_blkfree(ump, fs, ip->i_devvp, bprev, (long)osize,
+                       ffs_blkfree(ump, fs, ump->um_devvp, bprev, (long)osize,
                            ip->i_number, vp->v_type, NULL);
                delta = btodb(nsize - osize);
                DIP_SET(ip, i_blocks, DIP(ip, i_blocks) + delta);
@@ -490,7 +490,7 @@ ffs_reallocblks(ap)
         * These devices are flash and therefore work less well with this
         * optimization. Also skip if reallocblks has been disabled globally.
         */
-       ump = VTOI(ap->a_vp)->i_ump;
+       ump = ap->a_vp->v_mount->mnt_data;
        if (ump->um_candelete || doreallocblks == 0)
                return (ENOSPC);
 
@@ -529,8 +529,8 @@ ffs_reallocblks_ufs1(ap)
 
        vp = ap->a_vp;
        ip = VTOI(vp);
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        /*
         * If we are not tracking block clusters or if we have less than 4%
         * free blocks left, then do not attempt to cluster. Running with
@@ -727,7 +727,7 @@ ffs_reallocblks_ufs1(ap)
 #endif
        for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
                if (!DOINGSOFTDEP(vp))
-                       ffs_blkfree(ump, fs, ip->i_devvp,
+                       ffs_blkfree(ump, fs, ump->um_devvp,
                            dbtofsb(fs, buflist->bs_children[i]->b_blkno),
                            fs->fs_bsize, ip->i_number, vp->v_type, NULL);
                buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
@@ -778,8 +778,8 @@ ffs_reallocblks_ufs2(ap)
 
        vp = ap->a_vp;
        ip = VTOI(vp);
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        /*
         * If we are not tracking block clusters or if we have less than 4%
         * free blocks left, then do not attempt to cluster. Running with
@@ -975,7 +975,7 @@ ffs_reallocblks_ufs2(ap)
 #endif
        for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
                if (!DOINGSOFTDEP(vp))
-                       ffs_blkfree(ump, fs, ip->i_devvp,
+                       ffs_blkfree(ump, fs, ump->um_devvp,
                            dbtofsb(fs, buflist->bs_children[i]->b_blkno),
                            fs->fs_bsize, ip->i_number, vp->v_type, NULL);
                buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno);
@@ -1040,8 +1040,8 @@ ffs_valloc(pvp, mode, cred, vpp)
 
        *vpp = NULL;
        pip = VTOI(pvp);
-       fs = pip->i_fs;
-       ump = pip->i_ump;
+       ump = ITOUMP(pip);
+       fs = ump->um_fs;
 
        UFS_LOCK(ump);
        reclaimed = 0;
@@ -1114,10 +1114,12 @@ dup_alloc:
        ip->i_flag = 0;
        (*vpp)->v_vflag = 0;
        (*vpp)->v_type = VNON;
-       if (fs->fs_magic == FS_UFS2_MAGIC)
+       if (fs->fs_magic == FS_UFS2_MAGIC) {
                (*vpp)->v_op = &ffs_vnodeops2;
-       else
+               ip->i_flag |= IN_UFS2;
+       } else {
                (*vpp)->v_op = &ffs_vnodeops1;
+       }
        return (0);
 noinodes:
        if (reclaimed == 0) {
@@ -1158,8 +1160,8 @@ ffs_dirpref(pip)
        u_int mincg, minndir;
        u_int maxcontigdirs;
 
-       mtx_assert(UFS_MTX(pip->i_ump), MA_OWNED);
-       fs = pip->i_fs;
+       mtx_assert(UFS_MTX(ITOUMP(pip)), MA_OWNED);
+       fs = ITOFS(pip);
 
        avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;
        avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
@@ -1307,8 +1309,8 @@ ffs_blkpref_ufs1(ip, lbn, indx, bap)
        ufs2_daddr_t pref;
 
        KASSERT(indx <= 0 || bap != NULL, ("need non-NULL bap"));
-       mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
-       fs = ip->i_fs;
+       mtx_assert(UFS_MTX(ITOUMP(ip)), MA_OWNED);
+       fs = ITOFS(ip);
        /*
         * Allocation of indirect blocks is indicated by passing negative
         * values in indx: -1 for single indirect, -2 for double indirect,
@@ -1412,8 +1414,8 @@ ffs_blkpref_ufs2(ip, lbn, indx, bap)
        ufs2_daddr_t pref;
 
        KASSERT(indx <= 0 || bap != NULL, ("need non-NULL bap"));
-       mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
-       fs = ip->i_fs;
+       mtx_assert(UFS_MTX(ITOUMP(ip)), MA_OWNED);
+       fs = ITOFS(ip);
        /*
         * Allocation of indirect blocks is indicated by passing negative
         * values in indx: -1 for single indirect, -2 for double indirect,
@@ -1526,12 +1528,12 @@ ffs_hashalloc(ip, cg, pref, size, rsize,
        ufs2_daddr_t result;
        u_int i, icg = cg;
 
-       mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
+       mtx_assert(UFS_MTX(ITOUMP(ip)), MA_OWNED);
 #ifdef INVARIANTS
        if (ITOV(ip)->v_mount->mnt_kern_flag & MNTK_SUSPENDED)
                panic("ffs_hashalloc: allocation on suspended filesystem");
 #endif
-       fs = ip->i_fs;
+       fs = ITOFS(ip);
        /*
         * 1: preferred cylinder group
         */
@@ -1589,8 +1591,8 @@ ffs_fragextend(ip, cg, bprev, osize, nsi
        int i, error;
        u_int8_t *blksfree;
 
-       ump = ip->i_ump;
-       fs = ip->i_fs;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))
                return (0);
        frags = numfrags(fs, nsize);
@@ -1600,8 +1602,8 @@ ffs_fragextend(ip, cg, bprev, osize, nsi
                return (0);
        }
        UFS_UNLOCK(ump);
-       error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
-               (int)fs->fs_cgsize, NOCRED, &bp);
+       error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
+           (int)fs->fs_cgsize, NOCRED, &bp);
        if (error)
                goto fail;
        cgp = (struct cg *)bp->b_data;
@@ -1673,13 +1675,13 @@ ffs_alloccg(ip, cg, bpref, size, rsize)
        int i, allocsiz, error, frags;
        u_int8_t *blksfree;
 
-       ump = ip->i_ump;
-       fs = ip->i_fs;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (0);
        UFS_UNLOCK(ump);
-       error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
-               (int)fs->fs_cgsize, NOCRED, &bp);
+       error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
+           (int)fs->fs_cgsize, NOCRED, &bp);
        if (error)
                goto fail;
        cgp = (struct cg *)bp->b_data;
@@ -1775,8 +1777,8 @@ ffs_alloccgblk(ip, bp, bpref, size)
        u_int8_t *blksfree;
        int i, cgbpref;
 
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        mtx_assert(UFS_MTX(ump), MA_OWNED);
        cgp = (struct cg *)bp->b_data;
        blksfree = cg_blksfree(cgp);
@@ -1861,12 +1863,12 @@ ffs_clusteralloc(ip, cg, bpref, len)
        int32_t *lp;
        u_int8_t *blksfree;
 
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        if (fs->fs_maxcluster[cg] < len)
                return (0);
        UFS_UNLOCK(ump);
-       if (bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,
+       if (bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,
            NOCRED, &bp))
                goto fail_lock;
        cgp = (struct cg *)bp->b_data;
@@ -1965,8 +1967,8 @@ getinobuf(struct inode *ip, u_int cg, u_
 {
        struct fs *fs;
 
-       fs = ip->i_fs;
-       return (getblk(ip->i_devvp, fsbtodb(fs, ino_to_fsba(fs,
+       fs = ITOFS(ip);
+       return (getblk(ITODEVVP(ip), fsbtodb(fs, ino_to_fsba(fs,
            cg * fs->fs_ipg + cginoblk)), (int)fs->fs_bsize, 0, 0,
            gbflags));
 }
@@ -1997,13 +1999,13 @@ ffs_nodealloccg(ip, cg, ipref, mode, unu
        int error, start, len, i;
        u_int32_t old_initediblk;
 
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
 check_nifree:
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);
        UFS_UNLOCK(ump);
-       error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
+       error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
                (int)fs->fs_cgsize, NOCRED, &bp);
        if (error) {
                brelse(bp);
@@ -2101,7 +2103,7 @@ gotit:
                 * to it, then leave it unchanged as the other thread
                 * has already set it correctly.
                 */
-               error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
+               error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
                    (int)fs->fs_cgsize, NOCRED, &bp);
                UFS_LOCK(ump);
                ACTIVECLEAR(fs, cg);
@@ -2166,7 +2168,8 @@ ffs_blkfree_cg(ump, fs, devvp, bno, size
        cg = dtog(fs, bno);
        if (devvp->v_type == VREG) {
                /* devvp is a snapshot */
-               dev = VTOI(devvp)->i_devvp->v_rdev;
+               MPASS(devvp->v_mount->mnt_data == ump);
+               dev = ump->um_devvp->v_rdev;
                cgblkno = fragstoblks(fs, cgtod(fs, cg));
        } else {
                /* devvp is a normal disk device */
@@ -2396,7 +2399,7 @@ ffs_checkblk(ip, bno, size)
        int i, error, frags, free;
        u_int8_t *blksfree;
 
-       fs = ip->i_fs;
+       fs = ITOFS(ip);
        if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
                printf("bsize = %ld, size = %ld, fs = %s\n",
                    (long)fs->fs_bsize, size, fs->fs_fsmnt);
@@ -2404,7 +2407,7 @@ ffs_checkblk(ip, bno, size)
        }
        if ((u_int)bno >= fs->fs_size)
                panic("ffs_checkblk: bad block %jd", (intmax_t)bno);
-       error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, dtog(fs, bno))),
+       error = bread(ITODEVVP(ip), fsbtodb(fs, cgtod(fs, dtog(fs, bno))),
                (int)fs->fs_cgsize, NOCRED, &bp);
        if (error)
                panic("ffs_checkblk: cg bread failed");
@@ -2438,6 +2441,7 @@ ffs_vfree(pvp, ino, mode)
        ino_t ino;
        int mode;
 {
+       struct ufsmount *ump;
        struct inode *ip;
 
        if (DOINGSOFTDEP(pvp)) {
@@ -2445,8 +2449,8 @@ ffs_vfree(pvp, ino, mode)
                return (0);
        }
        ip = VTOI(pvp);
-       return (ffs_freefile(ip->i_ump, ip->i_fs, ip->i_devvp, ino, mode,
-           NULL));
+       ump = VFSTOUFS(pvp->v_mount);
+       return (ffs_freefile(ump, ump->um_fs, ump->um_devvp, ino, mode, NULL));
 }
 
 /*
@@ -2473,7 +2477,8 @@ ffs_freefile(ump, fs, devvp, ino, mode, 
        cg = ino_to_cg(fs, ino);
        if (devvp->v_type == VREG) {
                /* devvp is a snapshot */
-               dev = VTOI(devvp)->i_devvp->v_rdev;
+               MPASS(devvp->v_mount->mnt_data == ump);
+               dev = ump->um_devvp->v_rdev;
                cgbno = fragstoblks(fs, cgtod(fs, cg));
        } else {
                /* devvp is a normal disk device */
@@ -3056,7 +3061,7 @@ sysctl_ffs_fsck(SYSCTL_HANDLER_ARGS)
                        break;
                AUDIT_ARG_VNODE1(vp);
                ip = VTOI(vp);
-               if (ip->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(ip))
                        error = copyin((void *)(intptr_t)cmd.size, ip->i_din1,
                            sizeof(struct ufs1_dinode));
                else
@@ -3076,7 +3081,7 @@ sysctl_ffs_fsck(SYSCTL_HANDLER_ARGS)
                        error = EPERM;
                        break;
                }
-               if (VTOI(vp)->i_ump != ump) {
+               if (ITOUMP(VTOI(vp)) != ump) {
                        error = EINVAL;
                        break;
                }
@@ -3173,11 +3178,11 @@ buffered_write(fp, uio, active_cred, fla
                return (EINVAL);
        }
        ip = VTOI(vp);
-       if (ip->i_devvp != devvp) {
+       if (ITODEVVP(ip) != devvp) {
                vput(vp);
                return (EINVAL);
        }
-       fs = ip->i_fs;
+       fs = ITOFS(ip);
        vput(vp);
        foffset_lock_uio(fp, uio, flags);
        vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);

Modified: head/sys/ufs/ffs/ffs_balloc.c
==============================================================================
--- head/sys/ufs/ffs/ffs_balloc.c       Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_balloc.c       Sat Sep 17 16:47:34 2016        
(r305902)
@@ -111,8 +111,8 @@ ffs_balloc_ufs1(struct vnode *vp, off_t 
 
        ip = VTOI(vp);
        dp = ip->i_din1;
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       fs = ITOFS(ip);
+       ump = ITOUMP(ip);
        lbn = lblkno(fs, startoffset);
        size = blkoff(fs, startoffset) + size;
        reclaimed = 0;
@@ -548,7 +548,7 @@ fail:
                }
                lbns_remfree++;
 #endif
-               ffs_blkfree(ump, fs, ip->i_devvp, *blkp, fs->fs_bsize,
+               ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize,
                    ip->i_number, vp->v_type, NULL);
        }
        return (error);
@@ -584,8 +584,8 @@ ffs_balloc_ufs2(struct vnode *vp, off_t 
 
        ip = VTOI(vp);
        dp = ip->i_din2;
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       fs = ITOFS(ip);
+       ump = ITOUMP(ip);
        lbn = lblkno(fs, startoffset);
        size = blkoff(fs, startoffset) + size;
        reclaimed = 0;
@@ -1141,7 +1141,7 @@ fail:
                }
                lbns_remfree++;
 #endif
-               ffs_blkfree(ump, fs, ip->i_devvp, *blkp, fs->fs_bsize,
+               ffs_blkfree(ump, fs, ump->um_devvp, *blkp, fs->fs_bsize,
                    ip->i_number, vp->v_type, NULL);
        }
        return (error);

Modified: head/sys/ufs/ffs/ffs_inode.c
==============================================================================
--- head/sys/ufs/ffs/ffs_inode.c        Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_inode.c        Sat Sep 17 16:47:34 2016        
(r305902)
@@ -92,8 +92,8 @@ ffs_update(vp, waitfor)
        if ((ip->i_flag & IN_MODIFIED) == 0 && waitfor == 0)
                return (0);
        ip->i_flag &= ~(IN_LAZYACCESS | IN_LAZYMOD | IN_MODIFIED);
-       fs = ip->i_fs;
-       if (fs->fs_ronly && ip->i_ump->um_fsckpid == 0)
+       fs = ITOFS(ip);
+       if (fs->fs_ronly && ITOUMP(ip)->um_fsckpid == 0)
                return (0);
        /*
         * If we are updating a snapshot and another process is currently
@@ -110,7 +110,7 @@ ffs_update(vp, waitfor)
        if (IS_SNAPSHOT(ip))
                flags = GB_LOCK_NOWAIT;
 loop:
-       error = breadn_flags(ip->i_devvp,
+       error = breadn_flags(ITODEVVP(ip),
             fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
             (int) fs->fs_bsize, 0, 0, 0, NOCRED, flags, &bp);
        if (error != 0) {
@@ -143,7 +143,7 @@ loop:
                softdep_update_inodeblock(ip, bp, waitfor);
        else if (ip->i_effnlink != ip->i_nlink)
                panic("ffs_update: bad link cnt");
-       if (ip->i_ump->um_fstype == UFS1) {
+       if (I_IS_UFS1(ip)) {
                *((struct ufs1_dinode *)bp->b_data +
                    ino_to_fsbo(fs, ip->i_number)) = *ip->i_din1;
                /* XXX: FIX? The entropy here is desirable, but the harvesting 
may be expensive */
@@ -197,8 +197,8 @@ ffs_truncate(vp, length, flags, cred)
        off_t osize;
 
        ip = VTOI(vp);
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = VFSTOUFS(vp->v_mount);
+       fs = ump->um_fs;
        bo = &vp->v_bufobj;
 
        ASSERT_VOP_LOCKED(vp, "ffs_truncate");
@@ -270,7 +270,7 @@ ffs_truncate(vp, length, flags, cred)
                        for (i = 0; i < NXADDR; i++) {
                                if (oldblks[i] == 0)
                                        continue;
-                               ffs_blkfree(ump, fs, ip->i_devvp, oldblks[i],
+                               ffs_blkfree(ump, fs, ITODEVVP(ip), oldblks[i],
                                    sblksize(fs, osize, i), ip->i_number,
                                    vp->v_type, NULL);
                        }
@@ -346,7 +346,7 @@ ffs_truncate(vp, length, flags, cred)
                if (error)
                        return (error);
                indiroff = (lbn - NDADDR) % NINDIR(fs);
-               if (ip->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(ip))
                        blkno = ((ufs1_daddr_t *)(bp->b_data))[indiroff];
                else
                        blkno = ((ufs2_daddr_t *)(bp->b_data))[indiroff];
@@ -518,7 +518,7 @@ ffs_truncate(vp, length, flags, cred)
                        blocksreleased += count;
                        if (lastiblock[level] < 0) {
                                DIP_SET(ip, i_ib[level], 0);
-                               ffs_blkfree(ump, fs, ip->i_devvp, bn,
+                               ffs_blkfree(ump, fs, ump->um_devvp, bn,
                                    fs->fs_bsize, ip->i_number,
                                    vp->v_type, NULL);
                                blocksreleased += nblocks;
@@ -539,7 +539,7 @@ ffs_truncate(vp, length, flags, cred)
                        continue;
                DIP_SET(ip, i_db[i], 0);
                bsize = blksize(fs, ip, i);
-               ffs_blkfree(ump, fs, ip->i_devvp, bn, bsize, ip->i_number,
+               ffs_blkfree(ump, fs, ump->um_devvp, bn, bsize, ip->i_number,
                    vp->v_type, NULL);
                blocksreleased += btodb(bsize);
        }
@@ -571,7 +571,7 @@ ffs_truncate(vp, length, flags, cred)
                         * required for the storage we're keeping.
                         */
                        bn += numfrags(fs, newspace);
-                       ffs_blkfree(ump, fs, ip->i_devvp, bn,
+                       ffs_blkfree(ump, fs, ump->um_devvp, bn,
                           oldspace - newspace, ip->i_number, vp->v_type, NULL);
                        blocksreleased += btodb(oldspace - newspace);
                }
@@ -630,7 +630,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
        ufs2_daddr_t *countp;
 {
        struct buf *bp;
-       struct fs *fs = ip->i_fs;
+       struct fs *fs;
        struct vnode *vp;
        caddr_t copy = NULL;
        int i, nblocks, error = 0, allerror = 0;
@@ -638,7 +638,9 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
        ufs2_daddr_t blkcount, factor, blocksreleased = 0;
        ufs1_daddr_t *bap1 = NULL;
        ufs2_daddr_t *bap2 = NULL;
-#      define BAP(ip, i) (((ip)->i_ump->um_fstype == UFS1) ? bap1[i] : bap2[i])
+#define BAP(ip, i) (I_IS_UFS1(ip) ? bap1[i] : bap2[i])
+
+       fs = ITOFS(ip);
 
        /*
         * Calculate index in current block of last
@@ -686,7 +688,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
                return (error);
        }
 
-       if (ip->i_ump->um_fstype == UFS1)
+       if (I_IS_UFS1(ip))
                bap1 = (ufs1_daddr_t *)bp->b_data;
        else
                bap2 = (ufs2_daddr_t *)bp->b_data;
@@ -694,7 +696,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
                copy = malloc(fs->fs_bsize, M_TEMP, M_WAITOK);
                bcopy((caddr_t)bp->b_data, copy, (u_int)fs->fs_bsize);
                for (i = last + 1; i < NINDIR(fs); i++)
-                       if (ip->i_ump->um_fstype == UFS1)
+                       if (I_IS_UFS1(ip))
                                bap1[i] = 0;
                        else
                                bap2[i] = 0;
@@ -705,7 +707,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
                        if (error)
                                allerror = error;
                }
-               if (ip->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(ip))
                        bap1 = (ufs1_daddr_t *)copy;
                else
                        bap2 = (ufs2_daddr_t *)copy;
@@ -725,7 +727,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, lev
                                allerror = error;
                        blocksreleased += blkcount;
                }
-               ffs_blkfree(ip->i_ump, fs, ip->i_devvp, nb, fs->fs_bsize,
+               ffs_blkfree(ITOUMP(ip), fs, ITODEVVP(ip), nb, fs->fs_bsize,
                    ip->i_number, vp->v_type, NULL);
                blocksreleased += nblocks;
        }
@@ -759,6 +761,6 @@ int
 ffs_rdonly(struct inode *ip)
 {
 
-       return (ip->i_ump->um_fs->fs_ronly != 0);
+       return (ITOFS(ip)->fs_ronly != 0);
 }
 

Modified: head/sys/ufs/ffs/ffs_rawread.c
==============================================================================
--- head/sys/ufs/ffs/ffs_rawread.c      Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_rawread.c      Sat Sep 17 16:47:34 2016        
(r305902)
@@ -204,7 +204,7 @@ ffs_rawread_readahead(struct vnode *vp,
        bsize = vp->v_mount->mnt_stat.f_iosize;
        
        ip = VTOI(vp);
-       dp = ip->i_devvp;
+       dp = ITODEVVP(ip);
 
        iolen = ((vm_offset_t) udata) & PAGE_MASK;
        bp->b_bcount = len;
@@ -440,7 +440,7 @@ ffs_rawread(struct vnode *vp,
 
                /* Only handle sector aligned reads */
                ip = VTOI(vp);
-               secsize = ip->i_devvp->v_bufobj.bo_bsize;
+               secsize = ITODEVVP(ip)->v_bufobj.bo_bsize;
                if ((uio->uio_offset & (secsize - 1)) == 0 &&
                    (uio->uio_resid & (secsize - 1)) == 0) {
                        
@@ -460,7 +460,7 @@ ffs_rawread(struct vnode *vp,
                                }
                                
                                partialbytes = ((unsigned int) ip->i_size) %
-                                       ip->i_fs->fs_bsize;
+                                   ITOFS(ip)->fs_bsize;
                                blockbytes = (int) filebytes - partialbytes;
                                if (blockbytes > 0) {
                                        skipbytes = uio->uio_resid -

Modified: head/sys/ufs/ffs/ffs_snapshot.c
==============================================================================
--- head/sys/ufs/ffs/ffs_snapshot.c     Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_snapshot.c     Sat Sep 17 16:47:34 2016        
(r305902)
@@ -302,7 +302,7 @@ restart:
        vp = nd.ni_vp;
        vp->v_vflag |= VV_SYSTEM;
        ip = VTOI(vp);
-       devvp = ip->i_devvp;
+       devvp = ITODEVVP(ip);
        /*
         * Allocate and copy the last block contents so as to be able
         * to set size to that of the filesystem.
@@ -587,7 +587,7 @@ loop:
                        }
                }
                snaplistsize += 1;
-               if (xp->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(xp))
                        error = expunge_ufs1(vp, xp, copy_fs, fullacct_ufs1,
                            BLK_NOCOPY, 1);
                else
@@ -620,7 +620,7 @@ loop:
                        goto out1;
                }
                xp = VTOI(xvp);
-               if (xp->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(xp))
                        error = expunge_ufs1(vp, xp, copy_fs, fullacct_ufs1,
                            BLK_NOCOPY, 0);
                else
@@ -706,7 +706,7 @@ out1:
        TAILQ_FOREACH(xp, &sn->sn_head, i_nextsnap) {
                if (xp == ip)
                        break;
-               if (xp->i_ump->um_fstype == UFS1)
+               if (I_IS_UFS1(xp))
                        error = expunge_ufs1(vp, xp, fs, snapacct_ufs1,
                            BLK_SNAP, 0);
                else
@@ -735,7 +735,7 @@ out1:
         * blocks marked as used in the snapshot bitmaps. Also, collect
         * the list of allocated blocks in i_snapblklist.
         */
-       if (ip->i_ump->um_fstype == UFS1)
+       if (I_IS_UFS1(ip))
                error = expunge_ufs1(vp, ip, copy_fs, mapacct_ufs1,
                    BLK_SNAP, 0);
        else
@@ -887,9 +887,9 @@ cgaccount(cg, vp, nbp, passno)
        int error, len, loc, indiroff;
 
        ip = VTOI(vp);
-       fs = ip->i_fs;
-       error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
-               (int)fs->fs_cgsize, KERNCRED, &bp);
+       fs = ITOFS(ip);
+       error = bread(ITODEVVP(ip), fsbtodb(fs, cgtod(fs, cg)),
+           (int)fs->fs_cgsize, KERNCRED, &bp);
        if (error) {
                brelse(bp);
                return (error);
@@ -899,7 +899,7 @@ cgaccount(cg, vp, nbp, passno)
                brelse(bp);
                return (EIO);
        }
-       UFS_LOCK(ip->i_ump);
+       UFS_LOCK(ITOUMP(ip));
        ACTIVESET(fs, cg);
        /*
         * Recomputation of summary information might not have been performed
@@ -908,7 +908,7 @@ cgaccount(cg, vp, nbp, passno)
         * fsck is slightly more consistent.
         */
        fs->fs_cs(fs, cg) = cgp->cg_cs;
-       UFS_UNLOCK(ip->i_ump);
+       UFS_UNLOCK(ITOUMP(ip));
        bcopy(bp->b_data, nbp->b_data, fs->fs_cgsize);
        if (fs->fs_cgsize < fs->fs_bsize)
                bzero(&nbp->b_data[fs->fs_cgsize],
@@ -952,7 +952,7 @@ cgaccount(cg, vp, nbp, passno)
                        }
                        indiroff = 0;
                }
-               if (ip->i_ump->um_fstype == UFS1) {
+               if (I_IS_UFS1(ip)) {
                        if (ffs_isblock(fs, cg_blksfree(cgp), loc))
                                ((ufs1_daddr_t *)(ibp->b_data))[indiroff] =
                                    BLK_NOCOPY;
@@ -1257,7 +1257,7 @@ mapacct_ufs1(vp, oldblkp, lastblkp, fs, 
                        *ip->i_snapblklist++ = lblkno;
                if (blkno == BLK_SNAP)
                        blkno = blkstofrags(fs, lblkno);
-               ffs_blkfree(ip->i_ump, fs, vp, blkno, fs->fs_bsize, inum,
+               ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
                    vp->v_type, NULL);
        }
        return (0);
@@ -1541,7 +1541,7 @@ mapacct_ufs2(vp, oldblkp, lastblkp, fs, 
                        *ip->i_snapblklist++ = lblkno;
                if (blkno == BLK_SNAP)
                        blkno = blkstofrags(fs, lblkno);
-               ffs_blkfree(ip->i_ump, fs, vp, blkno, fs->fs_bsize, inum,
+               ffs_blkfree(ITOUMP(ip), fs, vp, blkno, fs->fs_bsize, inum,
                    vp->v_type, NULL);
        }
        return (0);
@@ -1565,7 +1565,7 @@ ffs_snapgone(ip)
         * Find snapshot in incore list.
         */
        xp = NULL;
-       sn = ip->i_devvp->v_rdev->si_snapdata;
+       sn = ITODEVVP(ip)->v_rdev->si_snapdata;
        if (sn != NULL)
                TAILQ_FOREACH(xp, &sn->sn_head, i_nextsnap)
                        if (xp == ip)
@@ -1578,8 +1578,8 @@ ffs_snapgone(ip)
        /*
         * Delete snapshot inode from superblock. Keep list dense.
         */
-       fs = ip->i_fs;
-       ump = ip->i_ump;
+       ump = ITOUMP(ip);
+       fs = ump->um_fs;
        UFS_LOCK(ump);
        for (snaploc = 0; snaploc < FSMAXSNAP; snaploc++)
                if (fs->fs_snapinum[snaploc] == ip->i_number)
@@ -1611,8 +1611,8 @@ ffs_snapremove(vp)
        struct snapdata *sn;
 
        ip = VTOI(vp);
-       fs = ip->i_fs;
-       devvp = ip->i_devvp;
+       fs = ITOFS(ip);
+       devvp = ITODEVVP(ip);
        /*
         * If active, delete from incore list (this snapshot may
         * already have been in the process of being deleted, so
@@ -1646,7 +1646,7 @@ ffs_snapremove(vp)
                if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
                        DIP_SET(ip, i_db[blkno], 0);
                else if ((dblk == blkstofrags(fs, blkno) &&
-                    ffs_snapblkfree(fs, ip->i_devvp, dblk, fs->fs_bsize,
+                    ffs_snapblkfree(fs, ITODEVVP(ip), dblk, fs->fs_bsize,
                     ip->i_number, vp->v_type, NULL))) {
                        DIP_SET(ip, i_blocks, DIP(ip, i_blocks) -
                            btodb(fs->fs_bsize));
@@ -1664,14 +1664,14 @@ ffs_snapremove(vp)
                else
                        last = fs->fs_size - blkno;
                for (loc = 0; loc < last; loc++) {
-                       if (ip->i_ump->um_fstype == UFS1) {
+                       if (I_IS_UFS1(ip)) {
                                dblk = ((ufs1_daddr_t *)(ibp->b_data))[loc];
                                if (dblk == 0)
                                        continue;
                                if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
                                        ((ufs1_daddr_t *)(ibp->b_data))[loc]= 0;
                                else if ((dblk == blkstofrags(fs, blkno) &&
-                                    ffs_snapblkfree(fs, ip->i_devvp, dblk,
+                                    ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
                                     fs->fs_bsize, ip->i_number, vp->v_type,
                                     NULL))) {
                                        ip->i_din1->di_blocks -=
@@ -1686,7 +1686,7 @@ ffs_snapremove(vp)
                        if (dblk == BLK_NOCOPY || dblk == BLK_SNAP)
                                ((ufs2_daddr_t *)(ibp->b_data))[loc] = 0;
                        else if ((dblk == blkstofrags(fs, blkno) &&
-                            ffs_snapblkfree(fs, ip->i_devvp, dblk,
+                            ffs_snapblkfree(fs, ITODEVVP(ip), dblk,
                             fs->fs_bsize, ip->i_number, vp->v_type, NULL))) {
                                ip->i_din2->di_blocks -= btodb(fs->fs_bsize);
                                ((ufs2_daddr_t *)(ibp->b_data))[loc] = 0;
@@ -1781,7 +1781,7 @@ retry:
                        if (error)
                                break;
                        indiroff = (lbn - NDADDR) % NINDIR(fs);
-                       if (ip->i_ump->um_fstype == UFS1)
+                       if (I_IS_UFS1(ip))
                                blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
                        else
                                blkno=((ufs2_daddr_t *)(ibp->b_data))[indiroff];
@@ -1806,7 +1806,7 @@ retry:
                        if (lbn < NDADDR) {
                                DIP_SET(ip, i_db[lbn], BLK_NOCOPY);
                                ip->i_flag |= IN_CHANGE | IN_UPDATE;
-                       } else if (ip->i_ump->um_fstype == UFS1) {
+                       } else if (I_IS_UFS1(ip)) {
                                ((ufs1_daddr_t *)(ibp->b_data))[indiroff] =
                                    BLK_NOCOPY;
                                bdwrite(ibp);
@@ -1854,7 +1854,7 @@ retry:
                        }
                        if (lbn < NDADDR) {
                                DIP_SET(ip, i_db[lbn], bno);
-                       } else if (ip->i_ump->um_fstype == UFS1) {
+                       } else if (I_IS_UFS1(ip)) {
                                ((ufs1_daddr_t *)(ibp->b_data))[indiroff] = bno;
                                bdwrite(ibp);
                        } else {
@@ -2136,7 +2136,7 @@ ffs_bp_snapblk(devvp, bp)
        sn = devvp->v_rdev->si_snapdata;
        if (sn == NULL || TAILQ_FIRST(&sn->sn_head) == NULL)
                return (0);
-       fs = TAILQ_FIRST(&sn->sn_head)->i_fs;
+       fs = ITOFS(TAILQ_FIRST(&sn->sn_head));
        lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
        snapblklist = sn->sn_blklist;
        upper = sn->sn_listsize - 1;
@@ -2263,7 +2263,7 @@ ffs_copyonwrite(devvp, bp)
                return (0);             /* No snapshot */
        }
        ip = TAILQ_FIRST(&sn->sn_head);
-       fs = ip->i_fs;
+       fs = ITOFS(ip);
        lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno));
        snapblklist = sn->sn_blklist;
        upper = sn->sn_listsize - 1;
@@ -2337,7 +2337,7 @@ ffs_copyonwrite(devvp, bp)
                        if (error)
                                break;
                        indiroff = (lbn - NDADDR) % NINDIR(fs);
-                       if (ip->i_ump->um_fstype == UFS1)
+                       if (I_IS_UFS1(ip))
                                blkno=((ufs1_daddr_t *)(ibp->b_data))[indiroff];
                        else
                                blkno=((ufs2_daddr_t *)(ibp->b_data))[indiroff];
@@ -2493,15 +2493,19 @@ readblock(vp, bp, lbn)
 {
        struct inode *ip = VTOI(vp);
        struct bio *bip;
+       struct fs *fs;
+
+       ip = VTOI(vp);
+       fs = ITOFS(ip);
 
        bip = g_alloc_bio();
        bip->bio_cmd = BIO_READ;
-       bip->bio_offset = dbtob(fsbtodb(ip->i_fs, blkstofrags(ip->i_fs, lbn)));
+       bip->bio_offset = dbtob(fsbtodb(fs, blkstofrags(fs, lbn)));
        bip->bio_data = bp->b_data;
        bip->bio_length = bp->b_bcount;
        bip->bio_done = NULL;
 
-       g_io_request(bip, ip->i_devvp->v_bufobj.bo_private);
+       g_io_request(bip, ITODEVVP(ip)->v_bufobj.bo_private);
        bp->b_error = biowait(bip, "snaprdb");
        g_destroy_bio(bip);
        return (bp->b_error);

Modified: head/sys/ufs/ffs/ffs_softdep.c
==============================================================================
--- head/sys/ufs/ffs/ffs_softdep.c      Sat Sep 17 16:45:57 2016        
(r305901)
+++ head/sys/ufs/ffs/ffs_softdep.c      Sat Sep 17 16:47:34 2016        
(r305902)
@@ -3998,7 +3998,7 @@ newjmvref(dp, ino, oldoff, newoff)
        struct jmvref *jmvref;
 
        jmvref = malloc(sizeof(*jmvref), M_JMVREF, M_SOFTDEP_FLAGS);
-       workitem_alloc(&jmvref->jm_list, D_JMVREF, UFSTOVFS(dp->i_ump));
+       workitem_alloc(&jmvref->jm_list, D_JMVREF, ITOVFS(dp));
        jmvref->jm_list.wk_state = ATTACHED | DEPCOMPLETE;
        jmvref->jm_parent = dp->i_number;
        jmvref->jm_ino = ino;
@@ -4025,7 +4025,7 @@ newjremref(struct dirrem *dirrem, struct
        struct jremref *jremref;
 
        jremref = malloc(sizeof(*jremref), M_JREMREF, M_SOFTDEP_FLAGS);
-       workitem_alloc(&jremref->jr_list, D_JREMREF, UFSTOVFS(dp->i_ump));
+       workitem_alloc(&jremref->jr_list, D_JREMREF, ITOVFS(dp));
        jremref->jr_state = ATTACHED;
        newinoref(&jremref->jr_ref, ip->i_number, dp->i_number, diroff,
           nlink, ip->i_mode);
@@ -4061,7 +4061,7 @@ newjaddref(struct inode *dp, ino_t ino, 
        struct jaddref *jaddref;
 
        jaddref = malloc(sizeof(*jaddref), M_JADDREF, M_SOFTDEP_FLAGS);
-       workitem_alloc(&jaddref->ja_list, D_JADDREF, UFSTOVFS(dp->i_ump));
+       workitem_alloc(&jaddref->ja_list, D_JADDREF, ITOVFS(dp));
        jaddref->ja_state = ATTACHED;
        jaddref->ja_mkdir = NULL;
        newinoref(&jaddref->ja_ref, ino, dp->i_number, diroff, nlink, mode);
@@ -4649,7 +4649,7 @@ inodedep_lookup_ip(ip)
 
        KASSERT(ip->i_nlink >= ip->i_effnlink,
            ("inodedep_lookup_ip: bad delta"));
-       (void) inodedep_lookup(UFSTOVFS(ip->i_ump), ip->i_number, DEPALLOC,
+       (void) inodedep_lookup(ITOVFS(ip), ip->i_number, DEPALLOC,
            &inodedep);
        inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
        KASSERT((inodedep->id_state & UNLINKED) == 0, ("inode unlinked"));
@@ -4672,12 +4672,12 @@ softdep_setup_create(dp, ip)
        struct jaddref *jaddref;
        struct vnode *dvp;
 
-       KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(dp->i_ump)) != 0,
+       KASSERT(MOUNTEDSOFTDEP(ITOVFS(dp)) != 0,
            ("softdep_setup_create called on non-softdep filesystem"));
        KASSERT(ip->i_nlink == 1,
            ("softdep_setup_create: Invalid link count."));
        dvp = ITOV(dp);
-       ACQUIRE_LOCK(dp->i_ump);
+       ACQUIRE_LOCK(ITOUMP(dp));
        inodedep = inodedep_lookup_ip(ip);
        if (DOINGSUJ(dvp)) {
                jaddref = (struct jaddref *)TAILQ_LAST(&inodedep->id_inoreflst,
@@ -4686,7 +4686,7 @@ softdep_setup_create(dp, ip)
                    ("softdep_setup_create: No addref structure present."));
        }
        softdep_prelink(dvp, NULL);
-       FREE_LOCK(dp->i_ump);
+       FREE_LOCK(ITOUMP(dp));
 }
 
 /*
@@ -4704,7 +4704,7 @@ softdep_setup_dotdot_link(dp, ip)
        struct jaddref *jaddref;
        struct vnode *dvp;
 
-       KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(dp->i_ump)) != 0,
+       KASSERT(MOUNTEDSOFTDEP(ITOVFS(dp)) != 0,
            ("softdep_setup_dotdot_link called on non-softdep filesystem"));
        dvp = ITOV(dp);
        jaddref = NULL;
@@ -4715,13 +4715,13 @@ softdep_setup_dotdot_link(dp, ip)
        if (DOINGSUJ(dvp))
                jaddref = newjaddref(ip, dp->i_number, DOTDOT_OFFSET,
                    dp->i_effnlink - 1, dp->i_mode);
-       ACQUIRE_LOCK(dp->i_ump);
+       ACQUIRE_LOCK(ITOUMP(dp));
        inodedep = inodedep_lookup_ip(dp);
        if (jaddref)
                TAILQ_INSERT_TAIL(&inodedep->id_inoreflst, &jaddref->ja_ref,
                    if_deps);
        softdep_prelink(dvp, ITOV(ip));
-       FREE_LOCK(dp->i_ump);
+       FREE_LOCK(ITOUMP(dp));
 }
 
 /*
@@ -4739,20 +4739,20 @@ softdep_setup_link(dp, ip)
        struct jaddref *jaddref;
        struct vnode *dvp;
 
-       KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(dp->i_ump)) != 0,
+       KASSERT(MOUNTEDSOFTDEP(ITOVFS(dp)) != 0,
            ("softdep_setup_link called on non-softdep filesystem"));
        dvp = ITOV(dp);
        jaddref = NULL;
        if (DOINGSUJ(dvp))
                jaddref = newjaddref(dp, ip->i_number, 0, ip->i_effnlink - 1,
                    ip->i_mode);
-       ACQUIRE_LOCK(dp->i_ump);
+       ACQUIRE_LOCK(ITOUMP(dp));
        inodedep = inodedep_lookup_ip(ip);
        if (jaddref)
                TAILQ_INSERT_TAIL(&inodedep->id_inoreflst, &jaddref->ja_ref,
                    if_deps);
        softdep_prelink(dvp, ITOV(ip));
-       FREE_LOCK(dp->i_ump);
+       FREE_LOCK(ITOUMP(dp));
 }
 
 /*
@@ -4772,7 +4772,7 @@ softdep_setup_mkdir(dp, ip)
        struct jaddref *jaddref;
        struct vnode *dvp;
 
-       KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(dp->i_ump)) != 0,
+       KASSERT(MOUNTEDSOFTDEP(ITOVFS(dp)) != 0,
            ("softdep_setup_mkdir called on non-softdep filesystem"));
        dvp = ITOV(dp);
        dotaddref = dotdotaddref = NULL;
@@ -4784,7 +4784,7 @@ softdep_setup_mkdir(dp, ip)
                    dp->i_effnlink - 1, dp->i_mode);
                dotdotaddref->ja_state |= MKDIR_PARENT;
        }
-       ACQUIRE_LOCK(dp->i_ump);
+       ACQUIRE_LOCK(ITOUMP(dp));
        inodedep = inodedep_lookup_ip(ip);
        if (DOINGSUJ(dvp)) {
                jaddref = (struct jaddref *)TAILQ_LAST(&inodedep->id_inoreflst,
@@ -4802,7 +4802,7 @@ softdep_setup_mkdir(dp, ip)
                TAILQ_INSERT_TAIL(&inodedep->id_inoreflst,
                    &dotdotaddref->ja_ref, if_deps);
        softdep_prelink(ITOV(dp), NULL);
-       FREE_LOCK(dp->i_ump);
+       FREE_LOCK(ITOUMP(dp));
 }
 
 /*
@@ -4816,14 +4816,14 @@ softdep_setup_rmdir(dp, ip)
 {
        struct vnode *dvp;
 
-       KASSERT(MOUNTEDSOFTDEP(UFSTOVFS(dp->i_ump)) != 0,
+       KASSERT(MOUNTEDSOFTDEP(ITOVFS(dp)) != 0,
            ("softdep_setup_rmdir called on non-softdep filesystem"));
        dvp = ITOV(dp);
-       ACQUIRE_LOCK(dp->i_ump);
+       ACQUIRE_LOCK(ITOUMP(dp));

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-head@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"

Reply via email to