Return to lfs_vnops.c CVS log

Up to [Apple Darwin 0.x] / kernel / bsd / ufs / lfs

Annotation of kernel/bsd/ufs/lfs/lfs_vnops.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
        !             7:  * Reserved.  This file contains Original Code and/or Modifications of
        !             8:  * Original Code as defined in and that are subject to the Apple Public
        !             9:  * Source License Version 1.1 (the "License").  You may not use this file
        !            10:  * except in compliance with the License.  Please obtain a copy of the
        !            11:  * License at http://www.apple.com/publicsource and read it before using
        !            12:  * this file.
        !            13:  * 
        !            14:  * The Original Code and all software distributed under the License are
        !            15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            19:  * License for the specific language governing rights and limitations
        !            20:  * under the License.
        !            21:  * 
        !            22:  * @APPLE_LICENSE_HEADER_END@
        !            23:  */
        !            24: 
        !            25: /*     $NetBSD: lfs_vnops.c,v 1.6 1994/12/14 13:03:50 mycroft Exp $    */
        !            26: 
        !            27: /*
        !            28:  * Copyright (c) 1986, 1989, 1991, 1993
        !            29:  *     The Regents of the University of California.  All rights reserved.
        !            30:  *
        !            31:  * Redistribution and use in source and binary forms, with or without
        !            32:  * modification, are permitted provided that the following conditions
        !            33:  * are met:
        !            34:  * 1. Redistributions of source code must retain the above copyright
        !            35:  *    notice, this list of conditions and the following disclaimer.
        !            36:  * 2. Redistributions in binary form must reproduce the above copyright
        !            37:  *    notice, this list of conditions and the following disclaimer in the
        !            38:  *    documentation and/or other materials provided with the distribution.
        !            39:  * 3. All advertising materials mentioning features or use of this software
        !            40:  *    must display the following acknowledgement:
        !            41:  *     This product includes software developed by the University of
        !            42:  *     California, Berkeley and its contributors.
        !            43:  * 4. Neither the name of the University nor the names of its contributors
        !            44:  *    may be used to endorse or promote products derived from this software
        !            45:  *    without specific prior written permission.
        !            46:  *
        !            47:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            48:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            49:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            50:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            51:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            52:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            53:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            54:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            55:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            56:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            57:  * SUCH DAMAGE.
        !            58:  *
        !            59:  *     @(#)lfs_vnops.c 8.8 (Berkeley) 8/10/94
        !            60:  */
        !            61: 
        !            62: #include <sys/param.h>
        !            63: #include <sys/systm.h>
        !            64: #include <sys/namei.h>
        !            65: #include <sys/resourcevar.h>
        !            66: #include <sys/kernel.h>
        !            67: #include <sys/file.h>
        !            68: #include <sys/stat.h>
        !            69: #include <sys/buf.h>
        !            70: #include <sys/proc.h>
        !            71: #include <sys/conf.h>
        !            72: #include <sys/mount.h>
        !            73: #include <sys/vnode.h>
        !            74: #include <sys/malloc.h>
        !            75: 
        !            76: #include <vm/vm.h>
        !            77: 
        !            78: #include <miscfs/specfs/specdev.h>
        !            79: #include <miscfs/fifofs/fifo.h>
        !            80: 
        !            81: #include <ufs/ufs/quota.h>
        !            82: #include <ufs/ufs/inode.h>
        !            83: #include <ufs/ufs/dir.h>
        !            84: #include <ufs/ufs/ufsmount.h>
        !            85: #include <ufs/ufs/ufs_extern.h>
        !            86: 
        !            87: #include <ufs/lfs/lfs.h>
        !            88: #include <ufs/lfs/lfs_extern.h>
        !            89: 
        !            90: /* Global vfs data structures for lfs. */
        !            91: int (**lfs_vnodeop_p)();
        !            92: struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
        !            93:        { &vop_default_desc, vn_default_error },
        !            94:        { &vop_lookup_desc, ufs_lookup },               /* lookup */
        !            95:        { &vop_create_desc, ufs_create },               /* create */
        !            96:        { &vop_whiteout_desc, ufs_whiteout },           /* whiteout */
        !            97:        { &vop_mknod_desc, ufs_mknod },                 /* mknod */
        !            98:        { &vop_open_desc, ufs_open },                   /* open */
        !            99:        { &vop_close_desc, lfs_close },                 /* close */
        !           100:        { &vop_access_desc, ufs_access },               /* access */
        !           101:        { &vop_getattr_desc, lfs_getattr },             /* getattr */
        !           102:        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        !           103:        { &vop_read_desc, lfs_read },                   /* read */
        !           104:        { &vop_write_desc, lfs_write },                 /* write */
        !           105:        { &vop_lease_desc, ufs_lease_check },           /* lease */
        !           106:        { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
        !           107:        { &vop_select_desc, ufs_select },               /* select */
        !           108:        { &vop_mmap_desc, ufs_mmap },                   /* mmap */
        !           109:        { &vop_fsync_desc, lfs_fsync },                 /* fsync */
        !           110:        { &vop_seek_desc, ufs_seek },                   /* seek */
        !           111:        { &vop_remove_desc, ufs_remove },               /* remove */
        !           112:        { &vop_link_desc, ufs_link },                   /* link */
        !           113:        { &vop_rename_desc, ufs_rename },               /* rename */
        !           114:        { &vop_mkdir_desc, ufs_mkdir },                 /* mkdir */
        !           115:        { &vop_rmdir_desc, ufs_rmdir },                 /* rmdir */
        !           116:        { &vop_symlink_desc, ufs_symlink },             /* symlink */
        !           117:        { &vop_readdir_desc, ufs_readdir },             /* readdir */
        !           118:        { &vop_readlink_desc, ufs_readlink },           /* readlink */
        !           119:        { &vop_abortop_desc, ufs_abortop },             /* abortop */
        !           120:        { &vop_inactive_desc, lfs_inactive },           /* inactive */
        !           121:        { &vop_reclaim_desc, lfs_reclaim },             /* reclaim */
        !           122:        { &vop_lock_desc, ufs_lock },                   /* lock */
        !           123:        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        !           124:        { &vop_bmap_desc, ufs_bmap },                   /* bmap */
        !           125:        { &vop_strategy_desc, ufs_strategy },           /* strategy */
        !           126:        { &vop_print_desc, ufs_print },                 /* print */
        !           127:        { &vop_islocked_desc, ufs_islocked },           /* islocked */
        !           128:        { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */
        !           129:        { &vop_advlock_desc, ufs_advlock },             /* advlock */
        !           130:        { &vop_blkatoff_desc, lfs_blkatoff },           /* blkatoff */
        !           131:        { &vop_valloc_desc, lfs_valloc },               /* valloc */
        !           132:        { &vop_vfree_desc, lfs_vfree },                 /* vfree */
        !           133:        { &vop_truncate_desc, lfs_truncate },           /* truncate */
        !           134:        { &vop_update_desc, lfs_update },               /* update */
        !           135:        { &vop_bwrite_desc, lfs_bwrite },               /* bwrite */
        !           136:        { &vop_pgrd_desc, lfs_pgrg },                   /* pager read */
        !           137:        { &vop_pgwr_desc, lfs_pgwr },                   /* pager write */
        !           138:        { (struct vnodeop_desc*)NULL, (int(*)())NULL }
        !           139: };
        !           140: struct vnodeopv_desc lfs_vnodeop_opv_desc =
        !           141:        { &lfs_vnodeop_p, lfs_vnodeop_entries };
        !           142: 
        !           143: int (**lfs_specop_p)();
        !           144: struct vnodeopv_entry_desc lfs_specop_entries[] = {
        !           145:        { &vop_default_desc, vn_default_error },
        !           146:        { &vop_lookup_desc, spec_lookup },              /* lookup */
        !           147:        { &vop_create_desc, spec_create },              /* create */
        !           148:        { &vop_mknod_desc, spec_mknod },                /* mknod */
        !           149:        { &vop_open_desc, spec_open },                  /* open */
        !           150:        { &vop_close_desc, ufsspec_close },             /* close */
        !           151:        { &vop_access_desc, ufs_access },               /* access */
        !           152:        { &vop_getattr_desc, lfs_getattr },             /* getattr */
        !           153:        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        !           154:        { &vop_read_desc, ufsspec_read },               /* read */
        !           155:        { &vop_write_desc, ufsspec_write },             /* write */
        !           156:        { &vop_lease_desc, spec_lease_check },          /* lease */
        !           157:        { &vop_ioctl_desc, spec_ioctl },                /* ioctl */
        !           158:        { &vop_select_desc, spec_select },              /* select */
        !           159:        { &vop_mmap_desc, spec_mmap },                  /* mmap */
        !           160:        { &vop_fsync_desc, spec_fsync },                /* fsync */
        !           161:        { &vop_seek_desc, spec_seek },                  /* seek */
        !           162:        { &vop_remove_desc, spec_remove },              /* remove */
        !           163:        { &vop_link_desc, spec_link },                  /* link */
        !           164:        { &vop_rename_desc, spec_rename },              /* rename */
        !           165:        { &vop_mkdir_desc, spec_mkdir },                /* mkdir */
        !           166:        { &vop_rmdir_desc, spec_rmdir },                /* rmdir */
        !           167:        { &vop_symlink_desc, spec_symlink },            /* symlink */
        !           168:        { &vop_readdir_desc, spec_readdir },            /* readdir */
        !           169:        { &vop_readlink_desc, spec_readlink },          /* readlink */
        !           170:        { &vop_abortop_desc, spec_abortop },            /* abortop */
        !           171:        { &vop_inactive_desc, lfs_inactive },           /* inactive */
        !           172:        { &vop_reclaim_desc, lfs_reclaim },             /* reclaim */
        !           173:        { &vop_lock_desc, ufs_lock },                   /* lock */
        !           174:        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        !           175:        { &vop_bmap_desc, spec_bmap },                  /* bmap */
        !           176:        { &vop_strategy_desc, spec_strategy },          /* strategy */
        !           177:        { &vop_print_desc, ufs_print },                 /* print */
        !           178:        { &vop_islocked_desc, ufs_islocked },           /* islocked */
        !           179:        { &vop_pathconf_desc, spec_pathconf },          /* pathconf */
        !           180:        { &vop_advlock_desc, spec_advlock },            /* advlock */
        !           181:        { &vop_blkatoff_desc, spec_blkatoff },          /* blkatoff */
        !           182:        { &vop_valloc_desc, spec_valloc },              /* valloc */
        !           183:        { &vop_vfree_desc, lfs_vfree },                 /* vfree */
        !           184:        { &vop_truncate_desc, spec_truncate },          /* truncate */
        !           185:        { &vop_update_desc, lfs_update },               /* update */
        !           186:        { &vop_bwrite_desc, lfs_bwrite },               /* bwrite */
        !           187:        { (struct vnodeop_desc*)NULL, (int(*)())NULL }
        !           188: };
        !           189: struct vnodeopv_desc lfs_specop_opv_desc =
        !           190:        { &lfs_specop_p, lfs_specop_entries };
        !           191: 
        !           192: #ifdef FIFO
        !           193: int (**lfs_fifoop_p)();
        !           194: struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
        !           195:        { &vop_default_desc, vn_default_error },
        !           196:        { &vop_lookup_desc, fifo_lookup },              /* lookup */
        !           197:        { &vop_create_desc, fifo_create },              /* create */
        !           198:        { &vop_mknod_desc, fifo_mknod },                /* mknod */
        !           199:        { &vop_open_desc, fifo_open },                  /* open */
        !           200:        { &vop_close_desc, ufsfifo_close },             /* close */
        !           201:        { &vop_access_desc, ufs_access },               /* access */
        !           202:        { &vop_getattr_desc, lfs_getattr },             /* getattr */
        !           203:        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        !           204:        { &vop_read_desc, ufsfifo_read },               /* read */
        !           205:        { &vop_write_desc, ufsfifo_write },             /* write */
        !           206:        { &vop_lease_desc, fifo_lease_check },          /* lease */
        !           207:        { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
        !           208:        { &vop_select_desc, fifo_select },              /* select */
        !           209:        { &vop_mmap_desc, fifo_mmap },                  /* mmap */
        !           210:        { &vop_fsync_desc, fifo_fsync },                /* fsync */
        !           211:        { &vop_seek_desc, fifo_seek },                  /* seek */
        !           212:        { &vop_remove_desc, fifo_remove },              /* remove */
        !           213:        { &vop_link_desc, fifo_link },                  /* link */
        !           214:        { &vop_rename_desc, fifo_rename },              /* rename */
        !           215:        { &vop_mkdir_desc, fifo_mkdir },                /* mkdir */
        !           216:        { &vop_rmdir_desc, fifo_rmdir },                /* rmdir */
        !           217:        { &vop_symlink_desc, fifo_symlink },            /* symlink */
        !           218:        { &vop_readdir_desc, fifo_readdir },            /* readdir */
        !           219:        { &vop_readlink_desc, fifo_readlink },          /* readlink */
        !           220:        { &vop_abortop_desc, fifo_abortop },            /* abortop */
        !           221:        { &vop_inactive_desc, lfs_inactive },           /* inactive */
        !           222:        { &vop_reclaim_desc, lfs_reclaim },             /* reclaim */
        !           223:        { &vop_lock_desc, ufs_lock },                   /* lock */
        !           224:        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        !           225:        { &vop_bmap_desc, fifo_bmap },                  /* bmap */
        !           226:        { &vop_strategy_desc, fifo_strategy },          /* strategy */
        !           227:        { &vop_print_desc, ufs_print },                 /* print */
        !           228:        { &vop_islocked_desc, ufs_islocked },           /* islocked */
        !           229:        { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
        !           230:        { &vop_advlock_desc, fifo_advlock },            /* advlock */
        !           231:        { &vop_blkatoff_desc, fifo_blkatoff },          /* blkatoff */
        !           232:        { &vop_valloc_desc, fifo_valloc },              /* valloc */
        !           233:        { &vop_vfree_desc, lfs_vfree },                 /* vfree */
        !           234:        { &vop_truncate_desc, fifo_truncate },          /* truncate */
        !           235:        { &vop_update_desc, lfs_update },               /* update */
        !           236:        { &vop_bwrite_desc, lfs_bwrite },               /* bwrite */
        !           237:        { (struct vnodeop_desc*)NULL, (int(*)())NULL }
        !           238: };
        !           239: struct vnodeopv_desc lfs_fifoop_opv_desc =
        !           240:        { &lfs_fifoop_p, lfs_fifoop_entries };
        !           241: #endif /* FIFO */
        !           242: 
        !           243: #define        LFS_READWRITE
        !           244: #include <ufs/ufs/ufs_readwrite.c>
        !           245: #undef LFS_READWRITE
        !           246: 
        !           247: /*
        !           248:  * Synch an open file.
        !           249:  */
        !           250: /* ARGSUSED */
        !           251: lfs_fsync(ap)
        !           252:        struct vop_fsync_args /* {
        !           253:                struct vnode *a_vp;
        !           254:                struct ucred *a_cred;
        !           255:                int a_waitfor;
        !           256:                struct proc *a_p;
        !           257:        } */ *ap;
        !           258: {
        !           259:        struct timeval tv;
        !           260: 
        !           261:        tv = time;
        !           262:        return (VOP_UPDATE(ap->a_vp, &tv, &tv,
        !           263:            ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0));
        !           264: }
        !           265: 
        !           266: /*
        !           267:  * These macros are used to bracket UFS directory ops, so that we can
        !           268:  * identify all the pages touched during directory ops which need to
        !           269:  * be ordered and flushed atomically, so that they may be recovered.
        !           270:  */
        !           271: #define        SET_DIROP(fs) {                                                 \
        !           272:        if ((fs)->lfs_writer)                                           \
        !           273:                tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);  \
        !           274:        ++(fs)->lfs_dirops;                                             \
        !           275:        (fs)->lfs_doifile = 1;                                          \
        !           276: }
        !           277: 
        !           278: #define        SET_ENDOP(fs) {                                                 \
        !           279:        --(fs)->lfs_dirops;                                             \
        !           280:        if (!(fs)->lfs_dirops)                                          \
        !           281:                wakeup(&(fs)->lfs_writer);                              \
        !           282: }
        !           283: 
        !           284: #define        MARK_VNODE(dvp) (dvp)->v_flag |= VDIROP
        !           285: 
        !           286: int
        !           287: lfs_symlink(ap)
        !           288:        struct vop_symlink_args /* {
        !           289:                struct vnode *a_dvp;
        !           290:                struct vnode **a_vpp;
        !           291:                struct componentname *a_cnp;
        !           292:                struct vattr *a_vap;
        !           293:                char *a_target;
        !           294:        } */ *ap;
        !           295: {
        !           296:        int ret;
        !           297: 
        !           298:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           299:        MARK_VNODE(ap->a_dvp);
        !           300:        ret = ufs_symlink(ap);
        !           301:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           302:        return (ret);
        !           303: }
        !           304: 
        !           305: int
        !           306: lfs_mknod(ap)
        !           307:        struct vop_mknod_args /* {
        !           308:                struct vnode *a_dvp;
        !           309:                struct vnode **a_vpp;
        !           310:                struct componentname *a_cnp;
        !           311:                struct vattr *a_vap;
        !           312:        } */ *ap;
        !           313: {
        !           314:        int ret;
        !           315: 
        !           316:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           317:        MARK_VNODE(ap->a_dvp);
        !           318:        ret = ufs_mknod(ap);
        !           319:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           320:        return (ret);
        !           321: }
        !           322: 
        !           323: int
        !           324: lfs_create(ap)
        !           325:        struct vop_create_args /* {
        !           326:                struct vnode *a_dvp;
        !           327:                struct vnode **a_vpp;
        !           328:                struct componentname *a_cnp;
        !           329:                struct vattr *a_vap;
        !           330:        } */ *ap;
        !           331: {
        !           332:        int ret;
        !           333: 
        !           334:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           335:        MARK_VNODE(ap->a_dvp);
        !           336:        ret = ufs_create(ap);
        !           337:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           338:        return (ret);
        !           339: }
        !           340: 
        !           341: int
        !           342: lfs_mkdir(ap)
        !           343:        struct vop_mkdir_args /* {
        !           344:                struct vnode *a_dvp;
        !           345:                struct vnode **a_vpp;
        !           346:                struct componentname *a_cnp;
        !           347:                struct vattr *a_vap;
        !           348:        } */ *ap;
        !           349: {
        !           350:        int ret;
        !           351: 
        !           352:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           353:        MARK_VNODE(ap->a_dvp);
        !           354:        ret = ufs_mkdir(ap);
        !           355:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           356:        return (ret);
        !           357: }
        !           358: 
        !           359: int
        !           360: lfs_remove(ap)
        !           361:        struct vop_remove_args /* {
        !           362:                struct vnode *a_dvp;
        !           363:                struct vnode *a_vp;
        !           364:                struct componentname *a_cnp;
        !           365:        } */ *ap;
        !           366: {
        !           367:        int ret;
        !           368: 
        !           369:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           370:        MARK_VNODE(ap->a_dvp);
        !           371:        MARK_VNODE(ap->a_vp);
        !           372:        ret = ufs_remove(ap);
        !           373:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           374:        return (ret);
        !           375: }
        !           376: 
        !           377: int
        !           378: lfs_rmdir(ap)
        !           379:        struct vop_rmdir_args /* {
        !           380:                struct vnodeop_desc *a_desc;
        !           381:                struct vnode *a_dvp;
        !           382:                struct vnode *a_vp;
        !           383:                struct componentname *a_cnp;
        !           384:        } */ *ap;
        !           385: {
        !           386:        int ret;
        !           387: 
        !           388:        SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
        !           389:        MARK_VNODE(ap->a_dvp);
        !           390:        MARK_VNODE(ap->a_vp);
        !           391:        ret = ufs_rmdir(ap);
        !           392:        SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
        !           393:        return (ret);
        !           394: }
        !           395: 
        !           396: int
        !           397: lfs_link(ap)
        !           398:        struct vop_link_args /* {
        !           399:                struct vnode *a_vp;
        !           400:                struct vnode *a_tdvp;
        !           401:                struct componentname *a_cnp;
        !           402:        } */ *ap;
        !           403: {
        !           404:        int ret;
        !           405: 
        !           406:        SET_DIROP(VTOI(ap->a_vp)->i_lfs);
        !           407:        MARK_VNODE(ap->a_vp);
        !           408:        ret = ufs_link(ap);
        !           409:        SET_ENDOP(VTOI(ap->a_vp)->i_lfs);
        !           410:        return (ret);
        !           411: }
        !           412: 
        !           413: int
        !           414: lfs_rename(ap)
        !           415:        struct vop_rename_args  /* {
        !           416:                struct vnode *a_fdvp;
        !           417:                struct vnode *a_fvp;
        !           418:                struct componentname *a_fcnp;
        !           419:                struct vnode *a_tdvp;
        !           420:                struct vnode *a_tvp;
        !           421:                struct componentname *a_tcnp;
        !           422:        } */ *ap;
        !           423: {
        !           424:        int ret;
        !           425: 
        !           426:        SET_DIROP(VTOI(ap->a_fdvp)->i_lfs);
        !           427:        MARK_VNODE(ap->a_fdvp);
        !           428:        MARK_VNODE(ap->a_tdvp);
        !           429:        ret = ufs_rename(ap);
        !           430:        SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
        !           431:        return (ret);
        !           432: }
        !           433: /* XXX hack to avoid calling ITIMES in getattr */
        !           434: int
        !           435: lfs_getattr(ap)
        !           436:        struct vop_getattr_args /* {
        !           437:                struct vnode *a_vp;
        !           438:                struct vattr *a_vap;
        !           439:                struct ucred *a_cred;
        !           440:                struct proc *a_p;
        !           441:        } */ *ap;
        !           442: {
        !           443:        register struct vnode *vp = ap->a_vp;
        !           444:        register struct inode *ip = VTOI(vp);
        !           445:        register struct vattr *vap = ap->a_vap;
        !           446:        /*
        !           447:         * Copy from inode table
        !           448:         */
        !           449:        vap->va_fsid = ip->i_dev;
        !           450:        vap->va_fileid = ip->i_number;
        !           451:        vap->va_mode = ip->i_mode & ~IFMT;
        !           452:        vap->va_nlink = ip->i_nlink;
        !           453:        vap->va_uid = ip->i_uid;
        !           454:        vap->va_gid = ip->i_gid;
        !           455:        vap->va_rdev = (dev_t)ip->i_rdev;
        !           456:        vap->va_size = ip->i_din.di_size;
        !           457:        vap->va_atime = ip->i_atime;
        !           458:        vap->va_mtime = ip->i_mtime;
        !           459:        vap->va_ctime = ip->i_ctime;
        !           460:        vap->va_flags = ip->i_flags;
        !           461:        vap->va_gen = ip->i_gen;
        !           462:        /* this doesn't belong here */
        !           463:        if (vp->v_type == VBLK)
        !           464:                vap->va_blocksize = BLKDEV_IOSIZE;
        !           465:        else if (vp->v_type == VCHR)
        !           466:                vap->va_blocksize = MAXPHYSIO;
        !           467:        else
        !           468:                vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
        !           469:        vap->va_bytes = dbtob(ip->i_blocks);
        !           470:        vap->va_type = vp->v_type;
        !           471:        vap->va_filerev = ip->i_modrev;
        !           472:        return (0);
        !           473: }
        !           474: /*
        !           475:  * Close called
        !           476:  *
        !           477:  * XXX -- we were using ufs_close, but since it updates the
        !           478:  * times on the inode, we might need to bump the uinodes
        !           479:  * count.
        !           480:  */
        !           481: /* ARGSUSED */
        !           482: int
        !           483: lfs_close(ap)
        !           484:        struct vop_close_args /* {
        !           485:                struct vnode *a_vp;
        !           486:                int  a_fflag;
        !           487:                struct ucred *a_cred;
        !           488:                struct proc *a_p;
        !           489:        } */ *ap;
        !           490: {
        !           491:        register struct vnode *vp = ap->a_vp;
        !           492:        register struct inode *ip = VTOI(vp);
        !           493:        int mod;
        !           494: 
        !           495:        if (vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) {
        !           496:                mod = ip->i_flag & IN_MODIFIED;
        !           497:                ITIMES(ip, &time, &time);
        !           498:                if (!mod && ip->i_flag & IN_MODIFIED)
        !           499:                        ip->i_lfs->lfs_uinodes++;
        !           500:        }
        !           501:        return (0);
        !           502: }
        !           503: 
        !           504: /*
        !           505:  * Stub inactive routine that avoid calling ufs_inactive in some cases.
        !           506:  */
        !           507: int lfs_no_inactive = 0;
        !           508: 
        !           509: int
        !           510: lfs_inactive(ap)
        !           511:        struct vop_inactive_args /* {
        !           512:                struct vnode *a_vp;
        !           513:        } */ *ap;
        !           514: {
        !           515:        
        !           516:        if (lfs_no_inactive)
        !           517:                return (0);
        !           518:        return (ufs_inactive(ap));
        !           519: }
        !           520: 
        !           521: /*
        !           522:  * Reclaim an inode so that it can be used for other purposes.
        !           523:  */
        !           524: int
        !           525: lfs_reclaim(ap)
        !           526:        struct vop_reclaim_args /* {
        !           527:                struct vnode *a_vp;
        !           528:        } */ *ap;
        !           529: {
        !           530:        register struct vnode *vp = ap->a_vp;
        !           531:        int error;
        !           532: 
        !           533:        if (error = ufs_reclaim(vp))
        !           534:                return (error);
        !           535:        FREE(vp->v_data, M_LFSNODE);
        !           536:        vp->v_data = NULL;
        !           537:        return (0);
        !           538: }

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