Return to ufs_vnops.c CVS log

Up to [Net/2] / Net2 / ufs

Annotation of Net2/ufs/ufs_vnops.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)ufs_vnops.c 7.64 (Berkeley) 5/16/91
        !            34:  */
        !            35: 
        !            36: #include "param.h"
        !            37: #include "systm.h"
        !            38: #include "namei.h"
        !            39: #include "resourcevar.h"
        !            40: #include "kernel.h"
        !            41: #include "file.h"
        !            42: #include "stat.h"
        !            43: #include "buf.h"
        !            44: #include "proc.h"
        !            45: #include "conf.h"
        !            46: #include "mount.h"
        !            47: #include "vnode.h"
        !            48: #include "specdev.h"
        !            49: #include "fifo.h"
        !            50: #include "malloc.h"
        !            51: 
        !            52: #include "lockf.h"
        !            53: #include "quota.h"
        !            54: #include "inode.h"
        !            55: #include "dir.h"
        !            56: #include "fs.h"
        !            57: 
        !            58: /*
        !            59:  * Create a regular file
        !            60:  */
        !            61: ufs_create(ndp, vap, p)
        !            62:        struct nameidata *ndp;
        !            63:        struct vattr *vap;
        !            64:        struct proc *p;
        !            65: {
        !            66:        struct inode *ip;
        !            67:        int error;
        !            68: 
        !            69:        if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip))
        !            70:                return (error);
        !            71:        ndp->ni_vp = ITOV(ip);
        !            72:        return (0);
        !            73: }
        !            74: 
        !            75: /*
        !            76:  * Mknod vnode call
        !            77:  */
        !            78: /* ARGSUSED */
        !            79: ufs_mknod(ndp, vap, cred, p)
        !            80:        struct nameidata *ndp;
        !            81:        struct ucred *cred;
        !            82:        struct vattr *vap;
        !            83:        struct proc *p;
        !            84: {
        !            85:        register struct vnode *vp;
        !            86:        struct inode *ip;
        !            87:        int error;
        !            88: 
        !            89:        if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip))
        !            90:                return (error);
        !            91:        ip->i_flag |= IACC|IUPD|ICHG;
        !            92:        if (vap->va_rdev != VNOVAL) {
        !            93:                /*
        !            94:                 * Want to be able to use this to make badblock
        !            95:                 * inodes, so don't truncate the dev number.
        !            96:                 */
        !            97:                ip->i_rdev = vap->va_rdev;
        !            98:        }
        !            99:        /*
        !           100:         * Remove inode so that it will be reloaded by iget and
        !           101:         * checked to see if it is an alias of an existing entry
        !           102:         * in the inode cache.
        !           103:         */
        !           104:        vp = ITOV(ip);
        !           105:        vput(vp);
        !           106:        vp->v_type = VNON;
        !           107:        vgone(vp);
        !           108:        return (0);
        !           109: }
        !           110: 
        !           111: /*
        !           112:  * Open called.
        !           113:  *
        !           114:  * Nothing to do.
        !           115:  */
        !           116: /* ARGSUSED */
        !           117: ufs_open(vp, mode, cred, p)
        !           118:        struct vnode *vp;
        !           119:        int mode;
        !           120:        struct ucred *cred;
        !           121:        struct proc *p;
        !           122: {
        !           123: 
        !           124:        return (0);
        !           125: }
        !           126: 
        !           127: /*
        !           128:  * Close called
        !           129:  *
        !           130:  * Update the times on the inode.
        !           131:  */
        !           132: /* ARGSUSED */
        !           133: ufs_close(vp, fflag, cred, p)
        !           134:        struct vnode *vp;
        !           135:        int fflag;
        !           136:        struct ucred *cred;
        !           137:        struct proc *p;
        !           138: {
        !           139:        register struct inode *ip = VTOI(vp);
        !           140: 
        !           141:        if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
        !           142:                ITIMES(ip, &time, &time);
        !           143:        return (0);
        !           144: }
        !           145: 
        !           146: /*
        !           147:  * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC.
        !           148:  * The mode is shifted to select the owner/group/other fields. The
        !           149:  * super user is granted all permissions.
        !           150:  */
        !           151: ufs_access(vp, mode, cred, p)
        !           152:        struct vnode *vp;
        !           153:        register int mode;
        !           154:        struct ucred *cred;
        !           155:        struct proc *p;
        !           156: {
        !           157:        register struct inode *ip = VTOI(vp);
        !           158:        register gid_t *gp;
        !           159:        int i, error;
        !           160: 
        !           161: #ifdef DIAGNOSTIC
        !           162:        if (!VOP_ISLOCKED(vp)) {
        !           163:                vprint("ufs_access: not locked", vp);
        !           164:                panic("ufs_access: not locked");
        !           165:        }
        !           166: #endif
        !           167: #ifdef QUOTA
        !           168:        if (mode & VWRITE) {
        !           169:                switch (vp->v_type) {
        !           170:                case VREG: case VDIR: case VLNK:
        !           171:                        if (error = getinoquota(ip))
        !           172:                                return (error);
        !           173:                }
        !           174:        }
        !           175: #endif /* QUOTA */
        !           176:        /*
        !           177:         * If you're the super-user, you always get access.
        !           178:         */
        !           179:        if (cred->cr_uid == 0)
        !           180:                return (0);
        !           181:        /*
        !           182:         * Access check is based on only one of owner, group, public.
        !           183:         * If not owner, then check group. If not a member of the
        !           184:         * group, then check public access.
        !           185:         */
        !           186:        if (cred->cr_uid != ip->i_uid) {
        !           187:                mode >>= 3;
        !           188:                gp = cred->cr_groups;
        !           189:                for (i = 0; i < cred->cr_ngroups; i++, gp++)
        !           190:                        if (ip->i_gid == *gp)
        !           191:                                goto found;
        !           192:                mode >>= 3;
        !           193: found:
        !           194:                ;
        !           195:        }
        !           196:        if ((ip->i_mode & mode) != 0)
        !           197:                return (0);
        !           198:        return (EACCES);
        !           199: }
        !           200: 
        !           201: /* ARGSUSED */
        !           202: ufs_getattr(vp, vap, cred, p)
        !           203:        struct vnode *vp;
        !           204:        register struct vattr *vap;
        !           205:        struct ucred *cred;
        !           206:        struct proc *p;
        !           207: {
        !           208:        register struct inode *ip = VTOI(vp);
        !           209: 
        !           210:        ITIMES(ip, &time, &time);
        !           211:        /*
        !           212:         * Copy from inode table
        !           213:         */
        !           214:        vap->va_fsid = ip->i_dev;
        !           215:        vap->va_fileid = ip->i_number;
        !           216:        vap->va_mode = ip->i_mode & ~IFMT;
        !           217:        vap->va_nlink = ip->i_nlink;
        !           218:        vap->va_uid = ip->i_uid;
        !           219:        vap->va_gid = ip->i_gid;
        !           220:        vap->va_rdev = (dev_t)ip->i_rdev;
        !           221: #ifdef tahoe
        !           222:        vap->va_size = ip->i_size;
        !           223:        vap->va_size_rsv = 0;
        !           224: #else
        !           225:        vap->va_qsize = ip->i_din.di_qsize;
        !           226: #endif
        !           227:        vap->va_atime.tv_sec = ip->i_atime;
        !           228:        vap->va_atime.tv_usec = 0;
        !           229:        vap->va_mtime.tv_sec = ip->i_mtime;
        !           230:        vap->va_mtime.tv_usec = 0;
        !           231:        vap->va_ctime.tv_sec = ip->i_ctime;
        !           232:        vap->va_ctime.tv_usec = 0;
        !           233:        vap->va_flags = ip->i_flags;
        !           234:        vap->va_gen = ip->i_gen;
        !           235:        /* this doesn't belong here */
        !           236:        if (vp->v_type == VBLK)
        !           237:                vap->va_blocksize = BLKDEV_IOSIZE;
        !           238:        else if (vp->v_type == VCHR)
        !           239:                vap->va_blocksize = MAXBSIZE;
        !           240:        else
        !           241:                vap->va_blocksize = ip->i_fs->fs_bsize;
        !           242:        vap->va_bytes = dbtob(ip->i_blocks);
        !           243:        vap->va_bytes_rsv = 0;
        !           244:        vap->va_type = vp->v_type;
        !           245:        return (0);
        !           246: }
        !           247: 
        !           248: /*
        !           249:  * Set attribute vnode op. called from several syscalls
        !           250:  */
        !           251: ufs_setattr(vp, vap, cred, p)
        !           252:        register struct vnode *vp;
        !           253:        register struct vattr *vap;
        !           254:        register struct ucred *cred;
        !           255:        struct proc *p;
        !           256: {
        !           257:        register struct inode *ip = VTOI(vp);
        !           258:        int error = 0;
        !           259: 
        !           260:        /*
        !           261:         * Check for unsetable attributes.
        !           262:         */
        !           263:        if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
        !           264:            (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
        !           265:            (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
        !           266:            ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
        !           267:                return (EINVAL);
        !           268:        }
        !           269:        /*
        !           270:         * Go through the fields and update iff not VNOVAL.
        !           271:         */
        !           272:        if (vap->va_uid != (u_short)VNOVAL || vap->va_gid != (u_short)VNOVAL)
        !           273:                if (error = chown1(vp, vap->va_uid, vap->va_gid, p))
        !           274:                        return (error);
        !           275:        if (vap->va_size != VNOVAL) {
        !           276:                if (vp->v_type == VDIR)
        !           277:                        return (EISDIR);
        !           278:                if (error = itrunc(ip, vap->va_size, 0)) /* XXX IO_SYNC? */
        !           279:                        return (error);
        !           280:        }
        !           281:        if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
        !           282:                if (cred->cr_uid != ip->i_uid &&
        !           283:                    (error = suser(cred, &p->p_acflag)))
        !           284:                        return (error);
        !           285:                if (vap->va_atime.tv_sec != VNOVAL)
        !           286:                        ip->i_flag |= IACC;
        !           287:                if (vap->va_mtime.tv_sec != VNOVAL)
        !           288:                        ip->i_flag |= IUPD;
        !           289:                ip->i_flag |= ICHG;
        !           290:                if (error = iupdat(ip, &vap->va_atime, &vap->va_mtime, 1))
        !           291:                        return (error);
        !           292:        }
        !           293:        if (vap->va_mode != (u_short)VNOVAL)
        !           294:                error = chmod1(vp, (int)vap->va_mode, p);
        !           295:        if (vap->va_flags != VNOVAL) {
        !           296:                if (cred->cr_uid != ip->i_uid &&
        !           297:                    (error = suser(cred, &p->p_acflag)))
        !           298:                        return (error);
        !           299:                if (cred->cr_uid == 0) {
        !           300:                        ip->i_flags = vap->va_flags;
        !           301:                } else {
        !           302:                        ip->i_flags &= 0xffff0000;
        !           303:                        ip->i_flags |= (vap->va_flags & 0xffff);
        !           304:                }
        !           305:                ip->i_flag |= ICHG;
        !           306:        }
        !           307:        return (error);
        !           308: }
        !           309: 
        !           310: /*
        !           311:  * Change the mode on a file.
        !           312:  * Inode must be locked before calling.
        !           313:  */
        !           314: chmod1(vp, mode, p)
        !           315:        register struct vnode *vp;
        !           316:        register int mode;
        !           317:        struct proc *p;
        !           318: {
        !           319:        register struct ucred *cred = p->p_ucred;
        !           320:        register struct inode *ip = VTOI(vp);
        !           321:        int error;
        !           322: 
        !           323:        if (cred->cr_uid != ip->i_uid &&
        !           324:            (error = suser(cred, &p->p_acflag)))
        !           325:                return (error);
        !           326:        if (cred->cr_uid) {
        !           327:                if (vp->v_type != VDIR && (mode & ISVTX))
        !           328:                        return (EFTYPE);
        !           329:                if (!groupmember(ip->i_gid, cred) && (mode & ISGID))
        !           330:                        return (EPERM);
        !           331:        }
        !           332:        ip->i_mode &= ~07777;
        !           333:        ip->i_mode |= mode & 07777;
        !           334:        ip->i_flag |= ICHG;
        !           335:        if ((vp->v_flag & VTEXT) && (ip->i_mode & ISVTX) == 0)
        !           336:                (void) vnode_pager_uncache(vp);
        !           337:        return (0);
        !           338: }
        !           339: 
        !           340: /*
        !           341:  * Perform chown operation on inode ip;
        !           342:  * inode must be locked prior to call.
        !           343:  */
        !           344: chown1(vp, uid, gid, p)
        !           345:        register struct vnode *vp;
        !           346:        uid_t uid;
        !           347:        gid_t gid;
        !           348:        struct proc *p;
        !           349: {
        !           350:        register struct inode *ip = VTOI(vp);
        !           351:        register struct ucred *cred = p->p_ucred;
        !           352:        uid_t ouid;
        !           353:        gid_t ogid;
        !           354:        int error = 0;
        !           355: #ifdef QUOTA
        !           356:        register int i;
        !           357:        long change;
        !           358: #endif
        !           359: 
        !           360:        if (uid == (u_short)VNOVAL)
        !           361:                uid = ip->i_uid;
        !           362:        if (gid == (u_short)VNOVAL)
        !           363:                gid = ip->i_gid;
        !           364:        /*
        !           365:         * If we don't own the file, are trying to change the owner
        !           366:         * of the file, or are not a member of the target group,
        !           367:         * the caller must be superuser or the call fails.
        !           368:         */
        !           369:        if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid ||
        !           370:            !groupmember((gid_t)gid, cred)) &&
        !           371:            (error = suser(cred, &p->p_acflag)))
        !           372:                return (error);
        !           373:        ouid = ip->i_uid;
        !           374:        ogid = ip->i_gid;
        !           375: #ifdef QUOTA
        !           376:        if (error = getinoquota(ip))
        !           377:                return (error);
        !           378:        if (ouid == uid) {
        !           379:                dqrele(vp, ip->i_dquot[USRQUOTA]);
        !           380:                ip->i_dquot[USRQUOTA] = NODQUOT;
        !           381:        }
        !           382:        if (ogid == gid) {
        !           383:                dqrele(vp, ip->i_dquot[GRPQUOTA]);
        !           384:                ip->i_dquot[GRPQUOTA] = NODQUOT;
        !           385:        }
        !           386:        change = ip->i_blocks;
        !           387:        (void) chkdq(ip, -change, cred, CHOWN);
        !           388:        (void) chkiq(ip, -1, cred, CHOWN);
        !           389:        for (i = 0; i < MAXQUOTAS; i++) {
        !           390:                dqrele(vp, ip->i_dquot[i]);
        !           391:                ip->i_dquot[i] = NODQUOT;
        !           392:        }
        !           393: #endif
        !           394:        ip->i_uid = uid;
        !           395:        ip->i_gid = gid;
        !           396: #ifdef QUOTA
        !           397:        if ((error = getinoquota(ip)) == 0) {
        !           398:                if (ouid == uid) {
        !           399:                        dqrele(vp, ip->i_dquot[USRQUOTA]);
        !           400:                        ip->i_dquot[USRQUOTA] = NODQUOT;
        !           401:                }
        !           402:                if (ogid == gid) {
        !           403:                        dqrele(vp, ip->i_dquot[GRPQUOTA]);
        !           404:                        ip->i_dquot[GRPQUOTA] = NODQUOT;
        !           405:                }
        !           406:                if ((error = chkdq(ip, change, cred, CHOWN)) == 0) {
        !           407:                        if ((error = chkiq(ip, 1, cred, CHOWN)) == 0)
        !           408:                                goto good;
        !           409:                        else
        !           410:                                (void) chkdq(ip, -change, cred, CHOWN|FORCE);
        !           411:                }
        !           412:                for (i = 0; i < MAXQUOTAS; i++) {
        !           413:                        dqrele(vp, ip->i_dquot[i]);
        !           414:                        ip->i_dquot[i] = NODQUOT;
        !           415:                }
        !           416:        }
        !           417:        ip->i_uid = ouid;
        !           418:        ip->i_gid = ogid;
        !           419:        if (getinoquota(ip) == 0) {
        !           420:                if (ouid == uid) {
        !           421:                        dqrele(vp, ip->i_dquot[USRQUOTA]);
        !           422:                        ip->i_dquot[USRQUOTA] = NODQUOT;
        !           423:                }
        !           424:                if (ogid == gid) {
        !           425:                        dqrele(vp, ip->i_dquot[GRPQUOTA]);
        !           426:                        ip->i_dquot[GRPQUOTA] = NODQUOT;
        !           427:                }
        !           428:                (void) chkdq(ip, change, cred, FORCE|CHOWN);
        !           429:                (void) chkiq(ip, 1, cred, FORCE|CHOWN);
        !           430:                (void) getinoquota(ip);
        !           431:        }
        !           432:        return (error);
        !           433: good:
        !           434:        if (getinoquota(ip))
        !           435:                panic("chown: lost quota");
        !           436: #endif /* QUOTA */
        !           437:        if (ouid != uid || ogid != gid)
        !           438:                ip->i_flag |= ICHG;
        !           439:        if (ouid != uid && cred->cr_uid != 0)
        !           440:                ip->i_mode &= ~ISUID;
        !           441:        if (ogid != gid && cred->cr_uid != 0)
        !           442:                ip->i_mode &= ~ISGID;
        !           443:        return (0);
        !           444: }
        !           445: 
        !           446: /*
        !           447:  * Vnode op for reading.
        !           448:  */
        !           449: /* ARGSUSED */
        !           450: ufs_read(vp, uio, ioflag, cred)
        !           451:        struct vnode *vp;
        !           452:        register struct uio *uio;
        !           453:        int ioflag;
        !           454:        struct ucred *cred;
        !           455: {
        !           456:        register struct inode *ip = VTOI(vp);
        !           457:        register struct fs *fs;
        !           458:        struct buf *bp;
        !           459:        daddr_t lbn, bn, rablock;
        !           460:        int size, diff, error = 0;
        !           461:        long n, on, type;
        !           462: 
        !           463: #ifdef DIAGNOSTIC
        !           464:        if (uio->uio_rw != UIO_READ)
        !           465:                panic("ufs_read mode");
        !           466:        type = ip->i_mode & IFMT;
        !           467:        if (type != IFDIR && type != IFREG && type != IFLNK)
        !           468:                panic("ufs_read type");
        !           469: #endif
        !           470:        if (uio->uio_resid == 0)
        !           471:                return (0);
        !           472:        if (uio->uio_offset < 0)
        !           473:                return (EINVAL);
        !           474:        ip->i_flag |= IACC;
        !           475:        fs = ip->i_fs;
        !           476:        do {
        !           477:                lbn = lblkno(fs, uio->uio_offset);
        !           478:                on = blkoff(fs, uio->uio_offset);
        !           479:                n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
        !           480:                diff = ip->i_size - uio->uio_offset;
        !           481:                if (diff <= 0)
        !           482:                        return (0);
        !           483:                if (diff < n)
        !           484:                        n = diff;
        !           485:                size = blksize(fs, ip, lbn);
        !           486:                rablock = lbn + 1;
        !           487:                if (vp->v_lastr + 1 == lbn &&
        !           488:                    lblktosize(fs, rablock) < ip->i_size)
        !           489:                        error = breada(ITOV(ip), lbn, size, rablock,
        !           490:                                blksize(fs, ip, rablock), NOCRED, &bp);
        !           491:                else
        !           492:                        error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
        !           493:                vp->v_lastr = lbn;
        !           494:                n = MIN(n, size - bp->b_resid);
        !           495:                if (error) {
        !           496:                        brelse(bp);
        !           497:                        return (error);
        !           498:                }
        !           499:                error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
        !           500:                if (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size)
        !           501:                        bp->b_flags |= B_AGE;
        !           502:                brelse(bp);
        !           503:        } while (error == 0 && uio->uio_resid > 0 && n != 0);
        !           504:        return (error);
        !           505: }
        !           506: 
        !           507: /*
        !           508:  * Vnode op for writing.
        !           509:  */
        !           510: ufs_write(vp, uio, ioflag, cred)
        !           511:        register struct vnode *vp;
        !           512:        struct uio *uio;
        !           513:        int ioflag;
        !           514:        struct ucred *cred;
        !           515: {
        !           516:        struct proc *p = uio->uio_procp;
        !           517:        register struct inode *ip = VTOI(vp);
        !           518:        register struct fs *fs;
        !           519:        struct buf *bp;
        !           520:        daddr_t lbn, bn;
        !           521:        u_long osize;
        !           522:        int n, on, flags;
        !           523:        int size, resid, error = 0;
        !           524: 
        !           525: #ifdef DIAGNOSTIC
        !           526:        if (uio->uio_rw != UIO_WRITE)
        !           527:                panic("ufs_write mode");
        !           528: #endif
        !           529:        switch (vp->v_type) {
        !           530:        case VREG:
        !           531:                if (ioflag & IO_APPEND)
        !           532:                        uio->uio_offset = ip->i_size;
        !           533:                /* fall through */
        !           534:        case VLNK:
        !           535:                break;
        !           536: 
        !           537:        case VDIR:
        !           538:                if ((ioflag & IO_SYNC) == 0)
        !           539:                        panic("ufs_write nonsync dir write");
        !           540:                break;
        !           541: 
        !           542:        default:
        !           543:                panic("ufs_write type");
        !           544:        }
        !           545:        if (uio->uio_offset < 0)
        !           546:                return (EINVAL);
        !           547:        if (uio->uio_resid == 0)
        !           548:                return (0);
        !           549:        /*
        !           550:         * Maybe this should be above the vnode op call, but so long as
        !           551:         * file servers have no limits, i don't think it matters
        !           552:         */
        !           553:        if (vp->v_type == VREG && p &&
        !           554:            uio->uio_offset + uio->uio_resid >
        !           555:              p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
        !           556:                psignal(p, SIGXFSZ);
        !           557:                return (EFBIG);
        !           558:        }
        !           559:        resid = uio->uio_resid;
        !           560:        osize = ip->i_size;
        !           561:        fs = ip->i_fs;
        !           562:        flags = 0;
        !           563:        if (ioflag & IO_SYNC)
        !           564:                flags = B_SYNC;
        !           565:        do {
        !           566:                lbn = lblkno(fs, uio->uio_offset);
        !           567:                on = blkoff(fs, uio->uio_offset);
        !           568:                n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
        !           569:                if (n < fs->fs_bsize)
        !           570:                        flags |= B_CLRBUF;
        !           571:                else
        !           572:                        flags &= ~B_CLRBUF;
        !           573:                if (error = balloc(ip, lbn, (int)(on + n), &bp, flags))
        !           574:                        break;
        !           575:                bn = bp->b_blkno;
        !           576:                if (uio->uio_offset + n > ip->i_size) {
        !           577:                        ip->i_size = uio->uio_offset + n;
        !           578:                        vnode_pager_setsize(vp, ip->i_size);
        !           579:                }
        !           580:                size = blksize(fs, ip, lbn);
        !           581:                (void) vnode_pager_uncache(vp);
        !           582:                n = MIN(n, size - bp->b_resid);
        !           583:                error = uiomove(bp->b_un.b_addr + on, n, uio);
        !           584:                if (ioflag & IO_SYNC)
        !           585:                        (void) bwrite(bp);
        !           586:                else if (n + on == fs->fs_bsize) {
        !           587:                        bp->b_flags |= B_AGE;
        !           588:                        bawrite(bp);
        !           589:                } else
        !           590:                        bdwrite(bp);
        !           591:                ip->i_flag |= IUPD|ICHG;
        !           592:                if (cred->cr_uid != 0)
        !           593:                        ip->i_mode &= ~(ISUID|ISGID);
        !           594:        } while (error == 0 && uio->uio_resid > 0 && n != 0);
        !           595:        if (error && (ioflag & IO_UNIT)) {
        !           596:                (void) itrunc(ip, osize, ioflag & IO_SYNC);
        !           597:                uio->uio_offset -= resid - uio->uio_resid;
        !           598:                uio->uio_resid = resid;
        !           599:        }
        !           600:        if (!error && (ioflag & IO_SYNC))
        !           601:                error = iupdat(ip, &time, &time, 1);
        !           602:        return (error);
        !           603: }
        !           604: 
        !           605: /* ARGSUSED */
        !           606: ufs_ioctl(vp, com, data, fflag, cred, p)
        !           607:        struct vnode *vp;
        !           608:        int com;
        !           609:        caddr_t data;
        !           610:        int fflag;
        !           611:        struct ucred *cred;
        !           612:        struct proc *p;
        !           613: {
        !           614: 
        !           615:        return (ENOTTY);
        !           616: }
        !           617: 
        !           618: /* ARGSUSED */
        !           619: ufs_select(vp, which, fflags, cred, p)
        !           620:        struct vnode *vp;
        !           621:        int which, fflags;
        !           622:        struct ucred *cred;
        !           623:        struct proc *p;
        !           624: {
        !           625: 
        !           626:        /*
        !           627:         * We should really check to see if I/O is possible.
        !           628:         */
        !           629:        return (1);
        !           630: }
        !           631: 
        !           632: /*
        !           633:  * Mmap a file
        !           634:  *
        !           635:  * NB Currently unsupported.
        !           636:  */
        !           637: /* ARGSUSED */
        !           638: ufs_mmap(vp, fflags, cred, p)
        !           639:        struct vnode *vp;
        !           640:        int fflags;
        !           641:        struct ucred *cred;
        !           642:        struct proc *p;
        !           643: {
        !           644: 
        !           645:        return (EINVAL);
        !           646: }
        !           647: 
        !           648: /*
        !           649:  * Synch an open file.
        !           650:  */
        !           651: /* ARGSUSED */
        !           652: ufs_fsync(vp, fflags, cred, waitfor, p)
        !           653:        struct vnode *vp;
        !           654:        int fflags;
        !           655:        struct ucred *cred;
        !           656:        int waitfor;
        !           657:        struct proc *p;
        !           658: {
        !           659:        struct inode *ip = VTOI(vp);
        !           660: 
        !           661:        if (fflags & FWRITE)
        !           662:                ip->i_flag |= ICHG;
        !           663:        vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0);
        !           664:        return (iupdat(ip, &time, &time, waitfor == MNT_WAIT));
        !           665: }
        !           666: 
        !           667: /*
        !           668:  * Seek on a file
        !           669:  *
        !           670:  * Nothing to do, so just return.
        !           671:  */
        !           672: /* ARGSUSED */
        !           673: ufs_seek(vp, oldoff, newoff, cred)
        !           674:        struct vnode *vp;
        !           675:        off_t oldoff, newoff;
        !           676:        struct ucred *cred;
        !           677: {
        !           678: 
        !           679:        return (0);
        !           680: }
        !           681: 
        !           682: /*
        !           683:  * ufs remove
        !           684:  * Hard to avoid races here, especially
        !           685:  * in unlinking directories.
        !           686:  */
        !           687: ufs_remove(ndp, p)
        !           688:        struct nameidata *ndp;
        !           689:        struct proc *p;
        !           690: {
        !           691:        register struct inode *ip, *dp;
        !           692:        int error;
        !           693: 
        !           694:        ip = VTOI(ndp->ni_vp);
        !           695:        dp = VTOI(ndp->ni_dvp);
        !           696:        error = dirremove(ndp);
        !           697:        if (!error) {
        !           698:                ip->i_nlink--;
        !           699:                ip->i_flag |= ICHG;
        !           700:        }
        !           701:        if (dp == ip)
        !           702:                vrele(ITOV(ip));
        !           703:        else
        !           704:                iput(ip);
        !           705:        iput(dp);
        !           706:        return (error);
        !           707: }
        !           708: 
        !           709: /*
        !           710:  * link vnode call
        !           711:  */
        !           712: ufs_link(vp, ndp, p)
        !           713:        register struct vnode *vp;
        !           714:        register struct nameidata *ndp;
        !           715:        struct proc *p;
        !           716: {
        !           717:        register struct inode *ip = VTOI(vp);
        !           718:        int error;
        !           719: 
        !           720: #ifdef DIANOSTIC
        !           721:        if ((ndp->ni_nameiop & HASBUF) == 0)
        !           722:                panic("ufs_link: no name");
        !           723: #endif
        !           724:        if ((unsigned short)ip->i_nlink >= LINK_MAX) {
        !           725:                free(ndp->ni_pnbuf, M_NAMEI);
        !           726:                return (EMLINK);
        !           727:        }
        !           728:        if (ndp->ni_dvp != vp)
        !           729:                ILOCK(ip);
        !           730:        ip->i_nlink++;
        !           731:        ip->i_flag |= ICHG;
        !           732:        error = iupdat(ip, &time, &time, 1);
        !           733:        if (!error)
        !           734:                error = direnter(ip, ndp);
        !           735:        if (ndp->ni_dvp != vp)
        !           736:                IUNLOCK(ip);
        !           737:        FREE(ndp->ni_pnbuf, M_NAMEI);
        !           738:        vput(ndp->ni_dvp);
        !           739:        if (error) {
        !           740:                ip->i_nlink--;
        !           741:                ip->i_flag |= ICHG;
        !           742:        }
        !           743:        return (error);
        !           744: }
        !           745: 
        !           746: /*
        !           747:  * Rename system call.
        !           748:  *     rename("foo", "bar");
        !           749:  * is essentially
        !           750:  *     unlink("bar");
        !           751:  *     link("foo", "bar");
        !           752:  *     unlink("foo");
        !           753:  * but ``atomically''.  Can't do full commit without saving state in the
        !           754:  * inode on disk which isn't feasible at this time.  Best we can do is
        !           755:  * always guarantee the target exists.
        !           756:  *
        !           757:  * Basic algorithm is:
        !           758:  *
        !           759:  * 1) Bump link count on source while we're linking it to the
        !           760:  *    target.  This also ensure the inode won't be deleted out
        !           761:  *    from underneath us while we work (it may be truncated by
        !           762:  *    a concurrent `trunc' or `open' for creation).
        !           763:  * 2) Link source to destination.  If destination already exists,
        !           764:  *    delete it first.
        !           765:  * 3) Unlink source reference to inode if still around. If a
        !           766:  *    directory was moved and the parent of the destination
        !           767:  *    is different from the source, patch the ".." entry in the
        !           768:  *    directory.
        !           769:  */
        !           770: ufs_rename(fndp, tndp, p)
        !           771:        register struct nameidata *fndp, *tndp;
        !           772:        struct proc *p;
        !           773: {
        !           774:        register struct inode *ip, *xp, *dp;
        !           775:        struct dirtemplate dirbuf;
        !           776:        int doingdirectory = 0, oldparent = 0, newparent = 0;
        !           777:        int error = 0;
        !           778: 
        !           779: #ifdef DIANOSTIC
        !           780:        if ((tndp->ni_nameiop & HASBUF) == 0 ||
        !           781:            (fndp->ni_nameiop & HASBUF) == 0)
        !           782:                panic("ufs_rename: no name");
        !           783: #endif
        !           784:        dp = VTOI(fndp->ni_dvp);
        !           785:        ip = VTOI(fndp->ni_vp);
        !           786:        /*
        !           787:         * Check if just deleting a link name.
        !           788:         */
        !           789:        if (fndp->ni_vp == tndp->ni_vp) {
        !           790:                VOP_ABORTOP(tndp);
        !           791:                vput(tndp->ni_dvp);
        !           792:                vput(tndp->ni_vp);
        !           793:                vrele(fndp->ni_dvp);
        !           794:                if ((ip->i_mode&IFMT) == IFDIR) {
        !           795:                        VOP_ABORTOP(fndp);
        !           796:                        vrele(fndp->ni_vp);
        !           797:                        return (EINVAL);
        !           798:                }
        !           799:                doingdirectory = 0;
        !           800:                goto unlinkit;
        !           801:        }
        !           802:        ILOCK(ip);
        !           803:        if ((ip->i_mode&IFMT) == IFDIR) {
        !           804:                /*
        !           805:                 * Avoid ".", "..", and aliases of "." for obvious reasons.
        !           806:                 */
        !           807:                if ((fndp->ni_namelen == 1 && fndp->ni_ptr[0] == '.') ||
        !           808:                    dp == ip || fndp->ni_isdotdot || (ip->i_flag & IRENAME)) {
        !           809:                        VOP_ABORTOP(tndp);
        !           810:                        vput(tndp->ni_dvp);
        !           811:                        if (tndp->ni_vp)
        !           812:                                vput(tndp->ni_vp);
        !           813:                        VOP_ABORTOP(fndp);
        !           814:                        vrele(fndp->ni_dvp);
        !           815:                        vput(fndp->ni_vp);
        !           816:                        return (EINVAL);
        !           817:                }
        !           818:                ip->i_flag |= IRENAME;
        !           819:                oldparent = dp->i_number;
        !           820:                doingdirectory++;
        !           821:        }
        !           822:        vrele(fndp->ni_dvp);
        !           823: 
        !           824:        /*
        !           825:         * 1) Bump link count while we're moving stuff
        !           826:         *    around.  If we crash somewhere before
        !           827:         *    completing our work, the link count
        !           828:         *    may be wrong, but correctable.
        !           829:         */
        !           830:        ip->i_nlink++;
        !           831:        ip->i_flag |= ICHG;
        !           832:        error = iupdat(ip, &time, &time, 1);
        !           833:        IUNLOCK(ip);
        !           834: 
        !           835:        /*
        !           836:         * When the target exists, both the directory
        !           837:         * and target vnodes are returned locked.
        !           838:         */
        !           839:        dp = VTOI(tndp->ni_dvp);
        !           840:        xp = NULL;
        !           841:        if (tndp->ni_vp)
        !           842:                xp = VTOI(tndp->ni_vp);
        !           843:        /*
        !           844:         * If ".." must be changed (ie the directory gets a new
        !           845:         * parent) then the source directory must not be in the
        !           846:         * directory heirarchy above the target, as this would
        !           847:         * orphan everything below the source directory. Also
        !           848:         * the user must have write permission in the source so
        !           849:         * as to be able to change "..". We must repeat the call 
        !           850:         * to namei, as the parent directory is unlocked by the
        !           851:         * call to checkpath().
        !           852:         */
        !           853:        if (oldparent != dp->i_number)
        !           854:                newparent = dp->i_number;
        !           855:        if (doingdirectory && newparent) {
        !           856:                VOP_LOCK(fndp->ni_vp);
        !           857:                error = ufs_access(fndp->ni_vp, VWRITE, tndp->ni_cred, p);
        !           858:                VOP_UNLOCK(fndp->ni_vp);
        !           859:                if (error)
        !           860:                        goto bad;
        !           861:                if (xp != NULL)
        !           862:                        iput(xp);
        !           863:                if (error = checkpath(ip, dp, tndp->ni_cred))
        !           864:                        goto out;
        !           865:                if ((tndp->ni_nameiop & SAVESTART) == 0)
        !           866:                        panic("ufs_rename: lost to startdir");
        !           867:                if (error = lookup(tndp, p))
        !           868:                        goto out;
        !           869:                dp = VTOI(tndp->ni_dvp);
        !           870:                xp = NULL;
        !           871:                if (tndp->ni_vp)
        !           872:                        xp = VTOI(tndp->ni_vp);
        !           873:        }
        !           874:        /*
        !           875:         * 2) If target doesn't exist, link the target
        !           876:         *    to the source and unlink the source. 
        !           877:         *    Otherwise, rewrite the target directory
        !           878:         *    entry to reference the source inode and
        !           879:         *    expunge the original entry's existence.
        !           880:         */
        !           881:        if (xp == NULL) {
        !           882:                if (dp->i_dev != ip->i_dev)
        !           883:                        panic("rename: EXDEV");
        !           884:                /*
        !           885:                 * Account for ".." in new directory.
        !           886:                 * When source and destination have the same
        !           887:                 * parent we don't fool with the link count.
        !           888:                 */
        !           889:                if (doingdirectory && newparent) {
        !           890:                        if ((unsigned short)dp->i_nlink >= LINK_MAX) {
        !           891:                                error = EMLINK;
        !           892:                                goto bad;
        !           893:                        }
        !           894:                        dp->i_nlink++;
        !           895:                        dp->i_flag |= ICHG;
        !           896:                        if (error = iupdat(dp, &time, &time, 1))
        !           897:                                goto bad;
        !           898:                }
        !           899:                if (error = direnter(ip, tndp)) {
        !           900:                        if (doingdirectory && newparent) {
        !           901:                                dp->i_nlink--;
        !           902:                                dp->i_flag |= ICHG;
        !           903:                                (void) iupdat(dp, &time, &time, 1);
        !           904:                        }
        !           905:                        goto bad;
        !           906:                }
        !           907:                iput(dp);
        !           908:        } else {
        !           909:                if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
        !           910:                        panic("rename: EXDEV");
        !           911:                /*
        !           912:                 * Short circuit rename(foo, foo).
        !           913:                 */
        !           914:                if (xp->i_number == ip->i_number)
        !           915:                        panic("rename: same file");
        !           916:                /*
        !           917:                 * If the parent directory is "sticky", then the user must
        !           918:                 * own the parent directory, or the destination of the rename,
        !           919:                 * otherwise the destination may not be changed (except by
        !           920:                 * root). This implements append-only directories.
        !           921:                 */
        !           922:                if ((dp->i_mode & ISVTX) && tndp->ni_cred->cr_uid != 0 &&
        !           923:                    tndp->ni_cred->cr_uid != dp->i_uid &&
        !           924:                    xp->i_uid != tndp->ni_cred->cr_uid) {
        !           925:                        error = EPERM;
        !           926:                        goto bad;
        !           927:                }
        !           928:                /*
        !           929:                 * Target must be empty if a directory and have no links
        !           930:                 * to it. Also, ensure source and target are compatible
        !           931:                 * (both directories, or both not directories).
        !           932:                 */
        !           933:                if ((xp->i_mode&IFMT) == IFDIR) {
        !           934:                        if (!dirempty(xp, dp->i_number, tndp->ni_cred) || 
        !           935:                            xp->i_nlink > 2) {
        !           936:                                error = ENOTEMPTY;
        !           937:                                goto bad;
        !           938:                        }
        !           939:                        if (!doingdirectory) {
        !           940:                                error = ENOTDIR;
        !           941:                                goto bad;
        !           942:                        }
        !           943:                        cache_purge(ITOV(dp));
        !           944:                } else if (doingdirectory) {
        !           945:                        error = EISDIR;
        !           946:                        goto bad;
        !           947:                }
        !           948:                if (error = dirrewrite(dp, ip, tndp))
        !           949:                        goto bad;
        !           950:                /*
        !           951:                 * If the target directory is in the same
        !           952:                 * directory as the source directory,
        !           953:                 * decrement the link count on the parent
        !           954:                 * of the target directory.
        !           955:                 */
        !           956:                 if (doingdirectory && !newparent) {
        !           957:                        dp->i_nlink--;
        !           958:                        dp->i_flag |= ICHG;
        !           959:                }
        !           960:                vput(ITOV(dp));
        !           961:                /*
        !           962:                 * Adjust the link count of the target to
        !           963:                 * reflect the dirrewrite above.  If this is
        !           964:                 * a directory it is empty and there are
        !           965:                 * no links to it, so we can squash the inode and
        !           966:                 * any space associated with it.  We disallowed
        !           967:                 * renaming over top of a directory with links to
        !           968:                 * it above, as the remaining link would point to
        !           969:                 * a directory without "." or ".." entries.
        !           970:                 */
        !           971:                xp->i_nlink--;
        !           972:                if (doingdirectory) {
        !           973:                        if (--xp->i_nlink != 0)
        !           974:                                panic("rename: linked directory");
        !           975:                        error = itrunc(xp, (u_long)0, IO_SYNC);
        !           976:                }
        !           977:                xp->i_flag |= ICHG;
        !           978:                iput(xp);
        !           979:                xp = NULL;
        !           980:        }
        !           981: 
        !           982:        /*
        !           983:         * 3) Unlink the source.
        !           984:         */
        !           985: unlinkit:
        !           986:        fndp->ni_nameiop &= ~MODMASK;
        !           987:        fndp->ni_nameiop |= LOCKPARENT | LOCKLEAF;
        !           988:        if ((fndp->ni_nameiop & SAVESTART) == 0)
        !           989:                panic("ufs_rename: lost from startdir");
        !           990:        (void) lookup(fndp, p);
        !           991:        if (fndp->ni_vp != NULL) {
        !           992:                xp = VTOI(fndp->ni_vp);
        !           993:                dp = VTOI(fndp->ni_dvp);
        !           994:        } else {
        !           995:                /*
        !           996:                 * From name has disappeared.
        !           997:                 */
        !           998:                if (doingdirectory)
        !           999:                        panic("rename: lost dir entry");
        !          1000:                vrele(ITOV(ip));
        !          1001:                return (0);
        !          1002:        }
        !          1003:        /*
        !          1004:         * Ensure that the directory entry still exists and has not
        !          1005:         * changed while the new name has been entered. If the source is
        !          1006:         * a file then the entry may have been unlinked or renamed. In
        !          1007:         * either case there is no further work to be done. If the source
        !          1008:         * is a directory then it cannot have been rmdir'ed; its link
        !          1009:         * count of three would cause a rmdir to fail with ENOTEMPTY.
        !          1010:         * The IRENAME flag ensures that it cannot be moved by another
        !          1011:         * rename.
        !          1012:         */
        !          1013:        if (xp != ip) {
        !          1014:                if (doingdirectory)
        !          1015:                        panic("rename: lost dir entry");
        !          1016:        } else {
        !          1017:                /*
        !          1018:                 * If the source is a directory with a
        !          1019:                 * new parent, the link count of the old
        !          1020:                 * parent directory must be decremented
        !          1021:                 * and ".." set to point to the new parent.
        !          1022:                 */
        !          1023:                if (doingdirectory && newparent) {
        !          1024:                        dp->i_nlink--;
        !          1025:                        dp->i_flag |= ICHG;
        !          1026:                        error = vn_rdwr(UIO_READ, ITOV(xp), (caddr_t)&dirbuf,
        !          1027:                                sizeof (struct dirtemplate), (off_t)0,
        !          1028:                                UIO_SYSSPACE, IO_NODELOCKED, 
        !          1029:                                tndp->ni_cred, (int *)0, (struct proc *)0);
        !          1030:                        if (error == 0) {
        !          1031:                                if (dirbuf.dotdot_namlen != 2 ||
        !          1032:                                    dirbuf.dotdot_name[0] != '.' ||
        !          1033:                                    dirbuf.dotdot_name[1] != '.') {
        !          1034:                                        dirbad(xp, 12, "rename: mangled dir");
        !          1035:                                } else {
        !          1036:                                        dirbuf.dotdot_ino = newparent;
        !          1037:                                        (void) vn_rdwr(UIO_WRITE, ITOV(xp),
        !          1038:                                            (caddr_t)&dirbuf,
        !          1039:                                            sizeof (struct dirtemplate),
        !          1040:                                            (off_t)0, UIO_SYSSPACE,
        !          1041:                                            IO_NODELOCKED|IO_SYNC,
        !          1042:                                            tndp->ni_cred, (int *)0,
        !          1043:                                            (struct proc *)0);
        !          1044:                                        cache_purge(ITOV(dp));
        !          1045:                                }
        !          1046:                        }
        !          1047:                }
        !          1048:                error = dirremove(fndp);
        !          1049:                if (!error) {
        !          1050:                        xp->i_nlink--;
        !          1051:                        xp->i_flag |= ICHG;
        !          1052:                }
        !          1053:                xp->i_flag &= ~IRENAME;
        !          1054:        }
        !          1055:        if (dp)
        !          1056:                vput(ITOV(dp));
        !          1057:        if (xp)
        !          1058:                vput(ITOV(xp));
        !          1059:        vrele(ITOV(ip));
        !          1060:        return (error);
        !          1061: 
        !          1062: bad:
        !          1063:        if (xp)
        !          1064:                vput(ITOV(xp));
        !          1065:        vput(ITOV(dp));
        !          1066: out:
        !          1067:        ip->i_nlink--;
        !          1068:        ip->i_flag |= ICHG;
        !          1069:        vrele(ITOV(ip));
        !          1070:        return (error);
        !          1071: }
        !          1072: 
        !          1073: /*
        !          1074:  * A virgin directory (no blushing please).
        !          1075:  */
        !          1076: struct dirtemplate mastertemplate = {
        !          1077:        0, 12, 1, ".",
        !          1078:        0, DIRBLKSIZ - 12, 2, ".."
        !          1079: };
        !          1080: 
        !          1081: /*
        !          1082:  * Mkdir system call
        !          1083:  */
        !          1084: ufs_mkdir(ndp, vap, p)
        !          1085:        struct nameidata *ndp;
        !          1086:        struct vattr *vap;
        !          1087:        struct proc *p;
        !          1088: {
        !          1089:        register struct inode *ip, *dp;
        !          1090:        struct inode *tip;
        !          1091:        struct vnode *dvp;
        !          1092:        struct dirtemplate dirtemplate;
        !          1093:        int error;
        !          1094:        int dmode;
        !          1095: 
        !          1096: #ifdef DIANOSTIC
        !          1097:        if ((ndp->ni_nameiop & HASBUF) == 0)
        !          1098:                panic("ufs_mkdir: no name");
        !          1099: #endif
        !          1100:        dvp = ndp->ni_dvp;
        !          1101:        dp = VTOI(dvp);
        !          1102:        if ((unsigned short)dp->i_nlink >= LINK_MAX) {
        !          1103:                free(ndp->ni_pnbuf, M_NAMEI);
        !          1104:                iput(dp);
        !          1105:                return (EMLINK);
        !          1106:        }
        !          1107:        dmode = vap->va_mode&0777;
        !          1108:        dmode |= IFDIR;
        !          1109:        /*
        !          1110:         * Must simulate part of maknode here to acquire the inode, but
        !          1111:         * not have it entered in the parent directory. The entry is made
        !          1112:         * later after writing "." and ".." entries.
        !          1113:         */
        !          1114:        if (error = ialloc(dp, dirpref(dp->i_fs), dmode, ndp->ni_cred, &tip)) {
        !          1115:                free(ndp->ni_pnbuf, M_NAMEI);
        !          1116:                iput(dp);
        !          1117:                return (error);
        !          1118:        }
        !          1119:        ip = tip;
        !          1120:        ip->i_uid = ndp->ni_cred->cr_uid;
        !          1121:        ip->i_gid = dp->i_gid;
        !          1122: #ifdef QUOTA
        !          1123:        if ((error = getinoquota(ip)) ||
        !          1124:            (error = chkiq(ip, 1, ndp->ni_cred, 0))) {
        !          1125:                free(ndp->ni_pnbuf, M_NAMEI);
        !          1126:                ifree(ip, ip->i_number, dmode);
        !          1127:                iput(ip);
        !          1128:                iput(dp);
        !          1129:                return (error);
        !          1130:        }
        !          1131: #endif
        !          1132:        ip->i_flag |= IACC|IUPD|ICHG;
        !          1133:        ip->i_mode = dmode;
        !          1134:        ITOV(ip)->v_type = VDIR;        /* Rest init'd in iget() */
        !          1135:        ip->i_nlink = 2;
        !          1136:        error = iupdat(ip, &time, &time, 1);
        !          1137: 
        !          1138:        /*
        !          1139:         * Bump link count in parent directory
        !          1140:         * to reflect work done below.  Should
        !          1141:         * be done before reference is created
        !          1142:         * so reparation is possible if we crash.
        !          1143:         */
        !          1144:        dp->i_nlink++;
        !          1145:        dp->i_flag |= ICHG;
        !          1146:        if (error = iupdat(dp, &time, &time, 1))
        !          1147:                goto bad;
        !          1148: 
        !          1149:        /*
        !          1150:         * Initialize directory with "."
        !          1151:         * and ".." from static template.
        !          1152:         */
        !          1153:        dirtemplate = mastertemplate;
        !          1154:        dirtemplate.dot_ino = ip->i_number;
        !          1155:        dirtemplate.dotdot_ino = dp->i_number;
        !          1156:        error = vn_rdwr(UIO_WRITE, ITOV(ip), (caddr_t)&dirtemplate,
        !          1157:            sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE,
        !          1158:            IO_NODELOCKED|IO_SYNC, ndp->ni_cred, (int *)0, (struct proc *)0);
        !          1159:        if (error) {
        !          1160:                dp->i_nlink--;
        !          1161:                dp->i_flag |= ICHG;
        !          1162:                goto bad;
        !          1163:        }
        !          1164:        if (DIRBLKSIZ > dp->i_fs->fs_fsize) {
        !          1165:                panic("mkdir: blksize");     /* XXX - should grow w/balloc() */
        !          1166:        } else {
        !          1167:                ip->i_size = DIRBLKSIZ;
        !          1168:                ip->i_flag |= ICHG;
        !          1169:        }
        !          1170:        /*
        !          1171:         * Directory all set up, now
        !          1172:         * install the entry for it in
        !          1173:         * the parent directory.
        !          1174:         */
        !          1175:        if (error = direnter(ip, ndp)) {
        !          1176:                dp->i_nlink--;
        !          1177:                dp->i_flag |= ICHG;
        !          1178:        }
        !          1179: bad:
        !          1180:        /*
        !          1181:         * No need to do an explicit itrunc here,
        !          1182:         * vrele will do this for us because we set
        !          1183:         * the link count to 0.
        !          1184:         */
        !          1185:        if (error) {
        !          1186:                ip->i_nlink = 0;
        !          1187:                ip->i_flag |= ICHG;
        !          1188:                iput(ip);
        !          1189:        } else
        !          1190:                ndp->ni_vp = ITOV(ip);
        !          1191:        FREE(ndp->ni_pnbuf, M_NAMEI);
        !          1192:        iput(dp);
        !          1193:        return (error);
        !          1194: }
        !          1195: 
        !          1196: /*
        !          1197:  * Rmdir system call.
        !          1198:  */
        !          1199: ufs_rmdir(ndp, p)
        !          1200:        register struct nameidata *ndp;
        !          1201:        struct proc *p;
        !          1202: {
        !          1203:        register struct inode *ip, *dp;
        !          1204:        int error = 0;
        !          1205: 
        !          1206:        ip = VTOI(ndp->ni_vp);
        !          1207:        dp = VTOI(ndp->ni_dvp);
        !          1208:        /*
        !          1209:         * No rmdir "." please.
        !          1210:         */
        !          1211:        if (dp == ip) {
        !          1212:                vrele(ITOV(dp));
        !          1213:                iput(ip);
        !          1214:                return (EINVAL);
        !          1215:        }
        !          1216:        /*
        !          1217:         * Verify the directory is empty (and valid).
        !          1218:         * (Rmdir ".." won't be valid since
        !          1219:         *  ".." will contain a reference to
        !          1220:         *  the current directory and thus be
        !          1221:         *  non-empty.)
        !          1222:         */
        !          1223:        if (ip->i_nlink != 2 || !dirempty(ip, dp->i_number, ndp->ni_cred)) {
        !          1224:                error = ENOTEMPTY;
        !          1225:                goto out;
        !          1226:        }
        !          1227:        /*
        !          1228:         * Delete reference to directory before purging
        !          1229:         * inode.  If we crash in between, the directory
        !          1230:         * will be reattached to lost+found,
        !          1231:         */
        !          1232:        if (error = dirremove(ndp))
        !          1233:                goto out;
        !          1234:        dp->i_nlink--;
        !          1235:        dp->i_flag |= ICHG;
        !          1236:        cache_purge(ITOV(dp));
        !          1237:        iput(dp);
        !          1238:        ndp->ni_dvp = NULL;
        !          1239:        /*
        !          1240:         * Truncate inode.  The only stuff left
        !          1241:         * in the directory is "." and "..".  The
        !          1242:         * "." reference is inconsequential since
        !          1243:         * we're quashing it.  The ".." reference
        !          1244:         * has already been adjusted above.  We've
        !          1245:         * removed the "." reference and the reference
        !          1246:         * in the parent directory, but there may be
        !          1247:         * other hard links so decrement by 2 and
        !          1248:         * worry about them later.
        !          1249:         */
        !          1250:        ip->i_nlink -= 2;
        !          1251:        error = itrunc(ip, (u_long)0, IO_SYNC);
        !          1252:        cache_purge(ITOV(ip));
        !          1253: out:
        !          1254:        if (ndp->ni_dvp)
        !          1255:                iput(dp);
        !          1256:        iput(ip);
        !          1257:        return (error);
        !          1258: }
        !          1259: 
        !          1260: /*
        !          1261:  * symlink -- make a symbolic link
        !          1262:  */
        !          1263: ufs_symlink(ndp, vap, target, p)
        !          1264:        struct nameidata *ndp;
        !          1265:        struct vattr *vap;
        !          1266:        char *target;
        !          1267:        struct proc *p;
        !          1268: {
        !          1269:        struct inode *ip;
        !          1270:        int error;
        !          1271: 
        !          1272:        error = maknode(IFLNK | vap->va_mode, ndp, &ip);
        !          1273:        if (error)
        !          1274:                return (error);
        !          1275:        error = vn_rdwr(UIO_WRITE, ITOV(ip), target, strlen(target), (off_t)0,
        !          1276:                UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0,
        !          1277:                (struct proc *)0);
        !          1278:        iput(ip);
        !          1279:        return (error);
        !          1280: }
        !          1281: 
        !          1282: /*
        !          1283:  * Vnode op for read and write
        !          1284:  */
        !          1285: ufs_readdir(vp, uio, cred, eofflagp)
        !          1286:        struct vnode *vp;
        !          1287:        register struct uio *uio;
        !          1288:        struct ucred *cred;
        !          1289:        int *eofflagp;
        !          1290: {
        !          1291:        int count, lost, error;
        !          1292: 
        !          1293:        count = uio->uio_resid;
        !          1294:        count &= ~(DIRBLKSIZ - 1);
        !          1295:        lost = uio->uio_resid - count;
        !          1296:        if (count < DIRBLKSIZ || (uio->uio_offset & (DIRBLKSIZ -1)))
        !          1297:                return (EINVAL);
        !          1298:        uio->uio_resid = count;
        !          1299:        uio->uio_iov->iov_len = count;
        !          1300:        error = ufs_read(vp, uio, 0, cred);
        !          1301:        uio->uio_resid += lost;
        !          1302:        if ((VTOI(vp)->i_size - uio->uio_offset) <= 0)
        !          1303:                *eofflagp = 1;
        !          1304:        else
        !          1305:                *eofflagp = 0;
        !          1306:        return (error);
        !          1307: }
        !          1308: 
        !          1309: /*
        !          1310:  * Return target name of a symbolic link
        !          1311:  */
        !          1312: ufs_readlink(vp, uiop, cred)
        !          1313:        struct vnode *vp;
        !          1314:        struct uio *uiop;
        !          1315:        struct ucred *cred;
        !          1316: {
        !          1317: 
        !          1318:        return (ufs_read(vp, uiop, 0, cred));
        !          1319: }
        !          1320: 
        !          1321: /*
        !          1322:  * Ufs abort op, called after namei() when a CREATE/DELETE isn't actually
        !          1323:  * done. If a buffer has been saved in anticipation of a CREATE, delete it.
        !          1324:  */
        !          1325: /* ARGSUSED */
        !          1326: ufs_abortop(ndp)
        !          1327:        struct nameidata *ndp;
        !          1328: {
        !          1329: 
        !          1330:        if ((ndp->ni_nameiop & (HASBUF | SAVESTART)) == HASBUF)
        !          1331:                FREE(ndp->ni_pnbuf, M_NAMEI);
        !          1332:        return (0);
        !          1333: }
        !          1334: 
        !          1335: /*
        !          1336:  * Lock an inode.
        !          1337:  */
        !          1338: ufs_lock(vp)
        !          1339:        struct vnode *vp;
        !          1340: {
        !          1341:        register struct inode *ip = VTOI(vp);
        !          1342: 
        !          1343:        ILOCK(ip);
        !          1344:        return (0);
        !          1345: }
        !          1346: 
        !          1347: /*
        !          1348:  * Unlock an inode.
        !          1349:  */
        !          1350: ufs_unlock(vp)
        !          1351:        struct vnode *vp;
        !          1352: {
        !          1353:        register struct inode *ip = VTOI(vp);
        !          1354: 
        !          1355:        if (!(ip->i_flag & ILOCKED))
        !          1356:                panic("ufs_unlock NOT LOCKED");
        !          1357:        IUNLOCK(ip);
        !          1358:        return (0);
        !          1359: }
        !          1360: 
        !          1361: /*
        !          1362:  * Check for a locked inode.
        !          1363:  */
        !          1364: ufs_islocked(vp)
        !          1365:        struct vnode *vp;
        !          1366: {
        !          1367: 
        !          1368:        if (VTOI(vp)->i_flag & ILOCKED)
        !          1369:                return (1);
        !          1370:        return (0);
        !          1371: }
        !          1372: 
        !          1373: /*
        !          1374:  * Get access to bmap
        !          1375:  */
        !          1376: ufs_bmap(vp, bn, vpp, bnp)
        !          1377:        struct vnode *vp;
        !          1378:        daddr_t bn;
        !          1379:        struct vnode **vpp;
        !          1380:        daddr_t *bnp;
        !          1381: {
        !          1382:        struct inode *ip = VTOI(vp);
        !          1383: 
        !          1384:        if (vpp != NULL)
        !          1385:                *vpp = ip->i_devvp;
        !          1386:        if (bnp == NULL)
        !          1387:                return (0);
        !          1388:        return (bmap(ip, bn, bnp));
        !          1389: }
        !          1390: 
        !          1391: /*
        !          1392:  * Calculate the logical to physical mapping if not done already,
        !          1393:  * then call the device strategy routine.
        !          1394:  */
        !          1395: int checkoverlap = 0;
        !          1396: 
        !          1397: ufs_strategy(bp)
        !          1398:        register struct buf *bp;
        !          1399: {
        !          1400:        register struct inode *ip = VTOI(bp->b_vp);
        !          1401:        struct vnode *vp;
        !          1402:        int error;
        !          1403: 
        !          1404:        if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR)
        !          1405:                panic("ufs_strategy: spec");
        !          1406:        if (bp->b_blkno == bp->b_lblkno) {
        !          1407:                if (error = bmap(ip, bp->b_lblkno, &bp->b_blkno))
        !          1408:                        return (error);
        !          1409:                if ((long)bp->b_blkno == -1)
        !          1410:                        clrbuf(bp);
        !          1411:        }
        !          1412:        if ((long)bp->b_blkno == -1) {
        !          1413:                biodone(bp);
        !          1414:                return (0);
        !          1415:        }
        !          1416: #ifdef DIAGNOSTIC
        !          1417:        if (checkoverlap) {
        !          1418:                register struct buf *ep;
        !          1419:                struct buf *ebp;
        !          1420:                daddr_t start, last;
        !          1421: 
        !          1422:                ebp = &buf[nbuf];
        !          1423:                start = bp->b_blkno;
        !          1424:                last = start + btodb(bp->b_bcount) - 1;
        !          1425:                for (ep = buf; ep < ebp; ep++) {
        !          1426:                        if (ep == bp || (ep->b_flags & B_INVAL) ||
        !          1427:                            ep->b_vp == NULLVP)
        !          1428:                                continue;
        !          1429:                        if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, (daddr_t)0))
        !          1430:                                continue;
        !          1431:                        if (vp != ip->i_devvp)
        !          1432:                                continue;
        !          1433:                        /* look for overlap */
        !          1434:                        if (ep->b_bcount == 0 || ep->b_blkno > last ||
        !          1435:                            ep->b_blkno + btodb(ep->b_bcount) <= start)
        !          1436:                                continue;
        !          1437:                        vprint("Disk overlap", vp);
        !          1438:                        printf("\tstart %d, end %d overlap start %d, end %d\n",
        !          1439:                                start, last, ep->b_blkno,
        !          1440:                                ep->b_blkno + btodb(ep->b_bcount) - 1);
        !          1441:                        panic("Disk buffer overlap");
        !          1442:                }
        !          1443:        }
        !          1444: #endif /* DIAGNOSTIC */
        !          1445:        vp = ip->i_devvp;
        !          1446:        bp->b_dev = vp->v_rdev;
        !          1447:        (*(vp->v_op->vop_strategy))(bp);
        !          1448:        return (0);
        !          1449: }
        !          1450: 
        !          1451: /*
        !          1452:  * Print out the contents of an inode.
        !          1453:  */
        !          1454: ufs_print(vp)
        !          1455:        struct vnode *vp;
        !          1456: {
        !          1457:        register struct inode *ip = VTOI(vp);
        !          1458: 
        !          1459:        printf("tag VT_UFS, ino %d, on dev %d, %d", ip->i_number,
        !          1460:                major(ip->i_dev), minor(ip->i_dev));
        !          1461: #ifdef FIFO
        !          1462:        if (vp->v_type == VFIFO)
        !          1463:                fifo_printinfo(vp);
        !          1464: #endif /* FIFO */
        !          1465:        printf("%s\n", (ip->i_flag & ILOCKED) ? " (LOCKED)" : "");
        !          1466:        if (ip->i_spare0 == 0)
        !          1467:                return;
        !          1468:        printf("\towner pid %d", ip->i_spare0);
        !          1469:        if (ip->i_spare1)
        !          1470:                printf(" waiting pid %d", ip->i_spare1);
        !          1471:        printf("\n");
        !          1472: }
        !          1473: 
        !          1474: /*
        !          1475:  * Read wrapper for special devices.
        !          1476:  */
        !          1477: ufsspec_read(vp, uio, ioflag, cred)
        !          1478:        struct vnode *vp;
        !          1479:        struct uio *uio;
        !          1480:        int ioflag;
        !          1481:        struct ucred *cred;
        !          1482: {
        !          1483: 
        !          1484:        /*
        !          1485:         * Set access flag.
        !          1486:         */
        !          1487:        VTOI(vp)->i_flag |= IACC;
        !          1488:        return (spec_read(vp, uio, ioflag, cred));
        !          1489: }
        !          1490: 
        !          1491: /*
        !          1492:  * Write wrapper for special devices.
        !          1493:  */
        !          1494: ufsspec_write(vp, uio, ioflag, cred)
        !          1495:        struct vnode *vp;
        !          1496:        struct uio *uio;
        !          1497:        int ioflag;
        !          1498:        struct ucred *cred;
        !          1499: {
        !          1500: 
        !          1501:        /*
        !          1502:         * Set update and change flags.
        !          1503:         */
        !          1504:        VTOI(vp)->i_flag |= IUPD|ICHG;
        !          1505:        return (spec_write(vp, uio, ioflag, cred));
        !          1506: }
        !          1507: 
        !          1508: /*
        !          1509:  * Close wrapper for special devices.
        !          1510:  *
        !          1511:  * Update the times on the inode then do device close.
        !          1512:  */
        !          1513: ufsspec_close(vp, fflag, cred, p)
        !          1514:        struct vnode *vp;
        !          1515:        int fflag;
        !          1516:        struct ucred *cred;
        !          1517:        struct proc *p;
        !          1518: {
        !          1519:        register struct inode *ip = VTOI(vp);
        !          1520: 
        !          1521:        if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
        !          1522:                ITIMES(ip, &time, &time);
        !          1523:        return (spec_close(vp, fflag, cred, p));
        !          1524: }
        !          1525: 
        !          1526: #ifdef FIFO
        !          1527: /*
        !          1528:  * Read wrapper for fifo's
        !          1529:  */
        !          1530: ufsfifo_read(vp, uio, ioflag, cred)
        !          1531:        struct vnode *vp;
        !          1532:        struct uio *uio;
        !          1533:        int ioflag;
        !          1534:        struct ucred *cred;
        !          1535: {
        !          1536: 
        !          1537:        /*
        !          1538:         * Set access flag.
        !          1539:         */
        !          1540:        VTOI(vp)->i_flag |= IACC;
        !          1541:        return (fifo_read(vp, uio, ioflag, cred));
        !          1542: }
        !          1543: 
        !          1544: /*
        !          1545:  * Write wrapper for fifo's.
        !          1546:  */
        !          1547: ufsfifo_write(vp, uio, ioflag, cred)
        !          1548:        struct vnode *vp;
        !          1549:        struct uio *uio;
        !          1550:        int ioflag;
        !          1551:        struct ucred *cred;
        !          1552: {
        !          1553: 
        !          1554:        /*
        !          1555:         * Set update and change flags.
        !          1556:         */
        !          1557:        VTOI(vp)->i_flag |= IUPD|ICHG;
        !          1558:        return (fifo_write(vp, uio, ioflag, cred));
        !          1559: }
        !          1560: 
        !          1561: /*
        !          1562:  * Close wrapper for fifo's.
        !          1563:  *
        !          1564:  * Update the times on the inode then do device close.
        !          1565:  */
        !          1566: ufsfifo_close(vp, fflag, cred, p)
        !          1567:        struct vnode *vp;
        !          1568:        int fflag;
        !          1569:        struct ucred *cred;
        !          1570:        struct proc *p;
        !          1571: {
        !          1572:        register struct inode *ip = VTOI(vp);
        !          1573: 
        !          1574:        if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
        !          1575:                ITIMES(ip, &time, &time);
        !          1576:        return (fifo_close(vp, fflag, cred, p));
        !          1577: }
        !          1578: #endif /* FIFO */
        !          1579: 
        !          1580: /*
        !          1581:  * Allocate a new inode.
        !          1582:  */
        !          1583: maknode(mode, ndp, ipp)
        !          1584:        int mode;
        !          1585:        register struct nameidata *ndp;
        !          1586:        struct inode **ipp;
        !          1587: {
        !          1588:        register struct inode *ip;
        !          1589:        struct inode *tip;
        !          1590:        register struct inode *pdir = VTOI(ndp->ni_dvp);
        !          1591:        ino_t ipref;
        !          1592:        int error;
        !          1593: 
        !          1594: #ifdef DIANOSTIC
        !          1595:        if ((ndp->ni_nameiop & HASBUF) == 0)
        !          1596:                panic("maknode: no name");
        !          1597: #endif
        !          1598:        *ipp = 0;
        !          1599:        if ((mode & IFMT) == 0)
        !          1600:                mode |= IFREG;
        !          1601:        if ((mode & IFMT) == IFDIR)
        !          1602:                ipref = dirpref(pdir->i_fs);
        !          1603:        else
        !          1604:                ipref = pdir->i_number;
        !          1605:        if (error = ialloc(pdir, ipref, mode, ndp->ni_cred, &tip)) {
        !          1606:                free(ndp->ni_pnbuf, M_NAMEI);
        !          1607:                iput(pdir);
        !          1608:                return (error);
        !          1609:        }
        !          1610:        ip = tip;
        !          1611:        ip->i_uid = ndp->ni_cred->cr_uid;
        !          1612:        ip->i_gid = pdir->i_gid;
        !          1613: #ifdef QUOTA
        !          1614:        if ((error = getinoquota(ip)) ||
        !          1615:            (error = chkiq(ip, 1, ndp->ni_cred, 0))) {
        !          1616:                free(ndp->ni_pnbuf, M_NAMEI);
        !          1617:                ifree(ip, ip->i_number, mode);
        !          1618:                iput(ip);
        !          1619:                iput(pdir);
        !          1620:                return (error);
        !          1621:        }
        !          1622: #endif
        !          1623:        ip->i_flag |= IACC|IUPD|ICHG;
        !          1624:        ip->i_mode = mode;
        !          1625:        ITOV(ip)->v_type = IFTOVT(mode);        /* Rest init'd in iget() */
        !          1626:        ip->i_nlink = 1;
        !          1627:        if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, ndp->ni_cred) &&
        !          1628:            suser(ndp->ni_cred, NULL))
        !          1629:                ip->i_mode &= ~ISGID;
        !          1630: 
        !          1631:        /*
        !          1632:         * Make sure inode goes to disk before directory entry.
        !          1633:         */
        !          1634:        if (error = iupdat(ip, &time, &time, 1))
        !          1635:                goto bad;
        !          1636:        if (error = direnter(ip, ndp))
        !          1637:                goto bad;
        !          1638:        if ((ndp->ni_nameiop & SAVESTART) == 0)
        !          1639:                FREE(ndp->ni_pnbuf, M_NAMEI);
        !          1640:        iput(pdir);
        !          1641:        *ipp = ip;
        !          1642:        return (0);
        !          1643: 
        !          1644: bad:
        !          1645:        /*
        !          1646:         * Write error occurred trying to update the inode
        !          1647:         * or the directory so must deallocate the inode.
        !          1648:         */
        !          1649:        free(ndp->ni_pnbuf, M_NAMEI);
        !          1650:        iput(pdir);
        !          1651:        ip->i_nlink = 0;
        !          1652:        ip->i_flag |= ICHG;
        !          1653:        iput(ip);
        !          1654:        return (error);
        !          1655: }
        !          1656: 
        !          1657: /*
        !          1658:  * Advisory record locking support
        !          1659:  */
        !          1660: ufs_advlock(vp, id, op, fl, flags)
        !          1661:        struct vnode *vp;
        !          1662:        caddr_t id;
        !          1663:        int op;
        !          1664:        register struct flock *fl;
        !          1665:        int flags;
        !          1666: {
        !          1667:        register struct inode *ip = VTOI(vp);
        !          1668:        register struct lockf *lock;
        !          1669:        off_t start, end;
        !          1670:        int error;
        !          1671: 
        !          1672:        /*
        !          1673:         * Avoid the common case of unlocking when inode has no locks.
        !          1674:         */
        !          1675:        if (ip->i_lockf == (struct lockf *)0) {
        !          1676:                if (op != F_SETLK) {
        !          1677:                        fl->l_type = F_UNLCK;
        !          1678:                        return (0);
        !          1679:                }
        !          1680:        }
        !          1681:        /*
        !          1682:         * Convert the flock structure into a start and end.
        !          1683:         */
        !          1684:        switch (fl->l_whence) {
        !          1685: 
        !          1686:        case SEEK_SET:
        !          1687:        case SEEK_CUR:
        !          1688:                /*
        !          1689:                 * Caller is responsible for adding any necessary offset
        !          1690:                 * when SEEK_CUR is used.
        !          1691:                 */
        !          1692:                start = fl->l_start;
        !          1693:                break;
        !          1694: 
        !          1695:        case SEEK_END:
        !          1696:                start = ip->i_size + fl->l_start;
        !          1697:                break;
        !          1698: 
        !          1699:        default:
        !          1700:                return (EINVAL);
        !          1701:        }
        !          1702:        if (start < 0)
        !          1703:                return (EINVAL);
        !          1704:        if (fl->l_len == 0)
        !          1705:                end = -1;
        !          1706:        else
        !          1707:                end = start + fl->l_len - 1;
        !          1708:        /*
        !          1709:         * Create the lockf structure
        !          1710:         */
        !          1711:        MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK);
        !          1712:        lock->lf_start = start;
        !          1713:        lock->lf_end = end;
        !          1714:        lock->lf_id = id;
        !          1715:        lock->lf_inode = ip;
        !          1716:        lock->lf_type = fl->l_type;
        !          1717:        lock->lf_next = (struct lockf *)0;
        !          1718:        lock->lf_block = (struct lockf *)0;
        !          1719:        lock->lf_flags = flags;
        !          1720:        /*
        !          1721:         * Do the requested operation.
        !          1722:         */
        !          1723:        switch(op) {
        !          1724:        case F_SETLK:
        !          1725:                return (lf_setlock(lock));
        !          1726: 
        !          1727:        case F_UNLCK:
        !          1728:                error = lf_clearlock(lock);
        !          1729:                FREE(lock, M_LOCKF);
        !          1730:                return (error);
        !          1731: 
        !          1732:        case F_GETLK:
        !          1733:                error = lf_getlock(lock, fl);
        !          1734:                FREE(lock, M_LOCKF);
        !          1735:                return (error);
        !          1736:        
        !          1737:        default:
        !          1738:                free(lock, M_LOCKF);
        !          1739:                return (EINVAL);
        !          1740:        }
        !          1741:        /* NOTREACHED */
        !          1742: }
        !          1743: 
        !          1744: /*
        !          1745:  * Global vfs data structures for ufs
        !          1746:  */
        !          1747: struct vnodeops ufs_vnodeops = {
        !          1748:        ufs_lookup,             /* lookup */
        !          1749:        ufs_create,             /* create */
        !          1750:        ufs_mknod,              /* mknod */
        !          1751:        ufs_open,               /* open */
        !          1752:        ufs_close,              /* close */
        !          1753:        ufs_access,             /* access */
        !          1754:        ufs_getattr,            /* getattr */
        !          1755:        ufs_setattr,            /* setattr */
        !          1756:        ufs_read,               /* read */
        !          1757:        ufs_write,              /* write */
        !          1758:        ufs_ioctl,              /* ioctl */
        !          1759:        ufs_select,             /* select */
        !          1760:        ufs_mmap,               /* mmap */
        !          1761:        ufs_fsync,              /* fsync */
        !          1762:        ufs_seek,               /* seek */
        !          1763:        ufs_remove,             /* remove */
        !          1764:        ufs_link,               /* link */
        !          1765:        ufs_rename,             /* rename */
        !          1766:        ufs_mkdir,              /* mkdir */
        !          1767:        ufs_rmdir,              /* rmdir */
        !          1768:        ufs_symlink,            /* symlink */
        !          1769:        ufs_readdir,            /* readdir */
        !          1770:        ufs_readlink,           /* readlink */
        !          1771:        ufs_abortop,            /* abortop */
        !          1772:        ufs_inactive,           /* inactive */
        !          1773:        ufs_reclaim,            /* reclaim */
        !          1774:        ufs_lock,               /* lock */
        !          1775:        ufs_unlock,             /* unlock */
        !          1776:        ufs_bmap,               /* bmap */
        !          1777:        ufs_strategy,           /* strategy */
        !          1778:        ufs_print,              /* print */
        !          1779:        ufs_islocked,           /* islocked */
        !          1780:        ufs_advlock,            /* advlock */
        !          1781: };
        !          1782: 
        !          1783: struct vnodeops spec_inodeops = {
        !          1784:        spec_lookup,            /* lookup */
        !          1785:        spec_create,            /* create */
        !          1786:        spec_mknod,             /* mknod */
        !          1787:        spec_open,              /* open */
        !          1788:        ufsspec_close,          /* close */
        !          1789:        ufs_access,             /* access */
        !          1790:        ufs_getattr,            /* getattr */
        !          1791:        ufs_setattr,            /* setattr */
        !          1792:        ufsspec_read,           /* read */
        !          1793:        ufsspec_write,          /* write */
        !          1794:        spec_ioctl,             /* ioctl */
        !          1795:        spec_select,            /* select */
        !          1796:        spec_mmap,              /* mmap */
        !          1797:        spec_fsync,             /* fsync */
        !          1798:        spec_seek,              /* seek */
        !          1799:        spec_remove,            /* remove */
        !          1800:        spec_link,              /* link */
        !          1801:        spec_rename,            /* rename */
        !          1802:        spec_mkdir,             /* mkdir */
        !          1803:        spec_rmdir,             /* rmdir */
        !          1804:        spec_symlink,           /* symlink */
        !          1805:        spec_readdir,           /* readdir */
        !          1806:        spec_readlink,          /* readlink */
        !          1807:        spec_abortop,           /* abortop */
        !          1808:        ufs_inactive,           /* inactive */
        !          1809:        ufs_reclaim,            /* reclaim */
        !          1810:        ufs_lock,               /* lock */
        !          1811:        ufs_unlock,             /* unlock */
        !          1812:        spec_bmap,              /* bmap */
        !          1813:        spec_strategy,          /* strategy */
        !          1814:        ufs_print,              /* print */
        !          1815:        ufs_islocked,           /* islocked */
        !          1816:        spec_advlock,           /* advlock */
        !          1817: };
        !          1818: 
        !          1819: #ifdef FIFO
        !          1820: struct vnodeops fifo_inodeops = {
        !          1821:        fifo_lookup,            /* lookup */
        !          1822:        fifo_create,            /* create */
        !          1823:        fifo_mknod,             /* mknod */
        !          1824:        fifo_open,              /* open */
        !          1825:        ufsfifo_close,          /* close */
        !          1826:        ufs_access,             /* access */
        !          1827:        ufs_getattr,            /* getattr */
        !          1828:        ufs_setattr,            /* setattr */
        !          1829:        ufsfifo_read,           /* read */
        !          1830:        ufsfifo_write,          /* write */
        !          1831:        fifo_ioctl,             /* ioctl */
        !          1832:        fifo_select,            /* select */
        !          1833:        fifo_mmap,              /* mmap */
        !          1834:        fifo_fsync,             /* fsync */
        !          1835:        fifo_seek,              /* seek */
        !          1836:        fifo_remove,            /* remove */
        !          1837:        fifo_link,              /* link */
        !          1838:        fifo_rename,            /* rename */
        !          1839:        fifo_mkdir,             /* mkdir */
        !          1840:        fifo_rmdir,             /* rmdir */
        !          1841:        fifo_symlink,           /* symlink */
        !          1842:        fifo_readdir,           /* readdir */
        !          1843:        fifo_readlink,          /* readlink */
        !          1844:        fifo_abortop,           /* abortop */
        !          1845:        ufs_inactive,           /* inactive */
        !          1846:        ufs_reclaim,            /* reclaim */
        !          1847:        ufs_lock,               /* lock */
        !          1848:        ufs_unlock,             /* unlock */
        !          1849:        fifo_bmap,              /* bmap */
        !          1850:        fifo_strategy,          /* strategy */
        !          1851:        ufs_print,              /* print */
        !          1852:        ufs_islocked,           /* islocked */
        !          1853:        fifo_advlock,           /* advlock */
        !          1854: };
        !          1855: #endif /* FIFO */
        !          1856: 
        !          1857: enum vtype iftovt_tab[16] = {
        !          1858:        VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
        !          1859:        VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
        !          1860: };
        !          1861: int    vttoif_tab[9] = {
        !          1862:        0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFIFO, IFMT,
        !          1863: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.