root/ufs/ffs/ffs_vnops.c

DEFINITIONS

1. ffs_read
2. ffs_write
3. ffs_fsync
4. ffs_reclaim
5. ffsfifo_reclaim

    1 /*      $OpenBSD: ffs_vnops.c,v 1.45 2007/06/01 23:47:57 deraadt Exp $  */
    2 /*      $NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $    */
    4 /*
    5  * Copyright (c) 1982, 1986, 1989, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)ffs_vnops.c 8.10 (Berkeley) 8/10/94
   33  */
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/resourcevar.h>
   38 #include <sys/kernel.h>
   39 #include <sys/file.h>
   40 #include <sys/stat.h>
   41 #include <sys/buf.h>
   42 #include <sys/proc.h>
   43 #include <sys/conf.h>
   44 #include <sys/mount.h>
   45 #include <sys/vnode.h>
   46 #include <sys/malloc.h>
   47 #include <sys/signalvar.h>
   48 #include <sys/pool.h>
   49 #include <sys/event.h>
   51 #include <uvm/uvm_extern.h>
   53 #include <miscfs/specfs/specdev.h>
   54 #include <miscfs/fifofs/fifo.h>
   56 #include <ufs/ufs/quota.h>
   57 #include <ufs/ufs/inode.h>
   58 #include <ufs/ufs/dir.h>
   59 #include <ufs/ufs/ufs_extern.h>
   60 #include <ufs/ufs/ufsmount.h>
   62 #include <ufs/ffs/fs.h>
   63 #include <ufs/ffs/ffs_extern.h>
   65 /* Global vfs data structures for ufs. */
   66 int (**ffs_vnodeop_p)(void *);
   67 struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
   68         { &vop_default_desc, vn_default_error },
   69         { &vop_lookup_desc, ufs_lookup },               /* lookup */
   70         { &vop_create_desc, ufs_create },               /* create */
   71         { &vop_mknod_desc, ufs_mknod },                 /* mknod */
   72         { &vop_open_desc, ufs_open },                   /* open */
   73         { &vop_close_desc, ufs_close },                 /* close */
   74         { &vop_access_desc, ufs_access },               /* access */
   75         { &vop_getattr_desc, ufs_getattr },             /* getattr */
   76         { &vop_setattr_desc, ufs_setattr },             /* setattr */
   77         { &vop_read_desc, ffs_read },                   /* read */
   78         { &vop_write_desc, ffs_write },                 /* write */
   79         { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
   80         { &vop_poll_desc, ufs_poll },                   /* poll */
   81         { &vop_kqfilter_desc, ufs_kqfilter },           /* kqfilter */
   82         { &vop_revoke_desc, ufs_revoke },               /* revoke */
   83         { &vop_fsync_desc, ffs_fsync },                 /* fsync */
   84         { &vop_remove_desc, ufs_remove },               /* remove */
   85         { &vop_link_desc, ufs_link },                   /* link */
   86         { &vop_rename_desc, ufs_rename },               /* rename */
   87         { &vop_mkdir_desc, ufs_mkdir },                 /* mkdir */
   88         { &vop_rmdir_desc, ufs_rmdir },                 /* rmdir */
   89         { &vop_symlink_desc, ufs_symlink },             /* symlink */
   90         { &vop_readdir_desc, ufs_readdir },             /* readdir */
   91         { &vop_readlink_desc, ufs_readlink },           /* readlink */
   92         { &vop_abortop_desc, vop_generic_abortop },     /* abortop */
   93         { &vop_inactive_desc, ufs_inactive },           /* inactive */
   94         { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
   95         { &vop_lock_desc, ufs_lock },                   /* lock */
   96         { &vop_unlock_desc, ufs_unlock },               /* unlock */
   97         { &vop_bmap_desc, ufs_bmap },                   /* bmap */
   98         { &vop_strategy_desc, ufs_strategy },           /* strategy */
   99         { &vop_print_desc, ufs_print },                 /* print */
  100         { &vop_islocked_desc, ufs_islocked },           /* islocked */
  101         { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */
  102         { &vop_advlock_desc, ufs_advlock },             /* advlock */
  103         { &vop_reallocblks_desc, ffs_reallocblks },     /* reallocblks */
  104         { &vop_bwrite_desc, vop_generic_bwrite },
  105         { NULL, NULL }
  106 };
  108 struct vnodeopv_desc ffs_vnodeop_opv_desc =
  109         { &ffs_vnodeop_p, ffs_vnodeop_entries };
  111 int (**ffs_specop_p)(void *);
  112 struct vnodeopv_entry_desc ffs_specop_entries[] = {
  113         { &vop_default_desc, spec_vnoperate },
  114         { &vop_close_desc, ufsspec_close },             /* close */
  115         { &vop_access_desc, ufs_access },               /* access */
  116         { &vop_getattr_desc, ufs_getattr },             /* getattr */
  117         { &vop_setattr_desc, ufs_setattr },             /* setattr */
  118         { &vop_read_desc, ufsspec_read },               /* read */
  119         { &vop_write_desc, ufsspec_write },             /* write */
  120         { &vop_fsync_desc, ffs_fsync },                 /* fsync */
  121         { &vop_inactive_desc, ufs_inactive },           /* inactive */
  122         { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
  123         { &vop_lock_desc, ufs_lock },                   /* lock */
  124         { &vop_unlock_desc, ufs_unlock },               /* unlock */
  125         { &vop_print_desc, ufs_print },                 /* print */
  126         { &vop_islocked_desc, ufs_islocked },           /* islocked */
  127         { NULL, NULL }
  128 };
  130 struct vnodeopv_desc ffs_specop_opv_desc =
  131         { &ffs_specop_p, ffs_specop_entries };
  133 #ifdef FIFO
  134 int (**ffs_fifoop_p)(void *);
  135 struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
  136         { &vop_default_desc, fifo_vnoperate },
  137         { &vop_close_desc, ufsfifo_close },             /* close */
  138         { &vop_access_desc, ufs_access },               /* access */
  139         { &vop_getattr_desc, ufs_getattr },             /* getattr */
  140         { &vop_setattr_desc, ufs_setattr },             /* setattr */
  141         { &vop_read_desc, ufsfifo_read },               /* read */
  142         { &vop_write_desc, ufsfifo_write },             /* write */
  143         { &vop_fsync_desc, ffs_fsync },                 /* fsync */
  144         { &vop_inactive_desc, ufs_inactive },           /* inactive */
  145         { &vop_reclaim_desc, ffsfifo_reclaim },         /* reclaim */
  146         { &vop_lock_desc, ufs_lock },                   /* lock */
  147         { &vop_unlock_desc, ufs_unlock },               /* unlock */
  148         { &vop_print_desc, ufs_print },                 /* print */
  149         { &vop_islocked_desc, ufs_islocked },           /* islocked */
  150         { &vop_bwrite_desc, vop_generic_bwrite },
  151         { NULL, NULL }
  152 };
  154 struct vnodeopv_desc ffs_fifoop_opv_desc =
  155         { &ffs_fifoop_p, ffs_fifoop_entries };
  156 #endif /* FIFO */
  158 /*
  159  * Enabling cluster read/write operations.
  160  */
  161 int doclusterread = 1;
  162 int doclusterwrite = 1;
  164 /*
  165  * Vnode op for reading.
  166  */
  167 /* ARGSUSED */
  168 int
ffs_read(void *v)
  170 {
  171         struct vop_read_args *ap = v;
  172         struct vnode *vp;
  173         struct inode *ip;
  174         struct uio *uio;
  175         struct fs *fs;
  176         struct buf *bp;
daddr64_t lbn, nextlbn;
off_t bytesinfile;
  179         long size, xfersize, blkoffset;
mode_t mode;
  181         int error;
vp = ap->a_vp;
ip = VTOI(vp);
mode = DIP(ip, mode);
uio = ap->a_uio;
  188 #ifdef DIAGNOSTIC
  189         if (uio->uio_rw != UIO_READ)
panic("ffs_read: mode");
  192         if (vp->v_type == VLNK) {
  193                 if ((int)DIP(ip, size) < vp->v_mount->mnt_maxsymlinklen ||
  194                     (vp->v_mount->mnt_maxsymlinklen == 0 &&
DIP(ip, blocks) == 0))
panic("ffs_read: short symlink");
  197         } else if (vp->v_type != VREG && vp->v_type != VDIR)
panic("ffs_read: type %d", vp->v_type);
  199 #endif
fs = ip->i_fs;
  201         if ((u_int64_t)uio->uio_offset > fs->fs_maxfilesize)
  202                 return (EFBIG);
  204         if (uio->uio_resid == 0)
  205                 return (0);
  207         for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
  208                 if ((bytesinfile = DIP(ip, size) - uio->uio_offset) <= 0)
  209                         break;
lbn = lblkno(fs, uio->uio_offset);
nextlbn = lbn + 1;
size = fs->fs_bsize;    /* WAS blksize(fs, ip, lbn); */
blkoffset = blkoff(fs, uio->uio_offset);
xfersize = fs->fs_bsize - blkoffset;
  215                 if (uio->uio_resid < xfersize)
xfersize = uio->uio_resid;
  217                 if (bytesinfile < xfersize)
xfersize = bytesinfile;
  220                 if (lblktosize(fs, nextlbn) >= DIP(ip, size))
error = bread(vp, lbn, size, NOCRED, &bp);
  222                 else if (lbn - 1 == ip->i_ci.ci_lastr) {
error = bread_cluster(vp, lbn, size, &bp);
  224                 } else
error = bread(vp, lbn, size, NOCRED, &bp);
  227                 if (error)
  228                         break;
ip->i_ci.ci_lastr = lbn;
  231                 /*
  232                  * We should only get non-zero b_resid when an I/O error
  233                  * has occurred, which should cause us to break above.
  234                  * However, if the short read did not cause an error,
  235                  * then we want to ensure that we do not uiomove bad
  236                  * or uninitialized data.
  237                  */
size -= bp->b_resid;
  239                 if (size < xfersize) {
  240                         if (size == 0)
  241                                 break;
xfersize = size;
  243                 }
error = uiomove((char *)bp->b_data + blkoffset, (int)xfersize,
uio);
  246                 if (error)
  247                         break;
brelse(bp);
  249         }
  250         if (bp != NULL)
brelse(bp);
ip->i_flag |= IN_ACCESS;
  253         return (error);
  254 }
  256 /*
  257  * Vnode op for writing.
  258  */
  259 int
ffs_write(void *v)
  261 {
  262         struct vop_write_args *ap = v;
  263         struct vnode *vp;
  264         struct uio *uio;
  265         struct inode *ip;
  266         struct fs *fs;
  267         struct buf *bp;
  268         struct proc *p;
daddr_t lbn;
off_t osize;
  271         int blkoffset, error, extended, flags, ioflag, resid, size, xfersize;
extended = 0;
ioflag = ap->a_ioflag;
uio = ap->a_uio;
vp = ap->a_vp;
ip = VTOI(vp);
  279 #ifdef DIAGNOSTIC
  280         if (uio->uio_rw != UIO_WRITE)
panic("ffs_write: mode");
  282 #endif
  284         /*
  285          * If writing 0 bytes, succeed and do not change
  286          * update time or file offset (standards compliance)
  287          */
  288         if (uio->uio_resid == 0)
  289                 return (0);
  291         switch (vp->v_type) {
  292         case VREG:
  293                 if (ioflag & IO_APPEND)
uio->uio_offset = DIP(ip, size);
  295                 if ((DIP(ip, flags) & APPEND) && uio->uio_offset != DIP(ip, size))
  296                         return (EPERM);
  297                 /* FALLTHROUGH */
  298         case VLNK:
  299                 break;
  300         case VDIR:
  301                 if ((ioflag & IO_SYNC) == 0)
panic("ffs_write: nonsync dir write");
  303                 break;
  304         default:
panic("ffs_write: type");
  306         }
fs = ip->i_fs;
  309         if (uio->uio_offset < 0 ||
  310             (u_int64_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
  311                 return (EFBIG);
  312         /*
  313          * Maybe this should be above the vnode op call, but so long as
  314          * file servers have no limits, I don't think it matters.
  315          */
p = uio->uio_procp;
  317         if (vp->v_type == VREG && p && !(ioflag & IO_NOLIMIT) &&
uio->uio_offset + uio->uio_resid >
p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
psignal(p, SIGXFSZ);
  321                 return (EFBIG);
  322         }
resid = uio->uio_resid;
osize = DIP(ip, size);
flags = ioflag & IO_SYNC ? B_SYNC : 0;
  328         for (error = 0; uio->uio_resid > 0;) {
lbn = lblkno(fs, uio->uio_offset);
blkoffset = blkoff(fs, uio->uio_offset);
xfersize = fs->fs_bsize - blkoffset;
  332                 if (uio->uio_resid < xfersize)
xfersize = uio->uio_resid;
  334                 if (fs->fs_bsize > xfersize)
flags |= B_CLRBUF;
  336                 else
flags &= ~B_CLRBUF;
  339                 if ((error = UFS_BUF_ALLOC(ip, uio->uio_offset, xfersize,
ap->a_cred, flags, &bp)) != 0)
  341                         break;
  342                 if (uio->uio_offset + xfersize > DIP(ip, size)) {
DIP_ASSIGN(ip, size, uio->uio_offset + xfersize);
uvm_vnp_setsize(vp, DIP(ip, size));
extended = 1;
  346                 }
  347                 (void)uvm_vnp_uncache(vp);
size = blksize(fs, ip, lbn) - bp->b_resid;
  350                 if (size < xfersize)
xfersize = size;
error =
uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
  356                 if (error != 0)
bzero((char *)bp->b_data + blkoffset, xfersize);
  359                 if (ioflag & IO_SYNC)
  360                         (void)bwrite(bp);
  361                 else if (xfersize + blkoffset == fs->fs_bsize) {
  362                         if (doclusterwrite)
cluster_write(bp, &ip->i_ci, DIP(ip, size));
  364                         else
bawrite(bp);
  366                 } else
bdwrite(bp);
  369                 if (error || xfersize == 0)
  370                         break;
ip->i_flag |= IN_CHANGE | IN_UPDATE;
  372         }
  373         /*
  374          * If we successfully wrote any data, and we are not the superuser
  375          * we clear the setuid and setgid bits as a precaution against
  376          * tampering.
  377          */
  378         if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0)
DIP(ip, mode) &= ~(ISUID | ISGID);
  380         if (resid > uio->uio_resid)
VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
  382         if (error) {
  383                 if (ioflag & IO_UNIT) {
  384                         (void)UFS_TRUNCATE(ip, osize,
ioflag & IO_SYNC, ap->a_cred);
uio->uio_offset -= resid - uio->uio_resid;
uio->uio_resid = resid;
  388                 }
  389         } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) {
error = UFS_UPDATE(ip, MNT_WAIT);
  391         }
  392         return (error);
  393 }
  395 /*
  396  * Synch an open file.
  397  */
  398 /* ARGSUSED */
  399 int
ffs_fsync(void *v)
  401 {
  402         struct vop_fsync_args *ap = v;
  403         struct vnode *vp = ap->a_vp;
  404         struct buf *bp, *nbp;
  405         int s, error, passes, skipmeta;
  407         if (vp->v_type == VBLK &&
vp->v_specmountpoint != NULL &&
  409             (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
softdep_fsync_mountdev(vp, ap->a_waitfor);
  412         /*
  413          * Flush all dirty buffers associated with a vnode.
  414          */
passes = NIADDR + 1;
skipmeta = 0;
  417         if (ap->a_waitfor == MNT_WAIT)
skipmeta = 1;
s = splbio();
loop:
  421         for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp;
bp = LIST_NEXT(bp, b_vnbufs))
bp->b_flags &= ~B_SCANNED;
  424         for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
nbp = LIST_NEXT(bp, b_vnbufs);
  426                 /* 
  427                  * Reasons to skip this buffer: it has already been considered
  428                  * on this pass, this pass is the first time through on a
  429                  * synchronous flush request and the buffer being considered
  430                  * is metadata, the buffer has dependencies that will cause
  431                  * it to be redirtied and it has not already been deferred,
  432                  * or it is already being written.
  433                  */
  434                 if (bp->b_flags & (B_BUSY | B_SCANNED))
  435                         continue;
  436                 if ((bp->b_flags & B_DELWRI) == 0)
panic("ffs_fsync: not dirty");
  438                 if (skipmeta && bp->b_lblkno < 0)
  439                         continue;
  440                 if (ap->a_waitfor != MNT_WAIT &&
LIST_FIRST(&bp->b_dep) != NULL &&
  442                     (bp->b_flags & B_DEFERRED) == 0 &&
buf_countdeps(bp, 0, 1)) {
bp->b_flags |= B_DEFERRED;
  445                         continue;
  446                 }
bremfree(bp);
bp->b_flags |= B_BUSY | B_SCANNED;
splx(s);
  451                 /*
  452                  * On our final pass through, do all I/O synchronously
  453                  * so that we can find out if our flush is failing
  454                  * because of write errors.
  455                  */
  456                 if (passes > 0 || ap->a_waitfor != MNT_WAIT)
  457                         (void) bawrite(bp);
  458                 else if ((error = bwrite(bp)) != 0)
  459                         return (error);
s = splbio();
  461                 /*
  462                  * Since we may have slept during the I/O, we need
  463                  * to start from a known point.
  464                  */
nbp = LIST_FIRST(&vp->v_dirtyblkhd);
  466         }
  467         if (skipmeta) {
skipmeta = 0;
  469                 goto loop;
  470         }
  471         if (ap->a_waitfor == MNT_WAIT) {
vwaitforio(vp, 0, "ffs_fsync", 0);
  474                 /*
  475                  * Ensure that any filesystem metadata associated
  476                  * with the vnode has been written.
  477                  */
splx(s);
  479                 if ((error = softdep_sync_metadata(ap)) != 0)
  480                         return (error);
s = splbio();
  482                 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
  483                         /*
  484                          * Block devices associated with filesystems may
  485                          * have new I/O requests posted for them even if
  486                          * the vnode is locked, so no amount of trying will
  487                          * get them clean. Thus we give block devices a
  488                          * good effort, then just give up. For all other file
  489                          * types, go around and try again until it is clean.
  490                          */
  491                         if (passes > 0) {
passes -= 1;
  493                                 goto loop;
  494                         }
  495 #ifdef DIAGNOSTIC
  496                         if (vp->v_type != VBLK)
vprint("ffs_fsync: dirty", vp);
  498 #endif
  499                 }
  500         }
splx(s);
  502         return (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
  503 }
  505 /*
  506  * Reclaim an inode so that it can be used for other purposes.
  507  */
  508 int
ffs_reclaim(void *v)
  510 {
  511         struct vop_reclaim_args *ap = v;
  512         struct vnode *vp = ap->a_vp;
  513         struct inode *ip = VTOI(vp);
  514         int error;
  516         if ((error = ufs_reclaim(vp, ap->a_p)) != 0)
  517                 return (error);
  519         if (ip->i_din1 != NULL) {
  520 #ifdef FFS2
  521                 if (ip->i_ump->um_fstype == UM_UFS2)
pool_put(&ffs_dinode2_pool, ip->i_din2);
  523                 else
  524 #endif
pool_put(&ffs_dinode1_pool, ip->i_din1);
  526         }
pool_put(&ffs_ino_pool, ip);
vp->v_data = NULL;
  532         return (0);
  533 }
  535 #ifdef FIFO
  536 int
ffsfifo_reclaim(void *v)
  538 {
fifo_reclaim(v);
  540         return (ffs_reclaim(v));
  541 }
  542 #endif